vtkDICOMCompiler.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 vtkDICOMCompiler_h
#define vtkDICOMCompiler_h
 
#include "vtkObject.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 vtkStringArray;
 
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_END
#endif
 
class vtkDICOMFile;
class vtkDICOMMetaData;
class vtkDICOMCompilerInternalFriendship;
 
 
class VTKDICOM_EXPORT vtkDICOMCompiler : public vtkObject
{
public:
  static vtkDICOMCompiler *New();
 
  vtkTypeMacro(vtkDICOMCompiler, vtkObject);
 
  void PrintSelf(ostream& os, vtkIndent indent) VTK_DICOM_OVERRIDE;
 
  vtkSetStringMacro(FileName);
  vtkGetStringMacro(FileName);
 
 
  vtkSetStringMacro(SOPInstanceUID);
  vtkGetStringMacro(SOPInstanceUID);
 
 
  vtkSetStringMacro(SeriesInstanceUID);
  vtkGetStringMacro(SeriesInstanceUID);
 
 
  vtkSetStringMacro(StudyInstanceUID);
  vtkGetStringMacro(StudyInstanceUID);
 
 
  vtkSetStringMacro(ImplementationClassUID);
  vtkGetStringMacro(ImplementationClassUID);
 
 
  vtkSetStringMacro(ImplementationVersionName);
  vtkGetStringMacro(ImplementationVersionName);
 
 
  vtkSetStringMacro(SourceApplicationEntityTitle);
  vtkGetStringMacro(SourceApplicationEntityTitle);
 
 
  vtkSetStringMacro(TransferSyntaxUID);
  vtkGetStringMacro(TransferSyntaxUID);
 
  void SetMetaData(vtkDICOMMetaData *);
  vtkDICOMMetaData *GetMetaData() { return this->MetaData; }
 
  vtkSetMacro(Index, int);
  int GetIndex() { return this->Index; }
 
 
  void SetBufferSize(int size);
  int GetBufferSize() { return this->BufferSize; }
 
  virtual void WriteHeader();
 
 
  virtual void WritePixelData(const unsigned char *cp, vtkIdType size);
 
  virtual void WriteFrame(const unsigned char *cp, vtkIdType size);
 
  virtual void Close();
 
 
  virtual void CloseAndRemove();
 
  unsigned long GetErrorCode() { return this->ErrorCode; }
 
 
  void GenerateSeriesUIDs();
 
 
  vtkSetMacro(KeepOriginalPixelDataVR, bool);
  vtkBooleanMacro(KeepOriginalPixelDataVR, bool);
  vtkGetMacro(KeepOriginalPixelDataVR, bool);
 
protected:
  vtkDICOMCompiler();
  ~vtkDICOMCompiler() VTK_DICOM_OVERRIDE;
 
 
  virtual bool FlushBuffer(unsigned char* &cp, unsigned char* &ep);
 
  virtual void CompileError(const char *message);
 
  virtual void DiskFullError();
 
  void SetErrorCode(unsigned long e) { this->ErrorCode = e; }
 
  virtual bool WriteFile(vtkDICOMMetaData *data, int idx);
 
  bool WriteMetaHeader(
    unsigned char* &cp, unsigned char* &ep,
    vtkDICOMMetaData *data, int idx);
 
  bool WriteMetaData(
    unsigned char* &cp, unsigned char* &ep,
    vtkDICOMMetaData *data, int idx);
 
  bool WriteFragments();
 
  void FreeFragments();
 
  unsigned int ComputePixelDataSize();
 
  char *FileName;
  char *SOPInstanceUID;
  char *SeriesInstanceUID;
  char *StudyInstanceUID;
  char *ImplementationClassUID;
  char *ImplementationVersionName;
  char *SourceApplicationEntityTitle;
  char *TransferSyntaxUID;
  vtkDICOMMetaData *MetaData;
  vtkStringArray *SeriesUIDs;
  vtkDICOMFile *OutputFile;
  unsigned char *Buffer;
  unsigned char **FrameData;
  unsigned int *FrameLength;
  unsigned int FrameCounter;
  int BufferSize;
  int ChunkSize;
  int Index;
  bool BigEndian;
  bool Compressed;
  bool KeepOriginalPixelDataVR;
  unsigned long ErrorCode;
 
  static char StudyUID[64];
 
  // used to share FlushBuffer with internal classes
  friend class vtkDICOMCompilerInternalFriendship;
 
private:
#ifdef VTK_DICOM_DELETE
  vtkDICOMCompiler(const vtkDICOMCompiler&) VTK_DICOM_DELETE;
  void operator=(const vtkDICOMCompiler&) VTK_DICOM_DELETE;
#else
  vtkDICOMCompiler(const vtkDICOMCompiler&) = delete;
  void operator=(const vtkDICOMCompiler&) = delete;
#endif
};
 
#endif /* vtkDICOMCompiler_h */