SoView2DCSOExtensibleEditor.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2012, 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 <SoView2DExtension.h>
#include <SoView2DCSOEditor/SoView2DCSOExtensibleEditor/SoCSOEditorExtension.h>
#include <SoView2DCSOEditor/SoView2DCSOExtensibleEditor/extensions/SoCSODefaultRenderer/SoCSODefaultRenderer.h>
 
#include <Inventor/misc/SoRef.h>
 
#include <mlMatrix4.h>
#include <deque>
 
typedef std::vector<SoRef<SoCSOEditorExtension> > ExtensionList;
 
ML_START_NAMESPACE
class CSO;
class CSOList;
ML_END_NAMESPACE
 
class SoCSOTransform;
 
 
class CSOCreateAction;
class CSOBulgeAction;
class CSOSelectAndMoveAction;
class CSOLabelMoveAction;
class CSOLabelResizeAction;
class CSOTransformAction;
class CSOInsertSeedPointIntoPathPointListAction;
 
class CSOCopyCommandAction;
class CSOCutCommandAction;
class CSOPasteCommandAction;
 
class CSODeleteSeedPointCommandAction;
class CSODeleteCSOCommandAction;
 
class CSOUndoCommandAction;
class CSORedoCommandAction;
 
class CSOCancelCommandAction;
 
class CSORemoveAllCommandAction;
 
ML_START_NAMESPACE
class CSOVisualizationSettings;
ML_END_NAMESPACE
 
enum RenderPasses
{
  MainRenderPass,
  SecondRenderPass,
  OverlayPass,
  NumRenderPasses
};
 
 
class SOCSO_EXPORT SoView2DCSOExtensibleEditor : public SoView2DExtension
{
public:
 
  SoView2DCSOExtensibleEditor();
  static void initClass();
 
  SoSFMLBase inCSOList;
  SoSFNode inExtensions;
  SoSFMLBase inVisualizationSettings;
  SoSFMLBase inTransformationProvider;
  SoSFString creatorExtensionId;
  SoSFBool interactOnlyWithSelectedCSO;
  SoSFBool alwaysCreateNewCSOs;
  SoSFBool alwaysModifyExistingCSOs;
  SoSFBool keyCommandsEnabled;
  SoSFBool enableRemoveAll;
  SoSFBool renderLeftOverCSOsWithDefaultRenderer;
  SoSFBool allowSelectionWithDefaultRenderer;
  SoSFEnum renderCSOsOnImagesDependingOnCreationMode;
  SoSFBool updateCSOIdUnderMouseCursor;
  SoSFInt32 csoIdUnderMouseCursor;
  SoSFBool isCreatingNewCSO;
  SoSFBool isEditingExistingCSO;
  SoSFBool accumulateTransformations;
  SoSFTrigger cancelGeneration;
  SoSFBool updateImageStatisticsOnFinishInteraction;
 
  void getExtensions(ExtensionList& extensions);
  ml::CSOList* getInputCSOList();
  std::string getDefaultCreatorString() const { return std::string("__default"); }
 
  void pointerLeftWindow() override;
  void pointerPosition(const SoPointerPosition& pos) override;
 
  ml::CSOVisualizationSettings* getVisualizationSettings();
 
  SoCSOEditorExtension* getActiveEditor() const;
  void setActiveEditor(SoCSOEditorExtension* editor, bool storeLastEditor = true);
  void resetLastActiveEditor();
  SoCSODefaultRenderer* getDefaultRenderer();
  void setInteractionModifier(int mode) { _interactionMode = mode; }
  int getInteractionModifier() const { return _interactionMode; }
 
  void setCSOUnderTheMouseId(int id);
 
  bool shouldShowCSOAtAll(ml::CSO* cso);
  bool shouldShowCSOForCurrentTimePoint(const CSODrawView2DInfos& view2DInfos, ml::CSO* cso);
  bool shouldShowCSORegardingParallelState(const CSODrawSliceInformation& sliceInfo, const CSODrawView2DInfos& view2DInfos, ml::CSO* cso);
  bool shouldShowCSOBeyondSlice(const CSODrawSliceInformation& sliceInfo, const CSODrawView2DInfos& view2DInfos, ml::CSO* cso);
  bool shouldShowCSOOnImageWithId(const CSODrawView2DInfos& view2DInfos, ml::CSO* cso);
  bool shouldShowCSOOnViewerWithId(const CSODrawView2DInfos& view2DInfos, ml::CSO* cso);
  bool hasRegistrationInformation(const SoPointerPosition& pos, ml::CSO* cso);
  ml::AbstractTransformationPtr getRegistrationInformation(const SoPointerPosition& pos, ml::CSO* cso);
  ml::CoordinateSystemReference getCoordinateSystemReference(ml::CSO* cso);
  ml::CoordinateSystemReference getCoordinateSystemReference(SoView2D* viewer);
  ml::CoordinateSystemReference getCoordinateSystemReference(const CSODrawView2DInfos& view2DInfos);
  ml::CoordinateSystemReference getCoordinateSystemReference(const SoPointerPosition& pos);
  bool hasTransformationProvider() const { return _transformationProvider != nullptr; }
  ml::AbstractTransformationPtr getTransformation(const ml::CoordinateSystemReference& from, const ml::CoordinateSystemReference& to);
  bool isSameImage(const ml::CoordinateSystemReference& from, const ml::CoordinateSystemReference& to);
 
  void transformCSO(ml::CSO* cso, const ml::AbstractTransformationPtr& transformation);
 
  void fillCSOSliceInformation(const CSODrawCSOInfos& csoInfos, const CSODrawView2DInfos& view2DInfos, CSODrawSliceInformation& sliceInfo, const ml::Matrix4& worldToVoxelMatrix, const CSOVoxelSlab& csoSlab);
 
  void startEditingCSO(const SoPointerPosition& pos, ml::CSO* cso);
  void stopEditingCSO();
 
  enum CSORenderOnImagesDependingOnCreationModes
  {
    ON_ALL_IMAGES = 0,                            
    ONLY_ON_IMAGES_THEY_WERE_CREATED_ON = 1,      
    ONLY_ON_IMAGES_THEY_WERE_NOT_CREATED_ON = 2,  
    ONLY_ON_IMAGES_THEY_CAN_BE_TRANSFORMED_TO = 3 
  };
 
  void toggleCancelCommandIsActiveForModifications(bool isActive);
 
  bool isSelectionAllowedWithDefaultRenderer() const { return allowSelectionWithDefaultRenderer.getValue(); }
 
  void setCreateActionTrigger(const SoPointingAction::Trigger& trigger);
 
  void setCreateActionTriggerToDefault();
 
  void cancel();
 
protected:
 
  ~SoView2DCSOExtensibleEditor() override;
 
  void startDrawing(View2DSliceList* slicelist) override;
 
  void draw(View2DSliceList* slicelist, View2DSlice* slice, int sliceZ) override;
 
  bool evalEvent(SoView2D* view2d, View2DSliceList* slicelist, View2DEvent* ec, View2DEventPhase phase) override;
 
  void notifyEditorsOfMouseWheelEvent(SoMouseWheelEvent::Orientation orientation, int turn, View2DEvent* ec);
 
  static void csoListNotificationCB(void* userData, int notificationFlag);
 
  void editingOnChanged(SoField*) override;
  void buttonMaskChanged(SoField*) override;
 
  void extensionChanged(SoField*);
  void interactOnlyWithSelectedCSOChanged(SoField*);
  void inTransformationProviderChanged(SoField*);
  void cancelGenerationChanged(SoField*);
  void isCreatingOrEditingChanged(SoField*);
 
  void doAction(SoAction *action) override;
  std::vector<SoCSOTransform*> _csoTransforms;
 
private:
  using SoView2DExtension::pointerLeftWindow;
  using SoView2DExtension::pointerPosition;
 
  ml::CSOVisualizationSettings _dummyVisualizationSettings;
  SoRef<SoCSODefaultRenderer> _defaultRenderer;
 
  bool _activeCreatorEditorDirty;
 
  void _inCSOListCB(SoField*);
 
  SbVec3f _currentPointerWorldPosition;
  SbVec3f _startPointerWorldPosition;
  int     _currentTimePointIndex;
 
  void storeCopiedCSOGroupInformation();
 
  void setActiveEditor(const ExtensionList& extensions);
  void setActionsEnabled();
  void setKeyboardActionsEnabled();
  void setTriggerFieldsToActions();
 
  void toggleCancelCommandIsActive();
  void togglePasteCommandIsActive();
  void toggleCutCopyCommandIsActive();
  void toggleUndoCommandIsActive();
  void toggleRedoCommandIsActive();
  void toggleDeleteCSOCommandIsActive();
  void toggleDeleteSeedPointCommandIsActive();
  void toggleRemoveAllCommandIsActive();
 
  bool areKeyboardCommandsActive() { return isEditingOn() && keyCommandsEnabled.getValue(); }
 
  bool isInteracting();
 
  void copySelectedCSOs();
 
  void copySelectedCSOsToInternalList(ml::CSOList* csoList);
  void cutSelectedCSOs();
  void pasteCSOs();
 
  void deleteSelectedCSOs();
  void deleteSelectedSeedPoint();
 
  void undo();
  void redo();
 
  void removeAllCSOsAndGroups();
 
  SbVec3f getMidPointSelectedCSOs();
 
  void getNonActiveEditorExtensionIds(std::vector <std::string>& nonActiveEditorExtensions);
 
  // Returns whether the given CSO should be rendered.
  bool shouldRenderCSO(ml::CSO* cso, const CSODrawView2DInfos& view2DInfos, const CSODrawSliceInformation& sliceInfo);
 
  void resetCreatingAndEditingFields();
  void resetAllExtensionCaches();
  void resetAllEditorsAndCaches();
 
  SoCSOEditorExtension* getExtensionForCSO(ml::CSO* cso);
  bool doesCSOTimePointMatchCurrentTimePoint(const CSODrawView2DInfos& view2DInfos, ml::CSO* cso);
 
  ml::TransformationProvider* _transformationProvider;
 
  // this is the editor active for creating new CSOs
  SoRef<SoCSOEditorExtension> _activeEditor;
  SoRef<SoCSOEditorExtension> _lastActiveEditor;
 
  CSOLabelResizeAction*   _labelResizeAction;
  CSOLabelMoveAction*     _labelMoveAction;
  CSOTransformAction*     _transformAction;
  CSOInsertSeedPointIntoPathPointListAction* _insertSeedPointAction;
  CSOSelectAndMoveAction* _selectAndMoveAction;
  CSOCreateAction*        _createAction;
  CSOBulgeAction*         _bulgeAction;
 
  int _interactionMode;
 
  CSOCopyCommandAction*  _copyCommandAction;
  CSOCutCommandAction*   _cutCommandAction;
  CSOPasteCommandAction* _pasteCommandAction;
 
  CSODeleteSeedPointCommandAction* _deleteSeedPointCommandAction;
  CSODeleteCSOCommandAction*       _deleteCSOCommandAction;
 
  CSOUndoCommandAction* _undoCommandAction;
  CSORedoCommandAction* _redoCommandAction;
 
  CSOCancelCommandAction* _cancelCommandAction;
 
  CSORemoveAllCommandAction* _removeAllCommandAction;
 
  std::vector < ml::CSO* >             _copiedCSOs;
  std::map < int, std::vector< int > > _copiedCSOGroupIds;
 
 
  unsigned int _prevWheelCode;
  int          _sumWheel;
 
  friend bool SoCSOEditorTools::evaluateHitPoint(const ml::Vector3& worldPosition, View2DSliceList* slicelist, ml::CSOList* csoList,
    const ml::CSOBoundingBox& slabBB, const std::string& subType, SoView2DCSOExtensibleEditor* editor,
    bool testSeedPoints,
    ml::CSO*& localHitCSO, ml::CSOSeedPoint*& localHitSeedPoint,
    ml::CSOPathPoints*& localHitPathPoints, float& distance);
 
  // Stores a list of voxel slabs for a given cso list
  // for given world matrix and cso change id.
  struct SlabCacheEntry
  {
    SlabCacheEntry()
    {
      csoList = nullptr;
      csoListGeometryChangeId = 0;
    }
    void clear()
    {
      csoList = nullptr;
      csoListGeometryChangeId = 0;
      csoSlabs.clear();
    }
 
    void*       csoList;
    MLuint64    csoListGeometryChangeId;
    ml::Matrix4 worldToVoxelMatrix;
    std::vector<CSOVoxelSlab> csoSlabs;
  };
 
  // Stores N cache entries.
  std::deque<SlabCacheEntry*> _csoSlabCache;
 
  const SlabCacheEntry& findOrCreateSlabCache(const ml::Matrix4& worldToVoxelMatrix, size_t matrixHashKey, ml::CSOList* list);
 
 
  void notifyCSOListObservers(ml::CSOList* csoList);
 
  // make the keyboard commands friends so they
  // can access private/protected methods.
  friend class CSOCopyCommandAction;
  friend class CSOCutCommandAction;
  friend class CSOPasteCommandAction;
 
  friend class CSODeleteSeedPointCommandAction;
  friend class CSODeleteCSOCommandAction;
 
  friend class CSOUndoCommandAction;
  friend class CSORedoCommandAction;
 
  friend class CSORemoveAllCommandAction;
 
  SO_NODE_HEADER(SoView2DCSOExtensibleEditor);
};