LY multi-scene

src/main/java/com/elphel/imagej/cameras/CLTParameters.java

@@ -321,6 +321,21 @@ public class CLTParameters {
 	public boolean    lyr_filter_ds =   false;   // true;
 	public boolean    lyr_filter_lyf =  false;   // ~clt_parameters.lyf_filter, but may be different, now off for a single cameras
 
+	// Multi-scene LY parameters
+	// Infinity detection
+	public double     lyms_far_inf =       -0.5;  // Far limit when searching for infinity objects
+	public double     lyms_near_inf =       0.5;  // Near limit when searching for infinity objects
+	public double     lyms_far_fract =      0.05; // Mode of disparity distribution within range
+	public double     lyms_inf_range_offs = 0.05; // Add to the disparity distribution mode for infinity center
+	public double     lyms_inf_range =      0.15; // Consider infinity tiles that are within +/- half of this range from infinity center
+	//non-infinity parameters		
+	public double     lyms_min_inf_str =    0.2;  // Minimal strength of infinity tiles
+	public double     lyms_min_fg_str =     0.4;  // Minimal strength of non-infinity tiles
+	public int        lyms_clust_size =     4;    // cluster size (same in both directions) for measuring LY data
+	public double     lyms_scene_range =   10.0;  // disparity range for non-infinity in the same cluster 
+	public int        lyms_min_num_inf =   10;    // Minimal number of tiles (in all scenes total) in an infinity cluster
+	
+	
 
 	// old fcorr parameters, reuse?
 	// 		public int        fcorr_sample_size = 32;    // Use square this size side to detect outliers
@@ -1243,6 +1258,17 @@ public class CLTParameters {
 		properties.setProperty(prefix+"lyr_filter_ds",              this.lyr_filter_ds +"");
 		properties.setProperty(prefix+"lyr_filter_lyf",             this.lyr_filter_lyf +"");
 		
+		properties.setProperty(prefix+"lyms_far_inf",               this.lyms_far_inf +"");
+		properties.setProperty(prefix+"lyms_near_inf",              this.lyms_near_inf +"");
+		properties.setProperty(prefix+"lyms_far_fract",             this.lyms_far_fract +"");
+		properties.setProperty(prefix+"lyms_inf_range_offs",        this.lyms_inf_range_offs +"");
+		properties.setProperty(prefix+"lyms_inf_range",             this.lyms_inf_range +"");
+		properties.setProperty(prefix+"lyms_min_inf_str",           this.lyms_min_inf_str +"");
+		properties.setProperty(prefix+"lyms_min_fg_str",            this.lyms_min_fg_str +"");
+		properties.setProperty(prefix+"lyms_clust_size",            this.lyms_clust_size +"");
+		properties.setProperty(prefix+"lyms_scene_range",           this.lyms_scene_range +"");
+		properties.setProperty(prefix+"lyms_min_num_inf",           this.lyms_min_num_inf +"");
+
 		properties.setProperty(prefix+"corr_magic_scale",           this.corr_magic_scale +"");
 		properties.setProperty(prefix+"corr_select",                this.corr_select +"");
 
@@ -2073,6 +2099,17 @@ public class CLTParameters {
 		if (properties.getProperty(prefix+"lyr_filter_ds")!=null)                 this.lyr_filter_ds=Boolean.parseBoolean(properties.getProperty(prefix+"lyr_filter_ds"));
 		if (properties.getProperty(prefix+"lyr_filter_lyf")!=null)                this.lyr_filter_lyf=Boolean.parseBoolean(properties.getProperty(prefix+"lyr_filter_lyf"));
 
+		if (properties.getProperty(prefix+"lyms_far_inf")!=null)                  this.lyms_far_inf=Double.parseDouble(properties.getProperty(prefix+"lyms_far_inf"));
+		if (properties.getProperty(prefix+"lyms_near_inf")!=null)                 this.lyms_near_inf=Double.parseDouble(properties.getProperty(prefix+"lyms_near_inf"));
+		if (properties.getProperty(prefix+"lyms_far_fract")!=null)                this.lyms_far_fract=Double.parseDouble(properties.getProperty(prefix+"lyms_far_fract"));
+		if (properties.getProperty(prefix+"lyms_inf_range_offs")!=null)           this.lyms_inf_range_offs=Double.parseDouble(properties.getProperty(prefix+"lyms_inf_range_offs"));
+		if (properties.getProperty(prefix+"lyms_inf_range")!=null)                this.lyms_inf_range=Double.parseDouble(properties.getProperty(prefix+"lyms_inf_range"));
+		if (properties.getProperty(prefix+"lyms_min_inf_str")!=null)              this.lyms_min_inf_str=Double.parseDouble(properties.getProperty(prefix+"lyms_min_inf_str"));
+		if (properties.getProperty(prefix+"lyms_min_fg_str")!=null)               this.lyms_min_fg_str=Double.parseDouble(properties.getProperty(prefix+"lyms_min_fg_str"));
+		if (properties.getProperty(prefix+"lyms_clust_size")!=null)               this.lyms_clust_size=Integer.parseInt(properties.getProperty(prefix+"lyms_clust_size"));
+		if (properties.getProperty(prefix+"lyms_scene_range")!=null)              this.lyms_scene_range=Double.parseDouble(properties.getProperty(prefix+"lyms_scene_range"));
+		if (properties.getProperty(prefix+"lyms_min_num_inf")!=null)              this.lyms_min_num_inf=Integer.parseInt(properties.getProperty(prefix+"lyms_min_num_inf"));
+		
 		if (properties.getProperty(prefix+"corr_magic_scale")!=null)              this.corr_magic_scale=Double.parseDouble(properties.getProperty(prefix+"corr_magic_scale"));
 		if (properties.getProperty(prefix+"corr_select")!=null)                   this.corr_select=Integer.parseInt(properties.getProperty(prefix+"corr_select"));
 
@@ -3006,13 +3043,30 @@ public class CLTParameters {
 		gd.addCheckbox    ("Filter lazy eye pairs by their values wen GT data is available",                    this.lyr_filter_lyf,
 				"Same as \"Filter lazy eye pairs by their values\" above, but for the rig-guided adjustments");
 
-
-		//  			gd.addNumericField("Use square this size side to detect outliers",                                      this.fcorr_sample_size,  0);
-		//  			gd.addNumericField("Keep tiles only if there are more in each square",                                  this.fcorr_mintiles,     0);
-		//  			gd.addNumericField("Remove this fraction of tiles from each sample",                                    this.fcorr_reloutliers,  3);
-		//  			gd.addNumericField("Gaussian blur channel mismatch data",                                               this.fcorr_sigma,        3);
-
-		///  			gd.addNumericField("Calculated from correlation offset vs. actual one (not yet understood)",            this.corr_magic_scale,  3);
+		gd.addTab         ("LY multiscene", "Multiscene series Lazy Eye correction");
+
+		gd.addMessage     ("--- Infinity detection ---");
+		gd.addNumericField("Infinity far",                                                     this.lyms_far_inf,        4,6,"pix",
+				"Far limit when searching for infinity objects");
+		gd.addNumericField("Infinity near",                                                    this.lyms_near_inf,       4,6,"pix",
+				"Near limit when searching for infinity objects");
+		gd.addNumericField("Infinity mode (0.0 - min, 1.0 - max",                              this.lyms_far_fract,      4,6,"",
+				"Mode of disparity distribution within range (0.0 - min, 1.0 - max)");
+		gd.addNumericField("Offset infinity center from mode",                                 this.lyms_inf_range_offs, 4,6,"pix",
+				"Add to the disparity distribution mode for infinity center");
+		gd.addNumericField("Infinity full range",                                              this.lyms_inf_range,      4,6,"pix",
+				"Consider infinity tiles that are within +/- half of this range from infinity center");
+		gd.addMessage     ("--- LY data measurement ---");
+		gd.addNumericField("Minimal strength (infinity)",                                      this.lyms_min_inf_str,    4,6,"",
+				"Minimal strength of infinity tiles");
+		gd.addNumericField("Minimal strength (non-infinity)",                                  this.lyms_min_fg_str,     4,6,"",
+				"Minimal strength of non-infinity tiles");
+		gd.addNumericField("Cluster size",                                                     this.lyms_clust_size,     0,3,"pix",
+				"Cluster size (same in both directions) for measuring LY data");
+		gd.addNumericField("Per-scene disparity range",                                        this.lyms_scene_range,    4,6,"pix",
+				"Disparity range for non-infinity in the same cluster");
+		gd.addNumericField("Minimal number of infinity tiles",                                 this.lyms_min_num_inf,    0,3,"",
+				"Minimal number of tiles (in all scenes total) in an infinity cluster");
 		
 		gd.addTab         ("3D", "3D reconstruction");
 		gd.addMessage     ("--- 3D reconstruction ---");
@@ -3977,12 +4031,16 @@ public class CLTParameters {
 		this.lyr_filter_ds=         gd.getNextBoolean();
 		this.lyr_filter_lyf=        gd.getNextBoolean();
 		
-		//  			          this.fcorr_sample_size= (int)gd.getNextNumber();
-		//  			          this.fcorr_mintiles= (int)  gd.getNextNumber();
-		//  			          this.fcorr_reloutliers=     gd.getNextNumber();
-		//  			          this.fcorr_sigma=           gd.getNextNumber();
-
-		///  			          this.corr_magic_scale=      gd.getNextNumber();
+		this.lyms_far_inf=          gd.getNextNumber();
+		this.lyms_near_inf=         gd.getNextNumber();
+		this.lyms_far_fract=        gd.getNextNumber();
+		this.lyms_inf_range_offs=   gd.getNextNumber();
+		this.lyms_inf_range=        gd.getNextNumber();
+		this.lyms_min_inf_str=      gd.getNextNumber();
+		this.lyms_min_fg_str=       gd.getNextNumber();
+		this.lyms_clust_size= (int) gd.getNextNumber();
+		this.lyms_scene_range=      gd.getNextNumber();
+		this.lyms_min_num_inf=(int) gd.getNextNumber();
 
 		this.show_textures=         gd.getNextBoolean();
 		this.debug_filters=         gd.getNextBoolean();

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

@@ -8950,6 +8950,64 @@ public class ImageDttCPU {
 		return corr2d_decimated;
 	}
 
+	public static double [][] corr2d_decimate( // not used in lwir
+			final double [][]        corr2d_img,
+			final int               tilesX,
+			final int               tilesY,
+			final int               clust_size,
+			final int []            wh, 
+			final int               threadsMax,     // maximal number of threads to launch
+			final int               globalDebugLevel) {
+		int len = 0;
+		final double [][] corr2d_decimated = new double [corr2d_img.length][];
+		for (int i = 0; i < corr2d_img.length; i++) {
+			if (corr2d_img[i] != null) {
+				len = corr2d_img[i].length;
+				break;
+			}
+		}
+		final int tile_size = (int) Math.round(Math.sqrt(len/(tilesX * tilesY)));
+		final int clustersX = (int) Math.ceil(1.0 * tilesX / clust_size);
+		final int clustersY = (int) Math.ceil(1.0 * tilesY / clust_size);
+		final int clusters =  clustersX * clustersY;
+		final Thread[] threads = newThreadArray(threadsMax);
+		final AtomicInteger ai = new AtomicInteger(0);
+		final int clust_lines = clust_size * tile_size;
+		final int in_line_len =  clustersX * clust_size * tile_size;
+		final int out_line_len = clustersX * tile_size;
+		if (wh != null) {
+			wh[0] = clustersX * tile_size;
+			wh[1] = clustersY * tile_size;
+		}
+
+		for (int ithread = 0; ithread < threads.length; ithread++) {
+			threads[ithread] = new Thread() {
+				@Override
+				public void run() {
+					for (int nLayer = ai.getAndIncrement(); nLayer < corr2d_img.length; nLayer = ai.getAndIncrement()) {
+						if (corr2d_img[nLayer] != null){
+							corr2d_decimated[nLayer] = new double [clusters * tile_size * tile_size];
+							for (int clustY = 0; clustY < clustersY; clustY++) {
+								for (int clustX = 0; clustX < clustersX; clustX++) {
+									int offs = clustY * clust_lines * in_line_len; 
+									for (int line = 0; line < tile_size; line++) {
+										System.arraycopy(
+												corr2d_img[nLayer],
+												(clustY * clust_lines + line) * in_line_len + clustX * clust_lines,
+												corr2d_decimated[nLayer],
+												(clustY * tile_size + line) * out_line_len + clustX * tile_size,
+												tile_size);
+									}
+								}
+							}
+						}
+					}
+				}
+			};
+		}
+		startAndJoin(threads);
+		return corr2d_decimated;
+	}
 	
 	
 	

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

@@ -281,10 +281,12 @@ public class MultisceneLY {
 			final int          clust_size,
 			final double       inf_range,     // full range centered at inf_disp_ref to be used as infinity
 			final double       scene_range,   // disparity range for non-infinity in the same cluster
+			final int          min_num_inf,   // Minimal number of tiles (in all scenes total) in an infinity cluster
 			final QuadCLT []   scenes,        // ordered by increasing timestamps
 			final boolean [][] valid_tile,    // tile with lma and single correlation maximum
 			final double       inf_disp_ref,  // average disparity at infinity for ref scene
-			final boolean [][] is_infinity,   // may be null, if not - may be infinity from the composite depth map
+			final boolean [][] is_infinity,   // may be null (all non-infinity), if not - may be infinity from the composite depth map
+			final boolean      only_infinity, // do not process non-infinity
 			int []             in_num_tiles,     // null or array of number of clusters
 			boolean []         in_inf_cluster,   // null or array of number of clusters, will return if cluster uses only infinite tiles
 			final int          threadsMax,
@@ -303,6 +305,10 @@ public class MultisceneLY {
 		
 		final int []     num_tiles =   (in_num_tiles != null)?   in_num_tiles :   (new int [clusters]);
 		final boolean [] inf_cluster = (in_inf_cluster != null)? in_inf_cluster : (new boolean [clusters]);
+		Arrays.fill(num_tiles, 0);
+		Arrays.fill(inf_cluster, false);
+		
+		final int [] num_inf_cluster = new int[clusters];
 		for (int nscene = 0; nscene < num_scenes; nscene++) {
 			target_disparities[nscene] = scenes[nscene].getDSRBG()[0];
 			Arrays.fill(rslt_disparities[nscene], Double.NaN);
@@ -314,7 +320,7 @@ public class MultisceneLY {
 			for (int ithread = 0; ithread < threads.length; ithread++) {
 				threads[ithread] = new Thread() {
 					public void run() {
-						Cluster:
+//						Cluster:
 						for (int nClust = ai.getAndIncrement(); nClust < clusters; nClust = ai.getAndIncrement()) {
 							int clustX = nClust % clustersX;
 							int clustY = nClust / clustersX;
@@ -329,20 +335,36 @@ public class MultisceneLY {
 												if (is_infinity[nscene][nTile] &&
 														valid_tile[nscene][nTile] && // next may be NaN
 														(Math.abs(target_disparities[nscene][nTile] - inf_disp_ref) <= inf_hrange)) {
-													inf_cluster[nClust] = true;
-													continue Cluster;
+													num_inf_cluster[nClust]++;
+//													inf_cluster[nClust] = true;
+//													continue Cluster;
+												}
+											}
 										}
 									}
 								}
 							}
 						}
 					}
+				};
+			}		      
+			ImageDtt.startAndJoin(threads);
+			ai.set(0);
+			// mark clusters as infinity if they have enough infinity tiles
+			for (int ithread = 0; ithread < threads.length; ithread++) {
+				threads[ithread] = new Thread() {
+					public void run() {
+						for (int nClust = ai.getAndIncrement(); nClust < clusters; nClust = ai.getAndIncrement()) {
+							if (num_inf_cluster[nClust] >= min_num_inf) {
+								inf_cluster[nClust] = true;
+							}
 						}
 					}
 				};
 			}		      
 			ImageDtt.startAndJoin(threads);
 			
+			
 			// Mark suitable infinity tiles (they are NaN now)
 			ai.set(0);
 			for (int ithread = 0; ithread < threads.length; ithread++) {
@@ -378,6 +400,7 @@ public class MultisceneLY {
 			ImageDtt.startAndJoin(threads);
 		}
 		
+		if (!only_infinity) {
 			ai.set(0);
 			for (int ithread = 0; ithread < threads.length; ithread++) {
 				threads[ithread] = new Thread() {
@@ -387,7 +410,7 @@ public class MultisceneLY {
 						for (int nClust = ai.getAndIncrement(); nClust < clusters; nClust = ai.getAndIncrement()) if (!inf_cluster[nClust]){
 							int clustX = nClust % clustersX;
 							int clustY = nClust / clustersX;
-//						int num_tot = 0;
+							//						int num_tot = 0;
 							for (int nscene = 0; nscene < num_scenes; nscene++) {
 								Arrays.fill(clust_disp,Double.NaN);
 								double sum_disp = 0;
@@ -454,15 +477,119 @@ public class MultisceneLY {
 				};
 			}		      
 			ImageDtt.startAndJoin(threads);
+		}
 		return rslt_disparities;
 	}
 
+	public static double [][][] getLYDataInfNoinf(
+			final CLTParameters  clt_parameters,
+			final int            clust_size,
+			final double         inf_range,         // full range centered at inf_disp_ref to be used as infinity
+			final double         scene_range,       // disparity range for non-infinity in the same cluster
+			final int            min_num_inf,       // Minimal number of tiles (in all scenes total) in an infinity cluster
+			final QuadCLT []     scenes,            // ordered by increasing timestamps
+			final boolean [][]   valid_tile,        // tile with lma and single correlation maximum
+			final double         inf_disp_ref,      // average disparity at infinity for ref scene // is_scene_infinity
+			final boolean [][]   is_scene_infinity, // may be null, if not - may be infinity from the composite depth map
+			final double  [][][] target_disparities,
+			final double         dbg_disparity_offset,
+			final int [][]       in_num_tiles,     // null or number of tiles per cluster to multiply strength
+			final int            threadsMax,
+			final int            debug_level){
+		final double [][][] inf_noinf_lazy_eye_data = new double [2][][];
+		int last_scene_index = scenes.length-1;
+		QuadCLT last_scene = scenes[last_scene_index];
+		int tilesX = last_scene.tp.getTilesX();
+		int tilesY = last_scene.tp.getTilesY();
+		int clustersX = (int) Math.ceil(1.0 * tilesX / clust_size);
+		int clustersY = (int) Math.ceil(1.0 * tilesY / clust_size);
+		int clusters = clustersX * clustersY;
+		final int [][]     num_tiles =   (in_num_tiles != null)?   in_num_tiles :   (new int [2][]);
+		for (int i = 0; i < num_tiles.length; i++) {
+			num_tiles[i] = new int [clusters];
+		}
+//		int [][]     num_tiles =    new int [2][clusters]; // may be null;; // null;
+		boolean [] inf_cluster  = new boolean [clusters]; // null;		
+		boolean       debug      = debug_level > -3;
+		// get for infinity only
+		double [][] target_disparities_inf = MultisceneLY.useTilesLY(
+				clust_size,    // final int          clust_size,
+				inf_range,     // final double       inf_range,     // full range centered at inf_disp_ref to be used as infinity
+				scene_range,   // final double       scene_range,   // disparity range for non-infinity in the same cluster
+				min_num_inf,   // final int          min_num_inf,   // Minimal number of tiles (in all scenes total) in an infinity cluster
+				scenes,        // final QuadCLT []   scenes,        // ordered by increasing timestamps
+				valid_tile,    // final boolean [][] valid_tile,    // tile with lma and single correlation maximum
+				inf_disp_ref,  // final double       inf_disp_ref,  // average disparity at infinity for ref scene // is_scene_infinity
+				is_scene_infinity, // final boolean [][] is_infinity,   // may be null, if not - may be infinity from the composite depth map
+				true,          // final boolean      only_infinity, // do not process non-infinity
+				num_tiles[0],  // int []             in_num_tiles,     // null or array of number of clusters
+				inf_cluster,   // boolean []         in_inf_cluster,   // null or array of number of clusters, will return if cluster uses only infinite tiles
+				threadsMax,    // final int          threadsMax,
+				debug);        // final boolean      debug)
+		
+		if (dbg_disparity_offset != 0.0) {
+			for (int nscene = 0; nscene < target_disparities_inf.length; nscene++) {
+				for (int i = 0; i < target_disparities_inf[nscene].length; i++) {
+					if (!Double.isNaN(target_disparities_inf[nscene][i])) {
+						target_disparities_inf[nscene][i] += dbg_disparity_offset;
+					}
+				}
+			}
+		}
+		
+		inf_noinf_lazy_eye_data[0] = 	MultisceneLY.getLYData( // TODO: show lazy_eye_data[][]
+				clt_parameters,         // final CLTParameters  clt_parameters,
+				clust_size,             // final int            clust_size,
+				scenes,                 // final QuadCLT []     scenes,        // ordered by increasing timestamps
+				target_disparities_inf, // final double[][]     target_disparities,
+				num_tiles[0],              // final int []         num_tiles,
+				threadsMax,             // final int            threadsMax,
+				debug_level);           // final int            debug_level);
+		// now for non-infinity:
+		double [][] target_disparities_noinf = MultisceneLY.useTilesLY(
+				clust_size,    // final int          clust_size,
+				inf_range,     // final double       inf_range,     // full range centered at inf_disp_ref to be used as infinity
+				scene_range,   // final double       scene_range,   // disparity range for non-infinity in the same cluster
+				min_num_inf,   // final int          min_num_inf,   // Minimal number of tiles (in all scenes total) in an infinity cluster
+				scenes,        // final QuadCLT []   scenes,        // ordered by increasing timestamps
+				valid_tile,    // final boolean [][] valid_tile,    // tile with lma and single correlation maximum
+				inf_disp_ref,  // final double       inf_disp_ref,  // average disparity at infinity for ref scene // is_scene_infinity
+				null,          // final boolean [][] is_infinity,   // may be null, if not - may be infinity from the composite depth map
+				false,         // final boolean      only_infinity, // do not process non-infinity
+				num_tiles[1],  // int []             in_num_tiles,     // null or array of number of clusters
+				inf_cluster,   // boolean []         in_inf_cluster,   // null or array of number of clusters, will return if cluster uses only infinite tiles
+				threadsMax,    // final int          threadsMax,
+				debug);        // final boolean      debug)
+		if (dbg_disparity_offset != 0.0) {
+			for (int nscene = 0; nscene < target_disparities_noinf.length; nscene++) {
+				for (int i = 0; i < target_disparities_noinf[nscene].length; i++) {
+					if (!Double.isNaN(target_disparities_noinf[nscene][i])) {
+						target_disparities_noinf[nscene][i] += dbg_disparity_offset;
+					}
+				}
+			}
+		}
+		inf_noinf_lazy_eye_data[1] = 	MultisceneLY.getLYData( // TODO: show lazy_eye_data[][]
+				clt_parameters,           // final CLTParameters  clt_parameters,
+				clust_size,               // final int            clust_size,
+				scenes,                   // final QuadCLT []     scenes,        // ordered by increasing timestamps
+				target_disparities_noinf, // final double[][]     target_disparities,
+				num_tiles[1],                // final int []         num_tiles,
+				threadsMax,               // final int            threadsMax,
+				debug_level);             // final int            debug_level);
+		if (target_disparities != null) {
+			target_disparities[0] = target_disparities_inf;
+			target_disparities[1] = target_disparities_noinf;
+		}
+		return inf_noinf_lazy_eye_data;
+	}	
+	
 	public static double [][] getLYData(
 			final CLTParameters  clt_parameters,
 			final int            clust_size,
 			final QuadCLT []     scenes,        // ordered by increasing timestamps
 			final double[][]     target_disparities,
-			final int []         num_tiles,
+			final int []         num_tiles, // null or number of tiles per cluster to multiply strength
 			final int            threadsMax,
 			final int            debug_level){
 		int last_scene_index = scenes.length-1;
@@ -700,6 +827,24 @@ public class MultisceneLY {
 						true,
 						last_scene.getImageName()+"-CORR-DECIMATED"+clust_size,
 						titles);
+				double [][] disparity_map_decimated = ImageDtt.corr2d_decimate( // not used in lwir
+						disparity_map,  // final float [][]        corr2d_img,
+						tilesX,        // final int               tilesX,
+						tilesY,        // final int               tilesY,
+						clust_size,    // final int               clust_size,
+						wh,            // final int []            wh, 
+						threadsMax,    // final int               threadsMax,     // maximal number of threads to launch
+						debug_level);  // final int               globalDebugLevel)
+				
+				(new ShowDoubleFloatArrays()).showArrays(
+						disparity_map_decimated,
+						wh[0],
+						wh[1],
+						true,
+						"disparity_map_decimated",
+						ImageDtt.getDisparityTitles(last_scene.getNumSensors(),last_scene.isMonochrome()) // ImageDtt.DISPARITY_TITLES
+						);
+				
 			}
 			
 			final double [][] rXY = last_scene.getErsCorrection().getRXY(false);
@@ -719,7 +864,9 @@ public class MultisceneLY {
 								lazy_eye_data[nClust] = new double [ExtrinsicAdjustment.get_INDX_LENGTH(numSens)];
 								// Number of tiles, strength or a product
 								double strength = disparity_map[ImageDtt.DISPARITY_INDEX_POLY + 1][nTile0];
-								
+								if (num_tiles != null) {
+									strength *= num_tiles[nClust];
+								}
 								lazy_eye_data[nClust][ExtrinsicAdjustment.INDX_STRENGTH] = strength;
 								lazy_eye_data[nClust][ExtrinsicAdjustment.INDX_TARGET] = combo_pXpYD[nTile0][2];
 								lazy_eye_data[nClust][ExtrinsicAdjustment.INDX_DIFF] =   disparity_map[ImageDtt.DISPARITY_INDEX_POLY][nTile0];

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

@@ -11147,11 +11147,24 @@ if (debugLevel > -100) return true; // temporarily !
 					threadsMax,     // int            threadsMax,  // maximal number of threads to launch
 					updateStatus,   // boolean        updateStatus,
 					debugLevel);    // int            debugLevel)
-///			quadCLTs[i].showDSIMain();
 		}
-//		int     ref_index = quadCLTs.length-1; // last scene
 		boolean proc_infinity = true; 
-//		QuadCLT ref_scene = quadCLTs[ref_index];
+		boolean lma_only = true; // use clt_parameters
+		double        dbg_disparity_offset = 0.0; // 0.1
+		double        inf_disp_ref =   0.0;
+/*		
+		double        far_inf =       -0.5; //
+		double        near_inf =       0.5; //
+		double        far_fract =      0.05; //
+		double        inf_range_offs = 0.05; // 
+		double        inf_range =      0.15; // 
+		double        min_inf_str =    0.2;  //
+		double        min_fg_str =     0.4;  //
+// non-infinity parameters		
+		int           clust_size =     4;
+		double        scene_range =   10.0;    // disparity range for non-infinity in the same cluster 
+		int           min_num_inf =   10;      // Minimal number of tiles (in all scenes total) in an infinity cluster
+*/
 		int last_scene_index = quadCLTs.length-1;
 		QuadCLT last_scene = quadCLTs[last_scene_index];
         String composite_suffix =    "-INTER-INTRA-LMA";
@@ -11162,36 +11175,23 @@ if (debugLevel > -100) return true; // temporarily !
     			0,                // int         num_slices, // (0 - all)
     			wh);              // int []      wh)
 		// composite_ds == null if no file
-		boolean lma_only = true; // use clt_parameters
 		
 		MultisceneLY multisceneLY = new MultisceneLY (
 				quadCLTs[0].getNumSensors(),
 				threadsMax,                                // int            threadsMax,  // maximal number of threads to launch
 				updateStatus);                             // boolean        updateStatus);
-/*	String [] combo_dsn_titles_full = {"disp", "strength","disp_lma","num_valid","change",
-				"disp_bg", "strength_bg","disp_lma_bg","change_bg","disp_fg","disp_bg_all"}; */
 	    // read interscene composite data
 		boolean [][] is_scene_infinity = null; // per scene, per tile - is infinity.
-		double        far_inf =       -0.5; //
-		double        near_inf =       0.5; //
-		double        far_fract =      0.05; //
-		double        inf_range_offs = 0.05; // 
-		double        inf_range =      0.15; // 
-		double        min_inf_str =    0.2;  //
-		double        min_fg_str =     0.4;  //
-// non-infinity parameters		
-		int           clust_size =     4;
-		double        inf_range2 =     0.5;     // full range centered at inf_disp_ref to be used as infinity
-		double        scene_range =   10.0;    // disparity range for non-infinity in the same cluster 
-		double        inf_disp_ref = 0.0;
+
+		
 
 		int tilesX = last_scene.tp.getTilesX();
 		int tilesY = last_scene.tp.getTilesY();
-		int clustersX = (int) Math.ceil(1.0 * tilesX / clust_size);
-		int clustersY = (int) Math.ceil(1.0 * tilesY / clust_size);
+		int clustersX = (int) Math.ceil(1.0 * tilesX / clt_parameters.lyms_clust_size);
+		int clustersY = (int) Math.ceil(1.0 * tilesY / clt_parameters.lyms_clust_size);
 		int clusters = clustersX * clustersY;
-		int []     num_tiles =    null;
-		boolean [] inf_cluster  = null;		
+//		int []     num_tiles =    new int [clusters]; // may be null;; // null;
+//		boolean [] inf_cluster  = new boolean [clusters]; // null;		
 		
 		boolean       debug      = debugLevel > -3; 
 		
@@ -11200,28 +11200,26 @@ if (debugLevel > -100) return true; // temporarily !
 			boolean [] ref_inf = MultisceneLY.getComboInfinity(
 					last_scene.tp,   // TileProcessor tp,
 					composite_ds,   // double [][]   composite_ds,
-					far_inf,        // double        far_inf,
-					near_inf,       // double        near_inf,
-					far_fract,      // double        far_fract,
-					inf_range_offs, // double        inf_range_offs,
-					inf_range,      // double        inf_range,
-					min_inf_str,    // double        min_inf_str,
-					min_fg_str,     // double        min_fg_str,
+					clt_parameters.lyms_far_inf,        // double        far_inf,
+					clt_parameters.lyms_near_inf,       // double        near_inf,
+					clt_parameters.lyms_far_fract,      // double        far_fract,
+					clt_parameters.lyms_inf_range_offs, // double        inf_range_offs,
+					clt_parameters.lyms_inf_range,      // double        inf_range,
+					clt_parameters.lyms_min_inf_str,    // double        min_inf_str,
+					clt_parameters.lyms_min_fg_str,     // double        min_fg_str,
 					inf_avg,        // double []     inf_avg,
 					debug);         // boolean       debug)
 			
 			is_scene_infinity =  MultisceneLY.infinityPerScene(
 		            quadCLTs,    // QuadCLT [] scenes,
-//		            ref_index,   // int        indx_ref,
 		            inf_avg[0],  // double     inf_disp_ref, // average disparity at infinity for ref scene
 		            ref_inf,     // boolean [] infinity_ref,
 		            debug,       // boolean    debug,
 		            threadsMax); // int        threadsMax)
 			inf_disp_ref = inf_avg[0];
-			num_tiles =    new int [clusters]; // may be null;
-			inf_cluster  = new boolean [clusters]; // may be null;
 		}
-		
+		// Read or generate+save number of correlation maximums per scene, per tile
+		// Will use only tiles with one and only one correlation maximum 
 		int [][] numCorrMax = new int [quadCLTs.length][]; // -> 
 		double [][] dNumCorrMax =last_scene.readDoubleArrayFromModelDirectory(
 				num_corr_max_suffix, // String      suffix,
@@ -11257,35 +11255,34 @@ if (debugLevel > -100) return true; // temporarily !
 					last_scene.tp.getTilesX(),                // int         width,
 					last_scene.tp.getTilesY());               // int         height)
 		}
+		// valid tile - one and only one maximum
 		boolean [][] valid_tile = new boolean[numCorrMax.length][numCorrMax[0].length];
 		for (int nscene = 0; nscene < numCorrMax.length; nscene++) {
 			for (int nTile = 0; nTile < numCorrMax[nscene].length; nTile++) {
 				valid_tile[nscene][nTile] = numCorrMax[nscene][nTile] == 1; // only single-maximum
 			}
 		}
-		double [][] target_disparities = MultisceneLY.useTilesLY(
-				clust_size,    // final int          clust_size,
-				inf_range,     // final double       inf_range,     // full range centered at inf_disp_ref to be used as infinity
-				scene_range,   // final double       scene_range,   // disparity range for non-infinity in the same cluster 
-				quadCLTs,      // final QuadCLT []   scenes,        // ordered by increasing timestamps
-				valid_tile,    // final boolean [][] valid_tile,    // tile with lma and single correlation maximum
-				inf_disp_ref,  // final double       inf_disp_ref,  // average disparity at infinity for ref scene // is_scene_infinity
-				is_scene_infinity, // final boolean [][] is_infinity,   // may be null, if not - may be infinity from the composite depth map
-				num_tiles,     //int []             in_num_tiles,     // null or array of number of clusters
-				inf_cluster,   //boolean []         in_inf_cluster,   // null or array of number of clusters, will return if cluster uses only infinite tiles
-				threadsMax,    // final int          threadsMax,
-				debug);        // final boolean      debug)
 
-		double [][] lazy_eye_data = 	MultisceneLY.getLYData( // TODO: show lazy_eye_data[][]
+		int [][] num_tiles2 = new int[2][];
+		double [][][] target_disparities = new double [2][][]; 
+		double [][][] lazy_eye_data = 	MultisceneLY.getLYDataInfNoinf(
 				clt_parameters,       // final CLTParameters  clt_parameters,
-				clust_size,         // final int            clust_size,
+				clt_parameters.lyms_clust_size,           // final int            clust_size,
+				clt_parameters.lyms_inf_range,            // final double         inf_range,         // full range centered at inf_disp_ref to be used as infinity
+				clt_parameters.lyms_scene_range,          // final double         scene_range,       // disparity range for non-infinity in the same cluster
+				clt_parameters.lyms_min_num_inf,          // final int            min_num_inf,       // Minimal number of tiles (in all scenes total) in an infinity cluster
 				quadCLTs,             // final QuadCLT []     scenes,            // ordered by increasing timestamps
+				valid_tile,           // final boolean [][]   valid_tile,        // tile with lma and single correlation maximum
+				inf_disp_ref,         // final double         inf_disp_ref,      // average disparity at infinity for ref scene // is_scene_infinity
+				is_scene_infinity,    // final boolean [][]   is_scene_infinity, // may be null, if not - may be infinity from the composite depth map
 				target_disparities,   // final double[][]     target_disparities,
-				num_tiles,          // final int []         num_tiles,
+				dbg_disparity_offset, // final double         dbg_disparity_offset,
+				num_tiles2,           // final int [][]       in_num_tiles,     // null or number of tiles per cluster to multiply strength
 				threadsMax,           // final int            threadsMax,
 				debugLevel);          // final int            debug_level);
 		
-		if (debugLevel > -4) {
+		// debug images
+		if (debugLevel > -3) {
 			double [][] dbg_numCorrMax = new double[numCorrMax.length][];
 			for (int i = 0; i < dbg_numCorrMax.length; i++) {
 				dbg_numCorrMax[i] = new double[numCorrMax[i].length];
@@ -11299,48 +11296,20 @@ if (debugLevel > -100) return true; // temporarily !
 					tilesY,
 					true,
 					"numCorrMax");
-			(new ShowDoubleFloatArrays()).showArrays(
-					target_disparities,
-					tilesX,
-					tilesY,
-					true,
-					"target_disparities");
-			if ((num_tiles != null) || (inf_cluster!= null)) {
-				double [][] dbg_num_tiles = new double[4][]; 
-				if (num_tiles != null) {
-					dbg_num_tiles[0] = new double [clusters];
-					for (int nClust = 0; nClust < clusters; nClust++) {
-						dbg_num_tiles[0][nClust] = num_tiles[nClust];
-					}
-				}
-				if (inf_cluster != null) {
-					dbg_num_tiles[1] = new double [clusters];
-					for (int nClust = 0; nClust < clusters; nClust++) {
-						dbg_num_tiles[1][nClust] = inf_cluster[nClust]?1.0:0.0;
-					}
-				}
-
-				if ((num_tiles != null) && (inf_cluster!= null)) {
-					dbg_num_tiles[2] = new double [clusters];
-					dbg_num_tiles[3] = new double [clusters];
-					Arrays.fill(dbg_num_tiles[2], Double.NaN);
-					Arrays.fill(dbg_num_tiles[3], Double.NaN);
+			double [][] dbg_num_tiles = new double[2][]; 
+			for (int i = 0; i < num_tiles2.length; i++ ) {
+				dbg_num_tiles[i] = new double [clusters];
 				for (int nClust = 0; nClust < clusters; nClust++) {
-						if (inf_cluster[nClust]){
-							dbg_num_tiles[2][nClust] = num_tiles[nClust];
-						} else {
-							dbg_num_tiles[3][nClust] = num_tiles[nClust];
+					dbg_num_tiles[i][nClust] = num_tiles2[i][nClust];
 				}
 			}
-				}
-
 			(new ShowDoubleFloatArrays()).showArrays(
 					dbg_num_tiles,
 					clustersX,
 					clustersY,
 					true,
-						"clusters_num_inf",
-						new String[] {"tiles","is_inf", "inf tiles", "fg tiles"});
+					"clusters_num_inf_boinf",
+					new String[] {"inf tiles", "noinf tiles"});
 
 		
 			if (lazy_eye_data != null) {
@@ -11349,53 +11318,33 @@ if (debugLevel > -100) return true; // temporarily !
 						clt_parameters.tileStep, // int         clusterSize,
 						clustersX,               // int         clustersX,
 						clustersY);              // int         clustersY)
-
-					double [][] dbg_cluster = new double [ExtrinsicAdjustment.get_INDX_LENGTH(last_scene.getNumSensors())][clustersY * clustersX];
+				double [][][] dbg_cluster = new double [lazy_eye_data.length][ExtrinsicAdjustment.get_INDX_LENGTH(last_scene.getNumSensors())][clustersY * clustersX];
+				for (int m = 0; m < lazy_eye_data.length; m++) {
 					for (int i = 0; i < dbg_cluster.length; i++) {
-						Arrays.fill(dbg_cluster[i], Double.NaN);
+						Arrays.fill(dbg_cluster[m][i], Double.NaN);
 					}
-					for (int n = 0; n < lazy_eye_data.length; n++) {
-						if (lazy_eye_data[n] != null) {
+					for (int n = 0; n < lazy_eye_data[m].length; n++) {
+						if (lazy_eye_data[m][n] != null) {
 							for (int i = 0; i < ExtrinsicAdjustment.get_INDX_LENGTH(last_scene.getNumSensors()); i++ ) {
-								dbg_cluster[i][n] = lazy_eye_data[n][i];
+								dbg_cluster[m][i][n] = lazy_eye_data[m][n][i];
+							}
 						}
 					}
 				}
+				for (int m = 0; m < lazy_eye_data.length; m++) {
 					(new ShowDoubleFloatArrays()).showArrays(
-							  dbg_cluster,
+							dbg_cluster[m],
 							clustersX,
 							clustersY,
 							true,
-							  last_scene.getImageName()+"-lazy_eye_data",
+							last_scene.getImageName()+"-lazy_eye_data-"+m,
 							ea_dbg.data_titles); //  ExtrinsicAdjustment.DATA_TITLES);
 				}
 			}
 		}
-		
-		if (debugLevel > -100) {
-			return;
+		if (debugLevel > -3) {
+			System.out.println("adjustLYSeries() Done");
 		}
-		/* 
-        String composite_suffix = "-INTER-INTRA-LMA";
-        int [] wh = new int[2];
-        double [][] composite_ds = ref_scene.readDoubleArrayFromModelDirectory(
-        		composite_suffix, // String      suffix,
-    			0,                // int         num_slices, // (0 - all)
-    			wh);              // int []      wh)
-		 * */
-		
-		OpticalFlow opticalFlow = new OpticalFlow(
-				quadCLT_main.getNumSensors(),
-				clt_parameters.ofp.scale_no_lma_disparity, // double         scale_no_lma_disparity,
-				threadsMax,                                // int            threadsMax,  // maximal number of threads to launch
-				updateStatus);                             // boolean        updateStatus);
-		
-		opticalFlow.adjustPairsDualPass(
-				clt_parameters, // CLTParameters  clt_parameters,			
-				clt_parameters.ofp.k_prev, // k_prev,
-				quadCLTs, // QuadCLT [] scenes, // ordered by increasing timestamps
-				clt_parameters.ofp.debug_level_optical); // 1); // -1); // int debug_level);
-		/* */
 
 		System.out.println("End of adjustLYSeries()");
 	}