RepBasicRangeCleaner Class Reference

Inheritance diagram for RepBasicRangeCleaner:

Public Member Functions
	RepBasicRangeCleaner ()
	default constructor
void	init_tables (MedDictionarySections &dict, MedSignals &sigs)
	initialize signal ids
void	register_virtual_section_name_id (MedDictionarySections &dict)
	Register section id to section name of new virtual signals.
bool	get_last_n_value (int time, const UniversalSigVec &range_sig, float &last_value)
virtual int	init (map< string, string > &mapper)
	Fill required- and affected-signals sets.
int	_apply (PidDynamicRec &rec, vector< int > &time_points, vector< vector< float > > &attributes_mat)
	Apply cleaning model.
void	fit_for_repository (MedPidRepository &rep)
	make changes to RepProcessor according to available signals in Repository
	ADD_SERIALIZATION_FUNCS (processor_type, signal_name, ranges_name, output_name, time_channel, req_signals, aff_signals, signal_id, ranges_id, output_id, virtual_signals, virtual_signals_generic, output_type, get_values_in_range, range_operator, range_val_channel, sets, range_time_channel, last_n, do_on_last_n, regex_on_sets) void print()
	Serialization.
Public Member Functions inherited from RepProcessor
virtual void	clear ()
virtual int	init (void *params)
	initialize from a params object : Should be implemented for inheriting classes that have parameters
virtual void	init_defaults ()
	initialize to default values : Should be implemented for inheriting classes that have parameters
virtual void	set_signal (const string &_signalName)
	set signal-name : Should be implemented for inheriting classes that have signalName
virtual void	set_signal_ids (MedSignals &sigs)
	set signal-ids : Should be implemented for inheriting classes that have signalId
virtual void	get_required_signal_names (unordered_set< string > &signalNames)
	Append required signal names to set : parent function just uses req_signals.
virtual void	get_required_signal_names (unordered_set< string > &signalNames, unordered_set< string > preReqSignals)
	Append required signal names to set only if processor is actually required to produce any of preReqSignals : parent function just uses req_signals.
virtual void	set_required_signal_ids (MedDictionarySections &dict)
	Fill req_signal_ids : parent function just fills from req_signals.
virtual void	add_virtual_signals (map< string, int > &_virtual_signals, map< string, string > &_virtual_signals_generic) const
	rep processors CREATING virtual signals need to implement this: adding their signals to the pile
virtual void	get_required_signal_ids (unordered_set< int > &signalIds)
	Append required signal names to set : parent function just uses req_signals.
virtual void	get_required_signal_ids (unordered_set< int > &signalIds, unordered_set< int > preReqSignals)
	Append required signal names to set only if processor is actually required to produce any of preReqSignals : parent function just uses req_signals.
virtual void	set_affected_signal_ids (MedDictionarySections &dict)
	Fill aff_signal_ids : parent function just fills from aff_signals.
bool	is_signal_affected (int signalId)
	Check if a signal is affected by processor </summray> Returns true if affected, false if not
bool	is_signal_affected (string &signalName)
virtual bool	filter (unordered_set< string > &reqSignals)
	Check if processor (and 'sub'-processors within) should be applied according to set of required signals </summray> Returns true if processor is not required and can be filtered, false otherwise
virtual void	init_attributes ()
	Init attributes information : Should be implemented for inheriting classes that have attributes.
virtual int	_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors)
	learn processing model on a subset of samples. Apply set of preceeding processors on DynamicPidRec before learning :
virtual int	_conditional_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of samples only if required. Apply set of preceeding processors on DynamicPidRec before learning :
int	learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors)
	learn processing model on a subset of ids. Apply set of preceeding processors on DynamicPidRec before learning
int	learn (MedPidRepository &rep)
	learn on all pids in repository, using fake samples - works only for repProcessors that ignore sample dates
int	learn (MedPidRepository &rep, MedSamples &samples)
	learn on subset of samples without preceesing processors
virtual int	conditional_learn (MedPidRepository &rep, MedSamples &samples, vector< RepProcessor * > &prev_processors, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of samples only if required. Apply set of preceeding processors on DynamicPidRec before learning :
int	conditional_learn (MedPidRepository &rep, MedSamples &samples, unordered_set< int > &neededSignalIds)
	learn processing model on a subset of ids only if required without preceesing processors
virtual int	_conditional_apply (PidDynamicRec &rec, vector< int > &time_points, unordered_set< int > &neededSignalIds, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points only if required : May be implemented for inheriting classes
virtual int	_apply_simple (PidDynamicRec &rec, vector< int > &time_points)
int	apply (PidDynamicRec &rec, vector< int > &time_points, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points
int	conditional_apply (PidDynamicRec &rec, vector< int > &time_points, unordered_set< int > &neededSignalIds, vector< vector< float > > &attributes_vals)
	apply processing on a single PidDynamicRec at a set of time-points only if required : if any of the signals in neededSignalIds is actually affected by processor
int	apply (PidDynamicRec &rec, MedIdSamples &samples)
	apply processing on a single PidDynamicRec at a set of time-points given by samples
int	conditional_apply (PidDynamicRec &rec, MedIdSamples &samples, unordered_set< int > &neededSignalIds)
	apply processing on a single PidDynamicRec at a set of time-points given by samples only if required
int	conditional_apply_without_attributes (PidDynamicRec &rec, const MedIdSamples &samples, unordered_set< int > &neededSignalIds)
	apply processing on a single PidDynamicRec at a set of time-points given by samples only if required, not affecting attributes
virtual void	dprint (const string &pref, int rp_flag)
	used for debug prints, each inheriting class can overload this one to get a more precise debug print.
virtual void	make_summary ()
virtual void	get_required_signal_categories (unordered_map< string, vector< string > > &signal_categories_in_use) const
	returns for each used signal it's used categories
void *	new_polymorphic (string derived_class_name)
	for polymorphic classes that want to be able to serialize/deserialize a pointer * to the derived class given its type one needs to implement this function to return a new to the derived class given its type (as in my_type)
size_t	get_processor_size ()
	get size of processor + processor_type
size_t	processor_serialize (unsigned char *blob)
	seialize processor + processor_type
virtual void	print ()
	optional printing of processor
Public Member Functions inherited from SerializableObject
virtual int	version () const
	Relevant for serializations.
virtual string	my_class_name () const
	For better handling of serializations it is highly recommended that each SerializableObject inheriting class will implement the next method.
virtual void	serialized_fields_name (vector< string > &field_names) const
	The names of the serialized fields.
virtual void	pre_serialization ()
virtual void	post_deserialization ()
virtual size_t	get_size ()
	Gets bytes sizes for serializations.
virtual size_t	serialize (unsigned char *blob)
	Serialiazing object to blob memory. return number ob bytes wrote to memory.
virtual size_t	deserialize (unsigned char *blob)
	Deserialiazing blob to object. returns number of bytes read.
size_t	serialize_vec (vector< unsigned char > &blob)
size_t	deserialize_vec (vector< unsigned char > &blob)
virtual size_t	serialize (vector< unsigned char > &blob)
virtual size_t	deserialize (vector< unsigned char > &blob)
virtual int	read_from_file (const string &fname)
	read and deserialize model
virtual int	write_to_file (const string &fname)
	serialize model and write to file
virtual int	read_from_file_unsafe (const string &fname)
	read and deserialize model without checking version number - unsafe read
int	init_from_string (string init_string)
	Init from string.
int	init_params_from_file (string init_file)
int	init_param_from_file (string file_str, string &param)
int	update_from_string (const string &init_string)
virtual int	update (map< string, string > &map)
	Virtual to update object from parsed fields.
virtual string	object_json () const

Data Fields
string	signal_name
	name of signal to clean
string	ranges_name
	name of signal that defines ranges
string	output_name
	name of output virtual signal - defaults to signal_name + "_" + ranges_name
int	signal_id
	id of signal to clean
int	ranges_id
	id of signal the defines ranges
int	output_id
	id of output signal
int	time_channel
	time channel to consider in cleaning in the original signal
int	range_time_channel
	range time channel to consider in cleaning. this time channel will be used to check we're not using the future in the range signal
int	output_type
	output signal type - should be identical to input signal type default to range + val type. Or string for generic type
int	get_values_in_range = 1
	if 1 (default) : keep only records time in range, if 0 : stay with the values out of range
range_op_type	range_operator = range_op_type::all
	options are all(default), first, last - which range to use in the reference signal
int	range_val_channel = -1
	the val channel in range signal to filter range signal. If < 0 or empty sets will not filter
vector< string >	sets
	sets use to filter ranges_name signal on range_val_channel. If empty or range_val_channel, no filters
bool	regex_on_sets = 0
	Whether to use aggregation of .*sets[i].* regex to create new sets vector (override original sets)
int	last_n = 0
	instead of looking on sets, take last value from range. 0 means current state, 1 one before, etc.j
bool	do_on_last_n = false
	if true, will use only last nth (using time channel 0) range signal backward from sample time and use this value to filter range. uses last_n value
Data Fields inherited from RepProcessor
RepProcessorTypes	processor_type = REP_PROCESS_LAST
	type of repository processor
unordered_set< string >	req_signals
	names of signals required for processsing
unordered_set< int >	req_signal_ids
	ids of signals required for processing
unordered_set< string >	aff_signals
	names of signals affected by processing
unordered_set< int >	aff_signal_ids
	ids of signals affected by processing
bool	unconditional = false
	indicated that processor should ALWAYS be applied
vector< string >	attributes
	attributes generated by the processor (optional)
vector< pair< string, int > >	virtual_signals
	virtual signals are created only in rep processors but can be used by any rep processor that comes after or any feture generator as a regular signal.
vector< pair< string, string > >	virtual_signals_generic

Additional Inherited Members
Static Public Member Functions inherited from RepProcessor
static RepProcessor *	make_processor (string name)
	create a new repository processor from name
static RepProcessor *	make_processor (string type, string params)
	create a new repository processor from name and a parameters string
static RepProcessor *	make_processor (RepProcessorTypes type)
	create a new repository processor from type
static RepProcessor *	make_processor (RepProcessorTypes type, string params)
	create a new repository processor from type and a parameters string
static RepProcessor *	create_processor (string &params)
	create a new repository processor from parameters string which contains rp_type

Member Function Documentation

_apply()

int RepBasicRangeCleaner::_apply ( PidDynamicRec &  rec, vector< int > &  time_points, vector< vector< float > > &  attributes_mat  )

virtual

Apply cleaning model.

Reimplemented from RepProcessor.

ADD_SERIALIZATION_FUNCS()

RepBasicRangeCleaner::ADD_SERIALIZATION_FUNCS	(	processor_type	,
		signal_name	,
		ranges_name	,
		output_name	,
		time_channel	,
		req_signals	,
		aff_signals	,
		signal_id	,
		ranges_id	,
		output_id	,
		virtual_signals	,
		virtual_signals_generic	,
		output_type	,
		get_values_in_range	,
		range_operator	,
		range_val_channel	,
		sets	,
		range_time_channel	,
		last_n	,
		do_on_last_n	,
		regex_on_sets
	)

Serialization.

Print processors information

fit_for_repository()

void RepBasicRangeCleaner::fit_for_repository ( MedPidRepository &  rep )

virtual

make changes to RepProcessor according to available signals in Repository

Reimplemented from RepProcessor.

init()

int RepBasicRangeCleaner::init ( map< string, string > &  mapper )

virtual

Fill required- and affected-signals sets.

The parsed fields from init command.

        if (field == "signal_name")
        {
            signal_name = entry.second;
        }
        else if (field == "rp_type")
        {
        }
        else if (field == "ranges_sig_name")
        {
            ranges_name = entry.second;
        }
        else if (field == "output_name")
        {
            output_name = entry.second;
        }
        else if (field == "time_channel")
            time_channel = med_stoi(entry.second);
        else if (field == "range_time_channel")
            range_time_channel = med_stoi(entry.second);
        else if (field == "get_values_in_range")
            get_values_in_range = med_stoi(entry.second);
        else if (field == "range_operator")
            range_operator = get_range_op(entry.second);
        else if (field == "range_val_channel")
            range_val_channel = med_stoi(entry.second);
        else if (field == "regex_on_sets")
            regex_on_sets = (bool)med_stoi(entry.second);
        else if (field == "last_n")
        {
            last_n = med_stoi(entry.second);
            do_on_last_n = true;
        }
        else if (field == "sets")
        {
            boost::split(sets, entry.second, boost::is_any_of(",;"));
        }
        else if (field == "output_type")
        {
            if (_is_numeric(entry.second))
                output_type = med_stoi(entry.second);
            else
                output_type_s = entry.second;
        } // needs to match the input signal type! defaults to range-value signal (3)
        else
            MTHROW_AND_ERR("Error in RepBasicRangeCleaner::init - Unsupported param \"%s\"\n", field.c_str());

[RepBasicRangeCleaner::init]

[RepBasicRangeCleaner::init]

Reimplemented from RepProcessor.

init_tables()

void RepBasicRangeCleaner::init_tables ( MedDictionarySections &  dict, MedSignals &  sigs  )

virtual

initialize signal ids

Reimplemented from RepProcessor.

register_virtual_section_name_id()

void RepBasicRangeCleaner::register_virtual_section_name_id ( MedDictionarySections &  dict )

virtual

Register section id to section name of new virtual signals.

Reimplemented from RepProcessor.

---

The documentation for this class was generated from the following files:

• Internal/MedProcessTools/MedProcessTools/RepProcess.h
• Internal/MedProcessTools/MedProcessTools/RepProcess.cpp