global target disparities

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

@@ -4560,7 +4560,8 @@ public class CuasMotion {
 			ImagePlus imp_extended= showTargetSequence(
 					extended_targets,    // double [][][] target_scene_sequence,
 					slice_titles,         // String []     titles, // all slices*frames titles or just slice titles or null
-					model_prefix+"-EXTENDED-TORENDER",   // String        title,
+//					model_prefix+"-EXTENDED-TORENDER",   // String        title,
+					parentCLT.getImageName()+getParametersSuffixRslt(clt_parameters,"-EXTENDED-TORENDER"),					
 					!batch_mode,    // boolean       show,
 					cuasMotion.tilesX);   //  int           tilesX) {
 			parentCLT.saveImagePlusInModelDirectory(imp_extended);
@@ -4585,7 +4586,9 @@ public class CuasMotion {
 				fpixels_accumulated5x5, // float[][] pixels,
 				cuasMotion.gpu_max_width, // int width,
 				cuasMotion.gpu_max_height, // int height,
-				model_prefix+"-ACCUMULATED"+(center_targ?"-CENTERED":""), //String title,
+//				model_prefix+"-ACCUMULATED"+(center_targ?"-CENTERED":""), //String title,
+				parentCLT.getImageName()+getParametersSuffixRslt(clt_parameters,"-ACCUMULATED"+(center_targ?"-CENTERED":"")),					
+				
 				slice_titles); //String [] titles)
 		imp_accumulated5x5.getProcessor().setMinAndMax(-input_range/2, input_range/2);
 		if (intermed_high) {
@@ -4635,7 +4638,8 @@ public class CuasMotion {
 					replaced_targets, // float[][] pixels,
 					cuasMotion.gpu_max_width, // int width,
 					cuasMotion.gpu_max_height, // int height,
-					model_prefix+"-REPLACED-TARGETS"+(ra_background? "-RABG":""), //String title,
+//					model_prefix+"-REPLACED-TARGETS"+(ra_background? "-RABG":""), //String title,
+					parentCLT.getImageName()+getParametersSuffixRslt(clt_parameters,"-REPLACED-TARGETS"+(ra_background? "-RABG":"")),					
 					scene_titles); //String [] titles)
 			imp_replaced_targets.getProcessor().setMinAndMax(-input_range/2, input_range/2);			
 			if (!batch_mode) {
@@ -4665,7 +4669,8 @@ public class CuasMotion {
 				frame0,                     // final int           frame0,
 				corr_inc,                   // final int           frame_step,
 				cuasMotion.gpu_max_width,   // final int           width,
-				model_prefix+"-RGB"+ra_bg_suffix+clean_suffix, // String              title,
+//				model_prefix+"-RGB"+ra_bg_suffix+clean_suffix, // String              title,
+				parentCLT.getImageName()+getParametersSuffixRslt(clt_parameters,"-RGB"+ra_bg_suffix+clean_suffix),
 				scene_titles,               // String []           titles,
 				uasLogReader,               // UasLogReader           uasLogReader,				
 				debugLevel);                // final int           debugLevel) {
@@ -6321,6 +6326,7 @@ public class CuasMotion {
 		}
 		boolean debug_tum= true; // false;
 		String model_prefix = parentCLT.getImageName()+getParametersSuffix(clt_parameters,null)+(cuasMotion.slow_targets? "-SLOW":"-FAST");
+		
 		float [][] fpixels_tum = fpixels;
 		if (temporal_um > 0) {
 			if (intermed_high && debug_tum) {

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

@@ -66,32 +66,34 @@ public class CuasMotionLMA {
 	public static final int RSLT_MISMATCH_BEFORE = 24;
 	public static final int RSLT_MISMATCH_AFTER =  25; // RSLT_MISMATCH_BEFORE+1;
 	public static final int RSLT_MISMATCH_DIRS=    26;
-	public static final int RSLT_MATCH_LENGTH=     27; 
+	public static final int RSLT_MATCH_LENGTH=     27; // is one less than the total length (0 - isolated)
 	public static final int RSLT_BEFORE_LENGTH=    28; // just for debug
 	public static final int RSLT_AFTER_LENGTH=     29; // just for debug
 	public static final int RSLT_SEQ_TRAVEL=       30; 
-	
-	// [RSLT_MATCH_LENGTH] is one less than the total length (0 - isolated)
 	public static final int RSLT_MSCORE =          31;
-
 	public static final int RSLT_QA =              32;
 	public static final int RSLT_QRMS =            33;
 	public static final int RSLT_QRMS_A =          34;
 	public static final int RSLT_QCENTER =         35;
 	public static final int RSLT_QMATCH =          36;
-	public static final int RSLT_QMATCH_LEN=37;
+	public static final int RSLT_QMATCH_LEN=       37;
 	public static final int RSLT_QTRAVEL=          38;
 	public static final int RSLT_QSCORE =          39;
-	public static final int RSLT_STRONGER =40; // index of stronger neighbor (may be more)
+	public static final int RSLT_STRONGER =        40; // index of stronger neighbor (may be more)
 	public static final int RSLT_SLOW =            41; // 1 - slow, 0 - fast 
 	public static final int RSLT_WHEN =            42;
 	public static final int RSLT_FAIL =            43;
-	public static final int RSLT_DISPARITY=44;
-	public static final int RSLT_DISP_DIFF=45;
-	public static final int RSLT_DISP_STR =46;
+	public static final int RSLT_DISPARITY=        44;
+	public static final int RSLT_DISP_DIFF=        45;
+	public static final int RSLT_DISP_STR =        46;
 	public static final int RSLT_RANGE =           47;
 	public static final int RSLT_GLOBAL =          48;
-	public static final int RSLT_LEN = RSLT_GLOBAL+1;
+	public static final int RSLT_GLENGTH =         49;
+	public static final int RSLT_GDISPARITY=       50;
+	public static final int RSLT_GDISP_DIFF=       51;
+	public static final int RSLT_GDISP_STR =       52;
+	public static final int RSLT_GRANGE =          53;
+	public static final int RSLT_LEN = RSLT_GRANGE+1;
 	
 	public static final String [] LMA_TITLES = 
 		{"X-OFFS","Y-OFFS", "AMPLITUDE", "RADIUS","RAD_POS", "OVERSHOOT","OFFSET","RMSE","RMSE/A","MAX2A","ITERATIONS",
@@ -107,7 +109,8 @@ public class CuasMotionLMA {
 				"*Q-AMPL","*Q-RMSE","*Q-RMSE/A","*Q-CENTER","*Q-MATCH","*Q-LENGTH","*QTRAVEL","*Q-SCORE",
 				"Stronger","Slow",
 				"WHEN", "FAILURE",
-				"Disparity","Disparity-Diff","Strength","Range","Global-index"};
+				"Disparity","Disparity-Diff","Strength","Range","Global-index",
+				"segment-length","segment-disparity","segment_disp-diff", "segment-strength", "segment-range"};
 	
 	public static final int FAIL_NONE =      0;
 	public static final int FAIL_MOTION =    1;  // motion strength/fraction too low

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

@@ -27,7 +27,7 @@ public class CuasRanging {
 	public static final String   TARGET_RANGING_LOGS_SUFFIX =      "-TARGET_RANGING.log";
 	public static final String   TARGET_RANGING_LOGS_FULL_SUFFIX = "-TARGET_RANGING_FULL.log";
 	public static final String   TARGET_DISPARITIES_SUFFIX =       "-TARGET_DISPARITIES";
-	public static final String   TARGET_STATS_SUFFIX =             "-TARGETS.csv";
+	public static final String   TARGET_STATS_SUFFIX =             "-TARGETS"; // *.csv
 
 	
 	final QuadCLT           center_CLT;
@@ -218,13 +218,14 @@ public class CuasRanging {
 				debugLevel);    // final int             debugLevel) {
 		double[][][] targets = cuasMotion.getTargets();
 
-		String model_prefix = center_CLT.getImageName()+CuasMotion.getParametersSuffixRanging(clt_parameters,null);
-		double [][] glob_stats = null;
+//		String model_prefix = center_CLT.getImageName()+CuasMotion.getParametersSuffixRanging(clt_parameters,null);
+//		double [][] glob_stats = null;
 
 		if (rng_disp || rng_glob) {
 			double [][][] disparity_targets = null;
 			if (reuse_disparity) {
-				String disparity_path = model_prefix+TARGET_DISPARITIES_SUFFIX; // may later be directly provided (e.g. select specific version)
+//				String disparity_path = model_prefix+TARGET_DISPARITIES_SUFFIX; // may later be directly provided (e.g. select specific version)
+				String disparity_path = center_CLT.getImageName()+CuasMotion.getParametersSuffixRanging(clt_parameters,TARGET_DISPARITIES_SUFFIX); // may later be directly provided (e.g. select specific version)
 				if (disparity_path.indexOf(Prefs.getFileSeparator()) < 0) { // now always
 					String x3d_path = center_CLT.getX3dDirectory();
 					disparity_path = x3d_path + Prefs.getFileSeparator() + disparity_path+".tiff";
@@ -273,7 +274,8 @@ public class CuasRanging {
 				 */
 				//	String model_prefix = center_CLT.getImageName()+CuasMotion.getParametersSuffix(clt_parameters,null);
 				if (rng_glob) {
-					glob_stats =  rangeSingleTargets(
+					// glob_stats =  
+					rangeSingleTargets(
 							targets,          //final double [][][] targets,   // centers
 							log_ranging,      // final boolean       log_ranging,
 							rng_vfy,          // final boolean       rng_vfy, // Generate/save ranging verification images (per-sensor and combined rendering from the same data)
@@ -291,7 +293,8 @@ public class CuasRanging {
 				ImagePlus imp_with_range = CuasMotion.showTargetSequence(
 						targets,          // double [][][] vector_fields_sequence,
 						cuasMotion.getSliceTitles(),         // String []     titles, // all slices*frames titles or just slice titles or null
-						model_prefix+TARGET_DISPARITIES_SUFFIX, // "-TARGET_DISPARITIES",// String        title,
+//						model_prefix+TARGET_DISPARITIES_SUFFIX, // "-TARGET_DISPARITIES",// String        title,
+						center_CLT.getImageName()+CuasMotion.getParametersSuffixRanging(clt_parameters,TARGET_DISPARITIES_SUFFIX),
 						!batch_mode,          // boolean       show,
 						cuasMotion.getTilesX());   //  int           tilesX) {
 				center_CLT.saveImagePlusInModelDirectory(imp_with_range);  // ImagePlus   imp)
@@ -631,64 +634,45 @@ public class CuasRanging {
 		return rendered;
 	}
 	
-	public double [][] rangeSingleTargets(
+	public void rangeSingleTargets(
 			final double [][][] targets,   // centers
 			final boolean       log_ranging,
 			final boolean       rng_vfy, // Generate/save ranging verification images (per-sensor and combined rendering from the same data) NOT implemented
 			final int           debugLevel) {
 		int [][][] linked_targets = CuasMotion.getLinkedTargets(targets);
-		double [][] target_glob_stats = new double [linked_targets.length][];
-		
-		
+///		double [][] target_glob_stats = new double [linked_targets.length][];
+		int    dbg_rng_tgt = clt_parameters.imp.cuas_dbg_rng_tgt;
 		int    show_mode =   clt_parameters.imp.cuas_dbg_show_mode; //  2; // 7; // 0; //  4; // 0; //3; +1 - disparity, +2 - corr
-//		int rng_combine =  clt_parameters.imp.cuas_rng_combine; // // combine multiple scenes before intrascene correlation
-		float [][][]  accum_2d_corr = null;
-		// for rng_vfy debugging
-///		final int half_accum_range = cuasMotion.getSeqLength()/2;
-///		final int num_sens =   center_CLT.getNumSensors();
-///		final int num_scenes =   2*half_accum_range+1;
-///		final int num_scene_grp = (num_scenes + (rng_combine - 1)) / rng_combine;
-///		final double [][][] ranging_verify = null; // (rng_vfy)  ? (new double [num_scene_grp + 1][num_sens + 1][]) : null;
 		
+		float [][][]  accum_2d_corr = null;
 		if (log_ranging) {
 			String log_head = getRangingLogParameters();
-			log_head +="target\tnseq\tframe_center\tnrefine\ttileX\ttileY\ttile\tdisparity\tdisp_diff\tstrength\tlast_str\tmax_diff\n";
+			log_head +="target\tnseq\tframe_center\tnrefine\ttileX\ttileY\ttile\tdisparity\tdisp_diff\thalf\tstrength\tlast_str\tmax_diff\n";
 			center_CLT.appendStringInModelDirectory(log_head, TARGET_RANGING_LOGS_SUFFIX);
 			center_CLT.appendStringInModelDirectory(log_head, TARGET_RANGING_LOGS_FULL_SUFFIX);
 		}
 		int target_id0 = 1;
-		int target_id1 = target_glob_stats.length;
+		int target_id1 = linked_targets.length;
+		if (dbg_rng_tgt >0) {
+			target_id0  = dbg_rng_tgt;
+			target_id1  = dbg_rng_tgt;
+		}
 		System.out.println ("rangeSingleTargets(): Processing target_id from "+target_id0+" to "+target_id1+" (inclusive)"); // for debugging
-		
 		for (int target_id = target_id0; target_id <= target_id1; target_id++) {
 			boolean rng_vfy_this = (target_id == target_id0) && rng_vfy; // only for the first target in range
-			double [] target_stats = rangeSingleTarget( // return {disparity, strength, last disparity difference}
+///			double [] target_stats = 
+			rangeSingleTarget( // return {disparity, strength, last disparity difference}
 					targets,        // final double [][][] targets,   // centers
 					linked_targets, // final int [][][]    linked_targets,
 					target_id,      // final int           target_id, // target number, starting with 1
 					log_ranging,    // final boolean       log_ranging,
 					accum_2d_corr,  // final float [][][]  accum_2d_corr, // if [1][][] - return accumulated 2d correlations (all pairs)
 					show_mode,      // final int           show_mode, //+1 - disparity, +2 - correlations +4 - debug single run
-//					ranging_verify, // final double [][][] ranging_verify,
 					rng_vfy_this,   // final boolean       rng_vfy, // Generate/save ranging verification images (per-sensor and combined rendering from the same data) NOT implemented
 					debugLevel) ;   // final int           debugLevel) ;
-			target_glob_stats[target_id-1] = target_stats;
+///			target_glob_stats[target_id-1] = target_stats;
 		}
-		/*
-		for (int nseq = nseq_first; nseq <= nseq_last; nseq++) {
-			int show_mode1 = show_mode & ((nseq == nseq_first)? 7 : 3);
-			double [][][] ranging_verify_use = (nseq == nseq_first) ? ranging_verify : null ;
-			rangeTargets(
-					 targets,            // final double [][][] targets,   // centers
-					 log_ranging,        // final boolean       log_ranging,
-					 accum_2d_corr,      // final float [][][]  accum_2d_corr, // if [1][][] - return accumulated 2d correlations (all pairs)
-					 nseq,               // final int           nseq,
-					 show_mode1,         // final int           show_mode, //+1 - disparity, +2 - correlations
-					 ranging_verify_use, // final double [][][] ranging_verify,
-					 debugLevel);        // final int           debugLevel)
-		}
-		*/
-		return target_glob_stats;
+		return; //  target_glob_stats;
 	}
 	
 	
@@ -721,7 +705,7 @@ public class CuasRanging {
 		
 		if (log_ranging) {
 			String log_head = getRangingLogParameters();
-			log_head +="target\tnseq\tframe_center\tnrefine\ttileX\ttileY\ttile\tdisparity\tdisp_diff\tstrength\tlast_str\tmax_diff\n";
+			log_head +="target\tnseq\tframe_center\tnrefine\ttileX\ttileY\ttile\tdisparity\tdisp_diff\thalf\tstrength\tlast_str\tmax_diff\n";
 			center_CLT.appendStringInModelDirectory(log_head, TARGET_RANGING_LOGS_SUFFIX);
 			center_CLT.appendStringInModelDirectory(log_head, TARGET_RANGING_LOGS_FULL_SUFFIX);
 		}
@@ -776,25 +760,125 @@ public class CuasRanging {
     	sb.append("cuas_max_disp_diff = "   + clt_parameters.imp.cuas_max_disp_diff   + "\n"); // Maximal disparity difference during last change to consider disparity valid
     	sb.append("cuas_min_disp_str = "    + clt_parameters.imp.cuas_min_disp_str    + "\n"); // Minimal disparity strength to consider disparity valid
     	sb.append("cuas_rng_limit = "       + clt_parameters.imp.cuas_rng_limit       + "\n"); // Maximal displayed distance to target
+    	sb.append("cuas_infinity = "        + clt_parameters.imp.cuas_infinity        + "\n"); // Disparity at infinity
     	
-//    	sb.append("nseq\tframe_center\tnrefine\ttileX\ttileY\ttile\tdisparity\tdisp_diff\tstrength\tlast_str\tmax_diff\n");
+    	sb.append("cuas_flw_levels = "      + clt_parameters.imp.cuas_flw_levels      + "\n"); // 1 - all, 2 - all and two halves, 3 - all, two halves and 4 quaters
+    	sb.append("cuas_flw_len = "         + clt_parameters.imp.cuas_flw_len         + "\n"); // Minimal number of key frames in each segment after division;
+    	sb.append("cuas_flw_diff = "        + clt_parameters.imp.cuas_flw_diff        + "\n"); // (pix) Minimal difference between halves to use "tilted" non-constant disparity 
 
     	return sb.toString();
 	}
 	
-	public double[] rangeSingleTarget( // return {disparity, strength, last disparity difference}
+	public void rangeSingleTarget( // return {disparity, strength, last disparity difference}
 			final double [][][] targets,   // centers
 			final int [][][]    linked_targets,
 			final int           target_id, // target number, starting with 1
 			final boolean       log_ranging,
 			final float [][][]  accum_2d_corr, // if [1][][] - return accumulated 2d correlations (all pairs)
-//			final int           nseq,
 			final int           show_mode, //+1 - disparity, +2 - correlations +4 - debug single run
 			final boolean       rng_vfy, // Generate/save ranging verification images (per-sensor and combined rendering from the same data) NOT implemented
 			final int           debugLevel) {
+		int    flw_levels =    clt_parameters.imp.cuas_flw_levels;
+		int    flw_len =       clt_parameters.imp.cuas_flw_len;
+///		double flw_diff =      clt_parameters.imp.cuas_flw_diff;
+		double max_disp_diff = clt_parameters.imp.cuas_max_disp_diff; //    0.05;  // Maximal disparity difference during last change to consider disparity valid
+		double min_disp_str =  clt_parameters.imp.cuas_min_disp_str;   //    0.4;   // Minimal disparity strength to consider disparity valid
+		double rng_limit =     clt_parameters.imp.cuas_rng_limit;         // 5000;     // Maximal displayed distance to target
+		double cuas_infinity = clt_parameters.imp.cuas_infinity;
+		
+		// extract target from the first to the last defined sequence number
+		int very_first_seq = -1;
+		for (int i = 0; i < targets.length; i++) {
+			if (linked_targets[target_id-1][i] != null) {
+				very_first_seq = i;
+				break;
+			}
+		}
+		if (very_first_seq < 0) {
+			System.out.println("rangeSingleTarget(): target "+target_id+" is undefined");
+			return; //  null;
+		}
+		int iseq;
+		for (iseq = very_first_seq; (iseq < targets.length) && (linked_targets[target_id-1][iseq] != null); iseq++ );
+		int [] target_tiles_full = new int [iseq - very_first_seq];
+		for (int i = 0; i < target_tiles_full.length; i++) target_tiles_full[i] = linked_targets[target_id-1][very_first_seq+i][0];
+		final GeometryCorrection gc = center_CLT.getGeometryCorrection();
+		process_segments: {
+			double [] seg_rslt = null;
+			for (int seg_lev = 0; seg_lev < flw_levels; seg_lev++) {
+				int num_segm = (1 << seg_lev);
+				for (int segm_num = 0; segm_num < num_segm; segm_num++) {
+					int seg_start = (target_tiles_full.length * segm_num) /num_segm;
+					int seg_end = ((target_tiles_full.length * (segm_num + 1)) /num_segm) - 1;
+					int [] target_tiles = new int [seg_end-seg_start+1];
+					System.arraycopy(target_tiles_full, seg_start, target_tiles, 0, target_tiles.length);
+					seg_rslt = rangeSingleTarget( // return {disparity, strength, last disparity difference}
+							targets,       // final double [][][] targets,   // centers
+							target_tiles,  // final int []        target_tiles,
+							seg_start+very_first_seq,     // final int           first_seq, // 
+							target_id,     // final int           target_id, // target number, starting with 1
+							log_ranging,   // final boolean       log_ranging,
+							accum_2d_corr, // final float [][][]  accum_2d_corr, // if [1][][] - return accumulated 2d correlations (all pairs)
+							show_mode,     // final int           show_mode, //+1 - disparity, +2 - correlations +4 - debug single run
+							rng_vfy,       // final boolean       rng_vfy, // Generate/save ranging verification images (per-sensor and combined rendering from the same data) NOT implemented
+							debugLevel);   // final int           debugLevel)
+					if (seg_rslt == null) {
+						System.out.println("rangeSingleTarget():failed to calculate disparity for target #"+target_id+
+								", segment level="+seg_lev+", segment number="+segm_num+", first_seq="+very_first_seq+", num_seq="+target_tiles.length);
+					} else {
+						int seg_length = seg_end - seg_start +1;
+						int middle_index = seg_start + seg_length/2; // middle for odd, next after middle for even
+						int ntile = target_tiles[middle_index - seg_start];
+						double [] target = targets[middle_index + very_first_seq][ntile];
+						double disparity =      seg_rslt[0] - cuas_infinity;
+						double strength =       seg_rslt[1];
+						double disparity_diff = seg_rslt[2];
+						double range =          Double.NaN;
+						if ((disparity_diff > max_disp_diff) || (strength < min_disp_str)) {
+							disparity = Double.NaN;
+						} else if (disparity <= 0){
+							range = Double.POSITIVE_INFINITY;
+						} else {
+							double z = gc.getZFromDisparity(disparity); // or should we use sqrt(x^2 + y^2 + z^2)?
+							if (z > rng_limit) {
+								range = Double.POSITIVE_INFINITY;
+							} else {
+								range = z; // was it positive already? Yes
+							}
+						}
+						target[CuasMotionLMA.RSLT_GLENGTH] =    seg_length; // null pointer
+						target[CuasMotionLMA.RSLT_GDISPARITY] = seg_rslt[0]; // disparity; here - raw disparity, not corrected
+						target[CuasMotionLMA.RSLT_GDISP_DIFF] = disparity_diff;
+						target[CuasMotionLMA.RSLT_GDISP_STR] =  strength;
+						target[CuasMotionLMA.RSLT_GRANGE] =     range;
+					}
+				}
+				// verify next leve's lengths
+				if ((target_tiles_full.length >> (seg_lev + 1)) < flw_len) {
+					break process_segments;
+				}
+			}
+		}
+        return; // null;
+	}
+	
+	
+	
+	public double[] rangeSingleTarget( // return {disparity, strength, last disparity difference}
+			final double [][][] targets,   // centers
+			final int []        target_tiles,
+			final int           first_seq, // 
+			final int           target_id, // target number, starting with 1
+			final boolean       log_ranging,
+			final float [][][]  accum_2d_corr, // if [1][][] - return accumulated 2d correlations (all pairs)
+			final int           show_mode, //+1 - disparity, +2 - correlations +4 - debug single run
+			final boolean       rng_vfy, // Generate/save ranging verification images (per-sensor and combined rendering from the same data) NOT implemented
+			final int           debugLevel) {
+		int refine_half_alt = 2;    // when refine >=  refine_half_alt and diff changed sign - multiply it by 0.5
 		final int end_mode = clt_parameters.imp.cuas_glob_ends; // 1; // 0 - same as internal, 1 - cosine extended ends, 2 - rectangular extended ends // make a parameter
 		final boolean first_last_extra = (end_mode > 0); 
 		final boolean smooth_ends = (end_mode == 1);
+		/*
 		// extract target from the first to the last defined sequence number
 		int first_seq = -1;
 		for (int i = 0; i < targets.length; i++) {
@@ -811,6 +895,7 @@ public class CuasRanging {
 		for (iseq = first_seq; (iseq < targets.length) && (linked_targets[target_id-1][iseq] != null); iseq++ );
 		int [] target_tiles = new int [iseq - first_seq];
 		for (int i = 0; i < target_tiles.length; i++) target_tiles[i] = linked_targets[target_id-1][first_seq+i][0];
+		*/
 		
 		boolean show_disparity=     (show_mode & 1) != 0;
 		boolean show_corr=          (show_mode & 2) != 0;
@@ -886,6 +971,13 @@ public class CuasRanging {
 					return null;
 				}
 			}
+			
+			String shalf = " ";
+			if ((nrefine >= refine_half_alt) && ((disparity_diff * disp_diff) < 0)) {  // disp_diff changed sign
+				disp_diff *= 0.5;
+				shalf = "*";
+			}
+			
 			boolean improved = false;
 			if ((str > 0) && !((worsen_str * strength) > str)) {
 				disparity += disp_diff;
@@ -901,17 +993,18 @@ public class CuasRanging {
 				
 				sb_last.append(target_id+"\t"+first_seq+"\t"+target_tiles.length+"\t"+nrefine+"\t"+ref_tileX+"\t"+ref_tileY+"\t"+ref_tile+"\t"+
 						disparity+"\t"+
-						disp_diff+"\t"+
+						disp_diff+"\t"+shalf+"\t"+
 						strength+"\t"+
 						str+"\t"+
 						abs_diff+"\n");
 			}
 			
 			if (debugLevel > -4) {
-				System.out.println(String.format("rangeSingleTarget(), target=%2d, first_seq=%3d (%3d), nrefine=%2d, %3d:%3d (%4d), disparity=%7.4f (%7.4f), strength=%7.5f (%7.5f) abs_diff=%7.5f",
+				System.out.println(String.format("rangeSingleTarget(), target=%2d, first_seq=%3d (%3d), nrefine=%2d, %3d:%3d (%4d), disparity=%7.4f (%7.4f %s), strength=%7.5f (%7.5f) abs_diff=%7.5f",
 						target_id, first_seq,target_tiles.length,nrefine,ref_tileX,ref_tileY,ref_tile,
 						disparity,
-						disp_diff,strength,str,abs_diff));
+						disp_diff, shalf,
+						strength,str,abs_diff));
 			}
 			
 			if (sb_full != null) {
@@ -954,7 +1047,7 @@ public class CuasRanging {
 		boolean show_disparity=     (show_mode & 1) != 0;
 		boolean show_corr=          (show_mode & 2) != 0;
 		boolean show_debug_single = (show_mode & 4) != 0;
-		
+		int refine_half_alt = 2;    // when refine >=  refine_half_alt and diff changed sign - multiply it by 0.5
 		final int rng_niterate =  clt_parameters.imp.cuas_rng_niterate;
 		final double rng_diff =   clt_parameters.imp.cuas_rng_diff;
 		double cuas_initial_disparity=clt_parameters.imp.cuas_initial_disparity; // 1.0;  // Start correlation with this disparity (in addition to infinity) after reset
@@ -1095,6 +1188,11 @@ public class CuasRanging {
 				if (Double.isNaN(targets[nseq][ntile][CuasMotionLMA.RSLT_DISPARITY])) {
 					targets[nseq][ntile][CuasMotionLMA.RSLT_DISPARITY] = 0.0;
 				}
+				String shalf = " ";
+				if ((nrefine >= refine_half_alt) && ((targets[nseq][ntile][CuasMotionLMA.RSLT_DISP_DIFF] * disp_diff) < 0)) { // disp_diff changed sign
+					disp_diff *= 0.5;
+					shalf = "*";
+				}
 				if ((str > 0) && !((worsen_str * targets[nseq][ntile][CuasMotionLMA.RSLT_DISP_STR]) > str)) {
 					targets[nseq][ntile][CuasMotionLMA.RSLT_DISPARITY] += disp_diff;
 					targets[nseq][ntile][CuasMotionLMA.RSLT_DISP_DIFF] =  disp_diff;
@@ -1110,6 +1208,7 @@ public class CuasRanging {
 					sb_last.append(itarget+"\t"+nseq+"\t"+frame_center+"\t"+nrefine+"\t"+dbg_tilex+"\t"+dbg_tiley+"\t"+ntile+"\t"+
 							targets[nseq][ntile][CuasMotionLMA.RSLT_DISPARITY]+"\t"+
 							disp_diff+"\t"+
+							shalf+"\t"+
 							targets[nseq][ntile][CuasMotionLMA.RSLT_DISP_STR]+"\t"+
 							str+"\t"+
 							max_diff+"\n");
@@ -1118,10 +1217,11 @@ public class CuasRanging {
 				if (debugLevel > -4) {
 					int dbg_tilex = ntile % tilesX;
 					int dbg_tiley = ntile / tilesX;
-					System.out.println(String.format("rangeTargets(), target=%2d, nseq=%3d (%3d), nrefine=%2d, %3d:%3d (%4d), disparity=%7.4f (%7.4f), strength=%7.5f (%7.5f) max_diff=%7.5f",
+					System.out.println(String.format("rangeTargets(), target=%2d, nseq=%3d (%3d), nrefine=%2d, %3d:%3d (%4d), disparity=%7.4f (%7.4f %s), strength=%7.5f (%7.5f) max_diff=%7.5f",
 							itarget, nseq,frame_center,nrefine,dbg_tilex,dbg_tiley,ntile,
 							targets[nseq][ntile][CuasMotionLMA.RSLT_DISPARITY],
-							disp_diff,targets[nseq][ntile][CuasMotionLMA.RSLT_DISP_STR],str,max_diff));
+							disp_diff,shalf,
+							targets[nseq][ntile][CuasMotionLMA.RSLT_DISP_STR],str,max_diff));
 					
 				}
 				
@@ -2543,14 +2643,18 @@ public class CuasRanging {
 		final int tilesX = cuasMotion.getTilesX();
 		final int tileSize = GPUTileProcessor.DTT_SIZE;
 		double  cuas_infinity =      clt_parameters.imp.cuas_infinity ; // 0.63;  // disparity at infinity for targets
+		int      flw_levels = clt_parameters.imp.cuas_flw_levels; // 1 - all, 2 - all and two halves, 3 - all, two halves and 4 quaters
+		
 		int num_seq = targets_single.length;
 		int [][][] linked_targets = CuasMotion.getLinkedTargets(targets_single);
 		int num_targets = linked_targets.length;
 		StringBuffer sb = new StringBuffer();
 		sb.append(getRangingLogParameters());
-		String []  fields = {"pX", "pY"," azimuth", "elevation","disparity","range"};
+		String []  fields_uas = {"pX", "pY"," azimuth", "elevation","disparity","range"};
+		String []  fields =     {"pX", "pY"," azimuth", "elevation","disparity","range","glength", "gdisp","gdisp-diff","gstr","grange"};
+//		String []  global_fields = {"glength", "gdisp","gdisp-diff","gstr","grange"};
 		// First header line
-		sb.append("scene\t\tFlight log"); for (int i = 0; i < fields.length; i++) sb.append("\t");
+		sb.append("scene\t\tFlight log"); for (int i = 0; i < fields_uas.length; i++) sb.append("\t");
 		for (int ntarg = 0; ntarg < num_targets; ntarg++) {
 			sb.append("Target "+(ntarg+1));for (int i = 0; i < fields.length; i++) sb.append("\t"); // there will be 1 extra blank column
 		}
@@ -2559,10 +2663,16 @@ public class CuasRanging {
 		sb.append("index\ttimestamp\t");
 		for (int ntarg = -1; ntarg < num_targets; ntarg++) {
 			String suffix = (ntarg < 0) ? "-fl_log":("-"+(ntarg+1));
+			if (ntarg < 0) {
+				for (int i = 0; i < fields_uas.length; i++) {
+					sb.append(fields[i]+suffix+"\t");
+				}
+			} else {
 				for (int i = 0; i < fields.length; i++) {
 					sb.append(fields[i]+suffix+"\t");
 				}
 			}
+		}
 		sb.append("\n"); // there will be 1 extra blank column
 		String [] slice_titles = 	cuasMotion.getSliceTitles(); // timestamps
 		UasLogReader  uasLogReader = cuasMotion.getUasLogReader();
@@ -2590,7 +2700,6 @@ public class CuasRanging {
 						for (int i = 0; i < fields.length; i++) {
 							sb.append("\t");
 						}
-
 					} else {
 						int tileX = ntile % tilesX;
 						int tileY = ntile / tilesX;
@@ -2608,6 +2717,17 @@ public class CuasRanging {
 								vy);            // double         target_vy);
 						sb.append(xc+"\t"+yc+"\t"+az_el_oaz_oel[0][0]+"\t"+az_el_oaz_oel[0][1]+"\t"+
 								target[CuasMotionLMA.RSLT_DISPARITY]+"\t"+target[CuasMotionLMA.RSLT_RANGE]+"\t");
+						if (target[CuasMotionLMA.RSLT_GLENGTH] > 0) {
+							sb.append(target[CuasMotionLMA.RSLT_GLENGTH]+"\t"+
+									target[CuasMotionLMA.RSLT_GDISPARITY]+"\t"+
+									target[CuasMotionLMA.RSLT_GDISP_DIFF]+"\t"+
+									target[CuasMotionLMA.RSLT_GDISP_STR]+"\t"+
+									target[CuasMotionLMA.RSLT_GRANGE]+"\t");
+						} else {
+							for (int i = 0; i < (fields.length - fields_uas.length); i++) {
+								sb.append("\t");
+							}
+						}
 					}
 				} else {
 					for (int i = 0; i < fields.length; i++) {
@@ -2617,7 +2737,7 @@ public class CuasRanging {
 			}
 			sb.append("\n"); // there will be 1 extra blank column
 		}
-		String suffix = CuasMotion.getParametersSuffixRslt(clt_parameters, null)+TARGET_STATS_SUFFIX;
+		String suffix = CuasMotion.getParametersSuffixRslt(clt_parameters, TARGET_STATS_SUFFIX)+".csv";
 		center_CLT.saveStringInModelDirectory(sb.toString(), suffix, false);
 		return;
 	}

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

@@ -875,7 +875,7 @@ min_str_neib_fpn	0.35
 	public boolean  cuas_rng_um2 =         true; // apply UM to images twice
 	public double   cuas_rng_um_weight =   1.0;  // unsharp mask weight for ranging images
 	public boolean  cuas_rng_coswnd =      false; // Use cosine scenes window (false - rectangular) 
-	public int      cuas_rng_combine =     2;    // combine multiple scenes before intrascene correlation
+	public int      cuas_rng_combine =     1;    // combine multiple scenes before intrascene correlation
 	public double   cuas_rng_radius0 =     3.0;  // mask out data outside peripheral areas, keep 0.5 at the radius - first iteration 
 	public double   cuas_rng_radius =      2.5;  // mask out data outside peripheral areas, keep 0.5 at the radius  - next iteration
 	public double   cuas_rng_blur =        0.5;  // relative transition radius range (for 0.5 the mask inside (1-0.5) radius will be 1.0, outside (1+0.5) radius will be 0
@@ -899,7 +899,7 @@ min_str_neib_fpn	0.35
 	
 	public boolean  cuas_reset_disparity =  true;  // reset target disparities from infinity
 	public double   cuas_initial_disparity = 1.0;  // Start correlation with this disparity (in addition to infinity) after reset
-	public double   cuas_infinity =         0.63;  // disparity at infinity for targets
+	public double   cuas_infinity =         0.65;  // disparity at infinity for targets
 	
 	public boolean cuas_rng_img =         false;  // Generate/save per-sensor target images
 	public boolean  cuas_rng_glob=         true;   // Generate/save integrated target disparities (one per target) TODO: add first/second half
@@ -907,13 +907,18 @@ min_str_neib_fpn	0.35
 	public boolean  cuas_rng_disp=         true;   // Generate/save target disparities
 	public boolean  cuas_rng_vfy=          false;  // Generate/save ranging verification images (per-sensor and combined rendering from the same data)
 	
-	
 	public int      cuas_rng_niterate =    6;      // number of disparity iterations
 	public double   cuas_rng_diff =        0.002;  // exit when disparity difference is smaller
 	
+	// following targets parameter
+	public int      cuas_flw_levels =      2;       // 1 - all, 2 - all and two halves, 3 - all, two halves and 4 quaters
+	public int      cuas_flw_len =        10;       // Minimal number of key frames in each segment after division;
+	public double   cuas_flw_diff =        0.03;    // (pix) Minimal difference between halves to use "tilted" non-constant disparity 
 	
+	// debug parameters
 	public boolean  cuas_debug =           false;  // save debug images (and show them if not in batch mode)
 	public int      cuas_dbg_rng_seq =    -1;     // Debug single sequence ranging (-1 - process all)
+	public int      cuas_dbg_rng_tgt =    -1;     // Debug single target ranging (-1 - process all), >0 - target id
 	public int      cuas_dbg_show_mode =   0;     // Debug show ranging debug images: +1 - disparity, +2 - correlations +4 - debug single run
 	public boolean  cuas_step_debug =      false;  // save debug images during per-step cuas recalculation (and show them if not in batch mode)
 	public boolean  cuas_save_stats =      false;  // Save target statistics data to find out which test failed and when (or when tile was found good)
@@ -2722,11 +2727,21 @@ min_str_neib_fpn	0.35
 		gd.addNumericField("Disparity difference",                   this.cuas_rng_diff, 5,8,"pix",
 				"Exit disparity iterations when difference for each target is below.");
 
+		gd.addMessage("=== Parameters for ranging individual targets ===");
+		gd.addNumericField("Sequence subdivision levels (>=1)",      this.cuas_flw_levels, 0,3,"",
+				"1 - all, 2 - all and two halves, 3 - all, two halves and 4 quaters.");
+		gd.addNumericField("Minimal sudivided length",               this.cuas_flw_len, 0,3,"",
+				"Minimal number of key frames in each segment after division.");
+		gd.addNumericField("Disparity halves disparity difference",  this.cuas_flw_diff, 5,8,"pix",
+				"Minimal difference between halves to use \"tilted\" (non-constant) disparity.");
+		
 		gd.addMessage("=== Debug ===");
 		gd.addCheckbox ("Save/show debug images",                    this.cuas_debug,
 				"Save CUAS-related debug images and show them in non-batch mode.");
 		gd.addNumericField("Debug ranging scene (-1 - process all)", this.cuas_dbg_rng_seq, 0,3,"",
-				"Debug single sequence ranging (-1 - process all).");
+				"Debug single-sequence ranging (-1 - process all).");
+		gd.addNumericField("Debug ranging target (-1 - process all)", this.cuas_dbg_rng_tgt, 0,3,"",
+				"Debug single-target ranging (-1 - process all), > 0 - target ID.");
 		gd.addNumericField("Debug show mode",                        this.cuas_dbg_show_mode, 0,3,"",
 				"Debug show ranging debug images: +1 - disparity, +2 - correlations +4 - debug single run.");
 		
@@ -3919,8 +3934,14 @@ min_str_neib_fpn	0.35
 		this.cuas_rng_vfy =             gd.getNextBoolean();
 		this.cuas_rng_niterate =  (int) gd.getNextNumber();
 		this.cuas_rng_diff =            gd.getNextNumber();
+		
+		this.cuas_flw_levels =   (int) gd.getNextNumber();
+		this.cuas_flw_len =      (int) gd.getNextNumber();
+		this.cuas_flw_diff =           gd.getNextNumber();
+		
 		this.cuas_debug =               gd.getNextBoolean();
 		this.cuas_dbg_rng_seq =   (int) gd.getNextNumber();
+		this.cuas_dbg_rng_tgt =   (int) gd.getNextNumber();
 		this.cuas_dbg_show_mode = (int) gd.getNextNumber();
 		
 		this.cuas_step_debug =          gd.getNextBoolean();
@@ -5008,8 +5029,13 @@ min_str_neib_fpn	0.35
 		properties.setProperty(prefix+"cuas_rng_niterate",    this.cuas_rng_niterate+"");   // int
 		properties.setProperty(prefix+"cuas_rng_diff",        this.cuas_rng_diff+"");       // double
 
+		properties.setProperty(prefix+"cuas_flw_levels",      this.cuas_flw_levels+"");     // int
+		properties.setProperty(prefix+"cuas_flw_len",         this.cuas_flw_len+"");        // int
+		properties.setProperty(prefix+"cuas_flw_diff",        this.cuas_flw_diff+"");       // double
+		
 		properties.setProperty(prefix+"cuas_debug",           this.cuas_debug+"");          // boolean
 		properties.setProperty(prefix+"cuas_dbg_rng_seq",     this.cuas_dbg_rng_seq+"");    // int
+		properties.setProperty(prefix+"cuas_dbg_rng_tgt",     this.cuas_dbg_rng_tgt+"");    // int
 		properties.setProperty(prefix+"cuas_dbg_show_mode",   this.cuas_dbg_show_mode+"");  // int
 		
 		properties.setProperty(prefix+"cuas_step_debug",      this.cuas_step_debug+"");     // boolean
@@ -6073,8 +6099,13 @@ min_str_neib_fpn	0.35
 		if (properties.getProperty(prefix+"cuas_rng_niterate")!=null)    this.cuas_rng_niterate=Integer.parseInt(properties.getProperty(prefix+"cuas_rng_niterate"));
 		if (properties.getProperty(prefix+"cuas_rng_diff")!=null)        this.cuas_rng_diff=Double.parseDouble(properties.getProperty(prefix+"cuas_rng_diff"));
 
+		if (properties.getProperty(prefix+"cuas_flw_levels")!=null)      this.cuas_flw_levels=Integer.parseInt(properties.getProperty(prefix+"cuas_flw_levels"));
+		if (properties.getProperty(prefix+"cuas_flw_len")!=null)         this.cuas_flw_len=Integer.parseInt(properties.getProperty(prefix+"cuas_flw_len"));
+		if (properties.getProperty(prefix+"cuas_flw_diff")!=null)        this.cuas_flw_diff=Double.parseDouble(properties.getProperty(prefix+"cuas_flw_diff"));
+		
 		if (properties.getProperty(prefix+"cuas_debug")!=null)           this.cuas_debug=Boolean.parseBoolean(properties.getProperty(prefix+"cuas_debug"));
 		if (properties.getProperty(prefix+"cuas_dbg_rng_seq")!=null)     this.cuas_dbg_rng_seq=Integer.parseInt(properties.getProperty(prefix+"cuas_dbg_rng_seq"));
+		if (properties.getProperty(prefix+"cuas_dbg_rng_tgt")!=null)     this.cuas_dbg_rng_tgt=Integer.parseInt(properties.getProperty(prefix+"cuas_dbg_rng_tgt"));
 		if (properties.getProperty(prefix+"cuas_dbg_show_mode")!=null)   this.cuas_dbg_show_mode=Integer.parseInt(properties.getProperty(prefix+"cuas_dbg_show_mode"));
 		if (properties.getProperty(prefix+"cuas_step_debug")!=null)      this.cuas_step_debug=Boolean.parseBoolean(properties.getProperty(prefix+"cuas_step_debug"));
 		if (properties.getProperty(prefix+"cuas_save_stats")!=null)      this.cuas_save_stats=Boolean.parseBoolean(properties.getProperty(prefix+"cuas_save_stats"));
@@ -7126,8 +7157,13 @@ min_str_neib_fpn	0.35
 		imp.cuas_glob_ends =        this.cuas_glob_ends;
 		imp.cuas_rng_diff =         this.cuas_rng_diff;
 		
+		imp.cuas_flw_levels =       this.cuas_flw_levels;
+		imp.cuas_flw_len =          this.cuas_flw_len;
+		imp.cuas_flw_diff =         this.cuas_flw_diff;
+		
 		imp.cuas_debug =            this.cuas_debug;
 		imp.cuas_dbg_rng_seq =      this.cuas_dbg_rng_seq;
+		imp.cuas_dbg_rng_tgt =      this.cuas_dbg_rng_tgt;
 		imp.cuas_dbg_show_mode =    this.cuas_dbg_show_mode;
 		imp.cuas_step_debug =       this.cuas_step_debug;
 		imp.cuas_save_stats =       this.cuas_save_stats;