mlDicomToMLTools.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
#pragma once
 
// Local includes
#include "MLDicomToMLToolsSystem.h"
#include "mlDICOMCachedIOFileHandle.h"
#include "mlDicomFrameSelectionTools.h"
#include "mlDicomFrameSetMinMaxCalculation.h"
#include "mlDicomOverlayTools.h"
#include "mlDicomToMLSubImageTools.h"
#include "mlDICOMTagSpectTools.h"
 
// ML includes
#include <mlModuleIncludes.h>
 
// DICOM tree prototypes.
#include <DCMTree_Lib.h>
 
ML_START_NAMESPACE
 
// Forwards
class DicomMessageCollector;
class ZTUFileNameSet;
 
namespace DICOMTagTools{
  struct DicomPaletteInfo;
}
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
namespace DicomToMLTools {
 
    // Forward(s) to internally used classes.
    class DCMTreeInfo;
 
    enum FillPageMethods {
      FILL_WITH_IMG_FILE_READER_WO_DICOM = 0,  
      FILL_WITH_IMG_FILE_READER,               
      FILL_WITH_SPECTROSCOPY_DATA_TAG_DATA,    
      FILL_WITH_PIXEL_DATA_TAG_DATA,           
      FILL_WITH_DEFAULT_FILL_VAL,              
      FILL_DO_NOT_FILL                         
    };
 
    MLDICOM_TO_ML_TOOLS_EXPORT void convertToImageProperties(DCMTree::StructuredMFPtr                &baseSMFPtr,
                                                             const std::string                       &firstFileName,
                                                             PagedImage                              &resultImgProps,
                                                             FillPageMethods                         *fillPageMethod,
                                                             const ZTUFileNameSet                    *setOfFileHandles,
                                                             double                                  defaultFillValue,
                                                             CalculateMinMaxFromDicomModes           minMaxCalcMode,
                                                             const std::string                       &versionString,
                                                             bool                                    anonymize,
                                                             bool                                    removePrivateMultiFrameSQTag,
                                                             bool                                    forceOrthogonalWorldMatrix,
                                                             bool                                    copyPrivateTopLevelSrcTags,
                                                             DicomMessageCollector                   &dcmMsgCollector);
 
    MLDICOM_TO_ML_TOOLS_EXPORT size_t getVoxelSize(DCMTree::Const_TreePtr         treePtr,
                                                   double                         &voxSizeX,
                                                   double                         &voxSizeY,
                                                   double                         &voxSizeZ,
                                                   bool                           replaceOnlyIfFound,
                                                   bool                           *isPrecise,
                                                   std::vector<DCMTree::RawTagId> *usedTags,
                                                   DicomMessageCollector          &dcmMsgCollector);
 
    MLDICOM_TO_ML_TOOLS_EXPORT bool applyPaletteInfosToPagedImage(const DICOMTagTools::DicomPaletteInfo &paletteInfos, 
                                                                  PagedImage                            &pagedImage,
                                                                  const bool                            adjustToLUTType=false);
 
    MLDICOM_TO_ML_TOOLS_EXPORT bool applySubImageColorLookUp(const SubImage                        &inSubImg,
                                                             const DICOMTagTools::DicomPaletteInfo &paletteInfo,
                                                             SubImage                              &outSubImg);
 
    MLDICOM_TO_ML_TOOLS_EXPORT bool applyPhotometricInterpretationChangesToPagedImage(const DCMTree::Const_TreePtr &dcmTree, 
                                                                                      PagedImage                   &pagedImage);
 
    MLDICOM_TO_ML_TOOLS_EXPORT bool applyPhotometricInterpretationToSubImg(DCMTree::Const_TreePtr dcmTree,
                                                                           const SubImage         &inSubImg,
                                                                           const double           minVoxelValue,
                                                                           const double           maxVoxelValue,
                                                                           SubImage               &outSubImg);
    
    MLDICOM_TO_ML_TOOLS_EXPORT void getSpectDICOMImageProperties(DCMTree::Const_TreePtr treePtr,
                                                                 const std::string      &fileNameUTF8,
                                                                 PagedImage             &outInfos,
                                                                 Vector4                &rotAxisAndRadians,
                                                                 Vector3                &ipp,
                                                                 Vector3                &relMRSPositionVector,
                                                                 Vector3                &mrsPositionVector,
                                                                 Vector3                &voiVector,
                                                                 Vector3                &fovVector,
                                                                 bool                   useOldWorldMatrixCalculation,
                                                                 DicomMessageCollector  &dcmMsgCollector);
 
    MLDICOM_TO_ML_TOOLS_EXPORT bool copySpectData(SubImage                          &outSubImg,
                                                  const ImageVector                 &outImgExtent,
                                                  const DICOMTagTools::SpectComplex *mrsData,
                                                  size_t                            spectDataSizeInBytes);
 
    MLDICOM_TO_ML_TOOLS_EXPORT bool isImageFrameNotOfBits(DCMTree::Const_TreePtr treePtr);
    
    MLDICOM_TO_ML_TOOLS_EXPORT void setWorldMatrixFromDcmTree(DCMTree::Const_TreePtr treePtr,
                                                              PagedImage             &outInfos,
                                                              DicomMessageCollector  &dcmMsgCollector);
 
    MLDICOM_TO_ML_TOOLS_EXPORT MLDataType getMLDataTypeFromDCMTree(DCMTree::Const_TreePtr treePtr,
                                                                   DicomMessageCollector  &dcmMsgCollector);
 
    MLDICOM_TO_ML_TOOLS_EXPORT void checkAndCorrectImageExtentAccordingToPixelData(DCMTree::Const_TreePtr treePtr, 
                                                                                   size_t                 pixelDataSizeInBytes,
                                                                                   ImageVector            &imgExt,
                                                                                   DicomMessageCollector  &dcmMsgCollector);
 
    MLDICOM_TO_ML_TOOLS_EXPORT bool determineImageExtentsFromDCMTree(DCMTree::Const_TreePtr   treePtr,
                                                                     ImageVector              &imgExt,
                                                                     std::vector<std::string> *cDimInfos,
                                                                     bool                     overrideBadTagInfos,
                                                                     DicomMessageCollector    &dcmMsgCollector);
    
    MLDICOM_TO_ML_TOOLS_EXPORT void getAnyDICOMImageProperties(DCMTree::Const_TreePtr treePtr,
                                                               PagedImage             &outInfos,
                                                               bool                   overrideBadTagInfos,
                                                               DicomMessageCollector  &dcmMsgCollector);
    
    MLDICOM_TO_ML_TOOLS_EXPORT std::string determineBasicREGProperties(DCMTree::Const_TreePtr treePtr,
                                                                       size_t                 extent[3],
                                                                       double                 voxelSize[3],
                                                                       MLErrorCode            &errCode,
                                                                       DicomMessageCollector  &dcmMsgCollector);
 
    MLDICOM_TO_ML_TOOLS_EXPORT std::string determineREGProperties(DCMTree::Const_TreePtr treePtr,
                                                                  ImageVector            &extent,
                                                                  Vector3                &voxelSize,
                                                                  SubImage               *subImage,
                                                                  MLErrorCode            *errCode,
                                                                  DicomMessageCollector  &dcmMsgCollector);
 
    MLDICOM_TO_ML_TOOLS_EXPORT bool hasValidNonImageModality(DCMTree::Const_TreePtr treePtr);
 
    enum OutputDataTypeSelector {
      NoChange  = 0,   
      Automatic,       
      UseMLuint8,      
      UseMLint8,       
      UseMLuint16,     
      UseMLint16,      
      UseMLuint32,     
      UseMLint32,      
      UseMLFloat,      
      UseMLDouble      
    };
 
    enum { NumOutputDataTypeSelectors = UseMLDouble +1};
    
    extern MLDICOM_TO_ML_TOOLS_EXPORT const char * const OutputDataTypeSelectorsStrings[NumOutputDataTypeSelectors]; 
    
    MLDICOM_TO_ML_TOOLS_EXPORT MLDataType determineOutputVoxelType(DCMTree::StructuredMFPtr           &srcVolumeSMFTree,
                                                                   const MLDataType                   inVoxDataType,
                                                                   const SubImageBox                  &volumeBox,
                                                                   const double                       inDataRangeMin,
                                                                   const double                       inDataRangeMax,
                                                                   const OutputDataTypeSelector       voxelTypeSelector,
                                                                   const VoxelDoubleOperations        operationMode,
                                                                   const PositionSpecificDoubleVector &posDbls,
                                                                   const VoxelDoubleOperations        defaultOperationMode,
                                                                   const double                       defaultOperationDouble,
                                                                   double                             &resultRangeMin,
                                                                   double                             &resultRangeMax);
 
   MLDICOM_TO_ML_TOOLS_EXPORT void determineDCMTreeInfo(DCMTree::Const_TreePtr dcmTree,
                                                        DCMTreeInfo            &dcmTreeInfo);
 
   MLDICOM_TO_ML_TOOLS_EXPORT DCMTree::Const_StructuredMFPtr getSMFTreeFromPagedImage(const PagedImage &pImg);
};
 
ML_END_NAMESPACE