MeVisLab/Standard/Sources/Inventor/SoCSO/SoCSODefines.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

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

// Some definitions for the SoCSO project.

#ifndef __SoCSODefines_H
#define __SoCSODefines_H

#include <SoCSOIncludes.h>
#include <CSOBase/CSODefines.h>


ML_START_NAMESPACE
class StylePalette;
class CSOProcessorData;
class CSOVisualizationSettings;
ML_END_NAMESPACE

class SoCSOTransform;



struct CSOEvalEventView2DInfos 
{
  CSOEvalEventView2DInfos()
  {
    view2D = NULL;
    slicelist = NULL;
    ec = NULL;
    phase = EVENT_ANY;
  }
  SoView2D*        view2D;
  View2DSliceList* slicelist;
  View2DEvent*     ec;
  View2DEventPhase phase;
};


struct CSOEvalEventCSOInfos 
{
  CSOEvalEventCSOInfos()
  {
    csoList = NULL;
    hitMode = 0;
    recentlySelectedCSO = NULL;
    recentlySelectedSeedPoint = NULL;
    recentlySelectedPathPoints = NULL;
    timepointindex = -1;
    deleteSeedPoint = false;
    interactOnlyOnSelectedCSOs = false;
  }

  ml::CSOList*       csoList;
  ml::Vector3        currentHitPoint;
  int                hitMode;
  ml::CSO*           recentlySelectedCSO;
  ml::CSOSeedPoint*  recentlySelectedSeedPoint;
  ml::CSOPathPoints* recentlySelectedPathPoints;
  ml::CSOBoundingBox slabBB;
  int                timepointindex;
  bool               deleteSeedPoint;
  bool               interactOnlyOnSelectedCSOs;
};


typedef CSOEvalEventView2DInfos CSOProcessView2DInfos;
typedef CSOEvalEventCSOInfos    CSOProcessCSOInfos;


struct CSODrawView2DInfos 
{
  CSODrawView2DInfos()
  {
    slicelist = NULL;
    slice = NULL;
    z = -1;
    stylePalette = NULL;
    seriesInstanceUID = "";
    csoTransform = NULL;
  }
  View2DSliceList*  slicelist;
  View2DSlice*      slice;
  int               z;
  std::string       seriesInstanceUID;  
  SoCSOTransform*   csoTransform;

  ml::StylePalette* stylePalette;
};


enum CSOSliceInformation
{
  CSO_SLICE_UNKNOWN = 0,      
  CSO_SLICE_COMPLETELY_ON,    
  CSO_SLICE_CROSSED,          
  CSO_SLICE_COMPLETELY_ABOVE, 
  CSO_SLICE_COMPLETELY_BELOW  
};


struct CSOSliceCrossing
{
  std::vector<ml::Vector3> positions;
};


struct CSODrawSliceInformation
{
  CSODrawSliceInformation() 
  {
    sliceInformation = CSO_SLICE_UNKNOWN;
    distanceFromSliceInVoxels = 0;
  }
  
  CSOSliceInformation sliceInformation;  
  int distanceFromSliceInVoxels;
};


struct CSODrawCSOInfos 
{
  CSODrawCSOInfos()
  {
    csoList = NULL;
    cso = NULL;
  }
  ml::CSOBoundingBox slabBB;
  ml::CSOList*       csoList;
  ml::CSO*           cso;
  std::vector<int>   csoIds;

  void setDrawnCSOIDs(const std::vector<int>& ids) 
  {
    csoIds.clear();
    for (size_t i = 0; i < ids.size(); ++i) {
      csoIds.push_back(ids[i]);
    }
  }

  CSODrawCSOInfos& operator=(const CSODrawCSOInfos& infos)
  {
    if (&infos != this)
    {
      slabBB = infos.slabBB;
      csoList = infos.csoList;
      setDrawnCSOIDs(infos.csoIds);
    }
    return *this;
  }
};


enum SEED_POINT_MARKER_MODES 
{
  SHOW_MARKER_NONE    = 0, 
  SHOW_MARKER_RECT    = 1, 
  SHOW_MARKER_CIRCLE  = 2  
};


enum COLOR_MODES 
{
  COLOR_AS_CSO  = 0, 
  COLOR_GENERAL = 1  
};


enum STYLE_PALETTE_INDEX_USE 
{
  USE_INDEX_FOR_CSO   = 0, 
  USE_INDEX_FOR_GROUP = 1  
};


struct CSOVisualParameters 
{
  float pathPointRed;
  float pathPointGreen;
  float pathPointBlue;
  float pathPointAlpha; 
  float pathPointWidth;
  unsigned short pathPointStyle;

  float seedPointRed;
  float seedPointGreen;
  float seedPointBlue;
  float seedPointAlpha;
  float seedPointSize;
  int   seedPointStyle;

  float labelRed;
  float labelGreen;
  float labelBlue;
  float labelAlpha;
};


struct CSOEditorState
{
  CSOEditorState()
  {
    csoCurrentlyUnderMouse = NULL;
    isCurrentlyMovingCSO = false;
    processorData = NULL;
  }
  ml::CSO* csoCurrentlyUnderMouse;
  bool isCurrentlyMovingCSO;
  ml::CSOProcessorData* processorData;
};


enum HIT_POINT_MODE 
{
  HIT_NOTHING_HIT = 0, 
  HIT_SEED_POINT  = 1, 
  HIT_PATH_POINT  = 2, 
};


enum SELECTION_COLOR_MODES 
{
  SELECTION_COLOR_MODE_BRIGHTEN = 0, 
  SELECTION_COLOR_MODE_FIXED    = 1  
};


enum SELECTION_LINE_WIDTH_MODES 
{
  SELECTION_LINE_WIDEN = 0, 
  SELECTION_LINE_FIXED = 1  
};


enum SELECTED_SEED_POINT_COLOR_MODES 
{
  SELECTED_SEED_POINT_COLOR_MODE_BRIGHTEN = 0, 
  SELECTED_SEED_POINT_COLOR_MODE_FIXED = 1     
};


enum SELECTED_SEED_POINT_SIZE_MODES 
{
  SELECTED_SEED_POINT_ENLARGE = 0, 
  SELECTED_SEED_POINT_FIXED = 1    
};


enum HIGHLIGHT_COLOR_MODES 
{
  HIGHLIGHT_COLOR_MODE_BRIGHTEN = 0, 
  HIGHLIGHT_COLOR_MODE_FIXED    = 1  
};


enum HIGHLIGHT_LINE_WIDTH_MODES 
{
  HIGHLIGHT_LINE_WIDEN = 0, 
  HIGHLIGHT_LINE_FIXED = 1  
};


enum SIDE_FILLING_LINE_WIDTH_MODES 
{
  SIDE_FILLING_WIDTH_AS_CSO = 0,
  SIDE_FILLING_WIDTH_AUTOMATIC,
  SIDE_FILLING_WIDTH_MANUAL
};


const unsigned short LINE_PATTERN_NONE   = 0x0000;       
const unsigned short LINE_PATTERN_SOLID  = 0xFFFF;       //<! Line pattern for a solid line.
const unsigned short LINE_PATTERN_DASHED = 0xF0FF;       
const unsigned short LINE_PATTERN_DOTTED = 0x0808;       
const unsigned short LINE_PATTERN_SHORT_DASHED = 0xC7C7; //<! Line pattern for a short dashed line.



#endif // __SoCSODefines_H