Fix missing dependencies. Add pip requirements

.gitattributes

@@ -0,0 +1,3 @@
+*.image filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.xdmf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -8,6 +8,7 @@ bin/
 compile_commands.json
 test_data/
 build/
+benchmarking/pyvenv*
 doc/_build/
 doc/_static/pfire_tutorial_files.zip
 gitstate.hpp
@@ -80,3 +81,18 @@ MANIFEST
 *.exe
 *.out
 *.app
+
+# IDEs
+.cproject
+.project
+.pydevproject
+.settings/
+src/.cproject
+src/.project
+
+
+external_libs/
+
+testdata/integration/regression/brain_2d/xdmf
+
+benchmarking/brain2d/brain2d.html

CMakeLists.txt

@@ -15,6 +15,7 @@
 
 cmake_minimum_required(VERSION 3.7.0)
 project(pFIRE)
+include(CMakePrintHelpers)
 
 if("${PROJECT_SOURCE_DIR}" STREQUAL "${PROJECT_BINARY_DIR}")
   message(FATAL_ERROR "In-source builds are not permitted. Make a separate folder for "
@@ -26,6 +27,9 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED on)
 set(CMAKE_EXPORT_COMPILE_COMMANDS on)
 
+#[=[
+#add_compile_options(-W -Wall -Werror)
+#]=]
 cmake_policy(SET CMP0074 NEW)
 
 if( NOT CMAKE_BUILD_TYPE )
@@ -35,9 +39,10 @@ if( NOT CMAKE_BUILD_TYPE )
 endif()
 
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra -Wuninitialized -O0 -ggdb -march=native -fstack-protector-strong")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wall -O3 -march=native -fno-fast-math")
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELEASE} -ggdb")
+set(CMAKE_CXX_FLAGS_RELEASE  "${CMAKE_CXX_FLAGS_RELEASE} -Wall -O3 -march=native -fno-fast-math")
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELEASE} -ggdb")
 
+# set( FIND_LIBRARY_USE_LIB64_PATHS property  TRUE)
 option(DEBUG_VERBOSE "Verbose debug outputs")
 if(DEBUG_VERBOSE)
   add_definitions(-DDEBUG_VERBOSE)
@@ -72,6 +77,10 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${pFIRE_SOURCE_DIR}/bin)
 # Ensure we can find FindPETSc and friends
 list(APPEND CMAKE_MODULE_PATH ${pFIRE_SOURCE_DIR}/cmake-modules)
 
+# Define flags to enable dependencies
+option(ENABLE_OpenImageIO "Enable Linking OpenImageIO library" [TRUE])
+option(ENABLE_DCMTK       "Enable Linking DCMTK library" [TRUE])
+
 find_package(MPI REQUIRED)
 include_directories(${MPI_INCLUDES})
 set(EXTRA_LIBS ${EXTRA_LIBS} ${MPI_LIBRARIES})
@@ -94,19 +103,67 @@ find_package(Boost REQUIRED COMPONENTS filesystem program_options)
 include_directories(${BOOST_INCLUDE_DIRS})
 set(EXTRA_LIBS ${EXTRA_LIBS} ${Boost_LIBRARIES})
 
-find_package(DCMTK)
+if(ENABLE_DCMTK)
+find_package(DCMTK CONFIG)
+endif(ENABLE_DCMTK)
+
 if(DCMTK_FOUND)
-include_directories(${DCMTK_INCLUDES})
-set(EXTRA_LIBS ${EXTRA_LIBS} ${DCMTK_LIBRARIES})
-  add_definitions(-DUSE_DCMTK)
+	message("DCMTK found")
+	include_directories(${DCMTK_INCLUDES})
+	# FIX the following line to work with DCMTK not in single library
+	 # set(EXTRA_LIBS ${EXTRA_LIBS} ${DCMTK_CMAKE_INSTALL_PREFIX}/lib64/libdcmtk.so )#${DCMTK_CMAKE_INSTALL_PREFIX}/${DCMTK_LIBRARIES})
+     set(EXTRA_LIBS ${EXTRA_LIBS} ${DCMTK_CMAKE_INSTALL_PREFIX}/${DCMTK_LIBRARIES})
+	add_definitions(-DUSE_DCMTK)
+	include_directories(${DCMTK_INCLUDE_DIRS})
+	cmake_print_variables(DCMTK_INCLUDES)  
+	cmake_print_variables(DCMTK_LIBRARIES)
+	#cmake_print_variables(DCMTK_CMAKE_INSTALL_PREFIX)
+
+
 endif(DCMTK_FOUND)
 
-find_package(OpenImageIO)
-if(OPENIMAGEIO_FOUND)
-include_directories(${OPENIMAGEIO_INCLUDE_DIR})
-set(EXTRA_LIBS ${EXTRA_LIBS} ${OPENIMAGEIO_LIBRARIES})
-  add_definitions(-DUSE_OIIO)
-endif(OPENIMAGEIO_FOUND)
+#list(APPEND CMAKE_FIND_ROOT_PATH "... insigneo-pfire/docker-pfire/singularity/fix_oiio_dcmtk/oiio/dist/lib64/cmake/OpenImageIO/")
+
+
+if(ENABLE_OpenImageIO)
+find_package(OpenImageIO CONFIG)
+endif(ENABLE_OpenImageIO)
+
+cmake_print_variables(OpenImageIO_FOUND)
+
+
+
+if(OpenImageIO_FOUND AND ENABLE_OpenImageIO)
+
+	#cmake_print_variables(OpenImageIO_INCLUDE_DIR)
+	cmake_print_variables(OpenImageIO_LIBRARIES)
+	#cmake_print_variables(OpenImageIO_LIB_DIR)
+	# OpenImageIO cmake config is missing library names so declaring here until they fix it
+#try modern	
+set (OpenImageIO_LIBRARIES "${OpenImageIO_LIB_DIR}/libOpenImageIO_Util.so;${OpenImageIO_LIB_DIR}/libOpenImageIO.so")
+#try modern	
+include_directories(${OpenImageIO_INCLUDE_DIR})
+	cmake_print_variables(OpenImageIO_LIBRARIES)
+	#set(EXTRA_LIBS ${EXTRA_LIBS} ${OpenImageIO_LIBRARIES} )
+	#add_definitions(-DUSE_OIIO)
+
+
+else(OpenImageIO_FOUND AND ENABLE_OpenImageIO)
+	message(STATUS "OPENIMAGEIO_FOUND ELSE branch")
+
+	#include_directories(${OpenImageIO_INCLUDE_DIR})
+	# danielta set(EXTRA_LIBS ${EXTRA_LIBS} ${OpenImageIO_LIBRARIES} ) #/usr/local/oiio/lib64/libOpenImageIO.a /usr/local/oiio/lib64/libOpenImageIO_Util.a)
+
+	#add_definitions(-DUSE_OIIO)
+
+endif(OpenImageIO_FOUND AND ENABLE_OpenImageIO)
+#	include(GNUInstallDirs)
+cmake_print_variables(EXTRA_LIBS)
+
+#find_library(JPEG_LIBRARY NAMES jpeg jpg libjpeg  REQUIRED NO_SYSTEM_ENVIRONMENT_PATH PATHS /usr/local/oiio/lib64)
+#cmake_print_variables(JPEG_LIBRARY)
+
+#set(EXTRA_LIBS ${EXTRA_LIBS} ${OpenImageIO_LIBRARIES})
 
 add_subdirectory(${pFIRE_SOURCE_DIR}/src)
 

benchmarking/README.md

@@ -0,0 +1,73 @@
+## pFIRE Benchmark suite
+
+The benchmark suite provides a framework to perform regression and comparison tests of pFire/ShiRT over a test cases organised in folders.
+
+
+# Installation
+
+The suite is written in Python and can be installed in the standard way.
+We recommend to use virtual environments as below:
+
+
+
+```bash
+	# Create virtual environment
+
+	cd pFIRE/benchmarking
+
+	python3 -m venv pyvenv3
+
+
+	# Activate
+
+	source pyvenv3/bin/activate
+
+	# Upgrade pip	
+	pip install --upgrade pip
+
+	# Install dependencies
+
+	pip install -r requirements.txt
+
+		##python setup.py install .
+	pip install .
+
+	# add folder to pythonpath
+
+	export PYTHONPATH=`pwd`/:$PYTHONPATH
+
+
+	../../pFIRE/testdata/integration/regression
+
+	# When not needed any more deactivate the virtual environment
+
+	deactivate
+
+
+```
+
+
+add pfire binary to PATH
+
+export PATH=/<path-to-pfire-binary>/:$PATH
+
+# Usage
+
+```
+pfire-integration-test --pfire-executable=</path-to-pfire>/<pfire-executable>  <base directory containing test configuration file> 
+```
+
+It is optional to provide the pFIRE executable filename. Apptainer allows to use the container as an executable (a wrapper around a container binary configured un the Runscript section)
+
+
+*  create a testconf file in each test folder
+*  pfire_benchmark  <path_to_>/mytest.testconf
+
+
+
+
+TODO add testconf syntax and use cases
+
+
+
+

benchmarking/pfire_benchmarking/__main__.py

@@ -12,8 +12,15 @@ def _parse_args():
     parser = argparse.ArgumentParser(description="Run pFIRE integration tests")
 
     parser.add_argument('dir', nargs='?', default=os.getcwd(), metavar="datadir",
-                        help="Test data directory, will be inspected recursively")
+                        help="Test data directory will be inspected recursively")
+
+    parser.add_argument('--pfire-executable', nargs='?', default="pfire", metavar="pfire_exec_filename",
+                        dest="pfire_exec_filename",
+                        help="pFIRE executable filepath (filename with full path)")
+
+
     parser.add_argument('--output', '-o', default='.', metavar="outdir",
+                        dest="output_dir",
                         help="Path at which to output results")
 
     return parser.parse_args()
@@ -23,13 +30,15 @@ def main():
     """ Run the testsuite over a directory tree
     """
     args = _parse_args()
-
-    testsuite = TestDespatcher(output_dir=args.output)
+    print(args)
+    print("pfire_exec_filename=", args.pfire_exec_filename )
+
+    testsuite = TestDespatcher(output_dir=args.output_dir, pfire_exec_filename=args.pfire_exec_filename ) 
 
     if not os.path.exists(args.dir):
         print("Error, path {} does not exist".format(args.dir))
         return
-
+    # Add tests or tests in directory tree
     if os.path.isfile(args.dir):
         testsuite.add_test(args.dir)
     else:

benchmarking/pfire_benchmarking/analysis_routines.py

@@ -48,8 +48,21 @@ def calculate_mutual_information(data1, data2, resolution=50,
     Returns a tuple of MI(X,Y), H(X), H(Y), H(X,Y)
     """
     jointmax = max(data1.max(), data2.max())
+
+
     # First calculate probability density
-    bin_edges = np.linspace(0, 1, num=resolution)
+    bin_edges = np.linspace(0, 1, num=resolution)#, dtype=object)
+
+    print ("shape(data1.flatten())=" + str(np.shape(data1.flatten())))
+    print ("shape(data2.flatten())=" + str(np.shape(data2.flatten())))
+
+    print ("shape(data1)=" + str(np.shape(data1)))
+    print ("shape(data2)=" + str(np.shape(data2)))
+
+    print ("shape(bin_edges)=" + str(np.shape(bin_edges)))
+
+
+
     prob1_2, _, _ = np.histogram2d(data1.flatten()/jointmax,
                                    data2.flatten()/jointmax,
                                    bins=bin_edges, density=True)
@@ -101,11 +114,25 @@ def compare_image_results(fixed_path, moved_path, accepted_path,
     else:
         fig_dir = os.path.normpath('.')
 
-    mi_start = calculate_proficiency(fixed_path, moved_path)
-    mi_accepted = calculate_proficiency(fixed_path, accepted_path)
-    mi_pfire = calculate_proficiency(fixed_path, pfire_path)
+
+    print("fixed_path="+ fixed_path)
+    print("moved_path="+ moved_path)
+    print("pfire_path="+ pfire_path)
+    print("accepted path="+ accepted_path)
+
+    print("MI fixed_path vs moved_path=\n"+ fixed_path + "\n" + moved_path)    
+    mi_start      = calculate_proficiency(fixed_path, moved_path)
+
+    print("MI fixed_path vs accepted_path=\n"+ fixed_path + "\n" + accepted_path)
+    mi_accepted   = calculate_proficiency(fixed_path, accepted_path)
+
+    print("MI fixed_path vs pfire_path=\n"+ fixed_path + "\n" +pfire_path)    
+    mi_pfire      = calculate_proficiency(fixed_path, pfire_path)
+
+    print("MI accepted_path vs pfire_path=\n"+ accepted_path + "\n" +pfire_path)    
     mi_comparison = calculate_proficiency(accepted_path, pfire_path)
 
+
     res_table = [("Normalized mutual information (proficiency):", ""),
                  ("Fixed vs. Moved:", "{:.3f}".format(mi_start.mi)),
                  ("{} vs. Fixed:".format(cmpname), "{:.3f}".format(mi_accepted.mi)),