diff --git a/Modules/BasicImageProcessing/CMakeLists.txt b/Modules/BasicImageProcessing/CMakeLists.txt new file mode 100644 index 0000000000..d60fb0247a --- /dev/null +++ b/Modules/BasicImageProcessing/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(MiniApps) diff --git a/Modules/BasicImageProcessing/MiniApps/CLPolyToNrrd.cpp b/Modules/BasicImageProcessing/MiniApps/CLPolyToNrrd.cpp new file mode 100644 index 0000000000..3681b8f260 --- /dev/null +++ b/Modules/BasicImageProcessing/MiniApps/CLPolyToNrrd.cpp @@ -0,0 +1,108 @@ +/*=================================================================== + +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 mitkCLPolyToNrrd_cpp +#define mitkCLPolyToNrrd_cpp + +#include "time.h" +#include + +#include +#include +#include +#include + +#include "mitkCommandLineParser.h" + +#include +#include +#include +#include +#include + + + +typedef itk::Image< double, 3 > FloatImageType; +typedef itk::Image< unsigned char, 3 > MaskImageType; + +int main(int argc, char* argv[]) +{ + mitkCommandLineParser parser; + parser.setArgumentPrefix("--", "-"); + // required params + parser.addArgument("polydata", "p", mitkCommandLineParser::InputDirectory, "Input Polydata", "Path to the input VTK polydata", us::Any(), false); + parser.addArgument("image", "i", mitkCommandLineParser::OutputDirectory, "Input Image", "Image which defines the dimensions of the Segmentation", us::Any(), false); + parser.addArgument("output", "o", mitkCommandLineParser::InputFile, "Output file", "Output files. Two files are create, a .nrrd image and a 3d-vtk.", us::Any(), false); + // Miniapp Infos + parser.setCategory("Classification Tools"); + parser.setTitle("2D-Polydata to Nrrd Segmentation"); + parser.setDescription("Creates a Nrrd segmentation based on a 2d-vtk polydata."); + parser.setContributor("MBI"); + + std::map parsedArgs = parser.parseArguments(argc, argv); + + if (parsedArgs.size()==0) + { + return EXIT_FAILURE; + } + if ( parsedArgs.count("help") || parsedArgs.count("h")) + { + return EXIT_SUCCESS; + } + + mitk::BaseData::Pointer data = mitk::IOUtil::LoadBaseData(parsedArgs["polydata"].ToString()); + mitk::Image::Pointer image = mitk::IOUtil::LoadImage(parsedArgs["image"].ToString()); + + //MITK_INFO << data; + mitk::Surface::Pointer surf = dynamic_cast(data.GetPointer()); + vtkSmartPointer circle = surf->GetVtkPolyData(); + + vtkSmartPointer extruder = + vtkSmartPointer::New(); + + extruder->SetInputData(circle); + image->GetGeometry()->GetSpacing()[2]; + extruder->SetScaleFactor(1.); + extruder->SetExtrusionTypeToNormalExtrusion(); + extruder->SetVector(0, 0, image->GetGeometry()->GetSpacing()[2]); + extruder->Update(); + surf->SetVtkPolyData(extruder->GetOutput()); + + mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New(); + surfaceToImageFilter->MakeOutputBinaryOn(); + surfaceToImageFilter->SetInput(surf); + surfaceToImageFilter->SetImage(image); + surfaceToImageFilter->Update(); + mitk::Image::Pointer resultImage = surfaceToImageFilter->GetOutput(); + + mitk::Convert2Dto3DImageFilter::Pointer multiFilter = mitk::Convert2Dto3DImageFilter::New(); + multiFilter->SetInput(resultImage); + multiFilter->Update(); + resultImage = multiFilter->GetOutput(); + + std::string saveAs = parsedArgs["output"].ToString(); + MITK_INFO << "Save as: " << saveAs; + saveAs = saveAs + ".vtk"; + mitk::IOUtil::SaveSurface(surf.GetPointer(),saveAs); + + saveAs = parsedArgs["output"].ToString(); + MITK_INFO << "Save as: " << saveAs; + saveAs = saveAs + ".nrrd"; + mitk::IOUtil::SaveImage(resultImage,saveAs); + + return 0; +} + +#endif \ No newline at end of file diff --git a/Modules/BasicImageProcessing/MiniApps/CLSimpleVoxelClassification.cpp b/Modules/BasicImageProcessing/MiniApps/CLSimpleVoxelClassification.cpp new file mode 100644 index 0000000000..9befddf770 --- /dev/null +++ b/Modules/BasicImageProcessing/MiniApps/CLSimpleVoxelClassification.cpp @@ -0,0 +1,225 @@ +/*=================================================================== + +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 +#include +#include +#include + +#include +#include +#include + +// CTK +#include "mitkCommandLineParser.h" + + + + +int main(int argc, char* argv[]) +{ + // Setup CLI Module parsable interface + mitkCommandLineParser parser; + parser.setTitle("Simple Random Forest Classifier"); + parser.setCategory("Classification"); + parser.setDescription("Learns and predicts classes"); + parser.setContributor("MBI"); + + parser.setArgumentPrefix("--", "-"); + // Add command line argument names + parser.addArgument("help", "h", mitkCommandLineParser::Bool, "Show options"); + parser.addArgument("loadFile", "l", mitkCommandLineParser::InputFile, + "DataCollection File"); + parser.addArgument( + "colIds", "c", mitkCommandLineParser::String, + "Patient Identifiers from DataCollection used for training"); + parser.addArgument("testId", "t", mitkCommandLineParser::String, + "Patient Identifier from DataCollection used for testing"); + parser.addArgument("features", "b", mitkCommandLineParser::String, + "Features"); + parser.addArgument("stats", "s", mitkCommandLineParser::String, + "Output file for stats"); + parser.addArgument("treeDepth", "d", mitkCommandLineParser::Int, + "limits tree depth"); + parser.addArgument("forestSize", "f", mitkCommandLineParser::Int, + "number of trees"); + parser.addArgument("configName", "n", mitkCommandLineParser::String, + "human readable name for configuration"); + parser.addArgument("output", "o", mitkCommandLineParser::OutputDirectory, + "output folder for results"); + + parser.addArgument("classmap", "m", mitkCommandLineParser::String, + "name of class that is to be learnt"); + + + std::map parsedArgs = parser.parseArguments(argc, argv); + // Show a help message + if (parsedArgs.size()==0 || parsedArgs.count("help") || parsedArgs.count("h")) { + std::cout << parser.helpText(); + return EXIT_SUCCESS; + } + + // Default values + bool useStatsFile = false; + unsigned int forestSize = 8; + unsigned int treeDepth = 10; + std::string configName = ""; + std::string outputFolder = ""; + + std::vector features; + std::vector trainingIds; + std::vector testingIds; + std::vector loadIds; // features + masks needed for training and evaluation + std::string outputFile; + std::string classMap; + std::string xmlFile; + std::ofstream experimentFS; + + // Parse input parameters + { + if (parsedArgs.count("colIds") || parsedArgs.count("c")) { + std::istringstream ss(us::any_cast(parsedArgs["colIds"])); + std::string token; + + while (std::getline(ss, token, ',')) + trainingIds.push_back(token); + } + + if (parsedArgs.count("output") || parsedArgs.count("o")) { + outputFolder = us::any_cast(parsedArgs["output"]); + } + + if (parsedArgs.count("classmap") || parsedArgs.count("m")) { + classMap = us::any_cast(parsedArgs["classmap"]); + } + + if (parsedArgs.count("configName") || parsedArgs.count("n")) { + configName = us::any_cast(parsedArgs["configName"]); + } + + if (parsedArgs.count("features") || parsedArgs.count("b")) { + std::istringstream ss(us::any_cast(parsedArgs["features"])); + std::string token; + + while (std::getline(ss, token, ',')) + features.push_back(token); + } + + if (parsedArgs.count("treeDepth") || parsedArgs.count("d")) { + treeDepth = us::any_cast(parsedArgs["treeDepth"]); + } + + + if (parsedArgs.count("forestSize") || parsedArgs.count("f")) { + forestSize = us::any_cast(parsedArgs["forestSize"]); + } + + if (parsedArgs.count("stats") || parsedArgs.count("s")) { + useStatsFile = true; + experimentFS.open(us::any_cast(parsedArgs["stats"]).c_str(), + std::ios_base::app); + } + + + if (parsedArgs.count("testId") || parsedArgs.count("t")) { + std::istringstream ss(us::any_cast(parsedArgs["testId"])); + std::string token; + + while (std::getline(ss, token, ',')) + testingIds.push_back(token); + } + + for (unsigned int i = 0; i < features.size(); i++) { + loadIds.push_back(features.at(i)); + } + loadIds.push_back(classMap); + + if (parsedArgs.count("stats") || parsedArgs.count("s")) { + outputFile = us::any_cast(parsedArgs["stats"]); + } + + if (parsedArgs.count("loadFile") || parsedArgs.count("l")) { + xmlFile = us::any_cast(parsedArgs["loadFile"]); + } else { + MITK_ERROR << parser.helpText(); + return EXIT_FAILURE; + } + } + + mitk::DataCollection::Pointer trainCollection; + mitk::DataCollection::Pointer testCollection; + { + mitk::CollectionReader colReader; + // Load only relevant images + colReader.SetDataItemNames(loadIds); + colReader.AddSubColIds(testingIds); + testCollection = colReader.LoadCollection(xmlFile); + colReader.ClearDataElementIds(); + colReader.ClearSubColIds(); + colReader.SetDataItemNames(loadIds); + colReader.AddSubColIds(trainingIds); + trainCollection = colReader.LoadCollection(xmlFile); + } + + ////////////////////////////////////////////////////////////////////////////// + // If required do Training.... + ////////////////////////////////////////////////////////////////////////////// + //mitk::DecisionForest forest; + + mitk::VigraRandomForestClassifier::Pointer forest = mitk::VigraRandomForestClassifier::New(); + + forest->SetTreeCount(forestSize); + forest->SetMaximumTreeDepth(treeDepth); + + + // create feature matrix + auto trainDataX = mitk::DCUtilities::DC3dDToMatrixXd(trainCollection, features, classMap); + // create label matrix + auto trainDataY = mitk::DCUtilities::DC3dDToMatrixXi(trainCollection, classMap, classMap); + + forest->Train(trainDataX, trainDataY); + + + // prepare feature matrix for test case + auto testDataX = mitk::DCUtilities::DC3dDToMatrixXd(testCollection,features, classMap); + auto testDataNewY = forest->Predict(testDataX); + + + mitk::DCUtilities::MatrixToDC3d(testDataNewY, testCollection, "RESULT", classMap); + + Eigen::MatrixXd Probs = forest->GetPointWiseProbabilities(); + + + Eigen::MatrixXd prob0 = Probs.col(0); + Eigen::MatrixXd prob1 = Probs.col(1); + + mitk::DCUtilities::MatrixToDC3d(prob0, testCollection,"prob0", classMap); + mitk::DCUtilities::MatrixToDC3d(prob1, testCollection,"prob1", classMap); + + + std::vector outputFilter; + mitk::CollectionWriter::ExportCollectionToFolder(testCollection, + outputFolder + "/result_collection.xml", + outputFilter); + return EXIT_SUCCESS; +} diff --git a/Modules/BasicImageProcessing/MiniApps/CMakeLists.txt b/Modules/BasicImageProcessing/MiniApps/CMakeLists.txt new file mode 100644 index 0000000000..20f05b6695 --- /dev/null +++ b/Modules/BasicImageProcessing/MiniApps/CMakeLists.txt @@ -0,0 +1,36 @@ +option(BUILD_BasicImageProcessingMiniApps "Build commandline tools for basic image processing" OFF) + +if(BUILD_BasicImageProcessingMiniApps OR MITK_BUILD_ALL_APPS) + + + include_directories( + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_BINARY_DIR} + ) + + # list of miniapps + # if an app requires additional dependencies + # they are added after a "^^" and separated by "_" + set(basicimageprocessingminiapps + Dicom2Nrrd^^ + CLPolyToNrrd^^ + CLSimpleVoxelClassification^^MitkDataCollection_MitkCLVigraRandomForest + ) + + foreach(basicimageprocessingminiapp ${basicimageprocessingminiapps}) + # extract mini app name and dependencies + string(REPLACE "^^" "\\;" miniapp_info ${basicimageprocessingminiapp}) + set(miniapp_info_list ${miniapp_info}) + list(GET miniapp_info_list 0 appname) + list(GET miniapp_info_list 1 raw_dependencies) + string(REPLACE "_" "\\;" dependencies "${raw_dependencies}") + set(dependencies_list ${dependencies}) + + mitkFunctionCreateCommandLineApp( + NAME ${appname} + DEPENDS MitkCore MitkCLCore ${dependencies_list} + PACKAGE_DEPENDS Qt5|Core + ) + endforeach() + +endif() diff --git a/Modules/DiffusionImaging/MiniApps/Dicom2Nrrd.cpp b/Modules/BasicImageProcessing/MiniApps/Dicom2Nrrd.cpp similarity index 78% rename from Modules/DiffusionImaging/MiniApps/Dicom2Nrrd.cpp rename to Modules/BasicImageProcessing/MiniApps/Dicom2Nrrd.cpp index 9d0f6d82e1..e9773c6a1d 100644 --- a/Modules/DiffusionImaging/MiniApps/Dicom2Nrrd.cpp +++ b/Modules/BasicImageProcessing/MiniApps/Dicom2Nrrd.cpp @@ -1,88 +1,103 @@ /*=================================================================== 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 "mitkDicomSeriesReader.h" #include "mitkProperties.h" #include "mitkCommandLineParser.h" #include "mitkIOUtil.h" using namespace std; +std::string const ReplaceString(std::string subject, const std::string& search, + const std::string& replace) { + size_t pos = 0; + while ((pos = subject.find(search, pos)) != std::string::npos) { + subject.replace(pos, search.length(), replace); + pos += replace.length(); + } + return subject; +} + int main(int argc, char* argv[]) { mitkCommandLineParser parser; parser.setTitle("Dicom Loader"); parser.setCategory("Preprocessing Tools"); parser.setDescription(""); parser.setContributor("MBI"); parser.setArgumentPrefix("--","-"); // Add command line argument names parser.addArgument("help", "h",mitkCommandLineParser::Bool, "Help:", "Show this help text"); parser.addArgument("input", "i", mitkCommandLineParser::InputDirectory, "Input folder:", "Input folder",us::Any(),false); parser.addArgument("output", "o", mitkCommandLineParser::OutputFile, "Output file:", "Output file",us::Any(),false); map parsedArgs = parser.parseArguments(argc, argv); if (parsedArgs.size()==0) return EXIT_FAILURE; // Show a help message if ( parsedArgs.count("help") || parsedArgs.count("h")) { std::cout << parser.helpText(); return EXIT_SUCCESS; } std::string inputFolder = us::any_cast(parsedArgs["input"]); std::string outFileName = us::any_cast(parsedArgs["output"]); //check if DICOMTags have been set as property for mitk::Image mitk::DicomSeriesReader::FileNamesGrouping seriesInFiles = mitk::DicomSeriesReader::GetSeries( inputFolder, true ); - std::list images; + std::vector images; std::map fileMap; // TODO sort series UIDs, implementation of map iterator might differ on different platforms (or verify this is a standard topic??) for (mitk::DicomSeriesReader::FileNamesGrouping::const_iterator seriesIter = seriesInFiles.begin(); seriesIter != seriesInFiles.end(); ++seriesIter) { mitk::DicomSeriesReader::StringContainer files = seriesIter->second.GetFilenames(); mitk::DataNode::Pointer node = mitk::DicomSeriesReader::LoadDicomSeries( files ); if (node.IsNotNull()) { mitk::Image::Pointer image = dynamic_cast( node->GetData() ); images.push_back( image ); fileMap.insert( std::pair(image,files)); } } // WARN: EXPECT ONLY ONE ITEM PER FOLDER - for ( std::list::const_iterator imageIter = images.begin(); - imageIter != images.end(); - ++imageIter ) + //for ( auto imageIter = images.begin(); + // imageIter != images.end(); + // ++imageIter ) + //{ + for (std::size_t index = 0; index < images.size(); ++index) { - const mitk::Image::Pointer image = *imageIter; - mitk::IOUtil::SaveImage(image,outFileName); + std::string indexString = std::to_string(index); + std::string newOutFileName = ReplaceString(outFileName, "%ID%", indexString); + + mitk::Image::Pointer image = images[index]; + mitk::IOUtil::SaveImage(image, newOutFileName); } return EXIT_SUCCESS; } diff --git a/Modules/Classification/CLCore/include/mitkConfigFileReader.h b/Modules/Classification/CLCore/include/mitkConfigFileReader.h index b033a5bf29..b0826a7701 100644 --- a/Modules/Classification/CLCore/include/mitkConfigFileReader.h +++ b/Modules/Classification/CLCore/include/mitkConfigFileReader.h @@ -1,206 +1,206 @@ /*=================================================================== 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 ConfigFileReader_h #define ConfigFileReader_h #include #include #include #include #include class ConfigFileReader { protected: typedef std::map ContentType; typedef std::map > ListContentType; ContentType m_ConfigContent; ListContentType m_ListContent; std::map m_ListSize; std::string Trim(std::string const& source, char const * delim = " \t\r\n") { std::string result(source); std::string::size_type index = result.find_last_not_of(delim); if(index != std::string::npos) result.erase(++index); index = result.find_first_not_of(delim); if(index != std::string::npos) result.erase(0, index); else result.erase(); return result; } std::string RemoveComment(std::string const& source, char const * delim = "#;") { std::string result(source); std::string::size_type index = result.find_first_of(delim); if(index != std::string::npos) result.erase(++index); return Trim(result); } std::string ListIndex(std::string const& section, unsigned int index) const { std::stringstream stream; stream << section << "/" << index; std::string result = stream.str(); std::transform(result.begin(), result.end(), result.begin(), ::tolower); return result; } std::string ContentIndex(std::string const& section, std::string const& entry) const { std::string result = section + '/' + entry; std::transform(result.begin(), result.end(), result.begin(), ::tolower); return result; } std::string ListSizeIndex(std::string const& section) const { std::string result = section; std::transform(result.begin(), result.end(), result.begin(), ::tolower); return result; } public: ConfigFileReader(std::string const& configFile) { ReadFile (configFile); } void ReadFile(std::string const& filePath) { std::ifstream file(filePath.c_str()); ReadStream(file); file.close(); } void ReadStream (std::istream& stream) { std::string line; std::string name; std::string value; std::string inSection; bool inConfigSection = true; - int posEqual; + std::size_t posEqual; while (std::getline(stream,line)) { line = RemoveComment(line, "#"); if (! line.length()) continue; if (line[0] == '[') { inConfigSection = true; inSection = Trim(line.substr(1,line.find(']')-1)); continue; } if(line[0] == '{') { std::string address = Trim(line.substr(1,line.find('}')-1)); inSection = ListIndex(address, ListSize(address,0)); m_ListSize[ListSizeIndex(address)]++; inConfigSection = false; continue; } if (inConfigSection) { posEqual=line.find('='); name = Trim(line.substr(0,posEqual)); value = Trim(line.substr(posEqual+1)); m_ConfigContent[ContentIndex(inSection, name)]=value; } else { m_ListContent[inSection].push_back(Trim(line)); } } } std::string Value(std::string const& section, std::string const& entry) const { std::string index = ContentIndex(section,entry); if (m_ConfigContent.find(index) == m_ConfigContent.end()) throw "Entry doesn't exist " + section + entry; return m_ConfigContent.find(index)->second; } std::string Value(const std::string & section, const std::string & entry, const std::string& standard) { try { return Value(section, entry); } catch (const char *) { m_ConfigContent[ContentIndex(section, entry)] = standard; return standard; } } int IntValue(const std::string & section, const std::string & entry) const { int result; std::stringstream stream (Value(section, entry)); stream >> result; return result; } int IntValue(const std::string & section, const std::string & entry, int standard) { try { return IntValue(section, entry); } catch (const char *) { std::stringstream stream; stream << standard; m_ConfigContent[ContentIndex(section, entry)] = stream.str(); return standard; } } std::vector Vector(std::string const& section, unsigned int index) const { if (m_ListContent.find(ListIndex(section, index)) == m_ListContent.end()) throw "Entry doesn't exist " + section; return m_ListContent.find(ListIndex(section,index))->second; } unsigned int ListSize(std::string const& section) const { if (m_ListSize.find(ListSizeIndex(section)) == m_ListSize.end()) throw "Entry doesn't exist " + section; return m_ListSize.find(ListSizeIndex(section))->second; } unsigned int ListSize(std::string const& section, unsigned int standard) { try { return ListSize(ListSizeIndex(section)); } catch (...) { m_ListSize[ListSizeIndex(section)] = standard; return standard; } } }; #endif \ No newline at end of file diff --git a/Modules/Classification/CLVigraRandomForest/include/mitkRandomForestIO.h b/Modules/Classification/CLVigraRandomForest/include/mitkRandomForestIO.h index 83233fd736..1abe06d2c0 100644 --- a/Modules/Classification/CLVigraRandomForest/include/mitkRandomForestIO.h +++ b/Modules/Classification/CLVigraRandomForest/include/mitkRandomForestIO.h @@ -1,65 +1,66 @@ /*=================================================================== 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 _MITK_DecisionForestFileIO__H_ #define _MITK_DecisionForestFileIO__H_ #include -#include "vigra/random_forest.hxx" +//#include "vigra/random_forest.hxx" +#include namespace mitk { /** * Writes vigra based mitk::DecisionForest * @ingroup Process */ class RandomForestFileIO : public mitk::AbstractFileIO { public: RandomForestFileIO(); RandomForestFileIO(const mitk::RandomForestFileIO& other); virtual ~RandomForestFileIO(); using AbstractFileIO::Write; virtual void Write(); using AbstractFileIO::Read; virtual std::vector > Read(); virtual ConfidenceLevel GetReaderConfidenceLevel() const; virtual ConfidenceLevel GetWriterConfidenceLevel() const; protected: mutable vigra::RandomForest m_rf; // DecisionForestFileIO(const DecisionForestFileIO& other); // virtual mitk::DecisionForestFileIO* Clone() const; private: virtual AbstractFileIO* IOClone() const; }; } // end of namespace mitk #endif diff --git a/Modules/DiffusionImaging/MiniApps/CMakeLists.txt b/Modules/DiffusionImaging/MiniApps/CMakeLists.txt index 722f2b79f2..3e2c75bca2 100755 --- a/Modules/DiffusionImaging/MiniApps/CMakeLists.txt +++ b/Modules/DiffusionImaging/MiniApps/CMakeLists.txt @@ -1,59 +1,53 @@ if(BUILD_DiffusionMiniApps OR MITK_BUILD_ALL_APPS) # needed include directories include_directories( ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ) # list of diffusion miniapps # if an app requires additional dependencies # they are added after a "^^" and separated by "_" set( diffusionminiapps NetworkCreation^^MitkFiberTracking_MitkConnectomics NetworkStatistics^^MitkConnectomics Fiberfox^^MitkFiberTracking MultishellMethods^^MitkFiberTracking PeaksAngularError^^MitkFiberTracking PeakExtraction^^MitkFiberTracking FiberExtraction^^MitkFiberTracking FiberProcessing^^MitkFiberTracking FiberDirectionExtraction^^MitkFiberTracking # LocalDirectionalFiberPlausibility^^MitkFiberTracking # HAS TO USE NEW PEAK IMAGE FORMAT StreamlineTracking^^MitkFiberTracking GibbsTracking^^MitkFiberTracking TractometerMetrics^^MitkFiberTracking FileFormatConverter^^MitkFiberTracking DFTraining^^MitkFiberTracking # DFTracking^^MitkFiberTracking TractDensity^^MitkFiberTracking ) foreach(diffusionminiapp ${diffusionminiapps}) # extract mini app name and dependencies string(REPLACE "^^" "\\;" miniapp_info ${diffusionminiapp}) set(miniapp_info_list ${miniapp_info}) list(GET miniapp_info_list 0 appname) list(GET miniapp_info_list 1 raw_dependencies) string(REPLACE "_" "\\;" dependencies "${raw_dependencies}") set(dependencies_list ${dependencies}) mitkFunctionCreateCommandLineApp( NAME ${appname} DEPENDS MitkCore MitkDiffusionCore ${dependencies_list} PACKAGE_DEPENDS ITK ) endforeach() - # This mini app does not depend on mitkDiffusionImaging at all - mitkFunctionCreateCommandLineApp( - NAME Dicom2Nrrd - DEPENDS MitkCore ${dependencies_list} - ) - if(EXECUTABLE_IS_ENABLED) MITK_INSTALL_TARGETS(EXECUTABLES ${EXECUTABLE_TARGET}) endif() endif() diff --git a/Modules/ModuleList.cmake b/Modules/ModuleList.cmake index bf1084ad4a..70f08e7c2f 100644 --- a/Modules/ModuleList.cmake +++ b/Modules/ModuleList.cmake @@ -1,84 +1,85 @@ # The entries in the mitk_modules list must be # ordered according to their dependencies. set(mitk_modules Core CommandLine AppUtil DCMTesting RDF LegacyIO DataTypesExt Annotation LegacyGL AlgorithmsExt MapperExt DICOMReader DICOMReaderServices DICOMTesting SceneSerializationBase PlanarFigure ImageDenoising ImageExtraction LegacyAdaptors SceneSerialization Gizmo GraphAlgorithms Multilabel ImageStatistics ContourModel SurfaceInterpolation Segmentation PlanarFigureSegmentation OpenViewCore QtWidgets QtWidgetsExt C3js QmlItems SegmentationUI Classification DiffusionImaging GPGPU OpenIGTLink IGTBase IGT CameraCalibration RigidRegistration RigidRegistrationUI DeformableRegistration DeformableRegistrationUI OpenCL OpenCVVideoSupport QtOverlays ToFHardware ToFProcessing ToFUI US USUI DicomUI Simulation Remeshing Python QtPython Persistence OpenIGTLinkUI IGTUI VtkShaders DicomRT RTUI IOExt XNAT TubeGraph BiophotonicsHardware TumorInvasionAnalysis MatchPointRegistration MatchPointRegistrationUI BoundingShape RenderWindowManager RenderWindowManagerUI CEST + BasicImageProcessing ) if(MITK_ENABLE_PIC_READER) list(APPEND mitk_modules IpPicSupportIO) endif()