summaryrefslogtreecommitdiffstats
path: root/src/Python
diff options
context:
space:
mode:
Diffstat (limited to 'src/Python')
-rw-r--r--src/Python/ccpi/filters/regularisers.py188
-rw-r--r--src/Python/setup-regularisers.py.in4
-rw-r--r--src/Python/src/cpu_regularisers.pyx637
-rw-r--r--src/Python/src/gpu_regularisers.pyx596
4 files changed, 765 insertions, 660 deletions
diff --git a/src/Python/ccpi/filters/regularisers.py b/src/Python/ccpi/filters/regularisers.py
index 588ea32..398e11c 100644
--- a/src/Python/ccpi/filters/regularisers.py
+++ b/src/Python/ccpi/filters/regularisers.py
@@ -7,21 +7,23 @@ try:
from ccpi.filters.gpu_regularisers import TV_ROF_GPU, TV_FGP_GPU, TV_SB_GPU, dTV_FGP_GPU, NDF_GPU, Diff4th_GPU, TGV_GPU, LLT_ROF_GPU, PATCHSEL_GPU
gpu_enabled = True
except ImportError:
- gpu_enabled = False
+ gpu_enabled = False
from ccpi.filters.cpu_regularisers import NDF_INPAINT_CPU, NVM_INPAINT_CPU
def ROF_TV(inputData, regularisation_parameter, iterations,
- time_marching_parameter,device='cpu'):
+ time_marching_parameter,tolerance_param,device='cpu'):
if device == 'cpu':
return TV_ROF_CPU(inputData,
regularisation_parameter,
- iterations,
- time_marching_parameter)
+ iterations,
+ time_marching_parameter,
+ tolerance_param)
elif device == 'gpu' and gpu_enabled:
return TV_ROF_GPU(inputData,
regularisation_parameter,
- iterations,
- time_marching_parameter)
+ iterations,
+ time_marching_parameter,
+ tolerance_param)
else:
if not gpu_enabled and device == 'gpu':
raise ValueError ('GPU is not available')
@@ -29,134 +31,165 @@ def ROF_TV(inputData, regularisation_parameter, iterations,
.format(device))
def FGP_TV(inputData, regularisation_parameter,iterations,
- tolerance_param, methodTV, nonneg, printM, device='cpu'):
+ tolerance_param, methodTV, nonneg, device='cpu'):
if device == 'cpu':
return TV_FGP_CPU(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
methodTV,
- nonneg,
- printM)
+ nonneg)
elif device == 'gpu' and gpu_enabled:
return TV_FGP_GPU(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
methodTV,
- nonneg,
- printM)
+ nonneg)
else:
if not gpu_enabled and device == 'gpu':
raise ValueError ('GPU is not available')
raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
.format(device))
def SB_TV(inputData, regularisation_parameter, iterations,
- tolerance_param, methodTV, printM, device='cpu'):
+ tolerance_param, methodTV, device='cpu'):
if device == 'cpu':
return TV_SB_CPU(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
- methodTV,
- printM)
+ methodTV)
elif device == 'gpu' and gpu_enabled:
return TV_SB_GPU(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
- methodTV,
- printM)
+ methodTV)
else:
if not gpu_enabled and device == 'gpu':
raise ValueError ('GPU is not available')
raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
.format(device))
-def FGP_dTV(inputData, refdata, regularisation_parameter, iterations,
- tolerance_param, eta_const, methodTV, nonneg, printM, device='cpu'):
+def LLT_ROF(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations,
+ time_marching_parameter, tolerance_param, device='cpu'):
if device == 'cpu':
- return dTV_FGP_CPU(inputData,
- refdata,
- regularisation_parameter,
- iterations,
- tolerance_param,
- eta_const,
- methodTV,
- nonneg,
- printM)
+ return LLT_ROF_CPU(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, tolerance_param)
elif device == 'gpu' and gpu_enabled:
- return dTV_FGP_GPU(inputData,
- refdata,
- regularisation_parameter,
- iterations,
- tolerance_param,
- eta_const,
- methodTV,
- nonneg,
- printM)
+ return LLT_ROF_GPU(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, tolerance_param)
+ else:
+ if not gpu_enabled and device == 'gpu':
+ raise ValueError ('GPU is not available')
+ raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
+ .format(device))
+def TGV(inputData, regularisation_parameter, alpha1, alpha0, iterations,
+ LipshitzConst, tolerance_param, device='cpu'):
+ if device == 'cpu':
+ return TGV_CPU(inputData,
+ regularisation_parameter,
+ alpha1,
+ alpha0,
+ iterations,
+ LipshitzConst,
+ tolerance_param)
+ elif device == 'gpu' and gpu_enabled:
+ return TGV_GPU(inputData,
+ regularisation_parameter,
+ alpha1,
+ alpha0,
+ iterations,
+ LipshitzConst,
+ tolerance_param)
else:
if not gpu_enabled and device == 'gpu':
raise ValueError ('GPU is not available')
raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
.format(device))
-def TNV(inputData, regularisation_parameter, iterations, tolerance_param):
- return TNV_CPU(inputData,
- regularisation_parameter,
- iterations,
- tolerance_param)
def NDF(inputData, regularisation_parameter, edge_parameter, iterations,
- time_marching_parameter, penalty_type, device='cpu'):
+ time_marching_parameter, penalty_type, tolerance_param, device='cpu'):
if device == 'cpu':
return NDF_CPU(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
+ iterations,
time_marching_parameter,
- penalty_type)
+ penalty_type,
+ tolerance_param)
elif device == 'gpu' and gpu_enabled:
return NDF_GPU(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
+ iterations,
time_marching_parameter,
- penalty_type)
+ penalty_type,
+ tolerance_param)
else:
if not gpu_enabled and device == 'gpu':
raise ValueError ('GPU is not available')
raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
.format(device))
def Diff4th(inputData, regularisation_parameter, edge_parameter, iterations,
- time_marching_parameter, device='cpu'):
+ time_marching_parameter, tolerance_param, device='cpu'):
if device == 'cpu':
return Diff4th_CPU(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
- time_marching_parameter)
+ iterations,
+ time_marching_parameter,
+ tolerance_param)
elif device == 'gpu' and gpu_enabled:
return Diff4th_GPU(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
- time_marching_parameter)
+ iterations,
+ time_marching_parameter,
+ tolerance_param)
+ else:
+ if not gpu_enabled and device == 'gpu':
+ raise ValueError ('GPU is not available')
+ raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
+ .format(device))
+def FGP_dTV(inputData, refdata, regularisation_parameter, iterations,
+ tolerance_param, eta_const, methodTV, nonneg, device='cpu'):
+ if device == 'cpu':
+ return dTV_FGP_CPU(inputData,
+ refdata,
+ regularisation_parameter,
+ iterations,
+ tolerance_param,
+ eta_const,
+ methodTV,
+ nonneg)
+ elif device == 'gpu' and gpu_enabled:
+ return dTV_FGP_GPU(inputData,
+ refdata,
+ regularisation_parameter,
+ iterations,
+ tolerance_param,
+ eta_const,
+ methodTV,
+ nonneg)
else:
if not gpu_enabled and device == 'gpu':
raise ValueError ('GPU is not available')
raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
.format(device))
-
+def TNV(inputData, regularisation_parameter, iterations, tolerance_param):
+ return TNV_CPU(inputData,
+ regularisation_parameter,
+ iterations,
+ tolerance_param)
def PatchSelect(inputData, searchwindow, patchwindow, neighbours, edge_parameter, device='cpu'):
if device == 'cpu':
return PATCHSEL_CPU(inputData,
searchwindow,
patchwindow,
- neighbours,
+ neighbours,
edge_parameter)
elif device == 'gpu' and gpu_enabled:
return PATCHSEL_GPU(inputData,
searchwindow,
patchwindow,
- neighbours,
+ neighbours,
edge_parameter)
else:
if not gpu_enabled and device == 'gpu':
@@ -168,47 +201,14 @@ def NLTV(inputData, H_i, H_j, H_k, Weights, regularisation_parameter, iterations
return NLTV_CPU(inputData,
H_i,
H_j,
- H_k,
+ H_k,
Weights,
regularisation_parameter,
iterations)
-
-def TGV(inputData, regularisation_parameter, alpha1, alpha0, iterations,
- LipshitzConst, device='cpu'):
- if device == 'cpu':
- return TGV_CPU(inputData,
- regularisation_parameter,
- alpha1,
- alpha0,
- iterations,
- LipshitzConst)
- elif device == 'gpu' and gpu_enabled:
- return TGV_GPU(inputData,
- regularisation_parameter,
- alpha1,
- alpha0,
- iterations,
- LipshitzConst)
- else:
- if not gpu_enabled and device == 'gpu':
- raise ValueError ('GPU is not available')
- raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
- .format(device))
-def LLT_ROF(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations,
- time_marching_parameter, device='cpu'):
- if device == 'cpu':
- return LLT_ROF_CPU(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter)
- elif device == 'gpu' and gpu_enabled:
- return LLT_ROF_GPU(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter)
- else:
- if not gpu_enabled and device == 'gpu':
- raise ValueError ('GPU is not available')
- raise ValueError('Unknown device {0}. Expecting gpu or cpu'\
- .format(device))
def NDF_INP(inputData, maskData, regularisation_parameter, edge_parameter, iterations,
time_marching_parameter, penalty_type):
- return NDF_INPAINT_CPU(inputData, maskData, regularisation_parameter,
+ return NDF_INPAINT_CPU(inputData, maskData, regularisation_parameter,
edge_parameter, iterations, time_marching_parameter, penalty_type)
-
+
def NVM_INP(inputData, maskData, SW_increment, iterations):
return NVM_INPAINT_CPU(inputData, maskData, SW_increment, iterations)
diff --git a/src/Python/setup-regularisers.py.in b/src/Python/setup-regularisers.py.in
index 82d9f9f..4c578e3 100644
--- a/src/Python/setup-regularisers.py.in
+++ b/src/Python/setup-regularisers.py.in
@@ -44,7 +44,7 @@ extra_include_dirs += [os.path.join(".." , "Core"),
os.path.join(".." , "Core", "regularisers_GPU" , "LLTROF" ) ,
os.path.join(".." , "Core", "regularisers_GPU" , "NDF" ) ,
os.path.join(".." , "Core", "regularisers_GPU" , "dTV_FGP" ) ,
- os.path.join(".." , "Core", "regularisers_GPU" , "DIFF4th" ) ,
+ os.path.join(".." , "Core", "regularisers_GPU" , "Diff4th" ) ,
os.path.join(".." , "Core", "regularisers_GPU" , "PatchSelect" ) ,
"."]
@@ -68,7 +68,7 @@ setup(
],
zip_safe = False,
- packages = {'ccpi','ccpi.filters', 'ccpi.supp'},
+ packages = {'ccpi', 'ccpi.filters', 'ccpi.supp'},
)
diff --git a/src/Python/src/cpu_regularisers.pyx b/src/Python/src/cpu_regularisers.pyx
index 11a0617..add641b 100644
--- a/src/Python/src/cpu_regularisers.pyx
+++ b/src/Python/src/cpu_regularisers.pyx
@@ -18,15 +18,15 @@ import cython
import numpy as np
cimport numpy as np
-cdef extern float TV_ROF_CPU_main(float *Input, float *Output, float lambdaPar, int iterationsNumb, float tau, int dimX, int dimY, int dimZ);
-cdef extern float TV_FGP_CPU_main(float *Input, float *Output, float lambdaPar, int iterationsNumb, float epsil, int methodTV, int nonneg, int printM, int dimX, int dimY, int dimZ);
-cdef extern float SB_TV_CPU_main(float *Input, float *Output, float lambdaPar, int iterationsNumb, float epsil, int methodTV, int printM, int dimX, int dimY, int dimZ);
-cdef extern float LLT_ROF_CPU_main(float *Input, float *Output, float lambdaROF, float lambdaLLT, int iterationsNumb, float tau, int dimX, int dimY, int dimZ);
-cdef extern float TGV_main(float *Input, float *Output, float lambdaPar, float alpha1, float alpha0, int iterationsNumb, float L2, int dimX, int dimY, int dimZ);
-cdef extern float Diffusion_CPU_main(float *Input, float *Output, float lambdaPar, float sigmaPar, int iterationsNumb, float tau, int penaltytype, int dimX, int dimY, int dimZ);
-cdef extern float Diffus4th_CPU_main(float *Input, float *Output, float lambdaPar, float sigmaPar, int iterationsNumb, float tau, int dimX, int dimY, int dimZ);
+cdef extern float TV_ROF_CPU_main(float *Input, float *Output, float *infovector, float lambdaPar, int iterationsNumb, float tau, float epsil, int dimX, int dimY, int dimZ);
+cdef extern float TV_FGP_CPU_main(float *Input, float *Output, float *infovector, float lambdaPar, int iterationsNumb, float epsil, int methodTV, int nonneg, int dimX, int dimY, int dimZ);
+cdef extern float SB_TV_CPU_main(float *Input, float *Output, float *infovector, float mu, int iter, float epsil, int methodTV, int dimX, int dimY, int dimZ);
+cdef extern float LLT_ROF_CPU_main(float *Input, float *Output, float *infovector, float lambdaROF, float lambdaLLT, int iterationsNumb, float tau, float epsil, int dimX, int dimY, int dimZ);
+cdef extern float TGV_main(float *Input, float *Output, float *infovector, float lambdaPar, float alpha1, float alpha0, int iterationsNumb, float L2, float epsil, int dimX, int dimY, int dimZ);
+cdef extern float Diffusion_CPU_main(float *Input, float *Output, float *infovector, float lambdaPar, float sigmaPar, int iterationsNumb, float tau, int penaltytype, float epsil, int dimX, int dimY, int dimZ);
+cdef extern float Diffus4th_CPU_main(float *Input, float *Output, float *infovector, float lambdaPar, float sigmaPar, int iterationsNumb, float tau, float epsil, int dimX, int dimY, int dimZ);
+cdef extern float dTV_FGP_CPU_main(float *Input, float *InputRef, float *Output, float *infovector, float lambdaPar, int iterationsNumb, float epsil, float eta, int methodTV, int nonneg, int dimX, int dimY, int dimZ);
cdef extern float TNV_CPU_main(float *Input, float *u, float lambdaPar, int maxIter, float tol, int dimX, int dimY, int dimZ);
-cdef extern float dTV_FGP_CPU_main(float *Input, float *InputRef, float *Output, float lambdaPar, int iterationsNumb, float epsil, float eta, int methodTV, int nonneg, int printM, int dimX, int dimY, int dimZ);
cdef extern float PatchSelect_CPU_main(float *Input, unsigned short *H_i, unsigned short *H_j, unsigned short *H_k, float *Weights, int dimX, int dimY, int dimZ, int SearchWindow, int SimilarWin, int NumNeighb, float h, int switchM);
cdef extern float Nonlocal_TV_CPU_main(float *A_orig, float *Output, unsigned short *H_i, unsigned short *H_j, unsigned short *H_k, float *Weights, int dimX, int dimY, int dimZ, int NumNeighb, float lambdaReg, int IterNumb);
@@ -37,341 +37,482 @@ cdef extern float TV_energy3D(float *U, float *U0, float *E_val, float lambdaPar
#****************************************************************#
#********************** Total-variation ROF *********************#
#****************************************************************#
-def TV_ROF_CPU(inputData, regularisation_parameter, iterationsNumb, marching_step_parameter):
+def TV_ROF_CPU(inputData, regularisation_parameter, iterationsNumb, marching_step_parameter,tolerance_param):
if inputData.ndim == 2:
- return TV_ROF_2D(inputData, regularisation_parameter, iterationsNumb, marching_step_parameter)
+ return TV_ROF_2D(inputData, regularisation_parameter, iterationsNumb, marching_step_parameter,tolerance_param)
elif inputData.ndim == 3:
- return TV_ROF_3D(inputData, regularisation_parameter, iterationsNumb, marching_step_parameter)
+ return TV_ROF_3D(inputData, regularisation_parameter, iterationsNumb, marching_step_parameter,tolerance_param)
-def TV_ROF_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def TV_ROF_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
- int iterationsNumb,
- float marching_step_parameter):
+ int iterationsNumb,
+ float marching_step_parameter,
+ float tolerance_param):
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Run ROF iterations for 2D data
- TV_ROF_CPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameter, iterationsNumb, marching_step_parameter, dims[1], dims[0], 1)
-
- return outputData
-
-def TV_ROF_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Run ROF iterations for 2D data
+ TV_ROF_CPU_main(&inputData[0,0], &outputData[0,0], &infovec[0], regularisation_parameter, iterationsNumb, marching_step_parameter, tolerance_param, dims[1], dims[0], 1)
+
+ return (outputData,infovec)
+
+def TV_ROF_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
int iterationsNumb,
- float marching_step_parameter):
+ float marching_step_parameter,
+ float tolerance_param):
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Run ROF iterations for 3D data
- TV_ROF_CPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter, iterationsNumb, marching_step_parameter, dims[2], dims[1], dims[0])
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
- return outputData
+ # Run ROF iterations for 3D data
+ TV_ROF_CPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0], regularisation_parameter, iterationsNumb, marching_step_parameter, tolerance_param, dims[2], dims[1], dims[0])
+
+ return (outputData,infovec)
#****************************************************************#
#********************** Total-variation FGP *********************#
#****************************************************************#
#******** Total-variation Fast-Gradient-Projection (FGP)*********#
-def TV_FGP_CPU(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, nonneg, printM):
+def TV_FGP_CPU(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, nonneg):
if inputData.ndim == 2:
- return TV_FGP_2D(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, nonneg, printM)
+ return TV_FGP_2D(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, nonneg)
elif inputData.ndim == 3:
- return TV_FGP_3D(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, nonneg, printM)
+ return TV_FGP_3D(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, nonneg)
-def TV_FGP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def TV_FGP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
- int iterationsNumb,
+ int iterationsNumb,
float tolerance_param,
int methodTV,
- int nonneg,
- int printM):
-
+ int nonneg):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
+
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
#/* Run FGP-TV iterations for 2D data */
- TV_FGP_CPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameter,
- iterationsNumb,
+ TV_FGP_CPU_main(&inputData[0,0], &outputData[0,0], &infovec[0], regularisation_parameter,
+ iterationsNumb,
tolerance_param,
methodTV,
nonneg,
- printM,
dims[1],dims[0],1)
-
- return outputData
-
-def TV_FGP_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+
+ return (outputData,infovec)
+
+def TV_FGP_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
- int iterationsNumb,
+ int iterationsNumb,
float tolerance_param,
int methodTV,
- int nonneg,
- int printM):
+ int nonneg):
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0], dims[1], dims[2]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
#/* Run FGP-TV iterations for 3D data */
- TV_FGP_CPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter,
- iterationsNumb,
+ TV_FGP_CPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0], regularisation_parameter,
+ iterationsNumb,
tolerance_param,
methodTV,
nonneg,
- printM,
dims[2], dims[1], dims[0])
- return outputData
+ return (outputData,infovec)
#***************************************************************#
#********************** Total-variation SB *********************#
#***************************************************************#
#*************** Total-variation Split Bregman (SB)*************#
-def TV_SB_CPU(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, printM):
+def TV_SB_CPU(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV):
if inputData.ndim == 2:
- return TV_SB_2D(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, printM)
+ return TV_SB_2D(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV)
elif inputData.ndim == 3:
- return TV_SB_3D(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV, printM)
+ return TV_SB_3D(inputData, regularisation_parameter, iterationsNumb, tolerance_param, methodTV)
-def TV_SB_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def TV_SB_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
- int iterationsNumb,
+ int iterationsNumb,
float tolerance_param,
- int methodTV,
- int printM):
-
+ int methodTV):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
#/* Run SB-TV iterations for 2D data */
- SB_TV_CPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameter,
- iterationsNumb,
+ SB_TV_CPU_main(&inputData[0,0], &outputData[0,0], &infovec[0],
+ regularisation_parameter,
+ iterationsNumb,
tolerance_param,
methodTV,
- printM,
- dims[1],dims[0],1)
-
- return outputData
-
-def TV_SB_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+ dims[1],dims[0], 1)
+
+ return (outputData,infovec)
+
+def TV_SB_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
- int iterationsNumb,
+ int iterationsNumb,
float tolerance_param,
- int methodTV,
- int printM):
+ int methodTV):
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0], dims[1], dims[2]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
#/* Run SB-TV iterations for 3D data */
- SB_TV_CPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter,
- iterationsNumb,
+ SB_TV_CPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0],
+ regularisation_parameter,
+ iterationsNumb,
tolerance_param,
methodTV,
- printM,
dims[2], dims[1], dims[0])
- return outputData
+ return (outputData,infovec)
+#***************************************************************#
+#******************* ROF - LLT regularisation ******************#
+#***************************************************************#
+def LLT_ROF_CPU(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, tolerance_param):
+ if inputData.ndim == 2:
+ return LLT_ROF_2D(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, tolerance_param)
+ elif inputData.ndim == 3:
+ return LLT_ROF_3D(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, tolerance_param)
+
+def LLT_ROF_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+ float regularisation_parameterROF,
+ float regularisation_parameterLLT,
+ int iterations,
+ float time_marching_parameter,
+ float tolerance_param):
+
+ cdef long dims[2]
+ dims[0] = inputData.shape[0]
+ dims[1] = inputData.shape[1]
+
+ cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
+ np.zeros([dims[0],dims[1]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
+ #/* Run ROF-LLT iterations for 2D data */
+ LLT_ROF_CPU_main(&inputData[0,0], &outputData[0,0], &infovec[0], regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter,
+ tolerance_param,
+ dims[1],dims[0],1)
+ return (outputData,infovec)
+
+def LLT_ROF_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+ float regularisation_parameterROF,
+ float regularisation_parameterLLT,
+ int iterations,
+ float time_marching_parameter,
+ float tolerance_param):
+
+ cdef long dims[3]
+ dims[0] = inputData.shape[0]
+ dims[1] = inputData.shape[1]
+ dims[2] = inputData.shape[2]
+ cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
+ np.zeros([dims[0], dims[1], dims[2]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
+ #/* Run ROF-LLT iterations for 3D data */
+ LLT_ROF_CPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0], regularisation_parameterROF, regularisation_parameterLLT, iterations,
+ time_marching_parameter,
+ tolerance_param,
+ dims[2], dims[1], dims[0])
+ return (outputData,infovec)
#***************************************************************#
#***************** Total Generalised Variation *****************#
#***************************************************************#
-def TGV_CPU(inputData, regularisation_parameter, alpha1, alpha0, iterations, LipshitzConst):
+def TGV_CPU(inputData, regularisation_parameter, alpha1, alpha0, iterations, LipshitzConst, tolerance_param):
if inputData.ndim == 2:
- return TGV_2D(inputData, regularisation_parameter, alpha1, alpha0,
- iterations, LipshitzConst)
+ return TGV_2D(inputData, regularisation_parameter, alpha1, alpha0,
+ iterations, LipshitzConst, tolerance_param)
elif inputData.ndim == 3:
- return TGV_3D(inputData, regularisation_parameter, alpha1, alpha0,
- iterations, LipshitzConst)
+ return TGV_3D(inputData, regularisation_parameter, alpha1, alpha0,
+ iterations, LipshitzConst, tolerance_param)
-def TGV_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def TGV_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
float alpha1,
float alpha0,
- int iterationsNumb,
- float LipshitzConst):
-
+ int iterationsNumb,
+ float LipshitzConst,
+ float tolerance_param):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
#/* Run TGV iterations for 2D data */
- TGV_main(&inputData[0,0], &outputData[0,0], regularisation_parameter,
+ TGV_main(&inputData[0,0], &outputData[0,0], &infovec[0], regularisation_parameter,
alpha1,
alpha0,
- iterationsNumb,
+ iterationsNumb,
LipshitzConst,
+ tolerance_param,
dims[1],dims[0],1)
- return outputData
-def TGV_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+ return (outputData,infovec)
+def TGV_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
float alpha1,
float alpha0,
- int iterationsNumb,
- float LipshitzConst):
-
+ int iterationsNumb,
+ float LipshitzConst,
+ float tolerance_param):
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0], dims[1], dims[2]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
#/* Run TGV iterations for 3D data */
- TGV_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter,
+ TGV_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0], regularisation_parameter,
alpha1,
alpha0,
- iterationsNumb,
+ iterationsNumb,
LipshitzConst,
+ tolerance_param,
dims[2], dims[1], dims[0])
- return outputData
+ return (outputData,infovec)
-#***************************************************************#
-#******************* ROF - LLT regularisation ******************#
-#***************************************************************#
-def LLT_ROF_CPU(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter):
+#****************************************************************#
+#***************Nonlinear (Isotropic) Diffusion******************#
+#****************************************************************#
+def NDF_CPU(inputData, regularisation_parameter, edge_parameter, iterationsNumb,time_marching_parameter, penalty_type,tolerance_param):
if inputData.ndim == 2:
- return LLT_ROF_2D(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter)
+ return NDF_2D(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type, tolerance_param)
elif inputData.ndim == 3:
- return LLT_ROF_3D(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter)
+ return NDF_3D(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type, tolerance_param)
-def LLT_ROF_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
- float regularisation_parameterROF,
- float regularisation_parameterLLT,
- int iterations,
- float time_marching_parameter):
-
+def NDF_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+ float regularisation_parameter,
+ float edge_parameter,
+ int iterationsNumb,
+ float time_marching_parameter,
+ int penalty_type,
+ float tolerance_param):
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
- #/* Run ROF-LLT iterations for 2D data */
- LLT_ROF_CPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, dims[1],dims[0],1)
- return outputData
-
-def LLT_ROF_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
- float regularisation_parameterROF,
- float regularisation_parameterLLT,
- int iterations,
- float time_marching_parameter):
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
+ # Run Nonlinear Diffusion iterations for 2D data
+ Diffusion_CPU_main(&inputData[0,0], &outputData[0,0], &infovec[0],
+ regularisation_parameter, edge_parameter, iterationsNumb,
+ time_marching_parameter, penalty_type,
+ tolerance_param,
+ dims[1], dims[0], 1)
+ return (outputData,infovec)
+
+def NDF_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+ float regularisation_parameter,
+ float edge_parameter,
+ int iterationsNumb,
+ float time_marching_parameter,
+ int penalty_type,
+ float tolerance_param):
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
- np.zeros([dims[0], dims[1], dims[2]], dtype='float32')
-
- #/* Run ROF-LLT iterations for 3D data */
- LLT_ROF_CPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, dims[2], dims[1], dims[0])
- return outputData
+ np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
+ # Run Nonlinear Diffusion iterations for 3D data
+ Diffusion_CPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0],
+ regularisation_parameter, edge_parameter, iterationsNumb,
+ time_marching_parameter, penalty_type,
+ tolerance_param,
+ dims[2], dims[1], dims[0])
+ return (outputData,infovec)
+#****************************************************************#
+#*************Anisotropic Fourth-Order diffusion*****************#
+#****************************************************************#
+def Diff4th_CPU(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter,tolerance_param):
+ if inputData.ndim == 2:
+ return Diff4th_2D(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter,tolerance_param)
+ elif inputData.ndim == 3:
+ return Diff4th_3D(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter,tolerance_param)
+def Diff4th_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+ float regularisation_parameter,
+ float edge_parameter,
+ int iterationsNumb,
+ float time_marching_parameter,
+ float tolerance_param):
+ cdef long dims[2]
+ dims[0] = inputData.shape[0]
+ dims[1] = inputData.shape[1]
+
+ cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
+ np.zeros([dims[0],dims[1]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
+ # Run Anisotropic Fourth-Order diffusion for 2D data
+ Diffus4th_CPU_main(&inputData[0,0], &outputData[0,0], &infovec[0],
+ regularisation_parameter,
+ edge_parameter, iterationsNumb,
+ time_marching_parameter,
+ tolerance_param,
+ dims[1], dims[0], 1)
+ return (outputData,infovec)
+
+def Diff4th_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+ float regularisation_parameter,
+ float edge_parameter,
+ int iterationsNumb,
+ float time_marching_parameter,
+ float tolerance_param):
+ cdef long dims[3]
+ dims[0] = inputData.shape[0]
+ dims[1] = inputData.shape[1]
+ dims[2] = inputData.shape[2]
+
+ cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
+ np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
+ # Run Anisotropic Fourth-Order diffusion for 3D data
+ Diffus4th_CPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0],
+ regularisation_parameter, edge_parameter,
+ iterationsNumb, time_marching_parameter,
+ tolerance_param,
+ dims[2], dims[1], dims[0])
+ return (outputData,infovec)
#****************************************************************#
#**************Directional Total-variation FGP ******************#
#****************************************************************#
#******** Directional TV Fast-Gradient-Projection (FGP)*********#
-def dTV_FGP_CPU(inputData, refdata, regularisation_parameter, iterationsNumb, tolerance_param, eta_const, methodTV, nonneg, printM):
+def dTV_FGP_CPU(inputData, refdata, regularisation_parameter, iterationsNumb, tolerance_param, eta_const, methodTV, nonneg):
if inputData.ndim == 2:
- return dTV_FGP_2D(inputData, refdata, regularisation_parameter, iterationsNumb, tolerance_param, eta_const, methodTV, nonneg, printM)
+ return dTV_FGP_2D(inputData, refdata, regularisation_parameter, iterationsNumb, tolerance_param, eta_const, methodTV, nonneg)
elif inputData.ndim == 3:
- return dTV_FGP_3D(inputData, refdata, regularisation_parameter, iterationsNumb, tolerance_param, eta_const, methodTV, nonneg, printM)
+ return dTV_FGP_3D(inputData, refdata, regularisation_parameter, iterationsNumb, tolerance_param, eta_const, methodTV, nonneg)
-def dTV_FGP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def dTV_FGP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
np.ndarray[np.float32_t, ndim=2, mode="c"] refdata,
float regularisation_parameter,
- int iterationsNumb,
+ int iterationsNumb,
float tolerance_param,
float eta_const,
int methodTV,
- int nonneg,
- int printM):
-
+ int nonneg):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
#/* Run FGP-dTV iterations for 2D data */
- dTV_FGP_CPU_main(&inputData[0,0], &refdata[0,0], &outputData[0,0], regularisation_parameter,
- iterationsNumb,
+ dTV_FGP_CPU_main(&inputData[0,0], &refdata[0,0], &outputData[0,0], &infovec[0],
+ regularisation_parameter,
+ iterationsNumb,
tolerance_param,
eta_const,
- methodTV,
+ methodTV,
nonneg,
- printM,
dims[1], dims[0], 1)
-
- return outputData
-
+ return (outputData,infovec)
+
def dTV_FGP_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
np.ndarray[np.float32_t, ndim=3, mode="c"] refdata,
float regularisation_parameter,
- int iterationsNumb,
+ int iterationsNumb,
float tolerance_param,
float eta_const,
int methodTV,
- int nonneg,
- int printM):
+ int nonneg):
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0], dims[1], dims[2]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.zeros([2], dtype='float32')
+
#/* Run FGP-dTV iterations for 3D data */
- dTV_FGP_CPU_main(&inputData[0,0,0], &refdata[0,0,0], &outputData[0,0,0], regularisation_parameter,
- iterationsNumb,
+ dTV_FGP_CPU_main(&inputData[0,0,0], &refdata[0,0,0], &outputData[0,0,0], &infovec[0],
+ regularisation_parameter,
+ iterationsNumb,
tolerance_param,
eta_const,
methodTV,
nonneg,
- printM,
dims[2], dims[1], dims[0])
- return outputData
-
+ return (outputData,infovec)
+
#****************************************************************#
#*********************Total Nuclear Variation********************#
#****************************************************************#
def TNV_CPU(inputData, regularisation_parameter, iterationsNumb, tolerance_param):
if inputData.ndim == 2:
- return
+ return
elif inputData.ndim == 3:
return TNV_3D(inputData, regularisation_parameter, iterationsNumb, tolerance_param)
-def TNV_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+def TNV_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
int iterationsNumb,
float tolerance_param):
@@ -379,101 +520,13 @@ def TNV_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
- cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
- np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Run TNV iterations for 3D (X,Y,Channels) data
- TNV_CPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter, iterationsNumb, tolerance_param, dims[2], dims[1], dims[0])
- return outputData
-#****************************************************************#
-#***************Nonlinear (Isotropic) Diffusion******************#
-#****************************************************************#
-def NDF_CPU(inputData, regularisation_parameter, edge_parameter, iterationsNumb,time_marching_parameter, penalty_type):
- if inputData.ndim == 2:
- return NDF_2D(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type)
- elif inputData.ndim == 3:
- return NDF_3D(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type)
-
-def NDF_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
- float regularisation_parameter,
- float edge_parameter,
- int iterationsNumb,
- float time_marching_parameter,
- int penalty_type):
- cdef long dims[2]
- dims[0] = inputData.shape[0]
- dims[1] = inputData.shape[1]
-
- cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
- np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Run Nonlinear Diffusion iterations for 2D data
- Diffusion_CPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type, dims[1], dims[0], 1)
- return outputData
-
-def NDF_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
- float regularisation_parameter,
- float edge_parameter,
- int iterationsNumb,
- float time_marching_parameter,
- int penalty_type):
- cdef long dims[3]
- dims[0] = inputData.shape[0]
- dims[1] = inputData.shape[1]
- dims[2] = inputData.shape[2]
-
- cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
- np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Run Nonlinear Diffusion iterations for 3D data
- Diffusion_CPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type, dims[2], dims[1], dims[0])
-
- return outputData
-#****************************************************************#
-#*************Anisotropic Fourth-Order diffusion*****************#
-#****************************************************************#
-def Diff4th_CPU(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter):
- if inputData.ndim == 2:
- return Diff4th_2D(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter)
- elif inputData.ndim == 3:
- return Diff4th_3D(inputData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter)
-
-def Diff4th_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
- float regularisation_parameter,
- float edge_parameter,
- int iterationsNumb,
- float time_marching_parameter):
- cdef long dims[2]
- dims[0] = inputData.shape[0]
- dims[1] = inputData.shape[1]
-
- cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
- np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Run Anisotropic Fourth-Order diffusion for 2D data
- Diffus4th_CPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, dims[1], dims[0], 1)
- return outputData
-
-def Diff4th_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
- float regularisation_parameter,
- float edge_parameter,
- int iterationsNumb,
- float time_marching_parameter):
- cdef long dims[3]
- dims[0] = inputData.shape[0]
- dims[1] = inputData.shape[1]
- dims[2] = inputData.shape[2]
-
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Run Anisotropic Fourth-Order diffusion for 3D data
- Diffus4th_CPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, dims[2], dims[1], dims[0])
+ # Run TNV iterations for 3D (X,Y,Channels) data
+ TNV_CPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter, iterationsNumb, tolerance_param, dims[2], dims[1], dims[0])
return outputData
-
#****************************************************************#
#***************Patch-based weights calculation******************#
#****************************************************************#
@@ -491,14 +544,14 @@ def PatchSel_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
dims[0] = neighbours
dims[1] = inputData.shape[0]
dims[2] = inputData.shape[1]
-
-
+
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] Weights = \
np.zeros([dims[0], dims[1],dims[2]], dtype='float32')
-
+
cdef np.ndarray[np.uint16_t, ndim=3, mode="c"] H_i = \
np.zeros([dims[0], dims[1],dims[2]], dtype='uint16')
-
+
cdef np.ndarray[np.uint16_t, ndim=3, mode="c"] H_j = \
np.zeros([dims[0], dims[1],dims[2]], dtype='uint16')
@@ -516,16 +569,16 @@ def PatchSel_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
dims[3] = neighbours
-
+
cdef np.ndarray[np.float32_t, ndim=4, mode="c"] Weights = \
np.zeros([dims[3],dims[0],dims[1],dims[2]], dtype='float32')
-
+
cdef np.ndarray[np.uint16_t, ndim=4, mode="c"] H_i = \
np.zeros([dims[3],dims[0],dims[1],dims[2]], dtype='uint16')
-
+
cdef np.ndarray[np.uint16_t, ndim=4, mode="c"] H_j = \
np.zeros([dims[3],dims[0],dims[1],dims[2]], dtype='uint16')
-
+
cdef np.ndarray[np.uint16_t, ndim=4, mode="c"] H_k = \
np.zeros([dims[3],dims[0],dims[1],dims[2]], dtype='uint16')
@@ -553,10 +606,10 @@ def NLTV_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
neighbours = H_i.shape[0]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
+
# Run nonlocal TV regularisation
Nonlocal_TV_CPU_main(&inputData[0,0], &outputData[0,0], &H_i[0,0,0], &H_j[0,0,0], &H_i[0,0,0], &Weights[0,0,0], dims[1], dims[0], 0, neighbours, regularisation_parameter, iterations)
return outputData
@@ -570,7 +623,7 @@ def NDF_INPAINT_CPU(inputData, maskData, regularisation_parameter, edge_paramete
elif inputData.ndim == 3:
return NDF_INP_3D(inputData, maskData, regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type)
-def NDF_INP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def NDF_INP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
np.ndarray[np.uint8_t, ndim=2, mode="c"] maskData,
float regularisation_parameter,
float edge_parameter,
@@ -585,12 +638,12 @@ def NDF_INP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Run Inpaiting by Diffusion iterations for 2D data
+
+ # Run Inpaiting by Diffusion iterations for 2D data
Diffusion_Inpaint_CPU_main(&inputData[0,0], &maskData[0,0], &outputData[0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type, dims[1], dims[0], 1)
return outputData
-
-def NDF_INP_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+
+def NDF_INP_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
np.ndarray[np.uint8_t, ndim=3, mode="c"] maskData,
float regularisation_parameter,
float edge_parameter,
@@ -601,11 +654,11 @@ def NDF_INP_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Run Inpaiting by Diffusion iterations for 3D data
+
+ # Run Inpaiting by Diffusion iterations for 3D data
Diffusion_Inpaint_CPU_main(&inputData[0,0,0], &maskData[0,0,0], &outputData[0,0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type, dims[2], dims[1], dims[0])
return outputData
@@ -616,27 +669,27 @@ def NVM_INPAINT_CPU(inputData, maskData, SW_increment, iterationsNumb):
if inputData.ndim == 2:
return NVM_INP_2D(inputData, maskData, SW_increment, iterationsNumb)
elif inputData.ndim == 3:
- return
+ return
-def NVM_INP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def NVM_INP_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
np.ndarray[np.uint8_t, ndim=2, mode="c"] maskData,
int SW_increment,
int iterationsNumb):
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
- np.zeros([dims[0],dims[1]], dtype='float32')
-
+ np.zeros([dims[0],dims[1]], dtype='float32')
+
cdef np.ndarray[np.uint8_t, ndim=2, mode="c"] maskData_upd = \
np.zeros([dims[0],dims[1]], dtype='uint8')
-
- # Run Inpaiting by Nonlocal vertical marching method for 2D data
- NonlocalMarching_Inpaint_main(&inputData[0,0], &maskData[0,0], &outputData[0,0],
+
+ # Run Inpaiting by Nonlocal vertical marching method for 2D data
+ NonlocalMarching_Inpaint_main(&inputData[0,0], &maskData[0,0], &outputData[0,0],
&maskData_upd[0,0],
SW_increment, iterationsNumb, 1, dims[1], dims[0], 1)
-
+
return (outputData, maskData_upd)
@@ -649,36 +702,36 @@ def TV_ENERGY(inputData, inputData0, regularisation_parameter, typeFunctional):
elif inputData.ndim == 3:
return TV_ENERGY_3D(inputData, inputData0, regularisation_parameter, typeFunctional)
-def TV_ENERGY_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
- np.ndarray[np.float32_t, ndim=2, mode="c"] inputData0,
+def TV_ENERGY_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+ np.ndarray[np.float32_t, ndim=2, mode="c"] inputData0,
float regularisation_parameter,
int typeFunctional):
-
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=1, mode="c"] outputData = \
np.zeros([1], dtype='float32')
-
- # run function
+
+ # run function
TV_energy2D(&inputData[0,0], &inputData0[0,0], &outputData[0], regularisation_parameter, typeFunctional, dims[1], dims[0])
-
+
return outputData
-
+
def TV_ENERGY_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
- np.ndarray[np.float32_t, ndim=3, mode="c"] inputData0,
+ np.ndarray[np.float32_t, ndim=3, mode="c"] inputData0,
float regularisation_parameter,
int typeFunctional):
-
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=1, mode="c"] outputData = \
np.zeros([1], dtype='float32')
-
+
# Run function
TV_energy3D(&inputData[0,0,0], &inputData0[0,0,0], &outputData[0], regularisation_parameter, typeFunctional, dims[2], dims[1], dims[0])
diff --git a/src/Python/src/gpu_regularisers.pyx b/src/Python/src/gpu_regularisers.pyx
index b52f669..84ee981 100644
--- a/src/Python/src/gpu_regularisers.pyx
+++ b/src/Python/src/gpu_regularisers.pyx
@@ -20,190 +20,195 @@ cimport numpy as np
CUDAErrorMessage = 'CUDA error'
-cdef extern int TV_ROF_GPU_main(float* Input, float* Output, float lambdaPar, int iter, float tau, int N, int M, int Z);
-cdef extern int TV_FGP_GPU_main(float *Input, float *Output, float lambdaPar, int iter, float epsil, int methodTV, int nonneg, int printM, int N, int M, int Z);
-cdef extern int TV_SB_GPU_main(float *Input, float *Output, float lambdaPar, int iter, float epsil, int methodTV, int printM, int N, int M, int Z);
-cdef extern int TGV_GPU_main(float *Input, float *Output, float lambdaPar, float alpha1, float alpha0, int iterationsNumb, float L2, int dimX, int dimY, int dimZ);
-cdef extern int LLT_ROF_GPU_main(float *Input, float *Output, float lambdaROF, float lambdaLLT, int iterationsNumb, float tau, int N, int M, int Z);
-cdef extern int NonlDiff_GPU_main(float *Input, float *Output, float lambdaPar, float sigmaPar, int iterationsNumb, float tau, int penaltytype, int N, int M, int Z);
-cdef extern int dTV_FGP_GPU_main(float *Input, float *InputRef, float *Output, float lambdaPar, int iterationsNumb, float epsil, float eta, int methodTV, int nonneg, int printM, int N, int M, int Z);
-cdef extern int Diffus4th_GPU_main(float *Input, float *Output, float lambdaPar, float sigmaPar, int iterationsNumb, float tau, int N, int M, int Z);
+cdef extern int TV_ROF_GPU_main(float* Input, float* Output, float *infovector, float lambdaPar, int iter, float tau, float epsil, int N, int M, int Z);
+cdef extern int TV_FGP_GPU_main(float *Input, float *Output, float *infovector, float lambdaPar, int iter, float epsil, int methodTV, int nonneg, int N, int M, int Z);
+cdef extern int TV_SB_GPU_main(float *Input, float *Output, float *infovector, float lambdaPar, int iter, float epsil, int methodTV, int N, int M, int Z);
+cdef extern int LLT_ROF_GPU_main(float *Input, float *Output, float *infovector, float lambdaROF, float lambdaLLT, int iterationsNumb, float tau, float epsil, int N, int M, int Z);
+cdef extern int TGV_GPU_main(float *Input, float *Output, float *infovector, float lambdaPar, float alpha1, float alpha0, int iterationsNumb, float L2, float epsil, int dimX, int dimY, int dimZ);
+cdef extern int NonlDiff_GPU_main(float *Input, float *Output, float *infovector, float lambdaPar, float sigmaPar, int iterationsNumb, float tau, int penaltytype, float epsil, int N, int M, int Z);
+cdef extern int Diffus4th_GPU_main(float *Input, float *Output, float *infovector, float lambdaPar, float sigmaPar, int iterationsNumb, float tau, float epsil, int N, int M, int Z);
+cdef extern int dTV_FGP_GPU_main(float *Input, float *InputRef, float *Output, float *infovector, float lambdaPar, int iterationsNumb, float epsil, float eta, int methodTV, int nonneg, int N, int M, int Z);
cdef extern int PatchSelect_GPU_main(float *Input, unsigned short *H_i, unsigned short *H_j, float *Weights, int N, int M, int SearchWindow, int SimilarWin, int NumNeighb, float h);
# Total-variation Rudin-Osher-Fatemi (ROF)
def TV_ROF_GPU(inputData,
regularisation_parameter,
- iterations,
- time_marching_parameter):
+ iterations,
+ time_marching_parameter,
+ tolerance_param):
if inputData.ndim == 2:
- return ROFTV2D(inputData,
+ return ROFTV2D(inputData,
regularisation_parameter,
iterations,
- time_marching_parameter)
+ time_marching_parameter,
+ tolerance_param)
elif inputData.ndim == 3:
- return ROFTV3D(inputData,
+ return ROFTV3D(inputData,
regularisation_parameter,
- iterations,
- time_marching_parameter)
-
+ iterations,
+ time_marching_parameter,
+ tolerance_param)
+
# Total-variation Fast-Gradient-Projection (FGP)
def TV_FGP_GPU(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
methodTV,
- nonneg,
- printM):
+ nonneg):
if inputData.ndim == 2:
return FGPTV2D(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
methodTV,
- nonneg,
- printM)
+ nonneg)
elif inputData.ndim == 3:
return FGPTV3D(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
methodTV,
- nonneg,
- printM)
+ nonneg)
# Total-variation Split Bregman (SB)
def TV_SB_GPU(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
- methodTV,
- printM):
+ methodTV):
if inputData.ndim == 2:
return SBTV2D(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
- methodTV,
- printM)
+ methodTV)
elif inputData.ndim == 3:
return SBTV3D(inputData,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
- methodTV,
- printM)
+ methodTV)
# LLT-ROF model
-def LLT_ROF_GPU(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter):
+def LLT_ROF_GPU(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, tolerance_param):
if inputData.ndim == 2:
- return LLT_ROF_GPU2D(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter)
+ return LLT_ROF_GPU2D(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, tolerance_param)
elif inputData.ndim == 3:
- return LLT_ROF_GPU3D(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter)
+ return LLT_ROF_GPU3D(inputData, regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, tolerance_param)
# Total Generilised Variation (TGV)
-def TGV_GPU(inputData, regularisation_parameter, alpha1, alpha0, iterations, LipshitzConst):
+def TGV_GPU(inputData, regularisation_parameter, alpha1, alpha0, iterations, LipshitzConst, tolerance_param):
if inputData.ndim == 2:
- return TGV2D(inputData, regularisation_parameter, alpha1, alpha0, iterations, LipshitzConst)
+ return TGV2D(inputData, regularisation_parameter, alpha1, alpha0, iterations, LipshitzConst, tolerance_param)
elif inputData.ndim == 3:
- return TGV3D(inputData, regularisation_parameter, alpha1, alpha0, iterations, LipshitzConst)
+ return TGV3D(inputData, regularisation_parameter, alpha1, alpha0, iterations, LipshitzConst, tolerance_param)
# Directional Total-variation Fast-Gradient-Projection (FGP)
def dTV_FGP_GPU(inputData,
refdata,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
eta_const,
methodTV,
- nonneg,
- printM):
+ nonneg):
if inputData.ndim == 2:
return FGPdTV2D(inputData,
refdata,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
eta_const,
methodTV,
- nonneg,
- printM)
+ nonneg)
elif inputData.ndim == 3:
return FGPdTV3D(inputData,
refdata,
regularisation_parameter,
- iterations,
+ iterations,
tolerance_param,
eta_const,
methodTV,
- nonneg,
- printM)
+ nonneg)
# Nonlocal Isotropic Diffusion (NDF)
def NDF_GPU(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
+ iterations,
time_marching_parameter,
- penalty_type):
+ penalty_type,
+ tolerance_param):
if inputData.ndim == 2:
return NDF_GPU_2D(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
+ iterations,
time_marching_parameter,
- penalty_type)
+ penalty_type,
+ tolerance_param)
elif inputData.ndim == 3:
return NDF_GPU_3D(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
+ iterations,
time_marching_parameter,
- penalty_type)
+ penalty_type,
+ tolerance_param)
# Anisotropic Fourth-Order diffusion
def Diff4th_GPU(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
- time_marching_parameter):
+ iterations,
+ time_marching_parameter,
+ tolerance_param):
if inputData.ndim == 2:
return Diff4th_2D(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
- time_marching_parameter)
+ iterations,
+ time_marching_parameter,
+ tolerance_param)
elif inputData.ndim == 3:
return Diff4th_3D(inputData,
regularisation_parameter,
edge_parameter,
- iterations,
- time_marching_parameter)
-
+ iterations,
+ time_marching_parameter,
+ tolerance_param)
+
#****************************************************************#
#********************** Total-variation ROF *********************#
#****************************************************************#
-def ROFTV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def ROFTV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
- int iterations,
- float time_marching_parameter):
-
+ int iterations,
+ float time_marching_parameter,
+ float tolerance_param):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
# Running CUDA code here
if (TV_ROF_GPU_main(
- &inputData[0,0], &outputData[0,0],
+ &inputData[0,0], &outputData[0,0], &infovec[0],
regularisation_parameter,
- iterations ,
- time_marching_parameter,
+ iterations,
+ time_marching_parameter,
+ tolerance_param,
dims[1], dims[0], 1)==0):
- return outputData;
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
-def ROFTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+
+def ROFTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
- int iterations,
- float time_marching_parameter):
-
+ int iterations,
+ float time_marching_parameter,
+ float tolerance_param):
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
@@ -211,76 +216,79 @@ def ROFTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Running CUDA code here
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
if (TV_ROF_GPU_main(
- &inputData[0,0,0], &outputData[0,0,0],
+ &inputData[0,0,0], &outputData[0,0,0], &infovec[0],
regularisation_parameter,
- iterations ,
- time_marching_parameter,
+ iterations,
+ time_marching_parameter,
+ tolerance_param,
dims[2], dims[1], dims[0])==0):
- return outputData;
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
#****************************************************************#
#********************** Total-variation FGP *********************#
#****************************************************************#
#******** Total-variation Fast-Gradient-Projection (FGP)*********#
-def FGPTV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def FGPTV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
- int iterations,
+ int iterations,
float tolerance_param,
int methodTV,
- int nonneg,
- int printM):
-
+ int nonneg):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Running CUDA code here
- if (TV_FGP_GPU_main(&inputData[0,0], &outputData[0,0],
- regularisation_parameter,
- iterations,
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
+ if (TV_FGP_GPU_main(&inputData[0,0], &outputData[0,0], &infovec[0],
+ regularisation_parameter,
+ iterations,
tolerance_param,
methodTV,
nonneg,
- printM,
dims[1], dims[0], 1)==0):
- return outputData;
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
-def FGPTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+def FGPTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
- int iterations,
+ int iterations,
float tolerance_param,
int methodTV,
- int nonneg,
- int printM):
-
+ int nonneg):
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Running CUDA code here
- if (TV_FGP_GPU_main(&inputData[0,0,0], &outputData[0,0,0],
- regularisation_parameter ,
- iterations,
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
+ if (TV_FGP_GPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0],
+ regularisation_parameter,
+ iterations,
tolerance_param,
methodTV,
nonneg,
- printM,
dims[2], dims[1], dims[0])==0):
- return outputData;
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
@@ -288,40 +296,39 @@ def FGPTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
#********************** Total-variation SB *********************#
#***************************************************************#
#*************** Total-variation Split Bregman (SB)*************#
-def SBTV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def SBTV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
- int iterations,
+ int iterations,
float tolerance_param,
- int methodTV,
- int printM):
-
+ int methodTV):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Running CUDA code here
- if (TV_SB_GPU_main(&inputData[0,0], &outputData[0,0],
- regularisation_parameter,
- iterations,
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
+ if (TV_SB_GPU_main(&inputData[0,0], &outputData[0,0],&infovec[0],
+ regularisation_parameter,
+ iterations,
tolerance_param,
methodTV,
- printM,
dims[1], dims[0], 1)==0):
- return outputData;
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
-def SBTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+
+def SBTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
- int iterations,
+ int iterations,
float tolerance_param,
- int methodTV,
- int printM):
-
+ int methodTV):
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
@@ -329,16 +336,17 @@ def SBTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Running CUDA code here
- if (TV_SB_GPU_main(&inputData[0,0,0], &outputData[0,0,0],
- regularisation_parameter ,
- iterations,
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
+ if (TV_SB_GPU_main(&inputData[0,0,0], &outputData[0,0,0],&infovec[0],
+ regularisation_parameter ,
+ iterations,
tolerance_param,
methodTV,
- printM,
dims[2], dims[1], dims[0])==0):
- return outputData;
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
@@ -347,32 +355,39 @@ def SBTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
#************************ LLT-ROF model ************************#
#***************************************************************#
#************Joint LLT-ROF model for higher order **************#
-def LLT_ROF_GPU2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def LLT_ROF_GPU2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameterROF,
float regularisation_parameterLLT,
- int iterations,
- float time_marching_parameter):
-
+ int iterations,
+ float time_marching_parameter,
+ float tolerance_param):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Running CUDA code here
- if (LLT_ROF_GPU_main(&inputData[0,0], &outputData[0,0],regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, dims[1],dims[0],1)==0):
- return outputData;
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
+ if (LLT_ROF_GPU_main(&inputData[0,0], &outputData[0,0],&infovec[0],regularisation_parameterROF, regularisation_parameterLLT, iterations,
+ time_marching_parameter,
+ tolerance_param,
+ dims[1],dims[0],1)==0):
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
-def LLT_ROF_GPU3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+
+def LLT_ROF_GPU3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameterROF,
float regularisation_parameterLLT,
- int iterations,
- float time_marching_parameter):
-
+ int iterations,
+ float time_marching_parameter,
+ float tolerance_param):
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
@@ -380,10 +395,16 @@ def LLT_ROF_GPU3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Running CUDA code here
- if (LLT_ROF_GPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameterROF, regularisation_parameterLLT, iterations, time_marching_parameter, dims[2], dims[1], dims[0])==0):
- return outputData;
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
+ if (LLT_ROF_GPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0], regularisation_parameterROF, regularisation_parameterLLT,
+ iterations,
+ time_marching_parameter,
+ tolerance_param,
+ dims[2], dims[1], dims[0])==0):
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
@@ -391,38 +412,43 @@ def LLT_ROF_GPU3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
#***************************************************************#
#***************** Total Generalised Variation *****************#
#***************************************************************#
-def TGV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def TGV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
float alpha1,
float alpha0,
- int iterationsNumb,
- float LipshitzConst):
-
+ int iterationsNumb,
+ float LipshitzConst,
+ float tolerance_param):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
#/* Run TGV iterations for 2D data */
- if (TGV_GPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameter,
+ if (TGV_GPU_main(&inputData[0,0], &outputData[0,0], &infovec[0], regularisation_parameter,
alpha1,
alpha0,
- iterationsNumb,
+ iterationsNumb,
LipshitzConst,
+ tolerance_param,
dims[1],dims[0], 1)==0):
- return outputData
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-def TGV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+def TGV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
float alpha1,
float alpha0,
- int iterationsNumb,
- float LipshitzConst):
-
+ int iterationsNumb,
+ float LipshitzConst,
+ float tolerance_param):
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
@@ -430,178 +456,205 @@ def TGV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Running CUDA code here
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
if (TGV_GPU_main(
- &inputData[0,0,0], &outputData[0,0,0], regularisation_parameter,
+ &inputData[0,0,0], &outputData[0,0,0], &infovec[0], regularisation_parameter,
alpha1,
alpha0,
- iterationsNumb,
+ iterationsNumb,
LipshitzConst,
+ tolerance_param,
dims[2], dims[1], dims[0])==0):
- return outputData;
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
#****************************************************************#
-#**************Directional Total-variation FGP ******************#
+#***************Nonlinear (Isotropic) Diffusion******************#
#****************************************************************#
-#******** Directional TV Fast-Gradient-Projection (FGP)*********#
-def FGPdTV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
- np.ndarray[np.float32_t, ndim=2, mode="c"] refdata,
+def NDF_GPU_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
- int iterations,
- float tolerance_param,
- float eta_const,
- int methodTV,
- int nonneg,
- int printM):
-
+ float edge_parameter,
+ int iterationsNumb,
+ float time_marching_parameter,
+ int penalty_type,
+ float tolerance_param):
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
- np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Running CUDA code here
- if (dTV_FGP_GPU_main(&inputData[0,0], &refdata[0,0], &outputData[0,0],
- regularisation_parameter,
- iterations,
- tolerance_param,
- eta_const,
- methodTV,
- nonneg,
- printM,
- dims[1], dims[0], 1)==0):
- return outputData
+ np.zeros([dims[0],dims[1]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ #rangecheck = penalty_type < 1 and penalty_type > 3
+ #if not rangecheck:
+# raise ValueError('Choose penalty type as 1 for Huber, 2 - Perona-Malik, 3 - Tukey Biweight')
+
+ # Run Nonlinear Diffusion iterations for 2D data
+ # Running CUDA code here
+ if (NonlDiff_GPU_main(&inputData[0,0], &outputData[0,0],&infovec[0],
+ regularisation_parameter,
+ edge_parameter, iterationsNumb,
+ time_marching_parameter, penalty_type,
+ tolerance_param,
+ dims[1], dims[0], 1)==0):
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
-
-def FGPdTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
- np.ndarray[np.float32_t, ndim=3, mode="c"] refdata,
+def NDF_GPU_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
- int iterations,
- float tolerance_param,
- float eta_const,
- int methodTV,
- int nonneg,
- int printM):
-
+ float edge_parameter,
+ int iterationsNumb,
+ float time_marching_parameter,
+ int penalty_type,
+ float tolerance_param):
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
- np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Running CUDA code here
- if (dTV_FGP_GPU_main(&inputData[0,0,0], &refdata[0,0,0], &outputData[0,0,0],
- regularisation_parameter ,
- iterations,
- tolerance_param,
- eta_const,
- methodTV,
- nonneg,
- printM,
- dims[2], dims[1], dims[0])==0):
- return outputData;
+ np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Run Nonlinear Diffusion iterations for 3D data
+ # Running CUDA code here
+ if (NonlDiff_GPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0],
+ regularisation_parameter, edge_parameter,
+ iterationsNumb, time_marching_parameter,
+ penalty_type,
+ tolerance_param,
+ dims[2], dims[1], dims[0])==0):
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
#****************************************************************#
-#***************Nonlinear (Isotropic) Diffusion******************#
+#************Anisotropic Fourth-Order diffusion******************#
#****************************************************************#
-def NDF_GPU_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+def Diff4th_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
float regularisation_parameter,
float edge_parameter,
- int iterationsNumb,
+ int iterationsNumb,
float time_marching_parameter,
- int penalty_type):
+ float tolerance_param):
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
np.zeros([dims[0],dims[1]], dtype='float32')
-
- #rangecheck = penalty_type < 1 and penalty_type > 3
- #if not rangecheck:
-# raise ValueError('Choose penalty type as 1 for Huber, 2 - Perona-Malik, 3 - Tukey Biweight')
-
- # Run Nonlinear Diffusion iterations for 2D data
- # Running CUDA code here
- if (NonlDiff_GPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type, dims[1], dims[0], 1)==0):
- return outputData;
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Run Anisotropic Fourth-Order diffusion for 2D data
+ # Running CUDA code here
+ if (Diffus4th_GPU_main(&inputData[0,0], &outputData[0,0], &infovec[0],
+ regularisation_parameter, edge_parameter, iterationsNumb,
+ time_marching_parameter,
+ tolerance_param,
+ dims[1], dims[0], 1)==0):
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
-def NDF_GPU_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+def Diff4th_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
float regularisation_parameter,
float edge_parameter,
- int iterationsNumb,
+ int iterationsNumb,
float time_marching_parameter,
- int penalty_type):
+ float tolerance_param):
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
- np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Run Nonlinear Diffusion iterations for 3D data
- # Running CUDA code here
- if (NonlDiff_GPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, penalty_type, dims[2], dims[1], dims[0])==0):
- return outputData;
+ np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Run Anisotropic Fourth-Order diffusion for 3D data
+ # Running CUDA code here
+ if (Diffus4th_GPU_main(&inputData[0,0,0], &outputData[0,0,0], &infovec[0],
+ regularisation_parameter, edge_parameter,
+ iterationsNumb, time_marching_parameter,
+ tolerance_param,
+ dims[2], dims[1], dims[0])==0):
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
#****************************************************************#
-#************Anisotropic Fourth-Order diffusion******************#
+#**************Directional Total-variation FGP ******************#
#****************************************************************#
-def Diff4th_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+#******** Directional TV Fast-Gradient-Projection (FGP)*********#
+def FGPdTV2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
+ np.ndarray[np.float32_t, ndim=2, mode="c"] refdata,
float regularisation_parameter,
- float edge_parameter,
- int iterationsNumb,
- float time_marching_parameter):
+ int iterations,
+ float tolerance_param,
+ float eta_const,
+ int methodTV,
+ int nonneg):
+
cdef long dims[2]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
-
+
cdef np.ndarray[np.float32_t, ndim=2, mode="c"] outputData = \
- np.zeros([dims[0],dims[1]], dtype='float32')
-
- # Run Anisotropic Fourth-Order diffusion for 2D data
- # Running CUDA code here
- if (Diffus4th_GPU_main(&inputData[0,0], &outputData[0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, dims[1], dims[0], 1)==0):
- return outputData
+ np.zeros([dims[0],dims[1]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
+ if (dTV_FGP_GPU_main(&inputData[0,0], &refdata[0,0], &outputData[0,0], &infovec[0],
+ regularisation_parameter,
+ iterations,
+ tolerance_param,
+ eta_const,
+ methodTV,
+ nonneg,
+ dims[1], dims[0], 1)==0):
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
-
-def Diff4th_3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+
+def FGPdTV3D(np.ndarray[np.float32_t, ndim=3, mode="c"] inputData,
+ np.ndarray[np.float32_t, ndim=3, mode="c"] refdata,
float regularisation_parameter,
- float edge_parameter,
- int iterationsNumb,
- float time_marching_parameter):
+ int iterations,
+ float tolerance_param,
+ float eta_const,
+ int methodTV,
+ int nonneg):
+
cdef long dims[3]
dims[0] = inputData.shape[0]
dims[1] = inputData.shape[1]
dims[2] = inputData.shape[2]
-
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] outputData = \
- np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
-
- # Run Anisotropic Fourth-Order diffusion for 3D data
- # Running CUDA code here
- if (Diffus4th_GPU_main(&inputData[0,0,0], &outputData[0,0,0], regularisation_parameter, edge_parameter, iterationsNumb, time_marching_parameter, dims[2], dims[1], dims[0])==0):
- return outputData;
+ np.zeros([dims[0],dims[1],dims[2]], dtype='float32')
+ cdef np.ndarray[np.float32_t, ndim=1, mode="c"] infovec = \
+ np.ones([2], dtype='float32')
+
+ # Running CUDA code here
+ if (dTV_FGP_GPU_main(&inputData[0,0,0], &refdata[0,0,0], &outputData[0,0,0], &infovec[0],
+ regularisation_parameter ,
+ iterations,
+ tolerance_param,
+ eta_const,
+ methodTV,
+ nonneg,
+ dims[2], dims[1], dims[0])==0):
+ return (outputData,infovec)
else:
raise ValueError(CUDAErrorMessage);
@@ -621,14 +674,14 @@ def PatchSel_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
cdef long dims[3]
dims[0] = neighbours
dims[1] = inputData.shape[0]
- dims[2] = inputData.shape[1]
-
+ dims[2] = inputData.shape[1]
+
cdef np.ndarray[np.float32_t, ndim=3, mode="c"] Weights = \
np.zeros([dims[0], dims[1],dims[2]], dtype='float32')
-
+
cdef np.ndarray[np.uint16_t, ndim=3, mode="c"] H_i = \
np.zeros([dims[0], dims[1],dims[2]], dtype='uint16')
-
+
cdef np.ndarray[np.uint16_t, ndim=3, mode="c"] H_j = \
np.zeros([dims[0], dims[1],dims[2]], dtype='uint16')
@@ -637,4 +690,3 @@ def PatchSel_2D(np.ndarray[np.float32_t, ndim=2, mode="c"] inputData,
return H_i, H_j, Weights;
else:
raise ValueError(CUDAErrorMessage);
-
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-08 22:30:11 +0000