vtkDICOMGenerator.h

/*=========================================================================
 
  Program: DICOM for VTK
 
  Copyright (c) 2012-2024 David Gobbi
  All rights reserved.
  See Copyright.txt or http://dgobbi.github.io/bsd3.txt for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkDICOMGenerator_h
#define vtkDICOMGenerator_h
 
#include "vtkObject.h"
#include "vtkStdString.h" // For std::string
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMConfig.h" // For configuration details
#include "vtkDICOMTag.h" // For method parameter
 
// Declare VTK classes within VTK's optional namespace
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_BEGIN
#endif
 
class vtkIntArray;
class vtkMatrix4x4;
class vtkInformation;
class vtkStringArray;
 
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_END
#endif
 
class vtkDICOMMetaData;
class vtkDICOMItem;
class vtkDICOMUIDGenerator;
 
 
class VTKDICOM_EXPORT vtkDICOMGenerator : public vtkObject
{
public:
  static vtkDICOMGenerator *New();
  vtkTypeMacro(vtkDICOMGenerator, vtkObject);
 
  void PrintSelf(ostream& os, vtkIndent indent) VTK_DICOM_OVERRIDE;
 
 
  virtual bool GenerateInstance(vtkInformation *);
 
 
  vtkDICOMMetaData *GetMetaData();
 
 
  vtkSetMacro(Extended, int);
  vtkBooleanMacro(Extended, int);
  vtkGetMacro(Extended, int);
 
 
  vtkSetMacro(MultiFrame, int);
  vtkBooleanMacro(MultiFrame, int);
  vtkGetMacro(MultiFrame, int);
 
 
  vtkSetMacro(TimeAsVector, int);
  vtkBooleanMacro(TimeAsVector, int);
  vtkGetMacro(TimeAsVector, int);
 
 
  vtkSetMacro(TimeDimension, int);
  vtkGetMacro(TimeDimension, int);
  vtkSetMacro(TimeSpacing, double);
  vtkGetMacro(TimeSpacing, double);
 
 
  vtkSetMacro(RescaleIntercept, double);
  vtkGetMacro(RescaleIntercept, double);
  vtkSetMacro(RescaleSlope, double);
  vtkGetMacro(RescaleSlope, double);
 
 
  vtkSetMacro(NumberOfOverlays, int);
  vtkGetMacro(NumberOfOverlays, int);
 
 
  void SetPatientMatrix(vtkMatrix4x4 *);
  vtkMatrix4x4 *GetPatientMatrix() { return this->PatientMatrix; }
 
 
  vtkSetMacro(OriginAtBottom, int);
  vtkGetMacro(OriginAtBottom, int);
 
 
  vtkSetMacro(ReverseSliceOrder, int);
  vtkGetMacro(ReverseSliceOrder, int);
 
 
  void SetSourceMetaData(vtkDICOMMetaData *);
  vtkDICOMMetaData *GetSourceMetaData();
 
 
  void SetUIDGenerator(vtkDICOMUIDGenerator *);
  vtkDICOMUIDGenerator *GetUIDGenerator();
 
 
  vtkIntArray *GetSliceIndexArray() { return this->SliceIndexArray; }
 
 
  vtkIntArray *GetComponentIndexArray() { return this->ComponentIndexArray; }
 
protected:
  enum {
    RepresentationUnsigned = 1u,
    RepresentationSigned = 2u,
    BitsStored1 = 1u,
    BitsStored6 = (1u << 5),
    BitsStored8 = (1u << 7),
    BitsStored10 = (1u << 9),
    BitsStored12 = (1u << 11),
    BitsStored16 = (1u << 15),
    BitsStored32 = (1u << 31)
  };
 
  vtkDICOMGenerator();
  ~vtkDICOMGenerator() VTK_DICOM_OVERRIDE;
 
  /*
   *  The generator uses the tag as a hint when generating the UIDs,
   *  for example the SOPInstanceUID might have a different format from
   *  the FrameOfReferenceUID.
   */
  std::string GenerateUID(vtkDICOMTag tag);
 
 
  void GenerateUIDs(vtkDICOMTag tag, vtkStringArray *uids);
 
  void SetPixelRestrictions(
    unsigned int pixelRepresentation, unsigned int bitsStored,
    int colorComponents);
 
  virtual bool GenerateSOPCommonModule(
    vtkDICOMMetaData *meta, const char *SOPClass);
 
  virtual bool GeneratePatientModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateClinicalTrialSubjectModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateGeneralStudyModule(vtkDICOMMetaData *source);
 
  virtual bool GeneratePatientStudyModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateClinicalTrialStudyModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateGeneralSeriesModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateClinicalTrialSeriesModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateFrameOfReferenceModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateGeneralEquipmentModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateGeneralImageModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateImagePlaneModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateImagePixelModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateContrastBolusModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateMultiFrameModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateDeviceModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateSpecimenModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateOverlayPlaneModule(vtkDICOMMetaData *source);
 
  virtual bool GenerateVOILUTModule(vtkDICOMMetaData *source);
 
 
  virtual bool CopyRequiredAttributes(
    const DC::EnumType *tags, vtkDICOMMetaData *source);
 
 
  virtual bool CopyOptionalAttributes(
    const DC::EnumType *tags, vtkDICOMMetaData *source);
 
 
  virtual bool CopyAttributes(
    const DC::EnumType *blacklist, vtkDICOMMetaData *source);
 
  static void ComputeAspectRatio(const double spacing[2], int aspect[2]);
 
  void ComputeAdjustedMatrix(
    double matrix[16], double origin[3], double spacing[3]);
 
 
  static void ComputePositionAndOrientation(
    const double origin[3], const double matrix[16],
    double position[3], double orientation[6]);
 
 
  virtual void ComputeDimensions(
    vtkInformation *info, int *nframes, int dims[5],
    double spacing[5], double origin[5]);
 
 
  virtual void ComputePixelValueRange(
    vtkInformation *info, int seriesRange[2]);
 
  virtual void MatchInstances(vtkDICOMMetaData *source);
 
 
  virtual void InitializeMetaData(vtkInformation *info);
 
  vtkDICOMMetaData *MetaData;
 
  vtkDICOMMetaData *SourceMetaData;
 
  vtkDICOMUIDGenerator *UIDGenerator;
 
  int Extended;
 
  int MultiFrame;
 
  int OriginAtBottom;
 
  int ReverseSliceOrder;
 
  int TimeAsVector;
 
  int TimeDimension;
  double TimeSpacing;
 
  double RescaleIntercept;
  double RescaleSlope;
 
  int NumberOfOverlays;
 
  int ScalarType;
 
 
  int NumberOfColorComponents;
 
  unsigned int AllowedPixelRepresentation;
  unsigned int AllowedBitsStored;
 
 
  int NumberOfFrames;
 
 
  int Dimensions[5];
  double Spacing[5];
  double Origin[5];
 
 
  int PixelValueRange[2];
 
  vtkMatrix4x4 *PatientMatrix;
 
  vtkIntArray *SliceIndexArray;
  vtkIntArray *ComponentIndexArray;
 
  vtkIntArray *SourceInstanceArray;
 
  vtkIntArray *RangeArray;
 
private:
#ifdef VTK_DICOM_DELETE
  vtkDICOMGenerator(const vtkDICOMGenerator&) VTK_DICOM_DELETE;
  void operator=(const vtkDICOMGenerator&) VTK_DICOM_DELETE;
#else
  vtkDICOMGenerator(const vtkDICOMGenerator&) = delete;
  void operator=(const vtkDICOMGenerator&) = delete;
#endif
};
 
#endif // vtkDICOMGenerator_h