mlModuleLoaderBackends.h

Go to the documentation of this file.

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

//----------------------------------------------------------------------------------
#pragma once
 
// Local includes
#include "MLModuleLoaderBackendsSystem.h"
 
// DICOM tree prototypes
#include <DCMTree_Lib.h>
 
// ML includes
#include <mlModuleIncludes.h>
#include <mlAPI.h>
 
ML_START_NAMESPACE
 
// Forward of internally used classes.
class MLImageFormat;
class ProgressLogger;

class MLMODULE_LOADER_BACKENDS_EXPORT ModuleLoaderBackendsControl : public Module {
public:
  ModuleLoaderBackendsControl();

  ~ModuleLoaderBackendsControl();

  static const MLuint64 ML_MODULE_LOADER_NO_BACKENDS;                     
  static const MLuint64 ML_MODULE_LOADER_ALL_BACKENDS;                    
 
  static const MLuint64 ML_MODULE_LOADER_ML_IMAGE_FORMAT_BACKEND;         
  static const MLuint64 ML_MODULE_LOADER_IMAGE_LOAD_BACKEND;              
  static const MLuint64 ML_MODULE_LOADER_ITK_IMAGE_FILE_READER_BACKEND;   
  static const MLuint64 ML_MODULE_LOADER_HISTO_LOAD_BACKEND;              

  static void allow(bool allowUsage=true);

  static void setAllowed(const MLuint64 backendsMask=ML_MODULE_LOADER_ALL_BACKENDS);

  static MLuint64 getAllowed();

  ML_MODULE_CLASS_HEADER(ModuleLoaderBackendsControl);
};
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
namespace ModuleLoaderBackends {

  enum {
    InterleavedPlanarConfig = 1 
  };

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode loadWithMLImageFormat(const std::string &pageFileName,
                                                                    SubImage          &outSubImg,
                                                                    const ImageVector &corrOffset,
                                                                    MLImageFormat     **loader,
                                                                    bool              loadFullImage=false);

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode saveAsMLImageFormat(PagedImage        &imgToSave,
                                                                  const std::string &outFileName,
                                                                  const std::string &mliCompress,
                                                                  bool              updateMinMaxAfterSave);
  
  MLMODULE_LOADER_BACKENDS_EXPORT void getDCMTreeFromMLImageFile(const std::string      &mlImageFileName,
                                                                 DCMTree::Const_TreePtr &treePtr,
                                                                 size_t                 &numVols,
                                                                 MLErrorCode            &fileLoadError,
                                                                 MLErrorCode            &treeExtractError);

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode loadWithImgFileLoader(const std::string &pageFileName,
                                                                    SubImage          &outSubImg,
                                                                    const ImageVector &corrOffset,
                                                                    MLint             dcmTiffExtZ,
                                                                    const bool        isDCMTiff,
                                                                    bool              loadFullImage=false);

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode saveSubImgInFile(const SubImage    &srcSubImg,
                                                               const std::string &outFileName);

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode createAndSaveThumbNail(PagedImage        &srcImg,
                                                                     const std::string &outFile,
                                                                     MLint             ext,
                                                                     bool              useMiddleSlice=true,
                                                                     bool              buildNoPreviewImageOnInvalidImage=false);

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode loadWithMLItkImageFileReader(const std::string      &pageFileName,
                                                                           SubImage               &outSubImg,
                                                                           const ImageVector      &corrOffset,
                                                                           MLDataType             fileDataType,
                                                                           Module                 **loader,
                                                                           DCMTree::Const_TreePtr constTreePtr,
                                                                           bool                   dstIsRGB,
                                                                           std::string            *metaDataDump=nullptr,
                                                                           bool                   loadFullImage=false,
                                                                           size_t                 itkLoadDim=3,
                                                                           bool                   hideErrorPosts=false,
                                                                           const SubImageBox      &expectedImageExtent=SubImageBox());

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode loadWithHistoLoad(const std::string      &fileName,
                                                                SubImage               &outSubImg,
                                                                const ImageVector      &corrOffset,
                                                                Module                 **loaderToCreate,
                                                                bool                   loadFullImage,
                                                                PagedImage             *pagedImg=nullptr,
                                                                MLint                  level=0);

  MLMODULE_LOADER_BACKENDS_EXPORT void destroyMLImageFormatFileReaderInstance(MLImageFormat *&instance);

  MLMODULE_LOADER_BACKENDS_EXPORT std::string getImagePropertiesWithImgFileReader(const std::string &fileName,
                                                                                  PagedImage &pImgProps,
                                                                                  std::string &fileFormat);

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode getImagePropertiesWithMLImageFormatReader(const std::string &fileName,
                                                                                        PagedImage &pImgProps);
 

  MLMODULE_LOADER_BACKENDS_EXPORT MLErrorCode checkOrCreateReusableModule(const std::string              &dllName,
                                                                          const std::string              &moduleName,
                                                                          const std::vector<std::string> &expectedFields,
                                                                          Module                         **module,
                                                                          Module                         **moduleToUse);

  MLMODULE_LOADER_BACKENDS_EXPORT std::string getPreferredLoader(const std::string &fileName);
};
 
ML_END_NAMESPACE