diff --git a/Modules/DICOMPM/CMakeLists.txt b/Modules/DICOMPM/CMakeLists.txt new file mode 100644 index 0000000000..bb13df19c1 --- /dev/null +++ b/Modules/DICOMPM/CMakeLists.txt @@ -0,0 +1,6 @@ +MITK_CREATE_MODULE(DICOMPM + DEPENDS MitkCore MitkDICOMReader MitkModelFit MitkDICOMQI + PACKAGE_DEPENDS + PRIVATE DCMTK +) +add_subdirectory(autoload/DICOMPMIO) \ No newline at end of file diff --git a/Modules/DICOMPM/autoload/DICOMPMIO/CMakeLists.txt b/Modules/DICOMPM/autoload/DICOMPMIO/CMakeLists.txt new file mode 100644 index 0000000000..3dd397dbaf --- /dev/null +++ b/Modules/DICOMPM/autoload/DICOMPMIO/CMakeLists.txt @@ -0,0 +1,6 @@ +MITK_CREATE_MODULE(DICOMPMIO + DEPENDS MitkModelFit MitkDICOMQI MitkDICOMPM + PACKAGE_DEPENDS + PRIVATE DCMQI DCMTK + AUTOLOAD_WITH MitkCore +) diff --git a/Modules/DICOMPM/autoload/DICOMPMIO/files.cmake b/Modules/DICOMPM/autoload/DICOMPMIO/files.cmake new file mode 100644 index 0000000000..399de4a982 --- /dev/null +++ b/Modules/DICOMPM/autoload/DICOMPMIO/files.cmake @@ -0,0 +1,5 @@ +set(CPP_FILES + mitkDICOMPMIO.cpp + mitkDICOMPMIOActivator.cpp +) + diff --git a/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.cpp b/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.cpp new file mode 100644 index 0000000000..a447b1d31c --- /dev/null +++ b/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.cpp @@ -0,0 +1,252 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef __mitkDICOMPMIO__cpp +#define __mitkDICOMPMIO__cpp + +#include "mitkDICOMPMIO.h" +#include "mitkDICOMQIIOMimeTypes.h" +#include "mitkDICOMPMConstants.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "mitkParamapPresetsParser.h" + + +// us +#include +#include + +// model fit parameters +#include "mitkModelFitConstants.h" + + +namespace mitk +{ + DICOMPMIO::DICOMPMIO() + : AbstractFileIO(Image::GetStaticNameOfClass(), + mitk::MitkDICOMQIIOMimeTypes::DICOMPM_MIMETYPE_NAME(), + "DICOM PM") + + { + AbstractFileWriter::SetRanking(10); + AbstractFileReader::SetRanking(10); + this->RegisterService(); + this->AddDICOMTagsToService(); + } + + void DICOMPMIO::AddDICOMTagsToService() + { + IDICOMTagsOfInterest *toiService = GetDicomTagsOfInterestService(); + if (toiService != nullptr) + { + toiService->AddTagOfInterest(DICOMPMConstants::RWVM_SEQUENCE_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::UNITS_SEQUENCE_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::UNITS_CODE_VALUE_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::UNITS_CODE_SCHEME_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::UNITS_CODE_MEANING_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::QUANTITY_DEFINITION_SEQUENCE_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::QUANTITY_DEFINITION_VALUE_TYPE_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::QUANTITY_DEFINITION_CONCEPT_CODE_SEQUENCE_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::QUANTITY_DEFINITION_CONCEPT_CODE_VALUE_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::QUANTITY_DEFINITION_CONCEPT_CODE_SCHEME_PATH()); + toiService->AddTagOfInterest(DICOMPMConstants::QUANTITY_DEFINITION_CONCEPT_CODE_MEANING_PATH()); + } + } + + IFileIO::ConfidenceLevel DICOMPMIO::GetWriterConfidenceLevel() const + { + if (AbstractFileIO::GetWriterConfidenceLevel() == Unsupported) + return Unsupported; + + const Image *PMinput = static_cast(this->GetInput()); + if (PMinput) + { + auto modalityProperty = PMinput->GetProperty(mitk::GeneratePropertyNameForDICOMTag(0x0008, 0x0060).c_str()); + if (modalityProperty.IsNotNull()) + { + std::string modality = modalityProperty->GetValueAsString(); + if (modality == "PM") + { + return Supported; + } + else return Unsupported; + } + else return Unsupported; + } + else return Unsupported; + } + + void DICOMPMIO::Write() + { + ValidateOutputLocation(); + mitk::LocaleSwitch localeSwitch("C"); + LocalFile localFile(this); + const std::string path = localFile.GetFileName(); + + auto PMinput = dynamic_cast(this->GetInput()); + if (PMinput == nullptr) + mitkThrow() << "Cannot write non-image data"; + + // Get DICOM information from referenced image + vector> dcmDatasetsSourceImage; + std::unique_ptr readFileFormat(new DcmFileFormat()); + + try + { + // Generate dcmdataset witk DICOM tags from property list; ATM the source are the filepaths from the + // property list + mitk::StringLookupTableProperty::Pointer filesProp = + dynamic_cast(PMinput->GetProperty("referenceFiles").GetPointer()); + + if (filesProp.IsNull()) + { + mitkThrow() << "No property with dicom file path."; + return; + } + + // returns a list of all referenced files + StringLookupTable filesLut = filesProp->GetValue(); + const StringLookupTable::LookupTableType &lookUpTableMap = filesLut.GetLookupTable(); + for (auto it : lookUpTableMap) + { + const char *fileName = (it.second).c_str(); + if (readFileFormat->loadFile(fileName, EXS_Unknown).good()) + { + std::unique_ptr readDCMDataset(readFileFormat->getAndRemoveDataset()); + dcmDatasetsSourceImage.push_back(std::move(readDCMDataset)); + } + } + } + catch (const std::exception &e) + { + MITK_ERROR << "An error occurred while getting the dicom information: " << e.what() << endl; + return; + } + + mitk::Image *mitkPMImage = const_cast(PMinput); + // Cast input PMinput to itk image + ImageToItk::Pointer PMimageToItkFilter = ImageToItk::New(); + PMimageToItkFilter->SetInput(mitkPMImage); + + // Cast from original itk type to dcmqi input itk image type + typedef itk::CastImageFilter castItkImageFilterType; + castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New(); + castFilter->SetInput(PMimageToItkFilter->GetOutput()); + castFilter->Update(); + PMitkInternalImageType::Pointer itkParamapImage = castFilter->GetOutput(); + + // Create PM meta information + const std::string tmpMetaInfoFile = this->CreateMetaDataJsonFilePM(); + MITK_INFO << "tmpMetaInfoFile" << tmpMetaInfoFile; + // Convert itk PM images to dicom image + MITK_INFO << "Writing PM image: " << path << std::endl; + try + { + vector rawVecDataset; + for (const auto& dcmDataSet : dcmDatasetsSourceImage) + rawVecDataset.push_back(dcmDataSet.get()); + std::unique_ptr PMconverter(new dcmqi::ParaMapConverter()); + MITK_INFO << "PMconverter->itkimage2paramap is called"; + std::unique_ptr PMresult (PMconverter->itkimage2paramap(itkParamapImage, rawVecDataset, tmpMetaInfoFile)); + MITK_INFO << "PMconverter->itkimage2paramap is successfully finished"; + // Write dicom file + DcmFileFormat dcmFileFormat(PMresult.get()); + std::string filePath = path.substr(0, path.find_last_of(".")); + filePath = filePath + ".dcm"; + dcmFileFormat.saveFile(filePath.c_str(), EXS_LittleEndianExplicit); + + } + catch (const std::exception &e) + { + MITK_ERROR << "An error occurred during writing the DICOM Paramap: " << e.what() << endl; + return; + } + + } + + const std::string mitk::DICOMPMIO::CreateMetaDataJsonFilePM() const + { + MITK_INFO << "mitk::DICOMPMIO::CreateMetaDataJsonFilePM() is called"; + const mitk::Image *PMimage = dynamic_cast(this->GetInput()); + dcmqi::JSONParametricMapMetaInformationHandler PMhandler; + + // Get Metadata from modelFitConstants + std::string parameterName; + PMimage->GetPropertyList()->GetStringProperty(ModelFitConstants::PARAMETER_NAME_PROPERTY_NAME().c_str(), parameterName); + std::string modelName; + PMimage->GetPropertyList()->GetStringProperty(ModelFitConstants::MODEL_NAME_PROPERTY_NAME().c_str(), modelName); + + mitk::ParamapPresetsParser* pmPresets = mitk::ParamapPresetsParser::New(); + // Here the mitkParamapPresets.xml file containing the Coding Schmeme Designator and Code Value are parsed and the relevant values extracted + pmPresets->LoadPreset(); + MITK_INFO << "pmPresets->LoadPreset(): " << pmPresets->LoadPreset(); + auto pmType_parameterName = pmPresets->GetType(parameterName); + auto pmType_modelName = pmPresets->GetType(modelName); + + // Here some other + // mandatory + // TODO: where to get these from? + // TODO: AnatomicRegionSequence from Segmentation? + + PMhandler.setAnatomicRegionSequence("T-9200B", "SRT", "Prostate"); + PMhandler.setDerivedPixelContrast("TCS"); + PMhandler.setFrameLaterality("U"); + // optional + PMhandler.setQuantityValueCode(pmType_parameterName.codeValue, pmType_parameterName.codeScheme, parameterName); + PMhandler.setMeasurementMethodCode(pmType_modelName.codeValue, pmType_modelName.codeScheme, modelName); + PMhandler.setSeriesNumber("1"); + PMhandler.setInstanceNumber("1"); + PMhandler.setDerivationCode("110816", "DCM", "Time Course of Signal"); + PMhandler.setMeasurementUnitsCode("/min", "UCUM", "/m"); + PMhandler.setRealWorldValueSlope(1); + + MITK_INFO << "mitk::DICOMPMIO::CreateMetaDataJsonFilePM() is successfully finished."; + return PMhandler.getJSONOutputAsString(); + + } + + + std::vector DICOMPMIO::Read() + { + mitk::LocaleSwitch localeSwitch("C"); + std::vector result; + + return result; + } + + IFileIO::ConfidenceLevel DICOMPMIO::GetReaderConfidenceLevel() const + { + return Unsupported; + } + + + + DICOMPMIO *DICOMPMIO::IOClone() const { return new DICOMPMIO(*this); } +} // namespace + + + + + + +#endif //__mitkDICOMPMIO__cpp diff --git a/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.h b/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.h new file mode 100644 index 0000000000..898040e8df --- /dev/null +++ b/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIO.h @@ -0,0 +1,72 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef __mitkDICOMPMIO_h +#define __mitkDICOMPMIO_h + +#include +#include +#include +#include +#include + + +namespace mitk +{ + /** + * Read and Writes a LabelSetImage to a dcm file + * @ingroup Process + */ + class DICOMPMIO : public mitk::AbstractFileIO + { + public: + + typedef mitk::Image PMInputType; + typedef itk::Image PMitkInputImageType; + typedef IODFloatingPointImagePixelModule::value_type PMFloatPixelType; // input type required for DCMQI + typedef itk::Image PMitkInternalImageType; + + DICOMPMIO(); + + // -------------- AbstractFileReader ------------- + + using AbstractFileReader::Read; + + /** + * @brief Reads a number of DICOM segmentation from the file system + * @return a vector of mitk::LabelSetImages + * @throws throws an mitk::Exception if an error ocurrs + */ + virtual std::vector Read() override; + virtual ConfidenceLevel GetReaderConfidenceLevel() const override; + + // -------------- AbstractFileWriter ------------- + + virtual void Write() override; + virtual ConfidenceLevel GetWriterConfidenceLevel() const override; + + private: + DICOMPMIO *IOClone() const override; + + // -------------- DICOMPMIO specific functions ------------- + + const std::string CreateMetaDataJsonFilePM() const; + + void AddDICOMTagsToService(); + }; +} // end of namespace mitk + +#endif // __mitkDICOMPMIO_h diff --git a/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIOActivator.cpp b/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIOActivator.cpp new file mode 100644 index 0000000000..160895d71a --- /dev/null +++ b/Modules/DICOMPM/autoload/DICOMPMIO/mitkDICOMPMIOActivator.cpp @@ -0,0 +1,62 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include +#include +#include +#include +#include + +#include "mitkDICOMPMIO.h" + +#include "mitkDICOMQIIOMimeTypes.h" + +namespace mitk +{ + /** + \brief Registers services for multilabel dicom module. + */ + class DICOMPMIOActivator : public us::ModuleActivator + { + std::vector m_FileIOs; + + public: + void Load(us::ModuleContext * context) override + { + us::ServiceProperties props; + props[us::ServiceConstants::SERVICE_RANKING()] = 10; + + std::vector mimeTypes = mitk::MitkDICOMQIIOMimeTypes::Get(); + for (std::vector::const_iterator mimeTypeIter = mimeTypes.begin(), + iterEnd = mimeTypes.end(); + mimeTypeIter != iterEnd; + ++mimeTypeIter) + { + context->RegisterService(*mimeTypeIter, props); + } + m_FileIOs.push_back(new DICOMPMIO()); + } + void Unload(us::ModuleContext *) override + { + for (auto &elem : m_FileIOs) + { + delete elem; + } + } + }; +} + +US_EXPORT_MODULE_ACTIVATOR(mitk::DICOMPMIOActivator) diff --git a/Modules/DICOMPM/files.cmake b/Modules/DICOMPM/files.cmake new file mode 100644 index 0000000000..ccf01c9be9 --- /dev/null +++ b/Modules/DICOMPM/files.cmake @@ -0,0 +1,10 @@ +file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*") + +set(CPP_FILES + mitkParamapPresetsParser.cpp +) + + +set(RESOURCE_FILES + mitkParamapPresets.xml +) diff --git a/Modules/DICOMPM/include/mitkParamapPresetsParser.h b/Modules/DICOMPM/include/mitkParamapPresetsParser.h new file mode 100644 index 0000000000..8a16e47917 --- /dev/null +++ b/Modules/DICOMPM/include/mitkParamapPresetsParser.h @@ -0,0 +1,79 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef PARAMAPRPRESETS_H_HEADER +#define PARAMAPPRESETS_H_HEADER + +#include +#include +#include +#include +#include + + + +namespace mitk { + + +class MITKDICOMPM_EXPORT ParamapPresetsParser : public vtkXMLParser +{ +public: + struct Type + { + std::string codeValue; + std::string codeScheme; + Type() = default; + Type(std::string value, std::string scheme) : codeValue(value), codeScheme(scheme){} + }; + + using ParamapPrestsType = std::map; + static ParamapPresetsParser *New(); + vtkTypeMacro(ParamapPresetsParser,vtkXMLParser); + + + + bool LoadPreset(); + bool LoadPreset(const std::string& fileName); + Type GetType(const std::string& name); + ParamapPrestsType const GetTypePresets(); + void NewPresets(ParamapPrestsType & newType); + + +protected: + ParamapPresetsParser() = default; + ~ParamapPresetsParser() override = default; + +private: + //##Documentation + //## @brief method used in XLM-Reading; gets called when a start-tag is read + void StartElement (const char *elementName, const char **atts) override; + + + //##Documentation + //## @brief reads an XML-String-Attribute + std::string ReadXMLStringAttribute(const std::string& name, const char **atts); + + static const std::string PRESET; + static const std::string TYPE; + static const std::string CODE_VALUE; + static const std::string CODE_SCHEME; + + std::string m_presetName; + ParamapPrestsType m_Type; + std::string m_XmlFileName; +}; +} +#endif diff --git a/Modules/DICOMPM/resource/mitkParamapPresets.xml b/Modules/DICOMPM/resource/mitkParamapPresets.xml new file mode 100644 index 0000000000..0e37758a9d --- /dev/null +++ b/Modules/DICOMPM/resource/mitkParamapPresets.xml @@ -0,0 +1,204 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Modules/DICOMPM/src/mitkParamapPresetsParser.cpp b/Modules/DICOMPM/src/mitkParamapPresetsParser.cpp new file mode 100644 index 0000000000..83e10f5b0d --- /dev/null +++ b/Modules/DICOMPM/src/mitkParamapPresetsParser.cpp @@ -0,0 +1,130 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#include "mitkParamapPresetsParser.h" +#include + +#include "usGetModuleContext.h" +#include "usModuleContext.h" +#include "usModule.h" +#include "usModuleResource.h" +#include "usModuleResourceStream.h" + +namespace mitk { + + const std::string ParamapPresetsParser::PRESET = "preset"; + const std::string ParamapPresetsParser::TYPE = "type"; + const std::string ParamapPresetsParser::CODE_VALUE = "code_value"; + const std::string ParamapPresetsParser::CODE_SCHEME = "coding_scheme"; + + vtkStandardNewMacro(ParamapPresetsParser); + + bool ParamapPresetsParser::LoadPreset() + { + std::cout << "ParamapPresetsParser::LoadPreset() is called" << std::endl; + us::ModuleResource presetResource = us::GetModuleContext()->GetModule()->GetResource("mitkParamapPresets.xml"); + if (!presetResource) return false; + + us::ModuleResourceStream presetStream(presetResource); + vtkXMLParser::SetStream(&presetStream); + if (!vtkXMLParser::Parse()) + { +#ifdef INTERDEBUG + MITK_INFO<<"ParamapPresetsParser::LoadPreset xml file cannot parse!"< const ParamapPresetsParser::GetTypePresets() + { + return m_Type; + } + + + + + + void ParamapPresetsParser::NewPresets(std::map& newType) + { + m_Type = newType; + //this->Save(); + } + +} diff --git a/Modules/ModuleList.cmake b/Modules/ModuleList.cmake index e34b1219a1..d1449c9904 100644 --- a/Modules/ModuleList.cmake +++ b/Modules/ModuleList.cmake @@ -1,83 +1,84 @@ # The entries in the mitk_modules list must be # ordered according to their dependencies. set(MITK_MODULES Core CommandLine AppUtil RDF LegacyIO DataTypesExt Annotation LegacyGL AlgorithmsExt MapperExt DICOMReader DICOMReaderServices DICOMQI DICOMTesting SceneSerializationBase PlanarFigure ImageDenoising ImageExtraction SceneSerialization Gizmo GraphAlgorithms Multilabel ImageStatistics ContourModel SurfaceInterpolation Segmentation PlanarFigureSegmentation QtWidgets QtWidgetsExt Chart SegmentationUI MatchPointRegistration MatchPointRegistrationUI Classification GPGPU OpenIGTLink IGTBase IGT CameraCalibration OpenCL OpenCVVideoSupport QtOverlays ToFHardware ToFProcessing ToFUI PhotoacousticsHardware PhotoacousticsAlgorithms PhotoacousticsLib US USUI DicomUI Remeshing Python QtPython Persistence OpenIGTLinkUI IGTUI DicomRT RTUI IOExt XNAT TubeGraph BiophotonicsHardware DiffusionImaging TumorInvasionAnalysis BoundingShape RenderWindowManager RenderWindowManagerUI CEST BasicImageProcessing ModelFit ModelFitUI Pharmacokinetics PharmacokineticsUI + DICOMPM ) if(MITK_ENABLE_PIC_READER) list(APPEND MITK_MODULES IpPicSupportIO) endif()