Refactoring

src/TileProcessor.cuh

@@ -724,7 +724,7 @@ __device__ void tile_combine_rgba(
 		// next not used
 		//		boolean       diff_gauss,     // when averaging images, use gaussian around average as weight (false - sharp all/nothing)
 		float   min_agree,      // minimal number of channels to agree on a point (real number to work with fuzzy averages)
-		float * chn_weights,     // color channel weights, sum == 1.0
+		const float * chn_weights,     // color channel weights, sum == 1.0
 		int     dust_remove,     // Do not reduce average weight when only one image differs much from the average
 		int     keep_weights,   // eturn channel weights and rms after A in RGBA (weight are always calculated, not so for the crms)
 		int     debug);
@@ -923,7 +923,7 @@ extern "C" __global__ void textures_accumulate( // (8,4,1) (N,1,1)
 		float             diff_sigma,         // pixel value/pixel change
 		float             diff_threshold,     // pixel value/pixel change
 		float             min_agree,          // minimal number of channels to agree on a point (real number to work with fuzzy averages)
-		float             weights[3],         // scale for R,B,G
+		const float       weights[3],         // scale for R,B,G
 		int               dust_remove,        // Do not reduce average weight when only one image differs much from the average
 		int               keep_weights,       // return channel weights after A in RGBA (was removed) (should be 0 if gpu_texture_rbg)?
 // combining both non-overlap and overlap (each calculated if pointer is not null )
@@ -3311,7 +3311,7 @@ extern "C" __global__ void textures_accumulate( // (8,4,1) (N,1,1)
 		float             diff_sigma,         // pixel value/pixel change
 		float             diff_threshold,     // pixel value/pixel change
 		float             min_agree,          // minimal number of channels to agree on a point (real number to work with fuzzy averages)
-		float             weights[3],         // scale for R,B,G
+		const float             weights[3],         // scale for R,B,G
 		int               dust_remove,        // Do not reduce average weight when only one image differs much from the average
 		int               keep_weights,       // return channel weights after A in RGBA (was removed) (should be 0 if gpu_texture_rbg)? Now +2 - output raw channels
 // combining both non-overlap and overlap (each calculated if pointer is not null )
@@ -5483,7 +5483,7 @@ __device__ void tile_combine_rgba(
 		// next not used
 		//		boolean       diff_gauss,     // when averaging images, use gaussian around average as weight (false - sharp all/nothing)
 		float   min_agree,     // minimal number of channels to agree on a point (real number to work with fuzzy averages)
-		float * chn_weights,   // color channel weights, sum == 1.0
+		const float * chn_weights,   // color channel weights, sum == 1.0
 		int     dust_remove,   // Do not reduce average weight when only one image differs much from the average
 		int     keep_weights,  // return channel weights and rms after A in RGBA (weight are always calculated, not so for the crms)
 		int     debug)

src/tp_files.cu

@@ -14,6 +14,8 @@
 //#include <iterator>
 //#include <vector>
 //#include "tp_utils.h"
+
+
 #include "tp_files.h"
 int get_file_size(std::string filename) // path to file
 {

src/tp_paths.h

+/*
+ * tp_paths.h
+ *
+ *  Created on: Mar 26, 2025
+ *      Author: elphel
+ */
+
+#ifndef SRC_TP_PATHS_H_
+#define SRC_TP_PATHS_H_
+
+class TpPaths{
+public:
+	    TpPaths(int lwir);
+		const char ** kernel_file;
+		const char ** kernel_offs_file;
+		const char ** image_files;
+		const char ** ports_offs_xy_file;
+		const char ** ports_clt_file;
+		const char ** result_rbg_file;
+
+		const char* result_corr_file;
+		const char* result_corr_quad_file;
+		const char* result_corr_td_norm_file;
+		const char* result_inter_td_norm_file;
+		const char* result_textures_file;
+		const char* result_diff_rgb_combo_file;
+		const char* result_textures_rgba_file;
+		const char* result_textures_file_dp;
+		const char* result_diff_rgb_combo_file_dp;
+		const char* result_textures_rgba_file_dp;
+		const char* rByRDist_file;
+		const char* correction_vector_file;
+		const char* geometry_correction_file;
+//		float * color_weights;// [3];
+//		float * generate_RBGA_params; // [5];
+};
+#endif /* SRC_TP_PATHS_H_ */

src/tp_utils.cu

@@ -7,6 +7,9 @@
 #include <cuda_runtime.h>
 #include <helper_cuda.h>
 #include "tp_utils.h"
+#include "dtt8x8.h" // for DTT_SIZE * DTT_SIZE21
+#include "tp_defines.h" // for TEXTURE_THREADS_PER_TILE
+
 float * copyalloc_kernel_gpu(float * kernel_host,
 		                int size, // size in floats
 						int full_size)
@@ -172,6 +175,72 @@ float * alloc_image_gpu(size_t* dstride, // in bytes!!
     return image_gpu;
 }
 
+// Prepare low pass filter (64 long) to be applied to each quadrant of the CLT data
+void set_clt_lpf(
+		float * lpf,    // size*size array to be filled out
+		float   sigma,
+		const int     dct_size)
+{
+	int dct_len = dct_size * dct_size;
+	if (sigma == 0.0f) {
+		lpf[0] = 1.0f;
+		for (int i = 1; i < dct_len; i++){
+			lpf[i] = 0.0;
+		}
+	} else {
+		for (int i = 0; i < dct_size; i++){
+			for (int j = 0; j < dct_size; j++){
+				lpf[i*dct_size+j] = exp(-(i*i+j*j)/(2*sigma));
+			}
+		}
+		// normalize
+		double sum = 0;
+		for (int i = 0; i < dct_size; i++){
+			for (int j = 0; j < dct_size; j++){
+				double d = 	lpf[i*dct_size+j];
+				d*=cos(M_PI*i/(2*dct_size))*cos(M_PI*j/(2*dct_size));
+				if (i > 0) d*= 2.0;
+				if (j > 0) d*= 2.0;
+				sum +=d;
+			}
+		}
+		for (int i = 0; i< dct_len; i++){
+			lpf[i] /= sum;
+		}
+	}
+}
+
+int host_get_textures_shared_size( // in bytes
+//__device__ int get_textures_shared_size( // in bytes
+	    int                num_cams,     // actual number of cameras
+	    int                num_colors,   // actual number of colors: 3 for RGB, 1 for LWIR/mono
+		int *              offsets){     // in floats
+//	int shared_floats = 0;
+	int offs = 0;
+//	int texture_threads_per_tile = TEXTURE_THREADS/num_cams;
+	if (offsets) offsets[0] = offs;
+	offs += num_cams * num_colors * 2 * DTT_SIZE * DTT_SIZE21; //float mclt_tiles         [NUM_CAMS][NUM_COLORS][2*DTT_SIZE][DTT_SIZE21]
+	if (offsets) offsets[1] = offs;
+	offs += num_cams * num_colors * 4 * DTT_SIZE * DTT_SIZE1;  // float clt_tiles         [NUM_CAMS][NUM_COLORS][4][DTT_SIZE][DTT_SIZE1]
+	if (offsets) offsets[2] = offs;
+//	offs += num_cams * num_colors * DTT_SIZE2 * DTT_SIZE21;    //float mclt_tmp           [NUM_CAMS][NUM_COLORS][DTT_SIZE2][DTT_SIZE21];
+	int mclt_tmp_size = num_cams * num_colors * DTT_SIZE2 * DTT_SIZE21;                // [NUM_CAMS][NUM_COLORS][DTT_SIZE2][DTT_SIZE21]
+	int rgbaw_size =    (2* (num_colors + 1) + num_cams) * DTT_SIZE2 * DTT_SIZE21;     // [NUM_COLORS + 1 + NUM_CAMS + NUM_COLORS + 1][DTT_SIZE2][DTT_SIZE21]
+	offs += (rgbaw_size > mclt_tmp_size) ? rgbaw_size : mclt_tmp_size;
+	if (offsets) offsets[3] = offs;
+	offs += num_cams * 2;                                      // float port_offsets      [NUM_CAMS][2];
+	if (offsets) offsets[4] = offs;
+	offs += num_colors * num_cams;                             // float ports_rgb_shared  [NUM_COLORS][NUM_CAMS];
+	if (offsets) offsets[5] = offs;
+	offs += num_cams;                                          // float max_diff_shared   [NUM_CAMS];
+	if (offsets) offsets[6] = offs;
+	offs += num_cams * TEXTURE_THREADS_PER_TILE;               // float max_diff_tmp      [NUM_CAMS][TEXTURE_THREADS_PER_TILE]
+	if (offsets) offsets[7] = offs;
+	offs += num_colors * num_cams *  TEXTURE_THREADS_PER_TILE; //float ports_rgb_tmp     [NUM_COLORS][NUM_CAMS][TEXTURE_THREADS_PER_TILE];
+	if (offsets) offsets[8] = offs;
+	return sizeof(float) * offs; // shared_floats;
+}
+
 
 
 

src/tp_utils.h

@@ -51,4 +51,17 @@ float * alloc_image_gpu(size_t* dstride, // in bytes!!
 		                int width,
 						int height);
 
+// Prepare low pass filter (64 long) to be applied to each quadrant of the CLT data
+void set_clt_lpf(
+		float * lpf,    // size*size array to be filled out
+		float   sigma,
+		const int     dct_size);
+
+int host_get_textures_shared_size( // in bytes
+//__device__ int get_textures_shared_size( // in bytes
+	    int                num_cams,     // actual number of cameras
+	    int                num_colors,   // actual number of colors: 3 for RGB, 1 for LWIR/mono
+		int *              offsets);    // in floats
+
+
 #endif /* SRC_TP_UTILS_H_ */