mitkSUVCalculationHelper.h

Go to the documentation of this file.

/*===================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
 
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
 
See LICENSE.txt or http://www.mitk.org for details.
 
===================================================================*/
 
 
#ifndef mitkSUVCalculationHelper_h
#define mitkSUVCalculationHelper_h
 
#include <limits>
#include <map>
#include <string>
#include <vector>
 
#include <mitkException.h>
#include <mitkExceptionMacro.h>
#include <mitkSlicedData.h>
 
#include <MitkPETExports.h>
 
namespace mitk
{
  class IPropertyProvider;
 
  enum class Sex
  {
    Male,
    Female,
    Other
  };
 
  class MITKPET_EXPORT SUVHelperException : public mitk::Exception
  {
  public:
    mitkExceptionClassMacro(SUVHelperException, mitk::Exception);
  };
 
  class MITKPET_EXPORT MissingDICOMPropertyException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(MissingDICOMPropertyException, SUVHelperException);
  };
 
  class MITKPET_EXPORT InvalidDICOMPropertyValueException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(InvalidDICOMPropertyValueException, SUVHelperException);
  };
 
  class MITKPET_EXPORT MultiItemRadiopharmaceuticalSequenceException
    : public InvalidDICOMPropertyValueException
  {
  public:
    mitkExceptionClassMacro(MultiItemRadiopharmaceuticalSequenceException,
                            InvalidDICOMPropertyValueException);
  };
 
  class MITKPET_EXPORT BenchmarkAdaptationRequiredException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(BenchmarkAdaptationRequiredException, SUVHelperException);
  };
 
  class MITKPET_EXPORT ImplausibleRadionuclideDoseException : public BenchmarkAdaptationRequiredException
  {
  public:
    mitkExceptionClassMacro(ImplausibleRadionuclideDoseException, BenchmarkAdaptationRequiredException);
  };
 
  class MITKPET_EXPORT VendorEmpiricalDecayFallbackRefusedException : public BenchmarkAdaptationRequiredException
  {
  public:
    mitkExceptionClassMacro(VendorEmpiricalDecayFallbackRefusedException, BenchmarkAdaptationRequiredException);
  };
 
  class MITKPET_EXPORT UnsupportedPETUnitsException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(UnsupportedPETUnitsException, SUVHelperException);
  };
 
  class MITKPET_EXPORT MissingPhilipsPETScaleException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(MissingPhilipsPETScaleException, SUVHelperException);
  };
 
  class MITKPET_EXPORT AmbiguousPatientSexAdaptationRefusedException : public BenchmarkAdaptationRequiredException
  {
  public:
    mitkExceptionClassMacro(AmbiguousPatientSexAdaptationRefusedException, BenchmarkAdaptationRequiredException);
  };
 
  class MITKPET_EXPORT AmbiguousDecayTimingException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(AmbiguousDecayTimingException, SUVHelperException);
  };
 
  class MITKPET_EXPORT InvalidDecayTimeMapException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(InvalidDecayTimeMapException, SUVHelperException);
  };
 
  class MITKPET_EXPORT InvalidDecayTimeOverrideException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(InvalidDecayTimeOverrideException, SUVHelperException);
  };
 
  class MITKPET_EXPORT ConflictingDecayTimeOverrideException : public SUVHelperException
  {
  public:
    mitkExceptionClassMacro(ConflictingDecayTimeOverrideException, SUVHelperException);
  };
 
  enum class DICOMReadPolicy
  {
    Lenient,
    Strict
  };
 
  enum class ManufacturerFamily
  {
    Siemens,
    GE,
    Philips,
    Other
  };
 
  ManufacturerFamily MITKPET_EXPORT GetManufacturerFamily(const mitk::IPropertyProvider* provider);
 
  enum class DecayCorrectionStrategy
  {
    Admin,
    Start,
    None,
    Manual
  };
 
  typedef std::map<mitk::SlicedData::IndexValueType, double> DecayTimeSliceMapType;
 
  typedef std::map<mitk::TimeStepType, DecayTimeSliceMapType> DecayTimeMapType;
 
  struct MITKPET_EXPORT DecayCorrectionInfo
  {
    DecayCorrectionStrategy strategy = DecayCorrectionStrategy::None;
    DecayTimeMapType        decayTimes;
  };
 
  struct MITKPET_EXPORT RadiopharmaceuticalInfo
  {
    double      halfLifeSeconds = std::numeric_limits<double>::quiet_NaN();
    double      totalDoseBq     = std::numeric_limits<double>::quiet_NaN();
    std::string name;
  };
 
  std::vector<RadiopharmaceuticalInfo> MITKPET_EXPORT
  GetRadiopharmaceuticalInfos(const mitk::IPropertyProvider* provider,
                              DICOMReadPolicy policy = DICOMReadPolicy::Lenient);
 
  double MITKPET_EXPORT GetPatientsWeight(const mitk::IPropertyProvider* provider);
 
  double MITKPET_EXPORT GetPatientsHeight(const mitk::IPropertyProvider* provider);
 
  Sex MITKPET_EXPORT GetPatientsSex(const mitk::IPropertyProvider* provider);
 
  DecayCorrectionStrategy MITKPET_EXPORT GetDecayCorrectionStrategy(const mitk::IPropertyProvider* provider);
 
  DecayCorrectionInfo MITKPET_EXPORT DeduceDecayCorrection(
    const mitk::SlicedData* data,
    double halfLifeSeconds = std::numeric_limits<double>::quiet_NaN(),
    DICOMReadPolicy policy = DICOMReadPolicy::Lenient);
 
}
 
#endif