pivtools 0.1.3__cp311-cp311-win_amd64.whl

pivtools_cli/example.py

@@ -0,0 +1,139 @@
+import logging
+import os
+import sys
+import tracemalloc
+import time
+from pathlib import Path
+
+# Add src to path for unified imports
+from pivtools_core.config import Config
+from pivtools_core.image_handling.load_images import load_images, load_mask_for_camera
+from pivtools_core.image_handling.load_images import compute_vector_mask
+
+from pivtools_cli.piv.piv import perform_piv_and_save
+from pivtools_cli.piv.save_results import (
+    save_coordinates_from_config_distributed,
+    get_output_path,
+)
+from pivtools_cli.piv_cluster.cluster import start_cluster
+from pivtools_cli.preprocessing.preprocess import preprocess_images
+
+if __name__ == "__main__":
+    
+    start_time = time.time()  # Start timer
+
+    config = Config()
+    os.environ["OMP_NUM_THREADS"] = config.omp_threads
+    os.environ["MALLOC_TRIM_THRESHOLD_"] = "0"
+    if config.debug:
+        tracemalloc.start()
+
+    try:
+        cluster, client = start_cluster(
+            n_workers_per_node=config.dask_workers_per_node,
+            threads_per_worker=config.dask_threads_per_worker,
+            memory_limit=config.dask_memory_limit,
+            config=config,
+        )
+        logging.info("Dask cluster started successfully")
+
+    except Exception as e:
+        logging.error("Error starting Dask cluster: %s", e)
+        exit(1)
+
+    try:
+
+        info = client.scheduler_info()
+        for w, meta in info["workers"].items():
+            logging.info("Dask Worker Info:")
+            logging.info("Worker %s", w)
+            logging.info("  pid: %s", meta.get("pid"))
+            logging.info("  host: %s", meta.get("host"))
+            logging.info("  local_dir: %s", meta.get("local_directory"))
+            logging.info("  nanny: %s", meta.get("nanny"))
+
+        camera_numbers = config.camera_numbers
+        source_path = config.source_paths[0]
+        base_path = config.base_paths[0]
+
+        for camera_num in camera_numbers:
+            logging.info("Processing camera: Cam%d", camera_num)
+
+            # Load images from source path (lazy loading - no memory consumption yet)
+            images = load_images(camera_num, config, source=source_path)
+            
+            # Preprocess images (applies filters from config)
+            # This intelligently handles batching:
+            # - Batch filters (time, pod): rechunks to batch_size
+            # - Single-image filters: keeps single-image chunks
+            # - No filters: skips preprocessing entirely
+            processed_images = preprocess_images(images, config)
+            
+            # Load mask once per camera (if masking is enabled)
+            mask = load_mask_for_camera(camera_num, config, source_path_idx=0)
+            
+            # Pre-compute vector masks once per camera (if masking is enabled)
+            vector_masks = None
+            if config.masking_enabled and mask is not None:
+                logging.info("Pre-computing vector masks for Cam%d", camera_num)
+                vector_masks = compute_vector_mask(mask, config)
+                logging.info("Vector masks computed: %d passes", len(vector_masks))
+            
+            # Get output path for this camera (uncalibrated PIV)
+            # Path: base_path/uncalibrated_piv/{num_images}/Cam{camera_num}/instantaneous
+            output_path = get_output_path(
+                config,
+                camera_num,
+                use_uncalibrated=True
+            )
+            
+            # Perform PIV and save in parallel on workers with TRUE lazy loading
+            # Each worker processes ONE image at a time: load → PIV → save → free
+            # Memory per worker: ~280 MB (constant regardless of total images)
+            # Dask scheduler handles task distribution automatically
+            saved_paths, scattered_cache = perform_piv_and_save(
+                processed_images,  # Use preprocessed images
+                config,
+                client,
+                output_path,
+                start_frame=1,
+                runs_to_save=config.instantaneous_runs_0based,
+                vector_masks=vector_masks,  # Pass pre-computed vector masks
+            )
+            
+            # Submit coordinate saving task (runs once per camera) with shared cache
+            coords_future = client.submit(
+                save_coordinates_from_config_distributed,
+                config,
+                output_path,
+                scattered_cache,  # Use the same scattered cache
+                config.instantaneous_runs_0based,
+            )
+            
+            # All PIV processing completed with true lazy loading!
+            # Workers processed images one-by-one, keeping memory footprint minimal
+            logging.info(
+                "PIV and save completed: %d frames saved to %s",
+                len(saved_paths), output_path
+            )
+            
+            # Wait for coordinates to be saved
+            coords_future.result()
+            logging.info("Coordinates saved to %s", output_path)
+
+        if config.debug:
+            current, peak = tracemalloc.get_traced_memory()
+            print(f"Current memory usage: {current / 10**6:.2f} MB")
+            print(f"Peak memory usage: {peak / 10**6:.2f} MB")
+
+            tracemalloc.stop()
+    except Exception as e:
+        import traceback
+        print(f"Error: {e}", flush=True)
+        print("Traceback:", flush=True)
+        traceback.print_exc()
+    finally:
+        client.close()
+        end_time = time.time()  # End timer
+        elapsed = end_time - start_time
+        print(f"Total elapsed time: {elapsed:.2f} seconds", flush=True)

pivtools_cli/lib/PIV_2d_cross_correlate.c

@@ -0,0 +1,334 @@
+#include "PIV_2d_cross_correlate.h"
+#include "common.h"
+#include "xcorr.h"
+#include "xcorr_cache.h"      /* FFTW wisdom caching */
+#include "peak_locate_lm.h"   /* Fast LM solver instead of GSL */
+#include <omp.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+unsigned char bulkxcorr2d(const float *fImageA, const float *fImageB, const float *fMask, const int *nImageSize,
+                          const float *fWinCtrsX, const float *fWinCtrsY, const int *nWindows, float *fWindowWeightA, bool bEnsemble,
+                          const float *fWindowWeightB, const int *nWindowSize, int nPeaks, int iPeakFinder,
+                          float *fPkLocX, float *fPkLocY, float *fPkHeight, float *fSx, float *fSy, float *fSxy, float *fCorrelPlane_Out)
+{
+	int i, j, ii, jj, x, y;
+	int xmin, ymin;
+	int iWindowIdx, nWindowsTotal;
+	float *fWindowA, *fWindowB;
+	float *fCorrelPlane, *fStd, *fCorrelWeight;
+	float *fPeakLoc;
+	float fMeanA, fMeanB, fEnergyA, fEnergyB, fEnergyNorm;
+	int nPxPerWindow, n;
+	unsigned uError;
+	sPlan sCCPlan;
+	/* Removed peak_finder_lock - LM solver is thread-safe without locks */
+	
+	/* calculate correlation plane weighting matrix
+	 * according to Raffel et al., the weight factors can be obtained
+	 * by convolving the image weighting function with itself
+	 */
+	nPxPerWindow		= nWindowSize[0] * nWindowSize[1];
+	fCorrelWeight = (float*)malloc(nPxPerWindow * sizeof(float));
+	if (!fCorrelWeight) { return ERROR_NOMEM; }
+	uError = convolve(fWindowWeightB, fWindowWeightB, fCorrelWeight, nWindowSize);
+	if (uError)
+	{
+		free(fCorrelWeight);
+		return uError;
+	}
+	
+	for(n = 0; n < nPxPerWindow; ++n)
+		fCorrelWeight[n] = nPxPerWindow / fCorrelWeight[n];
+	
+
+	nWindowsTotal = nWindows[0] * nWindows[1];
+
+	/* Initialize FFTW threading and wisdom cache */
+	fftwf_init_threads();
+	fftwf_plan_with_nthreads(1);
+	
+	/* Load FFTW wisdom for optimized plans */
+	char wisdom_path[512];
+	xcorr_cache_get_default_wisdom_path(wisdom_path, sizeof(wisdom_path));
+	xcorr_cache_init(wisdom_path);
+
+	/* fork here, parallelise */
+	
+	/* fork here, parallelise */
+	uError = ERROR_NONE;
+	// printf("  Max threads: %d\n", omp_get_max_threads());
+	
+	#pragma omp parallel \
+        private(i, j, n, ii, jj, x, y, \
+                xmin, ymin, \
+                iWindowIdx, \
+                fWindowA, fWindowB, fCorrelPlane, fStd, fPeakLoc, \
+                fMeanA, fMeanB, fEnergyA, fEnergyB, fEnergyNorm, \
+                sCCPlan) \
+        shared(fImageA, fImageB, fMask, nImageSize, \
+               fWinCtrsX, fWinCtrsY, nWindows, bEnsemble, \
+               fCorrelWeight, fWindowWeightA, fWindowWeightB, nWindowSize, nPeaks, iPeakFinder, \
+               fPkLocX, fPkLocY, fPkHeight, fSx, fSy, fSxy, \
+               nWindowsTotal, nPxPerWindow, fCorrelPlane_Out) \
+        default(none) \
+        reduction(|:uError) \
+        num_threads(omp_get_max_threads())
+	{
+		/* Allocate memory for correlation windows
+		 * Use aligned allocation for better cache performance
+		 */
+		uError			= ERROR_NONE;
+		fCorrelPlane	= (float*)fftwf_malloc(nPxPerWindow * sizeof(float));       
+		fWindowA			= (float*)fftwf_malloc(nPxPerWindow * sizeof(float));
+		fWindowB			= (float*)fftwf_malloc(nPxPerWindow * sizeof(float));
+        fStd = (float*)malloc(3 * nPeaks * sizeof(float));
+	    fPeakLoc			= (float*)malloc(3 * nPeaks * sizeof(float));
+		    
+        
+		if(!fWindowA || !fWindowB || !fCorrelPlane || !fPeakLoc || !fStd)
+		{
+			uError		= ERROR_NOMEM;
+			goto thread_cleanup;
+		}
+		
+		/* create cross-correlation plan for this thread */
+		memset(&sCCPlan, 0, sizeof(sCCPlan));
+		#pragma omp critical
+		{
+			fftwf_plan_with_nthreads(1);
+			uError			= xcorr_create_plan(nWindowSize, &sCCPlan);
+		}
+		if(uError)
+			goto thread_cleanup;
+
+		/* condense to one loop to make parallelisation easier */			
+		#pragma omp for schedule(static, CHUNKSIZE) nowait
+		for(iWindowIdx = 0; iWindowIdx < nWindowsTotal; ++iWindowIdx)
+		{
+            /* Coordinate system (matching MATLAB and Python):
+             * - nWindows[0] = number of windows in Y (height) direction
+             * - nWindows[1] = number of windows in X (width) direction
+             * - fWinCtrsY[jj] = Y-coordinate of window center (row index)
+             * - fWinCtrsX[ii] = X-coordinate of window center (column index)
+             * - Row-major linearization: index = jj * nWindows[1] + ii
+             */
+			
+			/* get index in window center arrays
+			 * For row-major: linearIdx = row*nCols + col
+			 * Here: iWindowIdx = jj*nWindows[1] + ii
+			 */
+			ii			= iWindowIdx % nWindows[1];  // Column index (X)
+			jj			= iWindowIdx / nWindows[1];  // Row index (Y)
+            
+			/* Mask uses same row-major indexing */
+			int mask_idx = jj * nWindows[1] + ii;
+            
+            if (mask_idx < 0 || mask_idx >= nWindows[0] * nWindows[1])
+            {
+				uError = ERROR_OUT_OF_BOUNDS;
+				//goto thread_cleanup;
+            }
+            // Check if the mask value at this index is 1
+            if (fMask[mask_idx] == 1)
+            {
+                continue;  // Skip this window if the mask value is 1
+            }
+			
+			/* Extract correlation window from images
+			 * Window center coordinates (0-based array indices):
+			 * - fWinCtrsX[ii] is the X-coordinate (column) of the window center
+			 *   For a 128-pixel window at the left edge: center = 63.5
+			 * - fWinCtrsY[jj] is the Y-coordinate (row) of the window center
+			 * Window size:
+			 * - nWindowSize[0] = window height (number of rows)
+			 * - nWindowSize[1] = window width (number of columns)
+			 * Image dimensions:
+			 * - nImageSize[0] = image height (number of rows)
+			 * - nImageSize[1] = image width (number of columns)
+			 * 
+			 * Window extraction:
+			 * - For a window of size N centered at position C:
+			 *   window covers pixels from floor(C - (N-1)/2 + 0.5) to floor(C + (N-1)/2 + 0.5)
+			 * - Example: N=128, C=63.5 -> floor(63.5 - 63.5 + 0.5) = 0 to floor(63.5 + 63.5 + 0.5) = 127
+			 */
+			
+			/* Calculate top-left corner of window in image coordinates */
+			int row_min = (int)floor(fWinCtrsY[jj] - ((float)nWindowSize[0]-1.0)/2.0 + 0.5);
+			int col_min = (int)floor(fWinCtrsX[ii] - ((float)nWindowSize[1]-1.0)/2.0 + 0.5);
+			
+			/* Bounds check to prevent segfault */
+			if (row_min < 0 || col_min < 0 || 
+			    row_min + nWindowSize[0] > nImageSize[0] || 
+			    col_min + nWindowSize[1] > nImageSize[1]) {
+				uError = ERROR_OUT_OF_BOUNDS;
+				continue;  /* Skip this window */
+			}
+			
+			/* Extract window pixels: iterate over window rows and columns */
+			for(int row_win = 0; row_win < nWindowSize[0]; ++row_win)
+			{
+				int row_img = row_min + row_win;
+				for(int col_win = 0; col_win < nWindowSize[1]; ++col_win)
+				{
+					int col_img = col_min + col_win;
+					/* Row-major indexing: array[row, col] -> row*width + col */
+					fWindowA[SUB2IND_2D(row_win, col_win, nWindowSize[1])] = 
+						fImageA[SUB2IND_2D(row_img, col_img, nImageSize[1])];
+					fWindowB[SUB2IND_2D(row_win, col_win, nWindowSize[1])] = 
+						fImageB[SUB2IND_2D(row_img, col_img, nImageSize[1])];
+				}
+			}
+			/* Pre-multiply by weighting window and compute mean 
+			 * Using SIMD hints for vectorization
+			 */
+			fMeanA		= 0;
+			fMeanB		= 0;
+			#pragma omp simd reduction(+:fMeanA,fMeanB)
+			for(n = 0; n < nPxPerWindow; ++n)
+			{
+				fWindowA[n] *= fWindowWeightA[n];
+				fWindowB[n] *= fWindowWeightB[n];
+				fMeanA		+= fWindowA[n];
+				fMeanB		+= fWindowB[n];
+			}
+			fMeanA		= fMeanA / (float)nPxPerWindow;
+			fMeanB		= fMeanB / (float)nPxPerWindow;
+			
+			/* Subtract mean and calculate signal energy for peak normalisation
+			 * Using SIMD hints for vectorization
+			 */
+			fEnergyA		= 0;
+			fEnergyB		= 0;
+			if (!bEnsemble) {
+				#pragma omp simd reduction(+:fEnergyA,fEnergyB)
+				for(n = 0; n < nPxPerWindow; ++n)
+				{
+					fWindowA[n] -= fMeanA;
+					fWindowB[n] -= fMeanB;
+					fEnergyA 	+= fWindowA[n]*fWindowA[n];
+					fEnergyB 	+= fWindowB[n]*fWindowB[n];
+				}
+			} else {
+				#pragma omp simd reduction(+:fEnergyA,fEnergyB)
+				for(n = 0; n < nPxPerWindow; ++n)
+				{
+					fEnergyA 	+= fWindowA[n]*fWindowA[n];
+					fEnergyB 	+= fWindowB[n]*fWindowB[n];
+				}
+			}
+			fEnergyNorm = 1 / (float)sqrt(fEnergyA * fEnergyB);
+
+			/* Cross-correlate */
+			xcorr_preplanned(fWindowB, fWindowA, fCorrelPlane, &sCCPlan);
+
+			/* Apply correlation plane weighting with SIMD vectorization */
+			if (!bEnsemble) {
+				#pragma omp simd
+				for (n = 0; n < nPxPerWindow; ++n)
+				{
+					fCorrelPlane[n] *= fCorrelWeight[n];
+				}
+			}
+			
+			
+            
+
+            
+            memcpy(&fCorrelPlane_Out[nPxPerWindow * iWindowIdx], fCorrelPlane, nPxPerWindow * sizeof(float));
+            
+                   
+
+			/* Call peak finder - LM solver is fully thread-safe, no locks needed */
+            if (!bEnsemble) {
+			    lsqpeaklocate_lm(fCorrelPlane, nWindowSize, fPeakLoc, nPeaks, iPeakFinder, fStd);
+                
+    
+			    /* Save displacement and peak height
+				 * Output arrays have shape [nPeaks, nWindows[0], nWindows[1]]
+				 * where nWindows[0] = Y-windows, nWindows[1] = X-windows
+				 * Peak locations from lsqpeaklocate_lm:
+				 * - fPeakLoc[0, n, 3] = row offset (Y) from window center
+				 * - fPeakLoc[1, n, 3] = column offset (X) from window center
+				 * - fPeakLoc[2, n, 3] = peak magnitude
+				 */
+			    for(n = 0; n < nPeaks; ++n)
+			    {
+				    /* Calculate linear index for this peak and window
+					 * For 3D array [nPeaks, nRows, nCols] in row-major:
+					 * index = peak*nRows*nCols + row*nCols + col
+					 */
+				    int out_idx = n * nWindows[0] * nWindows[1] + jj * nWindows[1] + ii;
+				    
+				    /* Peak location in correlation plane (centered at window size/2)
+					 * Subtract window center to get displacement from window center
+					 * fPeakLoc dimensions: [3, nPeaks] in row-major
+					 */
+				    float peak_row = fPeakLoc[SUB2IND_2D(0, n, nPeaks)];  // Y-displacement
+				    float peak_col = fPeakLoc[SUB2IND_2D(1, n, nPeaks)];  // X-displacement
+				    float peak_mag = fPeakLoc[SUB2IND_2D(2, n, nPeaks)];
+				    
+				    /* Store displacements (subtract window center to get offset) */
+				    fPkLocX[out_idx] = peak_col - nWindowSize[1]/2.0f;  // X is column
+				    fPkLocY[out_idx] = peak_row - nWindowSize[0]/2.0f;  // Y is row
+				    
+				    /* Store standard deviations */
+				    fSx[out_idx] = fStd[SUB2IND_2D(0, n, nPeaks)];
+				    fSy[out_idx] = fStd[SUB2IND_2D(1, n, nPeaks)];
+				    fSxy[out_idx] = fStd[SUB2IND_2D(2, n, nPeaks)];
+    
+				    /* Normalize peak height by window weight and energy content */
+				    int pk_row = MIN(MAX(0, (int)peak_row), nWindowSize[0]-1);
+				    int pk_col = MIN(MAX(0, (int)peak_col), nWindowSize[1]-1);
+				    fPkHeight[out_idx] = peak_mag * fEnergyNorm / 
+				        fCorrelWeight[SUB2IND_2D(pk_row, pk_col, nWindowSize[1])];
+			    }
+            }
+		}
+		
+		/* Cleanup memory and other resources before leaving the thread */
+thread_cleanup:
+		#pragma omp critical
+		{
+			xcorr_destroy_plan(&sCCPlan);
+		}
+		if(fWindowA) fftwf_free(fWindowA);
+		if(fStd) free(fStd);
+		if(fWindowB) fftwf_free(fWindowB);
+		if(fCorrelPlane) fftwf_free(fCorrelPlane);
+		if(fPeakLoc) free(fPeakLoc);
+
+	} /* end parallelised section */
+
+	/* Save wisdom for future runs */
+	xcorr_cache_save_wisdom(wisdom_path);
+
+	return uError;
+}
+
+/* fminvec, find minimum element in vector */
+float fminvec(const float *fVec, int n)
+{
+	int i;
+	float ret;
+
+	ret = fVec[0];
+	for(i = 1; i < n; ++i)
+		ret = MIN(ret, fVec[i]);
+
+	return ret;
+}
+
+/* fmaxvec, find maximum element in vector */
+float fmaxvec(const float *fVec, int n)
+{
+	int i;
+	float ret;
+
+	ret = fVec[0];
+	for(i = 1; i < n; ++i)
+		ret = MAX(ret, fVec[i]);
+
+	return ret;
+}

pivtools_cli/lib/PIV_2d_cross_correlate.h

@@ -0,0 +1,22 @@
+#ifndef PIV_2D_XCORR_H
+#define PIV_2D_XCORR_H
+#include <stdbool.h>
+
+#ifdef _WIN32
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT
+#endif
+
+/**** function declarations ****/
+
+EXPORT unsigned char bulkxcorr2d(const float *fImageA, const float *fImageB,const float *fMask, const int *nImageSize, 
+                           const float *fWinCtrsX, const float *fWinCtrsY, const int *nWindows, float * fWindowWeightA, bool bEnsemble,
+                           const float *fWindowWeightB, const int *nWindowSize, int nPeaks, int iPeakFinder, 
+                           float *fPkLocX, float *fPkLocY, float *fPkHeight, float *fSx, float *fSy, float *fSxy, float *fCorrelPlane_Out);
+
+
+EXPORT float fminvec(const float *fVec, int n);
+EXPORT float fmaxvec(const float *fVec, int n);
+
+#endif

pivtools_cli/lib/common.h

@@ -0,0 +1,36 @@
+#ifndef COMMON_H
+#define COMMON_H
+
+/**** useful macros ****/
+/* Row-major (C-contiguous) indexing for 2D arrays
+ * For array[i,j] with shape [M, N]:
+ * - i is the row index (0 to M-1), corresponds to Y/height
+ * - j is the column index (0 to N-1), corresponds to X/width
+ * - Linear index = i*N + j
+ */
+#define SUB2IND_2D(i, j, N)         ((i)*(N) + (j))
+#define SUB2IND_3D(i, j, k, M, N)   ((i)*(M)*(N) + (j)*(N) + (k))
+
+#define MIN(A,B)							((A)<(B)?(A):(B))
+#define MAX(A,B)							((A)>(B)?(A):(B))
+
+/**** defines ****/
+#define PI									3.14159265f
+#define SQRT_PI							1.77245385f
+#define TRUE								1
+#define FALSE								0
+#ifndef NAN 
+#define NAN (0.0f/0.0f) 
+#endif 
+
+#define CHUNKSIZE							256
+#define NUMTHREADS_MAX					omp_get_max_threads()
+
+#define ERROR_NONE						0
+#define ERROR_NOMEM						1
+#define ERROR_NOPLAN_FWD				2
+#define ERROR_NOPLAN_BWD				4
+#define ERROR_NOPLAN						8
+#define ERROR_OUT_OF_BOUNDS             9 
+
+#endif

pivtools_cli/lib/interp2custom.c

@@ -0,0 +1,146 @@
+#include "interp2custom.h"
+
+/**** global variables ****/
+int g_iLUTIn_interptialised = 0;
+int g_iKernelHalfSize = 5;
+int g_iKernelType = 0;
+float g_fGaussKernelStd = 0.65f;
+float *g_fLUT = NULL;
+
+/**** sinc helper ****/
+float sinc(float x) {
+    return x == 0.0f ? 1.0f : sinf(PI*x)/(PI*x);
+}
+
+/**** 1D interpolation ****/
+float interp1custom(float *y, float *fFilterCoefficients) {
+    int m;
+    float yi = 0;
+    #pragma omp simd
+    for(m = 0; m < KERNEL_SIZE; ++m) {
+        yi += y[m] * fFilterCoefficients[m];
+    }
+    return yi;
+}
+
+/**** vectorized 1D interpolation ****/
+void interp1custom_vec(float *y, float *yi, int N, float *fFilterCoefficients) {
+    int m, n;
+    memset(yi, 0, sizeof(float) * N);
+    for(m = 0; m < KERNEL_SIZE; ++m) {
+        #pragma omp simd
+        for(n = 0; n < N; ++n) {
+            yi[n] += y[m*N + n] * fFilterCoefficients[m];
+        }
+    }
+}
+
+/**** generate LUT ****/
+void interp1custom_generatelut(int iKernelType, int iKernelSize, float fOptions) {
+    int m, n;
+    float delta, A;
+    int iKernelHalfSize = iKernelSize / 2;
+    int bRegenerate = !g_iLUTIn_interptialised || iKernelType != g_iKernelType || iKernelHalfSize != g_iKernelHalfSize;
+    if(iKernelType == KERNEL_GAUSSIAN)
+        bRegenerate = bRegenerate || fOptions != g_fGaussKernelStd;
+
+    if(!bRegenerate) return;
+
+    if(g_iLUTIn_interptialised && g_fLUT) free(g_fLUT);
+    g_fLUT = (float*)malloc(NLUT * iKernelSize * sizeof(float));
+
+    switch(iKernelType) {
+        case KERNEL_LANCZOS:
+            for(n = 1; n < NLUT; ++n) {
+                delta = ((float)n)/((float)NLUT);
+                for(m = -iKernelHalfSize+1; m <= iKernelHalfSize; ++m) {
+                    g_fLUT[n * iKernelSize + m + iKernelHalfSize - 1] = sinc(delta - m) * sinc((delta - m)/(float)iKernelHalfSize);
+                }
+            }
+            memset(g_fLUT, 0, sizeof(float)*iKernelSize);
+            g_fLUT[iKernelHalfSize-1] = 1;
+            break;
+        case KERNEL_GAUSSIAN:
+            for(n = 0; n < NLUT; ++n) {
+                delta = ((float)n)/((float)NLUT);
+                A = 0;
+                for(m = -iKernelHalfSize+1; m <= iKernelHalfSize; ++m) {
+                    g_fLUT[n * iKernelSize + m + iKernelHalfSize - 1] = expf(-powf((m-delta)/fOptions, 2));
+                    A += g_fLUT[n * iKernelSize + m + iKernelHalfSize - 1];
+                }
+                A = 1/A;
+                for(m = -iKernelHalfSize+1; m <= iKernelHalfSize; ++m)
+                    g_fLUT[n * iKernelSize + m + iKernelHalfSize - 1] *= A;
+            }
+            break;
+    }
+    g_iKernelType = iKernelType;
+    g_fGaussKernelStd = fOptions;
+    g_iKernelHalfSize = iKernelHalfSize;
+    g_iLUTIn_interptialised = 1;
+}
+
+/**** destroy LUT ****/
+void interp1custom_destroylut(void) {
+    if(g_iLUTIn_interptialised && g_fLUT) {
+        free(g_fLUT);
+        g_fLUT = NULL;
+    }
+}
+
+/**** 2D interpolation ****/
+void interp2custom(const float *y, size_t *N, const float *f_i, const float *f_j, float *yi, int n_interp) {
+    int n, i, j;
+    float delta[2];
+    int m[2];
+    float *fFilterCoefficients[2];
+    float *yi_stage0, *yi_stage1;
+    int i_min, i_max, j_min, j_max;
+
+    #pragma omp parallel default(none) \
+        private(n,i,j,i_min,i_max,j_min,j_max,delta,m,fFilterCoefficients,yi_stage0,yi_stage1) \
+        shared(y,N,f_i,f_j,yi,n_interp,g_fLUT,g_iKernelHalfSize) \
+        num_threads(NUMTHREADS_MAX)
+    {
+        yi_stage0 = (float*)malloc(KERNEL_SIZE*KERNEL_SIZE*sizeof(float));
+        yi_stage1 = (float*)malloc(KERNEL_SIZE*sizeof(float));
+
+        #pragma omp for schedule(static, CHUNKSIZE)
+        for(n = 0; n < n_interp; ++n) {
+            if(f_i[n] < 0 || f_i[n] > N[0]-1 || f_j[n] < 0 || f_j[n] > N[1]-1) {
+                yi[n] = 0;
+                continue;
+            }
+
+            m[0] = (int)f_i[n];
+            m[1] = (int)f_j[n];
+            delta[0] = f_i[n] - m[0];
+            delta[1] = f_j[n] - m[1];
+
+            for(i = 0; i < 2; ++i) {
+                j = (int)((float)NLUT*delta[i]);
+                j = MIN(MAX(j,0),NLUT-1);
+                fFilterCoefficients[i] = &g_fLUT[j * KERNEL_SIZE];
+            }
+
+            i_min = MAX(0, m[0]-KERNEL_HALF_SIZE+1);
+            j_min = MAX(0, m[1]-KERNEL_HALF_SIZE+1);
+            i_max = MIN(N[0]-1, m[0]+KERNEL_HALF_SIZE);
+            j_max = MIN(N[1]-1, m[1]+KERNEL_HALF_SIZE);
+
+            memset(yi_stage0, 0, KERNEL_SIZE*KERNEL_SIZE*sizeof(float));
+
+            for(j = j_min; j <= j_max; ++j) {
+                memcpy(&yi_stage0[SUB2IND_2D(i_min-m[0]+KERNEL_HALF_SIZE-1, j-m[1]+KERNEL_HALF_SIZE-1, KERNEL_SIZE)],
+                       &y[SUB2IND_2D(i_min,j,N[0])],
+                       (i_max-i_min+1)*sizeof(float));
+            }
+
+            interp1custom_vec(yi_stage0, yi_stage1, KERNEL_SIZE, fFilterCoefficients[1]);
+            yi[n] = interp1custom(yi_stage1, fFilterCoefficients[0]);
+        }
+
+        free(yi_stage0);
+        free(yi_stage1);
+    }
+}