CSOLiveWireProcessor.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
**
**************************************************************************************/
 
#ifndef CSOLIVE_WIRE_PROCESSOR_H
#define CSOLIVE_WIRE_PROCESSOR_H
 
 
 
#include "SoCSOSystem.h"
#include "CSOProcessor/CSOProcessor.h"
 
#include <mlFields.h>
#include <CSOTools/CSOLiveWireGraph.h>
 
 
ML_START_NAMESPACE
 
 
enum CSOLiveWireFinishingMode
{
  CSO_LIVE_WIRE_FINISH_ON_DOUBLE_CLICK = 0, 
  CSO_LIVE_WIRE_FINISH_ON_DISTANCE     = 1  
};
 
 
enum SliceErrorHandlingMode
{
  CSO_SLICE_ERROR_HANDLING_REMOVE_CSO            = 0, 
  CSO_SLICE_ERROR_HANDLING_REMOVE_LAST_SEEDPOINT = 1, 
  CSO_SLICE_ERROR_HANDLING_PRINT_WARNING         = 2  
};
 
 
class SOCSO_EXPORT CSOLiveWireProcessor : public CSOProcessor
{
 
public:
 
  CSOLiveWireProcessor();
 
  bool process(CSOEvalEventView2DInfos view2DInfos, CSOEvalEventCSOInfos csoInfos) override;
 
  bool needsMemoryImage() override;
 
  void setMemoryImage(float* imageData, int sizex, int sizey, int voxelPosZ,
                              const Matrix4& voxelToWorldMatrix, const Matrix4& worldToVoxelMatrix,
                              View2DSliceList* slicelist) override;
 
  bool isCurrentlyGenerating() override;
  bool isCurrentlyEditing() override;
  bool couldCloseCSO() override;
  void resetInteractionState() override;
  void triggerSetMouseCursor(SoView2D* view2d, bool shouldSetMouseCursor) override;
 
 
protected:
 
  ~CSOLiveWireProcessor() override;
  void activateAttachments() override;
  void handleNotification(Field* field) override;
 
private:
 
  /* FIELDS */
 
  PlaneField* _planeFld;
  IntField*   _currentSliceFld;
  IntField*   _currentLayoutFld;
  StringField* _currentLayoutStringFld;
  BoolField*  _useInputImageFld;
  BoolField*  _useInputImageCostsFld;
  TypedEnumField<CSOLiveWireFinishingMode>* _finishingModeFld;
  IntField* _draggingToleranceFld;
  BoolField* _useFinishingDistanceFld;
  FloatField* _finishingDistanceFld;
  BoolField* _generateClosedCSOFld;
  TypedEnumField<SliceErrorHandlingMode>* _multipleSliceCSOErrorHandlingModeFld;
  BoolField* _isCurrentlyGeneratingFld;
  TypedEnumField<CSOSmoothingModes>*  _smoothingModeFld;
  IntField* _smoothingAmountFld;
 
  TypedEnumField<CSOLiveWireNeighborhoodMode>* _neighborhoodModeFld;
 
  FloatField* _weightGradientFld;
  FloatField* _weightLaplacianFld;
  FloatField* _weightDirectionalFld;
 
  /* MEMBER VARIABLES */
 
  CSOLiveWireGraph* _liveWireGraph;
 
  CSOList* _csoList;
 
  float _currentHitXPos;
  float _currentHitYPos;
  float _currentHitZPos;
  float _lastRecentHitXPos;
  float _lastRecentHitYPos;
  float _lastRecentHitZPos;
  float _startHitXPos;
  float _startHitYPos;
  float _startHitZPos;
 
  int _timePoint;
 
  CSO* _currentlyActiveCSO;
  CSOSeedPoint* _currentlyActiveSeedPoint;
  CSOPathPoints* _currentlyActivePathPoints;
 
  std::vector<Vector3>_draggedPositions;
 
  View2DSliceList* _slicelist;
 
  SoView2D* _lastCurrentView2D;
 
  int _lastCurrentZ;
 
  bool _isMovingSeedPoint;
  bool _isGeneratingCSO;
  bool _isDrawingInMotion;
  bool _couldCloseCurrentCSO;
 
  bool _bUseInputImage;
 
  bool _bUseInputCosts;
 
  float* _imageSlice;
  unsigned int _imageSizeX;
  unsigned int _imageSizeY;
 
  float* _view2DImg;
 
  TSubImage<float>  _inOptionalImg;
  bool            _optionalImgIsValid;
  PagedImage* _pImg;
 
  SbVec3f _sliceNormal0;
  SbVec3f _sliceNormal1;
  SbVec3f _sliceNormal2;
 
 
  /* METHODS */
 
  void _removeSeedPointFromMiddle();
 
  CSO* _addAndInitCSO();
  void _interpolate(CSO* cso, CSOPathPoints* pPoints);
  void _setInputImageSlice();
  bool _couldCloseByDistance(const Vector3& currPos, View2DSliceList* slicelist);
  bool _isInsideImage(VoxelPos pos);
  void _findLiveWirePathsAroundActiveSeedPoint(const Vector3& currentHitPoint);
  void _transformWorldToVoxel(const Vector3& worldPos, Vector3& voxelPos);
  void _transformVoxelToWorld(const Vector3& voxelPos, Vector3& worldPos);
  void _fillPoints(CSOPathPoints* pathPoints, const std::vector<VoxelPos>& positions);
  bool _isWithinRangeDistance(const Vector3& startPos, const Vector3& endPos, float rangeDistance, View2DSliceList* slicelist) const;
 
  ML_MODULE_CLASS_HEADER(CSOLiveWireProcessor);
};
 
 
 
ML_END_NAMESPACE
 
 
#endif //__CSOLiveWireProcessor_H