diff --git a/Modules/CEST/autoload/IO/mitkCESTIOActivator.cpp b/Modules/CEST/autoload/IO/mitkCESTIOActivator.cpp
index 7da1044d6c..78e7955706 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOActivator.cpp
+++ b/Modules/CEST/autoload/IO/mitkCESTIOActivator.cpp
@@ -1,46 +1,56 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCESTIOActivator.h"
#include "mitkCESTDICOMReaderService.h"
#include "mitkCESTGenericDICOMReaderService.h"
#include <usModuleContext.h>
#include "mitkCESTIOMimeTypes.h"
-#include "mitkIOMimeTypes.h"
namespace mitk
{
void CESTIOActivator::Load(us::ModuleContext *context)
{
us::ServiceProperties props;
props[us::ServiceConstants::SERVICE_RANKING()] = 10;
m_MimeTypes = mitk::MitkCESTIOMimeTypes::Get();
- for (std::vector<mitk::CustomMimeType *>::const_iterator mimeTypeIter = m_MimeTypes.begin(),
- iterEnd = m_MimeTypes.end();
- mimeTypeIter != iterEnd;
- ++mimeTypeIter)
+ for (auto& mimeType : m_MimeTypes)
{
- context->RegisterService(*mimeTypeIter, props);
+ if (mimeType->GetName() == mitk::MitkCESTIOMimeTypes::CEST_DICOM_WITHOUT_META_FILE_NAME())
+ { // "w/o meta" mimetype should only registered with low priority.
+ context->RegisterService(mimeType);
+ }
+ else
+ {
+ context->RegisterService(mimeType, props);
+ }
}
m_CESTDICOMReader.reset(new CESTDICOMReaderService());
- m_CESTDICOMManualReader.reset(new CESTDICOMManualReaderService(CustomMimeType(IOMimeTypes::DICOM_MIMETYPE()), "CEST DICOM Manual Reader"));
+ m_CESTDICOMManualWithMetaFileReader.reset(new CESTDICOMManualReaderService(MitkCESTIOMimeTypes::CEST_DICOM_WITH_META_FILE_MIMETYPE(), "CEST DICOM Manual Reader"));
+ m_CESTDICOMManualWithOutMetaFileReader.reset(new CESTDICOMManualReaderService(MitkCESTIOMimeTypes::CEST_DICOM_WITHOUT_META_FILE_MIMETYPE(), "CEST DICOM Manual Reader"));
}
- void CESTIOActivator::Unload(us::ModuleContext *) {}
+ void CESTIOActivator::Unload(us::ModuleContext *)
+ {
+ for (auto& elem : m_MimeTypes)
+ {
+ delete elem;
+ }
+ }
}
US_EXPORT_MODULE_ACTIVATOR(mitk::CESTIOActivator)
diff --git a/Modules/CEST/autoload/IO/mitkCESTIOActivator.h b/Modules/CEST/autoload/IO/mitkCESTIOActivator.h
index bbfd824d1d..4c34dc8a6c 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOActivator.h
+++ b/Modules/CEST/autoload/IO/mitkCESTIOActivator.h
@@ -1,41 +1,42 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKCESTIOActivator_H
#define MITKCESTIOActivator_H
#include <mitkCustomMimeType.h>
#include <usModuleActivator.h>
#include <usServiceEvent.h>
#include <memory>
namespace mitk
{
struct IFileReader;
class IDICOMTagsOfInterest;
class CESTIOActivator : public us::ModuleActivator
{
public:
void Load(us::ModuleContext *context) override;
void Unload(us::ModuleContext *context) override;
private:
std::unique_ptr<IFileReader> m_CESTDICOMReader;
- std::unique_ptr<IFileReader> m_CESTDICOMManualReader;
+ std::unique_ptr<IFileReader> m_CESTDICOMManualWithMetaFileReader;
+ std::unique_ptr<IFileReader> m_CESTDICOMManualWithOutMetaFileReader;
std::vector<mitk::CustomMimeType *> m_MimeTypes;
};
}
#endif // MITKCESTIOActivator_H
diff --git a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
index 28b696d7ea..e752e8a8ff 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
+++ b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.cpp
@@ -1,123 +1,223 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkCESTIOMimeTypes.h"
#include "mitkIOMimeTypes.h"
#include <mitkCustomTagParser.h>
#include <mitkDICOMDCMTKTagScanner.h>
#include <mitkDICOMFileReaderSelector.h>
#include <mitkLogMacros.h>
#include <itkGDCMImageIO.h>
#include <itksys/SystemTools.hxx>
namespace mitk
{
std::vector<CustomMimeType *> MitkCESTIOMimeTypes::Get()
{
std::vector<CustomMimeType *> mimeTypes;
// order matters here (descending rank for mime types)
+ mimeTypes.push_back(CEST_DICOM_WITH_META_FILE_MIMETYPE().Clone());
mimeTypes.push_back(CEST_DICOM_MIMETYPE().Clone());
+ mimeTypes.push_back(CEST_DICOM_WITHOUT_META_FILE_MIMETYPE().Clone());
return mimeTypes;
}
// Mime Types
- MitkCESTIOMimeTypes::MitkCESTDicomMimeType::MitkCESTDicomMimeType() : CustomMimeType(CEST_DICOM_MIMETYPE_NAME())
+ MitkCESTIOMimeTypes::MitkCESTDicomMimeType::MitkCESTDicomMimeType() : IOMimeTypes::BaseDicomMimeType(CEST_DICOM_MIMETYPE_NAME())
{
- this->AddExtension("gdcm");
- this->AddExtension("dcm");
- this->AddExtension("DCM");
- this->AddExtension("dc3");
- this->AddExtension("DC3");
- this->AddExtension("ima");
- this->AddExtension("img");
-
this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
this->SetComment("CEST DICOM");
}
bool MitkCESTIOMimeTypes::MitkCESTDicomMimeType::AppliesTo(const std::string &path) const
{
- bool canRead(CustomMimeType::AppliesTo(path));
+ bool canRead(IOMimeTypes::BaseDicomMimeType::AppliesTo(path));
// fix for bug 18572
// Currently this function is called for writing as well as reading, in that case
// the image information can of course not be read
// This is a bug, this function should only be called for reading.
if (!itksys::SystemTools::FileExists(path.c_str()))
{
return canRead;
}
// end fix for bug 18572
- // Ask the GDCM ImageIO class directly
- itk::GDCMImageIO::Pointer gdcmIO = itk::GDCMImageIO::New();
- canRead = gdcmIO->CanReadFile(path.c_str());
-
if (!canRead)
{
return canRead;
}
mitk::DICOMDCMTKTagScanner::Pointer scanner = mitk::DICOMDCMTKTagScanner::New();
mitk::DICOMTag siemensCESTprivateTag(0x0029, 0x1020);
mitk::StringList relevantFiles;
relevantFiles.push_back(path);
scanner->AddTag(siemensCESTprivateTag);
scanner->SetInputFiles(relevantFiles);
scanner->Scan();
mitk::DICOMTagCache::Pointer tagCache = scanner->GetScanCache();
mitk::DICOMImageFrameList imageFrameList = mitk::ConvertToDICOMImageFrameList(tagCache->GetFrameInfoList());
mitk::DICOMImageFrameInfo *firstFrame = imageFrameList.begin()->GetPointer();
std::string byteString = tagCache->GetTagValue(firstFrame, siemensCESTprivateTag).value;
if (byteString.empty()) {
return false;
}
mitk::CustomTagParser tagParser(relevantFiles[0]);
auto parsedPropertyList = tagParser.ParseDicomPropertyString(byteString);
bool mapNotEmpty = parsedPropertyList->GetMap()->size() > 0;
return mapNotEmpty;
}
MitkCESTIOMimeTypes::MitkCESTDicomMimeType *MitkCESTIOMimeTypes::MitkCESTDicomMimeType::Clone() const
{
return new MitkCESTDicomMimeType(*this);
}
MitkCESTIOMimeTypes::MitkCESTDicomMimeType MitkCESTIOMimeTypes::CEST_DICOM_MIMETYPE()
{
return MitkCESTDicomMimeType();
}
- // Names
std::string MitkCESTIOMimeTypes::CEST_DICOM_MIMETYPE_NAME()
{
// create a unique and sensible name for this mime type
static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.cest";
return name;
}
+
+ MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType::MitkCESTDicomWithMetaFileMimeType() : IOMimeTypes::BaseDicomMimeType(CEST_DICOM_WITH_META_FILE_NAME())
+ {
+ this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
+ this->SetComment("CEST DICOM");
+ }
+
+ bool MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType::AppliesTo(const std::string& path) const
+ {
+ bool canRead(IOMimeTypes::BaseDicomMimeType::AppliesTo(path));
+
+ // fix for bug 18572
+ // Currently this function is called for writing as well as reading, in that case
+ // the image information can of course not be read
+ // This is a bug, this function should only be called for reading.
+ if (!itksys::SystemTools::FileExists(path.c_str()))
+ {
+ return canRead;
+ }
+ // end fix for bug 18572
+
+ if (!canRead)
+ {
+ return canRead;
+ }
+
+ std::string dir = path;
+ if (!itksys::SystemTools::FileIsDirectory(path))
+ {
+ dir = itksys::SystemTools::GetProgramPath(path);
+ }
+
+ std::string metafilePath = dir +"/" + "CEST_META.json";
+
+ canRead = itksys::SystemTools::FileExists(metafilePath.c_str());
+
+ return canRead;
+ }
+
+ MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType* MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType::Clone() const
+ {
+ return new MitkCESTDicomWithMetaFileMimeType(*this);
+ }
+
+ MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType MitkCESTIOMimeTypes::CEST_DICOM_WITH_META_FILE_MIMETYPE()
+ {
+ return MitkCESTDicomWithMetaFileMimeType();
+ }
+
+ std::string MitkCESTIOMimeTypes::CEST_DICOM_WITH_META_FILE_NAME()
+ {
+ // create a unique and sensible name for this mime type
+ static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.cest.generic.meta";
+ return name;
+ }
+
+ MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType::MitkCESTDicomWOMetaFileMimeType() : IOMimeTypes::BaseDicomMimeType(CEST_DICOM_WITHOUT_META_FILE_NAME())
+ {
+ this->SetCategory(IOMimeTypes::CATEGORY_IMAGES());
+ this->SetComment("CEST DICOM");
+ }
+
+ bool MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType::AppliesTo(const std::string& path) const
+ {
+ bool canRead(IOMimeTypes::BaseDicomMimeType::AppliesTo(path));
+
+ // fix for bug 18572
+ // Currently this function is called for writing as well as reading, in that case
+ // the image information can of course not be read
+ // This is a bug, this function should only be called for reading.
+ if (!itksys::SystemTools::FileExists(path.c_str()))
+ {
+ return canRead;
+ }
+ // end fix for bug 18572
+
+ if (!canRead)
+ {
+ return canRead;
+ }
+
+ std::string dir = path;
+ if (!itksys::SystemTools::FileIsDirectory(path))
+ {
+ dir = itksys::SystemTools::GetProgramPath(path);
+ }
+
+ std::string metafilePath = dir + "/" + "CEST_META.json";
+
+ canRead = !itksys::SystemTools::FileExists(metafilePath.c_str());
+
+ return canRead;
+ }
+
+ MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType* MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType::Clone() const
+ {
+ return new MitkCESTDicomWOMetaFileMimeType(*this);
+ }
+
+ MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType MitkCESTIOMimeTypes::CEST_DICOM_WITHOUT_META_FILE_MIMETYPE()
+ {
+ return MitkCESTDicomWOMetaFileMimeType();
+ }
+
+ std::string MitkCESTIOMimeTypes::CEST_DICOM_WITHOUT_META_FILE_NAME()
+ {
+ // create a unique and sensible name for this mime type
+ static std::string name = IOMimeTypes::DEFAULT_BASE_NAME() + ".image.dicom.cest.generic.nometa";
+ return name;
+ }
+
}
diff --git a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.h b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.h
index e94a72adf8..a35ba83274 100644
--- a/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.h
+++ b/Modules/CEST/autoload/IO/mitkCESTIOMimeTypes.h
@@ -1,52 +1,85 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKCESTIOMIMETYPES_H
#define MITKCESTIOMIMETYPES_H
-#include "mitkCustomMimeType.h"
+#include "mitkIOMimeTypes.h"
#include <string>
namespace mitk
{
/// Provides the custom mime types for MitkCEST
class MitkCESTIOMimeTypes
{
public:
/** Mime type that parses dicom files to determine whether they are CEST dicom files.
*
* Accepts dicom files that contain the substring "CEST_Rev" (via the mitk::CustomTagParser parsing)
* in the tSequenceFileName parameter in dicom tag (0x0029, 0x1020)
*/
- class MitkCESTDicomMimeType : public CustomMimeType
+ class MitkCESTDicomMimeType : public IOMimeTypes::BaseDicomMimeType
{
public:
MitkCESTDicomMimeType();
bool AppliesTo(const std::string &path) const override;
MitkCESTDicomMimeType *Clone() const override;
};
static MitkCESTDicomMimeType CEST_DICOM_MIMETYPE();
static std::string CEST_DICOM_MIMETYPE_NAME();
+ /** Mime type that indicated generic CEST dicom files.
+ *
+ * The mime type assumes that dicom files that have a CEST_META.json file in the
+ * same directory are CEST DICOMs and relevant for this mime type.
+ */
+ class MitkCESTDicomWithMetaFileMimeType : public IOMimeTypes::BaseDicomMimeType
+ {
+ public:
+ MitkCESTDicomWithMetaFileMimeType();
+ bool AppliesTo(const std::string& path) const override;
+ MitkCESTDicomWithMetaFileMimeType* Clone() const override;
+ };
+
+ static MitkCESTDicomWithMetaFileMimeType CEST_DICOM_WITH_META_FILE_MIMETYPE();
+ static std::string CEST_DICOM_WITH_META_FILE_NAME();
+
+ /** Mime type that indicated dicom files that can be potantially read as Generic
+ * CEST but have *NO* CEST meta information.
+ *
+ * The mime type is used to offer the manual CEST loading for all DICOM images with
+ * low priority if no CEST meta file is present.
+ */
+ class MitkCESTDicomWOMetaFileMimeType : public IOMimeTypes::BaseDicomMimeType
+ {
+ public:
+ MitkCESTDicomWOMetaFileMimeType();
+ bool AppliesTo(const std::string& path) const override;
+ MitkCESTDicomWOMetaFileMimeType* Clone() const override;
+ };
+
+ static MitkCESTDicomWOMetaFileMimeType CEST_DICOM_WITHOUT_META_FILE_MIMETYPE();
+ static std::string CEST_DICOM_WITHOUT_META_FILE_NAME();
+
// Get all Mime Types
static std::vector<CustomMimeType *> Get();
private:
// purposely not implemented
MitkCESTIOMimeTypes();
MitkCESTIOMimeTypes(const MitkCESTIOMimeTypes &);
};
}
#endif // MITKCESTIOMIMETYPES_H
diff --git a/Modules/Core/include/mitkIOMimeTypes.h b/Modules/Core/include/mitkIOMimeTypes.h
index 8df3c8f990..472aaf028d 100644
--- a/Modules/Core/include/mitkIOMimeTypes.h
+++ b/Modules/Core/include/mitkIOMimeTypes.h
@@ -1,92 +1,103 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKIOMIMETYPES_H
#define MITKIOMIMETYPES_H
#include "mitkCustomMimeType.h"
#include <string>
namespace mitk
{
/**
* @ingroup IO
* @brief The IOMimeTypes class
*/
class MITKCORE_EXPORT IOMimeTypes
{
public:
- class MITKCORE_EXPORT DicomMimeType : public CustomMimeType
+
+ /** Base mime types for all kind of DICOM images, that can be reused
+ by more specific mime types based on DICOM images.*/
+ class MITKCORE_EXPORT BaseDicomMimeType : public CustomMimeType
+ {
+ public:
+ BaseDicomMimeType(const std::string &name);
+ BaseDicomMimeType(const BaseDicomMimeType& other);
+ bool AppliesTo(const std::string& path) const override;
+ BaseDicomMimeType* Clone() const override;
+ };
+
+ class MITKCORE_EXPORT DicomMimeType : public BaseDicomMimeType
{
public:
DicomMimeType();
- bool AppliesTo(const std::string &path) const override;
DicomMimeType *Clone() const override;
};
static std::vector<CustomMimeType *> Get();
static std::string DEFAULT_BASE_NAME(); // application/vnd.mitk
static std::string CATEGORY_IMAGES(); // Images
static std::string CATEGORY_SURFACES(); // Surfaces
// ------------------------------ VTK formats ----------------------------------
static CustomMimeType VTK_IMAGE_MIMETYPE(); // (mitk::Image) vti
static CustomMimeType VTK_IMAGE_LEGACY_MIMETYPE(); // (mitk::Image) vtk
static CustomMimeType VTK_PARALLEL_IMAGE_MIMETYPE(); // (mitk::Image) pvti
static CustomMimeType VTK_POLYDATA_MIMETYPE(); // (mitk::Surface) vtp, vtk
static CustomMimeType VTK_POLYDATA_LEGACY_MIMETYPE(); // (mitk::Surface) vtk
static CustomMimeType VTK_PARALLEL_POLYDATA_MIMETYPE(); // (mitk::Surface) pvtp
static CustomMimeType STEREOLITHOGRAPHY_MIMETYPE(); // (mitk::Surface) stl
static CustomMimeType WAVEFRONT_OBJ_MIMETYPE(); // (mitk::Surface) obj
static CustomMimeType STANFORD_PLY_MIMETYPE(); // (mitk::Surface) ply
static std::string STEREOLITHOGRAPHY_NAME(); // DEFAULT_BASE_NAME.stl
static std::string VTK_IMAGE_NAME(); // DEFAULT_BASE_NAME.vtk.image
static std::string VTK_IMAGE_LEGACY_NAME(); // DEFAULT_BASE_NAME.vtk.image.legacy
static std::string VTK_PARALLEL_IMAGE_NAME(); // DEFAULT_BASE_NAME.vtk.parallel.image
static std::string VTK_POLYDATA_NAME(); // DEFAULT_BASE_NAME.vtk.polydata
static std::string VTK_POLYDATA_LEGACY_NAME(); // DEFAULT_BASE_NAME.vtk.polydata.legacy
static std::string VTK_PARALLEL_POLYDATA_NAME(); // DEFAULT_BASE_NAME.vtk.parallel.polydata
static std::string WAVEFRONT_OBJ_NAME(); // DEFAULT_BASE_NAME.obj
static std::string STANFORD_PLY_NAME(); // DEFAULT_BASE_NAME.ply
// ------------------------- Image formats (ITK based) --------------------------
static CustomMimeType NRRD_MIMETYPE(); // nrrd, nhdr
static CustomMimeType NIFTI_MIMETYPE();
static CustomMimeType RAW_MIMETYPE(); // raw
static DicomMimeType DICOM_MIMETYPE();
static std::string NRRD_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.nrrd
static std::string NIFTI_MIMETYPE_NAME();
static std::string RAW_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.raw
static std::string DICOM_MIMETYPE_NAME();
// ------------------------------ MITK formats ----------------------------------
static CustomMimeType POINTSET_MIMETYPE(); // mps
static CustomMimeType GEOMETRY_DATA_MIMETYPE(); // .mitkgeometry
static std::string POINTSET_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.pointset
private:
// purposely not implemented
IOMimeTypes();
IOMimeTypes(const IOMimeTypes &);
};
}
#endif // MITKIOMIMETYPES_H
diff --git a/Modules/Core/src/IO/mitkIOMimeTypes.cpp b/Modules/Core/src/IO/mitkIOMimeTypes.cpp
index 15983508f6..801bde5c04 100644
--- a/Modules/Core/src/IO/mitkIOMimeTypes.cpp
+++ b/Modules/Core/src/IO/mitkIOMimeTypes.cpp
@@ -1,352 +1,363 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkIOMimeTypes.h"
#include "mitkCustomMimeType.h"
#include "mitkLogMacros.h"
#include "itkGDCMImageIO.h"
#include "itkMetaDataObject.h"
#include <itksys/SystemTools.hxx>
#include <itksys/Directory.hxx>
namespace mitk
{
- IOMimeTypes::DicomMimeType::DicomMimeType() : CustomMimeType(DICOM_MIMETYPE_NAME())
+ IOMimeTypes::BaseDicomMimeType::BaseDicomMimeType(const std::string& name) : CustomMimeType(name)
{
this->AddExtension("gdcm");
this->AddExtension("dcm");
this->AddExtension("DCM");
this->AddExtension("dc3");
this->AddExtension("DC3");
this->AddExtension("ima");
this->AddExtension("img");
this->SetCategory(CATEGORY_IMAGES());
this->SetComment("DICOM");
}
- bool IOMimeTypes::DicomMimeType::AppliesTo(const std::string &path) const
+ IOMimeTypes::BaseDicomMimeType::BaseDicomMimeType(const BaseDicomMimeType& other) : CustomMimeType(other.GetName())
+ {
+ }
+
+ bool IOMimeTypes::BaseDicomMimeType::AppliesTo(const std::string &path) const
{
// check whether directory or file
// if directory try to find first file within it instead
bool pathIsDirectory = itksys::SystemTools::FileIsDirectory(path);
std::string filepath = path;
if (pathIsDirectory)
{
itksys::Directory input;
input.Load(path.c_str());
std::vector<std::string> files;
for (unsigned long idx = 0; idx<input.GetNumberOfFiles(); idx++)
{
if (!itksys::SystemTools::FileIsDirectory(input.GetFile(idx)))
{
std::string fullpath = path + "/" + std::string(input.GetFile(idx));
files.push_back(fullpath.c_str());
}
}
filepath = files.front();
}
// Ask the GDCM ImageIO class directly
itk::GDCMImageIO::Pointer gdcmIO = itk::GDCMImageIO::New();
gdcmIO->SetFileName(filepath);
try {
gdcmIO->ReadImageInformation();
}
catch (const itk::ExceptionObject & /*err*/) {
return false;
}
//DICOMRT modalities have specific reader, don't read with normal DICOM readers
std::string modality;
itk::MetaDataDictionary& dict = gdcmIO->GetMetaDataDictionary();
itk::ExposeMetaData<std::string>(dict, "0008|0060", modality);
MITK_INFO << "DICOM Modality is " << modality;
if (modality == "RTSTRUCT" || modality == "RTDOSE" || modality == "RTPLAN") {
return false;
}
else {
return gdcmIO->CanReadFile(filepath.c_str());
}
}
- IOMimeTypes::DicomMimeType *IOMimeTypes::DicomMimeType::Clone() const { return new DicomMimeType(*this); }
+ IOMimeTypes::BaseDicomMimeType*IOMimeTypes::BaseDicomMimeType::Clone() const { return new BaseDicomMimeType(*this); }
+
+ IOMimeTypes::DicomMimeType::DicomMimeType() : BaseDicomMimeType(DICOM_MIMETYPE_NAME())
+ {
+ }
+
+ IOMimeTypes::DicomMimeType* IOMimeTypes::DicomMimeType::Clone() const { return new DicomMimeType(*this); }
+
std::vector<CustomMimeType *> IOMimeTypes::Get()
{
std::vector<CustomMimeType *> mimeTypes;
// order matters here (descending rank for mime types)
mimeTypes.push_back(NRRD_MIMETYPE().Clone());
mimeTypes.push_back(NIFTI_MIMETYPE().Clone());
mimeTypes.push_back(VTK_IMAGE_MIMETYPE().Clone());
mimeTypes.push_back(VTK_PARALLEL_IMAGE_MIMETYPE().Clone());
mimeTypes.push_back(VTK_IMAGE_LEGACY_MIMETYPE().Clone());
mimeTypes.push_back(DICOM_MIMETYPE().Clone());
mimeTypes.push_back(VTK_POLYDATA_MIMETYPE().Clone());
mimeTypes.push_back(VTK_PARALLEL_POLYDATA_MIMETYPE().Clone());
mimeTypes.push_back(VTK_POLYDATA_LEGACY_MIMETYPE().Clone());
mimeTypes.push_back(STEREOLITHOGRAPHY_MIMETYPE().Clone());
mimeTypes.push_back(WAVEFRONT_OBJ_MIMETYPE().Clone());
mimeTypes.push_back(STANFORD_PLY_MIMETYPE().Clone());
mimeTypes.push_back(RAW_MIMETYPE().Clone());
mimeTypes.push_back(POINTSET_MIMETYPE().Clone());
return mimeTypes;
}
CustomMimeType IOMimeTypes::VTK_IMAGE_MIMETYPE()
{
CustomMimeType mimeType(VTK_IMAGE_NAME());
mimeType.AddExtension("vti");
mimeType.SetCategory(CATEGORY_IMAGES());
mimeType.SetComment("VTK Image");
return mimeType;
}
CustomMimeType IOMimeTypes::VTK_IMAGE_LEGACY_MIMETYPE()
{
CustomMimeType mimeType(VTK_IMAGE_LEGACY_NAME());
mimeType.AddExtension("vtk");
mimeType.SetCategory(CATEGORY_IMAGES());
mimeType.SetComment("VTK Legacy Image");
return mimeType;
}
CustomMimeType IOMimeTypes::VTK_PARALLEL_IMAGE_MIMETYPE()
{
CustomMimeType mimeType(VTK_PARALLEL_IMAGE_NAME());
mimeType.AddExtension("pvti");
mimeType.SetCategory(CATEGORY_IMAGES());
mimeType.SetComment("VTK Parallel Image");
return mimeType;
}
CustomMimeType IOMimeTypes::VTK_POLYDATA_MIMETYPE()
{
CustomMimeType mimeType(VTK_POLYDATA_NAME());
mimeType.AddExtension("vtp");
mimeType.SetCategory(CATEGORY_SURFACES());
mimeType.SetComment("VTK PolyData");
return mimeType;
}
CustomMimeType IOMimeTypes::VTK_POLYDATA_LEGACY_MIMETYPE()
{
CustomMimeType mimeType(VTK_POLYDATA_LEGACY_NAME());
mimeType.AddExtension("vtk");
mimeType.SetCategory(CATEGORY_SURFACES());
mimeType.SetComment("VTK Legacy PolyData");
return mimeType;
}
CustomMimeType IOMimeTypes::VTK_PARALLEL_POLYDATA_MIMETYPE()
{
CustomMimeType mimeType(VTK_PARALLEL_POLYDATA_NAME());
mimeType.AddExtension("pvtp");
mimeType.SetCategory(CATEGORY_SURFACES());
mimeType.SetComment("VTK Parallel PolyData");
return mimeType;
}
CustomMimeType IOMimeTypes::STEREOLITHOGRAPHY_MIMETYPE()
{
CustomMimeType mimeType(STEREOLITHOGRAPHY_NAME());
mimeType.AddExtension("stl");
mimeType.SetCategory(CATEGORY_SURFACES());
mimeType.SetComment("Stereolithography");
return mimeType;
}
CustomMimeType IOMimeTypes::WAVEFRONT_OBJ_MIMETYPE()
{
CustomMimeType mimeType(WAVEFRONT_OBJ_NAME());
mimeType.AddExtension("obj");
mimeType.SetCategory(CATEGORY_SURFACES());
mimeType.SetComment("Wavefront OBJ");
return mimeType;
}
CustomMimeType IOMimeTypes::STANFORD_PLY_MIMETYPE()
{
CustomMimeType mimeType(STANFORD_PLY_NAME());
mimeType.AddExtension("ply");
mimeType.SetCategory(CATEGORY_SURFACES());
mimeType.SetComment("Stanford PLY");
return mimeType;
}
std::string IOMimeTypes::STEREOLITHOGRAPHY_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".stl";
return name;
}
std::string IOMimeTypes::WAVEFRONT_OBJ_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".obj";
return name;
}
std::string IOMimeTypes::STANFORD_PLY_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".ply";
return name;
}
std::string IOMimeTypes::DEFAULT_BASE_NAME()
{
static std::string name = "application/vnd.mitk";
return name;
}
std::string IOMimeTypes::CATEGORY_IMAGES()
{
static std::string cat = "Images";
return cat;
}
std::string IOMimeTypes::CATEGORY_SURFACES()
{
static std::string cat = "Surfaces";
return cat;
}
std::string IOMimeTypes::VTK_IMAGE_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".vtk.image";
return name;
}
std::string IOMimeTypes::VTK_IMAGE_LEGACY_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".vtk.image.legacy";
return name;
}
std::string IOMimeTypes::VTK_PARALLEL_IMAGE_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".vtk.parallel.image";
return name;
}
std::string IOMimeTypes::VTK_POLYDATA_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".vtk.polydata";
return name;
}
std::string IOMimeTypes::VTK_POLYDATA_LEGACY_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".vtk.polydata.legacy";
return name;
}
std::string IOMimeTypes::VTK_PARALLEL_POLYDATA_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".vtk.parallel.polydata";
return name;
}
CustomMimeType IOMimeTypes::NRRD_MIMETYPE()
{
CustomMimeType mimeType(NRRD_MIMETYPE_NAME());
mimeType.AddExtension("nrrd");
mimeType.AddExtension("nhdr");
mimeType.SetCategory("Images");
mimeType.SetComment("NRRD");
return mimeType;
}
CustomMimeType IOMimeTypes::NIFTI_MIMETYPE()
{
CustomMimeType mimeType(NIFTI_MIMETYPE_NAME());
mimeType.AddExtension("nii");
mimeType.AddExtension("nii.gz");
mimeType.AddExtension("hdr");
mimeType.AddExtension("hdr.gz");
mimeType.AddExtension("img");
mimeType.AddExtension("img.gz");
mimeType.AddExtension("nia");
mimeType.SetCategory("Images");
mimeType.SetComment("Nifti");
return mimeType;
}
CustomMimeType IOMimeTypes::RAW_MIMETYPE()
{
CustomMimeType mimeType(RAW_MIMETYPE_NAME());
mimeType.AddExtension("raw");
mimeType.SetCategory("Images");
mimeType.SetComment("Raw data");
return mimeType;
}
IOMimeTypes::DicomMimeType IOMimeTypes::DICOM_MIMETYPE() { return DicomMimeType(); }
std::string IOMimeTypes::NRRD_MIMETYPE_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".image.nrrd";
return name;
}
std::string IOMimeTypes::NIFTI_MIMETYPE_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".image.nifti";
return name;
}
std::string IOMimeTypes::RAW_MIMETYPE_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".image.raw";
return name;
}
std::string IOMimeTypes::DICOM_MIMETYPE_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".image.dicom";
return name;
}
CustomMimeType IOMimeTypes::POINTSET_MIMETYPE()
{
CustomMimeType mimeType(POINTSET_MIMETYPE_NAME());
mimeType.AddExtension("mps");
mimeType.SetCategory("Point Sets");
mimeType.SetComment("MITK Point Set");
return mimeType;
}
std::string IOMimeTypes::POINTSET_MIMETYPE_NAME()
{
static std::string name = DEFAULT_BASE_NAME() + ".pointset";
return name;
}
CustomMimeType IOMimeTypes::GEOMETRY_DATA_MIMETYPE()
{
mitk::CustomMimeType mimeType(DEFAULT_BASE_NAME() + ".geometrydata");
mimeType.AddExtension("mitkgeometry");
mimeType.SetCategory("Geometries");
mimeType.SetComment("GeometryData object");
return mimeType;
}
}