vtkDICOMReader.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 vtkDICOMReader_h
#define vtkDICOMReader_h
 
#include "vtkImageReader2.h"
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMConfig.h" // For configuration details
#include "vtkDICOMCharacterSet.h" // For character sets
 
// Declare VTK classes within VTK's optional namespace
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_BEGIN
#endif
 
class vtkIntArray;
class vtkTypeInt64Array;
class vtkStringArray;
class vtkMatrix4x4;
class vtkMedicalImageProperties;
 
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_END
#endif
 
class vtkDICOMMetaData;
class vtkDICOMParser;
class vtkDICOMSliceSorter;
 
// For compatibility with VTK 7.0 and earlier
#ifndef VTK_TYPE_BOOL_TYPEDEFED
#define VTK_TYPE_BOOL_TYPEDEFED
typedef int vtkTypeBool;
#endif
 
//----------------------------------------------------------------------------
class VTKDICOM_EXPORT vtkDICOMReader : public vtkImageReader2
{
public:
  vtkTypeMacro(vtkDICOMReader, vtkImageReader2);
 
  static vtkDICOMReader *New();
 
  void PrintSelf(ostream& os, vtkIndent indent) VTK_DICOM_OVERRIDE;
 
  const char* GetFileExtensions() VTK_DICOM_OVERRIDE {
    return ".dcm .dc"; }
 
  const char* GetDescriptiveName() VTK_DICOM_OVERRIDE {
    return "DICOM"; }
 
  int CanReadFile(const char* filename) VTK_DICOM_OVERRIDE;
 
 
  void SetDesiredStackID(const char *stackId);
  const char *GetDesiredStackID() { return this->DesiredStackID; }
 
 
  vtkStringArray *GetStackIDs() { return this->StackIDs; }
 
 
  vtkIntArray *GetFileIndexArray() { return this->FileIndexArray; }
 
 
  vtkIntArray *GetFrameIndexArray() { return this->FrameIndexArray; }
 
 
  vtkDICOMMetaData *GetMetaData() { return this->MetaData; }
 
 
  void SetDefaultCharacterSet(vtkDICOMCharacterSet cs);
  vtkDICOMCharacterSet GetDefaultCharacterSet() {
    return this->DefaultCharacterSet; }
 
 
  vtkSetMacro(OverrideCharacterSet, bool);
  vtkBooleanMacro(OverrideCharacterSet, bool);
  bool GetOverrideCharacterSet() {
    return this->OverrideCharacterSet; }
 
  vtkGetMacro(Sorting, int);
  vtkSetMacro(Sorting, int);
  vtkBooleanMacro(Sorting, int);
 
 
  void SetSorter(vtkDICOMSliceSorter *sorter);
  vtkDICOMSliceSorter *GetSorter() { return this->Sorter; }
 
 
  vtkGetMacro(TimeAsVector, int);
  vtkSetMacro(TimeAsVector, int);
  vtkBooleanMacro(TimeAsVector, int);
 
  int GetTimeDimension() { return this->TimeDimension; }
  double GetTimeSpacing() { return this->TimeSpacing; }
 
  vtkSetMacro(DesiredTimeIndex, int);
  vtkGetMacro(DesiredTimeIndex, int);
 
 
  vtkGetMacro(AutoYBRToRGB, int);
  vtkSetMacro(AutoYBRToRGB, int);
  vtkBooleanMacro(AutoYBRToRGB, int);
 
 
  vtkGetMacro(AutoRescale, int);
  vtkSetMacro(AutoRescale, int);
  vtkBooleanMacro(AutoRescale, int);
 
 
  double GetRescaleSlope() { return this->RescaleSlope; }
  double GetRescaleIntercept() { return this->RescaleIntercept; }
 
 
  vtkMatrix4x4 *GetPatientMatrix() { return this->PatientMatrix; }
 
 
  vtkImageData *GetOverlayOutput();
  vtkAlgorithmOutput *GetOverlayOutputPort();
  void SetOverlayOutput(vtkImageData *data);
 
  bool HasOverlay() { return (this->OverlayBitfield != 0); }
 
  unsigned short GetOverlayBitfield() { return this->OverlayBitfield; }
 
  vtkMedicalImageProperties *GetMedicalImageProperties();
 
  enum RowOrder { FileNative, TopDown, BottomUp };
 
 
  void SetMemoryRowOrder(int order);
  void SetMemoryRowOrderToFileNative() {
    this->SetMemoryRowOrder(FileNative); }
  void SetMemoryRowOrderToTopDown() {
    this->SetMemoryRowOrder(TopDown); }
  void SetMemoryRowOrderToBottomUp() {
    this->SetMemoryRowOrder(BottomUp); }
  int GetMemoryRowOrder() { return this->MemoryRowOrder; }
  const char *GetMemoryRowOrderAsString();
 
 
  vtkSetMacro(OutputScalarType, int);
  vtkGetMacro(OutputScalarType, int);
 
#ifndef __WRAP__
  using Superclass::Update;
  void Update() VTK_DICOM_OVERRIDE;
#endif
 
 
  static void RegisterCodecs();
  static void UnRegisterCodecs();
 
protected:
  vtkDICOMReader();
  ~vtkDICOMReader() VTK_DICOM_OVERRIDE;
 
  vtkTypeBool ProcessRequest(
    vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) VTK_DICOM_OVERRIDE;
 
  int RequestInformation(
    vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) VTK_DICOM_OVERRIDE;
 
  int RequestData(
    vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) VTK_DICOM_OVERRIDE;
 
  virtual bool ReadOverlays(vtkImageData *data);
 
  void UnpackOverlay(
    const void *filePtr, vtkIdType bitskip, vtkIdType count,
    void *buffer, vtkIdType incr, int bit);
 
  virtual bool ReadOneFile(
    const char *filename, int idx,
    unsigned char *buffer, vtkIdType bufferSize);
 
  void MaskBits(void *buffer, vtkIdType bufferSize, int scalarSize,
                int bitsStored, int pixelRepresentation);
 
  void UnpackBits(
    const void *source, void *buffer, vtkIdType bufferSize, int bits);
 
  void UnpackYBR422(
    const void *source, void *buffer, vtkIdType bufferSize, vtkIdType rowlen);
 
  virtual bool ReadFileNative(
    const char *filename, int idx,
    unsigned char *buffer, vtkIdType bufferSize);
 
  virtual bool ReadFileDelegated(
    const char *filename, int idx,
    unsigned char *buffer, vtkIdType bufferSize);
 
  virtual int ComputeRescaledScalarType(
    int scalarType, int bitsStored, int pixelRepresentation);
 
  virtual void RescaleBuffer(
    int fileIdx, int frameIdx, int fileType, int outputType,
    int numFileComponents, int numComponents,
    void *fileBuffer, void *outputBuffer, vtkIdType bufferSize);
 
  virtual void YBRToRGB(
    int fileIdx, int frameIdx, void *buffer, vtkIdType bufferSize);
 
  void RelayError(vtkObject *o, unsigned long e, void *data);
 
 
  virtual bool ValidateStructure(
    vtkIntArray *fileArray, vtkIntArray *frameArray);
 
  virtual void SortFiles(vtkIntArray *fileArray, vtkIntArray *frameArray);
 
  void NoSortFiles(vtkIntArray *fileArray, vtkIntArray *frameArray);
 
  virtual void UpdateMedicalImageProperties();
 
  int Sorting;
 
  double RescaleIntercept;
  double RescaleSlope;
 
  vtkMatrix4x4 *PatientMatrix;
 
  vtkDICOMMetaData *MetaData;
 
  vtkMedicalImageProperties *MedicalImageProperties;
 
  vtkDICOMCharacterSet DefaultCharacterSet;
 
  bool OverrideCharacterSet;
 
  vtkDICOMParser *Parser;
 
  vtkDICOMSliceSorter *Sorter;
 
  vtkTypeInt64Array *FileOffsetArray;
 
  vtkIntArray *FileIndexArray;
 
  vtkIntArray *FrameIndexArray;
 
  vtkStringArray *StackIDs;
 
  int MemoryRowOrder;
 
  int NeedsRescale;
  int AutoRescale;
  int FileScalarType;
  int OutputScalarType;
 
  int NeedsYBRToRGB;
  int AutoYBRToRGB;
 
 
  int NumberOfPackedComponents;
 
  int NumberOfPlanarComponents;
 
  int TimeAsVector;
  int TimeDimension;
  int DesiredTimeIndex;
  double TimeSpacing;
 
  char DesiredStackID[20];
 
  unsigned short OverlayBitfield;
  bool UpdateOverlayFlag;
 
private:
#ifdef VTK_DICOM_DELETE
  vtkDICOMReader(const vtkDICOMReader&) VTK_DICOM_DELETE;
  void operator=(const vtkDICOMReader&) VTK_DICOM_DELETE;
#else
  vtkDICOMReader(const vtkDICOMReader&) = delete;
  void operator=(const vtkDICOMReader&) = delete;
#endif
};
 
 
class VTKDICOM_EXPORT vtkDICOMReaderInitializer
{
public:
  vtkDICOMReaderInitializer();
  ~vtkDICOMReaderInitializer();
private:
  vtkDICOMReaderInitializer(const vtkDICOMReaderInitializer&);
  vtkDICOMReaderInitializer& operator=(const vtkDICOMReaderInitializer&);
};
 
static vtkDICOMReaderInitializer vtkDICOMReaderInitializerInstance;
 
#endif // vtkDICOMReader_h