vtkDICOMDirectory.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 vtkDICOMDirectory_h
#define vtkDICOMDirectory_h
 
#include "vtkAlgorithm.h"
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMConfig.h" // For configuration details
#include "vtkDICOMCharacterSet.h" // For character sets
#include "vtkVersion.h" // For changes to pipeline API
 
// Declare VTK classes within VTK's optional namespace
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_BEGIN
#endif
 
class vtkStringArray;
class vtkIntArray;
 
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_END
#endif
 
class vtkDICOMMetaData;
class vtkDICOMItem;
class vtkDICOMTag;
 
 
class VTKDICOM_EXPORT vtkDICOMDirectory : public vtkAlgorithm
{
public:
  vtkTypeMacro(vtkDICOMDirectory,vtkAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_DICOM_OVERRIDE;
  static vtkDICOMDirectory *New();
 
  enum {
    PATIENT, STUDY, SERIES, IMAGE, FRAME
  };
 
 
  void SetDirectoryName(const char *name);
  const char *GetDirectoryName() { return this->DirectoryName; }
 
 
  void SetInputFileNames(vtkStringArray *sa);
  vtkStringArray *GetInputFileNames() { return this->InputFileNames; }
 
 
  void AddInputFileNames(vtkStringArray *sa);
 
 
  void SetFilePattern(const char *pattern);
  const char *GetFilePattern() { return this->FilePattern; }
 
 
  vtkSetMacro(ScanDepth, int);
  int GetScanDepth() { return this->ScanDepth; }
 
  void SetFindQuery(const vtkDICOMItem& query);
 
 
  void SetFindLevel(int level);
  void SetFindLevelToImage() { this->SetFindLevel(IMAGE); }
  void SetFindLevelToSeries() { this->SetFindLevel(SERIES); }
  int GetFindLevel() { return this->FindLevel; }
 
 
  void Update() VTK_DICOM_OVERRIDE { this->Update(0); }
  void Update(int) VTK_DICOM_OVERRIDE;
#if (VTK_MAJOR_VERSION == 7 && VTK_MINOR_VERSION > 0) || VTK_MAJOR_VERSION > 7
  vtkTypeBool Update(vtkInformation *) VTK_DICOM_OVERRIDE {
    this->Update(); return 1; }
  vtkTypeBool Update(int i, vtkInformationVector *) VTK_DICOM_OVERRIDE {
    this->Update(i); return 1; }
#endif
 
  int GetNumberOfSeries();
 
  const vtkDICOMItem& GetSeriesRecord(int series);
 
  int GetNumberOfStudies();
 
  const vtkDICOMItem& GetStudyRecord(int study);
 
 
  const vtkDICOMItem& GetPatientRecordForStudy(int study);
 
  int GetNumberOfPatients();
 
  const vtkDICOMItem& GetPatientRecord(int patient);
 
  vtkIntArray *GetStudiesForPatient(int patient);
 
  int GetFirstSeriesForStudy(int study);
 
  int GetLastSeriesForStudy(int study);
 
  vtkStringArray *GetFileNamesForSeries(int i);
 
 
  vtkDICOMMetaData *GetMetaDataForSeries(int i);
 
 
  void SetQueryFilesToAlways() { this->SetQueryFiles(1); }
  void SetQueryFilesToNever() { this->SetQueryFiles(0); }
  void SetQueryFilesToDefault() { this->SetQueryFiles(-1); }
  vtkSetMacro(QueryFiles, int);
  int GetQueryFiles() { return this->QueryFiles; }
 
  const char *GetFileSetID() { return this->FileSetID; }
 
  const char *GetInternalFileName() { return this->InternalFileName; }
 
 
  vtkSetMacro(IgnoreDicomdir, int);
  vtkBooleanMacro(IgnoreDicomdir, int);
  int GetIgnoreDicomdir() { return this->IgnoreDicomdir; }
 
 
  vtkSetMacro(RequirePixelData, int);
  vtkBooleanMacro(RequirePixelData, int);
  int GetRequirePixelData() { return this->RequirePixelData; }
 
  vtkSetMacro(FollowSymlinks, int);
  vtkBooleanMacro(FollowSymlinks, int);
  int GetFollowSymlinks() { return this->FollowSymlinks; }
 
 
  vtkSetMacro(ShowHidden, int);
  vtkBooleanMacro(ShowHidden, int);
  int GetShowHidden() { return this->ShowHidden; }
 
 
  void SetDefaultCharacterSet(vtkDICOMCharacterSet cs);
  vtkDICOMCharacterSet GetDefaultCharacterSet() {
    return this->DefaultCharacterSet; }
 
 
  vtkSetMacro(OverrideCharacterSet, bool);
  vtkBooleanMacro(OverrideCharacterSet, bool);
  bool GetOverrideCharacterSet() {
    return this->OverrideCharacterSet; }
 
protected:
  vtkDICOMDirectory();
  ~vtkDICOMDirectory() VTK_DICOM_OVERRIDE;
 
  const char *DirectoryName;
  vtkStringArray *InputFileNames;
  const char *FilePattern;
  int QueryFiles;
  int IgnoreDicomdir;
  int RequirePixelData;
  int FollowSymlinks;
  int ShowHidden;
  int ScanDepth;
  vtkDICOMCharacterSet DefaultCharacterSet;
  bool OverrideCharacterSet;
 
  vtkTimeStamp UpdateTime;
  char *InternalFileName;
 
  virtual void Execute();
 
  virtual void FillImageRecord(vtkDICOMItem *item, vtkDICOMMetaData *meta,
                               const vtkDICOMTag *skip, size_t nskip);
 
  virtual void FillSeriesRecord(vtkDICOMItem *item, vtkDICOMMetaData *meta);
 
  virtual void FillStudyRecord(vtkDICOMItem *item, vtkDICOMMetaData *meta);
 
  virtual void FillPatientRecord(vtkDICOMItem *item, vtkDICOMMetaData *meta);
 
  virtual void SortFiles(vtkStringArray *input);
 
 
  void AddSeriesFileNames(
    int patient, int study, vtkStringArray *files,
    const vtkDICOMItem& patientRecord,
    const vtkDICOMItem& studyRecord,
    const vtkDICOMItem& seriesRecord,
    const vtkDICOMItem *imageRecords[]);
 
  void AddSeriesWithQuery(
    int patient, int study, vtkStringArray *files,
    const vtkDICOMItem& patientRecord,
    const vtkDICOMItem& studyRecord,
    const vtkDICOMItem& seriesRecord,
    const vtkDICOMItem *imageRecords[]);
 
 
  bool MatchesQuery(
    const vtkDICOMItem& record, vtkDICOMItem& result);
 
 
  int MatchesImageQuery(
    const vtkDICOMItem& record, const vtkDICOMItem& result);
 
  void RelayError(vtkObject *o, unsigned long e, void *data);
 
  void SetInternalFileName(const char *fname);
 
  void SetErrorCode(unsigned long e) VTK_DICOM_OVERRIDE {
    this->ErrorCode = e; }
 
 
  void ProcessDirectoryFile(const char *dirname, vtkDICOMMetaData *meta);
 
  void ProcessDirectory(
    const char *dirname, int depth, vtkStringArray *files);
 
  void ProcessOsirixDatabase(const char *fname);
 
  void CopyRecord(
    vtkDICOMMetaData *meta, const vtkDICOMItem *item, int instance);
 
private:
#ifdef VTK_DICOM_DELETE
  vtkDICOMDirectory(const vtkDICOMDirectory&) VTK_DICOM_DELETE;
  void operator=(const vtkDICOMDirectory&) VTK_DICOM_DELETE;
#else
  vtkDICOMDirectory(const vtkDICOMDirectory&) = delete;
  void operator=(const vtkDICOMDirectory&) = delete;
#endif
 
  struct SeriesItem;
  struct StudyItem;
  struct PatientItem;
  class SeriesVector;
  class StudyVector;
  class PatientVector;
  struct FileInfo;
  struct FileInfoPair;
  struct SeriesInfo;
  class SeriesInfoList;
  class SeriesInfoVector;
  class VisitedVector;
 
  vtkDICOMItem *Query;
  int FindLevel;
  SeriesVector *Series;
  StudyVector *Studies;
  PatientVector *Patients;
  VisitedVector *Visited;
  char *FileSetID;
  bool UsingOsirixDatabase;
 
  const vtkDICOMItem *CurrentPatientRecord;
  const vtkDICOMItem *CurrentStudyRecord;
  const vtkDICOMItem *CurrentSeriesRecord;
  const vtkDICOMItem *CurrentImageRecord;
 
  static bool CompareInstance(const FileInfo &fi1, const FileInfo &fi2);
 
  static bool CompareSeriesUIDs(const SeriesInfo *si, const char *uid);
 
  static bool CompareSeriesIds(const SeriesInfo *li1, const SeriesInfo *li2);
 
  static bool CompareSeriesInfo(const SeriesInfo &li1, const SeriesInfo &li2);
 
  static bool CompareInstanceUIDs(const FileInfoPair& p, const char *uid);
};
 
#endif