Added 32-bit tiff output for ML data

src/main/java/CLTPass3d.java

@@ -512,7 +512,7 @@ public class CLTPass3d{
 		 *
 		 * Replace weak by a weighted average of non-weak. If there are none - use weak ones, including this one too.
 		 */
-		public boolean[] replaceWeakOutlayers(
+		public boolean[] replaceWeakOutliers(
 				final boolean [] selection,
 				final double weakStrength,    // strength to be considered weak, subject to this replacement
 				final double maxDiff,
@@ -546,7 +546,7 @@ public class CLTPass3d{
 									(disparity[nTile] < absMinDisparity) ||
 									(disparity[nTile] > absMaxDisparity))&& ((selection == null) || selection[nTile])) {
 								if (nTile == dbg_nTile){
-									System.out.println("replaceWeakOutlayers():1 nTile="+nTile);
+									System.out.println("replaceWeakOutliers():1 nTile="+nTile);
 								}
 								double [] dbg_disparity = disparity;
 								double dbg_disparity_nTile = disparity[nTile];
@@ -602,7 +602,7 @@ public class CLTPass3d{
 					public void run() {
 						for (int nTile = ai.getAndIncrement(); nTile < nTiles; nTile = ai.getAndIncrement()) {
 							if (nTile == dbg_nTile){
-								System.out.println("replaceWeakOutlayers():2 nTile="+nTile);
+								System.out.println("replaceWeakOutliers():2 nTile="+nTile);
 							}
 							if (weakOutlayers[nTile]) {
 								double sw = 0.0, sd = 0.0;

src/main/java/Correlation2d.java

@@ -185,6 +185,42 @@ public class Correlation2d {
     		double [][] clt_data2,
     		double [][] tcorr, // null or initialized to [4][transform_len]
     		double      fat_zero) {
+    	if (tcorr == null) tcorr = new double [4][transform_len];
+    	double [] a2 = new double[transform_len];
+    	double sa2 = 0.0;
+		for (int i = 0; i < transform_len; i++) {
+			double s1 = 0.0, s2=0.0;
+			for (int n = 0; n< 4; n++){
+				s1+=clt_data1[n][i] * clt_data1[n][i];
+				s2+=clt_data2[n][i] * clt_data2[n][i];
+			}
+			a2[i] = Math.sqrt(s1*s2);
+			sa2 += a2[i];
+		}
+		double fz2 = sa2/transform_len * fat_zero * fat_zero; // fat_zero squared to match units
+		for (int i = 0; i < transform_len; i++) {
+			double scale = 1.0 / (a2[i] + fz2);
+			for (int n = 0; n<4; n++){
+				tcorr[n][i] = 0;
+				for (int k=0; k<4; k++){
+					if (ZI[n][k] < 0)
+						tcorr[n][i] -=
+								clt_data1[-ZI[n][k]][i] * clt_data2[k][i];
+					else
+						tcorr[n][i] +=
+								clt_data1[ZI[n][k]][i] * clt_data2[k][i];
+				}
+				tcorr[n][i] *= scale;
+			}
+		}
+		return tcorr;
+    }
+
+    public double[][] correlateSingleColorFD_old(
+    		double [][] clt_data1,
+    		double [][] clt_data2,
+    		double [][] tcorr, // null or initialized to [4][transform_len]
+    		double      fat_zero) {
     	if (tcorr == null) tcorr = new double [4][transform_len];
 		for (int i = 0; i < transform_len; i++) {
 			double s1 = 0.0, s2=0.0;
@@ -210,6 +246,7 @@ public class Correlation2d {
     }
 
 
+
     /**
      * Calculate color channels FD phase correlations, mix results with weights, apply optional low-pass filter
      * and convert to the pixel domain  as [(2*transform_size-1) * (2*transform_size-1)] tiles (15x15)
@@ -845,6 +882,7 @@ public class Correlation2d {
 	}
 	/**
 	 * Calculate 1-d maximum location, strength and half-width for the special strip (odd rows shifted by 0.5
+	 * Negative values are ignored!
 	 * Both x and y half-windows can be variable length (to reduce calculations with 0.0 elements), normalized
 	 * so sums of zero element and twice all others are 1.0
 	 * Window in Y direction corresponds to correlation stripe rows, corresponding to sqrt(2)/2 sensor pixels
@@ -992,6 +1030,140 @@ public class Correlation2d {
 	}
 
 
+	/**
+	 * Extract center 2-d correlation around zero from the full (now 15x15)
+	 * @param hwidth half width of the output tile (0 -> 1x1, 1-> 3x3, 2->5x5)
+	 * @param full_corr  full pixel-domain correlation (now 15x15=225 long)
+	 * @param center_corr - output array [(2*hwidth+1)*(2*hwidth+1)] or null
+	 * @return center_corr - center part of the correlation in linescan order
+	 */
+    public double [] corrCenterValues(
+    		int       hwidth,
+    		double [] full_corr,
+    		double [] center_corr) {
+    	if (full_corr == null) return null;
+    	int center = transform_size - 1;
+    	int width = 2 * center + 1;
+    	int owidth = 2*hwidth+1;
+    	if (center_corr == null) center_corr = new double [owidth*owidth];
+    	int indx = 0;
+    	int findx = (center - hwidth) * (width + 1); // top left corner
+    	for (int row = 0; row < owidth; row++) {
+        	for (int col = 0; col < owidth; col++) {
+        		center_corr[indx++] = full_corr[findx++];
+        	}
+        	findx += width-owidth;
+    	}
+    	return center_corr;
+    }
+
+    /**
+     * Extract center 2-d correlations around zero from the full (now 15x15) correlations
+     * for each of the 6 pairs and 2 combined directions (horizontal, vertical)
+     * @param hwidth half width of the output tile (0 -> 1x1, 1-> 3x3, 2->5x5)
+     * @param offset add before multiplication, subtract in the end. If negative - use averaging
+     *  instead of the shifted multiplication
+     * @param full_corr  full pixel-domain correlation (now 15x15=225 long)for each of 6 pairs
+     * @param center_corr - output array [(2*hwidth+1)*(2*hwidth+1)]. should be [8][]
+     */
+    public void corrCenterValues(
+    		int         hwidth,
+    		double      offset,
+    		double [][] full_corr,
+    		double [][] center_corr) {
+    	// first 6 layers - directly correspond to pairs (top, bottom, left, right, diagonal main, diagonal other)
+    	for (int i = 0; i < 6; i++) {
+    		center_corr[i] = corrCenterValues(
+    				hwidth,
+    				full_corr[i],
+    				center_corr[i]);
+    	}
+
+    	// combine vertical and horizontal pairs
+    	int center = transform_size - 1;
+    	int width =  2 * center + 1;
+    	int owidth = 2 * hwidth + 1;
+    	for (int ndir = 0; ndir < 2; ndir++) { // 0- hor, 1- vert
+    		if (center_corr[ndir] == null) center_corr[ndir] = new double [owidth*owidth];
+    		int indx = 0;
+    		int findx = (center - hwidth) * (width + 1); // top left corner
+    		for (int row = 0; row < owidth; row++) {
+    			for (int col = 0; col < owidth; col++) {
+    				double fc0 = full_corr[2 * ndir + 0][findx]; // 0 (top), 2 (left)
+    				double fc1 = full_corr[2 * ndir + 1][findx++]; // 1 - bottom, 3 (right)
+    				double cc = 0.0;
+    				if (offset >= 0.0) {
+    					if ((fc0 > 0.0) && (fc1 > 0.0)) {
+    						cc = Math.sqrt((fc0+offset)*(fc1+offset)) - offset;
+    					}
+    				} else {
+    					cc =  0.5*(fc0+fc1);
+    				}
+
+    				center_corr[ndir + 6][indx++] = cc; // save to 6-th and 7-th layer
+    			}
+    			findx += width-owidth;
+    		}
+    	}
+    }
+
+    /**
+     * Save 2d correlation data for one layer, one tile into the combined multi-layer ML array, viewable as an image
+     * @param tileX horizontal tile index
+     * @param tileY vertical tile index
+     * @param ml_hwidth half-width of the preserved 2d correlation (0 - single point, 1 -> 3x3, 2 -> 5x5, 7 - all data)
+     * @param ml_data multi-layer array, each layer matches an image of ((2 * ml_hwidth + 1) * tilesX) by ((2 * ml_hwidth + 1) * tilesY) in scanline order
+     * Each tile corresponds to  (2 * ml_hwidth + 1) * (2 * ml_hwidth + 1) square in the image. Only selected tiles will be updated, so it is good to initialize array
+     * with all Double.NaN values
+     * @param ml_layer layer to save tile data
+     * @param ml_tile (2 * ml_hwidth + 1) * (2 * ml_hwidth + 1) tile data to be saved
+     * @param tilesX image width in tiles
+     */
+    public void saveMlTile(
+    		int         tileX,
+    		int         tileY,
+    		int         ml_hwidth,
+    		double [][] ml_data,
+    		int         ml_layer,
+    		double []   ml_tile,
+    		int         tilesX) {
+    	int tile_width = 2 * ml_hwidth + 1;
+    	int full_width = tile_width * tilesX;
+    	int oindex = tileY *tile_width * full_width  + tileX * tile_width;
+    	for (int row = 0; row < tile_width; row++) {
+			System.arraycopy(ml_tile, row * tile_width, ml_data[ml_layer], oindex, tile_width);
+			oindex += full_width;
+    	}
+    }
+    /**
+     * Save a single value to the combined multi-layer ML array, viewable as an image
+     * @param tileX horizontal tile index
+     * @param tileY vertical tile index
+     * @param ml_hwidth half-width of the preserved 2d correlation (0 - single point, 1 -> 3x3, 2 -> 5x5, 7 - all data)
+     * @param ml_data multi-layer array, each layer matches an image of ((2 * ml_hwidth + 1) * tilesX) by ((2 * ml_hwidth + 1) * tilesY) in scanline order
+     * Each tile corresponds to  (2 * ml_hwidth + 1) * (2 * ml_hwidth + 1) square in the image. Only selected tiles will be updated, so it is good to initialize array
+     * with all Double.NaN values
+     * @param ml_layer layer to save tile data
+     * @param ml_index data index within tile
+     * @param ml_value value to set
+     * @param tilesX image width in tiles
+     */
+    public void saveMlTilePixel(
+    		int         tileX,
+    		int         tileY,
+    		int         ml_hwidth,
+    		double [][] ml_data,
+    		int         ml_layer,
+    		int         ml_index,
+    		double      ml_value,
+    		int         tilesX) {
+    	int tile_width = 2 * ml_hwidth + 1;
+    	int full_width = tile_width * tilesX;
+    	int oindex = tileY *tile_width * full_width  + tileX * tile_width + (ml_index/tile_width)*full_width + (ml_index%tile_width) ;
+    	ml_data[ml_layer][oindex] = ml_value;
+    }
+
+
 
 
     public double [] debugStrip(
@@ -1238,6 +1410,7 @@ public class Correlation2d {
     	return rslt;
     }
 
+    // ignores negative values
     public double [] single2dCM( // returns x-xcenter, y, strength (sign same as disparity)
     		ImageDttParameters  imgdtt_params,
     		double []           corr,
@@ -1408,7 +1581,7 @@ public class Correlation2d {
     		System.out.println(String.format("eff_strength = [%8.5f, %8.5f, %8.5f, %8.5f]", eff_strength[0], eff_strength[1], eff_strength[2], eff_strength[3]));
     		System.out.println(String.format("width_d =      [%8.5f, %8.5f, %8.5f, %8.5f]", width_d[0],      width_d[1],      width_d[2],      width_d[3]));
     	}
-		if (!strong[isel] || (isel <0)) {
+		if ((isel <0) || !strong[isel]) {
 			corr = Double.NaN;
 			if (debug) System.out.println("Direction with "+(bg?"min":"max")+" disparity is not strong enough -> no correction");
 		} else 		if (width_d[isel] > max_hwidth) {
@@ -1446,7 +1619,7 @@ public class Correlation2d {
     		}
     		if (debug) System.out.println("lim =  "+lim+", disp = "+disp);
     	}
-    	double [] rslt = {disp, eff_strength[isel], mx - mn, are_ortho ?1.0 : 0.0};
+    	double [] rslt = {disp, (isel >=0) ? eff_strength[isel]:0.0, mx - mn, are_ortho ?1.0 : 0.0};
 		if (debug) System.out.println(String.format("foregroundCorrect() -> [%8.5f, %8.5f, %8.5f, %3.1f]", rslt[0], rslt[1], rslt[2], rslt[3]));
 
     	return    rslt;

src/main/java/EyesisCorrectionParameters.java

@@ -134,11 +134,12 @@ public class EyesisCorrectionParameters {
     	public String x3dModelVersion="v01";
     	public String x3dDirectory="";
 
+    	public String mlDirectory="";
 
     	public CorrectionParameters getAux() {
     		return aux_camera;
     	}
-    	public CorrectionParameters aux_camera = null; // auxiliarry camera parameters
+    	public CorrectionParameters aux_camera = null; // auxiliary camera parameters
 //  		public boolean use_aux =             true;  // Generate debug images if a single set is selected
 		public void updateAuxFromMain() { // from master to aux
 			if (aux_camera == null) {
@@ -222,13 +223,10 @@ public class EyesisCorrectionParameters {
   			cp.referenceExposure=    	this.referenceExposure;
   			cp.relativeExposure=    	this.relativeExposure;
   			cp.swapSubchannels01=    	this.swapSubchannels01;
-//  			cp.cltKernelDirectory=    	this.cltKernelDirectory;
-//  			cp.cltKernelPrefix=    		this.cltKernelPrefix;
-//  			cp.cltSuffix=               this.cltSuffix;
   			cp.x3dDirectory=    		this.x3dDirectory;
+  			cp.mlDirectory=    	     	this.mlDirectory;
   			cp.use_x3d_subdirs=    		this.use_x3d_subdirs;
   			cp.x3dSubdirPrefix=    		this.x3dSubdirPrefix;
-// 			cp.x3dSubdirSuffix=    		this.x3dSubdirSuffix;
   			cp.x3dModelVersion=    		this.x3dModelVersion;
   			cp.clt_batch_apply_man=		this.clt_batch_apply_man;
   			cp.clt_batch_extrinsic=		this.clt_batch_extrinsic;
@@ -365,10 +363,10 @@ public class EyesisCorrectionParameters {
 
     		properties.setProperty(prefix+"x3dSubdirPrefix",       this.x3dSubdirPrefix+"");
     		properties.setProperty(prefix+"x3dSubdirSuffix",       this.x3dSubdirSuffix+"");
-
-
     		properties.setProperty(prefix+"x3dModelVersion",       this.x3dModelVersion);
 
+    		properties.setProperty(prefix+"mlDirectory",           this.mlDirectory);
+
     		properties.setProperty(prefix+"clt_batch_apply_man",   this.clt_batch_apply_man+"");
     		properties.setProperty(prefix+"clt_batch_extrinsic",   this.clt_batch_extrinsic+"");
     		properties.setProperty(prefix+"clt_batch_poly",        this.clt_batch_poly+"");
@@ -494,6 +492,8 @@ public class EyesisCorrectionParameters {
 
 			if (properties.getProperty(prefix+"x3dModelVersion")!=      null) this.x3dModelVersion=properties.getProperty(prefix+"x3dModelVersion");
 
+			if (properties.getProperty(prefix+"mlDirectory")!=          null) this.mlDirectory=properties.getProperty(prefix+"mlDirectory");
+
 			if (properties.getProperty(prefix+"clt_batch_apply_man")!= null) this.clt_batch_apply_man=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_apply_man"));
 			if (properties.getProperty(prefix+"clt_batch_extrinsic")!= null) this.clt_batch_extrinsic=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_extrinsic"));
 			if (properties.getProperty(prefix+"clt_batch_poly")!= null)      this.clt_batch_poly=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_poly"));
@@ -599,6 +599,8 @@ public class EyesisCorrectionParameters {
     				"When using timestamp as a subdirectory, add this prefix");
     		gd.addStringField ("x3d subdirectory suffix",                          this.x3dSubdirSuffix, 10,
     				"When using timestamp as a subdirectory, add this suffix");
+    		gd.addStringField ("ML output directory",                              this.mlDirectory, 60);
+    		gd.addCheckbox    ("Select ML output directory",                      false);
 
     		gd.addStringField("Equirectangular maps directory (may be empty)",     this.equirectangularDirectory, 60);
     		gd.addCheckbox("Select equirectangular maps directory",                false);
@@ -693,6 +695,8 @@ public class EyesisCorrectionParameters {
     		this.x3dSubdirPrefix=        gd.getNextString();
     		this.x3dSubdirSuffix=        gd.getNextString();
 
+    		this.mlDirectory=            gd.getNextString(); if (gd.getNextBoolean()) selectMlDirectory(false, true);
+
     		this.equirectangularDirectory=  gd.getNextString(); if (gd.getNextBoolean()) selectEquirectangularDirectory(false, false);
     		this.resultsDirectory=       gd.getNextString(); if (gd.getNextBoolean()) selectResultsDirectory(false, true);
     		this.sourcePrefix=           gd.getNextString();
@@ -749,6 +753,8 @@ public class EyesisCorrectionParameters {
     		gd.addStringField ("x3d subdirectory prefix",                          this.x3dSubdirPrefix, 10,    // 14a
     				"When using timestamp as a subdirectory, add this prefix");
 
+    		gd.addStringField ("ML output directory",                              this.mlDirectory, 60);       // 8d
+    		gd.addCheckbox    ("Select ML output directory",                       false);                      // 8e
 
 			gd.addMessage     ("============ Main camera============");
 
@@ -823,6 +829,7 @@ public class EyesisCorrectionParameters {
     		this.sourcePrefix=           gd.getNextString();  // 13
     		this.sourceSuffix=           gd.getNextString();  // 14
     		this.x3dSubdirPrefix=        gd.getNextString();  // 14a
+    		this.mlDirectory=            gd.getNextString(); if (gd.getNextBoolean()) selectMlDirectory(false, true);       // 8d
 
 // main camera
     		this.sensorDirectory=        gd.getNextString(); if (gd.getNextBoolean()) selectSensorDirectory(false, false);   // 5
@@ -1403,6 +1410,17 @@ public class EyesisCorrectionParameters {
     		return dir;
     	}
 
+    	public String selectMlDirectory(boolean smart, boolean newAllowed) {
+    		String dir= CalibrationFileManagement.selectDirectory(
+    				smart,
+    				newAllowed, // save
+    				"ML output directory", // title
+    				"Select ML output directory", // button
+    				null, // filter
+    				this.mlDirectory); //this.sourceDirectory);
+    		if (dir!=null) this.mlDirectory=dir;
+    		return dir;
+    	}
     	// add prefix/suffix to the model name
     	public String getModelName(String name) {
     		return this.x3dSubdirPrefix + name + this.x3dSubdirSuffix;
@@ -2988,7 +3006,7 @@ public class EyesisCorrectionParameters {
 
 
 
-  		public boolean    replaceWeakOutlayers =   true; // false;
+  		public boolean    replaceWeakOutliers =   true; // false;
 
   		public boolean    dbg_migrate =            true;
 

src/main/java/Eyesis_Correction.java

@@ -583,7 +583,9 @@ private Panel panel1,
 			addButton("CLT 2*4 images - 2",         panelClt4, color_conf_process);
 			addButton("CLT 2*4 images - 3",         panelClt4, color_conf_process);
 			addButton("Rig infinity calibration",   panelClt4, color_conf_process);
+			addButton("AUX Extrinsics",             panelClt4, color_process);
 			addButton("AUX show fine",              panelClt4, color_configure);
+			addButton("Rig enhance",                panelClt4, color_conf_process);
 
 			add(panelClt4);
 		}
@@ -4091,6 +4093,11 @@ private Panel panel1,
         	}
         }
         QUAD_CLT.listGeometryCorrection(true);
+        if (QUAD_CLT_AUX  != null) { // Only show auxiliary camera geometry if it is initialized
+        	System.out.println("\n === Auxiliary camera ===");
+            QUAD_CLT_AUX.listGeometryCorrection(true);
+        }
+
         return;
     } else if (label.equals("CLT show fine corr")) {
         if (QUAD_CLT == null){
@@ -4255,7 +4262,6 @@ private Panel panel1,
 
         EYESIS_CORRECTIONS.initSensorFiles(DEBUG_LEVEL);
         int numChannels=EYESIS_CORRECTIONS.getNumChannels();
-//        NONLIN_PARAMETERS.modifyNumChannels(numChannels);
         CHANNEL_GAINS_PARAMETERS.modifyNumChannels(numChannels);
 
         if (!QUAD_CLT.CLTKernelsAvailable()){
@@ -4303,6 +4309,80 @@ private Panel panel1,
 
 
 
+        if (configPath!=null) {
+        	saveTimestampedProperties( // save config again
+        			configPath,      // full path or null
+        			null, // use as default directory if path==null
+        			true,
+        			PROPERTIES);
+        }
+        return;
+    } else if (label.equals("AUX Extrinsics") || label.equals("AUX Poly corr")) {
+    	boolean adjust_extrinsics = label.equals("AUX Extrinsics") || label.equals("AUX Poly corr");
+    	boolean adjust_poly = label.equals("AUX Poly corr");
+    	DEBUG_LEVEL=MASTER_DEBUG_LEVEL;
+    	EYESIS_CORRECTIONS.setDebug(DEBUG_LEVEL);
+        if (QUAD_CLT_AUX == null){
+        	if (EYESIS_CORRECTIONS_AUX == null) {
+        		EYESIS_CORRECTIONS_AUX = new EyesisCorrections(SYNC_COMMAND.stopRequested,CORRECTION_PARAMETERS.getAux());
+        	}
+        	QUAD_CLT_AUX = new  QuadCLT (
+        			QuadCLT.PREFIX_AUX,
+        			PROPERTIES,
+        			EYESIS_CORRECTIONS_AUX,
+        			CORRECTION_PARAMETERS.getAux());
+        	if (DEBUG_LEVEL > 0){
+        		System.out.println("Created new QuadCLT instance for AUX camera, will need to read CLT kernels for aux camera");
+        	}
+        }
+    	String configPath=getSaveCongigPath();
+    	if (configPath.equals("ABORT")) return;
+
+    	EYESIS_CORRECTIONS_AUX.initSensorFiles(DEBUG_LEVEL);
+        int numChannelsAux=EYESIS_CORRECTIONS_AUX.getNumChannels();
+        CHANNEL_GAINS_PARAMETERS_AUX.modifyNumChannels(numChannelsAux);
+
+        if (!QUAD_CLT_AUX.CLTKernelsAvailable()){
+        	if (DEBUG_LEVEL > 0){
+        		System.out.println("Reading AUX CLT kernels");
+        	}
+        	QUAD_CLT_AUX.readCLTKernels(
+            		CLT_PARAMETERS,
+                    THREADS_MAX,
+                    UPDATE_STATUS, // update status info
+            		DEBUG_LEVEL);
+
+            if (DEBUG_LEVEL > 1){
+            	QUAD_CLT_AUX.showCLTKernels(
+            			THREADS_MAX,
+            			UPDATE_STATUS, // update status info
+            			DEBUG_LEVEL);
+        	}
+        }
+
+        if (!QUAD_CLT_AUX.geometryCorrectionAvailable()){
+        	if (DEBUG_LEVEL > 0){
+        		System.out.println("Calculating geometryCorrection for AUX camera");
+        	}
+        	if (!QUAD_CLT_AUX.initGeometryCorrection(DEBUG_LEVEL+2)){
+        		return;
+        	}
+        }
+
+        QUAD_CLT_AUX.processCLTQuads3d(
+        		adjust_extrinsics, // boolean adjust_extrinsics,
+        		adjust_poly,       // boolean adjust_poly,
+        		CLT_PARAMETERS,  // EyesisCorrectionParameters.DCTParameters           dct_parameters,
+        		DEBAYER_PARAMETERS, //EyesisCorrectionParameters.DebayerParameters     debayerParameters,
+        		COLOR_PROC_PARAMETERS, //EyesisCorrectionParameters.ColorProcParameters colorProcParameters,
+        		CHANNEL_GAINS_PARAMETERS_AUX, //CorrectionColorProc.ColorGainsParameters     channelGainParameters,
+        		RGB_PARAMETERS, //EyesisCorrectionParameters.RGBParameters             rgbParameters,
+        		EQUIRECTANGULAR_PARAMETERS, // EyesisCorrectionParameters.EquirectangularParameters equirectangularParameters,
+        		THREADS_MAX, //final int          threadsMax,  // maximal number of threads to launch
+        		UPDATE_STATUS, //final boolean    updateStatus,
+        		DEBUG_LEVEL); //final int        debugLevel);
+
+
         if (configPath!=null) {
         	saveTimestampedProperties( // save config again
         			configPath,      // full path or null
@@ -4502,7 +4582,15 @@ private Panel panel1,
         QuadCLT dbg_QUAD_CLT_AUX = QUAD_CLT_AUX;
 
         return;
-        /* ======================================================================== */
+/* ======================================================================== */
+    } else if (label.equals("Rig enhance")) {
+        DEBUG_LEVEL=MASTER_DEBUG_LEVEL;
+    	EYESIS_CORRECTIONS.setDebug(DEBUG_LEVEL);
+    	enhanceByRig();
+
+    	return;
+
+/* ======================================================================== */
     } else if (label.equals("CLT rig edit")) {
         DEBUG_LEVEL=MASTER_DEBUG_LEVEL;
         if (QUAD_CLT_AUX == null){
@@ -4918,6 +5006,38 @@ private Panel panel1,
 	}
 
 
+	public boolean enhanceByRig() {
+		if (!prepareRigImages()) return false;
+    	String configPath=getSaveCongigPath();
+    	if (configPath.equals("ABORT")) return false;
+
+    	if (DEBUG_LEVEL > -2){
+    		System.out.println("++++++++++++++ Enhancing single-camera DSI by the dual-camera rig++++++++++++++");
+    	}
+    	try {
+    		TWO_QUAD_CLT.enhanceByRig( // actually there is no sense to process multiple image sets. Combine with other processing?
+    				QUAD_CLT, // QuadCLT quadCLT_main,
+    				QUAD_CLT_AUX, // QuadCLT quadCLT_aux,
+    				CLT_PARAMETERS,  // EyesisCorrectionParameters.DCTParameters           dct_parameters,
+    				THREADS_MAX, //final int          threadsMax,  // maximal number of threads to launch
+    				UPDATE_STATUS, //final boolean    updateStatus,
+    				DEBUG_LEVEL);
+    	} catch (Exception e) {
+    		// TODO Auto-generated catch block
+    		e.printStackTrace();
+    	} //final int        debugLevel);
+
+    	if (configPath!=null) {
+    		saveTimestampedProperties( // save config again
+    				configPath,      // full path or null
+    				null, // use as default directory if path==null
+    				true,
+    				PROPERTIES);
+    	}
+    	return true;
+	}
+
+
 	public boolean infinityRig() {
 		if (!prepareRigImages()) return false;
     	String configPath=getSaveCongigPath();

src/main/java/ImageDttParameters.java

@@ -75,9 +75,9 @@ public class ImageDttParameters {
 	public boolean cnvx_add3x3 =            true;  // always select 3x3 cells around integer maximum
 
 	// Used for common interpolated stripes
-	public int     corr_wndy_size =         9;     // number of rows to calculate CM disparity
-	public double  corr_wndy_hwidth =       6.0;   // 50% window cutoff height
-	public double  corr_wndy_blur =         5.0;   // 100% to 0 % vertical transition range
+	public int     corr_wndy_size =         2;   // 9;     // number of rows to calculate CM disparity
+	public double  corr_wndy_hwidth =       1.0; // 6.0;   // 50% window cutoff height
+	public double  corr_wndy_blur =         1.0; // 5.0;   // 100% to 0 % vertical transition range
 	public int     corr_wndx_size =         9;     // half number of columns to calculate CM disparity (each row has only odd/even columns, so disparity range is smaller
 	public double  corr_wndx_hwidth =       6.0;   // 50% window cutoff width
 	public double  corr_wndx_blur =         5.0;   // 100% to 0 % vertical transition range