diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp index cbbd714f88..96f2e44744 100644 --- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp +++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.cpp @@ -1,179 +1,189 @@ #include "mitkRegistrationWrapper.h" #include "mitkPyramidImageRegistrationMethod.h" #include "mitkDiffusionImage.h" #include #include "itkB0ImageExtractionImageFilter.h" #include #include #include #include - -mitk::RegistrationWrapper::RegistrationWrapper() -{ -} - -void mitk::RegistrationWrapper::ApplyTransformationToImage(mitk::Image::Pointer &img, const mitk::RegistrationWrapper::RidgidTransformType &transformation,double* offset, mitk::Image::Pointer resampleReference, bool binary) const +void mitk::RegistrationWrapper::ApplyTransformationToImage(mitk::Image::Pointer img, const mitk::RegistrationWrapper::RidgidTransformType &transformation,double* offset, mitk::Image* resampleReference, bool binary) { typedef mitk::DiffusionImage DiffusionImageType; if (dynamic_cast (img.GetPointer()) == NULL) { + ItkImageType::Pointer itkImage = ItkImageType::New(); + + + MITK_ERROR << "imgCopy 0 " << "/" << img->GetReferenceCount(); + MITK_ERROR << "pixel type " << img->GetPixelType().GetComponentTypeAsString(); + CastToItkImage(img, itkImage); + + typedef itk::Euler3DTransform< double > RigidTransformType; RigidTransformType::Pointer rtransform = RigidTransformType::New(); RigidTransformType::ParametersType parameters(RigidTransformType::ParametersDimension); for (int i = 0; i<6;++i) parameters[i] = transformation[i]; rtransform->SetParameters( parameters ); mitk::Point3D origin = itkImage->GetOrigin(); origin[0]-=offset[0]; origin[1]-=offset[1]; origin[2]-=offset[2]; mitk::Point3D newOrigin = rtransform->GetInverseTransform()->TransformPoint(origin); itk::Matrix dir = itkImage->GetDirection(); itk::Matrix transM ( vnl_inverse(rtransform->GetMatrix().GetVnlMatrix())); itk::Matrix newDirection = transM * dir; itkImage->SetOrigin(newOrigin); itkImage->SetDirection(newDirection); // Perform Resampling if reference image is provided - if (resampleReference.IsNotNull()) + if (resampleReference != NULL) { typedef itk::ResampleImageFilter ResampleFilterType; ItkImageType::Pointer itkReference = ItkImageType::New(); CastToItkImage(resampleReference,itkReference); typedef itk::WindowedSincInterpolateImageFunction< ItkImageType, 3> WindowedSincInterpolatorType; WindowedSincInterpolatorType::Pointer sinc_interpolator = WindowedSincInterpolatorType::New(); typedef itk::NearestNeighborInterpolateImageFunction< ItkImageType, double > NearestNeighborInterpolatorType; NearestNeighborInterpolatorType::Pointer nn_interpolator = NearestNeighborInterpolatorType::New(); ResampleFilterType::Pointer resampler = ResampleFilterType::New(); resampler->SetInput(itkImage); resampler->SetReferenceImage( itkReference ); resampler->UseReferenceImageOn(); if (binary) resampler->SetInterpolator(nn_interpolator); else resampler->SetInterpolator(sinc_interpolator); resampler->Update(); GrabItkImageMemory(resampler->GetOutput(), img); } else - GrabItkImageMemory(itkImage, img); - + { + // !! CastToItk behaves very differently depending on the original data type + // if the target type is the same as the original, only a pointer to the data is set + // and an additional GrabItkImageMemory will cause a segfault when the image is destroyed + // GrabItkImageMemory - is not necessary in this case since we worked on the original data + // See Bug 17538. + if (img->GetPixelType().GetComponentTypeAsString() != "double") + img = GrabItkImageMemory(itkImage); + } } else { DiffusionImageType::Pointer diffImages = dynamic_cast(img.GetPointer()); typedef itk::Euler3DTransform< double > RigidTransformType; RigidTransformType::Pointer rtransform = RigidTransformType::New(); RigidTransformType::ParametersType parameters(RigidTransformType::ParametersDimension); for (int i = 0; i<6;++i) { parameters[i] = transformation[i]; } rtransform->SetParameters( parameters ); mitk::Point3D b0origin = diffImages->GetVectorImage()->GetOrigin(); b0origin[0]-=offset[0]; b0origin[1]-=offset[1]; b0origin[2]-=offset[2]; mitk::Point3D newOrigin = rtransform->GetInverseTransform()->TransformPoint(b0origin); itk::Matrix dir = diffImages->GetVectorImage()->GetDirection(); itk::Matrix transM ( vnl_inverse(rtransform->GetMatrix().GetVnlMatrix())); itk::Matrix newDirection = transM * dir; diffImages->GetVectorImage()->SetOrigin(newOrigin); diffImages->GetVectorImage()->SetDirection(newDirection); diffImages->Modified(); mitk::DiffusionImageCorrectionFilter::Pointer correctionFilter = mitk::DiffusionImageCorrectionFilter::New(); // For Diff. Images: Need to rotate the gradients (works in-place) correctionFilter->SetImage(diffImages); correctionFilter->CorrectDirections(transM.GetVnlMatrix()); img = diffImages; } } -void mitk::RegistrationWrapper::GetTransformation(mitk::Image::Pointer fixedImage, mitk::Image::Pointer movingImage, RidgidTransformType transformation,double* offset, mitk::Image::Pointer mask) +void mitk::RegistrationWrapper::GetTransformation(mitk::Image* fixedImage, mitk::Image* movingImage, RidgidTransformType transformation,double* offset, mitk::Image* mask) { // Handle the case that fixed/moving image is a DWI image - mitk::DiffusionImage* fixedDwi = dynamic_cast*> (fixedImage.GetPointer()); - mitk::DiffusionImage* movingDwi = dynamic_cast*> (movingImage.GetPointer()); + mitk::DiffusionImage* fixedDwi = dynamic_cast*> (fixedImage); + mitk::DiffusionImage* movingDwi = dynamic_cast*> (movingImage); itk::B0ImageExtractionImageFilter::Pointer b0Extraction = itk::B0ImageExtractionImageFilter::New(); offset[0]=offset[1]=offset[2]=0; if (fixedDwi != NULL) { // Set b0 extraction as fixed image b0Extraction->SetInput(fixedDwi->GetVectorImage()); b0Extraction->SetDirections(fixedDwi->GetDirections()); b0Extraction->Update(); mitk::Image::Pointer tmp = mitk::Image::New(); tmp->InitializeByItk(b0Extraction->GetOutput()); tmp->SetVolume(b0Extraction->GetOutput()->GetBufferPointer()); fixedImage = tmp; } if (movingDwi != NULL) { // Set b0 extraction as moving image b0Extraction->SetInput(movingDwi->GetVectorImage()); b0Extraction->SetDirections(movingDwi->GetDirections()); b0Extraction->Update(); mitk::Image::Pointer tmp = mitk::Image::New(); tmp->InitializeByItk(b0Extraction->GetOutput()); tmp->SetVolume(b0Extraction->GetOutput()->GetBufferPointer()); movingImage = tmp; } // align the offsets of the two images. this is done to avoid non-overlapping initialization Point3D origin = fixedImage->GetGeometry()->GetOrigin(); Point3D originMoving = movingImage->GetGeometry()->GetOrigin(); offset[0] = originMoving[0]-origin[0]; offset[1] = originMoving[1]-origin[1]; offset[2] = originMoving[2]-origin[2]; mitk::Image::Pointer tmpImage = movingImage->Clone(); tmpImage->GetGeometry()->SetOrigin(origin); // Start registration mitk::PyramidImageRegistrationMethod::Pointer registrationMethod = mitk::PyramidImageRegistrationMethod::New(); registrationMethod->SetFixedImage( fixedImage ); - if (mask.IsNotNull()) + if (mask != NULL) { registrationMethod->SetFixedImageMask(mask); registrationMethod->SetUseFixedImageMask(true); } else { registrationMethod->SetUseFixedImageMask(false); } registrationMethod->SetTransformToRigid(); registrationMethod->SetCrossModalityOn(); registrationMethod->SetMovingImage(tmpImage); registrationMethod->Update(); registrationMethod->GetParameters(transformation); // first three: euler angles, last three translation } diff --git a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.h b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.h index 329725f8fc..894c0117e2 100644 --- a/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.h +++ b/Modules/DiffusionImaging/DiffusionCore/Algorithms/Registration/mitkRegistrationWrapper.h @@ -1,83 +1,69 @@ #ifndef MITKBATCHEDREGISTRATION_H #define MITKBATCHEDREGISTRATION_H -// ITK -#include // MITK #include #include "mitkCommon.h" #include "mitkImage.h" namespace mitk { /** * @brief The RegistrationWrapper class wraps the pyramid registration to calculate and apply a reference transformation to several images. * * Use if several pictures with the same world geometry are to be registered * to one reference image, the registration is only computed once (for the moving image) and the geometry can be transformed for the complete * image batch accordingly. Can handle image types that are usually not supported by registrations filters, e.g. fiber bundles and segmentations: * these can be registered if a "registerable" image such as B0/T2 from which they are derived is supplied, since the transformation can be calculated * on those and applied to the derived objects. * * For DWI images a registerable B0 Image will automatically be extracted. * */ -class MitkDiffusionCore_EXPORT RegistrationWrapper : public itk::LightObject +class MitkDiffusionCore_EXPORT RegistrationWrapper { public: - typedef itk::Image ItkImageType; + typedef itk::Image ItkImageType; typedef itk::Image ItkBinaryImageType; typedef double* RidgidTransformType; - mitkClassMacro(RegistrationWrapper, itk::LightObject) - itkFactorylessNewMacro(Self) - itkCloneMacro(Self) /** * @brief ApplyTransformationToImage Applies transformation from GetTransformation to provided image. * * Transforms image according to previously calculated transformation. Can be applied to derived resources also (e.g. binary images). * Handles DWI Data and rotates the gradients according to the transformation. * Images are resampled to provided reference, if no reference it supplied a copy of the input image is used as reference. * * @param img - image on which the transformation is to be applied * @param transformation - transformation returned from GetTransformation * @param offset - offset transformation returned from GetTransformation * @param resampleReference - image to which is to be resampled * @param binary */ - void ApplyTransformationToImage(mitk::Image::Pointer& img, const RidgidTransformType& transformation, double *offset, mitk::Image::Pointer resampleReference = NULL , bool binary = false) const; + static void ApplyTransformationToImage(mitk::Image::Pointer img, const RidgidTransformType& transformation, double *offset, mitk::Image* resampleReference = NULL , bool binary = false); /** * @brief GetTransformation Registeres the moving to the fixed image and returns the according transformation * * \note Does not return a registered image \see ApplyTransformationToImage for this. * * Both images are set to the same origin (the one of the fixed image), this is supposed to ensure overlapping, * the correction of the moving image is returned in the offset. * * It is possible mask a certain area and thereby excluding it from the registration metric (e.g. a tumor that is operated on), * this can be set as mitk::Image where all non-zero voxels are excluded. * * @param fixedImage * @param movingImage * @param transformation * @param offset - stores offset that has been applied to match origin of both images * @param mask - optional, provide a mask that is excluded from registration metric */ - void GetTransformation(mitk::Image::Pointer fixedImage , mitk::Image::Pointer movingImage, RidgidTransformType transformation, double* offset, mitk::Image::Pointer mask = NULL); - - -protected: - RegistrationWrapper(); - ~RegistrationWrapper(){}; - -private: - RegistrationWrapper(const Self &); //purposely not implemented - void operator=(const Self &); //purposely not implemented + static void GetTransformation(mitk::Image* fixedImage , mitk::Image* movingImage, RidgidTransformType transformation, double* offset, mitk::Image* mask = NULL); }; } #endif // MITKBATCHEDREGISTRATION_H diff --git a/Modules/DiffusionImaging/MiniApps/BatchedFolderRegistration.cpp b/Modules/DiffusionImaging/MiniApps/BatchedFolderRegistration.cpp new file mode 100644 index 0000000000..3625bc16ee --- /dev/null +++ b/Modules/DiffusionImaging/MiniApps/BatchedFolderRegistration.cpp @@ -0,0 +1,341 @@ +/*=================================================================== + +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 "MiniAppManager.h" + +// CTK +#include "ctkCommandLineParser.h" + +#include +#include +#include +#include +#include +#include +#include "mitkNrrdDiffusionImageWriter.h" +// ITK +#include +#include + + +typedef std::vector FileListType; + + +static std::vector &split(const std::string &s, char delim, std::vector &elems) +{ + std::stringstream ss(s); + std::string item; + while (std::getline(ss, item, delim)) + { + elems.push_back(item); + } + return elems; +} + +static std::vector split(const std::string &s, char delim) +{ + std::vector < std::string > elems; + return split(s, delim, elems); +} + +/// Create list of all files in provided folder ending with same postfix +static FileListType CreateFileList(std::string folder , std::string postfix) +{ + itk::Directory::Pointer dir = itk::Directory::New(); + FileListType fileList; + + if( dir->Load(folder.c_str() ) ) + { + int n = dir->GetNumberOfFiles(); + for(int r=0;rGetFile( r ); + if (filename == "." || filename == "..") + continue; + filename = folder + filename; + if (!itksys::SystemTools::FileExists( filename.c_str())) + continue; + if (filename.substr(filename.length() -postfix.length() ) == postfix) + fileList.push_back(filename); + } + } + return fileList; +} + +/// Add '_reg' tag to file name +static std::string GetSavePath(std::string outputFolder, std::string fileName) +{ + std::string fileType = itksys::SystemTools::GetFilenameExtension(fileName); + std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(fileName); + + std::string savePathAndFileName = outputFolder +fileStem + "_reg" + fileType; + + return savePathAndFileName; +} + +/// Build a derived file name from moving images e.g. xxx_T2.nrrd becomes xxx_GTV.nrrd +static FileListType CreateDerivedFileList(std::string baseFN, std::string baseSuffix, std::vector derivedPatterns) +{ + FileListType files; + for (unsigned int i=0; i < derivedPatterns.size(); i++) + { + std::string derResourceSuffix = derivedPatterns.at(i); + std::string derivedResourceFilename = baseFN.substr(0,baseFN.length() -baseSuffix.length()) + derResourceSuffix; + MITK_INFO <<" Looking for file: " << derivedResourceFilename; + + if (!itksys::SystemTools::FileExists(derivedResourceFilename.c_str())) + { + MITK_INFO << "CreateDerivedFileList: File does not exit. Skipping entry."; + continue; + } + files.push_back(derivedResourceFilename); + } + return files; +} + +/// Save images according to file type +static void SaveImage(std::string fileName, mitk::Image* image, std::string fileType ) +{ + MITK_INFO << "----Save to " << fileName; + if (fileType == "dwi") // IOUtil does not handle dwi files properly Bug 15772 + { + mitk::NrrdDiffusionImageWriter< short >::Pointer dwiwriter = mitk::NrrdDiffusionImageWriter< short >::New(); + dwiwriter->SetInput( dynamic_cast* > (image)); + dwiwriter->SetFileName( fileName ); + try + { + dwiwriter->Update(); + } + catch( const itk::ExceptionObject& e) + { + MITK_ERROR << "Caught exception: " << e.what(); + mitkThrow() << "Failed with exception from subprocess!"; + } + } + else + { + mitk::IOUtil::SaveImage(image, fileName); + } +} + +/// Copy derived resources from first time step. Append _reg tag, but leave data untouched. +static void CopyResources(FileListType fileList, std::string outputPath) +{ + for (unsigned int j=0; j < fileList.size(); j++) + { + std::string derivedResourceFilename = fileList.at(j); + std::string fileType = itksys::SystemTools::GetFilenameExtension(derivedResourceFilename); + std::string fileStem = itksys::SystemTools::GetFilenameWithoutExtension(derivedResourceFilename); + std::string savePathAndFileName = outputPath +fileStem + "_reg." + fileType; + MITK_INFO << "Copy resource " << savePathAndFileName; + mitk::Image::Pointer resImage = mitk::IOUtil::LoadImage(derivedResourceFilename); + mitk::IOUtil::SaveImage(resImage, savePathAndFileName); + } +} + + +int BatchedFolderRegistration( int argc, char* argv[] ) +{ + ctkCommandLineParser parser; + parser.setArgumentPrefix("--","-"); + // Add command line argument names + parser.addArgument("help", "h",ctkCommandLineParser::Bool, "Show this help text"); + parser.addArgument("xml", "x",ctkCommandLineParser::Bool, "Print a XML description of this modules command line interface"); + //parser.addArgument("usemask", "u", QVariant::Bool, "Use segmentations (derived resources) to exclude areas from registration metrics"); + parser.addArgument("input", "i", ctkCommandLineParser::String, "Input folder",us::Any(),false); + parser.addArgument("output", "o", ctkCommandLineParser::String, "Output folder (ending with /)",us::Any(),false); + parser.addArgument("fixed", "f", ctkCommandLineParser::String, "Suffix for fixed image",us::Any(),false); + parser.addArgument("moving", "m", ctkCommandLineParser::String, "Suffix for moving images",us::Any(),false); + parser.addArgument("derived", "d", ctkCommandLineParser::String, "Derived resources suffixes (replaces suffix for moving images); comma separated",us::Any(),true); + parser.addArgument("silent", "s", ctkCommandLineParser::Bool, "No xml progress output."); + // Feature currently disabled + //parser.addArgument("resample", "r", QVariant::String, "Reference Image for resampling (optional), is not applied to tensor data"); + + map parsedArgs = parser.parseArguments(argc, argv); + + // Handle special arguments + bool silent = false; + { + if (parsedArgs.size() == 0) + { + MITK_ERROR << "Missig arguements" ; + return EXIT_FAILURE; + } + + if (parsedArgs.count("xml")) + { + MITK_ERROR << "This is to be handled by shell script"; + return EXIT_SUCCESS; + } + + if (parsedArgs.count("silent")) + silent = true; + + // Show a help message + if ( parsedArgs.count("help") || parsedArgs.count("h")) + { + std::cout << parser.helpText(); + return EXIT_SUCCESS; + } + } + std::string outputPath = us::any_cast(parsedArgs["output"]); + std::string refPattern = us::any_cast(parsedArgs["fixed"]); + std::string inputPath = us::any_cast(parsedArgs["input"]); + std::string movingImgPattern = us::any_cast(parsedArgs["moving"]); + //QString resampleReference = parsedArgs["resample"].toString(); + //bool maskTumor = parsedArgs["usemask"].toBool(); + + // if derived sources pattern is provided, populate QStringList with possible filename postfixes + std::vector derPatterns; + + if (parsedArgs.count("derived") || parsedArgs.count("d") ) + { + std::string arg = us::any_cast(parsedArgs["derived"]); + derPatterns = split(arg ,','); + } + + MITK_INFO << "Input Folder : " << inputPath; + MITK_INFO << "Looking for reference image ..."; + FileListType referenceFileList = CreateFileList(inputPath,refPattern); + + if (referenceFileList.size() != 1) + { + MITK_ERROR << "None or more than one possible reference images (" << refPattern <<") found. Exiting." << referenceFileList.size(); + MITK_INFO << "Choose a fixed arguement that is unique in the given folder!"; + return EXIT_FAILURE; + } + + std::string referenceFileName = referenceFileList.at(0); + + MITK_INFO << "Loading Reference (fixed) image: " << referenceFileName; + mitk::Image::Pointer refImage = mitk::IOUtil::LoadImage(referenceFileName); + + if (refImage.IsNull()) + MITK_ERROR << "Loaded fixed image is NULL"; + + // Copy reference image to destination + std::string savePathAndFileName = GetSavePath(outputPath, referenceFileName); + mitk::IOUtil::SaveImage(refImage, savePathAndFileName); + + // Copy all derived resources also to output folder, adding _reg suffix + referenceFileList = CreateDerivedFileList(referenceFileName, movingImgPattern,derPatterns); + CopyResources(referenceFileList, outputPath); + + std::string derivedResourceFilename; + mitk::Image::Pointer referenceMask = NULL; // union of all segmentations + + if (!silent) + { + // XML Output to report progress + std::cout << ""; + std::cout << "Batched Registration"; + std::cout << "Starting registration ... "; + std::cout << ""; + } + + // Now iterate over all files and register them to the reference image, + // also register derived resources based on file patterns + // ------------------------------------------------------------------------------ + + // Create File list + + FileListType movingImagesList = CreateFileList(inputPath, movingImgPattern); + + + // TODO Reactivate Resampling Feature + // mitk::Image::Pointer resampleImage = NULL; + // if (QFileInfo(resampleReference).isFile()) + // { + // resampleImage = mitk::IOUtil::LoadImage(resampleReference.toStdString()); + // } + for (unsigned int i =0; i < movingImagesList.size(); i++) + { + std::string fileMorphName = movingImagesList.at(i); + if (fileMorphName == referenceFileName) + { + + // do not process reference image again + continue; + } + MITK_INFO << "Processing image " << fileMorphName; + + // 1 Register morphological file to reference image + + if (!itksys::SystemTools::FileExists(fileMorphName.c_str())) + { + MITK_WARN << "File does not exit. Skipping entry."; + continue; + } + // Origin of images is cancelled + // TODO make this optional!! + double transf[6]; + double offset[3]; + { + mitk::Image::Pointer movingImage = mitk::IOUtil::LoadImage(fileMorphName); + + MITK_ERROR << "REF COUNT MOVING 0 " << movingImage->GetReferenceCount(); + if (movingImage.IsNull()) + MITK_ERROR << "Loaded moving image is NULL"; + + // Store transformation, apply it to morph file + MITK_INFO << "----------Registering moving image to reference----------"; + + + MITK_ERROR << "REF COUNT MOVING 1 " << movingImage->GetReferenceCount(); + //mitk::RegistrationWrapper::GetTransformation(refImage, movingImage, transf, offset, referenceMask); + MITK_ERROR << "REF COUNT MOVING 2 " << movingImage->GetReferenceCount(); + + mitk::RegistrationWrapper::ApplyTransformationToImage(movingImage, transf,offset, NULL); // , resampleImage + MITK_ERROR << "REF COUNT MOVING 3 " << movingImage->GetReferenceCount(); + savePathAndFileName = GetSavePath(outputPath, fileMorphName); + std::string fileType = itksys::SystemTools::GetFilenameExtension(fileMorphName); + SaveImage(savePathAndFileName,movingImage,fileType ); + } + + if (!silent) + { + std::cout << "."; + } + + // Now parse all derived resource and apply the above calculated transformation to them + // ------------------------------------------------------------------------------------ + + FileListType fList = CreateDerivedFileList(fileMorphName, movingImgPattern,derPatterns); + if (fList.size() > 0) + MITK_INFO << "----------DERIVED RESOURCES ---------"; + for (unsigned int j=0; j < fList.size(); j++) + { + derivedResourceFilename = fList.at(j); + MITK_INFO << "----Processing derived resource " << derivedResourceFilename << " ..."; + mitk::Image::Pointer derivedMovingResource = mitk::IOUtil::LoadImage(derivedResourceFilename); + // Apply transformation to derived resource, treat derived resource as binary + mitk::RegistrationWrapper::ApplyTransformationToImage(derivedMovingResource, transf,offset, NULL, true); + + savePathAndFileName = GetSavePath(outputPath, derivedResourceFilename); + std::string fileType = itksys::SystemTools::GetFilenameExtension(derivedResourceFilename); + + SaveImage(savePathAndFileName,derivedMovingResource,fileType ); + } + } + + if (!silent) + std::cout << ""; + return EXIT_SUCCESS; +} + +RegisterDiffusionMiniApp(BatchedFolderRegistration); diff --git a/Modules/DiffusionImaging/MiniApps/files.cmake b/Modules/DiffusionImaging/MiniApps/files.cmake index 16faf6666d..d8e72a7df5 100644 --- a/Modules/DiffusionImaging/MiniApps/files.cmake +++ b/Modules/DiffusionImaging/MiniApps/files.cmake @@ -1,25 +1,27 @@ set(CPP_FILES mitkDiffusionMiniApps.cpp MiniAppManager.cpp + + BatchedFolderRegistration.cpp FileFormatConverter.cpp TensorReconstruction.cpp TensorDerivedMapsExtraction.cpp QballReconstruction.cpp DiffusionIndices.cpp ExtractImageStatistics.cpp CopyGeometry.cpp GibbsTracking.cpp StreamlineTracking.cpp FiberProcessing.cpp LocalDirectionalFiberPlausibility.cpp #TractogramAngularError.cpp FiberDirectionExtraction.cpp PeakExtraction.cpp PeaksAngularError.cpp MultishellMethods.cpp #FiberFoxProcessing.cpp ExportShImage.cpp NetworkCreation.cpp NetworkStatistics.cpp DwiDenoising.cpp )