working on tile processing

src/main/java/EyesisCorrectionParameters.java

@@ -2012,7 +2012,7 @@ public class EyesisCorrectionParameters {
   		
   		// 3d reconstruction
   		public boolean    show_textures    = true;  // show generated textures
-  		public boolean    debug_filters     = false;// show intermediate results of filtering
+  		public boolean    debug_filters    = false;// show intermediate results of filtering
   		public double     min_smth         = 0.25;  // 0.25 minimal noise-normalized pixel difference in a channel to suspect something    
   		public double     sure_smth        = 2.0;   // reliable noise-normalized pixel difference in a channel to have something    
   		public double     bgnd_range       = 0.3;   // disparity range to be considered background
@@ -2037,10 +2037,33 @@ public class EyesisCorrectionParameters {
   		public int        ortho_bridge     = 10;    // number of tiles to bridge over hor/vert gaps
   		public double     ortho_rms        = 0.3;   // maximal disparity RMS in a run to replace by average
   		public int        ortho_half_length = 4;    // convolve hor/vert strength by 3*(2*l+1) kernels to detect multi-tile features 
-  		public double     ortho_mix        = 0.5;   // Fraction ovf convolved ortho in a mix with raw 
+  		public double     ortho_mix        = 0.5;   // Fraction ovf convolved ortho in a mix with raw
   		
+  		public int        max_clusters     = 10;    // Maximal number of clusters to generate for one run
+  		public boolean    correct_distortions = false; // Correct lens geometric distortions in a model (will need backdrop to be corrected too)
+  		public boolean    show_triangles =    true;  // Show generated triangles
+  		public boolean    avg_cluster_disp =  false;  // Weight-average disparity for the whole cluster 
+  		public double     maxDispTriangle   = 0.2;    // Maximal disparity difference in a triangle face to show
   		
-
+  		// Thin ice parameters
+  		public double     tiRigidVertical   = 3.0;   // relative disparity rigidity in vertical direction
+  		public double     tiRigidHorizontal = 1.0;   // relative disparity rigidity in horizontal direction
+  		public double     tiRigidDiagonal   = 0.5;   // relative disparity rigidity in diagonal direction
+  		public double     tiStrengthOffset  = 0.1;   // strength "floor" - subtract (limit 0) before applying
+  		public double     tiDispScale       = 0.5;   // divide actual (disparity*eff_Strength) by this  before Math.pow and applying to T.I.
+  		public double     tiDispPow         = 0.0;   // apply pow to disparity (restore sign) for disparity difference pressure on ice
+  		public double     tiDispPull        =  .1;   // tiDispPull: multiply strength*disparity difference to pull force
+  		public double     tiDispPullPreFinal=  .1;   // Scale tiDispPull for pre-final pass
+  		public double     tiDispPullFinal   =  .01;  // Scale tiDispPull for final pass
+  		public double     tiBreak3          = 0.6;   // TI break value of abs(d0-3d1+3d2-d3)
+  		public double     tiBreak31         = 0.1;   // TI break value of (d0-3d1+3d2-d3) * (d1 - d2)
+  		public double     tiBreak21         = 0.1;   // TI break value of (-d0+d1+d2-d3) * abs(d1 - d2)
+  		public int        tiBreakMode       = 0;     // TI break mode: 0: abs(3-rd derivative), 1: -(3-rd * 1-st), 2: -(2-nd * abs(1-st))  
+  		public double     tiBreakSame       = 0.5;   // Amplify colinear breaks in neighbor tiles
+  		public double     tiBreakTurn       = 0.125; // Amplify 90-degree turnintg breaks in neighbor tiles
+  		public int        tiIterations      = 1000;  // maximal number of TI iterations for each step
+  		public int        tiPrecision       = 6;     // iteration maximal error (1/power of 10) 
+  		public int        tiNumCycles       = 5;     // Number of cycles break-smooth (after the first smooth)  
   		
   		public CLTParameters(){}
   		public void setProperties(String prefix,Properties properties){
@@ -2152,7 +2175,6 @@ public class EyesisCorrectionParameters {
   			properties.setProperty(prefix+"ortho_min_hor",    this.ortho_min_hor +"");
   			properties.setProperty(prefix+"ortho_min_vert",   this.ortho_min_vert +"");
 			properties.setProperty(prefix+"ortho_asym",       this.ortho_asym +"");
-
 			properties.setProperty(prefix+"ortho_sustain",    this.ortho_sustain +"");
   			properties.setProperty(prefix+"ortho_run",        this.ortho_run+"");
 			properties.setProperty(prefix+"ortho_minmax",     this.ortho_minmax +"");
@@ -2160,6 +2182,32 @@ public class EyesisCorrectionParameters {
 			properties.setProperty(prefix+"ortho_rms",        this.ortho_rms +"");
   			properties.setProperty(prefix+"ortho_half_length",this.ortho_half_length+"");
 			properties.setProperty(prefix+"ortho_mix",        this.ortho_mix +"");
+			
+  			properties.setProperty(prefix+"max_clusters",     this.max_clusters+"");
+			properties.setProperty(prefix+"correct_distortions",this.correct_distortions+"");
+			properties.setProperty(prefix+"show_triangles",   this.show_triangles+"");
+			properties.setProperty(prefix+"avg_cluster_disp", this.avg_cluster_disp+"");
+			properties.setProperty(prefix+"maxDispTriangle",  this.maxDispTriangle +"");
+			
+			properties.setProperty(prefix+"tiRigidVertical",  this.tiRigidVertical +"");
+			properties.setProperty(prefix+"tiRigidHorizontal",this.tiRigidHorizontal +"");
+			properties.setProperty(prefix+"tiRigidDiagonal",  this.tiRigidDiagonal +"");
+			properties.setProperty(prefix+"tiStrengthOffset", this.tiStrengthOffset +"");
+			properties.setProperty(prefix+"tiDispScale",      this.tiDispScale +"");
+			properties.setProperty(prefix+"tiDispPow",        this.tiDispPow +"");
+			properties.setProperty(prefix+"tiDispPull",       this.tiDispPull +"");
+			properties.setProperty(prefix+"tiDispPullPreFinal",this.tiDispPullPreFinal +"");
+			properties.setProperty(prefix+"tiDispPullFinal",   this.tiDispPullFinal +"");
+			properties.setProperty(prefix+"tiBreak3",         this.tiBreak3 +"");
+			properties.setProperty(prefix+"tiBreak31",        this.tiBreak31 +"");
+			properties.setProperty(prefix+"tiBreak21",        this.tiBreak21 +"");
+			properties.setProperty(prefix+"tiBreakMode",      this.tiBreakMode +"");
+			properties.setProperty(prefix+"tiBreakSame",      this.tiBreakSame +"");
+			properties.setProperty(prefix+"tiBreakTurn",      this.tiBreakTurn +"");
+  			properties.setProperty(prefix+"tiIterations",     this.tiIterations+"");
+  			properties.setProperty(prefix+"tiPrecision",      this.tiPrecision+"");
+  			properties.setProperty(prefix+"tiNumCycles",      this.tiNumCycles+"");
+			
   		}
   		public void getProperties(String prefix,Properties properties){
   			if (properties.getProperty(prefix+"transform_size")!=null) this.transform_size=Integer.parseInt(properties.getProperty(prefix+"transform_size"));
@@ -2260,13 +2308,12 @@ public class EyesisCorrectionParameters {
   			if (properties.getProperty(prefix+"bgnd_maybe")!=null)        this.bgnd_maybe=Double.parseDouble(properties.getProperty(prefix+"bgnd_maybe"));
   			if (properties.getProperty(prefix+"min_clstr_seed")!=null)    this.min_clstr_seed=Integer.parseInt(properties.getProperty(prefix+"min_clstr_seed"));
   			if (properties.getProperty(prefix+"min_clstr_lone")!=null)    this.min_clstr_lone=Integer.parseInt(properties.getProperty(prefix+"min_clstr_lone"));
-  			if (properties.getProperty(prefix+"fill_gaps")!=null)          this.fill_gaps=Integer.parseInt(properties.getProperty(prefix+"fill_gaps"));
+  			if (properties.getProperty(prefix+"fill_gaps")!=null)         this.fill_gaps=Integer.parseInt(properties.getProperty(prefix+"fill_gaps"));
   			if (properties.getProperty(prefix+"min_clstr_block")!=null)   this.min_clstr_block=Integer.parseInt(properties.getProperty(prefix+"min_clstr_block"));
   			if (properties.getProperty(prefix+"bgnd_grow")!=null)         this.bgnd_grow=Integer.parseInt(properties.getProperty(prefix+"bgnd_grow"));
   			if (properties.getProperty(prefix+"ortho_min_hor")!=null)     this.ortho_min_hor=Double.parseDouble(properties.getProperty(prefix+"ortho_min_hor"));
   			if (properties.getProperty(prefix+"ortho_min_vert")!=null)    this.ortho_min_vert=Double.parseDouble(properties.getProperty(prefix+"ortho_min_vert"));
   			if (properties.getProperty(prefix+"ortho_asym")!=null)        this.ortho_asym=Double.parseDouble(properties.getProperty(prefix+"ortho_asym"));
-
   			if (properties.getProperty(prefix+"ortho_sustain")!=null)     this.ortho_sustain=Double.parseDouble(properties.getProperty(prefix+"ortho_sustain"));
   			if (properties.getProperty(prefix+"ortho_run")!=null)         this.ortho_run=Integer.parseInt(properties.getProperty(prefix+"ortho_run"));
   			if (properties.getProperty(prefix+"ortho_minmax")!=null)      this.ortho_minmax=Double.parseDouble(properties.getProperty(prefix+"ortho_minmax"));
@@ -2274,6 +2321,32 @@ public class EyesisCorrectionParameters {
   			if (properties.getProperty(prefix+"ortho_rms")!=null)         this.ortho_rms=Double.parseDouble(properties.getProperty(prefix+"ortho_rms"));
   			if (properties.getProperty(prefix+"ortho_half_length")!=null) this.ortho_half_length=Integer.parseInt(properties.getProperty(prefix+"ortho_half_length"));
   			if (properties.getProperty(prefix+"ortho_mix")!=null)         this.ortho_mix=Double.parseDouble(properties.getProperty(prefix+"ortho_mix"));
+  			
+  			if (properties.getProperty(prefix+"max_clusters")!=null)      this.max_clusters=Integer.parseInt(properties.getProperty(prefix+"max_clusters"));
+  			if (properties.getProperty(prefix+"correct_distortions")!=null) this.correct_distortions=Boolean.parseBoolean(properties.getProperty(prefix+"correct_distortions"));
+  			if (properties.getProperty(prefix+"show_triangles")!=null)    this.show_triangles=Boolean.parseBoolean(properties.getProperty(prefix+"show_triangles"));
+  			if (properties.getProperty(prefix+"avg_cluster_disp")!=null)  this.avg_cluster_disp=Boolean.parseBoolean(properties.getProperty(prefix+"avg_cluster_disp"));
+  			if (properties.getProperty(prefix+"maxDispTriangle")!=null)   this.maxDispTriangle=Double.parseDouble(properties.getProperty(prefix+"maxDispTriangle"));
+  			
+  			if (properties.getProperty(prefix+"tiRigidVertical")!=null)   this.tiRigidVertical=Double.parseDouble(properties.getProperty(prefix+"tiRigidVertical"));
+  			if (properties.getProperty(prefix+"tiRigidHorizontal")!=null) this.tiRigidHorizontal=Double.parseDouble(properties.getProperty(prefix+"tiRigidHorizontal"));
+  			if (properties.getProperty(prefix+"tiRigidDiagonal")!=null)   this.tiRigidDiagonal=Double.parseDouble(properties.getProperty(prefix+"tiRigidDiagonal"));
+  			if (properties.getProperty(prefix+"tiStrengthOffset")!=null)  this.tiStrengthOffset=Double.parseDouble(properties.getProperty(prefix+"tiStrengthOffset"));
+  			if (properties.getProperty(prefix+"tiDispScale")!=null)       this.tiDispScale=Double.parseDouble(properties.getProperty(prefix+"tiDispScale"));
+  			if (properties.getProperty(prefix+"tiDispPow")!=null)         this.tiDispPow=Double.parseDouble(properties.getProperty(prefix+"tiDispPow"));
+  			if (properties.getProperty(prefix+"tiDispPull")!=null)        this.tiDispPull=Double.parseDouble(properties.getProperty(prefix+"tiDispPull"));
+  			if (properties.getProperty(prefix+"tiDispPullPreFinal")!=null)this.tiDispPullPreFinal=Double.parseDouble(properties.getProperty(prefix+"tiDispPullPreFinal"));
+  			if (properties.getProperty(prefix+"tiDispPullFinal")!=null)   this.tiDispPullFinal=Double.parseDouble(properties.getProperty(prefix+"tiDispPullFinal"));
+  			if (properties.getProperty(prefix+"tiBreak3")!=null)          this.tiBreak3=Double.parseDouble(properties.getProperty(prefix+"tiBreak3"));
+  			if (properties.getProperty(prefix+"tiBreak31")!=null)         this.tiBreak31=Double.parseDouble(properties.getProperty(prefix+"tiBreak31"));
+  			if (properties.getProperty(prefix+"tiBreak21")!=null)         this.tiBreak21=Double.parseDouble(properties.getProperty(prefix+"tiBreak21"));
+  			if (properties.getProperty(prefix+"tiBreakMode")!=null)       this.tiBreakMode=Integer.parseInt(properties.getProperty(prefix+"tiBreakMode"));
+  			if (properties.getProperty(prefix+"tiBreakSame")!=null)       this.tiBreakSame=Double.parseDouble(properties.getProperty(prefix+"tiBreakSame"));
+  			if (properties.getProperty(prefix+"tiBreakTurn")!=null)       this.tiBreakTurn=Double.parseDouble(properties.getProperty(prefix+"tiBreakTurn"));
+  			if (properties.getProperty(prefix+"tiIterations")!=null)      this.tiIterations=Integer.parseInt(properties.getProperty(prefix+"tiIterations"));
+  			if (properties.getProperty(prefix+"tiPrecision")!=null)       this.tiPrecision=Integer.parseInt(properties.getProperty(prefix+"tiPrecision"));
+  			if (properties.getProperty(prefix+"tiNumCycles")!=null)       this.tiNumCycles=Integer.parseInt(properties.getProperty(prefix+"tiNumCycles"));
+  			
   		}
   		
   		public boolean showDialog() {
@@ -2402,9 +2475,33 @@ public class EyesisCorrectionParameters {
   			gd.addNumericField("Minimal maximal strength in an ortho run (max. in run >=...)",                 this.ortho_minmax,  3);
   			gd.addNumericField("Number of tiles to bridge over hor/vert gaps",                                 this.ortho_bridge,   0);
   			gd.addNumericField("Maximal disparity RMS in a run to replace by average)",                        this.ortho_rms,  3);
-  			gd.addNumericField("convolve hor/vert strength by 3*(2*l+1) kernels to detect multi-tile features",this.ortho_half_length,   0);
-  			gd.addNumericField("Fraction ovf convolved ortho in a mix with raw",                              this.ortho_mix,  3);
-
+  			gd.addNumericField("Convolve hor/vert strength by 3*(2*l+1) kernels to detect multi-tile features",this.ortho_half_length,   0);
+  			gd.addNumericField("Fraction of convolved ortho in a mix with raw",                                this.ortho_mix,  3);
+  			gd.addNumericField("Maximal number of clusters to generate for one run",                           this.max_clusters,   0);
+  			gd.addCheckbox    ("Correct lens geometric distortions in a model (will need backdrop to be corrected too)", this.correct_distortions);
+  			gd.addCheckbox    ("Show generated triangles",                                                     this.show_triangles);
+  			gd.addCheckbox    ("Weight-average disparity for the whole cluster ",                              this.avg_cluster_disp);
+  			gd.addNumericField("Maximal disparity difference in a triangle face to show",                      this.maxDispTriangle,  6);
+
+  			gd.addMessage     ("--- Thin ice parameters ---");
+  			gd.addNumericField("Relative disparity rigidity in vertical direction",                            this.tiRigidVertical,  6);
+  			gd.addNumericField("Relative disparity rigidity in horizontal direction",                          this.tiRigidHorizontal,  6);
+  			gd.addNumericField("Relative disparity rigidity in diagonal   direction",                          this.tiRigidDiagonal,  6);
+  			gd.addNumericField("Strength floor - subtract (limit with 0) before applying",                     this.tiStrengthOffset,  6);
+  			gd.addNumericField("Divide actual disparity by this  before Math.pow and applying to TI",          this.tiDispScale,  6);
+  			gd.addNumericField("Apply pow to disparity (restore sign) for disparity difference pressure on TI",this.tiDispPow,  6);
+  			gd.addNumericField("tiDispPull: multiply strength*disparity difference to pull force",             this.tiDispPull,  6);
+  			gd.addNumericField("Scale tiDispPull for pre-final pass",                                          this.tiDispPullPreFinal,  6);
+  			gd.addNumericField("Scale tiDispPull for final pass",                                              this.tiDispPullFinal,  6);
+  			gd.addNumericField("TI break value of abs(d0-3d1+3d2-d3)",                                         this.tiBreak3,  6);
+  			gd.addNumericField("TI break value of (d0-3d1+3d2-d3) * (d1 - d2)",                                this.tiBreak31,  6);
+  			gd.addNumericField("TI break value of (-d0+d1+d2-d3) * abs(d1 - d2)",                              this.tiBreak21,  6);
+  			gd.addNumericField("TI break mode: +1: abs(3-rd derivative), +2: -(3-rd * 1-st), +4: -(2-nd * abs(1-st))", this.tiBreakMode,  0);
+  			gd.addNumericField("Amplify colinear breaks in neighbor tiles",                                    this.tiBreakSame,  6);
+  			gd.addNumericField("Amplify 90-degree turnintg breaks in neighbor tiles",                          this.tiBreakTurn,  6);
+  			gd.addNumericField("Maximal number of TI iterations for each step",                                this.tiIterations, 0);
+  			gd.addNumericField("Iteration maximal error (1/power of 10)",                                      this.tiPrecision,  0);
+  			gd.addNumericField("Number of cycles break-smooth (after the first smooth)",                       this.tiNumCycles,  0);
   			WindowTools.addScrollBars(gd);
   			gd.showDialog();
   			
@@ -2526,6 +2623,33 @@ public class EyesisCorrectionParameters {
   			this.ortho_rms=             gd.getNextNumber();
   			this.ortho_half_length=(int)gd.getNextNumber();
   			this.ortho_mix=             gd.getNextNumber();
+
+  			this.max_clusters=    (int) gd.getNextNumber();
+  			this.correct_distortions=   gd.getNextBoolean();
+  			this.show_triangles=        gd.getNextBoolean();
+  			this.avg_cluster_disp=      gd.getNextBoolean();
+  			this.maxDispTriangle=       gd.getNextNumber();
+
+  			this.tiRigidVertical=       gd.getNextNumber();
+  			this.tiRigidHorizontal=     gd.getNextNumber();
+  			this.tiRigidDiagonal=       gd.getNextNumber();
+  			this.tiStrengthOffset=      gd.getNextNumber();
+  			this.tiDispScale=           gd.getNextNumber();
+  			this.tiDispPow=             gd.getNextNumber();
+  			this.tiDispPull=            gd.getNextNumber();
+  			this.tiDispPullPreFinal=    gd.getNextNumber();
+  			this.tiDispPullFinal=       gd.getNextNumber();
+  			this.tiBreak3=              gd.getNextNumber();
+  			this.tiBreak31=             gd.getNextNumber();
+  			this.tiBreak21=             gd.getNextNumber();
+  			this.tiBreakMode=     (int) gd.getNextNumber();
+  			this.tiBreakSame=           gd.getNextNumber();
+  			this.tiBreakTurn=           gd.getNextNumber();
+  			this.tiIterations=    (int) gd.getNextNumber();
+  			this.tiPrecision=     (int) gd.getNextNumber();
+  			this.tiNumCycles=     (int) gd.getNextNumber();
+  			
+  			
   			return true;
   		}
     }

src/main/java/GeometryCorrection.java

@@ -6,7 +6,7 @@ import ij.IJ;
  ** GeometryCorrection - geometry correction for multiple sensors sharing the same
  ** lens radial distortion model
  **
- ** Copyright (C) 2016 Elphel, Inc.
+ ** Copyright (C) 2017 Elphel, Inc.
  **
  ** -----------------------------------------------------------------------------**
  **  
@@ -323,6 +323,33 @@ public class GeometryCorrection {
 		return this.pixelCorrectionHeight * 0.001 * this.pixelSize / this.focalLength;
 	}
 
+	public double getScaleDzDx()
+	{
+		return ( 0.001 * this.pixelSize) / this.focalLength;
+	}
+	
+	
+	/*
+	 * Get real world coordinates from pixel coordinates and nominal disparity 
+	 */
+	public double [] getWorldCoordinates(
+			double px,
+			double py,
+			double disparity,
+			boolean correctDistortions) // correct distortion (will need corrected background too !)
+	{
+		double pXcd = px - 0.5 * this.pixelCorrectionWidth;
+		double pYcd = py - 0.5 * this.pixelCorrectionHeight;
+		double rD = Math.sqrt(pXcd*pXcd + pYcd*pYcd)*0.001*this.pixelSize; // distorted radius in a virtual center camera
+		double rND2R = correctDistortions?(getRByRDist(rD/this.distortionRadius, false)): 1.0;
+		double pXc = pXcd * rND2R; // non-distorted coordinates relative to the (0.5 * this.pixelCorrectionWidth, 0.5 * this.pixelCorrectionHeight)
+		double pYc = pYcd * rND2R; // in pixels
+		double z = -SCENE_UNITS_SCALE * this.focalLength * this.disparityRadius / (disparity * 0.001*this.pixelSize); // "+" - near, "-" far
+		double x =  SCENE_UNITS_SCALE * pXc * this.disparityRadius / disparity;
+		double y = -SCENE_UNITS_SCALE * pYc * this.disparityRadius / disparity;
+		double [] xyz = {x,y,z};
+		return xyz;
+	}
 	/*
 	 * Calculate pixel coordinates for each of numSensors images, for a given (px,py) of the idealized "center" (still distorted) image
 	 * and generic diparity, measured in pixels 
@@ -343,8 +370,6 @@ public class GeometryCorrection {
 		double [] a={this.distortionC,this.distortionB,this.distortionA,this.distortionA5,this.distortionA6,this.distortionA7,this.distortionA8};
 		for (int i = 0; i < numSensors; i++){
 			// non-distorted XY of the shifted location of the individual sensor
-//			double pXci = pXc + disparity *  this.rXY[i][0]; // in pixels
-//			double pYci = pYc + disparity *  this.rXY[i][1];
 			double pXci = pXc - disparity *  this.rXY[i][0]; // in pixels
 			double pYci = pYc - disparity *  this.rXY[i][1];
 			// calculate back to distorted

src/main/java/QuadCLT.java

@@ -3558,16 +3558,20 @@ public class QuadCLT {
 			  int tilesX,
 			  int tilesY,
 			  Rectangle bounds){
-		  int width =   tileSize*bounds.width + 1; 
-		  int height =  tileSize*bounds.height + 1;
+//		  int width =   tileSize*bounds.width + 1; 
+//		  int height =  tileSize*bounds.height + 1;
+		  int width =   tileSize*bounds.width; 
+		  int height =  tileSize*bounds.height;
 		  // Adding row/column of all 0, assuming java zeroes arrays
 		  int numSlices = imgData.length;
 		  double [][] rslt = new double [numSlices][width*height];
 		  int offset = (tileSize*bounds.y)*tileSize*tilesX + (tileSize*bounds.x); 
 //		  System.out.println("bounds = {.x:"+bounds.x + ", .y=" + bounds.y + ", .width=" + bounds.width + ", .height=" + bounds.height+ ", numSlices="+numSlices);
 //		  System.out.println("offset = " + offset+ " tileSize = "+tileSize);
-		  for (int y = 0; y < (height - 1); y ++){
-			  for (int x = 0; x < width-1; x ++){
+//		  for (int y = 0; y < (height - 1); y ++){
+//			  for (int x = 0; x < width-1; x ++){
+		  for (int y = 0; y < height; y ++){
+			  for (int x = 0; x < width; x ++){
 				  int indx = width * y + x; 
 				  int indx_in = indx + offset;
 				  for (int i = 0; i < numSlices; i++) {
@@ -4732,13 +4736,9 @@ public class QuadCLT {
 					tp.clt_3d_passes);
 		  
 		  x3dOutput.generateBackground();
- 		  String path= correctionsParameters.selectX3dDirectory(
+ 		  String x3d_path= correctionsParameters.selectX3dDirectory(
 				  true,  // smart,
 				  true);  //newAllowed, // save
- 		  if (path != null){
- 			  path+=Prefs.getFileSeparator()+name+".x3d";
- 			  x3dOutput.generateX3D(path);
- 		  }
  		  
 		  // testing 2-nd pass
 		  tp.secondPassSetup( // prepare tile tasks for the second pass based on the previous one(s)
@@ -4751,6 +4751,7 @@ public class QuadCLT {
 				  clt_parameters.bgnd_maybe, // double            this_maybe,       // maximal strength to ignore as non-background
 				  clt_parameters.sure_smth, // sure_smth,        // if 2-nd worst image difference (noise-normalized) exceeds this - do not propagate bgnd
 				  ImageDtt.DISPARITY_INDEX_CM,  // index of disparity value in disparity_map == 2 (0,2 or 4)
+				  geometryCorrection,
 				  threadsMax,  // maximal number of threads to launch                         
 				  updateStatus,
 				  debugLevel);
@@ -4770,12 +4771,13 @@ public class QuadCLT {
 
 			  
 		  }
-		  int scan_limit = 10; 
-		  for (int scanIndex = 1; (scanIndex < tp.clt_3d_passes.size()) && (scanIndex < scan_limit); scanIndex++){ // just temporary limiting
+//		  int scan_limit = 10; 
+		  for (int scanIndex = 1; (scanIndex < tp.clt_3d_passes.size()) && (scanIndex < clt_parameters.max_clusters); scanIndex++){ // just temporary limiting
 			  if (debugLevel > -1){
-				  System.out.println("Generating cluster images, hardwired limit of "+scan_limit+" largest, scan #"+scanIndex);
+				  System.out.println("Generating cluster images (limit is set to "+clt_parameters.max_clusters+") largest, scan #"+scanIndex);
 			  }
-			  ImagePlus cluster_image = getPassImage( // get image form a single pass
+//			  ImagePlus cluster_image = getPassImage( // get image form a single pass
+			  String texturePath = getPassImage( // get image form a single pass
 					  clt_parameters,
 					  colorProcParameters,
 					  rgbParameters,
@@ -4784,15 +4786,126 @@ public class QuadCLT {
 					  threadsMax,  // maximal number of threads to launch                         
 					  updateStatus,
 					  debugLevel);
+			  
+			  TileProcessor.CLTPass3d scan = tp.clt_3d_passes.get(scanIndex);
+			  
+			  // TODO: use new updated disparity, for now just what was forced for the picture
+			  double [] scan_disparity = new double [tp.tilesX * tp.tilesY];
+			  int indx = 0;
+			  for (int ty = 0; ty < tp.tilesY; ty ++) for (int tx = 0; tx < tp.tilesX; tx ++){
+				  scan_disparity[indx++] = scan.disparity[ty][tx];
+			  }
+			  if (clt_parameters.avg_cluster_disp){
+				  double sw = 0.0, sdw = 0.0;
+				  for (int i = 0; i< scan_disparity.length; i++){
+					  if (scan.selected[i] && !scan.border_tiles[i]){
+						  double w = scan.disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX][i];
+						  sw +=w;
+						  sdw += scan_disparity[i]*w;
+					  }
+				  }
+				  sdw/=sw;
+				  for (int i = 0; i< scan_disparity.length; i++){
+					  scan_disparity[i] = sdw;
+				  }
+				  
+				  
+			  }
+			  generateClusterX3d(
+					  x3dOutput,
+					  texturePath,
+					  scan.bounds,
+					  scan.selected,
+					  scan_disparity, // scan.disparity_map[ImageDtt.DISPARITY_INDEX_CM],
+					  clt_parameters.transform_size,
+					  clt_parameters.correct_distortions, // requires backdrop image to be corrected also
+					  (scanIndex <2) && clt_parameters.show_triangles,
+					  clt_parameters.bgnd_range,
+					  clt_parameters.other_range,
+					  clt_parameters.maxDispTriangle); 
+			  
 		  }
 
 		  // now generate and save texture files (start with full, later use bounding rectangle?)
 		  
 		  
+		  
+		  
+		  
+ 		  if (x3d_path != null){
+ 			 x3d_path+=Prefs.getFileSeparator()+name+".x3d";
+ 			  x3dOutput.generateX3D(x3d_path);
+ 		  }
  		  
 		  return imp_bgnd; // relative (to x3d directory) path - (String) imp_bgnd.getProperty("name");
 	  }
 
+	  public void generateClusterX3d(
+			  X3dOutput  x3dOutput,
+			  String     texturePath,
+			  Rectangle  bounds,
+			  boolean [] selected,
+			  double []  disparity,
+			  int        tile_size,
+			  boolean    correctDistortions, // requires backdrop image to be corrected also
+			  boolean    show_triangles,
+			  double     min_disparity,
+			  double     max_disparity,
+			  double     maxDispTriangle
+			  ) 
+	  {
+		  int [][] indices =  tp.getCoordIndices( // starting with 0, -1 - not selected
+				  bounds,
+				  selected);
+		  double [][] texCoord = tp.getTexCoords( // get texture coordinates for indices
+				  indices);
+		  double [][] worldXYZ = tp.getCoords( // get world XYZ in meters for indices
+				  disparity,
+				  min_disparity,
+				  max_disparity,
+				  bounds,
+				  indices,
+				  tile_size,
+				  correctDistortions, // requires backdrop image to be corrected also
+				  this.geometryCorrection);
+				  
+          double [] indexedDisparity = tp.getIndexedDisparities( // get disparity for each index
+							disparity,
+							min_disparity,
+							max_disparity,
+							bounds,
+							indices,
+							tile_size);
+
+		  int [][] triangles = 	tp.triangulateCluster(
+				  indices);
+		  
+		  
+		  triangles = 	tp.filterTriangles(
+					triangles,
+					indexedDisparity, // disparities per vertex index
+					maxDispTriangle); // maximal disparity difference in a triangle
+		  
+		  
+		  if (show_triangles) {
+			  tp.testTriangles(
+					  texturePath,
+					  bounds,
+					  selected,
+					  disparity,
+					  tile_size,
+					  indices,
+					  triangles);
+		  }
+
+		  x3dOutput.addCluster(
+				  texturePath,
+				  texCoord,
+				  worldXYZ,
+				  triangles);
+	  }
+	  
+	  
 	  public ImagePlus getBackgroundImage(
 			  EyesisCorrectionParameters.CLTParameters           clt_parameters,
 			  EyesisCorrectionParameters.ColorProcParameters colorProcParameters,
@@ -4936,7 +5049,8 @@ public class QuadCLT {
 	  
 	  
 	  
-	  public ImagePlus getPassImage( // get image form a single pass
+//	  public ImagePlus getPassImage( // get image form a single pass
+	 public String getPassImage( // get image form a single pass, return relative path for x3d
 			  EyesisCorrectionParameters.CLTParameters           clt_parameters,
 			  EyesisCorrectionParameters.ColorProcParameters colorProcParameters,
 			  EyesisCorrectionParameters.RGBParameters             rgbParameters,
@@ -5011,8 +5125,10 @@ public class QuadCLT {
 		  
 		  
 		  
-		  int width = resize ? (clt_parameters.transform_size * scan.bounds.width + 1): (clt_parameters.transform_size * tp.tilesX);
-		  int height = resize ? (clt_parameters.transform_size * scan.bounds.height + 1): (clt_parameters.transform_size * tp.tilesY);
+//		  int width = resize ? (clt_parameters.transform_size * scan.bounds.width + 1): (clt_parameters.transform_size * tp.tilesX);
+//		  int height = resize ? (clt_parameters.transform_size * scan.bounds.height + 1): (clt_parameters.transform_size * tp.tilesY);
+		  int width = resize ? (clt_parameters.transform_size * scan.bounds.width): (clt_parameters.transform_size * tp.tilesX);
+		  int height = resize ? (clt_parameters.transform_size * scan.bounds.height): (clt_parameters.transform_size * tp.tilesY);
 
 //    	  sdfa_instance = new showDoubleFloatArrays(); // just for debugging?		  
 //     	  sdfa_instance.showArrays(texture_rgbx, width, height, true, "texture_rgbx");
@@ -5044,7 +5160,7 @@ public class QuadCLT {
 					  correctionsParameters.png,
 					  clt_parameters.show_textures,
 					  -1); // jpegQuality){//  <0 - keep current, 0 - force Tiff, >0 use for JPEG
-		  return imp_texture_cluster;
+		  return imp_texture_cluster.getTitle()+".png"; // imp_texture_cluster;
 	  }
 
 	  

src/main/java/X3dOutput.java

-import java.util.ArrayList;
-
-import java.io.File;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
-import javax.xml.transform.OutputKeys;
-import javax.xml.transform.Transformer;
-import javax.xml.transform.TransformerException;
-import javax.xml.transform.TransformerFactory;
-import javax.xml.transform.dom.DOMSource;
-import javax.xml.transform.stream.StreamResult;
-
-import org.w3c.dom.Attr;
-import org.w3c.dom.Document;
-import org.w3c.dom.Element;
 
 /**
  **
@@ -38,6 +22,23 @@ import org.w3c.dom.Element;
  ** -----------------------------------------------------------------------------**
  **
  */
+import java.util.ArrayList;
+
+import java.io.File;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
 // Will use 1m units
 
 public class X3dOutput {
@@ -50,6 +51,7 @@ public class X3dOutput {
 	Element     el_X3d;
 	Element     el_Scene;
 	Element     el_TopGroup;
+	public int  max_line_length = 0; // 100; // 0 - no limit
 
 	public X3dOutput(
 			EyesisCorrectionParameters.CLTParameters        clt_parameters,
@@ -106,6 +108,87 @@ public class X3dOutput {
         el_Bgnd.setAttribute("bottomUrl",   bgnd_pass.texture);
 		el_Scene.appendChild(el_Bgnd);
 	}
+	
+	public void addCluster(
+			String url,
+			double [][] texCoord,
+			double [][] coordinate,
+			int [][] triangles)
+	{
+		//	public int  max_line_length = 100; // 0 - no limit
+		int linepos = 0;
+		StringBuffer sb_coord_index = new StringBuffer();
+		for (int i = 0; i < triangles.length; i++){
+			if ((max_line_length > 0) && ((sb_coord_index.length()-linepos) >= max_line_length)){
+				sb_coord_index.append("\n");
+				linepos = 0;
+			} else if ((linepos > 0) || ((max_line_length == 0) && (sb_coord_index.length() > 0))){
+				sb_coord_index.append(" ");
+			}
+//			sb_coord_index.append(triangles[i][0]+" "+triangles[i][1]+" "+triangles[i][2]+" -1");
+			sb_coord_index.append(triangles[i][2]+" "+triangles[i][1]+" "+triangles[i][0]+" -1");
+		}
+		StringBuffer sb_coords = new StringBuffer();
+		linepos = 0;
+		for (int i = 0; i < coordinate.length; i++){
+			if ((max_line_length >0) && ((sb_coords.length()-linepos) >= max_line_length)){
+				sb_coords.append("\n");
+				linepos = 0;
+			} else if ((linepos > 0) || ((max_line_length == 0) && (sb_coords.length() > 0))){
+				sb_coords.append(" ");
+			}
+			sb_coords.append(String.format("%.3f %.3f %.3f", coordinate[i][0], coordinate[i][1], coordinate[i][2]));
+		}
+		StringBuffer sb_tex_coords = new StringBuffer();
+		linepos = 0;
+		for (int i = 0; i < texCoord.length; i++){
+			if ((max_line_length >0) && ((sb_tex_coords.length()-linepos) >= max_line_length)){
+				sb_tex_coords.append("\n");
+				linepos = 0;
+			} else if ((linepos > 0) || ((max_line_length == 0) && (sb_tex_coords.length() > 0))){
+				sb_tex_coords.append(" ");
+			}
+			sb_tex_coords.append(String.format("%.4f %.4f", texCoord[i][0], texCoord[i][1]));
+		}
+		String sindex =  sb_coord_index.toString(); // for both coordIndex and texCoordIndex
+		String scoord =  sb_coords.toString();
+		String stcoord = sb_tex_coords.toString();
+		
+        Element el_shape =        x3dDoc.createElement("Shape");
+		el_Scene.appendChild(el_shape);
+		
+        Element el_appearance =   x3dDoc.createElement("Appearance");
+		el_shape.appendChild(el_appearance);
+
+        Element el_material =   x3dDoc.createElement("Material");
+		el_appearance.appendChild(el_material);
+		el_material.setAttribute("diffuseColor",    "0.376471 0.5 0.376471");
+		
+		
+        Element el_imageTexture = x3dDoc.createElement("ImageTexture");
+        el_imageTexture.setAttribute("url",url);
+        el_appearance.appendChild(el_imageTexture);
+        
+        Element el_IFC =          x3dDoc.createElement("IndexedFaceSet");
+        el_IFC.setAttribute("coordIndex",    sindex); // can it be reused?
+        el_IFC.setAttribute("texCoordIndex", sindex);
+        el_shape.appendChild(el_IFC);
+        
+        Element el_coordinate =   x3dDoc.createElement("Coordinate");
+        el_coordinate.setAttribute("point",    scoord);
+        el_IFC.appendChild(el_coordinate);
+
+        Element el_texCoordinate =   x3dDoc.createElement("TextureCoordinate");
+        el_texCoordinate.setAttribute("point",    stcoord);
+        el_IFC.appendChild(el_texCoordinate);
+        
+        
+        
+}
+	
+	
+	
+	
 	// close document, generate x3d file
 	public void generateX3D(String path)
 	{
@@ -130,46 +213,10 @@ public class X3dOutput {
 
 	public double [][] getBBox() // center: x,y,z, size:x,y,z
 	{
-		double depth =  geometry_correction.getZFromDisparity(clt_parameters.bgnd_range);
+		double depth =  geometry_correction.getZFromDisparity(clt_parameters.bgnd_range); 
 		double width  = depth * geometry_correction.getFOVWidth();
 		double height = depth * geometry_correction.getFOVHeight();
-		double [][] bbox = {{0, 0, depth/2},{width,height,depth}};
+		double [][] bbox = {{0, 0, -depth/2},{width,height,depth}};
 		return bbox;
 	}
 }
-/*
-An IndexedFaceSet geometry node creates geometry out of faces
-
-    texCoord and texCoordIndex - specify texture pieces 
-
-Shape {
-    appearance Appearance { . . . }
-    geometry IndexedFaceSet {
-        coord Coordinate { . . . }
-        coordIndex [ . . . ]
-        texCoord TextureCoordinate { . . . }
-        texCoordIndex [ . . . ]
-    }
-}
-<IndexedFaceSet coordIndex="0 1 2 -1 0 2 3 -1 ..." texCoordIndex="0 1 2 -1 0 2 3 -1 ...">
- <Coordinate point="-37.500000 4.000000 -46.450000 .../>
- <TextureCoordinate point="-37.500000 4.000000 -46.450000 .../>
- </IndexedFaceSet>
- 
- 
- <Shape DEF='Back'>
-<IndexedFaceSet coordIndex='7 6 5 4' texCoordIndex='0 1 2 3'>
-<Coordinate USE='Points'/>
-<TextureCoordinate USE='DefaultTextureCoordinate'/>
-</IndexedFaceSet>
-<Appearance>
-<ImageTexture
-  url=' "images/back.png" "http://x3dGraphics.com/examples/X3dForAdvancedModeling/GeometricShapes/images/back.png" "http://www.web3d.org/x3d/content/examples/Basic/DistributedInteractiveSimulation/images/back.png" '/>
-<TextureTransform USE='RotateRight'/>
-</Appearance>
-</Shape>
-
- 
- 
-
-*/
\ No newline at end of file