FeatureGenExtractTable.h

#ifndef _FTR_FEATURE_GEN_EXTRACT_TABLE_H_
#define _FTR_FEATURE_GEN_EXTRACT_TABLE_H_
#include "FeatureGenerator.h"
 
typedef enum
{
    SET,
    AGE_RANGE
} Rule_Type;
 
class KeyRule : public SerializableObject {
private:
    float parsed_min_range;
    float parsed_max_range;
    vector<char> lut; //lut for the specific rule
 
    void parse_rule();
public:
    string rep_signal; 
    //maybe in the future support more complex rule to accept feature_generator init to generate feature and than
    // use the _generate of this feature on each sample to calculate the range - not for now!
    Rule_Type type; 
    string rule_value; 
 
    KeyRule() {};
 
    KeyRule(const string &signal, const string &type_str, const string &value);
 
    void init_lut(MedDictionarySections& dict);
 
    bool test_rule(float val) const;
 
    ADD_CLASS_NAME(KeyRule)
        ADD_SERIALIZATION_FUNCS(rep_signal, type, rule_value, parsed_min_range, parsed_max_range)
};
 
class MapRules : public SerializableObject {
public:
    vector<KeyRule> rules; 
    vector<float> values; 
 
    bool join(const vector<float> &join_vals) const;
 
    ADD_CLASS_NAME(MapRules)
        ADD_SERIALIZATION_FUNCS(rules, values)
};
 
class FeatureGenExtractTable : public FeatureGenerator {
private:
    vector<MapRules> key_rules; 
    vector<string> extracted_names; 
 
    void read_rule_table_files();
    int missing_values_cnt;
public:
    string rules_config_file; 
    string table_file; 
    bool reverse_rule_order; 
    string table_nice_name; 
    //object uses also req_signals, req_signals_ids - calculates from key_rules when set_signal_ids is called
 
    FeatureGenExtractTable() {
        generator_type = FTR_GEN_EXTRACT_TBL;
        missing_val = MED_MAT_MISSING_VALUE;
        missing_values_cnt = 0;
        table_nice_name = "";
        table_file = "";
        rules_config_file = "";
        reverse_rule_order = false;
    }
 
    void copy(FeatureGenerator *generator) { *this = *(dynamic_cast<FeatureGenExtractTable *>(generator)); }
 
    int init(map<string, string>& mapper);
 
    void set_signal_ids(MedSignals& sigs);
    void init_tables(MedDictionarySections& dict);
    void set_names();
 
    void prepare(MedFeatures &features, MedPidRepository& rep, MedSamples& samples);
 
    int _generate(PidDynamicRec& in_rep, MedFeatures& features, int index, int num, vector<float *> &_p_data);
 
    int filter_features(unordered_set<string>& validFeatures);
 
    void get_required_signal_categories(unordered_map<string, vector<string>> &signal_categories_in_use) const;
 
    void make_summary();
 
    ADD_CLASS_NAME(FeatureGenExtractTable)
        ADD_SERIALIZATION_FUNCS(generator_type, req_signals, names, missing_val, tags, iGenerateWeights, key_rules, extracted_names, table_nice_name)
};
 
MEDSERIALIZE_SUPPORT(KeyRule)
MEDSERIALIZE_SUPPORT(MapRules)
MEDSERIALIZE_SUPPORT(FeatureGenExtractTable)
 
#endif