Merge pull request #183 from vais-ral/use_ctypes

Author: casperdcl

.gitignore

@@ -1 +1,8 @@
-.idea/
+/build_proj/
+/install/
+__pycache__/
+/src/Python/build/
+/src/Python/*.egg*/
+*.so
+*.dll
+*.dylib

CMakeLists.txt

@@ -1,22 +1,13 @@
-#   Copyright 2017 Edoardo Pasca
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-cmake_minimum_required (VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 
 project(RGL)
 #https://stackoverflow.com/questions/13298504/using-cmake-with-setup-py
 
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Options: Debug Release RelWithDebInfo MinSizeRel" FORCE)
+endif()
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
 # The version number.
 set (RGL_VERSION_MAJOR 1)
 set (RGL_VERSION_MINOR 0)
@@ -28,32 +19,22 @@ set (CIL_VERSION_PATCH 2)
 # set (CIL_VERSION '${CIL_VERSION_MAJOR}.${CIL_VERSION_MINOR}.${CIL_VERSION_PATCH}' CACHE INTERNAL "Core Imaging Library version" FORCE)
 # get CIL_VERSION from environment variable and set it in cmake
 set (CIL_VERSION $ENV{CIL_VERSION} CACHE INTERNAL "Core Imaging Library version" FORCE)
-message(STATUS "CIL_VERSION set to " ${CIL_VERSION})
+message(STATUS "CIL_VERSION: ${CIL_VERSION}")
 
 # set the Python variables for the Conda environment
 #include(${CMAKE_SOURCE_DIR}/CMake/FindAnacondaEnvironment.cmake)
 
 option (BUILD_MATLAB_WRAPPER "Build Matlab Wrappers" OFF)
 option (BUILD_PYTHON_WRAPPER "Build Python Wrappers" ON)
-option (CONDA_BUILD "Conda Build" OFF)
 option (BUILD_CUDA "Build the CUDA modules" ON)
 
 set(MATLAB_DEST_DIR "" CACHE PATH "Directory of the Matlab wrappers")
 if (MATLAB_DEST_DIR)
 set(MATLAB_DEST "${MATLAB_DEST_DIR}")
-else() 
+else()
 set(MATLAB_DEST "${CMAKE_INSTALL_PREFIX}/matlab")
 endif()
 message(STATUS "Matlab wrappers will be installed in " ${MATLAB_DEST})
 
-set(PYTHON_DEST_DIR "" CACHE PATH "Directory of the Python wrappers")
-if (PYTHON_DEST_DIR)
- set(PYTHON_DEST "${PYTHON_DEST_DIR}")
-else() 
- set(PYTHON_DEST "${CMAKE_INSTALL_PREFIX}/python")
-endif()
-message(STATUS "Python wrappers will be installed in " ${PYTHON_DEST})
-
-
 #add_subdirectory(src/Core)
 add_subdirectory(src)

Installation.md

@@ -1,16 +1,22 @@
-## Installation:
+# CCPi Regularisation Toolkit
+
+## Installation
 
 In order to compile C/C++ sources and additional wrappers from source code for numpy 1.24 and python 3.10, the recommended way is:
-```
+
+```sh
 git clone https://github.com/vais-ral/CCPi-Regularisation-Toolkit
 cd CCPi-Regularisation-Toolkit
 export CCPI_BUILD_ARGS="--numpy 1.24 --python 3.10"
 build/jenkins-build.sh
 ```
+
 this will install `conda build` environment and compiles C/C++ and Python wrappers and performs basic tests for environment with python 3.10 and numpy 1.24.
 
 ### CMake
+
 If you want to build directly using cmake, install CMake (v.>=3) to configure it. Additionally you will need a C compiler, `make` (on linux) and CUDA SDK where available. The toolkit may be used directly from C/C++ as it is compiled as a shared library (check-out the include files in `Core` for this)
+
 1. Clone this repository to a directory, i.e. `CCPi-Regularisation-Toolkit`,
 2. create a build directory.
 3. Issue `cmake` to configure (or `cmake-gui`, or `ccmake`, or `cmake3`). Use additional flags to fine tune the configuration.
@@ -22,35 +28,35 @@ Flags used during configuration
 | `BUILD_PYTHON_WRAPPER` | bool | `ON\|OFF` whether to build the Python wrapper |
 | `BUILD_MATLAB_WRAPPER` | bool | `ON\|OFF` whether to build the Matlab wrapper |
 | `CMAKE_INSTALL_PREFIX` | path | your favourite install directory |
-| `PYTHON_DEST_DIR` | path | python modules install directory (default `${CMAKE_INSTALL_PREFIX}/python`) |
 | `MATLAB_DEST_DIR` | path | Matlab modules install directory (default `${CMAKE_INSTALL_PREFIX}/matlab`)|
 | `BUILD_CUDA` | bool | `ON\|OFF` whether to build the CUDA regularisers |
-| `CONDA_BUILD`| bool | `ON\|OFF` whether it is installed with `setup.py install`|
 | `Matlab_ROOT_DIR` | path | Matlab directory|
-|`PYTHON_EXECUTABLE` | path | /path/to/python/executable|
+| `PYTHON_EXECUTABLE` | path | /path/to/python/executable|
 
 Here an example of build on Linux (see also `run.sh` for additional info):
 
-```bash
-git clone https://github.com/vais-ral/CCPi-Regularisation-Toolkit.git
-cd build
-cmake .. -DCONDA_BUILD=OFF -DBUILD_MATLAB_WRAPPER=ON -DBUILD_PYTHON_WRAPPER=ON -DBUILD_CUDA=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=./install
-make install
-cd install/python
-export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:../lib
+```sh
+git clone https://github.com/vais-ral/CCPi-Regularisation-Toolkit
+cd CCPi-Regularisation-Toolkit
+cmake -S . -B ./build_proj -DBUILD_MATLAB_WRAPPER=ON -DBUILD_PYTHON_WRAPPER=ON -DBUILD_CUDA=ON -DCMAKE_INSTALL_PREFIX=./install
+cmake --build ./build_proj --target install
 ```
 
 ### Python
+
 #### Python binaries
+
 Python binaries are distributed via the [ccpi](https://anaconda.org/ccpi/ccpi-regulariser) conda channel.
 
-```
+```sh
 conda install ccpi-regulariser -c ccpi -c conda-forge
 ```
 
 #### Python (conda-build)
-```
-export CIL_VERSION=$(date +%Y.%m) (Unix) / set CIL_VERSION=19.10 (Windows)
+
+```sh
+export CIL_VERSION=$(date +%Y.%m.%d) # UNIX
+# set CIL_VERSION=24.3.0             # Windows
 conda build recipe/ --numpy 1.23 --python 3.10
 conda install ccpi-regulariser=${CIL_VERSION} --use-local --force-reinstall # doesn't work?
 conda install -c file://${CONDA_PREFIX}/conda-bld/ ccpi-regulariser=${CIL_VERSION} --force-reinstall # try this one
@@ -60,25 +66,38 @@ python demo_gpu_regularisers.py # to run GPU demo
 ```
 
 ### Python (GPU-CuPy)
-One can also use some of the GPU modules directly (i.e. without the need of building the package) by using [CuPy](https://docs.cupy.dev/en/stable/index.html) implementations. 
+
+One can also use some of the GPU modules directly (i.e. without the need of building the package) by using [CuPy](https://docs.cupy.dev) implementations.
+
+```sh
+pip install git+https://github.com/vais-ral/CCPi-Regularisation-Toolkit
 ```
-git clone git@github.com:vais-ral/CCPi-Regularisation-Toolkit.git
-cd CCPi-Regularisation-Toolkit
-pip install .
-``` 
+
+> [!WARNING]
+> The above currently doesn't work; see **Python build** below instead:
 
 #### Python build
-If passed `CONDA_BUILD=ON` the software will be installed by issuing `python setup.py install` which will install in the system python (or whichever other python it's been picked up by CMake at configuration time.)
-If passed `CONDA_BUILD=OFF` the software will be installed in the directory pointed by `${PYTHON_DEST_DIR}` which defaults to `${CMAKE_INSTALL_PREFIX}/python`. Therefore this directory should be added to the `PYTHONPATH`.
 
-If Python is not picked by CMake you can provide the additional flag to CMake `-DPYTHON_EXECUTABLE=/path/to/python/executable`.
+If passed `BUILD_PYTHON_WRAPPER=ON`, CMake will install libraries in-place under `./src/Python`, followed by running `python -m pip install ./src/Python`.
+(Note that libraries are also installed under the user-specified `${CMAKE_INSTALL_PREFIX}`, which could be set to a throwaway directory, e.g. `-DCMAKE_INSTALL_PREFIX=./install`).
+
+If Python is not picked by CMake you can provide the additional flag to CMake `-DPYTHON_EXECUTABLE=/path/to/executable/python`.
+
+Tests can also be run in-place after the build:
+
+```sh
+PYTHONPATH=./src/Python python -m unittest discover ./test
+```
 
 ### MultiGPU capability (to use in Python with mpi4py)
+
 The toolkit can be used by running in parallel across multiple GPU devices on a PC or a compute node of a cluster. In order to initiate a parallel run on your GPUs you will need an MPI library, such as, [mpi4py](https://mpi4py.readthedocs.io/en/stable/). See multi_gpu demo script in demos folder, it can be run as
-```
+
+```sh
 mpirun -np 2 python multi_gpu.py -g -s -gpus 2
 ```
-where `-np` parameter defines the total number of processes and `-gpus` defines the number of available GPUs. 
+
+where `-np` parameter defines the total number of processes and `-gpus` defines the number of available GPUs.
 
 ### Matlab
 
@@ -87,23 +106,27 @@ Matlab wrapper will install in the `${MATLAB_DEST_DIR}` directory, which default
 If Matlab is not picked by CMake, you could add `-DMatlab_ROOT_DIR=<Matlab directory>`.
 
 #### Linux
+
 Because you've installed the modules in `<your favourite install directory>` you need to instruct Matlab to look in those directories:
 
 ```bash
-
 PATH="/path/to/mex/:$PATH" LD_LIBRARY_PATH="/path/to/library:$LD_LIBRARY_PATH" matlab
 ```
+
 By default `/path/to/mex` is `${CMAKE_INSTALL_PREFIX}/bin` and `/path/to/library/` is `${CMAKE_INSTALL_PREFIX}/lib`
 
 #### Windows
+
 On Windows the `dll` and the mex modules must reside in the same directory. It is sufficient to add the directory at the beginning of the m-file.
+
 ```matlab
 addpath(/path/to/library);
 ```
 
 #### Legacy Matlab installation (partly supported, please use Cmake)
+
+```sh
+cd src/Matlab/mex_compile
+compileCPU_mex.m % to compile CPU modules
+compileGPU_mex.m % to compile GPU modules (see instructions in the file)
 ```
-	cd src/Matlab/mex_compile
-	compileCPU_mex.m % to compile CPU modules
-	compileGPU_mex.m % to compile GPU modules (see instructions in the file)
-```

demos/demo_cpu_regularisers3D.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+#%%
 """
 Created on Thu Feb 22 11:39:43 2018
 
@@ -30,6 +31,7 @@ def printParametersToString(pars):
         return txt
 ###############################################################################
 
+os.chdir(os.path.join("..", "demos"))
 filename = os.path.join( "data" ,"lena_gray_512.tif")
 
 # read image
@@ -101,11 +103,12 @@ def printParametersToString(pars):
 
 print ("#############ROF TV CPU####################")
 start_time = timeit.default_timer()
-(rof_cpu3D, info_vec_cpu) = ROF_TV(pars['input'],
+info_vec_cpu = np.zeros(2, dtype = np.float32)
+rof_cpu3D = ROF_TV(pars['input'],
              pars['regularisation_parameter'],
              pars['number_of_iterations'],
              pars['time_marching_parameter'],
-              pars['tolerance_constant'], 'cpu')
+              pars['tolerance_constant'], device='cpu', infovector=info_vec_cpu)
 
 Qtools = QualityTools(idealVol, rof_cpu3D)
 pars['rmse'] = Qtools.rmse()
@@ -146,12 +149,12 @@ def printParametersToString(pars):
 
 print ("#############FGP TV GPU####################")
 start_time = timeit.default_timer()
-(fgp_cpu3D, info_vec_cpu)  = FGP_TV(pars['input'], 
+fgp_cpu3D = FGP_TV(pars['input'], 
               pars['regularisation_parameter'],
               pars['number_of_iterations'],
               pars['tolerance_constant'], 
               pars['methodTV'],
-              pars['nonneg'], 'cpu')
+              pars['nonneg'], device='cpu', infovector=info_vec_cpu)
 
 Qtools = QualityTools(idealVol, fgp_cpu3D)
 pars['rmse'] = Qtools.rmse()
@@ -190,15 +193,16 @@ def printParametersToString(pars):
         'nonneg': 0,
         'lipschitz_const' : 8}
 
-print ("#############FGP TV GPU####################")
+print ("#############PD-TV (3D) CPU####################")
 start_time = timeit.default_timer()
-(pd_cpu3D,info_vec_cpu) = PD_TV(pars['input'], 
+pd_cpu3D = PD_TV(pars['input'], 
               pars['regularisation_parameter'],
               pars['number_of_iterations'],
               pars['tolerance_constant'], 
+              pars['lipschitz_const'],
               pars['methodTV'],
               pars['nonneg'],
-              pars['lipschitz_const'],'cpu')
+              device='cpu', infovector=info_vec_cpu)
 
 Qtools = QualityTools(idealVol, pd_cpu3D)
 pars['rmse'] = Qtools.rmse()
@@ -237,11 +241,11 @@ def printParametersToString(pars):
 
 print ("#############SB TV CPU####################")
 start_time = timeit.default_timer()
-(sb_cpu3D, info_vec_cpu) = SB_TV(pars['input'], 
+sb_cpu3D = SB_TV(pars['input'], 
               pars['regularisation_parameter'],
               pars['number_of_iterations'],
               pars['tolerance_constant'], 
-              pars['methodTV'],'cpu')
+              pars['methodTV'], device='cpu', infovector=info_vec_cpu)
 
 Qtools = QualityTools(idealVol, sb_cpu3D)
 pars['rmse'] = Qtools.rmse()
@@ -283,12 +287,12 @@ def printParametersToString(pars):
 
 print ("#############LLT ROF CPU####################")
 start_time = timeit.default_timer()
-(lltrof_cpu3D,info_vec_cpu) = LLT_ROF(pars['input'], 
+lltrof_cpu3D = LLT_ROF(pars['input'], 
               pars['regularisation_parameterROF'],
               pars['regularisation_parameterLLT'],
               pars['number_of_iterations'],
               pars['time_marching_parameter'],
-              pars['tolerance_constant'], 'cpu')
+              pars['tolerance_constant'], device='cpu', infovector=info_vec_cpu)
 
 
 Qtools = QualityTools(idealVol, lltrof_cpu3D)
@@ -331,13 +335,13 @@ def printParametersToString(pars):
 
 print ("#############TGV CPU####################")
 start_time = timeit.default_timer()
-(tgv_cpu3D,info_vec_cpu)  = TGV(pars['input'], 
+tgv_cpu3D  = TGV(pars['input'], 
               pars['regularisation_parameter'],
               pars['alpha1'],
               pars['alpha0'],
               pars['number_of_iterations'],
               pars['LipshitzConstant'],
-              pars['tolerance_constant'],'cpu')
+              pars['tolerance_constant'], device='cpu', infovector=info_vec_cpu)
 
 
 Qtools = QualityTools(idealVol, tgv_cpu3D)
@@ -380,13 +384,13 @@ def printParametersToString(pars):
 
 print ("#############NDF CPU################")
 start_time = timeit.default_timer()
-(ndf_cpu3D,info_vec_cpu)  = NDF(pars['input'], 
+ndf_cpu3D  = NDF(pars['input'], 
               pars['regularisation_parameter'],
               pars['edge_parameter'], 
               pars['number_of_iterations'],
               pars['time_marching_parameter'], 
               pars['penalty_type'],
-              pars['tolerance_constant'], 'cpu')
+              pars['tolerance_constant'], device='cpu', infovector=info_vec_cpu)
 
 
 Qtools = QualityTools(idealVol, ndf_cpu3D)
@@ -428,12 +432,12 @@ def printParametersToString(pars):
 
 print ("#############Diff4th CPU################")
 start_time = timeit.default_timer()
-(diff4th_cpu3D,info_vec_cpu) = Diff4th(pars['input'], 
+diff4th_cpu3D = Diff4th(pars['input'], 
               pars['regularisation_parameter'],
               pars['edge_parameter'], 
               pars['number_of_iterations'],
               pars['time_marching_parameter'],
-              pars['tolerance_constant'],'cpu')
+              pars['tolerance_constant'], device='cpu', infovector=info_vec_cpu)
 
 
 Qtools = QualityTools(idealVol, diff4th_cpu3D)
@@ -477,14 +481,14 @@ def printParametersToString(pars):
 
 print ("#############FGP dTV CPU####################")
 start_time = timeit.default_timer()
-(fgp_dTV_cpu3D,info_vec_cpu)  = FGP_dTV(pars['input'],
+fgp_dTV_cpu3D = FGP_dTV(pars['input'],
               pars['refdata'], 
               pars['regularisation_parameter'],
               pars['number_of_iterations'],
               pars['tolerance_constant'], 
               pars['eta_const'],
               pars['methodTV'],
-              pars['nonneg'],'cpu')
+              pars['nonneg'], device='cpu', infovector=info_vec_cpu)
 
 
 Qtools = QualityTools(idealVol, fgp_dTV_cpu3D)