WEMProcessor.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#include "WEMBase/WEM.h"
#include "WEMGenerator.h"
#include "WEMBase/WEMRequirements.h"
 
 
ML_START_NAMESPACE


class MLWEM_EXPORT WEMProcessor : public WEMGenerator
{
public:

  WEMProcessor(std::string type="WEMProcessor", bool useInput=true, int numInImages=0, int numOutImages=0, std::string inWEMFieldName="inWEM");
 
protected:

  ~WEMProcessor() override;
 
 
  /* FIELDS */
 
  BoolField* _workDirectlyOnInputWEMsFld;
  ProgressField* _progressFld;

  TypedEnumField<TriangulationModes>* _triangulationModeFld;
 
 
  /* STATE VARIABLES */

  WEM* _inWEM;
  bool _isInNotificationCB;

  bool _isNotifyingMyself;

  inline WEMRequirements* getRequirements() { return _requirements; }

  inline bool areEdgesRequired() { return _requirements->areEdgesRequired(); }
  inline bool isSinglePatchRequired() { return _requirements->isSinglePatchRequired(); }
  inline bool isPatchTypeRequired(PatchTypes patchType) { return _requirements->isPatchTypeRequired(patchType); }
  inline bool isOrientationTypeRequired(OrientationTypes orientationType) { return _requirements->isOrientationTypeRequired(orientationType); }

  inline void requireEdges(bool requireEdgesFlag=true) { _requirements->requireEdges(requireEdgesFlag); }
  inline void requireSinglePatch(bool requireSinglePatchFlag=true) { _requirements->requireSinglePatch(requireSinglePatchFlag); }
  inline void requirePatchType(PatchTypes patchType) { _requirements->requirePatchType(patchType); }
  inline void requireOrientationType(OrientationTypes orientationType) { _requirements->requireOrientationType(orientationType); }

  bool _forceCompatible;
 
 
  /* METHODS */

  void handleNotification(Field *field) override;
  void activateAttachments() override;
  void _process() override;

  virtual void _addWEMPatch(WEMPatch* wemPatch, bool mergeAllPatches=false);
  void _notifyObservers() override;

  static void _wemInputNotificationCB(void* userData, std::vector<WEMEventContainer> ecList);

  WEMPatch* _makeCompatible(WEMPatch* wemPatch);
  void _copyWEMPatch(WEMPatch *wemPatch);

  BaseField* _inputWEMFld;
 
private:
  void _addWEMPatch(ml::WEMPatch*) override {}
  /* FIELDS */

  BoolField* _listenToFinishNotificationsFld;
  BoolField* _listenToRepaintNotificationsFld;
  BoolField* _listenToSelectionChangedNotificationsFld;
 
  /* METHODS */

  void _warnAboutInvalidUpdateModeOrAutoApplyFieldConfiguration();

  void _setupOutputWEM();
  void _copyInputWEMToOutputWEMMakeCompatible();
  bool _doesMakeCompatibleCreateNew(WEMPatch* wemPatch);
 
  /* VARIABLES */

  WEMRequirements* _requirements;

  ML_CLASS_HEADER(WEMProcessor)
};

 
ML_END_NAMESPACE