CSOVoxelSet.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
**
**************************************************************************************/
 
 
 
#pragma once
 
 
#include "MLCSOIncludes.h"
#include <CSOBase/CSODefines.h>
 
ML_START_NAMESPACE
 
 
typedef std::vector<Vector3> VoxelVector;
typedef std::vector<MLdouble> VoxelValueVector;
 
 
// Forward declaration.
class CSOVoxelSetList;
 
 
 
class MLCSO_EXPORT CSOVoxelSetPoint
{
public:
 
  int x = -1;
  int y = -1;
};
 
 
class MLCSO_EXPORT CSOVoxelSet
{
 
public:
 
  CSOVoxelSet();
  CSOVoxelSet(const CSOVoxelSet &csoVoxelSet);
  virtual ~CSOVoxelSet();
 
  /* METHODS */
 
  void addVoxelValuePositions(const std::vector<Vector3>& positions, const std::vector<MLdouble>& values);
  void addVoxelValuePositions(const std::vector<VoxelPosition>& positions, const std::vector<MLdouble>& values);
  size_t numTotalVoxels() const;
  Vector3 getVoxelPositionOfTotal(size_t index) const;
  double getVoxelValueOfTotal(size_t index) const;
 
  inline void setVoxelToWorldMatrix(const Matrix4& voxelToWorldMatrix) { _voxelToWorldMatrix = voxelToWorldMatrix; }
  inline const Matrix4& getVoxelToWorldMatrix() const { return _voxelToWorldMatrix; }
 
  size_t numSlices() const;
  unsigned int startingSlice() const;
  unsigned int endingSlice() const;
  const VoxelVector& getPositionsAt(size_t index) const;
  const VoxelValueVector& getValuesAt(size_t index) const;
  unsigned int numVoxelsOnSliceAt(size_t sliceIndex) const;
  Vector3 getVoxelPositionAtSlice(size_t sliceIndex, size_t voxelIndex) const;
  void getVoxelPositionAtSlice(size_t sliceIndex, size_t voxelIndex, int& x, int& y);
  bool getVoxelValueAtSlice(size_t sliceIndex, size_t voxelIndex, double& val) const;
  inline Vector3 getBoundingBoxV1() const { return _boundingBoxV1; }
  inline Vector3 getBoundingBoxV2() const { return _boundingBoxV2; }
  inline MLdouble getMinVoxelValue() const { return _minVoxelValue; }
  inline MLdouble getMaxVoxelValue() const { return _maxVoxelValue; }
 
  inline void setCSOVoxelSetList(CSOVoxelSetList* list) { _csoVoxelSetList = list; }
  inline CSOVoxelSetList* csoVoxelSetList() const { return _csoVoxelSetList; }
  inline unsigned int numGroups() const { return static_cast<unsigned int>(_groupIds.size()); }
  inline  int groupIdAt(size_t index) const { return _groupIds[index]; }
  inline void addCSOVoxelSetGroupId(int groupId) { _groupIds.push_back(groupId); }
 
  inline void setLabel(const std::string& labelArg) { _label = labelArg; }
  inline const std::string& label() const { return _label; }
  inline void setCreator(const std::string& creatorArg) { _creator = creatorArg; }
  inline const std::string& creator() const { return _creator; }
  inline void setTimepoint(int timepointArg) { _timepoint = timepointArg; }
  inline int timepoint() const { return _timepoint; }
  inline void setDescription(const std::string& descriptionArg) { _description = descriptionArg; }
  inline const std::string& description() const { return _description; }
 
 
  inline void setUniqueId(int id) { _uniqueId = id; }
  inline int uniqueId() const { return _uniqueId; }
 
 
protected:
 
private:
 
  /* MEMBER VARIABLES */
 
  std::vector<VoxelVector>      _sliceVoxels;
  std::vector<VoxelValueVector> _sliceVoxelValues;
 
  int _startingSlice;
  int _endingSlice;
 
  int _uniqueId;
  std::string _label;
  std::string _description;
  std::string _creator;
  int         _timepoint;
 
  Matrix4 _voxelToWorldMatrix;
 
  Vector3 _boundingBoxV1;
  Vector3 _boundingBoxV2;
 
  std::vector<int> _groupIds;
 
  CSOVoxelSetList* _csoVoxelSetList;
 
  MLdouble _minVoxelValue;
  MLdouble _maxVoxelValue;
 
  /* METHODS */
 
  void _sortToSlices(const std::vector<Vector3>& positions, const std::vector<MLdouble>& values);
};
 
 
ML_END_NAMESPACE