mlMedicalImageProperties.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
**
**************************************************************************************/
 
#ifndef ML_MEDICAL_IMAGE_PROPERTIES_H
#define ML_MEDICAL_IMAGE_PROPERTIES_H
 
 
// ML-includes
#include "mlDateTime.h"
#include "mlImageProperties.h"
#include "mlLinearAlgebra.h"
#include "mlImagePropertyExtensionContainer.h"
 
#ifdef _MSC_VER
// Save warning state.
#pragma warning( push )
 
// Warning disabled: 'warning C4275': non DLL-interface
// Reason: Exporting is done manually or as inline functions for the
// template class ImageProperties.
#pragma warning(disable : 4275 )
#endif
 
ML_START_NAMESPACE
 
// Use incomplete type to reduce header file dependencies.
class RuntimeType;
 
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT MedicalImageProperties : public ImageProperties
{
 
public:
 
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  MedicalImageProperties();
 
  ~MedicalImageProperties() override;
 
  MedicalImageProperties(const MedicalImageProperties& medicalImageProperties);
 
  MedicalImageProperties &operator=(const MedicalImageProperties& medicalImageProperties);
 
  void setImageProperties(const MedicalImageProperties& medicalImageProperties);
 
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  bool operator==(const MedicalImageProperties& medicalImageProperties) const;
 
  bool operator!=(const MedicalImageProperties& medicalImageProperties) const;
 
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  void setVoxelSize(MLdouble dx, MLdouble dy, MLdouble dz);
 
  void setVoxelSize(const Vector3& voxelSize);
 
  Vector3 getVoxelSize() const;
 
  double getVoxelVolumeInCubicMillimeters() const;
 
  double getVoxelVolumeInMilliliters() const;
 
 
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  bool isVoxelToWorldMatrixValid() const;
 
  void setVoxelToWorldMatrixValid(bool valid);
 
  const Matrix4& getVoxelToWorldMatrix() const;
 
  void setVoxelToWorldMatrix(const Matrix4& matrix);
 
  const Matrix4& getWorldToVoxelMatrix() const;
 
  Vector3 mapVoxelToWorld(const Vector3& voxelPosition) const;
 
  Vector3 mapWorldToVoxel(const Vector3& worldPosition) const;
 
  void scaleVoxelToWorldMatrix(const Vector3& scaleFactors);
 
  void translateVoxelToWorldMatrix(const Vector3& offsetVector);
 
 
  //--------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------
  std::vector<std::string>& getCDimensionInfos() { return _cDimInfos; };
  std::vector<DateTime>&    getTDimensionInfos() { return _tDimInfos; };
  std::vector<std::string>& getUDimensionInfos() { return _uDimInfos; };
 
  const std::vector<std::string>& getCDimensionInfos() const { return _cDimInfos; };
  const std::vector<DateTime>&    getTDimensionInfos() const { return _tDimInfos; };
  const std::vector<std::string>& getUDimensionInfos() const { return _uDimInfos; };
 
 
  //--------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------
  ImagePropertyExtensionContainer&       getImagePropertyContainer()            { return _imagePropertyExtensions; }
  const ImagePropertyExtensionContainer& getConstImagePropertyContainer() const { return _imagePropertyExtensions; }
 
 
private:
 
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  void updateVoxelSizeFromToWorldMatrix();
 
  void updateToWorldMatrixFromVoxelSize();
 
  void correctToWorldMatrix();
 
 
  void _assignMembers(const MedicalImageProperties& medicalImageProperties);
 
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  MLdouble _x_VoxelSize;
 
  MLdouble _y_VoxelSize;
 
  MLdouble _z_VoxelSize;
 
  Matrix4 _toWorldMatrix;
 
  Matrix4 _toVoxelMatrix;
 
  bool _isToWorldMatrixValid;
 
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  std::vector<std::string> _cDimInfos;
  std::vector<DateTime>    _tDimInfos;
  std::vector<std::string> _uDimInfos;
 
 
  //-------------------------------------------------------------------
  //-------------------------------------------------------------------
  ImagePropertyExtensionContainer _imagePropertyExtensions;
 
#if ML_DEPRECATED_SINCE(3,5,0)
 
 
public:
 
  inline ML_DEPRECATED void setImgProps(const MedicalImageProperties &medImgProps) { setImageProperties(medImgProps); }
  inline ML_DEPRECATED bool isToWorldMatrixValid() const { return isVoxelToWorldMatrixValid(); }
  inline ML_DEPRECATED void setToWorldMatrixValid(bool valid) { setVoxelToWorldMatrixValid(valid); }
  ML_DEPRECATED void getVoxelSize(MLfloat *dx, MLfloat *dy, MLfloat *dz) const;
  ML_DEPRECATED void getToWorldMatrix(MLfloat *mat) const;
  ML_DEPRECATED void setToWorldMatrix(MLfloat *mat);
  ML_DEPRECATED const Matrix4* getToWorldMatrix() const;
  ML_DEPRECATED void setToWorldMatrix(const Matrix4 *mat);
  ML_DEPRECATED void setToWorldMatrixIdentity();
  ML_DEPRECATED void getToVoxelMatrix(MLfloat *mat) const;
  ML_DEPRECATED const Matrix4* getToVoxelMatrix() const;
  ML_DEPRECATED void transformToWorldCoord (MLfloat *x, MLfloat *y, MLfloat *z) const;
  ML_DEPRECATED void transformToWorldCoord (MLdouble *x, MLdouble *y, MLdouble *z) const;
  ML_DEPRECATED void transformToWorldCoord (const Vector3& voxel, Vector3& world) const;
  ML_DEPRECATED void transformToVoxelCoord (MLfloat *x, MLfloat *y, MLfloat *z) const;
  ML_DEPRECATED void transformToVoxelCoord (MLdouble *x, MLdouble *y, MLdouble *z) const;
  ML_DEPRECATED void transformToVoxelCoord (const Vector3& world, Vector3& voxel) const;
  inline ML_DEPRECATED void scaleImage(MLfloat x, MLfloat y, MLfloat z) { scaleVoxelToWorldMatrix(Vector3(x,y,z)); }
  inline ML_DEPRECATED void translateImage(MLfloat x, MLfloat y, MLfloat z) { translateVoxelToWorldMatrix(Vector3(x,y,z)); }
  inline ML_DEPRECATED std::vector<std::string>& getCDimInfos() { return getCDimensionInfos(); };
  inline ML_DEPRECATED std::vector<DateTime>&    getTDimInfos() { return getTDimensionInfos(); };
  inline ML_DEPRECATED std::vector<std::string>& getUDimInfos() { return getUDimensionInfos(); };
  inline ML_DEPRECATED const std::vector<std::string>   &getConstCDimInfos() const  { return getCDimensionInfos(); };
  inline ML_DEPRECATED const std::vector<DateTime>      &getConstTDimInfos() const  { return getTDimensionInfos(); };
  inline ML_DEPRECATED const std::vector<std::string>   &getConstUDimInfos() const  { return getUDimensionInfos(); };
 
 
#endif
 
};
 
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
 
ML_END_NAMESPACE
 
 
 
 
 
#endif //of  __mlMedicalImageProperties_H