.circleci/circleci.cmake

+
+# set_from_env
+# ------------
+#
+# Sets a CMake variable from an environment variable. If the
+# environment variable  is not  defined then either a fatal error is
+# generated or the CMake variable is not modified.
+#
+# set_from_env( <variable> <environment variable> [REQUIRED|DEFAULT value] )
+function(set_from_env var env_var)
+  if(NOT DEFINED ENV{${env_var}})
+    if (ARGV2 STREQUAL "REQUIRED")
+      message(FATAL_ERROR "Required environment variable \"${env_var}\" not defined.")
+    elseif (ARGV2 STREQUAL "DEFAULT")
+      set(${var} ${ARGV3} PARENT_SCOPE)
+    endif()
+  else()
+    set(${var} $ENV{${env_var}} PARENT_SCOPE)
+  endif()
+endfunction()
+
+set(CTEST_SITE "CircleCI")
+set(CTEST_UPDATE_VERSION_ONLY 1)
+
+
+# Make environment variables to CMake variables for CTest
+set_from_env(CTEST_CMAKE_GENERATOR "CTEST_CMAKE_GENERATOR" DEFAULT "Unix Makefiles" )
+set_from_env(CTEST_BINARY_DIRECTORY "CTEST_BINARY_DIRECTORY")
+set_from_env(CTEST_DASHBOARD_ROOT  "CTEST_DASHBOARD_ROOT" REQUIRED)
+set_from_env(CTEST_SOURCE_DIRECTORY "CTEST_SOURCE_DIRECTORY" REQUIRED)
+set_from_env(CTEST_CONFIGURATION_TYPE "CTEST_CONFIGURATION_TYPE" DEFAULT "Release")
+set_from_env(CTEST_BUILD_FLAGS "CTEST_BUILD_FLAGS")
+set_from_env(CTEST_BUILD_TARGET "CTEST_BUILD_TARGET")
+set_from_env(CTEST_TEST_ARGS "CTEST_TEST_ARGS")
+
+
+set_from_env(PARALLEL_LEVEL "PARALLEL_LEVEL" DEFAULT 2 )
+set( CTEST_TEST_ARGS ${CTEST_TEST_ARGS} PARALLEL_LEVEL ${PARALLEL_LEVEL})
+
+set_from_env(DASHBOARD_BRANCH_DIRECTORY "DASHBOARD_BRANCH_DIRECTORY" REQUIRED)
+
+# Construct build name based on what is being built
+string(SUBSTRING $ENV{CIRCLE_SHA1} 0 7 commit_sha1)
+set(CTEST_BUILD_NAME "CircleCI-$ENV{CIRCLE_BRANCH}-$ENV{CIRCLE_STAGE}-${commit_sha1}")
+
+set_from_env(dashboard_git_branch "CIRCLE_BRANCH")
+set_from_env(dashboard_model "DASHBOARD_MODEL" DEFAULT "Experimental" )
+set(dashboard_loop 0)
+
+
+if ( EXISTS "${CTEST_SOURCE_DIRECTORY}/circle.yml")
+  list(APPEND CTEST_NOTES_FILES
+    "${CTEST_SOURCE_DIRECTORY}/circle.yml"
+    )
+endif()
+
+if ( EXISTS  "${CTEST_SOURCE_DIRECTORY}/.circleci/config.yml")
+  list(APPEND CTEST_NOTES_FILES
+    "${CTEST_SOURCE_DIRECTORY}/.circleci/config.yml"
+    )
+endif()
+
+
+SET (_dashboard_cache "
+    BUILD_DOCUMENTATION:BOOL=OFF
+    BUILD_EXAMPLES:BOOL=OFF
+    BUILD_SHARED_LIBS:BOOL=ON
+    BUILD_TESTING:BOOL=ON
+
+    SimpleITK_USE_SYSTEM_LUA:BOOL=ON
+    SimpleITK_EXPLICIT_INSTANTIATION:BOOL=OFF
+
+    WRAP_DEFAULT:BOOL=OFF
+" )
+
+set_from_env(dashboard_cache "CTEST_CACHE" DEFAULT ${_dashboard_cache})
+
+
+if (DEFINED ENV{DISTCC_DIR})
+  SET (dashboard_cache "${dashboard_cache}
+     CMAKE_CXX_COMPILER_LAUNCHER:STRING=distcc
+     CMAKE_C_COMPILER_LAUNCHER:STRING=distcc
+" )
+endif()
+
+
+
+include("${DASHBOARD_BRANCH_DIRECTORY}/simpleitk_common.cmake")
+
+if(NOT ${configure_return} EQUAL 0 OR
+   NOT ${build_return} EQUAL 0 OR
+   NOT ${build_errors} EQUAL 0 OR
+   NOT ${build_warnings} EQUAL 0 OR
+   NOT ${test_return} EQUAL 0)
+  message(FATAL_ERROR
+    "Build did not complete without warnings, errors, or failures.")
+else()
+  return(0)
+endif()

.circleci/config.yml

+referenced:
+  defaults: &defaults
+    docker:
+     - image: circleci/python:2.7
+    working_directory: ~/
+    resource_class: large
+    environment:
+      CTEST_DASHBOARD_ROOT: /home/circleci
+      CTEST_SOURCE_DIRECTORY: /home/circleci/SimpleITK
+      CTEST_BINARY_DIRECTORY: /home/circleci/SimpleITK-build
+      CTEST_BUILD_FLAGS: "-j 4"
+      CTEST_CONFIGURATION_TYPE: "Release"
+      CTEST_OUTPUT_ON_FAILURE: 1
+      ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS: 2
+      PARALLEL_LEVEL: 4
+      DASHBOARD_BRANCH_DIRECTORY: /home/circleci/dashboard
+      ExternalData_OBJECT_STORES: /home/circleci/.ExternalData
+      CCACHE_NODIRECT: 1
+  dependencies: &dependencies
+    run:
+      name: Dependencies
+      command: |
+        sudo apt-get install -y rsync lua5.1 ccache kwstyle swig
+        sudo pip install --upgrade pip
+        sudo pip install numpy scikit-ci-addons
+        ci_addons circle/install_cmake.py 3.10.2
+  generate-hash-step: &generate-hash-step
+    run:
+      name: Generate external data hash
+      command: |
+        cd SimpleITK
+        git log -n 1 ${CTEST_SOURCE_DIRECTORY}/Testing/Data/ | tee /home/circleci/external-data.hashable
+  restore-data-step: &restore-data-step
+     restore_cache:
+       keys:
+         - 'v1-external-data-{{ checksum "/home/circleci/external-data.hashable" }}'
+         - 'v1-external-data'
+  restore-ccache-step: &restore-ccache-step
+    restore_cache:
+      keys:
+        - ccache-{{ arch }}-{{ .Branch }}
+        - ccache-{{ arch }}-master
+  clone-dashboard-step: &clone-dashboard-step
+     run:
+       name: Cloning dashboard branch
+       command: |
+         git clone --single-branch ${CIRCLE_REPOSITORY_URL} -b dashboard ${DASHBOARD_BRANCH_DIRECTORY}
+  env-step: &env-step
+     run:
+       name: Additional Environment Variables
+       command: |
+         echo 'export DASHBOARD_MODEL=$( [[ "$CIRCLE_BRANCH" = "master" || "$CIRCLE_BRANCH" = "next"  || "$CIRCLE_BRANCH" = "release" ]] && echo Continuous || echo Experimental )' >> $BASH_ENV
+         echo 'export PATH=/usr/lib/ccache:${PATH}' >> $BASH_ENV
+
+version: 2
+jobs:
+  build-and-test:
+    <<: *defaults
+    steps:
+      - checkout:
+          path : ~/SimpleITK
+      - *generate-hash-step
+      - *restore-data-step
+      - *restore-ccache-step
+      - *clone-dashboard-step
+      - *dependencies
+      - *env-step
+      - run:
+          name: CCache initialization
+          command: |
+            ccache --show-stats
+            ccache --zero-stats
+            ccache --max-size=2.0G
+      - run:
+          name: Build and Testing with CTest
+          no_output_timeout: 20.0m
+          command: |
+            export LD_LIBRARY_PATH="${CTEST_BINARY_DIRECTORY}/ITK-prefix/lib/:${CTEST_BINARY_DIRECTORY}/SimpleITK-build/lib"
+            export CTEST_CACHE="
+              BUILD_DOCUMENTATION:BOOL=OFF
+              BUILD_EXAMPLES:BOOL=OFF
+              BUILD_SHARED_LIBS:BOOL=ON
+
+              SimpleITK_USE_SYSTEM_LUA:BOOL=ON
+              SimpleITK_EXPLICIT_INSTANTIATION:BOOL=OFF
+
+              WRAP_DEFAULT:BOOL=OFF"
+            ctest -V -S "${CTEST_SOURCE_DIRECTORY}/.circleci/circleci.cmake"
+      - run:
+          name: ccache stats
+          when: always
+          command: |
+            ccache --show-stats
+      - run:
+          name: Formatting CTest for JUnit
+          when: always
+          command: |
+            env
+            mkdir -p /tmp/test-results
+            ci_addons ctest_junit_formatter ${CTEST_BINARY_DIRECTORY} > /tmp/test-results/JUnit-${CIRCLE_NODE_INDEX}.xml
+      - store_test_results:
+          path: /tmp/test-results
+          destination: ctest
+      - save_cache:
+          key: 'ccache-{{ arch }}-{{ .Branch }}-{{ epoch }}'
+          paths: [ "/home/circleci/.ccache" ]
+      - save_cache:
+          key: 'v1-external-data-{{ checksum "/home/circleci/external-data.hashable" }}'
+          paths: [ "/home/circleci/.ExternalData" ]
+      - run:
+          name: Cleanup build
+          command: |
+            rm -rf "${CTEST_BINARY_DIRECTORY}/ITK" "${CTEST_BINARY_DIRECTORY}/ITK-build"
+            rm -rf "${CTEST_BINARY_DIRECTORY}/SimpleITK" "${CTEST_BINARY_DIRECTORY}/SimpleITK-build"
+      - persist_to_workspace:
+          root: /home/circleci/SimpleITK-build
+          paths:
+            - "*"
+  python-and-test:
+    <<: *defaults
+    steps:
+      - checkout:
+          path : ~/SimpleITK
+      - *generate-hash-step
+      - *restore-data-step
+      - *clone-dashboard-step
+      - *dependencies
+      - *env-step
+      - attach_workspace:
+          at: /home/circleci/SimpleITK-build
+      - run:
+          name: Build Python and Testing with CTest
+          no_output_timeout: 20.0m
+          command: |
+            export LD_LIBRARY_PATH="${CTEST_BINARY_DIRECTORY}/ITK-prefix/lib/:${CTEST_BINARY_DIRECTORY}/lib"
+            export CTEST_CACHE="CMAKE_PREFIX_PATH:PATH=${CTEST_BINARY_DIRECTORY}
+              SWIG_EXECUTABLE:PATH=${CTEST_BINARY_DIRECTORY}/Swig/bin/swig"
+            export CTEST_BINARY_DIRECTORY="/home/circleci/SimpleITK-py"
+            ctest -V -Ddashboard_source_config_dir:PATH="Wrapping/Python" -S "${CTEST_SOURCE_DIRECTORY}/.circleci/circleci.cmake"
+  docs:
+    <<: *defaults
+    steps:
+      - checkout:
+          path : ~/SimpleITK
+      - *generate-hash-step
+      - *restore-data-step
+      - *restore-ccache-step
+      - *clone-dashboard-step
+      - *dependencies
+      - *env-step
+      - run:
+          name: Additional Dependencies
+          command: |
+            sudo apt-get install -y doxygen
+      - run:
+          name: Building and Generating Doxygen
+          no_output_timeout: 20.0m
+          command: |
+            export CTEST_BUILD_TARGET=SimpleITK-doc
+            export CTEST_CACHE="
+             BUILD_SHARED_LIBS:BOOL=ON
+             WRAP_DEFAULT=OFF
+             BUILD_DOXYGEN=ON
+             SimpleITK_USE_SYSTEM_LUA:BOOL=ON"
+            ctest -V -Ddashboard_no_test:BOOL=1\
+              -Ddashboard_track:BOOL=Doxygen\
+              -S "${CTEST_SOURCE_DIRECTORY}/.circleci/circleci.cmake"
+      - run:
+          name: Archiving directory for artifact
+          command: |
+            cd ${CTEST_BINARY_DIRECTORY}/SimpleITK-build/Documentation/
+            tar -zcvf simpleitk_doxygen_html.tar.gz html
+      - store_artifacts:
+          path: /home/circleci/SimpleITK-build/SimpleITK-build/Documentation/simpleitk_doxygen_html.tar.gz
+workflows:
+  version: 2
+  build_and_test:
+    jobs:
+      - build-and-test:
+          filters:
+            branches:
+               ignore:
+                 - gh-pages
+                 - dashboard
+                 - hooks
+      - python-and-test:
+          requires:
+            - build-and-test
+  nightly:
+    triggers:
+      - schedule:
+          cron: "0 3 * * *"
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+        - docs

CMake/CTestCustom.cmake.in

@@ -54,6 +54,7 @@ SET(CTEST_CUSTOM_WARNING_EXCEPTION
   # Ignore CSharp invalid version warning for dev
   "warning CS1607.*The version number.*dev.*is invalid"
   "warning CS1607.*The version.*dev.*is not in the normal"
+  "warning CS7035.*The specified version string.*does not conform"
 
   # Warning when building R, issue related to make file
   "warning: jobserver unavailable:"

CMake/configure_file_build_time.cmake

+configure_file( "${CONFIGUREBUILDTIME_filename}" "${CONFIGUREBUILDTIME_out_filename}" )

CMake/sitkAddTest.cmake

@@ -2,6 +2,7 @@ include(sitkExternalData)
 include(CMakeParseArguments)
 
 set(SimpleITK_DATA_ROOT ${SimpleITK_SOURCE_DIR}/Testing/Data)
+set(SimpleITK_TEST_OUTPUT_DIR ${CMAKE_BINARY_DIR}/Testing/Temporary)
 
 #-----------------------------------------------------------------------------
 # SimpleITK wrapper for add_test that adds support for external data,
@@ -13,16 +14,26 @@ set(SimpleITK_DATA_ROOT ${SimpleITK_SOURCE_DIR}/Testing/Data)
 #   The first arguments are passed to cmake's add_test function with
 #   support for the DATA{} references to external data
 # TRANSFORM_COMPARE <test transform> <baseline displacement> [tolerance]
+# IMAGE_COMPARE <test image> <baseline image> [tolerance]
+# IMAGE_MD5_COMPARE <test image> <md5 hash>
 function(sitk_add_test)
   set(options "")
   set(oneValueArgs "NAME")
-  set(multiValueArgs COMMAND TRANSFORM_COMPARE)
+  set(multiValueArgs COMMAND TRANSFORM_COMPARE IMAGE_COMPARE IMAGE_MD5_COMPARE)
   cmake_parse_arguments("_" "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
 
   if ( NOT "${__TRANSFORM_COMPARE}" STREQUAL "" )
     set(COMPARE_ARGS ${COMPARE_ARGS} --compareTransform ${__TRANSFORM_COMPARE})
   endif()
 
+  if ( NOT "${__IMAGE_COMPARE}" STREQUAL "" )
+    set(COMPARE_ARGS ${COMPARE_ARGS} --compare ${__IMAGE_COMPARE})
+  endif()
+
+  if ( NOT "${__IMAGE_MD5_COMPARE}" STREQUAL "" )
+    set(COMPARE_ARGS ${COMPARE_ARGS} --compare-MD5 ${__IMAGE_MD5_COMPARE})
+  endif()
+
   if (COMPARE_ARGS)
     set(__COMMAND $<TARGET_FILE:sitkCompareDriver> ${COMPARE_ARGS} -- ${__COMMAND})
   endif()
@@ -30,7 +41,6 @@ function(sitk_add_test)
   # Add test with data in the SimpleITKData group.
   ExternalData_add_test(SimpleITKData NAME ${__NAME} COMMAND ${__COMMAND} ${__UNPARSED_ARGUMENTS})
 
-
 endfunction()
 
 
@@ -52,16 +62,21 @@ function(sitk_add_python_test name)
   endif()
 
   sitk_add_test(NAME Python.${name}
-    COMMAND "${ITK_TEST_DRIVER}"
+    COMMAND
       ${command}
       ${ARGN}
     )
+  set_property(TEST Python.${name}
+      PROPERTY LABELS Python
+      )
+  if (SimpleITK_TESTING_NOSHOW)
     set_property(TEST Python.${name}
         PROPERTY ENVIRONMENT SITK_NOSHOW=YES
         )
+  endif()
   if (NOT SimpleITK_PYTHON_USE_VIRTUALENV)
     set_property(TEST Python.${name}
-      APPEND PROPERTY ENVIRONMENT PYTHONPATH=${SimpleITK_BINARY_DIR}/Wrapping/Python
+      APPEND PROPERTY ENVIRONMENT PYTHONPATH=${SimpleITK_Python_BINARY_DIR}
       )
   endif()
 
@@ -86,16 +101,21 @@ function(sitk_add_lua_test name)
   endif()
 
   sitk_add_test(NAME Lua.${name}
-    COMMAND "${ITK_TEST_DRIVER}"
+    COMMAND
       ${command}
       ${ARGN}
     )
+  set_property(TEST Lua.${name}
+    PROPERTY LABELS Lua
+    )
   set_property(TEST Lua.${name}
     PROPERTY ENVIRONMENT LUA_CPATH=$<TARGET_FILE:SimpleITKLuaModule_LUA>
     )
+  if (SimpleITK_TESTING_NOSHOW)
     set_property(TEST Lua.${name}
       APPEND PROPERTY ENVIRONMENT SITK_NOSHOW=YES
       )
+  endif()
 endfunction()
 
 
@@ -117,11 +137,13 @@ function(sitk_add_ruby_test name)
   endif()
 
   sitk_add_test(NAME Ruby.${name}
-    COMMAND "${ITK_TEST_DRIVER}"
+    COMMAND
       ${command}
       ${ARGN}
     )
-
+  set_property(TEST Ruby.${name}
+    PROPERTY LABELS Ruby
+    )
   set_property(TEST Ruby.${name}
     PROPERTY ENVIRONMENT RUBYLIB=$<TARGET_FILE_DIR:simpleitk_RUBY>
     )
@@ -146,10 +168,13 @@ function(sitk_add_tcl_test name)
   endif()
 
   sitk_add_test(NAME Tcl.${name}
-    COMMAND "${ITK_TEST_DRIVER}"
+    COMMAND
       ${command}
       ${ARGN}
     )
+  set_property(TEST Tcl.${name}
+    PROPERTY LABELS Tcl
+    )
 endfunction()
 
 
@@ -170,9 +195,9 @@ function(sitk_add_java_test name java_file)
 
   set( _JAVA_LIBRARY_PATH  "$<TARGET_FILE_DIR:SimpleITKJava_JAVA>")
   if(WIN32)
-    set( _JAVA_CLASSPATH "${SimpleITK_BINARY_DIR}/Wrapping/Java/${JAR_FILE}$<SEMICOLON>${_class_path}" )
+    set( _JAVA_CLASSPATH "${SimpleITK_Java_BINARY_DIR}/${JAR_FILE}$<SEMICOLON>${_class_path}" )
   else()
-    set( _JAVA_CLASSPATH "${SimpleITK_BINARY_DIR}/Wrapping/Java/${JAR_FILE}:${_class_path}" )
+    set( _JAVA_CLASSPATH "${SimpleITK_Java_BINARY_DIR}/${JAR_FILE}:${_class_path}" )
   endif()
 
   if (NOT TARGET ${_java_class}Java)
@@ -196,13 +221,16 @@ function(sitk_add_java_test name java_file)
 
 
   sitk_add_test(NAME Java.${name}
-    COMMAND "${ITK_TEST_DRIVER}"
+    COMMAND
       "${Java_JAVA_EXECUTABLE}"
       "-Djava.library.path=${_JAVA_LIBRARY_PATH}"
       "-classpath" "${_JAVA_CLASSPATH}"
       "${_java_class}"
       ${ARGN}
     )
+  set_property(TEST Java.${name}
+    PROPERTY LABELS Java
+    )
 endfunction()
 
 
@@ -215,7 +243,8 @@ function(sitk_add_r_test name)
     return()
   endif()
 
-  set(command "${R_COMMAND}")
+  set(command "${RSCRIPT_EXECUTABLE}" "--no-save" "--no-restore"
+  "--no-site-file" "--no-init-file")
 
   # add extra command which may be needed on some systems
   if(CMAKE_OSX_ARCHITECTURES)
@@ -224,12 +253,17 @@ function(sitk_add_r_test name)
   endif()
 
   sitk_add_test(NAME R.${name}
-    COMMAND "${ITK_TEST_DRIVER}"
+    COMMAND
       ${command}
       ${ARGN}
     )
 
-  file(TO_NATIVE_PATH "${SimpleITK_BINARY_DIR}/Wrapping/R/R_libs" _native_path)
+  set_property(TEST R.${name}
+    PROPERTY LABELS R
+    )
+
+  file(TO_NATIVE_PATH "${SimpleITK_R_BINARY_DIR}/R_libs" _native_path)
+
   set_property(TEST R.${name}
     PROPERTY ENVIRONMENT R_LIBS=${_native_path}
     )
@@ -274,17 +308,19 @@ function(sitk_add_csharp_test name csharp_file)
   # the interpreter is set to "" when none is needed
   if( CSHARP_INTERPRETER )
     sitk_add_test(NAME CSharp.${name}
-      COMMAND "${ITK_TEST_DRIVER}"
+      COMMAND
         "${CSHARP_INTERPRETER}"
         "${CSHARP_BINARY_DIRECTORY}/${CSHARP_EXECUTABLE}.exe"
         ${ARGN}
       )
   else ()
     sitk_add_test(NAME CSharp.${name}
-      COMMAND "${ITK_TEST_DRIVER}"
+      COMMAND
         "${CSHARP_BINARY_DIRECTORY}/${CSHARP_EXECUTABLE}.exe"
         ${ARGN}
       )
   endif()
-
+  set_property(TEST CSharp.${name}
+    PROPERTY LABELS CSharp
+    )
 endfunction()

CMake/sitkCheckCXX11.cmake

@@ -15,25 +15,38 @@
 # SITK_HAS_TR1_TYPE_TRAITS
 # SITK_HAS_TR1_UNORDERED_MAP
 
+include(CMakePushCheckState)
+
+
+if(POLICY CMP0067) # CMake 3.8.2
+  cmake_policy(SET CMP0067 NEW)
+endif()
+
 #
 # Function to wrap try compiles on the aggregate cxx test file1
 #
 function(sitkCXX11Test VARIABLE)
-  # use the hash of the dependent cxx flags in the variable name to
-  # cache the results.
-  string(MD5 cmake_cxx_flags_hash "#${CMAKE_CXX_FLAGS}")
-  set(cache_var "${VARIABLE}_${cmake_cxx_flags_hash}")
 
-  if(DEFINED "${cache_var}")
-    set(${VARIABLE} "${${cache_var}}"  CACHE INTERNAL "Using hashed value from TRY_COMPILE")
-  else()
+  if(NOT DEFINED ${VARIABLE})
     message(STATUS "Performing Test ${VARIABLE}")
-    set(requred_definitions "${CMAKE_REQUIRED_DEFINITIONS} -D${VARIABLE}")
+
+    if(NOT POLICY CMP0067)
+      if(DEFINED CMAKE_CXX_STANDARD)
+        set(cmake_flags "${cmake_flags} -DCMAKE_CXX_STANDARD:STRING:=${CMAKE_CXX_STANDARD}")
+      endif()
+      if(DEFINED CMAKE_CXX_STANDARD_REQUIRED)
+        set(cmake_flags "${cmake_flags} -DCMAKE_CXX_STANDARD_REQUIRED:STRING:=${CMAKE_CXX_STANDARD_REQUIRED}")
+      endif()
+      if(DEFINED CMAKE_CXX_EXTENSIONS)
+        set(cmake_flags "${cmake_flags} -DCMAKE_CXX_EXTENSIONS:STRING:=${CMAKE_CXX_EXTENSIONS}")
+      endif()
+    endif()
+
     try_compile(${VARIABLE}
-      "${PROJECT_BINARY_DIR}/CMakeTmp"
+      "${PROJECT_BINARY_DIR}"
       "${CMAKE_CURRENT_LIST_DIR}/sitk_check_cxx11.cxx"
-      CMAKE_FLAGS
-      -DCOMPILE_DEFINITIONS:STRING=${requred_definitions}
+      CMAKE_FLAGS ${cmake_flags}
+      COMPILE_DEFINITIONS "-D${VARIABLE}" ${CMAKE_REQUIRED_DEFINITIONS}
       OUTPUT_VARIABLE output)
 
     set(${cache_var} ${${VARIABLE}} CACHE INTERNAL "hashed flags with  try_compile results")
@@ -49,6 +62,8 @@ function(sitkCXX11Test VARIABLE)
    endif()
 endfunction()
 
+cmake_push_check_state(RESET)
+
 #
 # Check for CXX11 Features
 #
@@ -66,7 +81,6 @@ sitkCXX11Test(SITK_HAS_CXX11_ALIAS_TEMPLATE)
 # prefix to tr1 headers, while libc++
 sitkCXX11Test(SITK_HAS_TR1_SUB_INCLUDE)
 
-set(CMAKE_REQUIRED_DEFINITIONS_SAVE ${CMAKE_REQUIRED_DEFINITIONS})
 if (SITK_HAS_TR1_SUB_INCLUDE)
   list(APPEND CMAKE_REQUIRED_DEFINITIONS "-DHAS_TR1_SUB_INCLUDE")
 endif()
@@ -78,16 +92,26 @@ sitkCXX11Test(SITK_HAS_TR1_FUNCTIONAL)
 sitkCXX11Test(SITK_HAS_TR1_TYPE_TRAITS)
 sitkCXX11Test(SITK_HAS_TR1_UNORDERED_MAP)
 
-# restore varaible
-set(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS_SAVE})
+# restore variable
+cmake_pop_check_state()
 
 
 if ( (NOT SITK_HAS_TR1_FUNCTIONAL AND NOT SITK_HAS_CXX11_FUNCTIONAL)
     OR
-    (NOT SITK_HAS_TR1_TYPE_TRAITS AND NOT SITK_HAS_CXX11_TYPE_TRAITS) )
+    (NOT SITK_HAS_TR1_TYPE_TRAITS AND NOT SITK_HAS_CXX11_TYPE_TRAITS)
+    )
+  if (MSVC)
     message( FATAL_ERROR
       "SimpleITK requires usage of C++11 or C++ Technical Report 1 (TR1).\n"
       "It may be available as an optional download for your compiler or difference CXX_FLAGS."
       "Please see the FAQs for details."
-    "https://www.itk.org/Wiki/SimpleITK/FAQ#Do_I_need_to_download_an_option_package_for_TR1_support.3F\n" )
+      "http://simpleitk.readthedocs.io/en/master/Documentation/docs/source/faq.html#do-i-need-to-download-an-option-package-for-tr1-support\n")
+  else()
+      message( FATAL_ERROR
+        "SimpleITK requires usage of C++11 or C++ Technical Report 1 "
+        "(TR1), but were neither able to detect TR1 nor automatically "
+        "enable C++11. Please review your configuration settings and "
+        "enable C++11.\n")
+
+  endif()
 endif ()

CMake/sitkCheckRequiredFlags.cmake

@@ -56,30 +56,48 @@ set(required_flags_regex_to_test
   "^-std=" # required to be last
 )
 
-foreach(f ${cmake_cxx_flags_list})
 foreach( _r ${required_flags_regex_to_test} )
-    string(REGEX MATCH  ${_r} _HAS_FLAG ${f} )
-    if (_HAS_FLAG )
+  set(_HAS_FLAG 0)
+  foreach(f ${cmake_cxx_flags_list})
+    string(REGEX MATCH  ${_r} _match ${f} )
+    if (_match )
       list(APPEND SimpleITK_PUBLIC_COMPILE_OPTIONS ${f})
+      set(_HAS_FLAG ${_match})
     endif()
   endforeach()
 endforeach()
 
+set(HAS_CXX_STD_FLAG ${_HAS_FLAG})
+
+
 #
-# Check if we need to enable C++11 with a compiler flag
+# Let the user set the CXX_STANDARD via these CMake variable, although
+# it is preferred to set it in the CXX_FLAGS, as it will be propagated
+# to SimpleITK's public compile options.
 #
+if( DEFINED CMAKE_CXX_STANDARD
+    OR DEFINED CMAKE_CXX_STANDARD_REQUIRED
+    OR DEFINED CMAKE_CXX_EXTENSIONS )
+  if(HAS_CXX_STD_FLAG)
+    message(SEND_ERROR "CMake CXX standard variables are not supported
+      concurrently with CXX flag: \"-std=\"! Use only one to configure CXX standard.")
+  endif()
+elseif(NOT HAS_CXX_STD_FLAG)
 
-if(NOT _HAS_FLAG)
+#
+# Check if we need to enable C++11 with a compiler flag
+#
 
   check_cxx_compiler_flag( "-std=c++11" CXX_HAS_stdcxx11)
+
   if (CXX_HAS_stdcxx11)
 
     message(STATUS "Checking if c++11 is required...")
-    try_compile(SITK_CHECK_CXX11
-      "${PROJECT_BINARY_DIR}/CMakeTmp"
+    try_compile(SITK_CXX11_NOT_REQUIRED
+      "${PROJECT_BINARY_DIR}"
       "${CMAKE_CURRENT_LIST_DIR}/sitk_check_cxx11_required.cxx"
       OUTPUT_VARIABLE OUTPUT)
-    if(${SITK_CHECK_CXX11})
+    if(SITK_CXX11_NOT_REQUIRED)
       message(STATUS "Checking if c++11 is required... NO" )
     else()
       message(STATUS "Checking if c++11 is required... YES" )

CMake/sitkCheckSourceTree.cmake

@@ -3,8 +3,8 @@ if(EXISTS "${SimpleITK_SOURCE_DIR}/.git/config" AND
     NOT EXISTS "${SimpleITK_SOURCE_DIR}/.git/hooks/pre-commit")
   # Silently ignore the error if the hooks directory is read-only.
   execute_process(
-    COMMAND ${CMAKE_COMMAND} -E copy ${ITK_SOURCE_DIR}/CMake/pre-commit
-                                     ${ITK_SOURCE_DIR}/.git/hooks/pre-commit
+    COMMAND ${CMAKE_COMMAND} -E copy ${SimpleITK_SOURCE_DIR}/CMake/pre-commit
+                                     ${SimpleITK_SOURCE_DIR}/.git/hooks/pre-commit
     OUTPUT_VARIABLE _output
     ERROR_VARIABLE  _output
     RESULT_VARIABLE _result

CMake/sitkCheckTemplateDisambiguation.cmake

@@ -8,5 +8,5 @@
 
 
 try_compile(SITK_HAS_TEMPLATE_DISAMBIGUATOR_DEPENDENT_NAME
-  "${PROJECT_BINARY_DIR}/CMakeTmp"
+  "${PROJECT_BINARY_DIR}"
   "${CMAKE_CURRENT_LIST_DIR}/sitkCheckTemplateDisambiguation.cxx")

CMake/sitkConfigureFileBuildtime.cmake

-
-include(VariableList)
-
-function( configure_file_buildtime filename out_filename )
-
-
-set( regex_1 "^[^@]*(@[^@]+@[^@]*)+[^@]*$")
-
-file ( STRINGS "${filename}" results REGEX "${regex_1}" )
-set( vars "" )
-
-foreach( line ${results})
-
-  set( regex_2 "^[^@]*@([^@]+)@(.*)$" )
-
-  string( REGEX MATCH "${regex_2}" line_match "${line}" )
-  list( APPEND vars ${CMAKE_MATCH_1} )
-  while( CMAKE_MATCH_1 )
-    string( REGEX MATCH "${regex_2}" line_match  "${CMAKE_MATCH_2}" )
-    list( APPEND vars ${CMAKE_MATCH_1} )
-  endwhile()
-    
-  list( SORT vars )
-  list( REMOVE_DUPLICATES vars )
-
-
-
-  
-endforeach()
-
-set( CONFIGUREBUILDTIME_filename ${filename} )
-set( CONFIGUREBUILDTIME_out_filename ${out_filename} )
-
-list( APPEND vars CONFIGUREBUILDTIME_filename CONFIGUREBUILDTIME_out_filename )
-
-VariableListToArgs( vars configure_vars )
-
-file( WRITE "${CMAKE_BINARY_DIR}/CMake/configure_file_buildtime.cmake"
-  "configure_file( \"\${CONFIGUREBUILDTIME_filename}\" \"\${CONFIGUREBUILDTIME_out_filename}\" )" )
-
-set( cmd ${CMAKE_COMMAND} "${configure_vars}"  -P "${CMAKE_BINARY_DIR}/CMake/configure_file_buildtime.cmake")
-
-if( TARGET ConfigureFileBuildtime )
-  add_custom_command( TARGET ConfigureFileBuildtime
-    PRE_BUILD
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    COMMENT "BuildTime Configuration of ${filename} to ${out_filename}"
-    COMMAND  ${cmd}
-    )
-else()
-  add_custom_command(
-    OUTPUT "${out_filename}"
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    DEPENDS "${filename}"
-    COMMENT "BuildTime Configuration of ${filename} to ${out_filename}"
-    COMMAND  ${cmd}
-    )
-  add_custom_target(ConfigureFileBuildtime ALL DEPENDS "${out_filename}" )
-endif()
-
-endfunction()

CMake/sitkExternalData.cmake

 get_filename_component(_SimpleITKExternalData_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
-# Fetch testing data.
-# 2.8.11 required for ExternalData.cmake.
-if( CMAKE_VERSION VERSION_LESS 2.8.11 )
-  message( FATAL_ERROR "BUILD_TESTING ON requires CMake 2.8.11 or newer." )
-endif()
 
 include(ExternalData)
 

CMake/sitkGenerateFilterSource.cmake

@@ -218,7 +218,7 @@ macro(generate_filter_source)
   get_cmake_property( _varNames VARIABLES )
   foreach (_varName ${_varNames})
     if(_varName MATCHES "^SimpleITKBasicFiltersGeneratedSource_")
-      unset(${varName} CACHE)
+      unset(${_varName} CACHE)
     endif()
   endforeach()
 
@@ -281,8 +281,8 @@ macro(generate_filter_source)
   file ( WRITE ${generated_headers_i} "")
 
   # Add ifndefs
-  file ( WRITE "${tmp_generated_headers_h}" "#ifndef __SimpleITK${directory_name}GeneratedHeaders_h\n")
-  file ( APPEND "${tmp_generated_headers_h}" "#define __SimpleITK${directory_name}GeneratedHeaders_h\n")
+  file ( WRITE "${tmp_generated_headers_h}" "#ifndef SimpleITK${directory_name}GeneratedHeaders_h\n")
+  file ( APPEND "${tmp_generated_headers_h}" "#define SimpleITK${directory_name}GeneratedHeaders_h\n")
 
   foreach ( filter ${GENERATED_FILTER_LIST} )
     file ( APPEND "${tmp_generated_headers_h}" "#include \"sitk${filter}.h\"\n" )

CMake/sitkLanguageOptions.cmake

 #
-# - This module finds the languages supported by SimpleITK, and
-#present the option to enable support
-#
-
-#
-# Currently this will search for Python, Java, TCL, Ruby, C#, R
-# Additionally it give the option to wrap LUA.
+# - This module finds the languages supported by SimpleITK. By default
+#a find package will be performed for each language, and if it is
+#detected wrapping for that language will be enabled
+#(WRAP_<languageName>=ON). This behavior can be overridden by setting
+#"WRAP_DEFAULT" to FALSE. Individual languages can be disabled with
+#the WRAP_<languageName> option. If either WRAP_DEFAULT or WRAP_<languageName> is
+#false then no find_package for the language will be performed, and
+#the language will not be wrapped.
 #
 
 include(sitkTargetLinkLibrariesWithDynamicLookup)
@@ -15,44 +16,79 @@ sitk_check_dynamic_lookup(MODULE
   SITK_UNDEFINED_SYMBOLS_ALLOWED
   )
 
-option(WRAP_DEFAULT "The default initial value for wrapping a language when it is detected on the system." ON)
+option(WRAP_DEFAULT "Enables automatic detection and wrapping for all languages." ON)
 mark_as_advanced(WRAP_DEFAULT)
 
+# Arguments:
+# - languageName - name of the language, will check variable
+#   `WRAP_<languageName>`
 #
-# Macro to set "_QUIET" and "_QUIET_LIBRARY" based on the first
-# argument being defined and true, to either REQUIRED or QUIET.
+# Modified Variables:
+#  - _do_find_package - always defined, true if find_pacakge for
+#    languages should be run.
+#  - _find_package_extra_args - may be set to `REQUIRED` of `QUIET` as
+#    needed.
+#  - WRAP_<languageName>_DEFAULT - may be set to `ON` or `OFF` if it
+#    can be determined with out a find_package call
 #
-macro(set_QUIET var)
-  if ( DEFINED  ${var} AND ${var} )
-    set( _QUIET "REQUIRED" )
+macro(sitkLanguageShouldDoFindPackage languageName )
+
+  if ( DEFINED  WRAP_${languageName} )
+    if ( WRAP_${languageName} )
+      # Variable `WRAP_<languageName>` is defined and TRUE, we need
+      # to call  `find_package` with `REQUIRED`
+      set(_do_find_package 1)
+      set(_find_package_extra_args  "REQUIRED")
+      set(WRAP_${languageName}_DEFAULT ON)
     else()
-    set( _QUIET "QUIET" )
+      # Variable `WRAP_<languageName>` is defined and FALSE, we do  *NOT* need
+      # to call  `find_package` at all to initialize the `WRAP_<languageName>_DEFAULT`
+      # variable
+      set(WRAP_${languageName}_DEFAULT OFF)
+      set(_do_find_package 0)
     endif()
-  if ( SITK_UNDEFINED_SYMBOLS_ALLOWED )
-    set( _QUIET_LIBRARY "QUIET" )
+  elseif( WRAP_DEFAULT )
+    # The variable `WRAP_<languageName>` is *NOT* defined and
+    # WRAP_DEFAULT=ON, so we must "quietly" do a find package to
+    # determine the value for `WRAP_<languageName>_DEFAULT` variable
+    set(_do_find_package 1)
+    set(_find_package_extra_args "QUIET")
   else()
-    set( _QUIET_LIBRARY ${_QUIET} )
+    # The variable `WRAP_<languageName>` is *NOT* defined and explicitly all
+    # languages are disabled by WRAP_DEFAULT=OFF, we do *NOT* need to
+    # call `find_package` to initialize the
+    # `WRAP_<languageName>_DEFAULT` variable.
+    set(WRAP_${languageName}_DEFAULT OFF)
+    set(_do_find_package 0)
   endif()
+
+
 endmacro()
 
 #
 # Setup the option for each language
 #
-set_QUIET( WRAP_LUA )
-find_package ( Lua ${_QUIET} )
 
-if ( LUA_FOUND )
-  set( WRAP_LUA_DEFAULT ${WRAP_DEFAULT} )
-else()
-  set( WRAP_LUA_DEFAULT OFF )
+#-----------------------------------------------------------
+# Lua
+
+sitkLanguageShouldDoFindPackage( LUA )
+
+if( _do_find_package )
+
+  find_package ( Lua ${_find_package_extra_args} )
+
+  set( WRAP_LUA_DEFAULT ${LUA_FOUND} )
 endif()
 
-set( LUA_ADDITIONAL_LIBRARIES "" CACHE STRING "Additional libraries which may be needed for lua such as readline.")
-mark_as_advanced( LUA_ADDITIONAL_LIBRARIES )
 
 option ( WRAP_LUA "Wrap Lua" ${WRAP_LUA_DEFAULT} )
 
 if ( WRAP_LUA )
+
+  set( LUA_ADDITIONAL_LIBRARIES "" CACHE STRING "Additional libraries which may be needed for lua such as readline.")
+  mark_as_advanced( LUA_ADDITIONAL_LIBRARIES )
+
   find_package( LuaInterp REQUIRED )
   list( APPEND SITK_LANGUAGES_VARS
     LUA_EXECUTABLE
@@ -65,32 +101,43 @@ if ( WRAP_LUA )
 endif()
 
 
+#-----------------------------------------------------------
+# Python
 
-# If you're not using python or it's the first time, be quiet
+sitkLanguageShouldDoFindPackage( PYTHON )
 
-set_QUIET( WRAP_PYTHON )
-find_package ( PythonInterp ${_QUIET})
-if ( PYTHONINTERP_FOUND )
-  find_package ( PythonLibs ${PYTHON_VERSION_STRING} EXACT ${_QUIET_LIBRARY} )
-else ()
-  find_package ( PythonLibs ${_QUIET_LIBRARY} )
+if( _do_find_package )
+
+  find_package ( PythonInterp ${_find_package_extra_args})
+
+  # if we don't need to link against a library, the make the
+  # find_package quiet.
+  if ( SITK_UNDEFINED_SYMBOLS_ALLOWED )
+    set( _find_package_extra_args "QUIET" )
   endif()
 
-if ( PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND
-    AND PYTHON_VERSION_STRING VERSION_LESS 2.7 )
-  message( WARNING "Python version less that 2.7: \"${PYTHON_VERSION_STRING}\"." )
+  if ( PYTHONINTERP_FOUND )
+    find_package ( PythonLibs ${PYTHON_VERSION_STRING} EXACT ${_find_package_extra_args} )
+  else ()
+    find_package ( PythonLibs ${_find_package_extra_args} )
   endif()
 
   if ( PYTHONLIBS_FOUND AND PYTHONINTERP_FOUND
       AND (PYTHON_VERSION_STRING VERSION_EQUAL PYTHONLIBS_VERSION_STRING) )
-  set( WRAP_PYTHON_DEFAULT ${WRAP_DEFAULT} )
+    set( WRAP_PYTHON_DEFAULT ON )
   else()
     set( WRAP_PYTHON_DEFAULT OFF )
   endif()
+endif()
 
 option( WRAP_PYTHON "Wrap Python" ${WRAP_PYTHON_DEFAULT} )
 
+
 if ( WRAP_PYTHON )
+  if ( PYTHON_VERSION_STRING VERSION_LESS 2.7 )
+    message( WARNING "Python version less than 2.7: \"${PYTHON_VERSION_STRING}\"." )
+  endif()
+
   list( APPEND SITK_LANGUAGES_VARS
     PYTHON_DEBUG_LIBRARY
     PYTHON_EXECUTABLE
@@ -108,15 +155,22 @@ if ( WRAP_PYTHON )
 endif ()
 
 
+#-----------------------------------------------------------
+# Java
+
+sitkLanguageShouldDoFindPackage( JAVA )
+
+if( _do_find_package )
+
+  find_package ( Java COMPONENTS Development Runtime ${_find_package_extra_args} )
+  find_package ( JNI ${_find_package_extra_args} )
 
-set_QUIET( WRAP_JAVA )
-find_package ( Java COMPONENTS Development Runtime ${_QUIET} )
-find_package ( JNI ${_QUIET} )
-if ( ${JAVA_FOUND} AND ${JNI_FOUND} )
-  set( WRAP_JAVA_DEFAULT ${WRAP_DEFAULT} )
-else ( ${JAVA_FOUND} AND ${JNI_FOUND} )
+  if ( JAVA_FOUND AND JNI_FOUND )
+    set( WRAP_JAVA_DEFAULT ON )
+  else ( ${JAVA_FOUND} AND JNI_FOUND )
     set( WRAP_JAVA_DEFAULT OFF )
-endif ( ${JAVA_FOUND} AND ${JNI_FOUND} )
+  endif ( )
+endif()
 
 option ( WRAP_JAVA "Wrap Java" ${WRAP_JAVA_DEFAULT} )
 
@@ -146,15 +200,17 @@ if ( WRAP_JAVA )
 endif()
 
 
-set_QUIET(WRAP_TCL)
+#-----------------------------------------------------------
+# Tcl
+
+sitkLanguageShouldDoFindPackage( WRAP_TCL )
 
-find_package ( TCL ${_QUIET} )
+if( _do_find_package )
 
-if ( ${TCL_FOUND} )
-  set ( WRAP_TCL_DEFAULT ${WRAP_DEFAULT} )
-else ( ${TCL_FOUND} )
-  set ( WRAP_TCL_DEFAULT OFF )
-endif ( ${TCL_FOUND} )
+  find_package ( TCL ${_find_package_extra_args} )
+
+  set ( WRAP_TCL_DEFAULT ${TCL_FOUND} )
+endif()
 
 option ( WRAP_TCL "Wrap Tcl" ${WRAP_TCL_DEFAULT} )
 
@@ -170,14 +226,21 @@ if ( WRAP_TCL )
 endif()
 
 
-set_QUIET( WRAP_RUBY )
+#-----------------------------------------------------------
+# Ruby
+
+sitkLanguageShouldDoFindPackage( RUBY )
+
+if( _do_find_package )
 
-find_package ( Ruby ${_QUIET} )
-if ( ${RUBY_FOUND} )
+  find_package ( Ruby ${_find_package_extra_args} )
+
+  if ( RUBY_FOUND )
     set ( WRAP_RUBY_DEFAULT ${WRAP_DEFAULT} )
-else ( ${RUBY_FOUND} )
+  else ( )
     set ( WRAP_RUBY_DEFAULT OFF )
-endif ( ${RUBY_FOUND} )
+  endif ( )
+endif()
 
 option ( WRAP_RUBY "Wrap Ruby" ${WRAP_RUBY_DEFAULT} )
 
@@ -193,18 +256,21 @@ if ( WRAP_RUBY )
 endif()
 
 
-if (DEFINED  WRAP_CSHARP AND WRAP_CSHARP)
-  set(_QUIET "REQUIRED")
-else()
-  set(_QUIET "QUIET")
-endif()
+#-----------------------------------------------------------
+#  CSharp
+
+sitkLanguageShouldDoFindPackage( CSHARP )
 
-find_package( CSharp ${_QUIET} )
-if ( ${CSHARP_FOUND} AND NOT MINGW )
-  set ( WRAP_CSHARP_DEFAULT ${WRAP_DEFAULT} )
+if( _do_find_package )
+
+  find_package( CSharp ${_find_package_extra_args} )
+
+  if ( CSHARP_FOUND AND NOT MINGW )
+    set ( WRAP_CSHARP_DEFAULT ON )
   else ()
     set ( WRAP_CSHARP_DEFAULT OFF )
   endif ()
+endif()
 
 option ( WRAP_CSHARP "Wrap C#" ${WRAP_CSHARP_DEFAULT} )
 
@@ -217,14 +283,21 @@ if ( WRAP_CSHARP )
 endif()
 
 
-set_QUIET( WRAP_R )
+#-----------------------------------------------------------
+#  R
 
-find_package(R ${_QUIET})
-if ( ${R_FOUND} AND NOT WIN32 )
-  set ( WRAP_R_DEFAULT ${WRAP_DEFAULT} )
+sitkLanguageShouldDoFindPackage( R )
+
+if( _do_find_package )
+
+  find_package(R ${_find_package_extra_args})
+
+  if ( R_FOUND AND NOT WIN32 )
+    set ( WRAP_R_DEFAULT ON )
   else( )
     set ( WRAP_R_DEFAULT OFF )
   endif( )
+endif()
 
 option ( WRAP_R "Wrap R" ${WRAP_R_DEFAULT} )
 
@@ -241,7 +314,3 @@ endif()
 if( WIN32 )
   mark_as_advanced( WRAP_R )
 endif()
-
-#
-# Below here are the 2nd tier languages they are not enabled automatically if detected
-#

CMake/sitkProjectLanguageCommon.cmake

@@ -24,6 +24,17 @@ if (NOT CMAKE_PROJECT_NAME STREQUAL "SimpleITK" )
   if(MSVC)
      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
   endif()
+
+  include(CTest)
+
+  if (BUILD_TESTING)
+    enable_testing()
+    include(sitkAddTest)
+
+    configure_file("${SimpleITK_SOURCE_DIR}/CMake/CTestCustom.cmake.in" CTestCustom.cmake)
+
+  endif()
+
 else()
   set(SimpleITK_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 endif()
@@ -94,7 +105,7 @@ list( APPEND SWIG_EXTRA_DEPS
 
 # check if uint64_t is the same as unsigned long
 try_compile(SITK_ULONG_SAME_AS_UINT64
-  ${PROJECT_BINARY_DIR}/CMakeTmp
+  "${PROJECT_BINARY_DIR}"
   ${SimpleITK_SOURCE_DIR}/CMake/same_uint64_ulong.cxx )
 
 # when "-DSWIGWORDSIZE64" is defined SWIG used unsigned long for uint64_t types

CMake/sitkSITKLegacyNaming.cmake

@@ -23,7 +23,7 @@ endfunction()
 macro(sitk_legacy_naming new_var_name )
 
 
-  if(NOT "${ARGV1}" STREQUAL "")
+  if(NOT "x${ARGV1}x" STREQUAL "xx")
     set( old_var_name ${ARGV1} )
   else()
     string( REGEX REPLACE  "^SimpleITK_" "SITK_" old_var_name "${new_var_name}" )

CMake/sitkSourceVersion.cmake

@@ -31,11 +31,17 @@ include(GetGitRevisionDescription)
 
 get_git_head_revision(GIT_REFVAR _GIT_VERSION_HASH)
 
-# if there is not git directory we should be in a distributed package
+# if there is not a git directory we should be in a distributed package
 # which should contain this additional cmake file with the
 # _GIT_VERSION variables
 if(_GIT_VERSION_HASH STREQUAL "GITDIR-NOTFOUND")
+    if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/sitkSourceVersionVars.cmake")
       include( "${CMAKE_CURRENT_LIST_DIR}/sitkSourceVersionVars.cmake" )
+    else()
+      message(WARNING "Unable to determine source version!\n
+Please use the git repository or an official source distribution.\n")
+      set(_GIT_VERSION_DEV "")
+    endif()
   return()
 endif()
 

CMake/sitkSourceVersionVars.cmake

@@ -5,10 +5,10 @@ macro( _set_if_not_empty var value )
 endmacro()
 
 set( _GIT_VERSION_MAJOR "1" )
-set( _GIT_VERSION_MINOR "0" )
-_set_if_not_empty( _GIT_VERSION_PATCH "1" )
+set( _GIT_VERSION_MINOR "1" )
+_set_if_not_empty( _GIT_VERSION_PATCH "0" )
 _set_if_not_empty( _GIT_VERSION_TWEAK "" )
 _set_if_not_empty( _GIT_VERSION_RC "" )
 _set_if_not_empty( _GIT_VERSION_POST "" )
 _set_if_not_empty( _GIT_VERSION_DEV "" )
-_set_if_not_empty( _GIT_VERSION_HASH "52bae" )
+_set_if_not_empty( _GIT_VERSION_HASH "dbc8d" )

CMake/sitkUseGTest.cmake

@@ -74,7 +74,7 @@ if( DEFINED GTEST_ROOT AND EXISTS "${GTEST_ROOT}/CMakeLists.txt")
     add_library(GTest::Main ALIAS ${GTEST_MAIN_LIBRARIES})
 
   else()
-    message(WARNING "CTEST_ROOT appears to be a source directory \
+    message(WARNING "GTEST_ROOT appears to be a source directory \
     but \"gtest/gtest.h\"  can not be found in source directory: \
     ${GTEST_ROOT}")
   endif()

CMakeLists.txt

@@ -11,6 +11,7 @@ cmake_policy( VERSION 3.0 )
 foreach(p
     CMP0042 # CMake 3.0
     CMP0063 # CMake 3.3.2
+    CMP0064 # CMake 3.4
     )
   if(POLICY ${p})
     cmake_policy(SET ${p} NEW)
@@ -118,7 +119,14 @@ option( SimpleITK_INT64_PIXELIDS "Instantiate 64-bit integer pixels, including u
 sitk_legacy_naming(SimpleITK_INT64_PIXELIDS)
 
 
-option( SimpleITK_4D_IMAGES "Add Image and I/O support for four spatial dimensions." OFF )
+
+set(SimpleITK_4D_IMAGES_DEFAULT ON)
+# 1900 = VS 14.0 (Visual Studio 2015)
+if(MSVC AND MSVC_VERSION VERSION_LESS 1900)
+  set( SimpleITK_4D_IMAGES_DEFAULT OFF )
+  message("disable")
+endif()
+option( SimpleITK_4D_IMAGES "Add Image and I/O support for four spatial dimensions." ${SimpleITK_4D_IMAGES_DEFAULT} )
 mark_as_advanced( SimpleITK_4D_IMAGES )
 sitk_legacy_naming(SimpleITK_4D_IMAGES)
 
@@ -213,9 +221,9 @@ function(sitk_install_exported_target tgt)
 
   install(TARGETS ${tgt}
     EXPORT SimpleITKTargets
-    RUNTIME DESTINATION ${SimpleITK_INSTALL_RUNTIME_DIR}
-    LIBRARY DESTINATION ${SimpleITK_INSTALL_LIBRARY_DIR}
-    ARCHIVE DESTINATION ${SimpleITK_INSTALL_ARCHIVE_DIR}
+    RUNTIME DESTINATION ${SimpleITK_INSTALL_RUNTIME_DIR} COMPONENT Runtime
+    LIBRARY DESTINATION ${SimpleITK_INSTALL_LIBRARY_DIR} COMPONENT Runtime
+    ARCHIVE DESTINATION ${SimpleITK_INSTALL_ARCHIVE_DIR} COMPONENT Development
     )
 endfunction()
 
@@ -280,26 +288,37 @@ set ( SimpleITK_DOC_FILES
 # root of the source tree
 get_filename_component( _itk_root "${ITK_USE_FILE}" PATH )
 get_filename_component( _itk_root "${_itk_root}" PATH )
-set( _itk_source_path "${_itk_root}" )
+
+set(_itk_doc_search_paths "${_itk_root}")
 
 get_filename_component( _itk_root "${_itk_root}" PATH )
 get_filename_component( _itk_root "${_itk_root}" PATH )
-set( _itk_doc_path "${_itk_root}/share/doc/ITK-${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}" )
-
-if( EXISTS "${_itk_source_path}/NOTICE" )
-  set( ITK_DOC_FILES
-    # "${_itk_source_path}/LICENSE" SimpleITK has same license file
-    "${_itk_source_path}/NOTICE"
-    "${_itk_source_path}/README.txt"
-    )
-elseif( EXISTS "${_itk_doc_path}/NOTICE" )
-  set( ITK_DOC_FILES
-    # "${_itk_doc_path}/LICENSE" SimpleITK has same license file
-    "${_itk_doc_path}/NOTICE"
-    "${_itk_doc_path}/README.txt"
+list( APPEND _itk_doc_search_paths
+   "${_itk_root}/share/doc/ITK-${ITK_VERSION_MAJOR}.${ITK_VERSION_MINOR}"
+   "${_itk_root}/share/doc/ITK"
 )
-else()
-  message( "doc_path: ${_itk_doc_path}" )
+
+
+#
+# Only append file if it exists
+#
+function(append_if_exists list_var file)
+   if( EXISTS ${file} )
+     list( APPEND ${list_var} ${file} )
+     set( ${list_var} ${${list_var}} PARENT_SCOPE )
+   endif()
+endfunction()
+
+foreach( _p IN LISTS _itk_doc_search_paths)
+  if( EXISTS "${_p}/NOTICE" )
+    append_if_exists(ITK_DOC_FILES "${_p}/NOTICE")
+    append_if_exists(ITK_DOC_FILES "${_p}/README.txt")
+    append_if_exists(ITK_DOC_FILES "${_p}/README.md")
+    break()
+  endif()
+endforeach()
+
+if( NOT ITK_DOC_FILES )
   message( WARNING "Unable to file ITK's NOTICE File!\n This file will not be included in SimpleITK packaging!" )
 endif()
 
@@ -360,21 +379,9 @@ if ( BUILD_TESTING )
 
   include( sitkAddTest )
 
-  file( GLOB_RECURSE content_links
-    RELATIVE "${SimpleITK_SOURCE_DIR}" "Testing/Data/*.md5" )
-  foreach(link ${content_links})
-    string( REGEX REPLACE "\\.md5$" "" link ${link} )
-    ExternalData_Expand_Arguments( SimpleITKData
-      link_location
-      DATA{${link}}
-      )
-  endforeach()
-
   enable_testing()
   add_subdirectory ( Testing )
 
-  option ( RUN_LONG_TESTS "Run long tests.  Some tests have been identified as long running, should these be run?" OFF )
-  mark_as_advanced(RUN_LONG_TESTS)
   set(BUILDNAME "${BUILDNAME}" CACHE STRING "Name of build on the dashboard")
   configure_file(CMake/CTestCustom.cmake.in CTestCustom.cmake)
 endif()

Code/BasicFilters/include/itkHashImageFilter.h

@@ -25,9 +25,6 @@
 #include "itkByteSwapper.h"
 
 
-#include "Ancillary/hl_md5.h"
-#include "Ancillary/hl_sha1.h"
-
 namespace itk {
 
 /** \class HashImageFilter