vtkDICOMMetaData.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 vtkDICOMMetaData_h
#define vtkDICOMMetaData_h
 
#include "vtkDataObject.h"
#include "vtkStdString.h" // For std::string
#include "vtkDICOMModule.h" // For export macro
#include "vtkDICOMConfig.h" // For configuration details
#include "vtkDICOMDataElement.h" // For method parameter
#include "vtkDICOMDictEntry.h" // For method parameter
 
// Declare VTK classes within VTK's optional namespace
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_BEGIN
#endif
 
class vtkIntArray;
 
#if defined(VTK_ABI_NAMESPACE_BEGIN)
VTK_ABI_NAMESPACE_END
#endif
 
class vtkDICOMTagPath;
 
 
class VTKDICOM_EXPORT vtkDICOMMetaData : public vtkDataObject
{
public:
  static vtkDICOMMetaData *New();
 
  vtkTypeMacro(vtkDICOMMetaData, vtkDataObject);
 
  void PrintSelf(ostream& os, vtkIndent indent) VTK_DICOM_OVERRIDE;
 
 
  int GetNumberOfInstances() { return this->NumberOfInstances; }
  void SetNumberOfInstances(int n);
 
  void Clear();
 
  void Initialize() VTK_DICOM_OVERRIDE;
 
  int GetNumberOfDataElements() {
    return this->NumberOfDataElements; }
 
  vtkDICOMDataElementIterator Begin() {
    return this->Head.Next; }
 
  vtkDICOMDataElementIterator End() {
    return &this->Tail; }
 
 
  vtkDICOMDataElementIterator Find(vtkDICOMTag tag) {
    vtkDICOMDataElement *e = this->FindDataElement(tag);
    return (e != 0 ? e : &this->Tail); }
 
  bool Has(vtkDICOMTag tag);
  bool HasAttribute(vtkDICOMTag tag) {
    return this->Has(tag); }
 
  void Erase(vtkDICOMTag tag);
  void RemoveAttribute(vtkDICOMTag tag) {
    this->Erase(tag); }
 
 
  const vtkDICOMValue &Get(vtkDICOMTag tag);
  const vtkDICOMValue &Get(const vtkDICOMTagPath &p);
  const vtkDICOMValue &GetAttributeValue(vtkDICOMTag tag) {
    return this->Get(tag); }
  const vtkDICOMValue &GetAttributeValue(const vtkDICOMTagPath &p) {
    return this->Get(p); }
 
 
  const vtkDICOMValue &Get(int idx, vtkDICOMTag tag);
  const vtkDICOMValue &Get(int idx, const vtkDICOMTagPath &p);
  const vtkDICOMValue &GetAttributeValue(int idx, vtkDICOMTag tag) {
    return this->Get(idx, tag); }
  const vtkDICOMValue &GetAttributeValue(int idx, const vtkDICOMTagPath &p) {
    return this->Get(idx, p); }
 
 
  const vtkDICOMValue &Get(int idx, int frame, vtkDICOMTag tag);
  const vtkDICOMValue &Get(int idx, int frame, const vtkDICOMTagPath &p);
  const vtkDICOMValue &GetAttributeValue(int idx, int frame, vtkDICOMTag tag) {
    return this->Get(idx, frame, tag); }
  const vtkDICOMValue &GetAttributeValue(
    int idx, int frame, const vtkDICOMTagPath &p) {
    return this->Get(idx, frame, p); }
 
 
  int GetFileIndex(int sliceIdx, int compIdx, int numComps);
  int GetFileIndex(int sliceIdx);
 
 
  int GetFrameIndex(int sliceIdx, int compIdx, int numComps);
  int GetFrameIndex(int sliceIdx);
 
 
  void Set(int idx, vtkDICOMTag tag, const vtkDICOMValue& v);
  void Set(int idx, vtkDICOMTag tag, double v);
  void Set(int idx, vtkDICOMTag tag, const std::string& v);
  void SetAttributeValue(int idx, vtkDICOMTag tag, const vtkDICOMValue& v) {
    this->Set(idx, tag, v); }
  void SetAttributeValue(int idx, vtkDICOMTag tag, double v) {
    this->Set(idx, tag, v); }
  void SetAttributeValue(int idx, vtkDICOMTag tag, const std::string& v) {
    this->Set(idx, tag, v); }
 
  void Set(vtkDICOMTag tag, const vtkDICOMValue& v);
  void Set(vtkDICOMTag tag, double v);
  void Set(vtkDICOMTag tag, const std::string& v);
  void SetAttributeValue(vtkDICOMTag tag, const vtkDICOMValue& v) {
    this->Set(tag, v); }
  void SetAttributeValue(vtkDICOMTag tag, double v) {
    this->Set(tag, v); }
  void SetAttributeValue(vtkDICOMTag tag, const std::string& v) {
    this->Set(tag, v); }
 
 
  void Set(int idx, const vtkDICOMTagPath& tag, const vtkDICOMValue& v);
  void Set(int idx, const vtkDICOMTagPath& tag, double v);
  void Set(int idx, const vtkDICOMTagPath& tag, const std::string& v);
  void SetAttributeValue(
    int idx, const vtkDICOMTagPath& tag, const vtkDICOMValue& v) {
    this->Set(idx, tag, v); }
  void SetAttributeValue(
    int idx, const vtkDICOMTagPath& tag, double v) {
    this->Set(idx, tag, v); }
  void SetAttributeValue(
    int idx, const vtkDICOMTagPath& tag, const std::string& v) {
    this->Set(idx, tag, v); }
 
  void Set(const vtkDICOMTagPath& tag, const vtkDICOMValue& v);
  void Set(const vtkDICOMTagPath& tag, double v);
  void Set(const vtkDICOMTagPath& tag, const std::string& v);
  void SetAttributeValue(const vtkDICOMTagPath& tag, const vtkDICOMValue& v) {
    this->Set(tag, v); }
  void SetAttributeValue(const vtkDICOMTagPath& tag, double v) {
    this->Set(tag, v); }
  void SetAttributeValue(const vtkDICOMTagPath& tag, const std::string& v) {
    this->Set(tag, v); }
 
 
  vtkDICOMTag ResolvePrivateTag(vtkDICOMTag ptag, const std::string& creator);
  vtkDICOMTag ResolvePrivateTag(
    int idx, vtkDICOMTag ptag, const std::string& creator);
 
 
  vtkDICOMTag ResolvePrivateTagForWriting(
    vtkDICOMTag ptag, const std::string& creator);
  vtkDICOMTag ResolvePrivateTagForWriting(
    int idx, vtkDICOMTag ptag, const std::string& creator);
 
 
  vtkDICOMDictEntry FindDictEntry(vtkDICOMTag tag);
 
  vtkDICOMVR FindDictVR(int idx, vtkDICOMTag tag);
 
  vtkDICOMValue MakeValueWithSpecificCharacterSet(
    vtkDICOMVR vr, const std::string& v);
 
  void SetFileIndexArray(vtkIntArray *fileArray);
  vtkIntArray *GetFileIndexArray() { return this->FileIndexArray; }
 
  void SetFrameIndexArray(vtkIntArray *frameArray);
  vtkIntArray *GetFrameIndexArray() { return this->FrameIndexArray; }
 
 
  void CopyAttributes(vtkDICOMMetaData *source);
 
  void ShallowCopy(vtkDataObject *source) VTK_DICOM_OVERRIDE;
  void DeepCopy(vtkDataObject *source) VTK_DICOM_OVERRIDE;
 
protected:
  vtkDICOMMetaData();
  ~vtkDICOMMetaData() VTK_DICOM_OVERRIDE;
 
  vtkDICOMDataElement *FindDataElement(vtkDICOMTag tag);
 
  vtkDICOMDataElement *FindDataElementOrInsert(vtkDICOMTag tag);
 
  int FindItemsOrInsert(
    int idx, bool useidx, const vtkDICOMTagPath& tagpath,
    vtkDICOMItem *items[]);
 
  vtkDICOMItem *FindItemOrInsert(int idx, const vtkDICOMTagPath& tagpath);
 
  const vtkDICOMValue *FindAttributeValue(int idx, vtkDICOMTag tag);
 
  const vtkDICOMValue *FindAttributeValue(
    int idx, const vtkDICOMTagPath& tagpath);
 
private:
  int NumberOfInstances;
 
  vtkDICOMDataElement **Table;
 
  vtkDICOMDataElement Head;
 
  vtkDICOMDataElement Tail;
 
  int NumberOfDataElements;
 
  vtkIntArray *FileIndexArray;
 
  vtkIntArray *FrameIndexArray;
 
#ifdef VTK_DICOM_DELETE
  vtkDICOMMetaData(const vtkDICOMMetaData&) VTK_DICOM_DELETE;
  void operator=(const vtkDICOMMetaData&) VTK_DICOM_DELETE;
#else
  vtkDICOMMetaData(const vtkDICOMMetaData&) = delete;
  void operator=(const vtkDICOMMetaData&) = delete;
#endif
};
 
#endif /* vtkDICOMMetaData_h */