vtkITKArchetypeImageSeriesReader.h

Go to the documentation of this file.

/*=========================================================================
 
Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.
 
See COPYRIGHT.txt
or http://www.slicer.org/copyright/copyright.txt for details.
 
Program:   vtkITK
Module:    $HeadURL$
Date:      $Date$
Version:   $Revision$
 
==========================================================================*/
 
#ifndef __vtkITKArchetypeImageSeriesReader_h
#define __vtkITKArchetypeImageSeriesReader_h
 
// VTKITK includes
#include "vtkITK.h"
 
// VTK includes
#include "vtkImageAlgorithm.h"
class vtkMatrix4x4;
 
// ITK includes
#include "itkImageIOBase.h"
#include "itkMetaDataDictionary.h"
#include "itkSpatialOrientation.h"
 
// STD includes
#include <algorithm>
#include <string>
#include <vector>

class VTK_ITK_EXPORT vtkITKArchetypeImageSeriesReader : public vtkImageAlgorithm
{
public:
  static vtkITKArchetypeImageSeriesReader* New();
  vtkTypeMacro(vtkITKArchetypeImageSeriesReader, vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  using CoordinateOrientationCode = itk::SpatialOrientationEnums::ValidCoordinateOrientations;

  vtkSetStringMacro(Archetype);
  vtkGetStringMacro(Archetype);

  unsigned int GetNumberOfFileNames();
  const std::vector<std::string>& GetFileNames();

  unsigned int AddFileName(const char* filename);
  const char* GetFileName(unsigned int n);
  void ResetFileNames();

  vtkSetVector3Macro(DefaultDataSpacing, double);
  vtkGetVector3Macro(DefaultDataSpacing, double);

  vtkSetVector3Macro(DefaultDataOrigin, double);
  vtkGetVector3Macro(DefaultDataOrigin, double);

  vtkSetMacro(FileNameSliceOffset, int);
  vtkGetMacro(FileNameSliceOffset, int);

  vtkSetMacro(FileNameSliceSpacing, int);
  vtkGetMacro(FileNameSliceSpacing, int);

  vtkSetMacro(FileNameSliceCount, int);
  vtkGetMacro(FileNameSliceCount, int);

  virtual int CanReadFile(const char* filename);

  void SetDesiredCoordinateOrientationToAxial()
  {
    this->DesiredCoordinateOrientation = CoordinateOrientationCode::ITK_COORDINATE_ORIENTATION_RAI;
    this->UseNativeCoordinateOrientation = 0;
    this->Modified();
  }
  void SetDesiredCoordinateOrientationToCoronal()
  {
    this->DesiredCoordinateOrientation = CoordinateOrientationCode::ITK_COORDINATE_ORIENTATION_RSA;
    this->UseNativeCoordinateOrientation = 0;
    this->Modified();
  }
  void SetDesiredCoordinateOrientationToSagittal()
  {
    this->DesiredCoordinateOrientation = CoordinateOrientationCode::ITK_COORDINATE_ORIENTATION_ASL;
    this->UseNativeCoordinateOrientation = 0;
    this->Modified();
  }
  void SetDesiredCoordinateOrientationToNative()
  {
    this->UseNativeCoordinateOrientation = 1;
    this->Modified();
  }
  vtkGetMacro(DesiredCoordinateOrientation, CoordinateOrientationCode);
  vtkGetMacro(UseNativeCoordinateOrientation, char);

  virtual void SetOutputScalarTypeToDouble()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_DOUBLE);
  }
  virtual void SetOutputScalarTypeToFloat()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_FLOAT);
  }
  virtual void SetOutputScalarTypeToLong()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_LONG);
  }
  virtual void SetOutputScalarTypeToUnsignedLong()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_UNSIGNED_LONG);
  }
  virtual void SetOutputScalarTypeToInt()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_INT);
  }
  virtual void SetOutputScalarTypeToUnsignedInt()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_UNSIGNED_INT);
  }
  virtual void SetOutputScalarTypeToShort()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_SHORT);
  }
  virtual void SetOutputScalarTypeToUnsignedShort()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_UNSIGNED_SHORT);
  }
  virtual void SetOutputScalarTypeToChar()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_CHAR);
  }
  virtual void SetOutputScalarTypeToUnsignedChar()
  {
    UseNativeScalarType = 0;
    this->SetOutputScalarType(VTK_UNSIGNED_CHAR);
  }
  virtual void SetOutputScalarTypeToNative()
  {
    UseNativeScalarType = 1;
    this->Modified();
  }

  void SetUseNativeOriginOn() { UseNativeOrigin = true; }

  void SetUseNativeOriginOff() { UseNativeOrigin = false; }

  enum
  {
    GDCM = 0,
    DCMTK
  };
  vtkSetClampMacro(DICOMImageIOApproach, int, vtkITKArchetypeImageSeriesReader::GDCM, vtkITKArchetypeImageSeriesReader::DCMTK);
  vtkGetMacro(DICOMImageIOApproach, int);
  void SetDICOMImageIOApproachToGDCM() { this->SetDICOMImageIOApproach(vtkITKArchetypeImageSeriesReader::GDCM); };
  void SetDICOMImageIOApproachToDCMTK() { this->SetDICOMImageIOApproach(vtkITKArchetypeImageSeriesReader::DCMTK); };

  vtkSetMacro(OutputScalarType, int);
  vtkGetMacro(OutputScalarType, int);

  vtkSetMacro(NumberOfComponents, unsigned int);
  vtkGetMacro(NumberOfComponents, unsigned int);

  vtkSetMacro(SingleFile, int);
  vtkGetMacro(SingleFile, int);

  vtkSetMacro(AnalyzeHeader, bool);
  vtkGetMacro(AnalyzeHeader, bool);

  vtkSetMacro(UseOrientationFromFile, int);
  vtkGetMacro(UseOrientationFromFile, int);

  vtkMatrix4x4* GetRasToIjkMatrix();

  vtkMatrix4x4* GetMeasurementFrameMatrix();

  vtkSetMacro(VoxelVectorType, int);
  vtkGetMacro(VoxelVectorType, int);

  const itk::MetaDataDictionary& GetMetaDataDictionary() const;
  std::vector<std::string> Tags;
  std::vector<std::string> TagValues;
  void ParseDictionary();
 
  unsigned int GetNumberOfItemsInDictionary();
  bool HasKey(char* tag);
  const char* GetNthKey(unsigned int n);
  const char* GetNthValue(unsigned int n);
  const char* GetTagValue(char* tag);

  bool GetGroupingByTags() { return GroupingByTags; }
 
  void SetGroupingByTagsOn() { GroupingByTags = true; }
 
  void SetGroupingByTagsOff() { GroupingByTags = false; }

  int GetSelectedUID() { return SelectedUID; }
 
  void SetSelectedUID(int v)
  {
    SelectedUID = v;
    SetGroupingByTagsOn();
  }

  int GetSelectedContentTime() { return SelectedContentTime; }
 
  void SetSelectedContentTime(int v)
  {
    SelectedContentTime = v;
    SetGroupingByTagsOn();
  }

  int GetSelectedTriggerTime() { return SelectedTriggerTime; }
 
  void SetSelectedTriggerTime(int v)
  {
    SelectedTriggerTime = v;
    SetGroupingByTagsOn();
  }

  int GetSelectedEchoNumbers() { return SelectedEchoNumbers; }
 
  void SetSelectedEchoNumbers(int v)
  {
    SelectedEchoNumbers = v;
    SetGroupingByTagsOn();
  }

  int GetSelectedDiffusion() { return SelectedDiffusion; }
 
  void SetSelectedDiffusion(int v)
  {
    SelectedDiffusion = v;
    SetGroupingByTagsOn();
  }

  int GetSelectedSlice() { return SelectedSlice; }
 
  void SetSelectedSlice(int v)
  {
    SelectedSlice = v;
    SetGroupingByTagsOn();
  }

  int GetSelectedOrientation() { return SelectedOrientation; }
 
  void SetSelectedOrientation(int v)
  {
    SelectedOrientation = v;
    SetGroupingByTagsOn();
  }

  unsigned int GetNumberOfSeriesInstanceUIDs() { return this->SeriesInstanceUIDs.size(); }
 
  unsigned int GetNumberOfContentTime() { return this->ContentTime.size(); }
 
  unsigned int GetNumberOfTriggerTime() { return this->TriggerTime.size(); }
 
  unsigned int GetNumberOfEchoNumbers() { return this->EchoNumbers.size(); }
 
  unsigned int GetNumberOfSliceLocation() { return this->SliceLocation.size(); }
 
  unsigned int GetNumberOfDiffusionGradientOrientation() { return this->DiffusionGradientOrientation.size(); };
 
  unsigned int GetNumberOfImageOrientationPatient() { return this->ImageOrientationPatient.size(); };
 
  unsigned int GetNumberOfImagePositionPatient() { return this->ImagePositionPatient.size(); }

  int ExistSeriesInstanceUID(const char* SeriesInstanceUID)
  {
    for (unsigned int k = 0; k < GetNumberOfSeriesInstanceUIDs(); k++)
    {
      if (this->SeriesInstanceUIDs[k].find(SeriesInstanceUID) != std::string::npos)
      {
        return k;
      }
    }
    return -1;
  }
 
  int ExistContentTime(const char* contentTime)
  {
    for (unsigned int k = 0; k < GetNumberOfContentTime(); k++)
    {
      if (this->ContentTime[k].find(contentTime) != std::string::npos)
      {
        return k;
      }
    }
    return -1;
  }
 
  int ExistTriggerTime(const char* triggerTime)
  {
    for (unsigned int k = 0; k < GetNumberOfTriggerTime(); k++)
    {
      if (this->TriggerTime[k].find(triggerTime) != std::string::npos)
      {
        return k;
      }
    }
    return -1;
  }
 
  int ExistEchoNumbers(const char* echoNumbers)
  {
    for (unsigned int k = 0; k < GetNumberOfEchoNumbers(); k++)
    {
      if (this->EchoNumbers[k].find(echoNumbers) != std::string::npos)
      {
        return k;
      }
    }
    return -1;
  }
 
  int ExistDiffusionGradientOrientation(float* dgo)
  {
    float a = 0;
    for (int n = 0; n < 3; n++)
    {
      a += dgo[n] * dgo[n];
    }
 
    for (unsigned int k = 0; k < GetNumberOfDiffusionGradientOrientation(); k++)
    {
      float b = 0;
      float c = 0;
      for (int n = 0; n < 3; n++)
      {
        b += this->DiffusionGradientOrientation[k][n] * this->DiffusionGradientOrientation[k][n];
        c += this->DiffusionGradientOrientation[k][n] * dgo[n];
      }
      c = fabs(c) / sqrt(a * b);
 
      if (c > 0.99999)
      {
        return k;
      }
    }
    return -1;
  }
 
  int ExistSliceLocation(float sliceLocation)
  {
    std::vector<float>::iterator iter = std::find(this->SliceLocation.begin(), this->SliceLocation.end(), sliceLocation);
    return iter != this->SliceLocation.end() ? std::distance(this->SliceLocation.begin(), iter) : -1;
  }
 
  int ExistImageOrientationPatient(float* directionCosine)
  {
    float a = sqrt(directionCosine[0] * directionCosine[0] + directionCosine[1] * directionCosine[1] + directionCosine[2] * directionCosine[2]);
    for (int k = 0; k < 3; k++)
    {
      directionCosine[k] /= a;
    }
    a = sqrt(directionCosine[3] * directionCosine[3] + directionCosine[4] * directionCosine[4] + directionCosine[5] * directionCosine[5]);
    for (int k = 3; k < 6; k++)
    {
      directionCosine[k] /= a;
    }
 
    for (unsigned int k = 0; k < GetNumberOfImageOrientationPatient(); k++)
    {
      std::vector<float> aVec = ImageOrientationPatient[k];
      a = sqrt(aVec[0] * aVec[0] + aVec[1] * aVec[1] + aVec[2] * aVec[2]);
      float b = (directionCosine[0] * aVec[0] + directionCosine[1] * aVec[1] + directionCosine[2] * aVec[2]) / a;
      if (b < 0.99999)
      {
        continue;
      }
 
      a = sqrt(aVec[3] * aVec[3] + aVec[4] * aVec[4] + aVec[5] * aVec[5]);
      b = (directionCosine[3] * aVec[3] + directionCosine[4] * aVec[4] + directionCosine[5] * aVec[5]) / a;
      if (b > 0.99999)
      {
        return k;
      }
    }
    return -1;
  }
 
  int ExistImagePositionPatient(float* ipp)
  {
    // Positions are the same if they are closer than this distance (in mm)
    const float tolerance = 1e-3;
    for (unsigned int k = 0; k < GetNumberOfImagePositionPatient(); k++)
    {
      float squaredDistance = 0;
      for (int n = 0; n < 3; n++)
      {
        const float difference = this->ImagePositionPatient[k][n] - ipp[n];
        squaredDistance += difference * difference;
      }
      if (squaredDistance < tolerance * tolerance)
      {
        return k;
      }
    }
    return -1;
  }

  const char* GetNthSeriesInstanceUID(unsigned int n)
  {
    if (n >= this->GetNumberOfSeriesInstanceUIDs())
    {
      return nullptr;
    }
    return this->SeriesInstanceUIDs[n].c_str();
  }
 
  const char* GetNthContentTime(unsigned int n)
  {
    if (n >= this->GetNumberOfContentTime())
    {
      return nullptr;
    }
    return this->ContentTime[n].c_str();
  }
 
  const char* GetNthTriggerTime(unsigned int n)
  {
    if (n >= this->GetNumberOfTriggerTime())
    {
      return nullptr;
    }
    return this->TriggerTime[n].c_str();
  }
 
  const char* GetNthEchoNumbers(unsigned int n)
  {
    if (n >= this->GetNumberOfEchoNumbers())
    {
      return nullptr;
    }
    return this->EchoNumbers[n].c_str();
  }
 
  float* GetNthDiffusionGradientOrientation(unsigned int n)
  {
    if (n >= this->GetNumberOfDiffusionGradientOrientation())
    {
      return nullptr;
    }
    float* dgo = new float[3];
    for (int k = 0; k < 3; k++)
    {
      dgo[k] = this->DiffusionGradientOrientation[n][k];
    }
    return dgo;
  }
 
  float GetNthSliceLocation(unsigned int n)
  {
    if (n >= this->GetNumberOfSliceLocation())
    {
      return this->SliceLocation[0];
    }
    return this->SliceLocation[0];
  }
 
  float* GetNthImageOrientationPatient(unsigned int n)
  {
    if (n >= this->GetNumberOfImageOrientationPatient())
    {
      return nullptr;
    }
    float* dgo = new float[6];
    for (int k = 0; k < 6; k++)
    {
      dgo[k] = this->ImageOrientationPatient[n][k];
    }
    return dgo;
  }
 
  float* GetNthImagePositionPatient(unsigned int n)
  {
    if (n >= this->GetNumberOfImagePositionPatient())
    {
      return nullptr;
    }
    float* ipp = new float[3];
    for (int k = 0; k < 3; k++)
    {
      ipp[k] = this->ImagePositionPatient[n][k];
    }
    return ipp;
  }

  int InsertSeriesInstanceUIDs(const char* aUID)
  {
    int k = ExistSeriesInstanceUID(aUID);
    if (k >= 0)
    {
      return k;
    }
 
    std::string aVector(aUID);
    this->SeriesInstanceUIDs.push_back(aVector);
    return (this->SeriesInstanceUIDs.size() - 1);
  }
 
  int InsertContentTime(const char* aTime)
  {
    int k = ExistContentTime(aTime);
    if (k >= 0)
    {
      return k;
    }
 
    std::string aVector(aTime);
    this->ContentTime.push_back(aVector);
    return (this->ContentTime.size() - 1);
  }
 
  int InsertTriggerTime(const char* aTime)
  {
    int k = ExistTriggerTime(aTime);
    if (k >= 0)
    {
      return k;
    }
 
    std::string aVector(aTime);
    this->TriggerTime.push_back(aVector);
    return (this->TriggerTime.size() - 1);
  }
 
  int InsertEchoNumbers(const char* aEcho)
  {
    int k = ExistEchoNumbers(aEcho);
    if (k >= 0)
    {
      return k;
    }
 
    std::string aVector(aEcho);
    this->EchoNumbers.push_back(aVector);
    return (this->EchoNumbers.size() - 1);
  }
 
  int InsertDiffusionGradientOrientation(float* a)
  {
    int k = ExistDiffusionGradientOrientation(a);
    if (k >= 0)
    {
      return k;
    }
    std::vector<float> aVector(3);
    float aMag = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
    for (k = 0; k < 3; k++)
    {
      aVector[k] = a[k] / aMag;
    }
 
    this->DiffusionGradientOrientation.push_back(aVector);
    return (this->DiffusionGradientOrientation.size() - 1);
  }

  int InsertSliceLocation(float a)
  {
    int k = ExistSliceLocation(a);
    if (k >= 0)
    {
      return k;
    }
 
    this->SliceLocation.push_back(a);
    return (this->SliceLocation.size() - 1);
  }

  int InsertNextSliceLocation()
  {
    int size = this->SliceLocation.size();
    this->SliceLocation.push_back(size > 0 ? this->SliceLocation.back() + 1 : 0.f);
    return size;
  }
 
  int InsertImageOrientationPatient(float* a)
  {
    int k = ExistImageOrientationPatient(a);
    if (k >= 0)
    {
      return k;
    }
    std::vector<float> aVector(6);
    float aMag = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
    float bMag = sqrt(a[3] * a[3] + a[4] * a[4] + a[5] * a[5]);
    for (k = 0; k < 3; k++)
    {
      aVector[k] = a[k] / aMag;
      aVector[k + 3] = a[k + 3] / bMag;
    }
 
    this->ImageOrientationPatient.push_back(aVector);
    return (this->ImageOrientationPatient.size() - 1);
  }
 
  int InsertImagePositionPatient(float* a)
  {
    int k = ExistImagePositionPatient(a);
    if (k >= 0)
    {
      return k;
    }
 
    std::vector<float> aVector(3);
    for (unsigned int i = 0; i < 3; i++)
    {
      aVector[i] = a[i];
    }
    this->ImagePositionPatient.push_back(aVector);
    return (this->ImagePositionPatient.size() - 1);
  }
 
  void AnalyzeDicomHeaders();
 
  void AssembleNthVolume(int n);
  int AssembleVolumeContainingArchetype();
 
  void GroupFiles(int idxSeriesInstanceUID,
                  int idxContentTime,
                  int idxTriggerTime,
                  int idxEchoNumbers,
                  int idxDiffusionGradientOrientation,
                  int idxSliceLocation,
                  int idxImageOrientationPatient);
 
  const char* GetNthFileName(int idxSeriesInstanceUID,
                             int idxContentTime,
                             int idxTriggerTime,
                             int idxEchoNumbers,
                             int idxDiffusionGradientOrientation,
                             int idxSliceLocation,
                             int idxImageOrientationPatient,
                             int n);
 
  static bool ReadMeasurementFrameMatrixFromMetaDataDictionary(const itk::MetaDataDictionary& dictionary, vtkMatrix4x4* measurementFrameMatrix);

  static bool IsListPixelComponentTypeInMetaDataDictionary(const itk::MetaDataDictionary& dictionary);

  static bool IsNifti2File(const char* fileName);

  static itk::ImageIOBase::Pointer CreateDICOMImageIO(int dicomImageIOApproach);
 
protected:
  vtkITKArchetypeImageSeriesReader();
  ~vtkITKArchetypeImageSeriesReader() override;

  static std::string GetMetaDataWithoutSpaces(const itk::MetaDataDictionary& dict, const std::string& tag);

  itk::ImageIOBase::Pointer GetImageIO(const char* filename);

  void ReportFileReadError(const std::string& fileName, const std::string& errorDetails);
 
  char* Archetype;
  int SingleFile;
  int UseOrientationFromFile;
  int DataExtent[6];
 
  int OutputScalarType;
  unsigned int NumberOfComponents;
 
  std::vector<double> MetaDataScalarRangeMinima;
  std::vector<double> MetaDataScalarRangeMaxima;
  void GetScalarRangeMetaDataKeys(itk::ImageIOBase::Pointer imageIO, std::string range_keys[2]);
  void SetMetaDataScalarRangeToPointDataInfo(vtkImageData* data);
 
  double DefaultDataSpacing[3];
  double DefaultDataOrigin[3];
  float ScanAxis[3];
  float ScanOrigin[3];
 
  int FileNameSliceOffset;
  int FileNameSliceSpacing;
  int FileNameSliceCount;
 
  vtkMatrix4x4* RasToIjkMatrix;
  vtkMatrix4x4* MeasurementFrameMatrix;
 
  char UseNativeCoordinateOrientation;
  char UseNativeScalarType;
  bool UseNativeOrigin;
 
  int DICOMImageIOApproach;
 
  bool GroupingByTags;
  int SelectedUID;
  int SelectedContentTime;
  int SelectedTriggerTime;
  int SelectedEchoNumbers;
  int SelectedDiffusion;
  int SelectedSlice;
  int SelectedOrientation;
 
  unsigned int IndexArchetype;
 
  std::vector<std::string> FileNames;
  std::vector<std::pair<double, int>> FileNameSliceKey;
  CoordinateOrientationCode DesiredCoordinateOrientation;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  itk::MetaDataDictionary Dictionary;

 
  std::vector<std::string> AllFileNames;
  bool AnalyzeHeader;
  bool IsOnlyFile;
  bool ArchetypeIsDICOM;
 
  std::vector<std::string> SeriesInstanceUIDs;
  std::vector<std::string> ContentTime;
  std::vector<std::string> TriggerTime;
  std::vector<std::string> EchoNumbers;
  std::vector<std::vector<float>> DiffusionGradientOrientation;
  std::vector<float> SliceLocation;
  std::vector<std::vector<float>> ImageOrientationPatient;
  std::vector<std::vector<float>> ImagePositionPatient;

  std::vector<long int> IndexSeriesInstanceUIDs;
  std::vector<long int> IndexContentTime;
  std::vector<long int> IndexTriggerTime;
  std::vector<long int> IndexEchoNumbers;
  std::vector<long int> IndexDiffusionGradientOrientation;
  std::vector<long int> IndexSliceLocation;
  std::vector<long int> IndexImageOrientationPatient;
  std::vector<long int> IndexImagePositionPatient;
 
  int VoxelVectorType;
 
private:
  vtkITKArchetypeImageSeriesReader(const vtkITKArchetypeImageSeriesReader&) = delete;
  void operator=(const vtkITKArchetypeImageSeriesReader&) = delete;
};
 
#endif