Trimming for low disparity difference (far objects) by tone

(temperature).

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

@@ -398,6 +398,12 @@ public class CLTParameters {
 	public double     tex_disp_rdiffj =               0.08; // maximal relative disparity difference for the "jumps". 
 	
 	public double     tex_fg_bg =                     0.1;  // Minimal FG/BG disparity difference (NaN bg if difference from FG < this)
+	
+	public double     tex_disp_over_sky =             0.1;  // change extended BS (by  tex_max_neib_lev) far tile to BS
+	public double     tex_str_over_sky =              0.7;  // change extended BS (by  tex_max_neib_lev) weak tile to BS  
+	public boolean    tex_require_lma =             true;   // require strong tile to have LMA 
+	
+	
 	public double     tex_distort =                   0.8;  // Maximal texture distortion to accumulate multiple scenes (0 - any)
 	public double     tex_mb =                        1.0;  // Reduce texture weight if motion blur exceeds this (as square of MB length)
 	
@@ -406,6 +412,7 @@ public class CLTParameters {
 	public int        tex_max_neib_lev =              2;    // 1 - single tiles layer around, 2 - two layers
 	public boolean    tex_split_textures =          false;  // (debugLevel > 1000); // false;
 	public int        tex_subdiv_tiles =              4;    // subdivide tiles to smaller triangles
+	public int        tex_sky_extra =                 2;    // additionally grow sky area (in layers) without marking as sky
 	public int        tex_sky_below =                10;    // extend sky these tile rows below lowest
 
 	// gd.addMessage     ("Triangular mesh");
@@ -511,6 +518,15 @@ public class CLTParameters {
 	public double        lre_weight_neib =          3.0; // 2.0; // 1.0;  // weight of same neighbors - add to cost multiplied by num_neib-4
 	public double        lre_weight_bg =            0.9; // 0.8; // 1.0; // 15.0/16; // 1.0;  // weight of BG cost relative to the FG one
 	public double        lre_best_dir_frac =        0.6;  // for BG - use this fraction of all sensors in the best direction
+	
+	//"Trimming by temperature (tone)
+	
+	public boolean       lre_use_min_max =         true;  // when trimming by tone, use min/max of the FG/BG instead of weighted averages 
+	public double        lre_temp_radius =         11.5;  // How far to look around for FG trimming by temperature
+	public int           lre_temp_min =             2;    // Minimal number of each of FG/BG while trimming by temperature
+	public double        lre_temp_weight =         20.0;  // Multiply -1.0..+1.0 range of the current pixel between average BG(-1) and FG(+1)
+	public double        lre_min_use_occl =         1.5;  // Minimal FG/BG difference to use trimming by occlusions. For lower use only temperature/tone
+	public double        lre_temp_disparity =       3.0;  // FG-BG disparity where weight of cost by obscuring equals weight of cost by temp   
 	public double        lre_cost_min =             1.0;  // minimal absolute value of the total cost to make changes
 	public int           lre_max_trim_iterations = 10;
 	// for fillOcclusionsNaN:
@@ -521,6 +537,7 @@ public class CLTParameters {
 	public boolean       lre_show_textures_combo =     false; //true;
 	public boolean       lre_show_textures_tiles =     false; //true;
 	public boolean       lre_show_sky_textures =       false; //true;
+	public int           lre_show_slice_bitmap =   -1; // bitmap of slices for which to show images (lre_show_update_alpha_slice, lre_show_textures_slice)
 	
 	public double     pt_super_trust   = 1.6;   // If strength exceeds ex_strength * super_trust, do not apply ex_nstrength and plate_ds
 	public boolean    pt_keep_raw_fg   = true;  // Do not replace raw tiles by the plates, if raw is closer (like poles)
@@ -1504,6 +1521,10 @@ public class CLTParameters {
 		properties.setProperty(prefix+"tex_disp_rdiffj",            this.tex_disp_rdiffj+"");     // double
 		
 		properties.setProperty(prefix+"tex_fg_bg",                  this.tex_fg_bg+"");           // double
+		properties.setProperty(prefix+"tex_disp_over_sky",          this.tex_disp_over_sky+"");   // double
+		properties.setProperty(prefix+"tex_str_over_sky",           this.tex_str_over_sky+"");    // double
+		properties.setProperty(prefix+"tex_require_lma",            this.tex_require_lma+"");     // boolean
+		
 		properties.setProperty(prefix+"tex_distort",                this.tex_distort+"");         // double
 		properties.setProperty(prefix+"tex_mb",                     this.tex_mb+"");              // double
 		
@@ -1512,6 +1533,7 @@ public class CLTParameters {
 		properties.setProperty(prefix+"tex_max_neib_lev",           this.tex_max_neib_lev+"");       // int
 		properties.setProperty(prefix+"tex_split_textures",         this.tex_split_textures+"");     // boolean
 		properties.setProperty(prefix+"tex_subdiv_tiles",           this.tex_subdiv_tiles+"");       // int
+		properties.setProperty(prefix+"tex_sky_extra",              this.tex_sky_extra+"");          // int
 		properties.setProperty(prefix+"tex_sky_below",              this.tex_sky_below+"");          // int
 		
 		properties.setProperty(prefix+"tex_disp_hires_tri",         this.tex_disp_hires_tri+""); // boolean
@@ -1617,6 +1639,14 @@ public class CLTParameters {
 		properties.setProperty(prefix+"lre_weight_neib",            this.lre_weight_neib+"");            // double  
 		properties.setProperty(prefix+"lre_weight_bg",              this.lre_weight_bg+"");              // double  
 		properties.setProperty(prefix+"lre_best_dir_frac",          this.lre_best_dir_frac+"");          // double
+		
+		properties.setProperty(prefix+"lre_use_min_max",            this.lre_use_min_max+"");            // boolean 
+		properties.setProperty(prefix+"lre_temp_radius",            this.lre_temp_radius+"");            // double
+		properties.setProperty(prefix+"lre_temp_min",               this.lre_temp_min+"");               // int     
+		properties.setProperty(prefix+"lre_temp_weight",            this.lre_temp_weight+"");            // double
+		properties.setProperty(prefix+"lre_min_use_occl",           this.lre_min_use_occl+"");           // double
+		properties.setProperty(prefix+"lre_temp_disparity",         this.lre_temp_disparity+"");         // double
+		
 		properties.setProperty(prefix+"lre_cost_min",               this.lre_cost_min+"");               // double  
 		properties.setProperty(prefix+"lre_max_trim_iterations",    this.lre_max_trim_iterations+"");    // int     
 		//                                
@@ -1626,8 +1656,8 @@ public class CLTParameters {
 		properties.setProperty(prefix+"lre_show_textures_slice",    this.lre_show_textures_slice+"");    // boolean 
 		properties.setProperty(prefix+"lre_show_textures_combo",    this.lre_show_textures_combo+"");    // boolean 
 		properties.setProperty(prefix+"lre_show_textures_tiles",    this.lre_show_textures_tiles+"");    // boolean 
-		
 		properties.setProperty(prefix+"lre_show_sky_textures",      this.lre_show_sky_textures+"");      // boolean 
+		properties.setProperty(prefix+"lre_show_slice_bitmap",      this.lre_show_slice_bitmap+"");      // int     
 
 		properties.setProperty(prefix+"pt_super_trust",             this.pt_super_trust +"");
 		properties.setProperty(prefix+"pt_keep_raw_fg",             this.pt_keep_raw_fg+"");
@@ -2488,6 +2518,10 @@ public class CLTParameters {
 		if (properties.getProperty(prefix+"tex_disp_rdiffj")!=null)      this.tex_disp_rdiffj=Double.parseDouble(properties.getProperty(prefix+"tex_disp_rdiffj"));
 		
 		if (properties.getProperty(prefix+"tex_fg_bg")!=null)            this.tex_fg_bg=Double.parseDouble(properties.getProperty(prefix+"tex_fg_bg"));
+		if (properties.getProperty(prefix+"tex_disp_over_sky")!=null)    this.tex_disp_over_sky=Double.parseDouble(properties.getProperty(prefix+"tex_disp_over_sky"));
+		if (properties.getProperty(prefix+"tex_str_over_sky")!=null)     this.tex_str_over_sky=Double.parseDouble(properties.getProperty(prefix+"tex_str_over_sky"));
+		if (properties.getProperty(prefix+"tex_require_lma")!=null)      this.tex_require_lma=Boolean.parseBoolean(properties.getProperty(prefix+"tex_require_lma"));		
+		
 		if (properties.getProperty(prefix+"tex_distort")!=null)          this.tex_distort=Double.parseDouble(properties.getProperty(prefix+"tex_distort"));
 		if (properties.getProperty(prefix+"tex_mb")!=null)               this.tex_mb=Double.parseDouble(properties.getProperty(prefix+"tex_mb"));
 		if (properties.getProperty(prefix+"tex_max_disparity_lim")!=null)this.tex_max_disparity_lim=Double.parseDouble(properties.getProperty(prefix+"tex_max_disparity_lim"));
@@ -2495,6 +2529,7 @@ public class CLTParameters {
 		if (properties.getProperty(prefix+"tex_max_neib_lev")!=null)     this.tex_max_neib_lev=Integer.parseInt(properties.getProperty(prefix+"tex_max_neib_lev"));		
 		if (properties.getProperty(prefix+"tex_split_textures")!=null)   this.tex_split_textures=Boolean.parseBoolean(properties.getProperty(prefix+"tex_split_textures"));		
 		if (properties.getProperty(prefix+"tex_subdiv_tiles")!=null)     this.tex_subdiv_tiles=Integer.parseInt(properties.getProperty(prefix+"tex_subdiv_tiles"));		
+		if (properties.getProperty(prefix+"tex_sky_extra")!=null)        this.tex_sky_extra=Integer.parseInt(properties.getProperty(prefix+"tex_sky_extra"));
 		if (properties.getProperty(prefix+"tex_sky_below")!=null)        this.tex_sky_below=Integer.parseInt(properties.getProperty(prefix+"tex_sky_below"));
 		
 		if (properties.getProperty(prefix+"tex_disp_hires_tri")!=null)   this.tex_disp_hires_tri=Boolean.parseBoolean(properties.getProperty(prefix+"tex_disp_hires_tri"));		
@@ -2600,6 +2635,14 @@ public class CLTParameters {
 		if (properties.getProperty(prefix+"lre_weight_neib")!=null)            this.lre_weight_neib=Double.parseDouble(properties.getProperty(prefix+"lre_weight_neib"));// double  
 		if (properties.getProperty(prefix+"lre_weight_bg")!=null)              this.lre_weight_bg=Double.parseDouble(properties.getProperty(prefix+"lre_weight_bg"));// double  
 		if (properties.getProperty(prefix+"lre_best_dir_frac")!=null)          this.lre_best_dir_frac=Double.parseDouble(properties.getProperty(prefix+"lre_best_dir_frac"));// double
+		
+		if (properties.getProperty(prefix+"lre_use_min_max")!=null)            this.lre_use_min_max=Boolean.parseBoolean(properties.getProperty(prefix+"lre_use_min_max"));// boolean 
+		if (properties.getProperty(prefix+"lre_temp_radius")!=null)            this.lre_temp_radius=Double.parseDouble(properties.getProperty(prefix+"lre_temp_radius"));// double
+		if (properties.getProperty(prefix+"lre_temp_min")!=null)               this.lre_temp_min=Integer.parseInt(properties.getProperty(prefix+"lre_temp_min"));// int     
+		if (properties.getProperty(prefix+"lre_temp_weight")!=null)            this.lre_temp_weight=Double.parseDouble(properties.getProperty(prefix+"lre_temp_weight"));// double
+		if (properties.getProperty(prefix+"lre_min_use_occl")!=null)           this.lre_min_use_occl=Double.parseDouble(properties.getProperty(prefix+"lre_min_use_occl"));// double
+		if (properties.getProperty(prefix+"lre_temp_disparity")!=null)         this.lre_temp_disparity=Double.parseDouble(properties.getProperty(prefix+"lre_temp_disparity"));// double
+		
 		if (properties.getProperty(prefix+"lre_cost_min")!=null)               this.lre_cost_min=Double.parseDouble(properties.getProperty(prefix+"lre_cost_min"));// double  
 		if (properties.getProperty(prefix+"lre_max_trim_iterations")!=null)    this.lre_max_trim_iterations=Integer.parseInt(properties.getProperty(prefix+"lre_max_trim_iterations"));// int     
 		//                                
@@ -2609,8 +2652,8 @@ public class CLTParameters {
 		if (properties.getProperty(prefix+"lre_show_textures_slice")!=null)    this.lre_show_textures_slice=Boolean.parseBoolean(properties.getProperty(prefix+"lre_show_textures_slice"));// boolean 
 		if (properties.getProperty(prefix+"lre_show_textures_combo")!=null)    this.lre_show_textures_combo=Boolean.parseBoolean(properties.getProperty(prefix+"lre_show_textures_combo"));// boolean 
 		if (properties.getProperty(prefix+"lre_show_textures_tiles")!=null)    this.lre_show_textures_tiles=Boolean.parseBoolean(properties.getProperty(prefix+"lre_show_textures_tiles"));// boolean
-
 		if (properties.getProperty(prefix+"lre_show_sky_textures")!=null)      this.lre_show_sky_textures=Boolean.parseBoolean(properties.getProperty(prefix+"lre_show_sky_textures"));// boolean
+		if (properties.getProperty(prefix+"lre_show_slice_bitmap")!=null)      this.lre_show_slice_bitmap=Integer.parseInt(properties.getProperty(prefix+"lre_show_slice_bitmap"));
 		
 		if (properties.getProperty(prefix+"pt_super_trust")!=null)                this.pt_super_trust=Double.parseDouble(properties.getProperty(prefix+"pt_super_trust"));
 		if (properties.getProperty(prefix+"pt_keep_raw_fg")!=null)                this.pt_keep_raw_fg=Boolean.parseBoolean(properties.getProperty(prefix+"pt_keep_raw_fg"));
@@ -3636,6 +3679,15 @@ public class CLTParameters {
 		
 		gd.addNumericField("Minimal FG/BG disparity separation", this.tex_fg_bg, 5,7,"pix",
 				"Minimal FG/BG disparity difference (NaN bg if difference from FG < this).");
+		gd.addMessage     ("Remove far/weak tiles near Blue Sky (within 2 tiles)");
+		gd.addNumericField("Far tiles near sky disparity",       this.tex_disp_over_sky, 5,7,"pix",
+				"Ignore far tiles near BS.");
+		gd.addNumericField("Weak tiles near sky strength",       this.tex_str_over_sky, 5,7,"",
+				"Ignore weak tiles near BS.");
+		gd.addCheckbox ("Require LMA",                           this.tex_require_lma,
+				"Consider tiles w/o LMA as weak near blue sky.");
+		
+		gd.addMessage     ("Reduce weight of distorted and motion blurred textures in multiscene averaging");
 		gd.addNumericField("Multiscene texture distortion",      this.tex_distort, 5,7,"pix",
 				"Maximal texture distortion to accumulate multiple scenes (neighbor tile center offset from the uniform grid. 0 - do not filter");
 		gd.addNumericField("Maximal motion blur to reduce weight",this.tex_mb, 5,7,"pix",
@@ -3651,7 +3703,9 @@ public class CLTParameters {
 				"Split combined texture images. False use multi-cluster full size texture images.");
 		gd.addNumericField("Subdivide tiles to emulate alpha",   this.tex_subdiv_tiles, 0,3,"",
 				"Subdivide tiles to smaller triangles to improve lateral resolution. Best for 1-2-4-8.");
-		gd.addNumericField("Extend sky area",                    this.tex_sky_below, 0,3,"tiles",
+		gd.addNumericField("Extend sky around",                  this.tex_sky_extra, 0,3,"tiles",
+				"additionally grow sky area (in layers) without marking it as sky.");
+		gd.addNumericField("Extend sky area down",               this.tex_sky_below, 0,3,"tiles",
 				"if >=0, extend sky these tile rows below lowest and extend sky up, right and left to full image.");
 		
 		gd.addMessage     ("Triangular mesh");
@@ -3844,10 +3898,28 @@ public class CLTParameters {
 				"Weight of BG cost relative to the FG one.");
 		gd.addNumericField("Best direction fraction",             this.lre_best_dir_frac, 5,7,"", // 0.6;  // for BG - use this fraction of all sensors in the best direction
 				"Reduce th BG cost by limiting number of considered sensor (find best consecutive ones) .");
+		
+		gd.addMessage("Trimming by temperature (tone)");
+		
+		
+		gd.addCheckbox ("Use min/max instead of averages",        this.lre_show_debug, // true
+				"when trimming by tone, use min/max of the FG/BG instead of weighted averages.");
+		gd.addNumericField("Trim by temperature radius",          this.lre_temp_radius, 5,7,"",
+				"How far to look around for FG trimming by temperature.");
+		gd.addNumericField("Min FG and BG neibs within radius",   this.lre_temp_min, 0,3,"", // 10
+				"Minimal number of each of FG/BG while trimming by temperature.");
+		gd.addNumericField("Cost weight of temperature",          this.lre_temp_weight, 5,7,"",
+				"Multiply -1.0..+1.0 range of the current pixel between average BG(-1) and FG(+1).");
+		gd.addNumericField("Minimal occlusions FG/BG difference", this.lre_min_use_occl, 5,7,"pix",
+				"Do not use occlusion costs for small FG/BG separation, only use temperature/tone based one.");
+		gd.addNumericField("FG/BG disparity difference",          this.lre_temp_disparity, 5,7,"pix",
+				"FG-BG disparity (in excess of the previous parameter) where weight of cost by obscuring equals weight of cost by temp. For lower temperature related cost increases.");
+		
 		gd.addNumericField("Minimal absolute value of the cost",  this.lre_cost_min, 5,7,"", // 1.0;  // minimal absolute value of the total cost to make changes
 				"Minimal absolute value of the total cost to make changes (opaque/transparent).");
 		gd.addNumericField("Number of the FG update iterations",  this.lre_max_trim_iterations, 0,3,"", // 10
 				"Number of iterations to recalculate FG pixels opaque/transparent state.");
+
 		gd.addMessage("Debug images generation");
 		gd.addCheckbox ("Global debug image enable",              this.lre_show_debug, // true
 				"Global debug image enable (masked by the batch mode state).");
@@ -3863,6 +3935,8 @@ public class CLTParameters {
 				"Show all-slices texture debug images with tile resolution (80x64 for Boson 640).");
 		gd.addCheckbox ("Show sky/backdrop texture expanding",    this.lre_show_sky_textures, //  false;
 				"Show how sky/backdrop texture is cut and extrapolated.");
+		gd.addNumericField("Show slices bitmap",                  this.lre_show_slice_bitmap, 0,6,"", // 10
+				"Bitmap of slices to show (-1 - all). Applies to per-slice alpha and per-slice textures.");
 		
 		gd.addTab ("Plates", "Plates filtering when building initial z-map");
 		gd.addMessage     ("********* Plates filtering when building initial z-map *********");
@@ -4857,6 +4931,10 @@ public class CLTParameters {
 		this.tex_disp_rdiffj =          gd.getNextNumber();
 		
 		this.tex_fg_bg =                gd.getNextNumber();
+		this.tex_disp_over_sky =        gd.getNextNumber();
+		this.tex_str_over_sky =         gd.getNextNumber();
+		this.tex_require_lma =          gd.getNextBoolean();
+		
 		this.tex_distort =              gd.getNextNumber();
 		this.tex_mb =                   gd.getNextNumber();
 		
@@ -4865,6 +4943,7 @@ public class CLTParameters {
 		this.tex_max_neib_lev =   (int) gd.getNextNumber();
 		this.tex_split_textures =       gd.getNextBoolean();
 		this.tex_subdiv_tiles =   (int) gd.getNextNumber();
+		this.tex_sky_extra =      (int) gd.getNextNumber();
 		this.tex_sky_below =      (int) gd.getNextNumber();
 
 		this.tex_disp_hires_tri =       gd.getNextBoolean();
@@ -4968,6 +5047,15 @@ public class CLTParameters {
 		this.lre_weight_neib=              gd.getNextNumber();  // double  
 		this.lre_weight_bg=                gd.getNextNumber();  // double  
 		this.lre_best_dir_frac=            gd.getNextNumber();  // double  
+		
+		this.lre_use_min_max=              gd.getNextBoolean(); // boolean 
+		this.lre_temp_radius=              gd.getNextNumber();  // double  
+		this.lre_temp_min=           (int) gd.getNextNumber();  // int     
+		this.lre_min_use_occl=             gd.getNextNumber();  // double  
+		this.lre_temp_weight=              gd.getNextNumber();  // double  
+		
+		this.lre_temp_disparity=           gd.getNextNumber();  // double  
+		
 		this.lre_cost_min=                 gd.getNextNumber();  // double  
 		this.lre_max_trim_iterations=(int) gd.getNextNumber();  // int     
 
@@ -4978,6 +5066,7 @@ public class CLTParameters {
 		this.lre_show_textures_combo=      gd.getNextBoolean(); // boolean 
 		this.lre_show_textures_tiles=      gd.getNextBoolean(); // boolean
 		this.lre_show_sky_textures=        gd.getNextBoolean(); // boolean   
+		this.lre_show_slice_bitmap=  (int) gd.getNextNumber();
 		
 		// end of gd.addtab     ("Lateral resolution enhancement");                                                                            
 		

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

@@ -7190,6 +7190,7 @@ public class QuadCLTCPU {
 	  public static void umTextures(
 			  final double [][][] textures, //  [nslices][nchn][i]
 			  final int    width,
+			  final boolean ignore_alpha,
 			  final double um_sigma,
 			  final double um_weight){
 		  if ((textures == null) || (textures.length==0)) {
@@ -7222,7 +7223,7 @@ public class QuadCLTCPU {
 						  for (int i = 0; i < texture.length; i++) {
 							  texture[i] = texture_orig[i] - um_weight * texture[i];
 						  }
-						  if (has_alpha) {
+						  if (has_alpha && !ignore_alpha) {
 							  for (int i = 0; i < texture.length; i++) if (texture_alpha[i] <= 0.0){
 								  texture[i] = 0.0;
 							  }
@@ -7323,6 +7324,7 @@ public class QuadCLTCPU {
 	  }
 	 
 	  public static void applyTexturesNormHist(
+			  final boolean       ignore_alpha,
 			  final double [][][] textures, //  [nslices][nchn][i]
 			  final double []     min_max,
 			  final double []     inv_table)
@@ -7341,7 +7343,7 @@ public class QuadCLTCPU {
 					  threads[ithread] = new Thread() {
 						  public void run() {
 							  for (int npix = ai.getAndIncrement(); npix < texture.length; npix = ai.getAndIncrement()) {
-								  if (!has_alpha || (texture_alpha[npix] > 0.0)) {
+								  if (!Double.isNaN(texture[npix]) && (ignore_alpha || !has_alpha || (texture_alpha[npix] > 0.0))) {
 									  double rel_in = (texture[npix] - min_max[0]) / range;
 									  if (rel_in < 0.0) {
 										  rel_in = 0.0;

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

@@ -307,7 +307,7 @@ public class TexturedModel {
 				if (!tn.isBorder(tile)) { // do not start on the border
 					for (int layer = 0; layer < layers; layer++) {
 						int n_neibs = NUM_NEIBS_FROM_BITS[num_neibs_dir[tile][layer]];
-//						if ((ncluster[tile][layer] == CLUSTER_UNASSIGNED) && (n_neibs > nn)) { // not yet assigned and >=0 neibs
+						//						if ((ncluster[tile][layer] == CLUSTER_UNASSIGNED) && (n_neibs > nn)) { // not yet assigned and >=0 neibs
 						if (!Double.isNaN(disparity_layers[layer][tile]) && (n_neibs > nn)) { // not yet assigned and >=0 neibs
 							nn = n_neibs;
 							best_tile = tile;
@@ -329,28 +329,49 @@ public class TexturedModel {
 	/**
 	 * Create a "blue sky" tile cluster with flaps, may be disconnected. Should be ran before
 	 * all other clusters are created  
+	 * @param cluster_list      empty clusters list, if Blue Sky is not empty, it will generate a cluster
+	 *                          and will be added to the list
 	 * @param disparity_layers  [layers][tiles] multi-layer disparity array with NaN
-	 *                         for non-existing tiles 
+	 *                          for non-existing tiles. This array will be modified to limit disparities
+	 *                          so they will be closer than a backdrop (blue sky) 
+	 * @param strength_layers   [layers][tiles] strength array corresponding to disparity_layers
 	 * @param blue_sky          per-tile array of the "blue sky" boolean array 
 	 * @param blue_sky_layer    layer for the "blue sky" data (should be on a single layer)
+	 * @param extra_sky_grow    additionally grow blue sky without using disparity array 
 	 * @param blue_sky_below    (only if is_sky_cluster) if >=0 - extend bounds, if <0 treat blue_sky bounds
 	 *                          same as regular ones.  
 	 * @param max_neib_lev      maximal neighbor level of borders used to generate internal int [] neib_lev
 	 *                          array. Neighbor level 0 corresponds to internal tiles that uses original
 	 *                          disparity, level 1 - neighbors of level 0 on the border or in conflict with
 	 *                          level 0. Level 2 - neighbors of 1 or in conflict with level 0, and so all.   
+	 * @param min_obj_disparity minimal disparity for non-BS objects (calculated from backdrop distance and
+	 *                          minimal absolute distance from tyhe backdrop) 
+	 * @param str_over_sky      maximal strength for extended BS area to remove weak far tiles 
+	 * @param disp_over_sky     maximal disparity for extended BS area to remove weak far tiles
+	 * @param tex_fg_bg         minimal layer disparity separation to keep both layers
 	 * @param tilesX            horizontal array dimension 
 	 * @param debugLevel        debug level - controls generation of images
-	 * @return                 TileCluster instance generated from the initial source_disparity[] array.
+	 * @return                  copy of (possibly modified disparity_layers) where tiles, corresponding to BS
+	 *                          are set to NaN - this array will be used to clusterize remaining disparity tiles.
 	 */
-	public static TileCluster buildSkyCluster(
+
+	public static double [][] buildSkyCluster(
+			final ArrayList <TileCluster> cluster_list,
 			final double [][]     disparity_layers, // should not have same tile disparity on multiple layers
+			final double [][]     strength_layers, // should not have same tile disparity on multiple layers
 			final boolean []      blue_sky, // Do not mix bs/no_bs in the same cluster 
 			final int             blue_sky_layer,
+			final int             extra_sky_grow, // 2
 			final int             blue_sky_below,
 			final int             max_neib_lev,
+			final double          min_obj_disparity, // minimal disparity of non-BS tiles (replace)
+			// filter objects over extended sky
+			final double          str_over_sky,
+			final double          disp_over_sky,
+			final double          tex_fg_bg,  // 0.1;  // Minimal FG/BG disparity difference (NaN bg if difference from FG < this)
 			final int             tilesX,
 			final int             debugLevel){
+		final int num_layers =  disparity_layers.length;
 		final int  tiles =      disparity_layers[0].length;
 		final int  tilesY =     tiles/tilesX;         
 		final int [] borders_int = new int[tiles];
@@ -364,21 +385,98 @@ public class TexturedModel {
 				public void run() {
 					for (int tile = ai.getAndIncrement(); tile < tiles; tile = ai.getAndIncrement()) {
 						if (blue_sky[tile]) {
-							int tileX = tile % tilesX;
-							int tileY = tile / tilesX;
 							anum.getAndIncrement();
 							borders_int[tile] = 0;
-							disparity_layers[blue_sky_layer][tile] = Double.NaN;
 						}
 					}
 				}
 			};
 		}		      
 		ImageDtt.startAndJoin(threads);
-		if (anum.get() == 0) {
-			return null; // no blue sky tiles exist
-		}
+		if (anum.get() > 0) {
 			final boolean [] selection = blue_sky.clone();
+			AtomicInteger anmod = new AtomicInteger(0);
+			for (int nlev = 1; nlev <= max_neib_lev; nlev++) {
+				final int fnlev = nlev;
+				tn.growSelection(
+						2,         // int              grow,           // grow tile selection by 1 over non-background tiles 1: 4 directions, 2 - 8 directions, 3 - 8 by 1, 4 by 1 more
+						selection, // final boolean [] tiles,
+						null);     // null); // final boolean [] prohibit)
+				ai.set(0);
+				for (int ithread = 0; ithread < threads.length; ithread++) {
+					threads[ithread] = new Thread() {
+						public void run() {
+							for (int tile = ai.getAndIncrement(); tile < tiles; tile = ai.getAndIncrement()) {
+								if (selection[tile] && (borders_int[tile] < 0)) {
+									borders_int[tile] = fnlev;
+									// if it is a weak far tile connected to BS area - make it 0
+									for (int nl = 0; nl <num_layers; nl++ ) {
+										double disp = disparity_layers[nl][tile];
+										double str =  strength_layers[nl][tile];
+										// if very low disparity - ok to miss even strong tile 
+										// if weak - ok to miss high disparity (it should be not that weak)
+										if (!Double.isNaN(disp) && ((disp < disp_over_sky) || (str < str_over_sky))){
+											for (int dir = 0; dir < TileNeibs.DIRS; dir++) {
+												int tile1 = tn.getNeibIndex(tile, dir);
+												if ((tile1 >= 0) && (borders_int[tile1] == 0)) {
+													disparity_layers[nl][tile] = Double.NaN; // erase
+													if (nl == blue_sky_layer) {
+														borders_int[tile] = 0; // blue sky mark as
+														anmod.getAndIncrement(); // will have to recalculate blue sky and borders
+													}
+													break; //dir, other layers continue
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					};
+				}		      
+				ImageDtt.startAndJoin(threads);
+			}
+			if (debugLevel > -2) {
+				System.out.println("buildSkyCluster(): extended Blue Sky over far weak tiles, number of modified tiles = "+anmod.get());
+			}
+			ai.set(0);
+			for (int ithread = 0; ithread < threads.length; ithread++) {
+				threads[ithread] = new Thread() {
+					public void run() {
+						for (int tile = ai.getAndIncrement(); tile < tiles; tile = ai.getAndIncrement()) {
+							if (selection[tile]) {
+								selection[tile] = borders_int[tile] == 0;
+								if (selection[tile]) {
+									blue_sky[tile] = true;
+								} else {
+									borders_int[tile] = -1; // reset for new expansion
+								}
+							}
+						}
+					}
+				};
+			}		      
+			ImageDtt.startAndJoin(threads);
+			// re-calculate borders and extra extend, do not expand blue_sky[]
+			if (extra_sky_grow > 0) {
+				tn.growSelection(
+						2 * extra_sky_grow,         // int              grow,           // grow tile selection by 1 over non-background tiles 1: 4 directions, 2 - 8 directions, 3 - 8 by 1, 4 by 1 more
+						selection, // final boolean [] tiles,
+						null);     // null); // final boolean [] prohibit)
+				ai.set(0);
+				for (int ithread = 0; ithread < threads.length; ithread++) {
+					threads[ithread] = new Thread() {
+						public void run() {
+							for (int tile = ai.getAndIncrement(); tile < tiles; tile = ai.getAndIncrement()) {
+								borders_int[tile] = selection[tile]? 0 : -1;
+							}
+						}
+					};
+				}		      
+				ImageDtt.startAndJoin(threads);
+			}
+
+
 			for (int nlev = 1; nlev <= max_neib_lev; nlev++) {
 				final int fnlev = nlev;
 				tn.growSelection(
@@ -445,6 +543,7 @@ public class TexturedModel {
 							int tileY = tile_crop / width + bounds.y ;
 							int tileX = tile_crop % width + bounds.x;
 							int tile = tileX + tileY * tilesX;
+							// keep all rectangle as 0 (not NaN) -> KEEP -> mesh
 							disparity_crop[tile_crop] = (borders_int[tile] >=0) ? 0.0 : Double.NaN;
 							border_int_crop[tile_crop] = borders_int[tile];
 						}
@@ -460,8 +559,72 @@ public class TexturedModel {
 					max_neib_lev,        // int        border_int_max,       // outer border value
 					disparity_crop,
 					true));       // boolean is_sky));
-		return tileCluster;
+			cluster_list.add(tileCluster);
+		} // if (anum.get() > 0) { - Blue Sky exists
+
+		// limit all non-BS disparities
+		ai.set(0);
+		for (int ithread = 0; ithread < threads.length; ithread++) {
+			threads[ithread] = new Thread() {
+				public void run() {
+					for (int tile = ai.getAndIncrement(); tile < tiles; tile = ai.getAndIncrement()) {
+						for (int nl = 0; nl <num_layers; nl++ ) {
+							double disp = disparity_layers[nl][tile];
+							if (blue_sky[tile] && (nl == blue_sky_layer)) {
+								disparity_layers[nl][tile] = 0.0;
+							} else if (!Double.isNaN(disp) && (disp < min_obj_disparity)) {
+								disparity_layers[nl][tile] = min_obj_disparity;
+							}
+						}
+						for (int nl = 0; nl <num_layers; nl++ ) {
+							double disp = disparity_layers[nl][tile];
+							if (!Double.isNaN(disp)) {
+								for (int nl1 = nl+1; nl1 <num_layers; nl1++ ) {
+									double disp1 = disparity_layers[nl1][tile];
+									if (!Double.isNaN(disp)) {
+										if (Math.abs(disp1 - disp) < tex_fg_bg) {
+											if (nl == blue_sky_layer) {
+												disparity_layers[nl1][tile] = Double.NaN;
+											} else if (nl1 == blue_sky_layer) {
+												disparity_layers[nl][tile] =  Double.NaN;
+												break; // go to next nl layer
+											} else if (strength_layers[nl][tile] > strength_layers[nl][tile]){
+												disparity_layers[nl1][tile] = Double.NaN;
+											} else {
+												disparity_layers[nl][tile] =  Double.NaN;
+												break; // go to next nl layer
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			};
 		}		      
+		ImageDtt.startAndJoin(threads);
+
+		final double [][] disparity_layers_out = new double [disparity_layers.length][];
+		for (int i = 0; i < disparity_layers.length; i++) {
+			disparity_layers_out[i] = disparity_layers[i].clone();
+		}
+		// now remove processed BS tiles from disparity_layers_out
+		ai.set(0);
+		for (int ithread = 0; ithread < threads.length; ithread++) {
+			threads[ithread] = new Thread() {
+				public void run() {
+					for (int tile = ai.getAndIncrement(); tile < tiles; tile = ai.getAndIncrement()) if (blue_sky[tile]){
+						disparity_layers_out[blue_sky_layer][tile] = Double.NaN;
+					}
+				}
+			};
+		}		      
+		ImageDtt.startAndJoin(threads);
+		return disparity_layers_out;
+
+	}
+
 
 	/**
 	 * Create initial cluster of connected tiles without provisions for overlap resolution
@@ -533,9 +696,9 @@ public class TexturedModel {
 				double delta_disp_diag =  (disp_adiffd + disp * disp_rdiffd) * disp_fof;
 				for (int dir = 0; dir < TileNeibs.DIRS; dir++) {
 					int tile1 = tn.getNeibIndex(tile, dir); // should always be > 0 here
-//					if (tile1 == 2849) {
-//						System.out.println("buildInitialCluster(): tile1 = "+tile1);
-//					}
+					//					if (tile1 == 2849) {
+					//						System.out.println("buildInitialCluster(): tile1 = "+tile1);
+					//					}
 					if (tile1 >= 0) {
 						double delta_disp = ((dir & 1) == 0)? delta_disp_ortho : delta_disp_diag;
 						// see if it already has a tile of the same cluster in this direction
@@ -748,7 +911,7 @@ public class TexturedModel {
 		}		
 
 
-//		final boolean [] disp_mod = new boolean[tiles]; // disparity modified from surce_disparity
+		//		final boolean [] disp_mod = new boolean[tiles]; // disparity modified from surce_disparity
 		Arrays.fill(neib_lev, -1);
 		System.arraycopy(source_disparity, 0, disparity, 0, tiles);
 		final TileNeibs tn =    new TileNeibs(tilesX, tilesY);
@@ -784,7 +947,7 @@ public class TexturedModel {
 						}
 						double disp = disparity[tile];
 						if (!Double.isNaN(disp)) {
-// 							neib_lev[tile] = (seams[tile] > 0) ? (max_neib_lev - seams[tile] + 1) : 0; // 2-> 1; 1 -> 2; 0-> 0;
+							// 							neib_lev[tile] = (seams[tile] > 0) ? (max_neib_lev - seams[tile] + 1) : 0; // 2-> 1; 1 -> 2; 0-> 0;
 							if (seams[tile] > 0) {
 								neib_lev[tile] = max_neib_lev - seams[tile] + 1;
 								initial_seam[tile] = true; 
@@ -837,13 +1000,13 @@ public class TexturedModel {
 			lor_list.ensureCapacity(loc_list.size());
 			while (!loc_list.isEmpty()) {
 				int tile = loc_list.remove(0);
-//				if (((tile >= 4028) && (tile <= 4032)) || ((tile >= 4108) && (tile <= 4112))) {
-//					System.out.println("buildTileCluster().11: tile="+tile);
-//					System.out.println();
-//				}
+				//				if (((tile >= 4028) && (tile <= 4032)) || ((tile >= 4108) && (tile <= 4112))) {
+				//					System.out.println("buildTileCluster().11: tile="+tile);
+				//					System.out.println();
+				//				}
 				// find highest neighbor of neib_lev < max_neib_lev
-//				double max_n = Double.NaN;
-//				int source_neib_level = 0; // maybe find max separately for each neib_level, and assign
+				//				double max_n = Double.NaN;
+				//				int source_neib_level = 0; // maybe find max separately for each neib_level, and assign
 				// lower disparity but lower neib_level if both conflict?
 				double [] max_n = new double [max_neib_lev];
 				Arrays.fill(max_n, Double.NaN);
@@ -886,10 +1049,10 @@ public class TexturedModel {
 				// look around, for conflicts, add if was not already there (consider using additional array?)
 				for (int dir0 = 0; dir0 < 8; dir0++) {
 					int tile = tn.getNeibIndex(tile0, dir0);
-//					if (((tile >= 4028) && (tile <= 4032)) || ((tile >= 4108) && (tile <= 4112))) {
-//						System.out.println("buildTileCluster().12: tile="+tile+", tile0="+tile0);
-//						System.out.println();
-//					}
+					//					if (((tile >= 4028) && (tile <= 4032)) || ((tile >= 4108) && (tile <= 4112))) {
+					//						System.out.println("buildTileCluster().12: tile="+tile+", tile0="+tile0);
+					//						System.out.println();
+					//					}
 					// tries many times as it does not qualify to be added
 					if ((tile >= 0) && !loc_list.contains(tile)) { // Do not check+add same tile
 						double disp = disparity[tile];
@@ -909,10 +1072,10 @@ public class TexturedModel {
 						}
 						//
 						if (!Double.isNaN(max_n)) { // got at least 1 neighbor
-//							if (((tile >= 4028) && (tile <= 4032)) || ((tile >= 4108) && (tile <= 4112))) {
-//								System.out.println("buildTileCluster().13: tile="+tile+", tile0="+tile0);
-//								System.out.println();
-//							}
+							//							if (((tile >= 4028) && (tile <= 4032)) || ((tile >= 4108) && (tile <= 4112))) {
+							//								System.out.println("buildTileCluster().13: tile="+tile+", tile0="+tile0);
+							//								System.out.println();
+							//							}
 							if (Double.isNaN(disparity[tile])) {
 								max_neib[tile] = max_n; // is it needed? Yes, for ordering
 								loc_list.add(tile);
@@ -1079,10 +1242,10 @@ public class TexturedModel {
 		}		      
 		ImageDtt.startAndJoin(threads);
 		final boolean [] dbg_discontinued_full = (debugLevel > 0)? discontinued.clone() : null;
-//		ai.set(0);
+		//		ai.set(0);
 		ati.set(0);
 		// re-create list of conflicts (with max_neib_lev only) of defined tiles with neib_lev[] < max_neib_lev
-//		loc_multi.clear();
+		//		loc_multi.clear();
 		for (int ithread = 0; ithread < threads.length; ithread++) {
 			loc_multi.add(new ArrayList<Integer>());
 			threads[ithread] = new Thread() {
@@ -1107,7 +1270,7 @@ public class TexturedModel {
 		Arrays.fill(discontinued, false);
 		ati.set(0);
 		// re-create list of conflicts (with max_neib_lev only) of defined tiles with neib_lev[] < max_neib_lev
-//		loc_multi.clear();
+		//		loc_multi.clear();
 		for (int ithread = 0; ithread < threads.length; ithread++) {
 			loc_multi.add(new ArrayList<Integer>());
 			threads[ithread] = new Thread() {
@@ -1132,7 +1295,7 @@ public class TexturedModel {
 		// filter loc_list from isolated tiles 
 
 
-//		boolean [] discontinued = new boolean [neib_lev.length];
+		//		boolean [] discontinued = new boolean [neib_lev.length];
 		// Temporarily mark loc_list with max_neib_lev+1 to remove them from averaging (later mark again)
 		/*
 		for (int tile:loc_list) {
@@ -1197,10 +1360,10 @@ public class TexturedModel {
 					break;
 				}
 				for (int tile:loc_list) {
-//					if (tile == 2608) {
-//						System.out.println("buildTileCluster().31: tile="+tile);
-//						System.out.println();
-//					}
+					//					if (tile == 2608) {
+					//						System.out.println("buildTileCluster().31: tile="+tile);
+					//						System.out.println();
+					//					}
 					neib_lev[tile] = nlev;
 					// mark new seams:
 					for (int layer = 0; layer < disparity_layers.length; layer++) {
@@ -1265,8 +1428,8 @@ public class TexturedModel {
 			System.out.println("buildTileCluster() BUG - no tiles removed from disparity_layers[] for cluster "+cluster_list.size());
 		}
 
-// Marking	discontinued max_neib_lev with max_neib_lev+1 for building meshes they should not be connected to max_neib_lev	
-// Maybe there is a more elegant way to do this.		
+		// Marking	discontinued max_neib_lev with max_neib_lev+1 for building meshes they should not be connected to max_neib_lev	
+		// Maybe there is a more elegant way to do this.		
 		ai.set(0);
 		for (int ithread = 0; ithread < threads.length; ithread++) {
 			threads[ithread] = new Thread() {
@@ -1356,9 +1519,9 @@ public class TexturedModel {
 			System.out.println("buildTileCluster(): splitting textureCluster into "+
 					num_sub + " connected ones, current cluster before them is "+cluster_list.size());
 		}
-// neib_lev[tile]
-// disparity
-// border_int
+		// neib_lev[tile]
+		// disparity
+		// border_int
 		TileCluster [] tileClusters = new TileCluster[pnum_clust[0]]; 
 		for (int nsub = 0; nsub < num_sub; nsub++) {
 			int []     neib_lev_sub =  (num_sub > 1) ? (new int [tiles]):    neib_lev;
@@ -1475,9 +1638,10 @@ public class TexturedModel {
 	 * @return                     array of consolidated (multiple non-overlapping clusters) clusters,
 	 *                             each having the full frame bounds.
 	 */
-	public static TileCluster [] clusterizeFgBg( //
+	public static TileCluster[] clusterizeFgBg( //
+			final ArrayList <TileCluster> cluster_list,			
 			final int          tilesX,
-			final double [][]  disparity_layers_src, // may have more layers
+			final double [][]  disparity_layers, // _src, // may have more layers
 			final boolean []   blue_sky, // use to expand background by blurring available data?
 			final int          blue_sky_layer,
 			final int          blue_sky_below,
@@ -1491,23 +1655,32 @@ public class TexturedModel {
 			final double       disp_adiffj,
 			final double       disp_rdiffj,
 			final int          debugLevel) {
-		final int tiles = disparity_layers_src[0].length;
+		final int layers = disparity_layers.length;
+		//		for (int i = 0 ; i < disparity_layers.length; i++) {
+		//			disparity_layers[i] = disparity_layers_src[i].clone();
+		//		}
+		final int tiles = disparity_layers[0].length;
 		final int tilesY = tiles/tilesX;
-		final int layers = disparity_layers_src.length;
 		final int [][] num_neibs_dir = new int[tiles][layers]; // -1 - none, otherwise - bitmask
 		// Needed to tell next clusters of the BG seam tiles (shared by >=2 clusters)
 		final int [][] seams_layers = new int [layers][tiles];
 		final int []   seams =        new int [tiles]; // seams matching disparity[]
 		//copy original disparity_layers_src to disparity_layers - they will be modified
-		final double [][] disparity_layers = new double [disparity_layers_src.length][];
-		for (int i = 0 ; i < disparity_layers.length; i++) {
-			disparity_layers[i] = disparity_layers_src[i].clone();
-		}
 		// maybe ncluster[][] will not be used at all - disparity_layers will be modified to NaN used tiles
 
 		// Before initial updateSeeds() - may be simplified as BS is already processed
-		final ArrayList <TileCluster> cluster_list = new ArrayList<TileCluster>();
+		//		final ArrayList <TileCluster> cluster_list = new ArrayList<TileCluster>();
 		// build blue sky first
+		// now it will be able to modify disparity_layers and sky_tiles to improve around blue sky
+		// make changes to disparity to go back to disparity_layers_src (all that are not new BS)
+		// make minimal disparity setting inside buildSkyCluster
+		// move TileCluster blueSkyCluster = buildSkyCluster(... to the caller and pass cluster_list here
+		// add
+		// 1. grey BS area (2 layers) 
+		// 2. minimal strength over grey area around BS
+		// 3. when extending, layer by layer - only extend if it has NaN over previous border level (or is level1)
+		// 4. Expand BS over NaN in grey area
+		/*
 		TileCluster blueSkyCluster = buildSkyCluster(
 				disparity_layers,     // final double [][]     disparity_layers, // should not have same tile disparity on multiple layers
 				blue_sky,             // final boolean []   blue_sky, // use to expand background by blurring available data?
@@ -1522,7 +1695,7 @@ public class TexturedModel {
 				System.out.println("clusterizeFgBg(): processed sky cluster");
 			}
 		}
-		
+		 */		
 		// calculate initial num_neibs_dir
 		updateSeeds( // and update num_neibs_dir
 				num_neibs_dir,    // final int [][]     num_neibs_dir, // [tile][layer]
@@ -1623,9 +1796,9 @@ public class TexturedModel {
 					disp_rdiff,                // final double          disp_rdiff,
 					tilesX,                    // final int             tilesX,
 					debugLevel);               // final int             debugLevel)
-//			if (debugLevel > -1000) {
-//				return null;
-//			}
+			//			if (debugLevel > -1000) {
+			//				return null;
+			//			}
 			for (int nsub = 0; nsub < tileClusters.length; nsub++) {
 				updateSeeds( // and update num_neibs_dir
 						num_neibs_dir,           // final int [][]     num_neibs_dir, // [tile][layer]
@@ -1669,8 +1842,8 @@ public class TexturedModel {
 
 			tile_start = next_seed_tile_layer[0];
 		} // while (true) {		
-//		int [] tile_stat = new int [tiles];
-//		int [] tile_layer = new int [tiles]; // just to know which layer was used for assigned tiles
+		//		int [] tile_stat = new int [tiles];
+		//		int [] tile_layer = new int [tiles]; // just to know which layer was used for assigned tiles
 		// consolidate clusters "good enough", use bounding box intersections, add cluster_gap to grow extra tiles by Gaussian
 		// cluster_gap
 		int [] comb_clusters = new int [cluster_list.size()];
@@ -1693,7 +1866,7 @@ public class TexturedModel {
 				// check to intersection with all prior clusters in this combo
 				candidate_cluster:
 				{
-//					Rectangle new_bounds = cluster_list.get(index_other).getBounds(cluster_gap); // cluster_gap should be 2x
+					//					Rectangle new_bounds = cluster_list.get(index_other).getBounds(cluster_gap); // cluster_gap should be 2x
 					Rectangle new_bounds = cluster_list.get(index_other).getBounds(); // cluster_gap should be 2x
 					for (int index_already = index_first; index_already < index_other; index_already++) if (comb_clusters[index_already] == this_combo) {
 						if (cluster_list.get(index_already).getBounds().intersects(new_bounds)) {
@@ -1806,16 +1979,22 @@ public class TexturedModel {
 		final double  disp_adiffj =       clt_parameters.tex_disp_adiffj;
 		final double  disp_rdiffj =       clt_parameters.tex_disp_rdiffj;
 		final double  tex_fg_bg =         clt_parameters.tex_fg_bg;             // 0.1;  // Minimal FG/BG disparity difference (NaN bg if difference from FG < this)
+		
+		final double  disp_over_sky =     clt_parameters.tex_disp_over_sky;     // 0.1; // Same as double          tex_fg_bg?
+		final double  str_over_sky =      clt_parameters.tex_str_over_sky;      // 0.7; // 
+		final boolean require_lma =       clt_parameters.tex_require_lma;       // true;
+		
 		final double  max_disparity_lim = clt_parameters.tex_max_disparity_lim; // 100.0;  // do not allow stray disparities above this
 		final double  min_trim_disparity =clt_parameters.tex_min_trim_disparity;//   2.0;  // do not try to trim texture outlines with lower disparities
 		final int     max_neib_lev =      clt_parameters.tex_max_neib_lev;      //   2; // 1 - single tiles layer around, 2 - two layers
 		final boolean split_textures =    clt_parameters.tex_split_textures;    // (debugLevel > 1000); // false;
 		final int     subdiv_tiles =      clt_parameters.tex_subdiv_tiles;      //   4; // subdivide tiles to smaller triangles
+		final int     extra_sky_grow =    clt_parameters.tex_sky_extra;         // 2; // not 4, as it is number of grow by 2
 		final int     sky_below =         clt_parameters.tex_sky_below;         //  10; // extend sky these tile rows below lowest
 		final boolean debug_disp_tri =    clt_parameters.tex_debug_disp_tri;    //   !batch_mode && (debugLevel > 0); // TODO: use clt_parameters
 
 		// If there is gap between clusters, add extra row of background tiles
-		int     add_bg_tiles =           clt_parameters.tex_add_bg_tiles;           // 0; // 1;
+//		int     add_bg_tiles =           clt_parameters.tex_add_bg_tiles;           // 0; // 1;
 		final boolean save_full_textures=clt_parameters.tex_save_full_textures  || !clt_parameters.tex_split_textures; //true; // false; // true;
 		final double  alpha_threshold =  clt_parameters.tex_alpha_threshold;    // 0.5;
 		final boolean renormalize =      clt_parameters.tex_renormalize;        // true; // false - use normalizations from previous scenes to keep consistent colors
@@ -1825,8 +2004,10 @@ public class TexturedModel {
 		final boolean showTri =          !batch_mode && (debugLevel > -1) && (clt_parameters.show_triangles);
 		final boolean disp_hires_tri =   !batch_mode && clt_parameters.tex_disp_hires_tri;
 		final int dbg_scale_mesh =        clt_parameters.tex_dbg_scale_mesh; //  4; // <=0 - do not show
-///		final double min_non_inf = 0.01; // relative to infinity disparity
+		///		final double min_non_inf = 0.01; // relative to infinity disparity
 		final boolean show_bs_debug =  !batch_mode &&  clt_parameters.lre_show_sky_textures; // add parameter 
+//		final boolean show_sky_textures =   clt_parameters.lre_show_sky_textures && !clt_parameters.multiseq_run;
+//		final int     show_slice_bitmap =   clt_parameters.lre_show_slice_bitmap;
 		
 		final int sky_layer = 0; // source disparity layer that contains "blue sky" 
 
@@ -1898,6 +2079,9 @@ public class TexturedModel {
 				scenes[ref_index], // QuadCLT        scene,
 				debugLevel);         // int debug_level)
 		double[][] ds_fg_bg = {ds_fg[0], ds_bg[0].clone()};
+		double[][] ss_fg_bg = {ds_fg[1], ds_bg[1]};
+
+		/*
 		for (int i = 0; i < dls_bg[0].length; i++) {
 			if (Math.abs(ds_fg_bg[1][i]-ds_fg_bg[0][i]) < tex_fg_bg) {
 				ds_fg_bg[1][i] = Double.NaN;
@@ -1916,12 +2100,12 @@ public class TexturedModel {
 				}
 			}
 		}
-		
+		 */
 		if (show_bs_debug) {
 			String [] dbg_titles = {"FG","BG","BS"};
 			double [][] dbg_img = {ds_fg_bg[0], ds_fg_bg[1],combo_dsn_final[OpticalFlow.COMBO_DSN_INDX_BLUE_SKY].clone()};
-			for (int i = 0; i < dbg_img.length; i++) {
-				dbg_img[2][i] *= 20;
+			for (int i = 0; i < dbg_img[0].length; i++) {
+				dbg_img[2][i] = sky_tiles[i]? 20:0; // *= 20;
 			}
 			ShowDoubleFloatArrays.showArrays(
 					dbg_img,
@@ -1933,10 +2117,69 @@ public class TexturedModel {
 		}
 
 		// Create data for consolidated textures (multiple texture segments combined in same "passes"
-		TileCluster [] tileClusters = clusterizeFgBg( // wrong result type, not decided
+		// now it will be able to modify ds_fg_bg and sky_tiles to improve around blue sky
+		final ArrayList <TileCluster> cluster_list = new ArrayList<TileCluster>();
+
+		if (require_lma) { // make non-LMA very weak;
+			for (int i = 0; i < ss_fg_bg.length; i++) {
+				ss_fg_bg[i]= ss_fg_bg[i].clone();
+			}
+			for (int i = 0; i < ss_fg_bg[0].length; i++) {
+				if (Double.isNaN(dls_fg[1][i])){
+					ss_fg_bg[0][i] = 0.0001;
+				}
+				if (Double.isNaN(dls_bg[1][i])){
+					ss_fg_bg[1][i] = 0.0001;
+				}
+			}
+		}
+		double [][] disparity_layers =buildSkyCluster(
+				cluster_list, // final ArrayList <TileCluster> cluster_list,
+				ds_fg_bg,          // final double [][]     disparity_layers, // should not have same tile disparity on multiple layers
+				ss_fg_bg,          // final double [][]     strength_layers, // should not have same tile disparity on multiple layers
+				sky_tiles,         // final boolean []      blue_sky, // Do not mix bs/no_bs in the same cluster 
+				sky_layer,         // final int             blue_sky_layer,
+				extra_sky_grow,    //  final int             extra_sky_grow,
+				sky_below,         // final int             blue_sky_below,
+				max_neib_lev,      // final int             max_neib_lev,
+				min_obj_disparity, // final double          min_obj_disparity, // minimal disparity of non-BS tiles (replace)
+				// filter objects over extended sky
+				str_over_sky,      // final double          str_over_sky,
+				disp_over_sky,     // final double          disp_over_sky,
+				tex_fg_bg,         // final double          tex_fg_bg,  // 0.1;  // Minimal FG/BG disparity difference (NaN bg if difference from FG < this)
+				tilesX,            // final int             tilesX,
+				debugLevel);       // final int             debugLevel)
+
+		if (show_bs_debug) {
+			String [] dbg_titles = {"FG","BG", "SFG", "SBG","BS"};
+			double [][] dbg_img = new double [dbg_titles.length][];
+			dbg_img[0] = disparity_layers[0];
+			dbg_img[1] = disparity_layers[1];
+			dbg_img[2] = ss_fg_bg[0];
+			dbg_img[3] = ss_fg_bg[1];
+			dbg_img[4] = new double [sky_tiles.length];
+			for (int i = 0; i < sky_tiles.length; i++) {
+				dbg_img[4][i] = sky_tiles[i]? 20: 0;
+			}
+			ShowDoubleFloatArrays.showArrays(
+					dbg_img,
+					tilesX,
+					dbg_img[0].length/tilesX,
+					true,
+					ref_scene.getImageName()+"-disparity_layers_after_sky",
+					dbg_titles);
+
+		}
+
+
+
+
+		TileCluster [] tileClusters = 
+				clusterizeFgBg( // wrong result type, not decided
+						cluster_list, // final ArrayList <TileCluster> cluster_list,
 						tilesX,            // final int          tilesX,
-				ds_fg_bg,          // final double [][]  disparities, // may have more layers
-				sky_tiles,         // final boolean      blue_sky, // use to expand background by blurring available data?
+						disparity_layers,  // ds_fg_bg,          // final double [][]  disparities, // may have more layers
+						sky_tiles,         // final boolean  []  blue_sky, // use to expand background by blurring available data?
 						sky_layer,         // final int          sky_layer,
 						sky_below,         // final int          blue_sky_below,
 						max_neib_lev,      // final int          max_neib_lev,
@@ -1949,7 +2192,7 @@ public class TexturedModel {
 						disp_adiffj,       // final double       disp_adiffj,
 						disp_rdiffj,       // final double       disp_rdiffj,
 						debugLevel); //1); //  2); // final int          debugLevel)
-/*
+		/*
 // Debugging up to here:
 //		if (debugLevel > -1000) {
 //			return false;
@@ -1959,7 +2202,7 @@ public class TexturedModel {
 			System.out.println("Temporary exit after clusterizeFgBg()");
 			return false;
 		}
-*/
+		 */
 		boolean [] scenes_sel = new boolean[scenes.length];
 		//		for (int i = scenes.length - 10; i <  scenes.length; i++) { // start with just one (reference) scene
 
@@ -2145,7 +2388,7 @@ public class TexturedModel {
 					}
 					continue;
 				}
-//				String texturePath = imp_texture_cluster.getTitle()+".png";
+				//				String texturePath = imp_texture_cluster.getTitle()+".png";
 				String texturePath = imp_texture_cluster.getOriginalFileInfo().fileName;
 
 				double [] scan_disparity = tileClusters[nslice].getSubDisparity(sub_i); // limited to cluster bounds
@@ -3773,19 +4016,59 @@ public class TexturedModel {
 		return masked_textures;
 	}
 
+	/**
+	 * Set disparity for extended (full rectangle normally) Blue Sky disparity for its
+	 * slice to all zeros, overwriting NaN. Results will be used to generate full mesh
+	 * over extended Sky - triangulation method uses NaN as transparency.    
+	 * @param tileClusters list if tile clusters
+	 * @param              slice_disparities per-slice (per texture image) disparity array
+	 *                     that will be modified. Disparity should be for the full image
+	 *                     array (80x64 for Flir Boson).
+	 * @param tilesX       number of tiles in a row
+	 */
+	public static void setBlueSkyDisparity(
+		final TileCluster [] tileClusters,
+		final double [][]    slice_disparities,
+		final int            tilesX)
+	{
+		int sky_slice = -1;
+		int sky_subindex = -1;
+		for (int i = 0; i < tileClusters.length; i++) {
+			sky_subindex = tileClusters[i].getSkyClusterIndex(); // finds first sky only!
+			if (sky_subindex >=0) {
+				sky_slice = i;
+				break;
+			}
+		}
+		if (sky_slice >= 0) {
+			Rectangle sky_tiles_bounds = tileClusters[sky_slice].getSubBounds(sky_subindex);
+			double [] sky_full_disparity = new double [sky_tiles_bounds.width * sky_tiles_bounds.height]; // all zeros
+			TileNeibs.setDoubleWindow(
+					sky_tiles_bounds,            // Rectangle window,
+					sky_full_disparity,                    // double [] window_data,
+					slice_disparities[sky_slice], // double [] data,
+					tilesX);                       // int data_width)
+		}
+	}
 	/**
 	 * Fill undefined sky texture tiles to its cluster full bounds 
-	 * @param tileClusters     array of tile clusters - one may have "blue sky" sub-cluster 
-	 * @param faded_textures   [slice]{texture, alpha}[pixel]
+	 * @param tileClusters      array of tile clusters - one may have "blue sky"
+	 *                          sub-cluster - it will be updated
+	 * @param textures_occluded [slice][pixel] textures that have NaN-s to be filled (read only)
+	 * @param alphas            [slice][pixel] alpha values, will be modified for BS cluster
+	 * @param textures_final    [slice][pixel] final textures, will be modified for BS cluster
 	 * @param shrink_sky_tiles shrink (currently 4 - 2 rows) defined sky tiles before filling
 	 *                         undefined pixels
 	 * @param width            image width (640 for Flir Boson)
 	 * @param transform_size   CLT transform size (==8)
 	 * @param dbg_prefix       null or debug image name prefix
 	 */
+
 	public static void extendBlueSKy(
 			final TileCluster [] tileClusters,
-			final double [][][]  faded_textures,
+			final double [][]    textures_occluded,
+			final double [][]    alphas,
+			final double [][]    textures_final,
 			final int            shrink_sky_tiles,
 			final int            width,
 			final int            transform_size,
@@ -3819,7 +4102,7 @@ public class TexturedModel {
 			final boolean [] reliable_sky = sky_sel.clone();
 			final double [] sky_pixels = TileNeibs.getDoubleWindow(
 					sky_pixels_bounds,            // Rectangle window,
-					faded_textures[sky_slice][0], // double [] data,
+					textures_occluded[sky_slice], // double [] data,
 					width);                       // int data_width)
 			final String [] dbg_titles = {"source","shrank", "hinted", "filled"};
 			final String [] dbg_tile_titles = {"start", "filled"};
@@ -3932,14 +4215,14 @@ public class TexturedModel {
 			TileNeibs.setDoubleWindow(
 					sky_pixels_bounds,            // Rectangle window,
 					sky_pixels_filled,            // double [] window_data,
-					faded_textures[sky_slice][0], // double [] data,
+					textures_final[sky_slice],    // double [] data,
 					width);                       // int data_width)
 			double [] sky_alpha = new double [sky_pixels.length];
 			Arrays.fill(sky_alpha, 1.0);
 			TileNeibs.setDoubleWindow(
 					sky_pixels_bounds,            // Rectangle window,
 					sky_alpha,                    // double [] window_data,
-					faded_textures[sky_slice][1], // double [] data,
+					alphas[sky_slice], // double [] data,
 					width);                       // int data_width)
 			if ((dbg_prefix != null) && (dbg_img != null)) {
 				ShowDoubleFloatArrays.showArrays(
@@ -3955,6 +4238,8 @@ public class TexturedModel {
 		return;
 	}
 	
+	
+	
 	/**
 	 * Fix alpha for the same disparity - version with analog alpha
 	 * @param tileClusters          array of TileCluster instances, each may consist of multiple
@@ -4431,6 +4716,7 @@ public class TexturedModel {
 	 * @param occluded_map          bitmap of blocked by FG sensors [slice][pixel]
 	 * @param min_sensors           minimal usable number of sensors visible from the FG pixel 
 	 * @param slice_disparities     [slice][tile] disparity
+	 * @param slice_clusters        [slice][tile] index of cluster, do not mix different indices
 	 * @param tile_keep             [slice][tile] tiles that have at least one opaque pixel
 	 * @param tile_stitch           [slice][tile] stitch tiles - tiles that have the same disparity in other slice
 	 * @param trim_tiles            [slice][tile] trim tiles - tiles that have trimmable pixels
@@ -4445,6 +4731,16 @@ public class TexturedModel {
 	 * @param weight_bg             weight of BG cost relative to the FG one
 	 * @param best_dir_frac         for BG - use this fraction of all sensors in the best direction
 	 * @param cost_min              minimal absolute value of the total cost to make changes
+	 * 
+	 * @param use_min_max           when trimming by tone, use min/max of the FG/BG instead of weighted averages
+	 * @param temp_radius           how far to look around for FG trimming by temperature
+	 * @param temp_min              minimal number of each of FG/BG while trimming by temperature
+	 * @param temp_weight           multiply -1.0..+1.0 range of the current pixel between average BG(-1) and FG(+1)
+	 * @param min_use_occl          minimal FG/BG difference to use trimming by occlusions. For lower
+	 *                              use only temperature/tone
+	 * @param temp_disparity        FG-BG disparity difference (in excess min_use_occl) for which weight
+	 *                              of cost by obscuring equals weight of cost by temp (for higher differences
+	 *                              tone cost diminishes and occlusion-based grows towards 1.0   
 	 * @param debug_costs           if not null, should be double [nslices][] - will return costs/NaN
 	 * @param debug_stats           if not null, should be int [nslices][] - will return number of added/removed
 	 *                              opaque pixels per slice
@@ -4460,6 +4756,7 @@ public class TexturedModel {
 			final int     [][]    occluded_map,
 			final int             min_sensors,
 			final double  [][]    slice_disparities,
+			final int     [][]    slice_clusters,
 			final boolean [][]    tile_keep, 
 			final boolean [][]    tile_stitch,  
 			final boolean [][]    trim_tiles,  
@@ -4474,12 +4771,20 @@ public class TexturedModel {
 			final double          weight_bg,
 			final double          best_dir_frac,
 			final double          cost_min,
+			//"Trimming by temperature (tone)
+			final boolean         use_min_max, // when trimming by tone, use min/max of the FG/BG instead of weighted averages
+			final double          temp_radius, //  =   11.5;  // How far to look around for FG trimming by temperature
+			final int             temp_min, //  =       2;  // Minimal number of each of FG/BG while trimming by temperature
+			final double          temp_weight, //  =   20.0;  // Multiply -1.0..+1.0 range of the current pixel between average BG(-1) and FG(+1)
+			final double          min_use_occl,// =     1.5;  // Minimal FG/BG difference to use trimming by occlusions. For lower use only
+			final double          temp_disparity, //  = 3.0;  // FG-BG disparity where weight of cost by obscuring equals weight of cost by temp   
 			// debug arrays
 			final double [][][]   debug_costs,
 			final int    [][]     debug_stats,
 			final int             width,
 			final int             transform_size){
 
+//		final double min_use_occl = 0.5 * temp_disparity; // add a separate parameter
 		final int min_sensors_bg = min_sensors; // maybe reduce? *=best_dir_frac?
 		final int num_slices =    alpha_pix.length;
 		final int img_size =      alpha_pix[0].length;
@@ -4487,21 +4792,32 @@ public class TexturedModel {
 		final int tilesX =        width/transform_size;
 		final int tilesY =        img_size/width/transform_size;
 		final int tiles =         tilesX * tilesY;
-		final int dbg_tile =      -1; // 4123;
-		final int dbg_slice =     0;
+		final int dbg_tile =      1820; // -1; // 4123;
+		final int dbg_slice =     3; //0;
+		
+		final int      iradius = (int) Math.floor(temp_radius); // 1 - 3x3, 2 - 5x5
+		final double [][] rad_weights = new double [2 * iradius + 1][2 * iradius + 1];
+		for (int dY = -iradius; dY <= iradius; dY ++) {
+			for (int dX = -iradius; dX <= iradius; dX ++) {
+				rad_weights[dY + iradius][dX + iradius] =
+						Math.cos(0.5 * Math.PI * dY / temp_radius) *
+						Math.cos(0.5 * Math.PI * dX / temp_radius);
+			}
+		}
+		
 		final Thread[] threads =  ImageDtt.newThreadArray(THREADS_MAX);
 		final AtomicInteger ai =  new AtomicInteger(0);
 		final AtomicInteger aplus =   new AtomicInteger(0); // number of added opaque pixels
 		final AtomicInteger aminus =  new AtomicInteger(0); // number of removed opaque pixels
 		final TileNeibs pn = new TileNeibs(width,height);
 		int num_modified_pixels = 0;
-		final int dbg_pix = -168170;
+		final int dbg_pix = 115680;
 		final boolean [][] new_alpha = new boolean[num_slices][img_size];
 		for (int nslice = 0; nslice < num_slices; nslice++) {
 			int fnslice = nslice;
 			System.arraycopy(alpha_pix[fnslice], 0, new_alpha[fnslice], 0, img_size);
 			if (debug_costs != null) {
-				debug_costs[fnslice] = new double [3][img_size]; // {cost, cost_fg, cost_bg}
+				debug_costs[fnslice] = new double [4][img_size]; // {cost, cost_fg, cost_bg, cost_temp}
 				for (int i = 0; i < debug_costs[fnslice].length; i++) {
 					Arrays.fill(debug_costs[fnslice][i], Double.NaN);
 				}
@@ -4518,6 +4834,8 @@ public class TexturedModel {
 							if ((fnslice == dbg_slice) && (tile == dbg_tile )) {
 								System.out.println("updateFgAlpha().1 nslice="+fnslice+", tile="+tile);
 							}
+							double disparity_fg = slice_disparities[fnslice][tile];
+							double disparity_bg = Double.NaN;
 							if (     trim_tiles [fnslice][tile] &&
 									!tile_stitch[fnslice][tile]) {
 								int tileX = tile % tilesX; 
@@ -4531,8 +4849,8 @@ public class TexturedModel {
 									if ((ns != fnslice) &&
 											tile_keep[ns][tile] &&
 											!tile_stitch[fnslice][tile] && // ***
-											(slice_disparities[ns][tile] < slice_disparities[fnslice][tile]) &&
-											((slice_disparities[fnslice][tile] - slice_disparities[ns][tile]) > min_disp_diff )) {
+											(slice_disparities[ns][tile] < disparity_fg) &&
+											((disparity_fg - slice_disparities[ns][tile]) > min_disp_diff )) {
 										double [][] offs_bg = channel_pixel_offsets[ns][tile];
 										double [][] pixel_offs = new double [num_sens][2];
 										for (int nsens = 0; nsens < num_sens; nsens++) {
@@ -4547,7 +4865,7 @@ public class TexturedModel {
 											for (int dx = 0; dx < transform_size; dx++) {
 												int px0 = tileX * transform_size + dx;
 												int pix = pix1 + dx;
-												if (pix==dbg_pix) {
+												if ((pix==dbg_pix) && (fnslice == dbg_slice)) {
 													System.out.println("updateFgAlpha().1 pix="+pix+", ns="+ns+", dx="+dx+", dy="+dy+
 															", disp_fg="+slice_disparities[fnslice][tile]+", disp_bg="+slice_disparities[ns][tile]);
 												}
@@ -4595,11 +4913,14 @@ public class TexturedModel {
 																	if (alpha_pix[ns][bg_pix] && !Double.isNaN(textures[ns][bg_pix])) { // null pointer
 																		if (!(bg_disparity[dy][dx][nsens] >= slice_disparities[ns][tile])) { // was NaN -> true
 																			bg_disparity[dy][dx][nsens] = slice_disparities[ns][tile];
+																			if (!(disparity_bg <= bg_disparity[dy][dx][nsens])) {
+																				disparity_bg = bg_disparity[dy][dx][nsens];
+																			}
 																			bg_value[dy][dx][nsens] = textures[ns][bg_pix];
-																			if (pix==dbg_pix) {
+																			if ((pix==dbg_pix) && (fnslice == dbg_slice)) {
 																				System.out.println(String.format(
-																						"%2d: bg_pix=%6d ibgx=%3d ibgy=%3d bg_value=%8.2f",
-																						nsens, bg_pix, ibgx, ibgy, bg_value[dy][dx][nsens]));
+																						"%2d: bg_pix=%6d ibgx=%3d ibgy=%3d", //  bg_value=%8.2f bg_disparity=%8.2f",
+																						nsens, bg_pix, ibgx, ibgy)); // , bg_value[dy][dx][nsens], bg_disparity[dy][dx]));
 																			}
 																		}
 																	}
@@ -4616,11 +4937,12 @@ public class TexturedModel {
 								// use bg_value[][][], bg_disparity[][][] to calculate bg weighths,
 								// calculate FG weights (same as VAR_INTER)
 								// add num neibs - 4 weight and make decisions
+								int this_clust = slice_clusters[fnslice][tile];
 								for (int dy = 0; dy < transform_size; dy++) {
 									int pix1 = pix0 + dy * width;
 									for (int dx = 0; dx < transform_size; dx++) {
 										int pix = pix1 + dx;
-										if (pix==dbg_pix) {
+										if ((pix==dbg_pix) && (fnslice == dbg_slice)) {
 											System.out.println("updateFgAlpha().2 pix="+pix);
 										}
 										if (trim_pix[fnslice][pix]) { // assign for all trim_pix
@@ -4644,7 +4966,7 @@ public class TexturedModel {
 													int num_bg=0;
 													double s2_bg = 0;
 													for (int nsens = 0; nsens < (best_dir_number-1); nsens++ ) {
-														if (pix==dbg_pix) {
+														if ((pix==dbg_pix) && (fnslice == dbg_slice)) {
 															System.out.println(String.format(
 																	"%2d: fg_value= %8.2f bg_value=%8.2f diff=%8.2f",
 																	nsens,
@@ -4652,13 +4974,16 @@ public class TexturedModel {
 																	bg_value[dy][dx][nsens],
 																	sensor_texture[fnslice][nsens][pix] - bg_value[dy][dx][nsens]));
 														}
-														if (((smask & (1 << nsens)) == 0) && (bg_disparity[dy][dx] != null) && !Double.isNaN(bg_disparity[dy][dx][nsens])) {
+														if (	((smask & (1 << nsens)) == 0) &&
+																(bg_disparity[dy][dx] != null) &&
+																!Double.isNaN(bg_disparity[dy][dx][nsens])) {
 															double db = sensor_texture[fnslice][nsens][pix] - bg_value[dy][dx][nsens];
 															s2_bg += db * db;
 															num_bg ++;
 														}
 													}													
 													double best_cost_bg = Double.NaN;
+													if (valid_bg) {
 														for (int i = 0; i < num_sens; i++ ) {
 															int nsens_plus =  (best_dir_number + i - 1) % num_sens;
 															int nsens_minus = i;
@@ -4699,6 +5024,71 @@ public class TexturedModel {
 																}
 															}
 														}
+													}
+													
+													// calculate cost_temp
+													double cost_temp = Double.NaN;
+													double ddisp = disparity_fg - disparity_bg; // FG disparity minus largest BG one;
+													if ((iradius > 0) && !Double.isNaN(disparity_bg)) {
+														double sw_bg = 0.0, swd_bg = 0.0, sw_fg = 0.0, swd_fg = 0.0;
+														int num_tfg = 0, num_tbg=0; // number of defined
+														double fg_min = Double.NaN, fg_max = Double.NaN;
+														double bg_min = Double.NaN, bg_max = Double.NaN;
+														for (int tdy = -iradius; tdy <= iradius; tdy++) {
+															// skip center
+															for (int tdx = -iradius; tdx <= iradius; tdx++) if ((tdy != 0) || (tdx != 0)){
+																int tpix = pn.getNeibIndex(pix, tdx, tdy);
+																if ((tpix >= 0) && !Double.isNaN(textures[fnslice][tpix])){
+																	// check it is the same cluster
+																	int ttileX = (tpix % width) / transform_size;
+																	int ttileY = (tpix / width) / transform_size;
+																	if (slice_clusters[fnslice][ttileX + ttileY * tilesX] != this_clust) {
+																		continue;
+																	}
+																	double w = rad_weights[tdy + iradius][tdx + iradius];
+																	double d = textures[fnslice][tpix];
+																	if (alpha_pix[fnslice][tpix]) {
+																		sw_fg += w;
+																		swd_fg += w * d;
+																		num_tfg ++;
+																		if (!(d <= fg_max)) fg_max = d;
+																		if (!(d >= fg_min)) fg_min = d;
+																		
+																	} else {
+																		sw_bg += w;
+																		swd_bg += w * d;
+																		num_tbg ++;
+																		if (!(d <= bg_max)) bg_max = d;
+																		if (!(d >= bg_min)) bg_min = d;
+																	}
+																}
+															}
+														} // for (int tdy = -iradius; tdy <= iradius; tdy++)
+														if ((num_tfg < temp_min) || (num_tbg < temp_min)) {
+															continue; // too few pixels to calculate
+														}
+														double avg_fg = swd_fg / sw_fg; // weighted average of the foreground neighbors 
+														double avg_bg = swd_bg / sw_bg; // weighted average of the background neighbors
+														if (use_min_max) {
+															if (avg_fg > avg_bg) {
+																avg_fg = fg_max;
+																avg_bg = bg_min;
+															} else {
+																avg_fg = fg_min;
+																avg_bg = bg_max;
+															}
+														}
+														if (avg_bg == avg_fg) {
+															continue; // all the same pixels?
+														}
+														//
+														
+														
+														cost_temp = 2* (textures[fnslice][pix] - avg_bg)/(avg_fg - avg_bg) - 1; // -1..+1
+													}
+													
+													
+													
 													// calculate costs
 													// maybe multiple backgrounds? Then combine them all
 													// each sensor - single BG - common array of 16?
@@ -4725,11 +5115,28 @@ public class TexturedModel {
 														// positive for more opaque, negative - for more transparent
 														double cost_neibs = weight_neib * (n_opaque - 0.5* n_neibs);
 														double cost =      Double.NaN;
-														if (Double.isNaN(cost_bg)) {
-															new_opaque = true;
+														double cost_occl =  Double.NaN;
+														double scale_occl = (ddisp >= min_use_occl) ? ((ddisp - min_use_occl)/(ddisp - min_use_occl + temp_disparity )) : 0.0;
+														if (!Double.isNaN(cost_bg) && 
+																!Double.isNaN(cost_fg) &&
+																(ddisp >= min_use_occl)) {
+															cost_occl = weight_bg*cost_bg - cost_fg;
+														}
+														// for sufficient disparity differences - keep old method
+														// with no BG -> opaque.
+														if (Double.isNaN(cost_bg)) { // && (scale_occl > 0)) {
+															new_opaque = true; // there is no BG layer at all
 														} else {
 															// cost > 0 -> opaque, cost < 0 -> transparent
-															cost = weight_bg*cost_bg - cost_fg + cost_neibs;
+															cost = (scale_occl > 0) ? cost_occl: 0.0; // could be NaN
+															if (iradius > 0) {
+																cost *= scale_occl;
+																// ddisp
+																if (!Double.isNaN(cost_temp)) {
+																	cost += temp_weight * cost_temp * (1.0 - scale_occl);
+																}
+															}
+															cost += cost_neibs;
 															if (Math.abs(cost) > cost_min) {
 																new_opaque =      cost > 0;
 																new_transparent = cost < 0;
@@ -4739,13 +5146,13 @@ public class TexturedModel {
 															debug_costs[fnslice][0][pix] = cost;
 															debug_costs[fnslice][1][pix] = cost_fg;
 															debug_costs[fnslice][2][pix] = cost_bg;
+															debug_costs[fnslice][3][pix] = cost_temp;
 															if (pix==dbg_pix) {
 																System.out.println(String.format(
-																		"cost= %8.2f cost_neibs=%8.2f cost_fg=%8.2f cost_bg=%8.2f",
-																		cost, cost_neibs, cost_fg, cost_bg));
+																		"cost= %8.2f cost_neibs=%8.2f cost_fg=%8.2f cost_bg=%8.2f f cost_temp=%8.2f",
+																		cost, cost_neibs, cost_fg, cost_bg, cost_temp));
 															}
 														}
-														
 													} // if (num_vis >= min_sensors) {
 												}
 											} else { // if (!transparent[fnslice][indx] && !opaque[fnslice][indx]) {
@@ -5179,6 +5586,7 @@ public class TexturedModel {
 	 *                           layer of tiles around defined, 3 - stitch tiles closest
 	 *                           to the edge of the cluster that has additional stitched
 	 *                           ones
+	 * @param slice_clusters     [slice][tile] cluster indices, undefined are -1                                              
 	 * @param border_int_max     maximal border level (currently ==2)
 	 * @param sensor_texture     [slice][sensor][pixel] - texture from the GPU output
 	 * @param combo_texture_in   [slice][pixel] - combined texture from all sensors. If null
@@ -5199,6 +5607,7 @@ public class TexturedModel {
 			final int            tilesX,
 			final double [][]    slice_disparities,
 			final int    [][]    slice_border_int,
+			final int  [][]      slice_clusters,
 			final int            border_int_max,
 			final double [][][]  sensor_texture,
 			final double [][]    combo_texture_in,
@@ -5207,7 +5616,7 @@ public class TexturedModel {
 			final double         min_trim_disparity, //  =  2.0;
 			final TpTask[][][]   tp_tasks_ref,       // reference tasks for each slice to get offsets			
 			final String         dbg_prefix_in) {
-//		clt_parameters.batch_run		
+		//		clt_parameters.batch_run		
 		final int    max_neib_lev =     clt_parameters.tex_max_neib_lev;      //   2; // 1 - single tiles layer around, 2 - two layers
 		final double        var_radius =      clt_parameters.lre_var_radius;       //    1.5; // 3.5;   // for variance filter of the combo disparity
 		final double        seed_inter =      clt_parameters.lre_seed_inter;       //  150; // 120; // 150;
@@ -5245,6 +5654,16 @@ public class TexturedModel {
 		final double          weight_bg =     clt_parameters.lre_weight_bg;     // 0.9; // 0.8; // 1.0; // 15.0/16; // 1.0;  // weight of BG cost relative to the FG one
 		final double          best_dir_frac = clt_parameters.lre_best_dir_frac; // 0.6;  // for BG - use this fraction of all sensors in the best direction
 		final double          cost_min =      clt_parameters.lre_cost_min;      // 1.0;  // minimal absolute value of the total cost to make changes
+		
+		//"Trimming by temperature (tone)
+		final boolean         temp_use_min_max = clt_parameters.lre_use_min_max; //  =         true;  // when trimming by tone, use min/max of the FG/BG instead of weighted averages 
+		final double          temp_radius =   clt_parameters.lre_temp_radius;   // 11.5;  // How far to look around for FG trimming by temperature
+		final int             temp_min =      clt_parameters.lre_temp_min;      // 2;  // Minimal number of each of FG/BG while trimming by temperature
+		final double          temp_weight =   clt_parameters.lre_temp_weight;   //20.0;  // Multiply -1.0..+1.0 range of the current pixel between average BG(-1) and FG(+1)   
+		final double          min_use_occl=   clt_parameters.lre_min_use_occl; //  1.5;  // Minimal FG/BG difference to use trimming by occlusions. For lower use only   
+		final double          temp_disparity= clt_parameters.lre_temp_disparity;// 3.0;  // FG-BG disparity where weight of cost by obscuring equals weight of cost by temp   
+		
+		
 		final int             max_trim_iterations = clt_parameters.lre_max_trim_iterations; //  10;
 		// debug images
 		final boolean         show_debug =              clt_parameters.lre_show_debug && !clt_parameters.multiseq_run;              //  true;
@@ -5253,6 +5672,7 @@ public class TexturedModel {
 		final boolean         show_textures_slice =     clt_parameters.lre_show_textures_slice;     //  false; //true;
 		final boolean         show_textures_combo =     clt_parameters.lre_show_textures_combo;     //  false; //true;
 		final boolean         show_textures_tiles =     clt_parameters.lre_show_textures_tiles;     //  false; //true;
+		final int             show_slice_bitmap =       clt_parameters.lre_show_slice_bitmap;
 
 		final String         dbg_prefix = show_debug ? dbg_prefix_in : null;
 
@@ -5372,7 +5792,7 @@ public class TexturedModel {
 				seed_fom,       // final double        seed_fom,   // minimal value of vars_inter/sqrt(vars_same)
 				seed_inter,     // final double        seed_inter, //  =   150;
 				width);         // final int           width)		
-// copy unbound_alpha here for debug		
+		// copy unbound_alpha here for debug		
 
 		final boolean [][] trim_seeds = (dbg_prefix != null)? new boolean [num_slices][] : null;
 		if (dbg_prefix != null) {
@@ -5494,7 +5914,7 @@ public class TexturedModel {
 				width,                    // final int            width,
 				transform_size);          // final int            transform_size)
 
-// Processing BG and FG trim
+		// Processing BG and FG trim
 		int [][] occluded_map =                  null;
 		int [][] occluded_map_enh =              null;
 		double  [][]  dbg_occluded_map =         null;
@@ -5586,6 +6006,7 @@ public class TexturedModel {
 					}
 				}
 
+// pass cluste indices				
 				updated_tiles = updateFgAlpha(
 						channel_pixel_offsets,      // final double [][][][] channel_pixel_offsets,
 						occluded_filled_textures,   // final double  [][]    textures,
@@ -5594,6 +6015,7 @@ public class TexturedModel {
 						occluded_map,// occluded_map_enh  // final int     [][]    occluded_map,   // bitmap of blocked by FG sensors
 						min_sensors,                // final int             min_sensors,    // minimal number of sensors visible from the FG pixel
 						slice_disparities,          // final double  [][]    slice_disparities,
+						slice_clusters,             // final int  [][]       slice_clusters,//       [slice][tile] index of cluster, do not mix different indices
 						tile_booleans[TILE_KEEP],   // final boolean [][]    tile_keep,      // tiles that have at least one pixel 
 						tile_booleans[TILE_STITCH], // final boolean [][]    tile_stitch,      // tiles that have at least one pixel 
 						trim_tiles,                 // final boolean [][]    trim_tiles,     // tiles that have at least one pixel 
@@ -5608,6 +6030,13 @@ public class TexturedModel {
 						weight_bg,                  // final double          weight_bg,      // weight of BG cost relative to the FG one
 						best_dir_frac,              // final double          best_dir_frac,  // for BG - use this fraction of all sensors in the best direction
 						cost_min,                   // final double          cost_min,       // minimal absolute value of the total cost to make changes
+						//"Trimming by temperature (tone)
+						temp_use_min_max,           // final boolean         use_min_max, // when trimming by tone, use min/max of the FG/BG instead of weighted averages
+						temp_radius,                // final double          temp_radius, //  =          5.0;  // How far to look around for FG trimming by temperature
+						temp_min,                   // final int             temp_min, //  =               2;  // Minimal number of each of FG/BG while trimming by temperature
+						temp_weight,                // final double          temp_weight, //  =          5.0;  // Multiply -1.0..+1.0 range of the current pixel between average BG(-1) and FG(+1)
+						min_use_occl,               // final double          min_use_occl,// =     1.5;  // Minimal FG/BG difference to use trimming by occlusions. For lower use only
+						temp_disparity,             // final double          temp_disparity, //  =       3.0;  // FG-BG disparity where weight of cost by obscuring equals weight of cost by temp   
 						debug_costs,                // final double [][]     debug_cost,     // if not null, should be double [nslices][] - will return costs/NaN
 						debug_stats,                // final int    [][]     debug_stats,    // if not null, should be int [nslices][] - will return number of added/removed per slice
 						width,                      // final int             width,
@@ -5628,32 +6057,43 @@ public class TexturedModel {
 					System.out.println (String.format("#%02d: %5d added, %5d removed (total %5d) opaque FG pixels",
 							nslice, debug_stats[nslice][0], debug_stats[nslice][1], debug_stats[nslice][0]+debug_stats[nslice][1]));
 				}
-				
+				boolean [] dbg_this_slice = new boolean[num_slices];
+				int num_show_slices = 0;
+				for (int nslice = 0; nslice< num_slices; nslice++) {
+					if ((show_slice_bitmap & (1 << nslice)) != 0) {
+						num_show_slices++;
+						dbg_this_slice[nslice] = true;
+					}
+				}
+				if (num_show_slices > 0) {
 					String [] dbg_titles0 = {"sure","before","after", "cost", "cost_fg",
-						"cost_bg", "combo", "occluded-filed", "occluded"};
+							"cost_bg", "cost_temp", "combo", "occluded-filed", "occluded"};
 					int dbg_len = width * height;
 					int sublen = dbg_titles0.length;
-				String [] dbg_titles = new String [sublen * num_slices];
+					String [] dbg_titles = new String [sublen * num_show_slices];
 					double [][] dbg_img = new double [dbg_titles.length][];
-				for (int nslice = 0; nslice< num_slices; nslice++) {
+					int indx_slice = 0;
+					for (int nslice = 0; nslice< num_slices; nslice++) if (dbg_this_slice[nslice]){
 						for (int i = 0; i < dbg_titles0.length; i++) {
-						dbg_titles[nslice * sublen + i] = dbg_titles0[i]+"-"+nslice;
+							dbg_titles[indx_slice * sublen + i] = dbg_titles0[i]+"-"+nslice;
 						}
-					dbg_img[nslice * sublen + 0] = new double [dbg_len];
-					dbg_img[nslice * sublen + 1] = new double [dbg_len];
-					dbg_img[nslice * sublen + 2] = new double [dbg_len];
+						dbg_img[indx_slice * sublen + 0] = new double [dbg_len];
+						dbg_img[indx_slice * sublen + 1] = new double [dbg_len];
+						dbg_img[indx_slice * sublen + 2] = new double [dbg_len];
 						for (int i = 0; i < dbg_len; i++) {
-						dbg_img[nslice * sublen + 0][i] =
+							dbg_img[indx_slice * sublen + 0][i] =
 									(sure_transparent[nslice][i]? 0 : 1) + (sure_opaque[nslice][i]? 2 : 0); 
-						dbg_img[nslice * sublen + 1][i] = (debug_alpha[nslice][i]? 3 : 0); 
-						dbg_img[nslice * sublen + 2][i] = (unbound_alpha[nslice][i]? 3 : 0); 
-					}
-					dbg_img[nslice * sublen + 3] = debug_costs[nslice][0];
-					dbg_img[nslice * sublen + 4] = debug_costs[nslice][1];
-					dbg_img[nslice * sublen + 5] = debug_costs[nslice][2];
-					dbg_img[nslice * sublen + 6] = gcombo_texture[nslice];
-					dbg_img[nslice * sublen + 7] = occluded_filled_textures[nslice];
-					dbg_img[nslice * sublen + 8] = occluded_textures[nslice];
+							dbg_img[indx_slice * sublen + 1][i] = (debug_alpha[nslice][i]? 3 : 0); 
+							dbg_img[indx_slice * sublen + 2][i] = (unbound_alpha[nslice][i]? 3 : 0); 
+						}
+						dbg_img[indx_slice * sublen + 3] = debug_costs[nslice][0];
+						dbg_img[indx_slice * sublen + 4] = debug_costs[nslice][1];
+						dbg_img[indx_slice * sublen + 5] = debug_costs[nslice][2];
+						dbg_img[indx_slice * sublen + 6] = debug_costs[nslice][3];
+						dbg_img[indx_slice * sublen + 7] = gcombo_texture[nslice];
+						dbg_img[indx_slice * sublen + 8] = occluded_filled_textures[nslice];
+						dbg_img[indx_slice * sublen + 9] = occluded_textures[nslice];
+						indx_slice++;
 					}
 					ShowDoubleFloatArrays.showArrays(
 							dbg_img,
@@ -5662,9 +6102,33 @@ public class TexturedModel {
 							true,
 							dbg_prefix+"-update_fg-"+niter, // +nslice,
 							dbg_titles);
+				}
 				System.out.println("updateFgAlpha() -> "+updated_tiles);
 			}
 		}
+		double [][] alphas = new double[num_slices][];
+		for (int nslice = 0; nslice < num_slices; nslice++) {
+			// replace old alpha with the new binary one
+			alphas[nslice] = new double [unbound_alpha[nslice].length];
+			for (int i = 0; i < unbound_alpha[nslice].length; i++) {
+				alphas[nslice][i] = unbound_alpha[nslice][i] ? 1.0 : 0.0;
+			}
+		}
+		
+		final int     shrink_sky_tiles =    2 * (2 +clt_parameters.tex_sky_extra); // 4; // 2; sum of 2 +bg extend 
+		final boolean grow_sky =            true;
+		if (grow_sky) {
+			// occluded_filled_textures
+			extendBlueSKy(
+					tileClusters,             // final TileCluster [] tileClusters,
+					occluded_textures,        // final double [][][]  textures_occluded,
+					alphas,                   // final double [][]    alphas,
+					occluded_filled_textures, // final double [][][]  textures_final,
+					shrink_sky_tiles,         // final int            shrink_sky_tiles,
+					width,                    // final int            width,
+					transform_size,           // final int            transform_size);
+					dbg_prefix);              // dbg_prefix);     // final String         dbg_prefix)
+		}
 
 		if (dbg_alpha_mods != null) {
 			// TODO:
@@ -5689,7 +6153,7 @@ public class TexturedModel {
 					dbg_prefix+"-update_fg-alpha", // +nslice,
 					dbg_titles);
 		}
-		
+/*
 		double [][] alphas = new double[num_slices][];
 		for (int nslice = 0; nslice < num_slices; nslice++) {
 			// replace old alpha with the new binary one
@@ -5698,9 +6162,10 @@ public class TexturedModel {
 				alphas[nslice][i] = unbound_alpha[nslice][i] ? 1.0 : 0.0;
 			}
 		}
+*/		
 
 		if ((dbg_prefix != null) && show_textures_slice) {
-			for (int nslice = 0; nslice < num_slices; nslice++) {
+			for (int nslice = 0; nslice < num_slices; nslice++) if ((show_slice_bitmap & (1 << nslice))!= 0) {
 				final double [] vars_ratio =               new double [img_size];
 				final double [] vars_fom =                 new double [img_size]; // inter/sqrt(same)
 				final double [] half_pix =                 new double [img_size];
@@ -5877,16 +6342,22 @@ public class TexturedModel {
 
 		double [][][] textures_alphas = new double [num_slices][][];
 		for (int nslice = 0; nslice < num_slices; nslice++) {
-			alphas[nslice] = new double [unbound_alpha[nslice].length];
-			for (int i = 0; i < unbound_alpha[nslice].length; i++) {
-				alphas[nslice][i] = unbound_alpha[nslice][i] ? 1.0 : 0.0;
-			}
+//			alphas[nslice] = new double [unbound_alpha[nslice].length];
+//			for (int i = 0; i < unbound_alpha[nslice].length; i++) {
+//				alphas[nslice][i] = unbound_alpha[nslice][i] ? 1.0 : 0.0;
+//			}
 			textures_alphas[nslice] = new double [][] {occluded_filled_textures[nslice], alphas[nslice]};
 		}
 		// set slice_disparities to NaN for unselected tiles - it will update tileClusters
 		setMeshTileSelection(
 				slice_disparities,         // final double  [][] slice_disparities,
 				tile_booleans[TILE_KEEP]); //final boolean [][] keep_tiles)
+		
+		setBlueSkyDisparity( // to be used during triangulation
+				tileClusters,      // final TileCluster [] tileClusters,
+				slice_disparities, // final double [][]    slice_disparities,
+				tilesX);           // final int            tilesX)
+		
 		String dbg_prefix1 = (dbg_prefix==null)? null: (dbg_prefix+"-masked");
 		if ((dbg_prefix1!=null) && show_textures_tiles) {
 			showDebugDisparities( // nop if dbg_prefix== null
@@ -5963,9 +6434,10 @@ public class TexturedModel {
 		final int     tex_hist_bins =       clt_parameters.tex_hist_bins;   //  1024 ;   
 		final int     tex_hist_segments =   clt_parameters.tex_hist_segments; // 32 ; 
 
-		final boolean show_sky_textures =   clt_parameters.lre_show_sky_textures && !clt_parameters.multiseq_run;
-		final int     shrink_sky_tiles =    4; // 2; sum of 2 +bg extend 
-		final boolean grow_sky =            true;
+//		final boolean show_sky_textures =   clt_parameters.lre_show_sky_textures && !clt_parameters.multiseq_run;
+//		final int     show_slice_bitmap =   clt_parameters.lre_show_slice_bitmap;
+//		final int     shrink_sky_tiles =    2 * (2 +clt_parameters.tex_sky_extra); // 4; // 2; sum of 2 +bg extend 
+//		final boolean grow_sky =            true;
 		final boolean alphaOverlapFix =     true; // if multiple tiles have the same (+/-?) disparity, make alpha max of them
 		final double  alphaOverlapTolerance = 0.0; // compare same disparity with tolerance (relative to disparity? make absolute meters?)
 		ImageDtt image_dtt;
@@ -6209,10 +6681,13 @@ public class TexturedModel {
 		} // for (int nslice = 0; nslice < num_slices; nslice++) {	
 
 		final double [][] slice_disparities = new double [num_slices][];
-		final int [][]    slice_border_int = new int [num_slices][];
+		final int [][]    slice_border_int = new int [num_slices][]; // 			final int  [][]      slice_clusters,
+		final int [][]    slice_clusters = new int [num_slices][];
+
 		for (int nslice = 0; nslice < num_slices; nslice++) {
 			slice_disparities[nslice] = tileClusters[nslice].getDisparity();  // disparity in the reference view tiles (Double.NaN - invalid)
 			slice_border_int[nslice] =  tileClusters[nslice].getBorderInt(); 
+			slice_clusters[nslice] =    tileClusters[nslice].getClusterIndex(); 
 		}
 		int border_int_max = tileClusters[0].getBorderIntMax();
 		double [][][] faded_textures = processTexture( //[slice]{texture, alpha}
@@ -6220,6 +6695,7 @@ public class TexturedModel {
 				tilesX,                    // final int            tilesX,
 				slice_disparities,         // final double [][]    slice_disparities,
 				slice_border_int,          // final int    [][]    slice_border_int,
+				slice_clusters, // 			final int  [][]      slice_clusters,
 				border_int_max,            // final int            border_int_max,
 				sensor_textures,           // final double [][]    sensor_texture,    // per-sensor texture value
 				null, // combo_textures,   // null, // final double []      combo_texture_in,  // average texture value
@@ -6249,7 +6725,8 @@ public class TexturedModel {
 					dbg_titles);
 
 		}
-		// Grow sky
+		// Grow sky - moved to processTexture()
+		/*
 		if (grow_sky) {
 			String dbg_prefix = show_sky_textures ? ref_scene.getImageName() : null;
 
@@ -6261,6 +6738,7 @@ public class TexturedModel {
 					transform_size,   // final int            transform_size);
 					dbg_prefix); // dbg_prefix);     // final String         dbg_prefix)
 		}
+		*/
 		// fix alpha
 		if (alphaOverlapFix) {
 			fixAlphaSameDisparity(
@@ -6271,7 +6749,8 @@ public class TexturedModel {
 					transform_size);       // final int            transform_size)			
 		}
 
-		// Is it needed here? Or move to processTexture()? - Slow
+		// Is it needed here? Or move to processTexture()?
+		// it is needed before Gaussian blur which extends NaN
 		for (int nslice = 0; nslice < faded_textures.length; nslice++) {
 			faded_textures[nslice][0] = TileProcessor.fillNaNs(
 					faded_textures[nslice][0], // final double [] data,
@@ -6280,11 +6759,11 @@ public class TexturedModel {
 					16,           // final int grow,
 					0.7,          // double    diagonal_weight, // relative to ortho
 					100,          // int       num_passes,
-					0.01,                     // final double     max_rchange, //  = 0.01
+					0.03,         // final double     max_rchange, //  = 0.01 - does not need to be accurate
 					THREADS_MAX); // final int threadsMax)      // maximal number of threads to launch 
 		}
 
-		if (debugLevel > -1) {
+		if (debugLevel > -2) {
 			double [][] dbg_textures = new double [faded_textures.length * faded_textures[0].length][faded_textures[0][0].length];
 			String [] dbg_titles = new String[dbg_textures.length];
 			String [] dbg_subtitles = new String [faded_textures[0].length];
@@ -6307,15 +6786,18 @@ public class TexturedModel {
 		}		
 
 		// Optionally apply UM (before auto/manual range)
+		final boolean um_ignore_alpha =     true;
+		final boolean hist_ignore_alpha =   true; 
 		if (tex_um) {
 			QuadCLTCPU.umTextures(
 					faded_textures,          // final double [][][] textures, //  [nslices][nchn][i]
 					tilesX * transform_size, // final int    width,
+					um_ignore_alpha,         // final boolean ignore_alpha,
 					tex_um_sigma,            // final double um_sigma,
 					tex_um_weight);          // final double um_weight)
 		}
 
-		if (debugLevel > -1) {
+		if (debugLevel > -2) {
 			double [][] dbg_textures = new double [faded_textures.length * faded_textures[0].length][faded_textures[0][0].length];
 			String [] dbg_titles = new String[dbg_textures.length];
 			String [] dbg_subtitles = new String [faded_textures[0].length];
@@ -6403,13 +6885,14 @@ public class TexturedModel {
 					norm_table, // double [] direct_table, // last is <1.0, first > 0
 					tex_hist_bins); //  int       num_bins)
 			QuadCLTCPU.applyTexturesNormHist(
+					hist_ignore_alpha, // final boolean       ignore_alpha
 					faded_textures,    // final double [][][] textures, //  [nslices][nchn][i]
 					cold_hot,          // final double []     min_max,
 					inverted_table);   // final double []     inv_table)
 		}
 
 
-		if (debugLevel > -1) {
+		if (debugLevel > -2) {
 			double [][] dbg_textures = new double [faded_textures.length * faded_textures[0].length][faded_textures[0][0].length];
 			String [] dbg_titles = new String[dbg_textures.length];
 			String [] dbg_subtitles = new String [faded_textures[0].length];
@@ -6466,6 +6949,9 @@ public class TexturedModel {
 			int                  transform_size,
 			int                  debugLevel)
 	{
+		if (debugLevel > -2) {
+			System.out.println("getInterCombinedTextures()m no_alpha=" + no_alpha); // true
+		}
 		final boolean tex_color =           clt_parameters.tex_color;     //  true;  
 		final int     tex_palette =         clt_parameters.tex_palette;     // 2 ;   
 		int num_slices = faded_textures.length;
@@ -6542,7 +7028,7 @@ public class TexturedModel {
 				int cluster_index = indices[i];
 				String title=String.format("%s-img%04d-texture",basename, cluster_index);
 				tex_clusters[cluster_index] = new ImagePlus(title, sub_stack);
-//				tex_clusters[cluster_index].getProcessor().resetMinAndMax(); // probably not needed for png
+				//				tex_clusters[cluster_index].getProcessor().resetMinAndMax(); // probably not needed for png
 			}
 		}
 		return tex_clusters;

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

@@ -269,7 +269,7 @@ class TileCluster{
 			return sub_indices;
 		}
 	}
-	public void resetClusterIndex() { // to rebuild cluster index from disparity
+	public void resetClusterIndex() { // to rebuild cluster index from disparity  NOT USED
 		this.cluster_index = null; 
 	}
 	public int [] getClusterIndex() { // (Now not) just a debug feature, no need to optimize?