mlDICOMGetTools.h

Go to the documentation of this file.

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

//----------------------------------------------------------------------------------
#pragma once
 
#include "MLDICOMTagsSystem.h"
 
#include <FMEThirdPartyWarningsDisable.h>
#include <list>
#include <set>
#include <string>
#include <tuple>
#include <vector>
#include <FMEThirdPartyWarningsRestore.h>
 
#include <mlLinearAlgebra.h>
#include <mlScaleShiftData.h>
 
// DICOM Tree prototypes.
#include <DCMTree_Lib.h>
 
ML_START_NAMESPACE
 
// Forwards
class DicomMessageCollector;
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
namespace DICOMTagTools {
  
MLDICOMTags_EXPORT std::string    createInstanceUID(bool useFMEUIDPrefix=false);

MLDICOMTags_EXPORT bool           looksLikeValidDICOMUID(const std::string &uidStrToCheck);

MLDICOMTags_EXPORT bool           isValidCSVrCharacter(const char ch);

MLDICOMTags_EXPORT bool           looksLikeValidCSVrValue(const std::string &codedString,
                                                          std::string *explanation=nullptr);

MLDICOMTags_EXPORT void           deepSearchTags(DCMTree::Const_TreePtr              treePtr,
                                                 const DCMTree::TagId               &tagId,
                                                 const size_t                        numTagsToFind,
                                                 std::vector<DCMTree::Const_TagPtr> &tagVector);

MLDICOMTags_EXPORT void           deepSearchTags(DCMTree::TreePtr             treePtr,
                                                 const DCMTree::TagId         &tagId,
                                                 const size_t                 numTagsToFind,
                                                 std::vector<DCMTree::TagPtr> &tagVector);

MLDICOMTags_EXPORT bool           deepSearchTag(DCMTree::Const_TreePtr treePtr, 
                                                const DCMTree::TagId   &tagId, 
                                                DCMTree::Const_TagPtr  &result);

MLDICOMTags_EXPORT bool           deepSearchTag(DCMTree::TreePtr     treePtr, 
                                                const DCMTree::TagId &tagId, 
                                                DCMTree::TagPtr      &result);
 

MLDICOMTags_EXPORT bool           deepSearchTag(DCMTree::Const_TreePtr treePtr, 
                                                const std::string      &tagIdStr, 
                                                DCMTree::Const_TagPtr  &result);

MLDICOMTags_EXPORT bool           deepSearchTag(DCMTree::TreePtr  treePtr, 
                                                const std::string &tagIdStr, 
                                                DCMTree::TagPtr   &result);

MLDICOMTags_EXPORT const DCMTree::TreePtrVector *getSequenceItemTreePtrVector(DCMTree::Const_TreePtr dcmMFTree,
                                                                              DCMTree::RawTagId      sequenceTagId);

MLDICOMTags_EXPORT std::string getTagValue(DCMTree::Const_TreePtr treePtr,
                                           DCMTree::RawTagId tagId,
                                           bool useNumericTagValueSorting);

MLDICOMTags_EXPORT size_t getTripleTag(DCMTree::Const_TreePtr treePtr,
                                       DCMTree::RawTagId tagId,
                                       double &ippX, double &ippY, double &ippZ,
                                       double initX, double initY, double initZ);

MLDICOMTags_EXPORT size_t getHexTag(DCMTree::Const_TreePtr treePtr,
                                    DCMTree::RawTagId tagId,
                                    double &ippX1, double &ippY1, double &ippZ1,
                                    double &ippX2, double &ippY2, double &ippZ2,
                                    double initX1, double initY1, double initZ1,
                                    double initX2, double initY2, double initZ2);

MLDICOMTags_EXPORT std::string isValidDICOMDate(std::string str,
                                                bool allowEmptyStrings = true, 
                                                bool allowOldFormat    = true);

MLDICOMTags_EXPORT std::string isValidDICOMTime(const std::string &str, 
                                                bool allowEmptyStrings = true);

MLDICOMTags_EXPORT std::pair<std::string, bool> checkDICOMPersonName(const std::string &str);

MLDICOMTags_EXPORT std::string getCompressionDescription(DCMTree::Const_TreePtr treePtr,
                                                         bool *isRetired=nullptr);

MLDICOMTags_EXPORT std::string isLossyCompressed(DCMTree::Const_TreePtr treePtr);

MLDICOMTags_EXPORT bool isCompressed(DCMTree::Const_TreePtr treePtr);

MLDICOMTags_EXPORT std::string getTransferSyntaxUIDAsString(DCMTree::Const_TreePtr treePtr,
                                                            bool searchOnlyOnTopLevel=false);

MLDICOMTags_EXPORT bool isJPEG2000Compressed(DCMTree::Const_TreePtr treePtr);

MLDICOMTags_EXPORT size_t getImagePositionPatient(DCMTree::Const_TreePtr treePtr,
                                                  double &ippX,
                                                  double &ippY,
                                                  double &ippZ,
                                                  bool   replaceOnlyIfFound);

MLDICOMTags_EXPORT size_t getImageOrientationPatient(DCMTree::Const_TreePtr treePtr,
                                                     double &iopX1,
                                                     double &iopY1,
                                                     double &iopZ1,
                                                     double &iopX2,
                                                     double &iopY2,
                                                     double &iopZ2);
 

enum OrientationType
{
  InvalidOrientation = 0  , 
  Axial                   , 
  Prone                   , 
  Cranial                 , 
  Coronal                 , 
  Sagittal                , 
  AlmostAxial             , 
  AlmostCoronal           , 
  AlmostSagittal          , 
  LessAlmostAxial         , 
  LessAlmostCoronal       , 
  LessAlmostSagittal      , 
  Oblique                 , 
  OtherOrientation        , 
  NoValues                , 
  NotApplicable           , 
 
  NumberOfOrientationTypes 
};

  extern const char *const OrientationName[NumberOfOrientationTypes];

MLDICOMTags_EXPORT std::string getHumanReadableImageOrientationPatient(DCMTree::Const_TreePtr dcmTree,
                                                                       int                    *resultOType=nullptr);

MLDICOMTags_EXPORT ScaleShiftData getRescaleSlopeInterceptAsScaleShift(DCMTree::Const_TreePtr treePtr);

MLDICOMTags_EXPORT DCMTree::Const_TagPtr getAnyPixelDataTag(DCMTree::Const_TreePtr treePtr, 
                                                            bool searchRecursivly=false);

MLDICOMTags_EXPORT DCMTree::PixelData getPixelDataPtrFromTree(DCMTree::Const_TreePtr treePtr,
                                                              size_t                 *valSizeInBytes,
                                                              DicomMessageCollector  &dcmMsgCollector);

MLDICOMTags_EXPORT bool hasMFPixelDataTag(DCMTree::Const_TreePtr treePtr,
                                          DCMTree::Const_TagPtr &tagPtr);

MLDICOMTags_EXPORT const DCMTree::MFPixelTag* getAsMFPixelPtr(DCMTree::Const_TagPtr tag);

MLDICOMTags_EXPORT const boost::shared_array<unsigned char> getPixelDataFrame(DCMTree::Const_TagPtr pixTag,
                                                                              boost::uint32_t       frameIdx);

MLDICOMTags_EXPORT bool usesNegativeNMStacking(DCMTree::Const_TreePtr treePtr);

MLDICOMTags_EXPORT bool hasNegativeSliceSpacing(DCMTree::Const_TreePtr treePtr);
        
MLDICOMTags_EXPORT bool hasAtMostOneFrameInSMFGrid(const DCMTree::StructuredMFPtr &smfTree);

MLDICOMTags_EXPORT bool hasAtMostOneFrameInSMFGrid(const DCMTree::Const_StructuredMFPtr &smfTree);

MLDICOMTags_EXPORT bool isBitImageDICOM(DCMTree::Const_TreePtr treePtr);

MLDICOMTags_EXPORT bool updateMinMaxFromDICOMTags(DCMTree::Const_TreePtr treePtr,
                                                  MLdouble               &minPixVal,
                                                  MLdouble               &maxPixVal);

MLDICOMTags_EXPORT bool getDoubleFromTag(DCMTree::Const_TagPtr tagPtr, double &returnDbl);

MLDICOMTags_EXPORT bool getDoubleVectorFromTag(DCMTree::Const_TagPtr tagPtr, std::vector<double> &returnDbls);

MLDICOMTags_EXPORT bool getVector2FromTag(DCMTree::Const_TagPtr tagPtr, Vector2 &returnVec);

MLDICOMTags_EXPORT bool getVector3FromTag(DCMTree::Const_TagPtr tagPtr, Vector3 &returnVec);

MLDICOMTags_EXPORT bool getVector6FromTag(DCMTree::Const_TagPtr tagPtr, Vector6 &returnVec);

MLDICOMTags_EXPORT bool get4x4DoubleMatrixFromTag(DCMTree::Const_TagPtr tagPtr, Matrix4 &returnMat);

MLDICOMTags_EXPORT DCMTree::TagPtr getTagIfItExists(DCMTree::TreePtr dcmTree,
                                                    DCMTree::TagId   tagId,
                                                    std::string      *errStr=nullptr);

MLDICOMTags_EXPORT DCMTree::TreePtr cloneDCMTree(DCMTree::Const_TreePtr dcmTree,
                                                 std::string            *errStr);

MLDICOMTags_EXPORT unsigned int findPrivateTagGroup(DCMTree::TreePtr  dcmTree,
                                                    const std::string &privateCreatorString);

MLDICOMTags_EXPORT unsigned int searchPrivateCreator(DCMTree::TreePtr  dcmTree,
                                                     const std::string &privateCreatorString="",
                                                     MLuint16          desiredPrivateGroupId=0x09,
                                                     MLuint8           desiredPrivateElementGroupId=0x10);

MLDICOMTags_EXPORT DCMTree::Const_TagPtr getPrivateFMETag(DCMTree::RawTagId      lowerEightBitOfElementId,
                                                          DCMTree::Const_TreePtr dcmTree);

MLDICOMTags_EXPORT bool getTopLevelSOPUID(DCMTree::Const_TreePtr dcmTree,
                                          std::string &sopUIDStr,
                                          const unsigned short fmeSOPElementUID,
                                          const DCMTree::RawTagId sopUID,
                                          bool tryEnhancedSOPClassUIDReconstruction=false);

MLDICOMTags_EXPORT void getTagStringValuesFromSequence(DCMTree::RawTagId      rawTagId,
                                                       DCMTree::Const_TagPtr  sequenceInWhichToSearch,
                                                       std::string            &tagValuesStringListToExtend,
                                                       const std::string      &sep,
                                                       std::set<std::string>  *makeUniqueSet=nullptr,
                                                       bool                   searchAsLower8BitOfPrivateFMETag=false);

MLDICOMTags_EXPORT DCMTree::Const_TagPtr getMeVisStructuredMFDimensionSequence(DCMTree::Const_TreePtr dcmTree);

MLDICOMTags_EXPORT DCMTree::Const_TagPtr getPrivateTag(const std::string      &privateCreatorString,
                                                       unsigned short         groupId,
                                                       DCMTree::RawTagId      lowerEightBitOfElementId,
                                                       DCMTree::Const_TreePtr dcmTree);

MLDICOMTags_EXPORT bool isPhilips3D(DCMTree::Const_TreePtr treePtr, MLint *spatialExtent=nullptr);

MLDICOMTags_EXPORT unsigned int getNumberOfFrames(DCMTree::Const_TreePtr dcmTree, 
                                                  unsigned int *fromTagOnly=nullptr);

MLDICOMTags_EXPORT void extractTagValuesFromPerFrameAndMeVisMFSequence(DCMTree::RawTagId rawTagId,
                                                                       DCMTree::Const_TreePtr dcmTree,
                                                                       std::string &tagValuesStringListToExtend,
                                                                       bool alsoAddTopLevelTags,
                                                                       const std::string &sep,
                                                                       std::set<std::string>  *makeUniqueSet=nullptr);

MLDICOMTags_EXPORT void getTagStringValuesFromSMFSequence(DCMTree::Const_TreePtr               inputDcmTree,
                                                          const std::vector<MLuint64>          &rawTagIds,
                                                          bool                                 appendFrameCount,
                                                          bool                                 appendCoords,
                                                          std::list<std::vector<std::string> > &tagValuesListToExtend);

MLDICOMTags_EXPORT void getTagStringValuesFromTopLevel(DCMTree::Const_TreePtr      inputDcmTree,
                                                       const std::vector<MLuint64> &rawTagIds,
                                                       std::vector<std::string>    &rootEntries);

MLDICOMTags_EXPORT std::string checkForMultipleSeriesInstanceUIDs(DCMTree::Const_TreePtr dcmTree);

MLDICOMTags_EXPORT std::string checkForExpectedModality(DCMTree::Const_TreePtr inTree,
                                                        const std::string &modalityValue);

MLDICOMTags_EXPORT std::string checkFor8Or16BitIntType(MLDataType dType,
                                                       const std::string &errMsgSuffix=" at input 0 for Enhanced MR Image");

MLDICOMTags_EXPORT std::string checkForMinMaxRangeInDataType(const double minVal,
                                                             const double maxVal,
                                                             MLDataType dType,
                                                             const std::string &errMsgSuffix=" at input 0");

MLDICOMTags_EXPORT std::string checkFor32BitRangedInputImage(const ImageVector &inImgExt, MLDataType dType);
 
};
 
ML_END_NAMESPACE