vtkDICOMSliceSorter.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 vtkDICOMSliceSorter_h
#define vtkDICOMSliceSorter_h
 
#include "vtkObject.h"
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMConfig.h" // For configuration details
#include "vtkDICOMTag.h" // For vtkDICOMTag
 
// Declare VTK classes within VTK's optional namespace
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_BEGIN
#endif
 
class vtkIntArray;
class vtkStringArray;
 
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_END
#endif
 
class vtkDICOMMetaData;
 
 
class VTKDICOM_EXPORT vtkDICOMSliceSorter : public vtkObject
{
public:
  vtkTypeMacro(vtkDICOMSliceSorter,vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_DICOM_OVERRIDE;
  static vtkDICOMSliceSorter *New();
 
 
  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; }
 
 
  void SetMetaData(vtkDICOMMetaData *meta);
  vtkDICOMMetaData *GetMetaData() { return this->MetaData; }
 
 
  vtkGetMacro(RepeatsAsTime, int);
  vtkSetMacro(RepeatsAsTime, int);
  vtkBooleanMacro(RepeatsAsTime, int);
 
 
  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);
 
 
  void SetTimeTag(vtkDICOMTag tag);
  vtkDICOMTag GetTimeTag() { return this->TimeTag; }
 
 
  void SetTimeSequence(vtkDICOMTag tag);
  vtkDICOMTag GetTimeSequence() { return this->TimeSequence; }
 
 
  vtkGetMacro(ReverseSlices, int);
  vtkSetMacro(ReverseSlices, int);
  vtkBooleanMacro(ReverseSlices, int);
 
  double GetSliceSpacing() { return this->SliceSpacing; }
 
  void Update();
 
protected:
  vtkDICOMSliceSorter();
  ~vtkDICOMSliceSorter() VTK_DICOM_OVERRIDE;
 
  // Sort the input files, put the sort in the supplied arrays.
  virtual void SortFiles(vtkIntArray *fileArray, vtkIntArray *frameArray);
 
  // The meta data for the image.
  vtkDICOMMetaData *MetaData;
 
  // An array to convert slice indices to input files
  vtkIntArray *FileIndexArray;
 
  // An array to convert slice indices to input frames
  vtkIntArray *FrameIndexArray;
 
  // An array that holds the stack IDs.
  vtkStringArray *StackIDs;
 
  // Time dimension variables.
  int RepeatsAsTime;
  int TimeAsVector;
  int TimeDimension;
  int DesiredTimeIndex;
  double TimeSpacing;
 
  // The stack to load.
  char DesiredStackID[20];
 
  // Whether to reverse the slice order.
  int ReverseSlices;
  double SliceSpacing;
 
  // The tags to use for time information.
  vtkDICOMTag TimeTag;
  vtkDICOMTag TimeSequence;
 
private:
#ifdef VTK_DICOM_DELETE
  vtkDICOMSliceSorter(const vtkDICOMSliceSorter&) VTK_DICOM_DELETE;
  void operator=(const vtkDICOMSliceSorter&) VTK_DICOM_DELETE;
#else
  vtkDICOMSliceSorter(const vtkDICOMSliceSorter&) = delete;
  void operator=(const vtkDICOMSliceSorter&) = delete;
#endif
};
 
#endif