mlEnhancedMultiFrameTools.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
 
#pragma once
 
#include "MLMLToDicomToolsSystem.h"
 
#include <mlModuleIncludes.h>
#include <DCMTree_Tree.h>
#include <DCMTree_DicomTags.h>
#include <DICOMPart16Tables.h>
 
#include <list>
 
ML_START_NAMESPACE

struct SourceFrameReference {
  SourceFrameReference() = default;

  ~SourceFrameReference(){};
  
  SourceFrameReference(DCMTree::Const_TreePtr dcmTree){ getFromDCMTree(dcmTree); }

  SourceFrameReference(const SourceFrameReference&) = default;

  SourceFrameReference & operator=(const SourceFrameReference&) = default;
  
  std::string sopClassUID;
  std::string fmeSOPClassUID;
  
  std::string sopInstanceUID;
  std::string fmeSOPInstanceUID;
  
  std::string fmeIndexOfDecomposedFrame;
  
  std::string referencedFrameNumber;
  std::string referencedSegmentNumber;
  std::string segmentNumber;
  
  std::string frameCounter;
  std::string zCoord;
  std::string tCoord;
  std::string uCoord;
  
  static const std::vector<MLuint64> rawTagIds;

  void getRawTopLevelSourceFrameReferences(DCMTree::Const_TreePtr      inputDcmTree,
                                           std::vector<std::string>    &rawTopLevelSourceFrameInfos) const;

  void setUpFromTagValueVector(const std::vector<std::string> &rawTopLevelSourceFrameReferences);
  
  void getFromDCMTree(DCMTree::Const_TreePtr inputDcmTree);
};

typedef std::vector< SourceFrameReference > SourceFrameReferenceVector;

ML_MLToDicomTools_EXPORT void setPixelMeasuresFunctionalGroupTags(DCMTree::TreePtr dcmTree, 
                                                                  const Vector2    &pixelSpacing, 
                                                                  double           sliceThickness,
                                                                  bool             addSpacingBetweenSlices=false,
                                                                  double           spacingBetweenSlices=1.0);

ML_MLToDicomTools_EXPORT void setPlanePositionFunctionalGroupTags(DCMTree::TreePtr dcmTree, 
                                                                  const Vector3    &imagePositionPatient);

ML_MLToDicomTools_EXPORT void setPlaneOrientationFunctionalGroupTags(DCMTree::TreePtr dcmTree,
                                                                     const Vector6   &imageOrientationPatient);
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
ML_MLToDicomTools_EXPORT void addCIDEntry(const char * const CIDGroupTable[][CIDGroups::NUM_CID_COLUMNS],
                                          size_t             CIDGroupTableSize,
                                          const std::string  &entryToAdd,
                                          DCMTree::TreePtr   itemTree);

ML_MLToDicomTools_EXPORT void setDerivationImageFunctionalGroupTags(DCMTree::TreePtr                 seqItemTreePtr,
                                                                    const std::vector<std::string>   &derivationCodeSequence,
                                                                    bool                             createEmpty=false,
                                                                    const SourceFrameReferenceVector &sourceFrameReferences=SourceFrameReferenceVector(),
                                                                    const size_t                     entriesToAddZ=std::string::npos,
                                                                    const size_t                     entriesToAddT=std::string::npos,
                                                                    const size_t                     entriesToAddU=std::string::npos,
                                                                    const std::string                &purposeOfReferenceCodeSequenceEntry="");

ML_MLToDicomTools_EXPORT void setFrameContentFunctionalGroupTags(DCMTree::TreePtr             dcmTree,
                                                                 const MedicalImageProperties &medImgProps,
                                                                 bool                         setTemporalPositionIndex,
                                                                 bool                         setFrameAcquisitionDateTime,
                                                                 const unsigned int           ztuPos[3],
                                                                 const unsigned int           ztuNumFrames[3]);

ML_MLToDicomTools_EXPORT void removedDuplicatedUnassignedSharedConvertedAttributes(DCMTree::TreePtr dcmTree);

ML_MLToDicomTools_EXPORT void addUnassignedSharedConvertedAttributes(DCMTree::Const_TreePtr inputDcmTree,
                                                                     DCMTree::TreePtr       dcmTree,
                                                                     bool                   removeReferencedImageSequence,
                                                                     bool                   suppressWritingUnassignedContent);

typedef std::set<std::pair<std::string, std::string>> StringPairSet;

ML_MLToDicomTools_EXPORT void getUniqueValuePairSetFromSequence(DCMTree::Const_TreePtr dcmTree,
                                                                DCMTree::RawTagId sequenceTagId,
                                                                DCMTree::RawTagId tagId1,
                                                                DCMTree::RawTagId tagId2,
                                                                StringPairSet &pairSet);

ML_MLToDicomTools_EXPORT void buildImageEvidenceSequence(DCMTree::Const_TreePtr inputDcmTree,
                                                         DCMTree::RawTagId inputSequenceTagId,
                                                         DCMTree::TreePtr dcmTree,
                                                         DCMTree::RawTagId evidenceSequenceTagId,
                                                         MLint insertionIndex,
                                                         bool scanFrames);

struct EnhancedMFObjectInfosBase {
  EnhancedMFObjectInfosBase() = default;
  EnhancedMFObjectInfosBase(const EnhancedMFObjectInfosBase&) = default;
  EnhancedMFObjectInfosBase& operator=(const EnhancedMFObjectInfosBase&) = default;
  virtual ~EnhancedMFObjectInfosBase() = default;
};

struct LegacyConvertedEnhancedMRInfos : public EnhancedMFObjectInfosBase { };

struct SegmentInfos {
  MLint startFrame;
  MLint segmentFrames;
  SubImageBox box;
};

struct EnhancedMFSEGObjectInfos : public EnhancedMFObjectInfosBase {
  std::vector<unsigned int> referencedSegmentNumbers;

  std::vector<SubImageBox> frameBoxes;

  std::vector<SegmentInfos> segmentInfos;

  std::vector<std::string> purposeOfReferenceCodeSequence;

  SourceFrameReferenceVector sourceFrameReferenceVector;

  inline bool empty() const {
    return referencedSegmentNumbers.empty() && frameBoxes.empty() && segmentInfos.empty();
  }
};

ML_MLToDicomTools_EXPORT void addMultiFrameFunctionalGroups(DCMTree::TreePtr                  dcmTree,
                                                            const ImageVector                 &frameHeapImageExtent,
                                                            const MedicalImageProperties      &medicalImageProps,
                                                            const std::vector<std::string>    &derivationCodeSequence=std::vector<std::string>(),
                                                            const EnhancedMFObjectInfosBase   &enhancedMFObjectInfos=EnhancedMFObjectInfosBase(),
                                                            DCMTree::Const_TreePtr            inputDcmTree=DCMTree::Const_TreePtr(),
                                                            std::vector<DCMTree::TagPtr>      *dicomImageTypeTags=nullptr,
                                                            std::vector<DCMTree::TagPtr>      *dicomImageDescriptionTags=nullptr,
                                                            bool                              suppressWritingUnassignedContent=false);

ML_MLToDicomTools_EXPORT void addMultiFrameDimensionTags(DCMTree::TreePtr             dcmTree,
                                                         const ImageVector            &frameHeapImageExtent,
                                                         const MedicalImageProperties &medicalImageProps);
 
// Forward internally used classes.
class DicomSegmentItem;

ML_MLToDicomTools_EXPORT std::string addAndSetMultiBinarySEGPixelDataTag(DCMTree::TreePtr resultTree,
                                                                         PagedImage &inputPagedImage,
                                                                         ImageVector &imageExtentToAdapt,
                                                                         const std::vector<DicomSegmentItem> &segmentItems,
                                                                         EnhancedMFSEGObjectInfos &enhancedMFSegmentInfos,
                                                                         bool savePaddedPixelData);

ML_MLToDicomTools_EXPORT void getSourceImageSequenceInformation(DCMTree::Const_TreePtr inputDcmTree,
                                                                const ImageVector &inputImageExtent,
                                                                SourceFrameReferenceVector &sourceFrameReferences);
 
 
ML_END_NAMESPACE