mlFileListFilterPlugin.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
#pragma once
 
// Local includes
#include "mlFileListFilterPluginBase.h"
 
// Include muParse for the evaluation of numeric function strings.
#if defined _WIN32
//include as C-API only for windows case as the muParser API is written like that
extern "C"
{
  #include "muParserDLL.h"
}
#else
  #include "muParserDLL.h"
#endif
 
ML_START_NAMESPACE
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class MLFILE_LIST_TOOLS_EXPORT FileListFilterPlugin : public FileListFilterPluginBase
{
public:

  enum LabellingEnumModes {
    DoNotChangeLabel          = 0,       
    SetLabelIfExpressionMatches,         
    SetLabelIfExpressionDoesNotMatch,    
    SetLabelIfPassFlagIsTrue,            
    SetLabelIfPassFlagIsFalse,           
    SetLabelIfPassFlagIsSet,             
    SetLabelIfPassFlagIsCleared,         
    SetLabelIfPassFlagIsUnchanged,       
    UnsetLabelIfExpressionMatches,       
    UnsetLabelIfExpressionDoesNotMatch,  
 
    NumLabellingEnumModes                
  };

  enum ConfigurationAssignmentEnumModes {
    DoNotChangeConfig         = 0,       
    SetConfigIfExpressionMatches,        
    SetConfigIfExpressionDoesNotMatch,   
    SetConfigIfPassFlagIsTrue,           
    SetConfigIfPassFlagIsFalse,          
    SetConfigIfPassFlagIsSet,            
    SetConfigIfPassFlagIsCleared,        
    SetConfigIfPassFlagIsUnchanged,      
    UnsetConfigIfExpressionMatches,      
    UnsetConfigIfExpressionDoesNotMatch, 
 
    NumConfigurationAssignmentEnumModes  
  };

  enum ProcessingSettingsAssignmentEnumModes {
    DoNotChangeProcSettings   = 0,             
    SetProcSettingsIfExpressionMatches,        
    SetProcSettingsIfExpressionDoesNotMatch,   
    SetProcSettingsIfPassFlagIsTrue,           
    SetProcSettingsIfPassFlagIsFalse,          
    SetProcSettingsIfPassFlagIsSet,            
    SetProcSettingsIfPassFlagIsCleared,        
    SetProcSettingsIfPassFlagIsUnchanged,      
    UnsetProcSettingsIfExpressionMatches,      
    UnsetProcSettingsIfExpressionDoesNotMatch, 
 
    NumProcSettingsAssignmentEnumModes         
  };

  static const char * const LabellingEnumStrings[NumLabellingEnumModes];

  static const char * const ConfigurationAssignmentEnumStrings[NumConfigurationAssignmentEnumModes];

  static const char * const ProcessingSettingsAssignmentEnumStrings[NumProcSettingsAssignmentEnumModes];

  FileListFilterPlugin(int numIns=0, int numOuts=0);

  ~FileListFilterPlugin() override;

  virtual void filterFile(FileListTools::FileAttribute &filterAttributes,
                          FilterMessageList *messageList) const override;

  inline BoolField   &getClearPassFlagBeforeFilteringFld              () const { return *_clearPassFlagBeforeFilteringFld           ; }
  inline StringField &getVolumeLabelFld                               () const { return *_volumeLabelFld                            ; }
  inline StringField &getVolumeConfigFld                              () const { return *_volumeConfigFld                           ; }
  inline StringField &getProcessingSettingsFld                        () const { return *_processingSettingsFld                     ; }
  inline EnumField   &getLabelAssignModeFld                           () const { return *_labelAssignModeFld                        ; }
  inline EnumField   &getConfigAssignModeFld                          () const { return *_configAssignModeFld                       ; }
  inline EnumField   &getProcessingSettingsAssignModeFld              () const { return *_processingSettingsAssignModeFld           ; }
  inline BoolField   &getAllowRecursiveTagSearchFld                   () const { return *_allowRecursiveTagSearchFld                ; }
  inline BoolField   &getApplyFilePathFilterFld                       () const { return *_applyFilePathFilterFld                    ; }
  inline StringField &getPathFilterRegExFld                           () const { return *_pathFilterRegExFld                        ; }
  inline BoolField   &getInvertPathFilterRegExFld                     () const { return *_invertPathFilterRegExFld                  ; }
  inline BoolField   &getSetPassFlagOnPathMatchesFld                  () const { return *_setPassFlagOnPathMatchesFld               ; }
  inline BoolField   &getClearPassFlagOnPathMismatchesFld             () const { return *_clearPassFlagOnPathMismatchesFld          ; }
  inline StringField &getRegExStatusFld                               () const { return *_regExStatusFld                            ; }
  inline BoolField   &getApplyTagStringFilterFld                      () const { return *_applyTagStringFilterFld                   ; }
  inline StringField &getTagStringFilterTagIdFld                      () const { return *_tagStringFilterTagIdFld                   ; }
  inline IntField    &getTagStringFilterTagValueIndexFld              () const { return *_tagStringFilterTagValueIndexFld           ; }
  inline StringField &getTagStringFilterPrivateCreatorFld             () const { return *_tagStringFilterPrivateCreatorFld          ; }
  inline BoolField   &getCheckOnlyFirstRecursiveTagStringFld          () const { return *_checkOnlyFirstRecursiveTagStringFld       ; }
  inline StringField &getTagStringEvalRegExFld                        () const { return *_tagStringEvalRegExFld                     ; }
  inline BoolField   &getInvertTagStringEvalRegExFld                  () const { return *_invertTagStringEvalRegExFld               ; }
  inline BoolField   &getSetTagStrEvalPassFlagOnPathMatchesFld        () const { return *_setTagStrEvalPassFlagOnPathMatchesFld     ; }
  inline BoolField   &getClearTagStrEvalPassFlagOnPathMismatchesFld   () const { return *_clearTagStrEvalPassFlagOnPathMismatchesFld; }
  inline StringField &getTagFilterRegExStatusFld                      () const { return *_tagFilterRegExStatusFld                   ; }
  inline BoolField   &getApplyTagValueFilterFld                       () const { return *_applyTagValueFilterFld                    ; }
  inline StringField &getTreeFilterExFld                              () const { return *_treeFilterExFld                           ; }
  inline StringField &getTagId0Fld                                    () const { return *_tagId0Fld                                 ; }
  inline StringField &getTagId1Fld                                    () const { return *_tagId1Fld                                 ; }
  inline StringField &getTagId2Fld                                    () const { return *_tagId2Fld                                 ; }
  inline StringField &getTagId3Fld                                    () const { return *_tagId3Fld                                 ; }
  inline IntField    &getTagId0ValueIndexFld                          () const { return *_tagId0ValueIndexFld                       ; }
  inline IntField    &getTagId1ValueIndexFld                          () const { return *_tagId1ValueIndexFld                       ; }
  inline IntField    &getTagId2ValueIndexFld                          () const { return *_tagId2ValueIndexFld                       ; }
  inline IntField    &getTagId3ValueIndexFld                          () const { return *_tagId3ValueIndexFld                       ; }
  inline StringField &getTagId0PrivateCreatorFld                      () const { return *_tagId0PrivateCreatorFld                   ; }
  inline StringField &getTagId1PrivateCreatorFld                      () const { return *_tagId1PrivateCreatorFld                   ; }
  inline StringField &getTagId2PrivateCreatorFld                      () const { return *_tagId2PrivateCreatorFld                   ; }
  inline StringField &getTagId3PrivateCreatorFld                      () const { return *_tagId3PrivateCreatorFld                   ; }
  inline DoubleField &getConst0Fld                                    () const { return *_const0Fld                                 ; }
  inline DoubleField &getConst1Fld                                    () const { return *_const1Fld                                 ; }
  inline DoubleField &getConst2Fld                                    () const { return *_const2Fld                                 ; }
  inline DoubleField &getConst3Fld                                    () const { return *_const3Fld                                 ; }
  inline DoubleField &getRangeMinFld                                  () const { return *_rangeMinFld                               ; }
  inline DoubleField &getRangeMaxFld                                  () const { return *_rangeMaxFld                               ; }
  inline BoolField   &getSetPassFlagOnTagValueMatchesFld              () const { return *_setPassFlagOnTagValueMatchesFld           ; }
  inline BoolField   &getClearPassFlagOnTagValueMismatchesFld         () const { return *_clearPassFlagOnTagValueMismatchesFld      ; }
  inline StringField &getTreeFilterStatusFld                          () const { return *_treeFilterStatusFld                       ; }
  inline BoolField   &getAlwaysPassEnhancedMultiFrameFilesFld         () const { return *_alwaysPassEnhancedMultiFrameFilesFld      ; }
  inline BoolField   &getFilterDecomposedEnhancedFramesFld            () const { return *_filterDecomposedEnhancedFramesFld         ; }
  
protected:

  void activateAttachments() override;

  void handleNotification(Field *field) override;

  virtual bool _handleNotificationForPathStringFiltering(Field *field);

  virtual void _applyFilePathFiltering(FileListTools::FileAttribute &filterAttributes,
                                       FilterMessageList *messageList,
                                       bool &wasDisabled,
                                       bool &wasEnabled,
                                       bool &expMatches) const;

  virtual bool _handleNotificationForTagStringFiltering(Field *field);

  virtual void _applyTagStringFiltering(FileListTools::FileAttribute &filterAttributes,
                                        FilterMessageList *messageList,
                                        bool &wasDisabled,
                                        bool &wasEnabled,
                                        bool &expMatches,
                                        DCMTree::Const_TreePtr &dcmTree) const;

  void _updateFlagsAccordingToTagStringValues(const std::vector<std::string>& tagStringValues,
                                              bool& passFlag, 
                                              bool& wasDisabled, 
                                              bool& wasEnabled, 
                                              bool& expMatches) const;

  virtual bool _handleNotificationForTagValueFiltering(Field *field);

  virtual void _applyTagValueFiltering(FileListTools::FileAttribute &filterAttributes,
                                       FilterMessageList *messageList,
                                       bool &wasDisabled,
                                       bool &wasEnabled,
                                       bool &expMatches,
                                       DCMTree::Const_TreePtr dcmTree) const;

  virtual void _applyLabelling(FileListTools::FileAttribute &filterAttributes,
                               FilterMessageList *messageList,
                               bool &wasDisabled,
                               bool &wasEnabled,
                               bool &expMatches) const;

  virtual void _applyConfigAssignment(FileListTools::FileAttribute &filterAttributes,
                                      FilterMessageList *messageList,
                                      bool &wasDisabled,
                                      bool &wasEnabled,
                                      bool &expMatches) const;

  virtual void _applyProcessingSettingsAssignment(FileListTools::FileAttribute &filterAttributes,
                                                  FilterMessageList *messageList,
                                                  bool &wasDisabled,
                                                  bool &wasEnabled,
                                                  bool &expMatches) const;

  DCMTree::Const_TagPtr _searchOneOrMultipleTags(DCMTree::Const_TreePtr              dcmTree, 
                                                 DCMTree::RawTagId                   rawTagId,  
                                                 std::vector<DCMTree::Const_TagPtr>* foundTags) const;

  DCMTree::Const_TagPtr _getNormalOrPrivateTag(DCMTree::Const_TreePtr             dcmTree,
                                               DCMTree::RawTagId                  rawTagId,
                                               const std::string                  &privateCreatorStr,
                                               std::vector<DCMTree::Const_TagPtr> *foundTags=nullptr) const;

  void _getTagStringValues(DCMTree::Const_TreePtr    dcmTree,
                           std::vector<std::string> &foundValues) const;
 
  
  double _getTagValueForTagValueFilter(DCMTree::Const_TreePtr dcmTree, 
                                       MLint                  tagValueFilterId,
                                       const std::string      &privateCreatorString,
                                       MLint                  valueIndex) const;
                                      
private:
 
  //----------- General settings:
  BoolField   *_clearPassFlagBeforeFilteringFld;

  StringField *_volumeLabelFld;

  StringField *_volumeConfigFld;

  StringField *_processingSettingsFld;
  
  EnumField   *_labelAssignModeFld;

  EnumField   *_configAssignModeFld;

  EnumField   *_processingSettingsAssignModeFld;

  BoolField   *_allowRecursiveTagSearchFld;
  
  //----------- Path filtering:
  BoolField   *_applyFilePathFilterFld;

  StringField *_pathFilterRegExFld;

  BoolField   *_invertPathFilterRegExFld;

  BoolField   *_setPassFlagOnPathMatchesFld;

  BoolField   *_clearPassFlagOnPathMismatchesFld;

  StringField *_regExStatusFld;
 
 
  //----------- String tag filtering:
  BoolField   *_applyTagStringFilterFld;

  StringField *_tagStringFilterTagIdFld;

  IntField    *_tagStringFilterTagValueIndexFld;
  
  StringField *_tagStringFilterPrivateCreatorFld;

  BoolField   *_checkOnlyFirstRecursiveTagStringFld;

  StringField *_tagStringEvalRegExFld;

  BoolField   *_invertTagStringEvalRegExFld;

  BoolField   *_setTagStrEvalPassFlagOnPathMatchesFld;

  BoolField   *_clearTagStrEvalPassFlagOnPathMismatchesFld;

  StringField *_tagFilterRegExStatusFld;

  MLint        _strEvalTagId;
 
 
  //----------- Numeric Tag filtering:
  muParserHandle_t _parser;

  BoolField   *_applyTagValueFilterFld;

  StringField *_treeFilterExFld;

  StringField *_tagId0Fld;
  StringField *_tagId1Fld;
  StringField *_tagId2Fld;
  StringField *_tagId3Fld;

  IntField *_tagId0ValueIndexFld;
  IntField *_tagId1ValueIndexFld;
  IntField *_tagId2ValueIndexFld;
  IntField *_tagId3ValueIndexFld;

  StringField *_tagId0PrivateCreatorFld;
  StringField *_tagId1PrivateCreatorFld;
  StringField *_tagId2PrivateCreatorFld;
  StringField *_tagId3PrivateCreatorFld;
  
  MLint _tagValueFilterId0;
  MLint _tagValueFilterId1;
  MLint _tagValueFilterId2;
  MLint _tagValueFilterId3;

  DoubleField *_const0Fld;
  DoubleField *_const1Fld;
  DoubleField *_const2Fld;
  DoubleField *_const3Fld;

  DoubleField *_rangeMinFld;
  DoubleField *_rangeMaxFld;

  BoolField   *_setPassFlagOnTagValueMatchesFld;

  BoolField   *_clearPassFlagOnTagValueMismatchesFld;
 

  StringField *_treeFilterStatusFld;

  BoolField   *_alwaysPassEnhancedMultiFrameFilesFld=nullptr;

  BoolField   *_filterDecomposedEnhancedFramesFld=nullptr;

  ML_MODULE_CLASS_HEADER(FileListFilterPlugin);
};

typedef FileListFilterPlugin DirectDicomImportImportFilterPlugin; 
 
 
ML_END_NAMESPACE