[Insight-users] problems with Fuzzyconnectedness&Discretegaussian
filters
Luis Ibanez
luis.ibanez at kitware.com
Mon Feb 20 11:40:16 EST 2006
Hi Ramakrishna,
1) When a method is Patented, you can not use it, not even
for research purposes, unless you get a license from the
patent holder.
Please contact:
Dr. Jay Udupa at the University of Pennsylvania
and ask him what would be the appropriate office at U.Penn
for you to request a license for using this method.
[ Dr. Udupa's email is in cc to this email ]
2) Please describe the problem that you have with the
SimpleFuzzyConnectednessScalarImageFilter
From your CMakeLists.txt file we cannot figure out
what kind of problem do you have.
Is it a configuration problem ?
Is it a compilation problem ?
Is it a linking problem ?
3) Please post to the list a minimal source code file where
you can reproduce the problem that you are reporting with
the DiscreteGaussianImageFilter.
You may also want to look at the usage of this filter, as
it is described in the ITK Software Guide:
http://www.itk.org/ItkSoftwareGuide.pdf
the source code of this example is available in
the directory:
Insight/
Examples/
Filtering/
DiscreteGaussianImageFilter.cxx
Regards,
Luis
---------------------------
Ramakrishna Paruchuri wrote:
> Dear Luis,
> following are my problem with ITK at the moment:
> 1.I tried somuch with simplefuzzyconnectednessscalarimage filetr and
> finally i am sending this camake list file in this mail.i could not trace
> theproblem why this is not working.it is specially mentioned that user
> should get permission from author for these patented folder files.what it
> exactly means? i am attching cmakelist in this mail.
> 2.i am trying to implement DiscreteGaussianImageFilter. but this filter is
> throwing an exception during the execution in the following way:
> "itk:error multithreader(395AEFF8)Exception occured during single method
> execute"
> and the error is coming from the following file
> "code\common\itkmultithread.cxx(358)
> can you please help me to fix these problems.
>
>
> ------------------------------------------------------------------------
>
> # This is the root ITK CMakeLists file.
> CMAKE_MINIMUM_REQUIRED(VERSION 1.8)
>
> PROJECT(ITK)
> INCLUDE_REGULAR_EXPRESSION("^([Nn]rrd|itk|vtk|vnl|vcl|vxl|f2c|netlib|ce|itpack|DICOM|meta|png|dbh|tif|jpeg|zlib|gdcm).*$")
> SOURCE_GROUP("XML Files" REGULAR_EXPRESSION "[.]xml$")
>
> # On Visual Studio 8 MS deprecated C. This removes all 1.276E1265 security
> # warnings
> IF(WIN32)
> IF(NOT BORLAND)
> IF(NOT CYGWIN)
> IF(NOT MINGW)
> IF(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS)
> ADD_DEFINITIONS(
> -D_CRT_FAR_MAPPINGS_NO_DEPRECATE
> -D_CRT_IS_WCTYPE_NO_DEPRECATE
> -D_CRT_MANAGED_FP_NO_DEPRECATE
> -D_CRT_NONSTDC_NO_DEPRECATE
> -D_CRT_SECURE_NO_DEPRECATE
> -D_CRT_SECURE_NO_DEPRECATE_GLOBALS
> -D_CRT_SETERRORMODE_BEEP_SLEEP_NO_DEPRECATE
> -D_CRT_TIME_FUNCTIONS_NO_DEPRECATE
> -D_CRT_VCCLRIT_NO_DEPRECATE
> -D_SCL_SECURE_NO_DEPRECATE
> )
> ENDIF(NOT ITK_ENABLE_VISUAL_STUDIO_DEPRECATED_C_WARNINGS)
> ENDIF(NOT MINGW)
> ENDIF(NOT CYGWIN)
> ENDIF(NOT BORLAND)
> ENDIF(WIN32)
>
> # Don't build anything unless the version of CMake is high enough.
> # The matching ELSE/ENDIF should be the last lines in the file.
> IF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.7)
>
> # If CMake is the version we're expecting, don't show the
> # CMAKE_BACKWARDS_COMPATIBILITY option.
> IF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" MATCHES "^1\\.8$")
> MARK_AS_ADVANCED(FORCE CMAKE_BACKWARDS_COMPATIBILITY)
> ELSE("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" MATCHES "^1\\.8$")
> MARK_AS_ADVANCED(CLEAR CMAKE_BACKWARDS_COMPATIBILITY)
> ENDIF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" MATCHES "^1\\.8$")
>
> #-----------------------------------------------------------------------------
> # ITK version number. An even minor number corresponds to releases.
> SET(ITK_VERSION_MAJOR "2")
> SET(ITK_VERSION_MINOR "4")
> SET(ITK_VERSION_PATCH "0")
>
> # Version string should not include patch level. The major.minor is
> # enough to distinguish available features of the toolkit.
> SET(ITK_VERSION_STRING "${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}")
>
> #-----------------------------------------------------------------------------
> # Load some macros.
> INCLUDE(${ITK_SOURCE_DIR}/Utilities/itkThirdParty.cmake)
>
> #-----------------------------------------------------------------------------
> # Test for some required system information.
> INCLUDE (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityC.cmake)
> INCLUDE (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityCXX.cmake)
>
> #-----------------------------------------------------------------------------
> # Configure Dart testing support. This should be done before any
> # MESSAGE(FATAL_ERROR ...) commands are invoked.
> INCLUDE(${CMAKE_ROOT}/Modules/Dart.cmake)
> MARK_AS_ADVANCED(TCL_TCLSH DART_ROOT)
> IF(BUILD_TESTING)
> ENABLE_TESTING()
> CONFIGURE_FILE(${ITK_SOURCE_DIR}/InsightLogo.gif
> ${ITK_BINARY_DIR}/Testing/HTML/TestingResults/Icons/Logo.gif
> COPYONLY IMMEDIATE)
> SET(BUILDNAME "${BUILDNAME}" CACHE STRING "Name of build on the dashboard")
> MARK_AS_ADVANCED(BUILDNAME)
> ENDIF(BUILD_TESTING)
>
> #-----------------------------------------------------------------------------
> # Output directories.
> SET (LIBRARY_OUTPUT_PATH ${ITK_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all libraries.")
> SET (EXECUTABLE_OUTPUT_PATH ${ITK_BINARY_DIR}/bin CACHE INTERNAL "Single output directory for building all executables.")
> MARK_AS_ADVANCED(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)
> SET(ITK_LIBRARY_PATH "${LIBRARY_OUTPUT_PATH}")
> SET(ITK_EXECUTABLE_PATH "${EXECUTABLE_OUTPUT_PATH}")
> SET(CXX_TEST_PATH ${EXECUTABLE_OUTPUT_PATH})
>
> SET(CMAKE_MODULE_PATH ${ITK_SOURCE_DIR}/CMake)
> # Deal with FFT v3 Options
> MARK_AS_ADVANCED(USE_FFTWD)
> OPTION(USE_FFTWD "Use double precision FFTW if found" OFF)
> MARK_AS_ADVANCED(USE_FFTWF)
> OPTION(USE_FFTWF "Use single precision FFTW if found" OFF)
> IF( USE_FFTWD OR USE_FFTWF )
> FIND_PACKAGE( FFTW )
> ENDIF( USE_FFTWD OR USE_FFTWF )
>
> # Deal with SGI SCSL Options
> OPTION(USE_SCSL "Use the SGI SCSL High Performance Computing math library" OFF)
> MARK_AS_ADVANCED(USE_SCSL)
> IF( USE_SCSL )
> FIND_PACKAGE( SCSL )
> ENDIF( USE_SCSL )
>
> # Put "." in the rpath of all ITK shared libraries.
> LINK_DIRECTORIES(.)
>
> #-----------------------------------------------------------------------------
> # ITK build configuration options.
> OPTION(BUILD_SHARED_LIBS "Build ITK with shared libraries." OFF)
> SET(ITK_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
>
> OPTION(ITK_CSWIG_TCL "Build cswig Tcl wrapper support (requires CableSwig)." OFF)
> OPTION(ITK_CSWIG_PYTHON "Build cswig Python wrapper support (requires CableSwig)." OFF)
> OPTION(ITK_CSWIG_JAVA "Build cswig Java wrapper support " OFF)
>
> # Options for building some of the most common core templates explicitly only
> # once. This has only been tested on gcc compilers.
> OPTION(ITK_EXPLICIT_INSTANTIATION "BETA-Try to explicitly build some of the core templates explictitly rather than over and over again." OFF)
> MARK_AS_ADVANCED(ITK_EXPLICIT_INSTANTIATION)
> IF( ITK_EXPLICIT_INSTANTIATION )
> ADD_DEFINITIONS(-DITK_EXPLICIT_INSTANTIATION)
> ENDIF( ITK_EXPLICIT_INSTANTIATION )
> # perl support does not work, contact bill hoffman at kitware
> # if you are interested in perl wrapping. It is close, but
> # not there yet.
> #OPTION(ITK_CSWIG_PERL "Build cswig Perl wrapper support " OFF)
>
> #-----------------------------------------------------------------------------
> # ITK build patented algorithms
> OPTION(ITK_USE_PATENTED "Build algorithms that are covered with Patents. It is YOUR responsibility to obtain a license from the patent holder in order to use these methods." OFF)
> MARK_AS_ADVANCED(ITK_USE_PATENTED)
>
> #-----------------------------------------------------------------------------
> # Do we need CableSwig?
> SET(ITK_NEED_CableSwig 0)
>
> IF(ITK_CSWIG_TCL)
> SET(ITK_NEED_CableSwig 1)
> ENDIF(ITK_CSWIG_TCL)
>
> IF(ITK_CSWIG_PYTHON)
> SET(ITK_NEED_CableSwig 1)
> ENDIF(ITK_CSWIG_PYTHON)
>
> IF(ITK_CSWIG_JAVA)
> SET(ITK_NEED_CableSwig 1)
> ENDIF(ITK_CSWIG_JAVA)
>
> IF(ITK_CSWIG_PERL)
> SET(ITK_NEED_CableSwig 1)
> ENDIF(ITK_CSWIG_PERL)
>
> IF(ITK_NEED_CableSwig)
> IF(NOT BUILD_SHARED_LIBS)
> MESSAGE(FATAL_ERROR "Wrapping requires a shared build, change BUILD_SHARED_LIBS to ON")
> ENDIF(NOT BUILD_SHARED_LIBS)
> ENDIF(ITK_NEED_CableSwig)
>
> #-----------------------------------------------------------------------------
> # Find CableSwig if necessary.
> IF(ITK_NEED_CableSwig)
> IF(EXISTS ${ITK_SOURCE_DIR}/Utilities/CableSwig)
> SET(CMAKE_MODULE_PATH ${ITK_SOURCE_DIR}/Utilities/CableSwig/SWIG/CMake)
>
> # CableSwig is included in the source distribution.
> SET(ITK_BUILD_CABLESWIG 1)
> SET(CableSwig_DIR ${ITK_BINARY_DIR}/Utilities/CableSwig)
> SET(CableSwig_FOUND 1)
> SET(CableSwig_INSTALL_ROOT /lib/InsightToolkit/CSwig)
> INCLUDE(${CableSwig_DIR}/CableSwigConfig.cmake OPTIONAL)
> ELSE(EXISTS ${ITK_SOURCE_DIR}/Utilities/CableSwig)
> # CableSwig is not included in the source distribution. Find it.
> FIND_PACKAGE(CableSwig)
> SET(CMAKE_MODULE_PATH ${CableSwig_DIR}/SWIG/CMake)
>
> # Hack for CMake 1.6 compatability.
> IF(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 1.7)
> SET(CableSwig_FOUND ${CABLESWIG_FOUND})
> SET(CableSwig_DIR ${CABLESWIG_DIR})
> ENDIF(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 1.7)
> ENDIF(EXISTS ${ITK_SOURCE_DIR}/Utilities/CableSwig)
>
> IF(NOT CableSwig_FOUND)
> # We have not found CableSwig. Complain.
> MESSAGE(FATAL_ERROR "CableSwig is required for CSwig Wrapping.")
> ENDIF(NOT CableSwig_FOUND)
> ENDIF(ITK_NEED_CableSwig)
>
> #-----------------------------------------------------------------------------
>
>
> #-----------------------------------------------------------------------------
> # Find wrapping language API libraries.
> IF(ITK_CSWIG_TCL)
> FIND_PACKAGE(TCL)
> # Hide useless settings provided by FindTCL.
> FOREACH(entry TCL_LIBRARY_DEBUG
> TK_LIBRARY_DEBUG
> TCL_STUB_LIBRARY
> TCL_STUB_LIBRARY_DEBUG
> TK_STUB_LIBRARY
> TK_STUB_LIBRARY_DEBUG
> TK_WISH)
> SET(${entry} "${${entry}}" CACHE INTERNAL "This value is not used by ITK.")
> ENDFOREACH(entry)
> ENDIF(ITK_CSWIG_TCL)
>
> IF(ITK_CSWIG_PYTHON)
> INCLUDE(${CMAKE_ROOT}/Modules/FindPythonLibs.cmake)
> FIND_PROGRAM(PYTHON_EXECUTABLE
> NAMES python python2.3 python2.2 python2.1 python2.0 python1.6 python1.5
> PATHS
> [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\2.3\\InstallPath]
> [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\2.2\\InstallPath]
> [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\2.1\\InstallPath]
> [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\2.0\\InstallPath]
> [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\1.6\\InstallPath]
> [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\1.5\\InstallPath]
> )
> MARK_AS_ADVANCED(PYTHON_EXECUTABLE)
> ENDIF(ITK_CSWIG_PYTHON)
>
> IF(ITK_CSWIG_JAVA)
> FIND_PACKAGE(Java)
> FIND_PACKAGE(JNI)
> ENDIF(ITK_CSWIG_JAVA)
> IF(ITK_CSWIG_PERL)
> FIND_PACKAGE(Perl)
> FIND_PACKAGE(PerlLibs)
> ENDIF(ITK_CSWIG_PERL)
>
> IF(WIN32)
> IF(BUILD_SHARED_LIBS)
> SET(ITK_COMMON_BUILD_TYPE "SHARED")
> ELSE(BUILD_SHARED_LIBS)
> SET(ITK_COMMON_BUILD_TYPE "STATIC")
> ENDIF(BUILD_SHARED_LIBS)
> SET(BUILD_SHARED_LIBS OFF)
> ENDIF(WIN32)
>
> OPTION(BUILD_EXAMPLES "Build the Examples directory." ON)
>
> OPTION(ITK_USE_SYSTEM_VXL "Use an outside build of VXL." OFF)
> MARK_AS_ADVANCED(ITK_USE_SYSTEM_VXL)
> IF(ITK_USE_SYSTEM_VXL)
> FIND_PACKAGE(VXL)
> IF(VXL_FOUND)
> INCLUDE(${VXL_CMAKE_DIR}/UseVXL.cmake)
> SET(VXL_NUMERICS_LIBRARIES vnl vnl_algo netlib vcl)
> ELSE(VXL_FOUND)
> MESSAGE(FATAL_ERROR "Must set VXL_DIR for ITK_USE_SYSTEM_VXL.")
> ENDIF(VXL_FOUND)
> ELSE(ITK_USE_SYSTEM_VXL)
> SET(VXL_NETLIB_INCLUDE_DIR ${ITK_SOURCE_DIR}/Utilities/vxl/v3p/netlib)
> SET(VXL_NUMERICS_LIBRARIES itkvnl itkvnl_algo itknetlib)
> ENDIF(ITK_USE_SYSTEM_VXL)
>
> # Provide options to use system versions of third-party libraries.
> ITK_THIRD_PARTY_OPTION(ZLIB zlib)
> ITK_THIRD_PARTY_OPTION(PNG png)
> ITK_THIRD_PARTY_OPTION(TIFF tiff)
>
> MARK_AS_ADVANCED(ITK_CSWIG_PYTHON)
> MARK_AS_ADVANCED(ITK_CSWIG_TCL)
> MARK_AS_ADVANCED(ITK_CSWIG_JAVA)
> MARK_AS_ADVANCED(ITK_CSWIG_PERL)
> MARK_AS_ADVANCED(CABLE_INDEX)
> MARK_AS_ADVANCED(CSWIG)
> MARK_AS_ADVANCED(GCCXML)
>
> #-----------------------------------------------------------------------------
> # Dispatch the build into the proper subdirectories.
> SUBDIRS(Utilities Code)
>
> # set a variable to determine if
> # the Wrapping/CSwig directory should be used
> SET(ITK_CSWIG_DIR 0)
> IF(ITK_CSWIG_TCL)
> SET(ITK_CSWIG_DIR 1)
> ENDIF(ITK_CSWIG_TCL)
> IF(ITK_CSWIG_PYTHON)
> SET(ITK_CSWIG_DIR 1)
> ENDIF(ITK_CSWIG_PYTHON)
> IF(ITK_CSWIG_JAVA)
> SET(ITK_CSWIG_DIR 1)
> ENDIF(ITK_CSWIG_JAVA)
>
> IF(ITK_CSWIG_DIR)
> SUBDIRS(Wrapping/CSwig)
> ENDIF(ITK_CSWIG_DIR)
>
> IF (BUILD_TESTING)
> SUBDIRS(Testing)
> ENDIF (BUILD_TESTING)
>
> IF(BUILD_EXAMPLES)
> SUBDIRS(Examples)
> ENDIF(BUILD_EXAMPLES)
>
> #-----------------------------------------------------------------------------
> # ITK requires special compiler flags on some platforms.
> IF(CMAKE_COMPILER_IS_GNUCXX)
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -ftemplate-depth-50")
> IF(APPLE)
> SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -no-cpp-precomp")
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -no-cpp-precomp")
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -Wno-long-double")
> ENDIF(APPLE)
> ENDIF(CMAKE_COMPILER_IS_GNUCXX)
>
> IF(UNIX)
> IF(NOT CMAKE_COMPILER_IS_GNUCXX)
> INCLUDE(${ITK_SOURCE_DIR}/CMake/TestNO_ICC_IDYNAMIC_NEEDED.cmake)
> TESTNO_ICC_IDYNAMIC_NEEDED(NO_ICC_IDYNAMIC_NEEDED ${ITK_SOURCE_DIR}/CMake )
> IF(NO_ICC_IDYNAMIC_NEEDED)
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS}")
> ELSE(NO_ICC_IDYNAMIC_NEEDED)
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -i_dynamic")
> ENDIF(NO_ICC_IDYNAMIC_NEEDED)
> ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
> ENDIF(UNIX)
>
> # Force the use of ansi cxx flags (i.e. -LANG:std on sgi )
> IF("x${CMAKE_ANSI_CXXFLAGS}" MATCHES "^x.*[^ ]")
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}")
> ENDIF("x${CMAKE_ANSI_CXXFLAGS}" MATCHES "^x.*[^ ]")
> IF("x${CMAKE_ANSI_CFLAGS}" MATCHES "^x.*[^ ]")
> SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} ${CMAKE_ANSI_CFLAGS}")
> ENDIF("x${CMAKE_ANSI_CFLAGS}" MATCHES "^x.*[^ ]")
>
> IF(CMAKE_SYSTEM MATCHES "IRIX.*")
> IF(NOT CMAKE_COMPILER_IS_GNUCXX)
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -woff 15,84,1110,1209,1424,1468,3102,3210,3439 -no_auto_include -ptused -no_prelink")
> SET(ITK_REQUIRED_LINK_FLAGS "${ITK_REQUIRED_LINK_FLAGS} -Wl,-woff15")
> ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
> ENDIF(CMAKE_SYSTEM MATCHES "IRIX.*")
>
> IF(MINGW)
> LINK_LIBRARIES(gdi32)
> ENDIF(MINGW)
>
> # for the gnu compiler a -D_PTHREADS is needed on sun
> # for the native compiler a -mt flag is needed on the sun
> IF(CMAKE_USE_PTHREADS)
> IF(CMAKE_SYSTEM MATCHES "SunOS.*")
> IF(CMAKE_COMPILER_IS_GNUCXX)
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -D_PTHREADS")
> ELSE(CMAKE_COMPILER_IS_GNUCXX)
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -mt")
> SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -mt")
> ENDIF(CMAKE_COMPILER_IS_GNUCXX)
> ENDIF(CMAKE_SYSTEM MATCHES "SunOS.*")
> ENDIF(CMAKE_USE_PTHREADS)
>
> IF(WIN32)
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -DNOMINMAX")
> ENDIF(WIN32)
>
> # mingw thread support
> IF(MINGW)
> SET(ITK_REQUIRED_CXX_FLAGS "${ITK_REQUIRED_CXX_FLAGS} -mthreads")
> SET(ITK_REQUIRED_C_FLAGS "${ITK_REQUIRED_C_FLAGS} -mthreads")
> SET(ITK_REQUIRED_LINK_FLAGS "${ITK_REQUIRED_LINK_FLAGS} -mthreads")
> ENDIF(MINGW)
>
> #-----------------------------------------------------------------------------
> # Find platform-specific differences in the handling of IEEE floating point
> # special values.
> INCLUDE(${ITK_SOURCE_DIR}/CMake/CheckBigBitfield.cmake)
> CHECK_BIG_BITFIELD(BIGBITFIELD_VALUE ${ITK_SOURCE_DIR}/CMake)
> IF(BIGBITFIELD_VALUE)
> SET(BIGBITFIELD 1 CACHE INTERNAL "System handles bit-fields larger than 32 bits.")
> ELSE(BIGBITFIELD_VALUE)
> SET(BIGBITFIELD 0 CACHE INTERNAL "System handles bit-fields larger than 32 bits.")
> ENDIF(BIGBITFIELD_VALUE)
>
> INCLUDE(${ITK_SOURCE_DIR}/CMake/TestQnanhibit.cmake)
> TEST_QNANHIBIT(QNANHIBIT_VALUE ${ITK_SOURCE_DIR}/CMake)
> IF(QNANHIBIT_VALUE)
> SET(QNANHIBIT 1 CACHE INTERNAL "The 22nd bit of 32-bit floating-point quiet NaN.")
> ELSE(QNANHIBIT_VALUE)
> SET(QNANHIBIT 0 CACHE INTERNAL "The 22nd bit of 32-bit floating-point quiet NaN.")
> ENDIF(QNANHIBIT_VALUE)
>
> IF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.0)
> ELSE("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.0)
> INCLUDE(CheckTypeSize)
> ENDIF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.0)
>
> CHECK_TYPE_SIZE("long long" ITK_SIZEOF_LONG_LONG)
> CHECK_TYPE_SIZE("__int64" ITK_SIZEOF___INT64)
>
> IF(ITK_SIZEOF___INT64)
> IF("ITK_TYPE_SAME_LONG_AND___INT64" MATCHES "^ITK_TYPE_SAME_LONG_AND___INT64$")
> MESSAGE(STATUS "Checking whether long and __int64 are the same type")
> TRY_COMPILE(ITK_TYPE_SAME_LONG_AND___INT64
> ${ITK_BINARY_DIR}/CMakeTmp
> ${ITK_SOURCE_DIR}/CMake/itkTestCompareTypes.cxx
> COMPILE_DEFINITIONS
> -DITK_TEST_COMPARE_TYPE_1=long
> -DITK_TEST_COMPARE_TYPE_2=__int64
> OUTPUT_VARIABLE OUTPUT)
> IF(ITK_TYPE_SAME_LONG_AND___INT64)
> MESSAGE(STATUS "Checking whether long and __int64 are the same type -- yes")
> SET(ITK_TYPE_SAME_LONG_AND___INT64 1 CACHE INTERNAL "Whether long and __int64 are the same type")
> ELSE(ITK_TYPE_SAME_LONG_AND___INT64)
> MESSAGE(STATUS "Checking whether long and __int64 are the same type -- no")
> SET(ITK_TYPE_SAME_LONG_AND___INT64 0 CACHE INTERNAL "Whether long and __int64 are the same type")
> WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeError.log
> "Determining whether long and __int64 are the same type "
> "failed with the following output:\n"
> "${OUTPUT}\n" APPEND)
> ENDIF(ITK_TYPE_SAME_LONG_AND___INT64)
> ENDIF("ITK_TYPE_SAME_LONG_AND___INT64" MATCHES "^ITK_TYPE_SAME_LONG_AND___INT64$")
> ENDIF(ITK_SIZEOF___INT64)
>
> IF(ITK_SIZEOF_LONG_LONG)
> CONFIGURE_FILE(${ITK_SOURCE_DIR}/CMake/itkTestStreamLongLong.cxx.in
> ${ITK_BINARY_DIR}/CMake/itkTestStreamLongLong.cxx @ONLY IMMEDIATE)
> IF("ITK_OSTREAM_SUPPORTS_LONG_LONG" MATCHES "^ITK_OSTREAM_SUPPORTS_LONG_LONG$")
> MESSAGE(STATUS "Checking if ostream supports long long")
> TRY_COMPILE(ITK_OSTREAM_SUPPORTS_LONG_LONG
> ${ITK_BINARY_DIR}
> ${ITK_BINARY_DIR}/CMake/itkTestStreamLongLong.cxx
> COMPILE_DEFINITIONS -DITK_TEST_OSTREAM_LONG_LONG
> OUTPUT_VARIABLE OUTPUT)
> IF(ITK_OSTREAM_SUPPORTS_LONG_LONG)
> MESSAGE(STATUS "Checking if ostream supports long long -- yes")
> SET(ITK_OSTREAM_SUPPORTS_LONG_LONG 1 CACHE INTERNAL "Whether ostream supports long long")
> ELSE(ITK_OSTREAM_SUPPORTS_LONG_LONG)
> MESSAGE(STATUS "Checking if ostream supports long long -- no")
> SET(ITK_OSTREAM_SUPPORTS_LONG_LONG 0 CACHE INTERNAL "Whether ostream supports long long")
> WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeError.log
> "Determining if ostream supports long long "
> "failed with the following output:\n"
> "${OUTPUT}\n" APPEND)
> ENDIF(ITK_OSTREAM_SUPPORTS_LONG_LONG)
> ENDIF("ITK_OSTREAM_SUPPORTS_LONG_LONG" MATCHES "^ITK_OSTREAM_SUPPORTS_LONG_LONG$")
> IF("ITK_ISTREAM_SUPPORTS_LONG_LONG" MATCHES "^ITK_ISTREAM_SUPPORTS_LONG_LONG$")
> MESSAGE(STATUS "Checking if istream supports long long")
> TRY_COMPILE(ITK_ISTREAM_SUPPORTS_LONG_LONG
> ${ITK_BINARY_DIR}
> ${ITK_BINARY_DIR}/CMake/itkTestStreamLongLong.cxx
> COMPILE_DEFINITIONS -DITK_TEST_ISTREAM_LONG_LONG
> OUTPUT_VARIABLE OUTPUT)
> IF(ITK_ISTREAM_SUPPORTS_LONG_LONG)
> MESSAGE(STATUS "Checking if istream supports long long -- yes")
> SET(ITK_ISTREAM_SUPPORTS_LONG_LONG 1 CACHE INTERNAL "Whether istream supports long long")
> ELSE(ITK_ISTREAM_SUPPORTS_LONG_LONG)
> MESSAGE(STATUS "Checking if istream supports long long -- no")
> SET(ITK_ISTREAM_SUPPORTS_LONG_LONG 0 CACHE INTERNAL "Whether istream supports long long")
> WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeError.log
> "Determining if istream supports long long "
> "failed with the following output:\n"
> "${OUTPUT}\n" APPEND)
> ENDIF(ITK_ISTREAM_SUPPORTS_LONG_LONG)
> ENDIF("ITK_ISTREAM_SUPPORTS_LONG_LONG" MATCHES "^ITK_ISTREAM_SUPPORTS_LONG_LONG$")
> ENDIF(ITK_SIZEOF_LONG_LONG)
>
>
> #-----------------------------------------------------------------------------
> # Configure the default ITK_DATA_ROOT for the location of ITK Data.
> FIND_PATH(ITK_DATA_ROOT ITKData.readme ${ITK_SOURCE_DIR}/Testing/Data $ENV{ITK_DATA_ROOT})
> MARK_AS_ADVANCED(ITK_DATA_ROOT)
>
>
> #-----------------------------------------------------------------------------
> # Configure files with settings for use by the build.
> CONFIGURE_FILE(${ITK_SOURCE_DIR}/itkConfigure.h.in
> ${ITK_BINARY_DIR}/itkConfigure.h)
> CONFIGURE_FILE(${ITK_SOURCE_DIR}/Utilities/Doxygen/doxygen.config.in
> ${ITK_BINARY_DIR}/doxygen.config)
> CONFIGURE_FILE(${ITK_SOURCE_DIR}/Utilities/Doxygen/itkdoxygen.pl.in
> ${ITK_BINARY_DIR}/itkdoxygen.pl)
>
> #-----------------------------------------------------------------------------
> # The entire ITK tree should use the same include path, except for the
> # Wrapping directory.
>
> # Create the list of include directories needed for ITK header files.
> INCLUDE(${ITK_SOURCE_DIR}/itkIncludeDirectories.cmake)
>
> # This should be the only INCLUDE_DIRECTORIES command in the entire
> # tree, except for the Utilities and Wrapping directories. We need to
> # do this in one place to make sure the order is correct.
> INCLUDE_DIRECTORIES(
> ${ITK_INCLUDE_DIRS_BUILD_TREE}
> ${ITK_INCLUDE_DIRS_BUILD_TREE_CXX}
> ${ITK_INCLUDE_DIRS_SYSTEM}
> )
>
> #-----------------------------------------------------------------------------
> # Help other projects use ITK.
>
> # Copy the UseITK.cmake file to the binary tree for backward compatability.
> CONFIGURE_FILE(${ITK_SOURCE_DIR}/UseITK.cmake.in
> ${ITK_BINARY_DIR}/UseITK.cmake COPYONLY IMMEDIATE)
>
> # Save the compiler settings so another project can import them.
> INCLUDE(${CMAKE_ROOT}/Modules/CMakeExportBuildSettings.cmake)
> CMAKE_EXPORT_BUILD_SETTINGS(${ITK_BINARY_DIR}/ITKBuildSettings.cmake)
> INSTALL_FILES(/lib/InsightToolkit .cmake ITKBuildSettings)
>
> # Save library dependencies.
> EXPORT_LIBRARY_DEPENDENCIES(${ITK_BINARY_DIR}/ITKLibraryDepends.cmake)
>
> # Create the ITKConfig.cmake file containing the ITK configuration.
> INCLUDE (${ITK_SOURCE_DIR}/itkGenerateITKConfig.cmake)
>
> # Install some files.
> INSTALL_FILES(/include/InsightToolkit .h itkConfigure)
> INSTALL_FILES(/lib/InsightToolkit .cmake UseITK ITKLibraryDepends)
>
> #-----------------------------------------------------------------------------
> # Add compiler flags ITK needs to work on this platform. This must be
> # done AFTER the call to CMAKE_EXPORT_BUILD_SETTINGS.
>
> SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ITK_REQUIRED_C_FLAGS}")
> SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ITK_REQUIRED_CXX_FLAGS}")
> SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
> SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
> SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${ITK_REQUIRED_LINK_FLAGS}")
> #-----------------------------------------------------------------------------
> # The frename-registers option does not work due to a bug in the gnu compiler.
> # It must be removed or data errors will be produced and incorrect results
> # will be produced. This is first documented in the gcc4 man page.
> IF(CMAKE_COMPILER_IS_GNUCXX)
> SET(ALL_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CXX_FLAGS} ${CMAKE_EXE_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}" )
> SEPARATE_ARGUMENTS(ALL_FLAGS)
> FOREACH(COMP_OPTION ${ALL_FLAGS})
> # MESSAGE("${COMP_OPTION} being checked.")
> IF("${COMP_OPTION}" STREQUAL "-frename-registers")
> MESSAGE(FATAL_ERROR "-frename-registers causes runtime bugs. It must be removed from your compilation options.")
> ENDIF("${COMP_OPTION}" STREQUAL "-frename-registers")
> IF("${COMP_OPTION}" STREQUAL "-ffloat-store")
> MESSAGE(FATAL_ERROR "-ffloat-store causes runtime bugs on gcc 3.2.3 (appearently not on gcc 3.4.3, but the exact criteria is not known). It must be removed from your compilation options.")
> ENDIF("${COMP_OPTION}" STREQUAL "-ffloat-store")
> ENDFOREACH(COMP_OPTION)
> ENDIF(CMAKE_COMPILER_IS_GNUCXX)
>
> # If the version of CMake was too old, complain and build nothing.
> # These should be the last lines in this file.
> ELSE("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.7)
> MESSAGE(SEND_ERROR
> "This version of CMake is too old to build this version of ITK. "
> "Please upgrade to CMake 1.8.")
> ENDIF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.7)
>
>
> ------------------------------------------------------------------------
>
> _______________________________________________
> Insight-users mailing list
> Insight-users at itk.org
> http://www.itk.org/mailman/listinfo/insight-users
More information about the Insight-users
mailing list