MeVisLab/Standard/Sources/Inventor/SoView2D/SoOrthoView2DBase.h

Go to the documentation of this file.

#ifndef __SoOrthoView2DBase_H
#define __SoOrthoView2DBase_H
//----------------------------------------------------------------------------------
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------

#ifndef __SoView2DSystem_H
#include "SoView2DSystem.h"
#endif

#ifndef __mlAPI_H
#include "mlAPI.h"
#endif

#include <XVEnterScope.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoSFInt32.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFTrigger.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/fields/SoSFVec3f.h>
#include <Inventor/fields/SoSFVec2f.h>
#include <Inventor/fields/SoSFColor.h>
#include <Inventor/fields/SoSFString.h>
#include <Inventor/fields/SoSFPlane.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoSwitch.h>
#include <Inventor/nodes/SoSubNode.h>
#include <Inventor/SbViewportRegion.h>
#include <Inventor/sensors/SoFieldSensor.h>
#include <XVLeaveScope.h>

#ifndef __SoSFMLConnector_H
#include "SoSFMLConnector.h"
#endif

class SoView2D;
class SoSFMLImage;

//=============================================================

//=============================================================
class SOVIEW2D_API SoOrthoView2DBase : public SoSeparator {

   SO_NODE_HEADER(SoOrthoView2DBase);

 public:

   SoSFBool drawImageData;

   SoSFString viewerId1;
   SoSFString viewerId2;
   SoSFString viewerId3;

   SoSFEnum  blendMode;
   SoSFEnum  filterMode;
   SoSFEnum  cacheMode;
   SoSFInt32 slab;

   SoSFEnum  layoutMode;
   SoSFVec3f worldPosition;
   SoSFBool  worldPosSticky;

   SoSFBool  snapToCenter;
   SoSFFloat sliceZoom;

   SoSFVec2f sliceOrigin1;

   SoSFVec2f sliceOrigin2;

   SoSFVec2f sliceOrigin3;

   SoSFBool  synchronizePanning;

   SoSFBool  keepSlicesInView;

   SoSFVec3f viewingCenter;

   SoSFVec3f viewingCenter1;

   SoSFVec3f viewingCenter2;

   SoSFVec3f viewingCenter3;

   SoSFBool  invertKeyPanningDirections;

   SoSFTrigger unzoom;

   SoSFBool  synchronizeZoom;

   SoSFFloat alphaFactor;
   SoSFColor baseColor;

   SoSFBool  extraViewSpace;
   SoSFVec2f extraViewLowerLeft;
   SoSFVec2f extraViewUpperRight;
   SoSFVec2f extraViewSize;

   SoSFInt32 timePoint;
   SoSFInt32 maxTimePoint;

  SoSFVec2f margin;

  SoSFBool  alternCubeLayout;

   SoSFTrigger deleteSelected;
   SoSFTrigger edit;


  SoSFBool useManagedInteraction;

  SoSFEnum    zoomMode;

  SoSFFloat   zoomModeParameter;

  SoSFFloat minSliceZoomKeyboard;

  SoSFInt32 sliceStep1;
  SoSFInt32 sliceStep2;
  SoSFInt32 sliceStep3;
  SoSFInt32 numSlices1;
  SoSFInt32 numSlices2;
  SoSFInt32 numSlices3;
  SoSFInt32 numXSlices1;
  SoSFInt32 numXSlices2;
  SoSFInt32 numXSlices3;


  SoSFPlane plane1;
  SoSFPlane plane2;
  SoSFPlane plane3;

  SoSFBool  synchronizeFilterMode;


  SoSFTrigger startCine;
  SoSFTrigger stopCine;
  SoSFInt32   cineCenterT;
  SoSFInt32   cineIntervalT;
  SoSFEnum    cineDirection;
  SoSFEnum    cineRepeat;
  SoSFFloat   cineSpeed;
  SoSFBool    cineFullRangeT;
  SoSFBool    cineAlwaysReset;



  SoSFString  status;

  SoSFString  seriesInstanceUID;


   static void    initClass();

 protected:

    SoOrthoView2DBase();

    virtual ~SoOrthoView2DBase();

    virtual mlField* getMLImageField(int /*viewerIndex*/) { return NULL; }

    virtual bool isViewerVisible(int viewerIndex) const;

    static void positionChangedCB(void *data, SoSensor* a);
    void        positionChanged();

    static void sliceChangedCB(void *data, SoSensor* a);
    void        sliceChanged(SoSensor *sensor);

    static void sliceZoomChangedCB(void *data, SoSensor* a);
    static void sliceZoomChanged1CB(void *data, SoSensor* a);
    static void sliceZoomChanged2CB(void *data, SoSensor* a);
    static void sliceZoomChanged3CB(void *data, SoSensor* a);
    void        sliceZoomChanged(int which);

    static void sliceOriginChanged1CB(void *data, SoSensor* a);
    static void sliceOriginChanged2CB(void *data, SoSensor* a);
    static void sliceOriginChanged3CB(void *data, SoSensor* a);

    void resetPanning();
    static void synchronizePanningChangedCB(void *data, SoSensor* a);
    static void viewingCenterChangedCB(void *data, SoSensor* a);
    static void viewingCenterChanged1CB(void *data, SoSensor* a);
    static void viewingCenterChanged2CB(void *data, SoSensor* a);
    static void viewingCenterChanged3CB(void *data, SoSensor* a);
    void viewingCenterChanged(int which);

    void setSliceViewingCenterFor(int which, const SbVec3f& center);


    static void maxTimePointChangedCB(void *data, SoSensor* a);
    void maxTimePointChanged();

    static void timeChangedCB(void *data, SoSensor* a);
    void        timeChanged();

    static void marginChangedCB(void *data, SoSensor* a);
    void        marginChanged();

    static void zoomModeChangedCB(void *data, SoSensor* a);
    void        zoomModeChanged();
    static void zoomModeParameterChangedCB(void *data, SoSensor* a);
    void        zoomModeParameterChanged();

    static void plane1ChangedCB(void *data, SoSensor* a);
    void        plane1Changed();
    static void plane2ChangedCB(void *data, SoSensor* a);
    void        plane2Changed();
    static void plane3ChangedCB(void *data, SoSensor* a);
    void        plane3Changed();

    static void filterMode1ChangedCB(void *data, SoSensor* a);
    void        filterMode1Changed();
    static void filterMode2ChangedCB(void *data, SoSensor* a);
    void        filterMode2Changed();
    static void filterMode3ChangedCB(void *data, SoSensor* a);
    void        filterMode3Changed();

    static void startCineModeCB(void *data, SoSensor* a);
    void        startCineMode();
    static void stopCineModeCB(void *data, SoSensor* a);
    void        stopCineMode();

    static void seriesInstanceUIDChangedCB(void *data, SoSensor* a);
    void        seriesInstanceUIDChanged();

    static int sliceInitCB (const SoView2D *view2D, SoSFMLImage *image, void *user);
    int sliceInit (const SoView2D *view2D, SoSFMLImage *image);

    static void  updateLayoutCB(void *data, SoSensor* a);
    void updateLayout();

    void  connectFieldsTo(SoView2D* view);

    void  updateTimePoints();

    SoSwitch* _switch1;

    SoView2D* _view[3];

    SoView2D* _lastConnectedView;

    int _timePoint[3];

    int _cineMaster;

    SoFieldSensor* _posSensor;
    SoFieldSensor* _sliceSensor1;
    SoFieldSensor* _sliceSensor2;
    SoFieldSensor* _sliceSensor3;

    SoFieldSensor* _zoomSensor;
    SoFieldSensor* _zoomSensor1;
    SoFieldSensor* _zoomSensor2;
    SoFieldSensor* _zoomSensor3;

    SoFieldSensor* _sliceOriginSensor1;
    SoFieldSensor* _sliceOriginSensor2;
    SoFieldSensor* _sliceOriginSensor3;

    SoFieldSensor* _synchronizePanningSensor;
    SoFieldSensor* _viewingCenterSensor;
    SoFieldSensor* _viewingCenterSensor1;
    SoFieldSensor* _viewingCenterSensor2;
    SoFieldSensor* _viewingCenterSensor3;

    SoFieldSensor* _layoutSensor;
    SoFieldSensor* _maxTimePointSensor1;
    SoFieldSensor* _maxTimePointSensor2;
    SoFieldSensor* _maxTimePointSensor3;
    SoFieldSensor* _timeSensor1;
    SoFieldSensor* _timeSensor2;
    SoFieldSensor* _timeSensor3;

    SoFieldSensor* _marginSensor;
    SoFieldSensor* _alternCubeLayoutSensor;
    SoFieldSensor* _extraViewSizeSensor;

    SoFieldSensor* _zoomModeSensor;
    SoFieldSensor* _zoomModeParameterSensor;

    SoFieldSensor* _plane1Sensor;
    SoFieldSensor* _plane2Sensor;
    SoFieldSensor* _plane3Sensor;
    
    SoFieldSensor* _filterMode1Sensor;
    SoFieldSensor* _filterMode2Sensor;
    SoFieldSensor* _filterMode3Sensor;

    SoTimerSensor     *_cineTimerSensor;
    SoFieldSensor     *_startCineSensor;
    SoFieldSensor     *_stopCineSensor;

    SoFieldSensor     *_seriesInstanceUIDSensor;

    bool _inhibitViewingCenterSync;


};

#endif