Debugging, added target calculation bypass, fixed LPF issue

src/main/java/com/elphel/imagej/cuas/CorrectionFPN.java

@@ -93,6 +93,7 @@ public class CorrectionFPN {
 	                        ImageDtt.THREADS_MAX,
 	                        debugLevel-2);
 	            }
+//	    		System.out.print("cuasSubtractFpn(): ");
 	            quadCLTs[scene_index].setImageCenter(center_CLT.getImageCenter());
 	            if (early_try_back) { // just faster debugging, not used in production
 	                double [][][] back_prop = backPropagate(
@@ -272,15 +273,23 @@ public class CorrectionFPN {
 					is_new,     //final boolean       save,
 					show_fpn); // final boolean       show)
 			// TODO: apply to all scenes here ! *************************************
+			
 			CorrectionFPN.setApplyRowCol(
 					quadCLTs, // final QuadCLT []     scenes,
 					row_col[0], //final double [][][]  rows,
 					row_col[1]); //  final double [][][]  cols )
+			if (debugLevel > -4) {
+				System.out.println("cuasSubtractRowColNoise(): Subtracted row/col noise from all source images in memory, marking them as applied.");	
+			}
+
 		} else { // reset row/col correction
 			CorrectionFPN.setApplyRowCol(
 					quadCLTs, // final QuadCLT []     scenes,
 					null, //final double [][][]  rows,
 					null); //  final double [][][]  cols )
+			if (debugLevel > -4) {
+				System.out.println("cuasSubtractRowColNoise(): Reset row/col noise in all source images.");	
+			}
 		}
 		return;
 	}
@@ -819,6 +828,7 @@ public class CorrectionFPN {
 			final double []   disparity_center,
 			final int         debugLevel) {
 		boolean en_debug = false;
+//		System.out.print("backPropagate(): ");
 		scene_CLT.setImageCenter(center_CLT.getImageCenter());  // set back-propagate mode
 		boolean batch_run =clt_parameters.batch_run; // may be modified for debug
 		int width=center_CLT.getTilesX()*center_CLT.getTileSize();
@@ -965,7 +975,7 @@ public class CorrectionFPN {
 				wh,              // null, // int []  wh,
 				use_reference);  // boolean use_reference
 		int order = 2;
-
+//		System.out.print("backPropagate(): disable back-propagate mode ");
 		scene_CLT.setImageCenter(null); // disable back-propagate mode 
 		double [][] coeffs = photometric(
 				scene_CLT.getImageData(), // inal double [][][] raw_img,

src/main/java/com/elphel/imagej/cuas/Cuas.java

@@ -434,6 +434,7 @@ public class Cuas {
 				dts)[0];            // final double ts_now)
 		center_CLT.setCenterClt(fcumul_clt); //	float [] clt)
 		double [][] image_center = center_CLT.convertCenterClt(null);
+//		System.out.print("createCenterClt(): ");
 		center_CLT.setImageCenter(image_center);
 		// 
 		String center_cuas_cumul_path = center_CLT.getImagePath()+Prefs.getFileSeparator() + center_CLT.getImageName()+CuasData.getCuasCumulativeSuffix();

src/main/java/com/elphel/imagej/cuas/CuasMotion.java

@@ -35,6 +35,7 @@ import com.elphel.imagej.tileprocessor.TileNeibs;
 import ij.IJ;
 import ij.ImagePlus;
 import ij.ImageStack;
+import ij.Prefs;
 import ij.process.ColorProcessor;
 import ij.process.FloatProcessor;
 import ij.process.ImageConverter;
@@ -1795,6 +1796,37 @@ public class CuasMotion {
 		return vf;
 	}
 	
+	public static double [][][] getTargetsFromHyper(String path){
+		int [] wh = new int [2];
+		String [][] pvf_top_titles = new String[1][];
+		String [][] pvf_titles = new String[1][];
+		double [][][] targets_file = ShowDoubleFloatArrays.readDoubleHyperstack(
+						path, // String      path,
+						wh,            // int []      wh,            // should be null or int[2] 
+						pvf_top_titles,   // String [][] ptop_titles,   // should be null or String [1][]
+						pvf_titles);      // String [][] pslice_titles){// should be null or String [1][]
+		if (targets_file == null) {
+			return null;
+		}
+//		int vect_len = INDX_SPEED; // vf_file.length;
+		int num_fields = targets_file.length;
+		int num_seq = targets_file[0].length;
+		int num_tiles = targets_file[0][0].length;
+		double [][][] vf = new double [num_seq][num_tiles][];
+		for (int nseq=0; nseq < num_seq; nseq++) {
+			for (int ntile = 0; ntile < num_tiles; ntile++) if (!Double.isNaN(targets_file[0][nseq][ntile])){
+				double [] v = new double[num_fields]; // cut to originally calculated fields
+				for (int i = 0; i < num_fields; i++) {
+					v[i] = targets_file[i][nseq][ntile];
+				}
+				vf[nseq][ntile] = v;
+			}
+		}
+		return vf;
+	}
+	
+	
+	
 	public static String trimSuffix(
 			String name,
 			String suffix) {
@@ -7705,11 +7737,11 @@ public class CuasMotion {
 	    double  lma_maxk =       clt_parameters.imp.cuas_lma_maxk; // =      5.0;  // Minimal K (overshoot) > 3.8
 	    double  lma_a2a =        clt_parameters.imp.cuas_lma_a2a; // =       0.7;  // Minimal ratio of the maximal pixel to the amplitude
 //	    double  max_mismatch =   clt_parameters.imp.cuas_max_mismatch;  // 2;
-		double  good_mismatch =  clt_parameters.imp.cuas_good_mismatch;  // 0.4;
+///		double  good_mismatch =  clt_parameters.imp.cuas_good_mismatch;  // 0.4;
 		double  slow_fast_mismatch =  clt_parameters.imp.cuas_slow_fast_mismatch;  // 1.5; allow larger mismatch between slow and fast
 		
-		double  match_len_pwr = clt_parameters.imp.cuas_match_len_pwr;  // raise matching length to this power for calculating score
-		double seq_travel=       clt_parameters.imp.cuas_seq_travel; // 3.0;   // minimal diagonal of the bounding box that includes sequence to be considered "cuas_enough_seq". Filtering out atmospheric fluctuations
+///		double  match_len_pwr = clt_parameters.imp.cuas_match_len_pwr;  // raise matching length to this power for calculating score
+///		double seq_travel=       clt_parameters.imp.cuas_seq_travel; // 3.0;   // minimal diagonal of the bounding box that includes sequence to be considered "cuas_enough_seq". Filtering out atmospheric fluctuations
 	    boolean fail_mismatch =  clt_parameters. imp.cuas_fail_mismatch;  // Fail on high mismatch early (when calculating scores);
 	    
 	    double  target_horizon=  clt_parameters.imp.cuas_horizon;	    
@@ -9178,8 +9210,12 @@ public class CuasMotion {
 		double  slow_ra =        clt_parameters.imp.cuas_slow_ra;
 		double  slow_score =     clt_parameters.imp.cuas_slow_score;
 		boolean clean_video =    clt_parameters.imp.cuas_clean_video;      //true;// save video without any debug information for targets, output in TIFF files. False - same output for video and TIFFs
-		
 		boolean  multi_targ =          clt_parameters.imp.cuas_multi_targ;           // true;  // Use multi-target for each tile mode
+		boolean  reuse_targets =       clt_parameters.imp.cuas_reuse_targets; // true;  // read previously calculated non-conflict (one per tile) targets
+		String   reuse_path =          clt_parameters.imp.cuas_reuse_path; //     "";    // either suffix (all parameters the same) or the full path (contains "/") 
+		
+		double [][][] targets_nonconflict = null;
+		
 		int seq_length = corr_offset + corr_pairs;
 		int corr_inc = half_step ? (corr_offset/2) : corr_offset;
 		int num_corr_samples = (fpixels.length - seq_length - start_frame) / corr_inc;
@@ -9188,7 +9224,22 @@ public class CuasMotion {
 			int frame_cent = start_frame + corr_inc * nscan + seq_length/2; // debug only
 			slice_titles[nscan] =  scene_titles[frame_cent];
 		}
-		double [][][] targets_nonconflict = null;
+		String model_prefix = parentCLT.getImageName()+getParametersSuffix(clt_parameters,null);
+		
+		if (reuse_targets && (reuse_path.length() > 0)) {
+			if (reuse_path.indexOf(Prefs.getFileSeparator()) < 0) {
+				String x3d_path = parentCLT.getX3dDirectory();
+				reuse_path = x3d_path + Prefs.getFileSeparator() + model_prefix + reuse_path+".tiff";
+			}
+			targets_nonconflict = getTargetsFromHyper(reuse_path);
+			if (targets_nonconflict == null) {
+				System.out.println("processMovingTargetsMulti(): failed to read target data from "+reuse_path);
+			} else {
+				System.out.println("processMovingTargetsMulti(): re-using target data from "+reuse_path);
+			}
+		}
+		
+		if (targets_nonconflict == null){
 			// process fast targets		
 			cuasMotion.slow_targets = false; // just for filenames
 			float [][] fpixels_fast = temporalUnsharpMask( // all good targets
@@ -9300,6 +9351,8 @@ public class CuasMotion {
 							debugLevel);             // final int            debugLevel)
 				}
 			}
+		}
+		
 		generateExtractFilterMovingTargets( // move parameters to clt_parameters
 				clt_parameters,          // CLTParameters       clt_parameters,
 				false, // final boolean       video_pass, // if clt_parameters.cuas_clean_video=true, video_pass=0 - output TIFFS, but no video. If video_pass==1 - only video with no debug
@@ -9346,26 +9399,26 @@ public class CuasMotion {
 		boolean half_step =      clt_parameters.imp.cuas_half_step; // true;
 		int     max_range =      clt_parameters.imp.cuas_max_range;
 
-		double target_strength = clt_parameters.imp.cuas_target_strength;
+///		double target_strength = clt_parameters.imp.cuas_target_strength;
 		double [][] target_frac = new double [clt_parameters.imp.cuas_target_frac.length][2];
 	// Moving target LMA	
 	// CUAS Motion LMA parameters
 	// CUAS Motion LMA filter parameters
-	    double  lma_rms =        clt_parameters.imp.cuas_lma_rms; // =       1.5;  // Maximal RMS, regardless of amplitude
-	    double  lma_arms =       clt_parameters.imp.cuas_lma_arms; // =      0.06; // Maximal absolute RMS, sufficient for any amplitude
-	    double  lma_rrms =       clt_parameters.imp.cuas_lma_rrms; // =      0.15; // Maximal relative to A rms. OK is when (RMS < cuas_lma_arms) || (RMS < cuas_lma_rrms * A)
-	    double  lma_mina =       clt_parameters.imp.cuas_lma_mina; // =      1.0;  // Minimal A (amplitude)
-	    double  lma_maxr =       clt_parameters.imp.cuas_lma_maxr; // =      5.0;  // Maximal radius (>3.8)
-	    double  lma_minr1 =      clt_parameters.imp.cuas_lma_minr1; // =     1.0;  // Maximal inner radius
-	    double  lma_mink =       clt_parameters.imp.cuas_lma_mink; // =      0.0;  // Minimal K (overshoot)  <0.007
-	    double  lma_maxk =       clt_parameters.imp.cuas_lma_maxk; // =      5.0;  // Minimal K (overshoot) > 3.8
-	    double  lma_a2a =        clt_parameters.imp.cuas_lma_a2a; // =       0.7;  // Minimal ratio of the maximal pixel to the amplitude
-	    double  max_mismatch =   clt_parameters.imp.cuas_max_mismatch;   // 2;
+///	    double  lma_rms =        clt_parameters.imp.cuas_lma_rms; // =       1.5;  // Maximal RMS, regardless of amplitude
+///	    double  lma_arms =       clt_parameters.imp.cuas_lma_arms; // =      0.06; // Maximal absolute RMS, sufficient for any amplitude
+///	    double  lma_rrms =       clt_parameters.imp.cuas_lma_rrms; // =      0.15; // Maximal relative to A rms. OK is when (RMS < cuas_lma_arms) || (RMS < cuas_lma_rrms * A)
+///	    double  lma_mina =       clt_parameters.imp.cuas_lma_mina; // =      1.0;  // Minimal A (amplitude)
+///	    double  lma_maxr =       clt_parameters.imp.cuas_lma_maxr; // =      5.0;  // Maximal radius (>3.8)
+///	    double  lma_minr1 =      clt_parameters.imp.cuas_lma_minr1; // =     1.0;  // Maximal inner radius
+///	    double  lma_mink =       clt_parameters.imp.cuas_lma_mink; // =      0.0;  // Minimal K (overshoot)  <0.007
+///	    double  lma_maxk =       clt_parameters.imp.cuas_lma_maxk; // =      5.0;  // Minimal K (overshoot) > 3.8
+///	    double  lma_a2a =        clt_parameters.imp.cuas_lma_a2a; // =       0.7;  // Minimal ratio of the maximal pixel to the amplitude
+///	    double  max_mismatch =   clt_parameters.imp.cuas_max_mismatch;   // 2;
 		double  good_mismatch =  clt_parameters.imp.cuas_good_mismatch;  // 0.4;
 		double  slow_fast_mismatch =  clt_parameters.imp.cuas_slow_fast_mismatch;  // 1.5; allow larger mismatch between slow and fast
 		
 		double  match_len_pwr =  clt_parameters.imp.cuas_match_len_pwr;   // raise matching length to this power for calculating score
-	    boolean fail_mismatch =  clt_parameters.imp.cuas_fail_mismatch;  // Fail on high mismatch early (when calculating scores);
+///	    boolean fail_mismatch =  clt_parameters.imp.cuas_fail_mismatch;  // Fail on high mismatch early (when calculating scores);
 	    double  target_horizon=  clt_parameters.imp.cuas_horizon;	    
 	// Handling overall target scores    
 	    

src/main/java/com/elphel/imagej/gpu/GpuQuad.java

@@ -1301,8 +1301,8 @@ public class GpuQuad{ // quad camera description
 		if (!force && this.gpuTileProcessor.bayer_set && !quadCLT.hasNewImageData()) {
 			return;
 		}
+//		System.out.print("setBayerImages(): ");
 		double [][] bayer_center = quadCLT.getImageCenter(); // null
-		//		if (bayer_center != null) {
 		if (center) {		
 			quadCLT.getResetImageCenter();
 			setBayerImage(
@@ -1983,8 +1983,6 @@ public class GpuQuad{ // quad camera description
 		}
 		boolean skip_kernels = rectilinear || (quadCLT == null) || no_kernels;
 		if (!rectilinear) {
-//			if ((quadCLT == null) || (quadCLT.getImageCenter() != null)) { // ????????????????
-//			if ((quadCLT != null) && (quadCLT.getImageCenter() == null)) {
 			if (!skip_kernels) {
 				setConvolutionKernels(false); // set kernels if they are not set already
 			}
@@ -1992,7 +1990,6 @@ public class GpuQuad{ // quad camera description
 					false,             // boolean  force,
 					use_center_image); // boolean center)
 		}
-//		boolean skip_kernels = rectilinear || (quadCLT == null) || (quadCLT.getImageCenter() != null) || !this.gpuTileProcessor.kernels_set || (quadCLT.no_kernels);
 
 		int [] wh1 = handleWH(
 				wh,         // int []  wh_in,

src/main/java/com/elphel/imagej/tileprocessor/IntersceneMatchParameters.java

@@ -867,6 +867,9 @@ min_str_neib_fpn	0.35
 	public int      cuas_num_orient =      2;     // initial value for num_orient
 	public int      cuas_num_accum =       1;     // initial value for num_accum
 	
+	public boolean  cuas_reuse_targets =   false; // read previously calculated non-conflict (one per tile) targets
+	public String   cuas_reuse_path =      "-TARGETS_SINGLE-FINAL";    // either suffix (all parameters the same) or the full path (contains "/") 
+	
 	// TODO: move next parameters elsewhere - they are not the motion blur ones.
 	public  int     mb_gain_index_pose =    5;     // pose readjust pass to switch to full mb_max_gain from mb_max_gain_inter
 	public  int     mb_gain_index_depth =   5;     // depth map refine pass (SfM) to switch to full mb_max_gain from mb_max_gain_inter
@@ -2573,6 +2576,11 @@ min_str_neib_fpn	0.35
 		gd.addNumericField("Value to overwrote num_accum",           this.cuas_num_accum, 0,3,"",
 				"Overwrite value (when Overwrite... is checked).");
 		
+		gd.addCheckbox ("Reuse previosly calculated targets",         this.cuas_reuse_targets,
+				"Read previously calculated non-conflict (one per tile) targets.");
+		gd.addStringField("Calculated targets suffix/path",          this.cuas_reuse_path, 120,
+				"Either suffix (if all the parameters the same) or the full path (contains \"/\").");
+
 		gd.addTab("LMA sequence","Interscene LMA sequence control");
 		gd.addMessage("Parameters for control of the LMA pose adjustment sequence");
 		gd.addNumericField("Pose readjust number for full mb_gain",  this.mb_gain_index_pose, 0,3,"",
@@ -3682,6 +3690,8 @@ min_str_neib_fpn	0.35
 		this.cuas_num_orient =    (int) gd.getNextNumber();
 		this.cuas_num_accum =     (int) gd.getNextNumber();
 		
+		this.cuas_reuse_targets =       gd.getNextBoolean();
+		this.cuas_reuse_path =          gd.getNextString();
 		
 		this.mb_gain_index_pose = (int) gd.getNextNumber();
 		this.mb_gain_index_depth =(int) gd.getNextNumber();
@@ -4707,6 +4717,9 @@ min_str_neib_fpn	0.35
 		properties.setProperty(prefix+"cuas_num_orient",      this.cuas_num_orient+"");     // int
 		properties.setProperty(prefix+"cuas_num_accum",       this.cuas_num_accum+"");      // int
 		
+		properties.setProperty(prefix+"cuas_reuse_targets",   this.cuas_reuse_targets+"");  // boolean
+		properties.setProperty(prefix+"cuas_reuse_path",      this.cuas_reuse_path+"");     // String
+		
 		properties.setProperty(prefix+"mb_gain_index_pose",   this.mb_gain_index_pose+"");  // int
 		properties.setProperty(prefix+"mb_gain_index_depth",  this.mb_gain_index_depth+""); // int
 
@@ -5707,6 +5720,9 @@ min_str_neib_fpn	0.35
 		if (properties.getProperty(prefix+"cuas_num_orient")!=null)      this.cuas_num_orient=Integer.parseInt(properties.getProperty(prefix+"cuas_num_orient"));
 		if (properties.getProperty(prefix+"cuas_num_accum")!=null)       this.cuas_num_accum=Integer.parseInt(properties.getProperty(prefix+"cuas_num_accum"));
 		
+		if (properties.getProperty(prefix+"cuas_reuse_targets")!=null)   this.cuas_reuse_targets=Boolean.parseBoolean(properties.getProperty(prefix+"cuas_reuse_targets"));
+		if (properties.getProperty(prefix+"cuas_reuse_path")!=null)      this.cuas_reuse_path=(String) properties.getProperty(prefix+"cuas_reuse_path");
+		
 		if (properties.getProperty(prefix+"mb_gain_index_pose")!=null)   this.mb_gain_index_pose=Integer.parseInt(properties.getProperty(prefix+"mb_gain_index_pose"));
 		if (properties.getProperty(prefix+"mb_ers_index")!=null)         this.mb_ers_index=Integer.parseInt(properties.getProperty(prefix+"mb_ers_index"));
 		if (properties.getProperty(prefix+"mb_ers_y_index")!=null)       this.mb_ers_y_index=Integer.parseInt(properties.getProperty(prefix+"mb_ers_y_index"));
@@ -6699,6 +6715,9 @@ min_str_neib_fpn	0.35
 		imp.cuas_num_orient =       this.cuas_num_orient;
 		imp.cuas_num_accum =        this.cuas_num_accum;
 		
+		imp.cuas_reuse_targets =    this.cuas_reuse_targets;
+		imp.cuas_reuse_path=        this.cuas_reuse_path;
+
 		imp.mb_gain_index_pose    = this.mb_gain_index_pose;
 		imp.mb_gain_index_depth   = this.mb_gain_index_depth;
 

src/main/java/com/elphel/imagej/tileprocessor/OpticalFlow.java

@@ -5006,7 +5006,15 @@ public class OpticalFlow {
 						}
 					}
 					
-					double [][] image_center = center_CLT.convertCenterClt(null);
+//					double [][] image_center = center_CLT.convertCenterClt(null); // when null, uses center_CLT.center_clt
+					double [][] image_center = center_CLT.convertCenterClt(
+							null, // when null, uses center_CLT.center_clt
+							clt_parameters.gpu_sigma_r, // final double              gpu_sigma_r,     // 0.9, 1.1
+							clt_parameters.gpu_sigma_b, // final double              gpu_sigma_b,     // 0.9, 1.1
+							clt_parameters.gpu_sigma_g, // final double              gpu_sigma_g,     // 0.6, 0.7
+							clt_parameters.gpu_sigma_m); // final double              gpu_sigma_m,     //  =       0.4; // 0.7;
+							
+//					System.out.print("buildSeries(): ");
 					center_CLT.setImageCenter(image_center);
 					boolean show_image_center = cuas_debug && !clt_parameters.batch_run;
 					if (show_image_center) { // restored, not new!
@@ -5566,7 +5574,7 @@ public class OpticalFlow {
 				double [][][] fpn = CorrectionFPN.cuasSubtractFpn( // returns fpn // null
 						clt_parameters,      // CLTParameters        clt_parameters,
 						cuas_subtract_fpn,   // boolean              cuas_subtract_fpn, //
-						changed,             //boolean              changed,           // 	        boolean changed = quadCLT_main.isPhotometricUpdatedAndReset();
+						false, // changed,             //boolean              changed,           // 	        boolean changed = quadCLT_main.isPhotometricUpdatedAndReset();
 						colorProcParameters, // ColorProcParameters  colorProcParameters,
 						center_CLT,          // QuadCLT              center_CLT,        // where combo_dsi is. Should have hasCenterClt()   (run makeCenterClt() before)
 						quadCLTs,            // QuadCLT []           quadCLTs,
@@ -8149,6 +8157,24 @@ public class OpticalFlow {
 			ref_pXpYD_or_null = ref_pXpYD;
 			ref_scene.getErsCorrection().setupERS();
 			System.out.println("Calculated virtual_PxPyD");
+			boolean debug_virtual_PxPyD = (debugLevel > 1000);
+			if (debug_virtual_PxPyD) {
+				String [] dbg_titles = {"pX", "pY", "D"};
+				double [][] dbg_pXpYD = new double[dbg_titles.length][ref_pXpYD.length];
+				for (int i = 0; i < dbg_pXpYD.length; i++) Arrays.fill(dbg_pXpYD[i], Double.NaN);
+				for (int i = 0; i < ref_pXpYD.length; i++) if (ref_pXpYD[i] != null) {
+					for (int j = 0; j < ref_pXpYD[i].length; j++) dbg_pXpYD[j][i] = ref_pXpYD[i][j];
+				}
+				ImagePlus imp_virtual_PxPyD= ShowDoubleFloatArrays.makeArrays(
+						dbg_pXpYD,
+						ref_scene.getTilesX(),
+						ref_scene.getTilesY(),
+						ref_scene.getImageName()+"-virtual_PxPyD",
+						dbg_titles);
+				ref_scene.saveImagePlusInModelDirectory(
+	        			null, // String      suffix,
+	        			imp_virtual_PxPyD); // ImagePlus   imp)
+			}
         } else {
         	ref_pXpYD = transformToScenePxPyD( // now should work with offset ref_scene
         			fov_tiles,            // final Rectangle [] extra_woi,    // show larger than sensor WOI (or null)

src/main/java/com/elphel/imagej/tileprocessor/QuadCLT.java

@@ -203,12 +203,74 @@ public class QuadCLT extends QuadCLTCPU {
 				sensor_mask_clt, // final int         sensor_mask,
                 wh,              // null, // int []  wh,
                 false);          // boolean use_reference
+/*		
+		float [][]  fpix = getComboFromTD(
+				-1, // final int                 sensor_mask, // only if merge_channels
+				false, // final boolean             merge_channels,
+				null, // final int []              whc, // if int[2], will return width, height
+				false); // final boolean             use_reference){
+				*/
+
+		
+		double [][] dbg = renderDoubleFromTDMono (
+				-1, // final int         sensor_mask,
+                wh,              // null, // int []  wh,
+                false);          // boolean use_reference
+
+		System.out.println("###  convertCenterClt(): result={"+result[0][0]+","+result[0][1]+","+result[0][2]+","+result[0][3]+", dbg.length="+dbg.length);
+		ShowDoubleFloatArrays.showArrays(
+				dbg,
+				wh[0],
+				wh[1],
+				true,
+				"convertCenterClt_test");
+		
+		return result;
+	}
+	
+	
+	public double [][] convertCenterClt(
+			float [][] fclt, // may be null
+			final double              gpu_sigma_r,     // 0.9, 1.1
+			final double              gpu_sigma_b,     // 0.9, 1.1
+			final double              gpu_sigma_g,     // 0.6, 0.7
+			final double              gpu_sigma_m) {     //  =       0.4; // 0.7;
+		final float [][] lpf_rgb = new float[][] {
+			ImageDtt.floatGetCltLpfFd(gpu_sigma_r, GPUTileProcessor.DTT_SIZE),
+			ImageDtt.floatGetCltLpfFd(gpu_sigma_b, GPUTileProcessor.DTT_SIZE),
+			ImageDtt.floatGetCltLpfFd(gpu_sigma_g, GPUTileProcessor.DTT_SIZE),
+			ImageDtt.floatGetCltLpfFd(gpu_sigma_m, GPUTileProcessor.DTT_SIZE)
+		};
+		gpuQuad.setLpfRbg( // constants memory - same for all cameras
+				lpf_rgb,
+				false); // boolean    debug)
+
+		int sensor_mask_clt = 1; // just one
+		setQuadClt();
+		int tilesX = getTilesX();
+		int tilesY = getTilesY();
+		int tile_size = getTileSize();
+		int [] wh = {tilesX*tile_size,tilesY*tile_size};
+		getGPUQuad().handleWH(
+				wh,     // int []  wh,
+				false); // boolean ref_scene)
+		setComboToTD(
+				fclt, // new float [][] {center_CLT.getCenterClt()}, // ,combo_seq_clt,   // final float [][]  fclt,
+				true,            // merge_clt,       // final boolean     merge_channels, // duplicate same data to all selected channels
+				sensor_mask_clt, // final int         sensor_mask, // only if merge_channels
+				null, // whc,    // final int []      whc, // if int[2], will return width, height
+				false);          // final boolean     use_reference);
+		double [][] result = renderDoubleFromTD (
+				sensor_mask_clt, // final int         sensor_mask,
+                wh,              // null, // int []  wh,
+                false);          // boolean use_reference
 		return result;
 	}
 	
 	
 	
 	
+	
 	/**
 	 * Remove weak non-LMA tiles if they do not have any LMA or strong neighbors and
 	 * too few weak neighbors. Single strong neighbor within range is enough, strong/LMA
@@ -3066,9 +3128,11 @@ public class QuadCLT extends QuadCLTCPU {
 			boolean     use_reference){
 		if (fclt == null) {
 			fclt = new float[][] {getCenterClt()};
-			merge_channels = true;
+///			System.out.println("+++  setComboToTD(): fclt={"+fclt[0][0]+","+fclt[0][1]+","+fclt[0][2]+","+fclt[0][3]);
+///			merge_channels = true;
+///		} else {
+///			System.out.println("+++! setComboToTD(): fclt={"+fclt[0][0]+","+fclt[0][1]+","+fclt[0][2]+","+fclt[0][3]);
 		}
-		
 		final int [] width_height = gpuQuad.getWH(use_reference);
 		final int num_colors = gpuQuad.getNumColors();
 		if (whc != null) {
@@ -3078,13 +3142,30 @@ public class QuadCLT extends QuadCLTCPU {
 				whc[2] = num_colors;
 			}
 		}
+///		System.out.println("+++? setComboToTD(): fclt.length="+fclt.length+", fclt[0].length="+fclt[0].length+
+///				", merge_channels="+merge_channels+", sensor_mask="+sensor_mask);
 		for (int ncam = 0; ncam < fclt.length; ncam++) if (((1 << ncam) & sensor_mask) != 0){
+//		for (int ncam = 0; ncam < getNumSensors(); ncam++) { // if (((1 << ncam) & sensor_mask) != 0){
+//		for (int ncam = 0; ncam < 1; ncam++) { // if (((1 << ncam) & sensor_mask) != 0){
 			int src_cam = merge_channels? 0: ncam;
 			gpuQuad.setCltData( // for testing only
 					ncam, // int      ncam,
 					fclt[src_cam], // float [] fclt, //
 					use_reference); // boolean  use_ref);
 		}
+/*		
+		
+		float [][] dbg_fclt = gpuQuad.getCltData( // only for color=0
+				use_reference); // boolean use_ref){
+
+		System.out.println("$$$ setComboToTD(): dbg_fclt={"+dbg_fclt[0][0]+","+dbg_fclt[0][1]+","+dbg_fclt[0][2]+","+dbg_fclt[0][3]);
+		ShowDoubleFloatArrays.showArrays(
+				fclt,
+				width_height[0],
+				width_height[1],
+				true,
+				"convertCenterClt_fclt");
+*/				
 		return;
 	}
 	
@@ -3300,6 +3381,45 @@ public class QuadCLT extends QuadCLTCPU {
 		return iclt_fimg_combo;
 	}
 	
+	public double [][] renderDoubleFromTDMono ( // [scene][color][pixel]
+			int                 sensor_mask,
+			int []              wh, // may be null, or {width, height}
+			boolean             use_reference
+			) {
+        gpuQuad.execImcltRbgAll(
+        		isMonochrome(),
+        		use_reference,
+				wh); //int [] wh
+		// get data back from GPU
+		final float [][][] iclt_fimg = new float [getNumSensors()][][];
+		int nchn = 0;
+		int nTiles = 0;
+		for (int ncam = 0; ncam < iclt_fimg.length; ncam++) if (((1 << ncam) & sensor_mask) != 0){
+			iclt_fimg[ncam] = gpuQuad.getRBG(ncam); // updated window
+//			ncol = iclt_fimg[ncam].length;
+			nTiles = iclt_fimg[ncam][0].length;
+			nchn++;
+		}
+		final double [][] iclt_fimg_combo = new double [nchn][nTiles];
+		final Thread[] threads = ImageDtt.newThreadArray(THREADS_MAX);
+		final AtomicInteger ai = new AtomicInteger(0);
+		for (int ithread = 0; ithread < threads.length; ithread++) {
+			threads[ithread] = new Thread() {
+				public void run() {
+					for (int nTile = ai.getAndIncrement(); nTile < iclt_fimg_combo[0].length; nTile = ai.getAndIncrement()) {
+						for (int i = 0; i < iclt_fimg.length; i++) if (iclt_fimg[i] != null) {
+							iclt_fimg_combo[i][nTile] = iclt_fimg[i][0][nTile];
+						}
+					}
+				}
+			};
+		}		      
+		ImageDtt.startAndJoin(threads);
+		return iclt_fimg_combo;
+	}
+	
+	
+	
 	public double [][][] renderDoubleFromTD ( // [scene][color][pixel]
 			int []              wh, // may be null, or {width, height}
 			boolean             use_reference

src/main/java/com/elphel/imagej/tileprocessor/QuadCLTCPU.java

@@ -6327,9 +6327,29 @@ public class QuadCLTCPU {
 
     public double [][] getResetImageCenter(){
     	new_image_data = false;
+    	boolean debug = false;
+    	if (debug) {
+    		if (image_center == null) {
+    			System.out.println("--- getResetImageCenter(): image_center== null");
+
+    		} else {
+    			System.out.println("--- getResetImageCenter(): image_center={"+image_center[0][0]+","+image_center[0][1]+","+image_center[0][2]+","+image_center[0][3]);
+
+    		}
+    	}
     	return image_center;
     }
     public double [][] getImageCenter(){ // does not reset new data
+    	boolean debug = false;
+    	if (debug) {
+    		if (image_center == null) {
+    			System.out.println("--- getImageCenter(): image_center== null");
+
+    		} else {
+    			System.out.println("--- getImageCenter(): image_center={"+image_center[0][0]+","+image_center[0][1]+","+image_center[0][2]+","+image_center[0][3]);
+
+    		}
+    	}
     	return image_center;
     }
     public void setImageCenter(double [][] data) {
@@ -6337,6 +6357,16 @@ public class QuadCLTCPU {
     	new_image_data = true;
 //    	image_fpn_applied = null;
 //    	image_fpn = null;
+    	boolean debug = false;
+    	if (debug) {
+    		if (image_center == null) {
+    			System.out.println("+++ setImageCenter(): image_center== null");
+
+    		} else {
+    			System.out.println("+++ setImageCenter(): image_center={"+image_center[0][0]+","+image_center[0][1]+","+image_center[0][2]+","+image_center[0][3]);
+    		}
+    	}
+    	return;
     }