diff --git a/CMakeExternals/ITK.cmake b/CMakeExternals/ITK.cmake index d66875190e..82263304e1 100644 --- a/CMakeExternals/ITK.cmake +++ b/CMakeExternals/ITK.cmake @@ -1,83 +1,94 @@ #----------------------------------------------------------------------------- # ITK #----------------------------------------------------------------------------- # Sanity checks if(DEFINED ITK_DIR AND NOT EXISTS ${ITK_DIR}) message(FATAL_ERROR "ITK_DIR variable is defined but corresponds to non-existing directory") endif() set(proj ITK) set(proj_DEPENDENCIES GDCM) if(MITK_USE_Python) list(APPEND proj_DEPENDENCIES CableSwig) endif() +if(MITK_USE_OpenCV) + list(APPEND proj_DEPENDENCIES OpenCV) +endif() set(ITK_DEPENDS ${proj}) if(NOT DEFINED ITK_DIR) set(additional_cmake_args ) if(MINGW) set(additional_cmake_args -DCMAKE_USE_WIN32_THREADS:BOOL=ON -DCMAKE_USE_PTHREADS:BOOL=OFF) endif() if(MITK_USE_Python) list(APPEND additional_cmake_args -DITK_WRAPPING:BOOL=ON #-DITK_USE_REVIEW:BOOL=ON -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE} -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR} -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2} -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY} #-DPYTHON_LIBRARIES=${PYTHON_LIBRARY} #-DPYTHON_DEBUG_LIBRARIES=${PYTHON_DEBUG_LIBRARIES} -DCableSwig_DIR:PATH=${CableSwig_DIR} #-DITK_WRAP_JAVA:BOOL=OFF -DITK_WRAP_unsigned_char:BOOL=ON #-DITK_WRAP_double:BOOL=ON -DITK_WRAP_rgb_unsigned_char:BOOL=ON #-DITK_WRAP_rgba_unsigned_char:BOOL=ON -DITK_WRAP_signed_char:BOOL=ON #-DWRAP_signed_long:BOOL=ON -DITK_WRAP_signed_short:BOOL=ON -DITK_WRAP_short:BOOL=ON -DITK_WRAP_unsigned_long:BOOL=ON ) else() list(APPEND additional_cmake_args -DUSE_WRAP_ITK:BOOL=OFF ) endif() + if(MITK_USE_OpenCV) + message("OpenCV_DIR: ${OpenCV_DIR}") + list(APPEND additional_cmake_args + -DModule_ITKVideoBridgeOpenCV:BOOL=ON + -DOpenCV_DIR:PATH=${OpenCV_DIR} + ) + endif() + set(ITK_PATCH_COMMAND ${CMAKE_COMMAND} -DTEMPLATE_FILE:FILEPATH=${MITK_SOURCE_DIR}/CMakeExternals/EmptyFileForPatching.dummy -P ${MITK_SOURCE_DIR}/CMakeExternals/PatchITK-4.3.1.cmake) ExternalProject_Add(${proj} SOURCE_DIR ${CMAKE_BINARY_DIR}/${proj}-src BINARY_DIR ${proj}-build PREFIX ${proj}-cmake URL ${MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL}/InsightToolkit-4.3.2.tar.gz URL_MD5 f25bb1561887be621d3954689f3944a6 INSTALL_COMMAND "" PATCH_COMMAND ${ITK_PATCH_COMMAND} CMAKE_GENERATOR ${gen} CMAKE_ARGS ${ep_common_args} ${additional_cmake_args} -DBUILD_TESTING:BOOL=OFF -DBUILD_EXAMPLES:BOOL=OFF -DITK_USE_SYSTEM_GDCM:BOOL=ON -DGDCM_DIR:PATH=${GDCM_DIR} DEPENDS ${proj_DEPENDENCIES} ) set(ITK_DIR ${CMAKE_CURRENT_BINARY_DIR}/${proj}-build) else() mitkMacroEmptyExternalProject(${proj} "${proj_DEPENDENCIES}") endif() diff --git a/Modules/OpenCVVideoSupport/Testing/CMakeLists.txt b/Modules/OpenCVVideoSupport/Testing/CMakeLists.txt index 5cc25bd8f1..153cd81e2e 100644 --- a/Modules/OpenCVVideoSupport/Testing/CMakeLists.txt +++ b/Modules/OpenCVVideoSupport/Testing/CMakeLists.txt @@ -1,8 +1 @@ MITK_CREATE_MODULE_TESTS() - - -# if(BUILD_TESTING AND MODULE_IS_ENABLED) -# mitkAddCustomModuleTest(mitkImageToOpenCVImageFilterTest mitkImageToOpenCVImageFilterTest -# ${MITK_DATA_DIR}/RenderingTestData/rgbImage.png -# ) -# endif() diff --git a/Modules/OpenCVVideoSupport/Testing/files.cmake b/Modules/OpenCVVideoSupport/Testing/files.cmake index 6e2ddb0530..072396b7ac 100644 --- a/Modules/OpenCVVideoSupport/Testing/files.cmake +++ b/Modules/OpenCVVideoSupport/Testing/files.cmake @@ -1,13 +1,3 @@ set(MODULE_TESTS -) - -set(MODULE_IMAGE_TESTS - mitkImageToOpenCVImageFilterTest.cpp -) - -# list of images for which the tests are run -set(MODULE_TESTIMAGES - Png2D-bw.png - RenderingTestData/rgbImage.png -#NrrdWritingTestImage.jpg + mitkOpenCVMitkConversionTest.cpp ) diff --git a/Modules/OpenCVVideoSupport/Testing/mitkImageToOpenCVImageFilterTest.cpp b/Modules/OpenCVVideoSupport/Testing/mitkImageToOpenCVImageFilterTest.cpp deleted file mode 100644 index 86612b236c..0000000000 --- a/Modules/OpenCVVideoSupport/Testing/mitkImageToOpenCVImageFilterTest.cpp +++ /dev/null @@ -1,177 +0,0 @@ -/*=================================================================== - -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 "mitkImageToOpenCVImageFilter.h" -#include "mitkOpenCVToMitkImageFilter.h" -#include -#include -#include -#include - -// #include -#include - -mitk::Image::Pointer LoadImage( std::string filename ) -{ - mitk::ItkImageFileReader::Pointer reader = mitk::ItkImageFileReader::New(); - reader->SetFileName ( filename.c_str() ); - reader->Update(); - if ( reader->GetOutput() == NULL ) - itkGenericExceptionMacro("File "<GetOutput(); - return image; -} - -static void testGeneratedImage() -{ - // create itk rgb image - typedef unsigned char PixelType; - typedef itk::Image< itk::RGBPixel, 2 > ImageType; - ImageType::Pointer itkImage = ImageType::New(); - - ImageType::IndexType start; - start[0] = 0; // first index on X - start[1] = 0; // first index on Y - ImageType::SizeType size; - size[0] = 50; // size along X - size[1] = 40; // size along Y - ImageType::RegionType region; - region.SetSize( size ); - region.SetIndex( start ); - itkImage->SetRegions( region ); - itkImage->Allocate(); - - typedef itk::ImageRegionIterator IteratorType; - IteratorType it(itkImage, region); - float twoThirdsTheWidth = size[0] / 4; - unsigned int x=0, y=0; - // create rgb pic - for ( it.GoToBegin(); !it.IsAtEnd(); ++it ) - { - ImageType::PixelType newPixel; - newPixel.SetRed(0); - newPixel.SetGreen(0); - // create asymmetric pic - if( x > twoThirdsTheWidth ) - newPixel.SetBlue(0); - else - newPixel.SetBlue(255); - it.Set(newPixel); - - ++x; - // next line found - if( x == size[0] ) - x = 0; - } - - // debugging - // itk::ImageFileWriter< ImageType >::Pointer writer = itk::ImageFileWriter< ImageType >::New(); - // writer->SetFileName( "c:\\image.png" ); - // writer->SetInput ( itkImage ); - // writer->Update(); - - // import rgb image as MITK image - mitk::Image::Pointer mitkImage = mitk::ImportItkImage(itkImage)->Clone(); - - mitk::ImageToOpenCVImageFilter::Pointer _ImageToOpenCVImageFilter = - mitk::ImageToOpenCVImageFilter::New(); - - _ImageToOpenCVImageFilter->SetImage( mitkImage ); - - IplImage* openCVImage = _ImageToOpenCVImageFilter->GetOpenCVImage(); - - MITK_TEST_CONDITION_REQUIRED( openCVImage != NULL, "Image returned by filter is not null."); - - // check byte size - const unsigned int expectedSize = size[0] * size[1] * 3 * sizeof( unsigned char);// sizeof( PixelType ); - const unsigned int realSize = openCVImage->width * openCVImage->height * openCVImage->nChannels * sizeof( unsigned char);//* sizeof ( PixelType ); - MITK_TEST_CONDITION_REQUIRED( expectedSize == realSize, "Test expectedSize == realSize"); - - // check pixel values - PixelType expectedBlueValue; - CvScalar s; - for (y = 0; (int)y < openCVImage->height; ++y) - { - for (x = 0; (int)x < openCVImage->width; ++x) - { - expectedBlueValue = 255; - if(x > twoThirdsTheWidth) - expectedBlueValue = 0; - - s = cvGet2D(openCVImage,y,x); - if( s.val[0] != expectedBlueValue || s.val[1] != 0 || s.val[2] != 0 ) - { - std::cout << "Wrong RGB values in created OpenCV image" << std::endl; - throw mitk::TestFailedException(); - } - } - } - -// cvNamedWindow( "test" ); -// cvShowImage( "test" , openCVImage ); -// cvWaitKey(); - -} - -static void testLoadedImage(std::string mitkImagePath) -{ - mitk::Image::Pointer testImage = LoadImage(mitkImagePath); - mitk::ImageToOpenCVImageFilter::Pointer _ImageToOpenCVImageFilter = - mitk::ImageToOpenCVImageFilter::New(); - - _ImageToOpenCVImageFilter->SetImage( testImage ); - - IplImage* openCVImage = _ImageToOpenCVImageFilter->GetOpenCVImage(); - IplImage* openCVImage_Ref = cvLoadImage(mitkImagePath.c_str()); - - MITK_TEST_CONDITION_REQUIRED( openCVImage != NULL, "Image returned by filter is not null."); - - for(int i = 0 ; iheight ; i++) - { - for(int j = 0 ; jwidth ; j++) - { - CvScalar s; - s=cvGet2D(openCVImage,i,j); // get the (i,j) pixel value - CvScalar sRef; - sRef=cvGet2D(openCVImage_Ref,i,j); // get the (i,j) pixel value - for(int c = 0 ; c < openCVImage->nChannels ; c++) - { - MITK_TEST_CONDITION_REQUIRED( s.val[c] == sRef.val[c] , "All pixel values have to be equal"); - } - } - } - - -// cvNamedWindow( "test" ); -// cvShowImage( "test" , openCVImage ); -// cvWaitKey(); -} - -/**Documentation - * test for the class "ImageToOpenCVImageFilter". - */ -int mitkImageToOpenCVImageFilterTest(int argc, char* argv[]) -{ - MITK_TEST_BEGIN("ImageToOpenCVImageFilter") - - testGeneratedImage(); - testLoadedImage(argv[1]); - // always end with this! - MITK_TEST_END(); - -} - - diff --git a/Modules/OpenCVVideoSupport/Testing/mitkOpenCVMitkConversionTest.cpp b/Modules/OpenCVVideoSupport/Testing/mitkOpenCVMitkConversionTest.cpp new file mode 100644 index 0000000000..92b18df971 --- /dev/null +++ b/Modules/OpenCVVideoSupport/Testing/mitkOpenCVMitkConversionTest.cpp @@ -0,0 +1,145 @@ +/*=================================================================== + +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 "mitkImageToOpenCVImageFilter.h" +#include "mitkOpenCVToMitkImageFilter.h" +#include +#include +#include +#include +#include +#include +#include + +// define test pixel indexes and intensities and other values +typedef itk::RGBPixel< unsigned char > TestUCRGBPixelType; + +cv::Size testImageSize; + +cv::Point pos1; +cv::Point pos2; +cv::Point pos3; + +cv::Vec3b color1; +cv::Vec3b color2; +cv::Vec3b color3; + +uchar greyValue1; +uchar greyValue2; +uchar greyValue3; + +template +void ComparePixels( itk::Image,VImageDimension>* image ) +{ + + + typedef itk::RGBPixel PixelType; + typedef itk::Image ImageType; + + typename ImageType::IndexType pixelIndex; + pixelIndex[0] = pos1.x; + pixelIndex[1] = pos1.y; + PixelType onePixel = image->GetPixel( pixelIndex ); + + MITK_TEST_CONDITION( color1[0] == onePixel.GetBlue(), "Testing if blue value (= " << static_cast(color1[0]) << ") at postion " + << pos1.x << ", " << pos1.y << " in OpenCV image is " + << "equals the blue value (= " << static_cast(onePixel.GetBlue()) << ")" + << " in the generated mitk image"); + + + pixelIndex[0] = pos2.x; + pixelIndex[1] = pos2.y; + onePixel = image->GetPixel( pixelIndex ); + + MITK_TEST_CONDITION( color2[1] == onePixel.GetGreen(), "Testing if green value (= " << static_cast(color2[1]) << ") at postion " + << pos2.x << ", " << pos2.y << " in OpenCV image is " + << "equals the green value (= " << static_cast(onePixel.GetGreen()) << ")" + << " in the generated mitk image"); + + + pixelIndex[0] = pos3.x; + pixelIndex[1] = pos3.y; + onePixel = image->GetPixel( pixelIndex ); + + MITK_TEST_CONDITION( color3[2] == onePixel.GetRed(), "Testing if red value (= " << static_cast(color3[2]) << ") at postion " + << pos3.x << ", " << pos3.y << " in OpenCV image is " + << "equals the red value (= " << static_cast(onePixel.GetRed()) << ")" + << " in the generated mitk image"); + +} + +int mitkOpenCVMitkConversionTest(int argc, char* argv[]) +{ + MITK_TEST_BEGIN("ImageToOpenCVImageFilter") + + MITK_INFO << "setting test values"; + testImageSize = cv::Size(11,11); + + pos1 = cv::Point(0,0); + pos2 = cv::Point(5,5); + pos3 = cv::Point(10,10); + + color1 = cv::Vec3b(50,0,0); + color2 = cv::Vec3b(0,128,0); + color3 = cv::Vec3b(0,0,255); + + greyValue1 = 0; + greyValue2 = 128; + greyValue3 = 255; + + MITK_INFO << "generating test OpenCV image (RGB)"; + cv::Mat testRGBImage = cv::Mat::zeros( testImageSize, CV_8UC3 ); + // generate some test intensity values + testRGBImage.at(pos1)= color1; + testRGBImage.at(pos2)= color2; + testRGBImage.at(pos3)= color3; + + //cv::namedWindow("debug", CV_WINDOW_FREERATIO ); + //cv::imshow("debug", testRGBImage.clone()); + //cv::waitKey(0); + + MITK_INFO << "converting OpenCV test image to mitk image and comparing scalar rgb values"; + mitk::OpenCVToMitkImageFilter::Pointer openCvToMitkFilter = + mitk::OpenCVToMitkImageFilter::New(); + openCvToMitkFilter->SetOpenCVMat( testRGBImage ); + openCvToMitkFilter->Update(); + + mitk::Image::Pointer mitkImage = openCvToMitkFilter->GetOutput(); + AccessFixedTypeByItk(mitkImage.GetPointer(), ComparePixels, + (itk::RGBPixel), // rgb image + (2) ); + + + MITK_INFO << "converting mitk image to OpenCV image and comparing scalar rgb values"; + mitk::ImageToOpenCVImageFilter::Pointer mitkToOpenCv = mitk::ImageToOpenCVImageFilter::New(); + mitkToOpenCv->SetImage( mitkImage ); + cv::Mat openCvImage = mitkToOpenCv->GetOpenCVMat(); + + cv::Vec3b convertedColor1 = openCvImage.at(pos1); + cv::Vec3b convertedColor2 = openCvImage.at(pos2); + cv::Vec3b convertedColor3 = openCvImage.at(pos3); + + MITK_TEST_CONDITION( color1 == convertedColor1, "Testing if initially created color values " << static_cast( color1[0] ) << ", " << static_cast( color1[1] ) << ", " << static_cast( color1[2] ) << " matches the color values " << static_cast( convertedColor1[0] ) << ", " << static_cast( convertedColor1[1] ) << ", " << static_cast( convertedColor1[2] ) << " at the same position " << pos1.x << ", " << pos1.y << " in the back converted OpenCV image" ) + + MITK_TEST_CONDITION( color2 == convertedColor2, "Testing if initially created color values " << static_cast( color2[0] ) << ", " << static_cast( color2[1] ) << ", " << static_cast( color2[2] ) << " matches the color values " << static_cast( convertedColor2[0] ) << ", " << static_cast( convertedColor2[1] ) << ", " << static_cast( convertedColor2[2] ) << " at the same position " << pos2.x << ", " << pos2.y << " in the back converted OpenCV image" ) + + MITK_TEST_CONDITION( color3 == convertedColor3, "Testing if initially created color values " << static_cast( color3[0] ) << ", " << static_cast( color3[1] ) << ", " << static_cast( color3[2] ) << " matches the color values " << static_cast( convertedColor3[0] ) << ", " << static_cast( convertedColor3[1] ) << ", " << static_cast( convertedColor3[2] ) << " at the same position " << pos3.x << ", " << pos3.y << " in the back converted OpenCV image" ) + + MITK_TEST_END(); + +} + + diff --git a/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.cpp b/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.cpp index 20f1ae7966..e26bfa3cfc 100644 --- a/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.cpp +++ b/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.cpp @@ -1,125 +1,92 @@ /*=================================================================== 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 "mitkImageToOpenCVImageFilter.h" #include #include #include mitk::ImageToOpenCVImageFilter::ImageToOpenCVImageFilter() : m_OpenCVImage(0) { } mitk::ImageToOpenCVImageFilter::~ImageToOpenCVImageFilter() { m_OpenCVImage = 0; } -int mitk::ImageToOpenCVImageFilter::GetDepth(const std::type_info& typeInfo) const -{ - if(typeInfo == typeid(unsigned char)) - { - return IPL_DEPTH_8U; - } - else if(typeInfo == typeid(char)) - { - return IPL_DEPTH_8S; - } - else if(typeInfo == typeid(unsigned short)) - { - return IPL_DEPTH_16U; - } - else if(typeInfo == typeid(short)) - { - return IPL_DEPTH_16S; - } - else if(typeInfo == typeid(int)) - { - return IPL_DEPTH_32S; - } - else if(typeInfo == typeid(float)) - { - return IPL_DEPTH_32F; - } - else if(typeInfo == typeid(double)) - { - return IPL_DEPTH_64F; - } - // rgb image - else if(typeInfo == typeid(UCRGBPixelType)) - { - return IPL_DEPTH_8U; - } - else if(typeInfo == typeid(USRGBPixelType)) - { - return IPL_DEPTH_16U; - } - else if(typeInfo == typeid(FloatRGBPixelType)) - { - return IPL_DEPTH_64F; - } - else if(typeInfo == typeid(DoubleRGBPixelType)) - { - return IPL_DEPTH_64F; - } - else return -1; -} - bool mitk::ImageToOpenCVImageFilter::CheckImage( mitk::Image* image ) { if(image == 0) { MITK_WARN << "MITK Image is 0"; return false; } if(image->GetDimension() != 2) { MITK_WARN << "Only 2D Images allowed"; return false; } return true; } IplImage* mitk::ImageToOpenCVImageFilter::GetOpenCVImage() { + m_OpenCVImage = 0; if(!this->CheckImage( m_Image )) return 0; - if(!m_OpenCVImage) - { + + try { AccessFixedTypeByItk(m_Image.GetPointer(), ItkImageProcessing, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ // gray image (UCRGBPixelType)(USRGBPixelType)(FloatRGBPixelType)(DoubleRGBPixelType), // rgb image (2) // dimensions ) } catch (const AccessByItkException& e) { std::cout << "Caught exception [from AccessFixedTypeByItk]: \n" << e.what() << "\n"; return 0; } - } + return m_OpenCVImage; } +cv::Mat mitk::ImageToOpenCVImageFilter::GetOpenCVMat() +{ + IplImage* img = this->GetOpenCVImage(); + //cvNamedWindow("debug2", CV_WINDOW_FREERATIO); + //cvShowImage("debug2", img); + //cv::waitKey(0); + cv::Mat mat; + if( img ) + { + // do not copy data, then release just the header + mat = cv::Mat ( img, false ); + cvReleaseImageHeader( &img ); + } + + return mat; +} + void mitk::ImageToOpenCVImageFilter::SetImage( mitk::Image* _Image ) { // if(m_Image == _Image) return; m_Image = _Image; - m_OpenCVImage = 0; } diff --git a/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.h b/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.h index 3c783f7017..3f82f25969 100644 --- a/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.h +++ b/Modules/OpenCVVideoSupport/mitkImageToOpenCVImageFilter.h @@ -1,162 +1,97 @@ /*=================================================================== 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 mitkImageToOpenCVImageFilter_h #define mitkImageToOpenCVImageFilter_h #include #include #include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "mitkOpenCVVideoSupportExports.h" +#include +#include namespace mitk { -/** - \brief A pseudo-Filter for creating OpenCV images from MITK images with the option of copying data or referencing it - - Last contributor: $Author: mueller $ -*/ - class MITK_OPENCVVIDEOSUPPORT_EXPORT ImageToOpenCVImageFilter : public itk::Object +/// +/// \brief A pseudo-Filter for creating OpenCV images from MITK images with the option of copying data or referencing it +/// +class MITK_OPENCVVIDEOSUPPORT_EXPORT ImageToOpenCVImageFilter : public itk::Object { - public: - typedef itk::RGBPixel< unsigned char > UCRGBPixelType; - typedef itk::RGBPixel< unsigned short > USRGBPixelType; - typedef itk::RGBPixel< float > FloatRGBPixelType; - typedef itk::RGBPixel< double > DoubleRGBPixelType; - - template - static mitk::Image::Pointer ConvertIplToMitkImage( const IplImage * input, bool copyBuffer = true ); - - mitkClassMacro(ImageToOpenCVImageFilter, itk::Object); - itkNewMacro(ImageToOpenCVImageFilter); - - void SetImage( mitk::Image* _Image ); - itkGetMacro(Image, mitk::Image*); - - bool CheckImage(mitk::Image* image); - /// - /// Get the produced OpenCVImage. - /// ATTENTION: Do not forget to release this image again with cvReleaseImage(). - /// - IplImage* GetOpenCVImage(); - - protected: - - ImageToOpenCVImageFilter(); // purposely hidden - virtual ~ImageToOpenCVImageFilter(); - - int GetDepth(const std::type_info& typeInfo) const; - - template - void ItkImageProcessing( itk::Image* image ); - - template - void ItkImageProcessing( itk::Image,VImageDimension>* image ); - - protected: - /// - /// Saves if the filter should copy the data or just reference it - /// - mitk::WeakPointer m_Image; - IplImage* m_OpenCVImage; + public: + typedef itk::RGBPixel< unsigned char > UCRGBPixelType; + typedef itk::RGBPixel< unsigned short > USRGBPixelType; + typedef itk::RGBPixel< float > FloatRGBPixelType; + typedef itk::RGBPixel< double > DoubleRGBPixelType; + + mitkClassMacro(ImageToOpenCVImageFilter, itk::Object); + itkNewMacro(ImageToOpenCVImageFilter); + + /// + /// \brief set the input MITK image + /// + void SetImage( mitk::Image* _Image ); + /// + /// \brief get the input MITK image + /// + itkGetMacro(Image, mitk::Image*); + + /// + /// \brief get the input MITK image + /// + bool CheckImage(mitk::Image* image); + + /// + /// RUNS the conversion and returns the produced OpenCVImage. + /// !!!ATTENTION!!! Do not forget to release this image again with cvReleaseImage(). + /// \return the produced OpenCVImage or 0 if an error occured! + /// + IplImage* GetOpenCVImage(); + + /// + /// RUNS the conversion and returns the produced image as cv::Mat. + /// \return the produced OpenCVImage or an empty image if an error occured + /// + cv::Mat GetOpenCVMat(); + + protected: + /// + /// the actual templated conversion method + /// + template + void ItkImageProcessing( itk::Image* image ); + + ImageToOpenCVImageFilter(); + ~ImageToOpenCVImageFilter(); + + /// + /// Saves if the filter should copy the data or just reference it + /// + mitk::WeakPointer m_Image; + IplImage* m_OpenCVImage; }; - template - void mitk::ImageToOpenCVImageFilter::ItkImageProcessing( itk::Image* image ) - { - PixelType pType = m_Image->GetPixelType(0); - typedef itk::Image ImageType; - const unsigned int numberOfComponents = pType.GetNumberOfComponents(); - const unsigned int numberOfPixels = m_Image->GetDimension(0) * m_Image->GetDimension(1); - const unsigned int numberOfValues = numberOfPixels * numberOfComponents; - -// const unsigned int numberOfBytes = numberOfValues * sizeof( typename ImageType::PixelType ); - - const typename ImageType::PixelType * itkBuffer = image->GetBufferPointer(); - typename ImageType::SizeType size = image->GetLargestPossibleRegion().GetSize(); - // create new opencv image - m_OpenCVImage = cvCreateImage( cvSize( size[0], size[1] ) - , GetDepth(typeid(TPixel)), numberOfComponents ); - const unsigned int stepsize = m_OpenCVImage->widthStep; - const unsigned int width = m_OpenCVImage->width; - const unsigned int height = m_OpenCVImage->height; -// memcpy( m_OpenCVImage->imageData, itkBuffer, numberOfBytes ); - TPixel* mitkImagedata = (TPixel*)m_Image->GetData(); - TPixel* cvdata= reinterpret_cast(m_OpenCVImage->imageData); - for(int y = 0 ; y < height; y++) - { - for(int x = 0 ; x < width*numberOfComponents ; x+=numberOfComponents) - { - for(int c = 0 ; c < numberOfComponents ; c++) - { - cvdata[(numberOfComponents-c-1)+x] =mitkImagedata[x+c]; - } - } - cvdata = (TPixel*)(((unsigned char*)cvdata)+stepsize); - mitkImagedata+= width*numberOfComponents; - } - } - - template - void mitk::ImageToOpenCVImageFilter::ItkImageProcessing( itk::Image,VImageDimension>* image ) - { - typedef itk::RGBPixel RGBPixelType; - typedef itk::Image RGBImageType; - typedef itk::ImageRegionIterator RGBIteratorType; - - RGBIteratorType it(image, image->GetLargestPossibleRegion()); - - typename RGBImageType::SizeType size = image->GetLargestPossibleRegion().GetSize(); - // create new opencv image - m_OpenCVImage = cvCreateImage( cvSize( size[0], size[1] ), GetDepth(typeid(RGBPixelType)), 3 ); - - unsigned int x = 0,y = 0; - CvScalar s; - for ( it.GoToBegin(); !it.IsAtEnd(); ++it ) - { - s.val[0] = it.Value().GetBlue(); - s.val[1] = it.Value().GetGreen(); - s.val[2] = it.Value().GetRed(); - - //MITK_DEBUG << "[" << x << "," << y << "] " << s.val[0] << "(B)," << s.val[1] << "(G)," << s.val[2] << "(R)"; - - cvSet2D(m_OpenCVImage,y,x,s); - - ++x; - // next line found - if( x == size[0] ) - { - x = 0; - ++y; - } - } - - } +template +void mitk::ImageToOpenCVImageFilter::ItkImageProcessing( itk::Image* image ) +{ + m_OpenCVImage = itk::OpenCVImageBridge::ITKImageToIplImage (image); +} + } // namespace #endif // mitkImageToOpenCVImageFilter_h diff --git a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp index 8a05a9991a..ec4281bbca 100644 --- a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp +++ b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.cpp @@ -1,173 +1,133 @@ /*=================================================================== 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 "mitkOpenCVToMitkImageFilter.h" #include #include #include +#include +#include mitk::OpenCVToMitkImageFilter::OpenCVToMitkImageFilter() -: m_OpenCVImage(0), m_CopyBuffer(true) +: m_OpenCVImage(0) { } mitk::OpenCVToMitkImageFilter::~OpenCVToMitkImageFilter() { } void mitk::OpenCVToMitkImageFilter::SetOpenCVImage(const IplImage* image) { this->m_OpenCVImage = image; this->Modified(); } void mitk::OpenCVToMitkImageFilter::GenerateData() { + IplImage cvMatIplImage; + const IplImage* targetImage = 0; if(m_OpenCVImage == 0) { - MITK_WARN << "Cannot not start filter. OpenCV Image not set."; - return; + if( m_OpenCVMat.cols == 0 || m_OpenCVMat.rows == 0 ) + { + MITK_WARN << "Cannot not start filter. OpenCV Image not set."; + return; + } + else + { + cvMatIplImage = m_OpenCVMat; + targetImage = &cvMatIplImage; + } } - - // convert to rgb image color space - IplImage* rgbOpenCVImage = cvCreateImage( cvSize( m_OpenCVImage->width, m_OpenCVImage->height ) - , m_OpenCVImage->depth, m_OpenCVImage->nChannels ); - - if( m_OpenCVImage->nChannels == 3) - cvCvtColor( m_OpenCVImage, rgbOpenCVImage, CV_BGR2RGB ); + else + targetImage = m_OpenCVImage; // now convert rgb image - if( (m_OpenCVImage->depth>=0) && ((unsigned int)m_OpenCVImage->depth == IPL_DEPTH_8S) && (m_OpenCVImage->nChannels == 1) ) - m_Image = ConvertIplToMitkImage< char, 2>( m_OpenCVImage, m_CopyBuffer ); + if( (targetImage->depth>=0) && ((unsigned int)targetImage->depth == IPL_DEPTH_8S) && (targetImage->nChannels == 1) ) + m_Image = ConvertIplToMitkImage< char, 2>( targetImage ); - else if( m_OpenCVImage->depth == IPL_DEPTH_8U && m_OpenCVImage->nChannels == 1 ) - m_Image = ConvertIplToMitkImage< unsigned char, 2>( m_OpenCVImage, m_CopyBuffer ); + else if( targetImage->depth == IPL_DEPTH_8U && targetImage->nChannels == 1 ) + m_Image = ConvertIplToMitkImage< unsigned char, 2>( targetImage ); - else if( m_OpenCVImage->depth == IPL_DEPTH_8U && m_OpenCVImage->nChannels == 3 ) - m_Image = ConvertIplToMitkImage< UCRGBPixelType, 2>( rgbOpenCVImage, m_CopyBuffer ); + else if( targetImage->depth == IPL_DEPTH_8U && targetImage->nChannels == 3 ) + m_Image = ConvertIplToMitkImage< UCRGBPixelType, 2>( targetImage ); - else if( m_OpenCVImage->depth == IPL_DEPTH_16U && m_OpenCVImage->nChannels == 1 ) - m_Image = ConvertIplToMitkImage< unsigned short, 2>( m_OpenCVImage, m_CopyBuffer ); + else if( targetImage->depth == IPL_DEPTH_16U && targetImage->nChannels == 1 ) + m_Image = ConvertIplToMitkImage< unsigned short, 2>( targetImage ); - else if( m_OpenCVImage->depth == IPL_DEPTH_16U && m_OpenCVImage->nChannels == 3 ) - m_Image = ConvertIplToMitkImage< USRGBPixelType, 2>( rgbOpenCVImage, m_CopyBuffer ); + else if( targetImage->depth == IPL_DEPTH_16U && targetImage->nChannels == 3 ) + m_Image = ConvertIplToMitkImage< USRGBPixelType, 2>( targetImage ); - else if( m_OpenCVImage->depth == IPL_DEPTH_32F && m_OpenCVImage->nChannels == 1 ) - m_Image = ConvertIplToMitkImage< float, 2>( m_OpenCVImage, m_CopyBuffer ); + else if( targetImage->depth == IPL_DEPTH_32F && targetImage->nChannels == 1 ) + m_Image = ConvertIplToMitkImage< float, 2>( targetImage ); - else if( m_OpenCVImage->depth == IPL_DEPTH_32F && m_OpenCVImage->nChannels == 3 ) - m_Image = ConvertIplToMitkImage< FloatRGBPixelType , 2>( rgbOpenCVImage, m_CopyBuffer ); + else if( targetImage->depth == IPL_DEPTH_32F && targetImage->nChannels == 3 ) + m_Image = ConvertIplToMitkImage< FloatRGBPixelType , 2>( targetImage ); - else if( m_OpenCVImage->depth == IPL_DEPTH_64F && m_OpenCVImage->nChannels == 1 ) - m_Image = ConvertIplToMitkImage< double, 2>( m_OpenCVImage, m_CopyBuffer ); + else if( targetImage->depth == IPL_DEPTH_64F && targetImage->nChannels == 1 ) + m_Image = ConvertIplToMitkImage< double, 2>( targetImage ); - else if( m_OpenCVImage->depth == IPL_DEPTH_64F && m_OpenCVImage->nChannels == 3 ) - m_Image = ConvertIplToMitkImage< DoubleRGBPixelType , 2>( rgbOpenCVImage, m_CopyBuffer ); + else if( targetImage->depth == IPL_DEPTH_64F && targetImage->nChannels == 3 ) + m_Image = ConvertIplToMitkImage< DoubleRGBPixelType , 2>( targetImage ); else { MITK_WARN << "Unknown image depth and/or pixel type. Cannot convert OpenCV to MITK image."; return; } - cvReleaseImage(&rgbOpenCVImage); + //cvReleaseImage(&rgbOpenCVImage); } mitk::ImageSource::OutputImageType* mitk::OpenCVToMitkImageFilter::GetOutput() { return m_Image; } /******************************************** * Converting from OpenCV image to ITK Image *********************************************/ template -mitk::Image::Pointer mitk::OpenCVToMitkImageFilter::ConvertIplToMitkImage( const IplImage * input, bool copyBuffer ) +mitk::Image::Pointer mitk::OpenCVToMitkImageFilter::ConvertIplToMitkImage( const IplImage * input, bool ) { mitk::Image::Pointer mitkImage(0); - typedef itk::Image< TPixel, VImageDimension > ItkImage; - - typedef itk::ImportImageFilter< TPixel, VImageDimension > ImportFilterType; - typename ImportFilterType::Pointer importFilter = ImportFilterType::New(); - - typename ImportFilterType::SizeType size; - - size[0] = input->width; - size[1] = input->height; - - typename ImportFilterType::IndexType start; - start.Fill( 0 ); - - typename ImportFilterType::RegionType region; - region.SetIndex( start ); - region.SetSize( size ); - - importFilter->SetRegion( region ); + typedef itk::Image< TPixel, VImageDimension > ImageType; + typename ImageType::Pointer output = itk::OpenCVImageBridge::IplImageToITKImage(input); - double origin[ VImageDimension ]; - origin[0] = 0.0; // X coordinate - origin[1] = 0.0; // Y coordinate + mitkImage = mitk::GrabItkImageMemory(output); - importFilter->SetOrigin( origin ); - - - double spacing[ VImageDimension ]; - spacing[0] = 1.0; // along X direction - spacing[1] = 1.0; // along Y direction - - importFilter->SetSpacing( spacing ); - - - const unsigned int numberOfPixels = size[0] * size[1]; - const unsigned int numberOfBytes = numberOfPixels * sizeof( TPixel ); - - - - if( copyBuffer ) - { - const bool importImageFilterWillOwnTheBuffer = false; - - TPixel * localBuffer = new TPixel[numberOfPixels]; - - memcpy(localBuffer, input->imageData, numberOfBytes); - - importFilter->SetImportPointer( localBuffer, numberOfPixels, - importImageFilterWillOwnTheBuffer ); - - } - else - { - const bool importImageFilterWillOwnTheBuffer = false; - - TPixel * localBuffer = reinterpret_cast< TPixel * >( input->imageData ); - - importFilter->SetImportPointer( localBuffer, numberOfPixels, - importImageFilterWillOwnTheBuffer ); - } + return mitkImage; +} - importFilter->Update(); - typename ItkImage::Pointer output = importFilter->GetOutput(); +void mitk::OpenCVToMitkImageFilter::SetOpenCVMat(const cv::Mat &image) +{ + m_OpenCVMat = image; +} - output->DisconnectPipeline(); - mitkImage = mitk::ImportItkImage(output)->Clone(); +void mitk::OpenCVToMitkImageFilter::SetCopyBuffer(bool) +{ +} - return mitkImage; +bool mitk::OpenCVToMitkImageFilter::GetCopyBuffer() +{ + return true; } diff --git a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h index 324c7ce381..9a339412c0 100644 --- a/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h +++ b/Modules/OpenCVVideoSupport/mitkOpenCVToMitkImageFilter.h @@ -1,76 +1,84 @@ /*=================================================================== 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 mitkOpenCVToMitkImageFilter_h #define mitkOpenCVToMitkImageFilter_h #include #include #include #include -#include #include #include "mitkOpenCVVideoSupportExports.h" namespace mitk { -/** - \brief Filter for creating MITK RGB Images from an OpenCV image - - Last contributor: $Author: mueller $ -*/ +/// +/// \brief Filter for creating MITK RGB Images from an OpenCV image +/// class MITK_OPENCVVIDEOSUPPORT_EXPORT OpenCVToMitkImageFilter : public ImageSource { public: typedef itk::RGBPixel< unsigned char > UCRGBPixelType; typedef itk::RGBPixel< unsigned short > USRGBPixelType; typedef itk::RGBPixel< float > FloatRGBPixelType; typedef itk::RGBPixel< double > DoubleRGBPixelType; + /// + /// the static function for the conversion + /// WARNING: copyBuffer is deprecated, data will always be copied + /// template - static mitk::Image::Pointer ConvertIplToMitkImage( const IplImage * input, bool copyBuffer = true ); + static mitk::Image::Pointer ConvertIplToMitkImage( const IplImage * input, bool copyBuffer=true ); mitkClassMacro(OpenCVToMitkImageFilter, ImageSource); itkNewMacro(OpenCVToMitkImageFilter); + /// + /// sets an iplimage as input + /// void SetOpenCVImage(const IplImage* image); itkGetMacro(OpenCVImage, const IplImage*); - itkSetMacro(CopyBuffer, bool); - itkGetMacro(CopyBuffer, bool); + /// + /// sets an opencv mat as input (will be used if OpenCVImage Ipl image is 0) + /// + void SetOpenCVMat(const cv::Mat& image); + itkGetMacro(OpenCVMat, cv::Mat); + + DEPRECATED( void SetCopyBuffer( bool ); ); + DEPRECATED( bool GetCopyBuffer(); ); OutputImageType* GetOutput(void); protected: OpenCVToMitkImageFilter(); // purposely hidden virtual ~OpenCVToMitkImageFilter(); virtual void GenerateData(); protected: mitk::Image::Pointer m_Image; const IplImage* m_OpenCVImage; - bool m_CopyBuffer; + cv::Mat m_OpenCVMat; }; } // namespace #endif // mitkOpenCVToMitkImageFilter_h - - diff --git a/SuperBuild.cmake b/SuperBuild.cmake index f70deb3293..4127fae258 100644 --- a/SuperBuild.cmake +++ b/SuperBuild.cmake @@ -1,366 +1,366 @@ #----------------------------------------------------------------------------- # Convenient macro allowing to download a file #----------------------------------------------------------------------------- macro(downloadFile url dest) file(DOWNLOAD ${url} ${dest} STATUS status) list(GET status 0 error_code) list(GET status 1 error_msg) if(error_code) message(FATAL_ERROR "error: Failed to download ${url} - ${error_msg}") endif() endmacro() #----------------------------------------------------------------------------- # MITK Prerequisites #----------------------------------------------------------------------------- if(UNIX AND NOT APPLE) include(mitkFunctionCheckPackageHeader) # Check for libxt-dev mitkFunctionCheckPackageHeader(StringDefs.h libxt-dev /usr/include/X11/) # Check for libtiff4-dev mitkFunctionCheckPackageHeader(tiff.h libtiff4-dev) # Check for libwrap0-dev mitkFunctionCheckPackageHeader(tcpd.h libwrap0-dev) endif() #----------------------------------------------------------------------------- # ExternalProjects #----------------------------------------------------------------------------- set(external_projects VTK ACVD GDCM CableSwig + OpenCV ITK Boost DCMTK CTK - OpenCV SOFA MITKData ) set(MITK_USE_CableSwig ${MITK_USE_Python}) set(MITK_USE_GDCM 1) set(MITK_USE_ITK 1) set(MITK_USE_VTK 1) foreach(proj VTK ACVD GDCM CableSwig ITK DCMTK CTK OpenCV SOFA) if(MITK_USE_${proj}) set(EXTERNAL_${proj}_DIR "${${proj}_DIR}" CACHE PATH "Path to ${proj} build directory") mark_as_advanced(EXTERNAL_${proj}_DIR) if(EXTERNAL_${proj}_DIR) set(${proj}_DIR ${EXTERNAL_${proj}_DIR}) endif() endif() endforeach() if(MITK_USE_Boost) set(EXTERNAL_BOOST_ROOT "${BOOST_ROOT}" CACHE PATH "Path to Boost directory") mark_as_advanced(EXTERNAL_BOOST_ROOT) if(EXTERNAL_BOOST_ROOT) set(BOOST_ROOT ${EXTERNAL_BOOST_ROOT}) endif() endif() if(BUILD_TESTING) set(EXTERNAL_MITK_DATA_DIR "${MITK_DATA_DIR}" CACHE PATH "Path to the MITK data directory") mark_as_advanced(EXTERNAL_MITK_DATA_DIR) if(EXTERNAL_MITK_DATA_DIR) set(MITK_DATA_DIR ${EXTERNAL_MITK_DATA_DIR}) endif() endif() # Look for git early on, if needed if((BUILD_TESTING AND NOT EXTERNAL_MITK_DATA_DIR) OR (MITK_USE_CTK AND NOT EXTERNAL_CTK_DIR)) find_package(Git REQUIRED) endif() #----------------------------------------------------------------------------- # External project settings #----------------------------------------------------------------------------- include(ExternalProject) set(ep_base "${CMAKE_BINARY_DIR}/CMakeExternals") set_property(DIRECTORY PROPERTY EP_BASE ${ep_base}) set(ep_install_dir ${ep_base}/Install) #set(ep_build_dir ${ep_base}/Build) set(ep_source_dir ${ep_base}/Source) #set(ep_parallelism_level) set(ep_build_shared_libs ON) set(ep_build_testing OFF) if(NOT MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL) set(MITK_THIRDPARTY_DOWNLOAD_PREFIX_URL http://mitk.org/download/thirdparty) endif() # Compute -G arg for configuring external projects with the same CMake generator: if(CMAKE_EXTRA_GENERATOR) set(gen "${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}") else() set(gen "${CMAKE_GENERATOR}") endif() # Use this value where semi-colons are needed in ep_add args: set(sep "^^") ## if(MSVC_VERSION) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /bigobj /MP") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj /MP") endif() set(ep_common_args -DBUILD_TESTING:BOOL=${ep_build_testing} -DCMAKE_INSTALL_PREFIX:PATH=${ep_install_dir} -DBUILD_SHARED_LIBS:BOOL=ON -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER} -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER} -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} -DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} #debug flags -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} #release flags -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} #relwithdebinfo -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO} #link flags -DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} -DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} -DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ) # Include external projects foreach(p ${external_projects}) include(CMakeExternals/${p}.cmake) endforeach() #----------------------------------------------------------------------------- # Set superbuild boolean args #----------------------------------------------------------------------------- set(mitk_cmake_boolean_args BUILD_SHARED_LIBS WITH_COVERAGE BUILD_TESTING MITK_USE_QT MITK_BUILD_ALL_PLUGINS MITK_BUILD_ALL_APPS MITK_BUILD_TUTORIAL # Deprecated. Use MITK_BUILD_EXAMPLES instead MITK_BUILD_EXAMPLES MITK_USE_ACVD MITK_USE_Boost MITK_USE_SYSTEM_Boost MITK_USE_BLUEBERRY MITK_USE_CTK MITK_USE_DCMTK MITK_DCMTK_BUILD_SHARED_LIBS MITK_USE_OpenCV MITK_USE_SOFA MITK_USE_Python MITK_USE_OpenCL ) #----------------------------------------------------------------------------- # Create the final variable containing superbuild boolean args #----------------------------------------------------------------------------- set(mitk_superbuild_boolean_args) foreach(mitk_cmake_arg ${mitk_cmake_boolean_args}) list(APPEND mitk_superbuild_boolean_args -D${mitk_cmake_arg}:BOOL=${${mitk_cmake_arg}}) endforeach() if(MITK_BUILD_ALL_PLUGINS) list(APPEND mitk_superbuild_boolean_args -DBLUEBERRY_BUILD_ALL_PLUGINS:BOOL=ON) endif() #----------------------------------------------------------------------------- # MITK Utilities #----------------------------------------------------------------------------- set(proj MITK-Utilities) ExternalProject_Add(${proj} DOWNLOAD_COMMAND "" CONFIGURE_COMMAND "" BUILD_COMMAND "" INSTALL_COMMAND "" DEPENDS # Mandatory dependencies ${VTK_DEPENDS} ${ITK_DEPENDS} # Optionnal dependencies ${ACVD_DEPENDS} ${Boost_DEPENDS} ${CTK_DEPENDS} ${DCMTK_DEPENDS} ${OpenCV_DEPENDS} ${SOFA_DEPENDS} ${MITK-Data_DEPENDS} ) #----------------------------------------------------------------------------- # Additional MITK CXX/C Flags #----------------------------------------------------------------------------- set(MITK_ADDITIONAL_C_FLAGS "" CACHE STRING "Additional C Flags for MITK") set(MITK_ADDITIONAL_C_FLAGS_RELEASE "" CACHE STRING "Additional Release C Flags for MITK") set(MITK_ADDITIONAL_C_FLAGS_DEBUG "" CACHE STRING "Additional Debug C Flags for MITK") mark_as_advanced(MITK_ADDITIONAL_C_FLAGS MITK_ADDITIONAL_C_FLAGS_DEBUG MITK_ADDITIONAL_C_FLAGS_RELEASE) set(MITK_ADDITIONAL_CXX_FLAGS "" CACHE STRING "Additional CXX Flags for MITK") set(MITK_ADDITIONAL_CXX_FLAGS_RELEASE "" CACHE STRING "Additional Release CXX Flags for MITK") set(MITK_ADDITIONAL_CXX_FLAGS_DEBUG "" CACHE STRING "Additional Debug CXX Flags for MITK") mark_as_advanced(MITK_ADDITIONAL_CXX_FLAGS MITK_ADDITIONAL_CXX_FLAGS_DEBUG MITK_ADDITIONAL_CXX_FLAGS_RELEASE) set(MITK_ADDITIONAL_EXE_LINKER_FLAGS "" CACHE STRING "Additional exe linker flags for MITK") set(MITK_ADDITIONAL_SHARED_LINKER_FLAGS "" CACHE STRING "Additional shared linker flags for MITK") set(MITK_ADDITIONAL_MODULE_LINKER_FLAGS "" CACHE STRING "Additional module linker flags for MITK") mark_as_advanced(MITK_ADDITIONAL_EXE_LINKER_FLAGS MITK_ADDITIONAL_SHARED_LINKER_FLAGS MITK_ADDITIONAL_MODULE_LINKER_FLAGS) #----------------------------------------------------------------------------- # MITK Configure #----------------------------------------------------------------------------- if(MITK_INITIAL_CACHE_FILE) set(mitk_initial_cache_arg -C "${MITK_INITIAL_CACHE_FILE}") endif() set(mitk_optional_cache_args ) foreach(type RUNTIME ARCHIVE LIBRARY) if(DEFINED CTK_PLUGIN_${type}_OUTPUT_DIRECTORY) list(APPEND mitk_optional_cache_args -DCTK_PLUGIN_${type}_OUTPUT_DIRECTORY:PATH=${CTK_PLUGIN_${type}_OUTPUT_DIRECTORY}) endif() endforeach() # Optional python variables if(MITK_USE_Python) list(APPEND mitk_optional_cache_args -DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE} -DPYTHON_INCLUDE_DIR:PATH=${PYTHON_INCLUDE_DIR} -DPYTHON_LIBRARY:FILEPATH=${PYTHON_LIBRARY} -DPYTHON_INCLUDE_DIR2:PATH=${PYTHON_INCLUDE_DIR2} ) endif() set(proj MITK-Configure) ExternalProject_Add(${proj} LIST_SEPARATOR ^^ DOWNLOAD_COMMAND "" CMAKE_GENERATOR ${gen} CMAKE_CACHE_ARGS # --------------- Build options ---------------- -DBUILD_TESTING:BOOL=${ep_build_testing} -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_BINARY_DIR}/MITK-build/install -DBUILD_SHARED_LIBS:BOOL=ON -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} # --------------- Compile options ---------------- -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER} -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER} "-DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} ${MITK_ADDITIONAL_C_FLAGS}" "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} ${MITK_ADDITIONAL_CXX_FLAGS}" # debug flags "-DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} ${MITK_ADDITIONAL_CXX_FLAGS_DEBUG}" "-DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} ${MITK_ADDITIONAL_C_FLAGS_DEBUG}" # release flags "-DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} ${MITK_ADDITIONAL_CXX_FLAGS_RELEASE}" "-DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} ${MITK_ADDITIONAL_C_FLAGS_RELEASE}" # relwithdebinfo -DCMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DCMAKE_C_FLAGS_RELWITHDEBINFO:STRING=${CMAKE_C_FLAGS_RELWITHDEBINFO} # link flags "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} ${MITK_ADDITIONAL_EXE_LINKER_FLAGS}" "-DCMAKE_SHARED_LINKER_FLAGS:STRING=${CMAKE_SHARED_LINKER_FLAGS} ${MITK_ADDITIONAL_SHARED_LINKER_FLAGS}" "-DCMAKE_MODULE_LINKER_FLAGS:STRING=${CMAKE_MODULE_LINKER_FLAGS} ${MITK_ADDITIONAL_MODULE_LINKER_FLAGS}" # Output directories -DMITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_LIBRARY_OUTPUT_DIRECTORY} -DMITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_RUNTIME_OUTPUT_DIRECTORY} -DMITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${MITK_CMAKE_ARCHIVE_OUTPUT_DIRECTORY} # ------------- Boolean build options -------------- ${mitk_superbuild_boolean_args} ${mitk_optional_cache_args} -DMITK_USE_SUPERBUILD:BOOL=OFF -DCTEST_USE_LAUNCHERS:BOOL=${CTEST_USE_LAUNCHERS} # ----------------- Miscellaneous --------------- -DMITK_CTEST_SCRIPT_MODE:STRING=${MITK_CTEST_SCRIPT_MODE} -DMITK_SUPERBUILD_BINARY_DIR:PATH=${MITK_BINARY_DIR} -DMITK_MODULES_TO_BUILD:INTERNAL=${MITK_MODULES_TO_BUILD} -DMITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_INTEGRAL_PIXEL_TYPES} -DMITK_ACCESSBYITK_FLOATING_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_FLOATING_PIXEL_TYPES} -DMITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES:STRING=${MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES} -DMITK_ACCESSBYITK_DIMENSIONS:STRING=${MITK_ACCESSBYITK_DIMENSIONS} # --------------- External project dirs --------------- -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} -DMITK_KWSTYLE_EXECUTABLE:FILEPATH=${MITK_KWSTYLE_EXECUTABLE} -DCTK_DIR:PATH=${CTK_DIR} -DDCMTK_DIR:PATH=${DCMTK_DIR} -DVTK_DIR:PATH=${VTK_DIR} # FindVTK expects VTK_DIR -DITK_DIR:PATH=${ITK_DIR} # FindITK expects ITK_DIR -DACVD_DIR:PATH=${ACVD_DIR} -DOpenCV_DIR:PATH=${OpenCV_DIR} -DSOFA_DIR:PATH=${SOFA_DIR} -DGDCM_DIR:PATH=${GDCM_DIR} -DBOOST_ROOT:PATH=${BOOST_ROOT} -DMITK_USE_Boost_LIBRARIES:STRING=${MITK_USE_Boost_LIBRARIES} -DMITK_DATA_DIR:PATH=${MITK_DATA_DIR} CMAKE_ARGS ${mitk_initial_cache_arg} SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} BINARY_DIR ${CMAKE_BINARY_DIR}/MITK-build BUILD_COMMAND "" INSTALL_COMMAND "" DEPENDS MITK-Utilities ) #----------------------------------------------------------------------------- # MITK #----------------------------------------------------------------------------- if(CMAKE_GENERATOR MATCHES ".*Makefiles.*") set(mitk_build_cmd "$(MAKE)") else() set(mitk_build_cmd ${CMAKE_COMMAND} --build ${CMAKE_CURRENT_BINARY_DIR}/MITK-build --config ${CMAKE_CFG_INTDIR}) endif() if(NOT DEFINED SUPERBUILD_EXCLUDE_MITKBUILD_TARGET OR NOT SUPERBUILD_EXCLUDE_MITKBUILD_TARGET) set(MITKBUILD_TARGET_ALL_OPTION "ALL") else() set(MITKBUILD_TARGET_ALL_OPTION "") endif() add_custom_target(MITK-build ${MITKBUILD_TARGET_ALL_OPTION} COMMAND ${mitk_build_cmd} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build DEPENDS MITK-Configure ) #----------------------------------------------------------------------------- # Custom target allowing to drive the build of the MITK project itself #----------------------------------------------------------------------------- add_custom_target(MITK COMMAND ${mitk_build_cmd} WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/MITK-build )