vtkDICOMWriter.h

/*=========================================================================
 
  Program: DICOM for VTK
 
  Copyright (c) 2012-2022 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 vtkDICOMWriter_h
#define vtkDICOMWriter_h
 
#include "vtkImageWriter.h"
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMConfig.h" // For configuration details
 
// Declare VTK classes within VTK's optional namespace
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_BEGIN
#endif
 
class vtkMatrix4x4;
 
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_END
#endif
 
class vtkDICOMMetaData;
class vtkDICOMGenerator;
 
class VTKDICOM_EXPORT vtkDICOMWriter : public vtkImageWriter
{
public:
  vtkTypeMacro(vtkDICOMWriter, vtkImageWriter);
 
  static vtkDICOMWriter *New();
 
  void PrintSelf(ostream& os, vtkIndent indent) VTK_DICOM_OVERRIDE;
 
 
  vtkSetStringMacro(SeriesDescription);
  vtkGetStringMacro(SeriesDescription);
 
 
  vtkSetStringMacro(ImageType);
  vtkGetStringMacro(ImageType);
 
 
  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);
 
 
  void SetPatientMatrix(vtkMatrix4x4 *);
  vtkMatrix4x4 *GetPatientMatrix() { return this->PatientMatrix; }
 
  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();
 
  enum SliceOrder { RHR, LHR, Same, Reverse };
 
 
  void SetFileSliceOrder(int order);
  void SetFileSliceOrderToRHR() { this->SetFileSliceOrder(RHR); }
  void SetFileSliceOrderToLHR() { this->SetFileSliceOrder(LHR); }
  void SetFileSliceOrderToSame() { this->SetFileSliceOrder(Same); }
  void SetFileSliceOrderToReverse() { this->SetFileSliceOrder(Reverse); }
  int GetFileSliceOrder() { return this->FileSliceOrder; }
  const char *GetFileSliceOrderAsString();
 
 
  void SetMetaData(vtkDICOMMetaData *);
  vtkDICOMMetaData *GetMetaData();
 
 
  void SetGenerator(vtkDICOMGenerator *);
  vtkDICOMGenerator *GetGenerator() { return this->Generator; }
 
 
  vtkSetStringMacro(TransferSyntaxUID);
  vtkGetStringMacro(TransferSyntaxUID);
 
 
  vtkSetMacro(Streaming, int);
  vtkGetMacro(Streaming, int);
  vtkBooleanMacro(Streaming, int);
 
  void SetOverlayInputData(vtkImageData *data);
  void SetOverlayInputConnection(vtkAlgorithmOutput *data);
  vtkImageData *GetOverlayInput();
 
  vtkSetMacro(OverlayType, int);
  vtkGetMacro(OverlayType, int);
  void SetOverlayTypeToGraphics() { this->SetOverlayType(0); }
  void SetOverlayTypeToROI() { this->SetOverlayType(1); }
 
  void Write() VTK_DICOM_OVERRIDE;
 
protected:
  vtkDICOMWriter();
  ~vtkDICOMWriter() VTK_DICOM_OVERRIDE;
 
  void ComputeInternalFileName(int slice);
 
  void FreeInternalFileName();
 
  virtual int GenerateMetaData(vtkInformation *info);
 
  virtual void GenerateOverlays(int minFileIdx, int maxFileIdx,
                                const int extent[4]);
 
  int FillInputPortInformation(int port, vtkInformation *info) VTK_DICOM_OVERRIDE;
 
  int RequestData(vtkInformation *request,
                  vtkInformationVector** inputVector,
                  vtkInformationVector* outputVector) VTK_DICOM_OVERRIDE;
 
  vtkDICOMMetaData *MetaData;
 
  vtkDICOMMetaData *GeneratedMetaData;
 
  vtkDICOMGenerator *Generator;
 
  int TimeAsVector;
 
  int TimeDimension;
  double TimeSpacing;
 
  double RescaleIntercept;
  double RescaleSlope;
 
  vtkMatrix4x4 *PatientMatrix;
 
  char *SeriesDescription;
 
  char *TransferSyntaxUID;
 
  char *ImageType;
 
  int OverlayType;
 
  int MemoryRowOrder;
 
  int FileSliceOrder;
 
  int Streaming;
 
private:
#ifdef VTK_DICOM_DELETE
  vtkDICOMWriter(const vtkDICOMWriter&) VTK_DICOM_DELETE;
  void operator=(const vtkDICOMWriter&) VTK_DICOM_DELETE;
#else
  vtkDICOMWriter(const vtkDICOMWriter&) = delete;
  void operator=(const vtkDICOMWriter&) = delete;
#endif
};
 
#endif // vtkDICOMWriter_h