MeVisLab/Standard/Sources/ML/MLCSO/CSOBase/CSO.h

Go to the documentation of this file.

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

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

#ifndef __CSO_H
#define __CSO_H

#include "MLCSOIncludes.h"

#include "CSOAttributes.h"
#include "CSOBase/CSOGroup.h"
#include "CSOBase/CSOSeedPoint.h"
#include "CSOBase/CSOPathPoints.h"
#include "CSOBase/CSOBoundingBox.h"


ML_START_NAMESPACE


// Forward declaration.
class CSOList;
class CSOManager;



class MLCSO_EXPORT CSO
{ 

public:

  CSO();
  CSO(CSOList* csoList);
  CSO(const CSO &cso, CSOList* csoList=NULL, int csoId=-1);
  virtual ~CSO();


  /* METHODS */


  
  void reverseSeedPointOrder();
  
  void resortSeedPointsClockwise();

  inline void storeInUndoManager() { setInsertRemoveSeedPoint(); }

  CSOManager* getManager() const;


  void applyTransformationMatrix(const Matrix4& matrix);
  void moveSeedPointsAndPathPoints(float dx, float dy, float dz, int timepoint);
  void moveSeedPointsAndPathPoints(float dx, float dy, float dz);

  void setAbsoluteMovement(float fromX,float fromY,float fromZ, float toX,float toY,float toZ, int fromTimePointIndex, int toTimePointIndex);
  void moveSingleSeedPoint(CSOSeedPoint* sPoint, float dx, float dy, float dz);
  void setAbsoluteSeedPointMovement();
  void setSeedPointsAndPathPoints(const CSO* cso);


  CSOSeedPoint* appendSeedAndPathPoint();
  CSOSeedPoint* appendSeedAndPathPoint(const Vector3& position);
  CSOPathPoints* insertPathPointsEndStart();
  CSOSeedPoint* appendSeedPoint();
  CSOPathPoints* appendPathPoints();
  void removeSeedPoint(CSOSeedPoint* sPoint);
  void removeAllSeedAndPathPoints();
  CSOSeedPoint* insertSeedPointAt(CSOPathPoints* toBeSplitPath, const Vector3& toInsertPos);
  void setInsertRemoveSeedPoint();


  CSOSeedPoint* getSeedPointAt(unsigned int index) const;
  inline CSOSeedPoint* getFirstSeedPoint() const { if (numSeedPoints()) { return _seedPointList[0];                } else { return NULL; } }
  inline CSOSeedPoint* getLastSeedPoint()  const { if (numSeedPoints()) { return _seedPointList[numSeedPoints()-1];} else { return NULL; } }
  inline unsigned int numSeedPoints() const { return static_cast<unsigned int>(_seedPointList.size());  }
  bool getSeedPointIndex(CSOSeedPoint* sPoint, unsigned int& index) const;
  inline unsigned int numPathPointLists() const  { return static_cast<unsigned int>(_pathPointsList.size()); }
  void fillPathPointCoordinatesFlattened(std::vector<Vector3>& pathPointCoords) const;
  void fillPathPointCoordinatesFlattened(std::vector<Vector4>& pathPointCoordsAndValues) const;
  inline CSOPathPoints* getPathPointsAt(unsigned int index) const { return _pathPointsList[index]; }
  unsigned int getTotalNumPathPoints() const;
  unsigned int getTotalNumUniquePathPoints() const;

  bool isSelected() const;


  void addSelectedSeedPoint(CSOSeedPoint* sPoint);
  void setSelectedSeedPoint(CSOSeedPoint* sPoint);
  bool isSelectedSeedPoint(CSOSeedPoint* sPoint) const;
  void clearSelectedSeedPoints();
  unsigned int getNumSelectedSeedPoints() const;
  CSOSeedPoint* getSelectedSeedPointAt(unsigned int index) const;


  void addGroup(CSOGroup* group);
  void addGroup(unsigned int groupId);
  bool isInGroup(CSOGroup* group) const;
  // Returns whether this CSO is in a same Group as the given CSO.
  bool isInSameGroupsAs(CSO* cso) const;
  bool isInGroup(unsigned int groupId) const;
  inline unsigned int numGroups() const { return static_cast<unsigned int>(_csoGroupIds.size()); }
  CSOGroup* getGroupAt(unsigned int index) const;
  inline unsigned int getGroupIdAt(unsigned int index) const { return _csoGroupIds[index]; }
  void removeGroup(CSOGroup* group);
  void removeAllGroups();


  void setType(const std::string& type) { _type = type; }
  const std::string& getType() const { return _type; }
  void setSubType(const std::string& subtype) { _subtype = subtype; }
  const std::string& getSubType() const { return _subtype; }
  void setCreatorId(int id) { _creatorId = id; }
  int getCreatorId() const { return _creatorId; }


  void setUserData(const std::string& name, Variant value) { _attributes.setUserData(name, value); }
  Variant getUserData(const std::string& name) const { return _attributes.getUserData(name); }
  void getUserDataNames(std::vector< std::string >& names) const { _attributes.getUserDataNames(names); }
  void removeUserData(const std::string& name) { _attributes.removeUserData(name); }


  const CSOBoundingBox& getWorldBoundingBox() const;
  const CSOBoundingBox& getVoxelBoundingBox(const Matrix4& worldToVoxelMatrix) const;
  const CSOBoundingBox& getVoxelBoundingBoxSeedPoints(const Matrix4& worldToVoxelMatrix) const;
  void setWorldToVoxelMatrix(const Matrix4& mat);
  const Matrix4& getWorldToVoxelMatrix() const;
  inline bool isInPlane() { Vector3 dummy; return isInPlane(dummy); }
  bool isInPlane(Vector3& planeNormal);
  inline const Vector3& getPlaneNormal() const { if (!_hasValidPlaneStatus) { _computeIsInPlane(); } return _planeNormal; }
  inline void computePlaneNormal() { if (!_hasValidPlaneStatus) { _computeIsInPlane(); } }
  inline void setIsInPlane(bool status) { _isInPlane = status; }
  inline void setPlaneNormal(const Vector3& planeNormal) { _planeNormal = planeNormal; _hasValidPlaneStatus = true; }
  inline void invalidatePlaneNormal() { _hasValidPlaneStatus = false; }
  float getLength() const;
  inline double getArea() const { _computeArea(); return _area; }
  inline void invalidateArea() { _hasValidArea = false; }
  void setIsClosed(bool isClosed);
  inline bool isClosed() const { return _isClosed; }
  bool isPoint() const;
  inline void setIsFinished(bool isFinished) { _isFinished = isFinished; }
  inline bool getIsFinished() const { return _isFinished; }
  inline void setNeedsInterpolation(bool needsInterpolation) { _needsInterpolation = needsInterpolation; }
  inline bool getNeedsInterpolation() const { return _needsInterpolation; }
  void determineNeedsInterpolation();
  void setNeedInterpolationAllSeedPoints(bool needsInterpolation);
  inline void setNeedInterpolation(CSOSeedPoint* seedPoint) { if (seedPoint != NULL) { seedPoint->setNeedsInterpolation(true); _needsInterpolation = true; } }
  void pathChanged();




  void setCSOList(CSOList* csoList);   
  inline CSOList* getCSOList() const { return _csoList; }
  inline unsigned int getId() const  { return _uniqueId; }   


  void setLabel(const std::string& label);
  inline const std::string& getLabel() const { return _attributes.label; }
  void setDescription(std::string description);
  inline const std::string& getDescription() const { return _attributes.description; }

  void setTimePointIndex(int index);
  int getTimePointIndex() const;
  void setShowState(bool state);
  bool getShowState() const;
  void setVoxelizeState(bool state);
  bool getVoxelizeState() const;
  void setEditableState(bool state);
  bool getEditableState() const;    
  void setPathPointStyle(CSOLineStyle style);
  inline void setPathPointStyle(int style) { setPathPointStyle(static_cast<CSOLineStyle>(style)); }
  CSOLineStyle getPathPointStyle() const;
  void setPathPointWidth(float width);
  float getPathPointWidth() const;
  void setPathPointColor(const Vector3& color);
  Vector3 getPathPointColor() const;
  void setPathPointAlpha(float alpha);
  float getPathPointAlpha() const;
  void setSeedPointStyle(int style);
  int getSeedPointStyle() const;
  void setSeedPointSize(float size);
  float getSeedPointSize() const;
  void setSeedPointColor(const Vector3& color);
  Vector3 getSeedPointColor() const;
  void setSeedPointAlpha(float alpha);
  float getSeedPointAlpha() const;

  void setVoxelWriteMode(int mode);
  int getVoxelWriteMode() const;
  void setVoxelWriteValue(float value);
  float getVoxelWriteValue() const;

  void setAllValuesTo(float value);


  inline int getPrivateTimePointIndex() const { return _attributes.timePointIndex; }
  inline bool getPrivateShowState() const { return _attributes.showState; }
  inline bool getPrivateVoxelizeState() const { return _attributes.voxelizeState; }
  inline bool getPrivateEditableState() const { return _attributes.editableState; }
  inline int    getPrivatePathPointStyle() const { return _attributes.pathPointStyle; }
  inline float   getPrivatePathPointWidth() const { return _attributes.pathPointWidth; }
  inline Vector3 getPrivatePathPointColor() const { return _attributes.pathPointColor; }
  inline float   getPrivatePathPointAlpha() const { return _attributes.pathPointAlpha; }
  inline int     getPrivateSeedPointStyle() const { return _attributes.seedPointStyle; }
  inline float   getPrivateSeedPointSize() const { return _attributes.seedPointSize; }
  inline Vector3 getPrivateSeedPointColor() const { return _attributes.seedPointColor; }
  inline float   getPrivateSeedPointAlpha() const { return _attributes.seedPointAlpha; }

  inline int getPrivateVoxelWriteMode() const { return _attributes.voxelWriteMode; }
  inline float getPrivateVoxelWriteValue() const { return _attributes.voxelWriteValue; }


  inline void setPrivateIsFinished(bool isFinished) { _isFinished = isFinished; }
  inline void setPrivateIsClosed(bool isClosedP) { _isClosed = isClosedP; }
  inline void setPrivateIsInPlane(bool isInPlaneP) { _isInPlane = isInPlaneP; }
  inline void setPrivateBoundingBox(const CSOBoundingBox& bb) { _worldBoundingBox = bb; _hasValidWorldBoundingBox = true; }
  inline void setPrivatePlaneNormal(const Vector3& normal) { _planeNormal = normal; _hasValidPlaneStatus = true; }
  inline void setId(unsigned int newId) { _uniqueId = newId; }

  bool saveAttributes(std::ostream& outStream, bool useAscii=false);

  void loadAttributes(std::istream& inStream, short version, bool swapBytes, bool useAscii=false);

#ifdef ML_DEPRECATED



  inline ML_DEPRECATED void moveSeedPoints(float dx, float dy, float dz, int timepoint) {
    moveSeedPointsAndPathPoints(dx,dy,dz,timepoint);
  }
  inline ML_DEPRECATED void setLineStyle(CSOLineStyle style) { setPathPointStyle(style); }
  inline ML_DEPRECATED CSOLineStyle getLineStyle() const { return getPathPointStyle(); }
  inline ML_DEPRECATED void setColor(const Vector3& color) { setPathPointColor(color); }
  inline ML_DEPRECATED Vector3 getColor() const { return getPathPointColor(); }
  inline ML_DEPRECATED void setAlpha(float alpha) { setPathPointAlpha(alpha); }
  inline ML_DEPRECATED float getAlpha() const { return getPathPointAlpha(); }
  inline ML_DEPRECATED void setLineWidth(float width) { setPathPointWidth(width); }
  inline ML_DEPRECATED float getLineWidth() const { return getPathPointWidth(); }
  inline ML_DEPRECATED void setMarkerMode(int mode) { setSeedPointStyle(mode); }
  inline ML_DEPRECATED int getMarkerMode() const { return getSeedPointStyle(); }
  inline ML_DEPRECATED void setMarkerColor(const Vector3& color) { setSeedPointColor(color); }
  inline ML_DEPRECATED Vector3 getMarkerColor() const { return getSeedPointColor(); }
  inline ML_DEPRECATED void setMarkerAlpha(float alpha) { setSeedPointAlpha(alpha); }
  inline ML_DEPRECATED float getMarkerAlpha() const { return getSeedPointAlpha();}
  inline ML_DEPRECATED void setMarkerSize(float size) { setSeedPointSize(size); }
  inline ML_DEPRECATED float getMarkerSize() const { return getSeedPointSize(); }
  inline ML_DEPRECATED CSOLineStyle getPrivateLineStyle() const { return static_cast<CSOLineStyle>(getPrivatePathPointStyle()); }
  inline ML_DEPRECATED Vector3 getPrivateColor() const { return getPrivatePathPointColor(); }
  inline ML_DEPRECATED float getPrivateAlpha() const { return getPrivatePathPointAlpha(); }
  inline ML_DEPRECATED float getPrivateLineWidth() const { return getPrivatePathPointWidth(); }
  inline ML_DEPRECATED int getPrivateMarkerMode() const { return getPrivateSeedPointStyle(); }
  inline ML_DEPRECATED Vector3 getPrivateMarkerColor() const { return getPrivateSeedPointColor(); }
  inline ML_DEPRECATED float getPrivateMarkerAlpha() const { return getPrivateSeedPointAlpha(); }
  inline ML_DEPRECATED float getPrivateMarkerSize() const { return getPrivateSeedPointSize(); }
#endif
  
protected:

private:

  template <class Method>
  int getOverrideGroupIndexForAttribute(Method method) const; // (defined in source file)

  /* MEMBER VARIABLES */

  unsigned int _uniqueId;

  std::vector<CSOSeedPoint*> _seedPointList;
  std::vector<CSOPathPoints*> _pathPointsList;

  CSOList* _csoList;

  std::vector<unsigned int> _csoGroupIds;

  std::vector<unsigned int> _selectedSeedPointsIndices;

  std::string _type;   
  std::string _subtype;  
  int        _creatorId;

  CSOAttributes _attributes;

  mutable bool _hasValidWorldBoundingBox;
  mutable bool _hasValidVoxelBoundingBox;
  mutable bool _hasValidVoxelSeedPointBoundingBox;

  mutable bool _hasValidPlaneStatus;
  mutable bool _hasValidArea;

  mutable CSOBoundingBox _worldBoundingBox;
  mutable CSOBoundingBox _voxelBoundingBox;
  mutable CSOBoundingBox _voxelSeedPointBoundingBox;

  mutable Matrix4 _lastRecentBBWorldToVoxelMatrix;
  mutable Matrix4 _lastRecentSeedPointsBBWorldToVoxelMatrix;

  bool _isFinished;
  bool _isClosed;
  mutable bool _isInPlane;
  mutable Vector3 _planeNormal;

  bool _needsInterpolation;

  mutable Matrix4 _transformationMatrix;


  mutable double _area;


  /* METHODS */

  void _initMembers();

  void _computeIsInPlane() const;
  void _computeArea() const;
  void _resetSeedPathLinks();
};



ML_END_NAMESPACE


#endif // __CSO_H