Low texture areas - debugging averaging correlation with surface (27498290) · Commits · Elphel / imagej-elphel

src/main/java/BiQuadParameters.java

+24 −15

Original line number	Diff line number	Diff line
		@@ -156,11 +156,12 @@ public class BiQuadParameters {
		// filtering lt candidates
		public double ltavg_min_disparity = -1.0; // any
		public double ltavg_max_density = 0.1;
		public int ltavg_grow = 4; // each 2 add 8 directions step. Odd have last step in 4 ortho directions only.
		public int ltavg_shrink = 2; // shrink after expanding. Combination of both fills small gaps
		public int ltavg_gap_hwidth = 2; // maximal radius of a void to be filled
		public int ltavg_clust_hwidth = 5; // minimal radius of a cluster to keep
		public int ltavg_extra_grow = 1; // additionally grow low-textured areas selections
		// smoothing parameters
		public boolean ltavg_smooth_strength = false; // provide tile strength when smoothing target disparity
		public double ltavg_neib_pull = 0.2; // pull to weighted average relative to pull to the original disparity value. If 0.0 - will only update former NaN-s
		public double ltavg_neib_pull = 1.0; // pull to weighted average relative to pull to the original disparity value. If 0.0 - will only update former NaN-s
		public int ltavg_max_iter = 20; //
		public double ltavg_min_change = 0.01; //

		@@ -461,10 +462,12 @@ public class BiQuadParameters {
		"May be used to mask out infinity background");
		gd.addNumericField("Maximal density to consider it to be low textured area", this.ltavg_max_density, 4,6,"",
		"Select areas with lower density");
		gd.addNumericField("Grow selection, each two units get expanion in 8 directions", this.ltavg_grow, 0,3,"",
		"Two steps give one-tile expansion in 8 directions, odd numbers expand only in 4 ortho directions on the last expansion");
		gd.addNumericField("Shrink selection after growing", this.ltavg_shrink, 0,3,"",
		"Grow followed by shring fill small gaps");
		gd.addNumericField("Maximal radius of a void in low-texture selection to fill" , this.ltavg_gap_hwidth, 0,3,"",
		"Low textured selection may have gaps that will be filled");
		gd.addNumericField("Minimal radius of a low-textured cluster to process", this.ltavg_clust_hwidth, 0,3,"",
		"Remove low-textured areas smaller that twice this size in each orthogonal directions");
		gd.addNumericField("Additionally grow low-textured areas selections", this.ltavg_extra_grow, 0,3,"",
		"Low textured areas will be grown by the radius of correlation averaging plus this value");
		gd.addCheckbox ("Use tile strengths when filling gaps/smoothing", this.ltavg_smooth_strength,
		"Unchecked - consider all tiles to have the same strength");
		gd.addNumericField("Relative pull of the nieghbor tiles compared to the original disparity" , this.ltavg_neib_pull, 4,6,"",
		@@ -678,8 +681,9 @@ public class BiQuadParameters {
		this.ltavg_dens_radius= (int) gd.getNextNumber();
		this.ltavg_min_disparity= gd.getNextNumber();
		this.ltavg_max_density= gd.getNextNumber();
		this.ltavg_grow= (int) gd.getNextNumber();
		this.ltavg_shrink= (int) gd.getNextNumber();
		this.ltavg_gap_hwidth= (int) gd.getNextNumber();
		this.ltavg_clust_hwidth= (int) gd.getNextNumber();
		this.ltavg_extra_grow= (int) gd.getNextNumber();
		this.ltavg_smooth_strength= gd.getNextBoolean();
		this.ltavg_neib_pull= gd.getNextNumber();
		this.ltavg_max_iter= (int) gd.getNextNumber();
		@@ -846,8 +850,10 @@ public class BiQuadParameters {
		properties.setProperty(prefix+"ltavg_dens_radius", this.ltavg_dens_radius+"");
		properties.setProperty(prefix+"ltavg_min_disparity", this.ltavg_min_disparity+"");
		properties.setProperty(prefix+"ltavg_max_density", this.ltavg_max_density+"");
		properties.setProperty(prefix+"ltavg_grow", this.ltavg_grow+"");
		properties.setProperty(prefix+"ltavg_shrink", this.ltavg_shrink+"");
		properties.setProperty(prefix+"ltavg_gap_hwidth", this.ltavg_gap_hwidth+"");
		properties.setProperty(prefix+"ltavg_clust_hwidth", this.ltavg_clust_hwidth+"");
		properties.setProperty(prefix+"ltavg_extra_grow", this.ltavg_extra_grow+"");

		properties.setProperty(prefix+"ltavg_smooth_strength", this.ltavg_smooth_strength+"");
		properties.setProperty(prefix+"ltavg_neib_pull", this.ltavg_neib_pull+"");
		properties.setProperty(prefix+"ltavg_max_iter", this.ltavg_max_iter+"");
		@@ -1015,8 +1021,10 @@ public class BiQuadParameters {
		if (properties.getProperty(prefix+"ltavg_dens_radius")!=null) this.ltavg_dens_radius=Integer.parseInt(properties.getProperty(prefix+"ltavg_dens_radius"));
		if (properties.getProperty(prefix+"ltavg_min_disparity")!=null) this.ltavg_min_disparity=Double.parseDouble(properties.getProperty(prefix+"ltavg_min_disparity"));
		if (properties.getProperty(prefix+"ltavg_max_density")!=null) this.ltavg_max_density=Double.parseDouble(properties.getProperty(prefix+"ltavg_max_density"));
		if (properties.getProperty(prefix+"ltavg_grow")!=null) this.ltavg_grow=Integer.parseInt(properties.getProperty(prefix+"ltavg_grow"));
		if (properties.getProperty(prefix+"ltavg_shrink")!=null) this.ltavg_shrink=Integer.parseInt(properties.getProperty(prefix+"ltavg_shrink"));
		if (properties.getProperty(prefix+"ltavg_gap_hwidth")!=null) this.ltavg_gap_hwidth=Integer.parseInt(properties.getProperty(prefix+"ltavg_gap_hwidth"));
		if (properties.getProperty(prefix+"ltavg_clust_hwidth")!=null) this.ltavg_clust_hwidth=Integer.parseInt(properties.getProperty(prefix+"ltavg_clust_hwidth"));
		if (properties.getProperty(prefix+"ltavg_extra_grow")!=null) this.ltavg_extra_grow=Integer.parseInt(properties.getProperty(prefix+"ltavg_extra_grow"));

		if (properties.getProperty(prefix+"ltavg_smooth_strength")!=null) this.ltavg_smooth_strength=Boolean.parseBoolean(properties.getProperty(prefix+"ltavg_smooth_strength"));
		if (properties.getProperty(prefix+"ltavg_neib_pull")!=null) this.ltavg_neib_pull=Double.parseDouble(properties.getProperty(prefix+"ltavg_neib_pull"));
		if (properties.getProperty(prefix+"ltavg_max_iter")!=null) this.ltavg_max_iter=Integer.parseInt(properties.getProperty(prefix+"ltavg_max_iter"));
		@@ -1182,8 +1190,9 @@ public class BiQuadParameters {
		bqp.ltavg_dens_radius= this.ltavg_dens_radius;
		bqp.ltavg_min_disparity= this.ltavg_min_disparity;
		bqp.ltavg_max_density= this.ltavg_max_density;
		bqp.ltavg_grow= this.ltavg_grow;
		bqp.ltavg_shrink= this.ltavg_shrink;
		bqp.ltavg_gap_hwidth= this.ltavg_gap_hwidth;
		bqp.ltavg_clust_hwidth= this.ltavg_clust_hwidth;
		bqp.ltavg_extra_grow= this.ltavg_extra_grow;
		bqp.ltavg_smooth_strength= this.ltavg_smooth_strength;
		bqp.ltavg_neib_pull= this.ltavg_neib_pull;
		bqp.ltavg_max_iter= this.ltavg_max_iter;

src/main/java/BiScan.java

+42 −16

Original line number	Diff line number	Diff line
		@@ -150,6 +150,7 @@ public class BiScan {

		// trusted should be set, copied and replaced as needed
		public double [][] getFilteredDisparityStrength( // FIXME
		final boolean [] area_of_interest,
		final double [][] disparityStrength,
		final double min_disparity, // keep original disparity far tiles
		final double trusted_strength, // trusted correlation strength
		@@ -193,6 +194,7 @@ public class BiScan {
		for (int i = 0; i < num_tiles; i++) ds[0][i] = Double.NaN;
		// double boost_low_density = 0.8; // 1.0; //0.2;
		suggestNewScan(
		area_of_interest, // final boolean [] area_of_interest,
		disparityStrength, // final double [][] disparityStrength,
		trusted_strength, // final double trusted_strength, // trusted correlation strength
		strength_rfloor, // final double strength_rfloor, // strength floor - relative to trusted
		@@ -480,14 +482,15 @@ public class BiScan {
		* 2) target disaprity that lead to the current measurement after refinement
		* 3) any other disable measurement
		* 4) any target disparity that lead to the disabled measurement
		* @param area_of_interest - limit results to these tiles (if provided)
		* @param disparityStrength - a pair of array or null. If null, will calculate fro the current scan
		* if not null - use as is
		* @param trusted_strength strength to trust unconditionally
		* @param strength_rfloor strength floor to subrtact as a fraction of the trusted strength
		* @param strength_rfloor strength floor to subtract as a fraction of the trusted strength
		* @param discard_cond if true may suggest new disparities for conditionally trusted tiles
		* @param discard_weak if true may suggest new disparities over trusted weak tiles
		* @param discard_stron if true may suggest new disparities over any tile
		* @param strength_pow raise strength to thyis power (normally just 1.0)
		* @param strength_pow raise strength to this power (normally just 1.0)
		* @param smpl_radius sample "radius", square side is 2 * smpl_radius + 1
		* @param smpl_num minimal absolute number of samples required to try fit a plane and validate a tile
		* If smpl_num == 0, faster calculation (single pass) using only *_narrow settings
		@@ -519,6 +522,7 @@ public class BiScan {
		*/

		int suggestNewScan(
		final boolean [] area_of_interest,
		final double [][] disparityStrength,
		final double trusted_strength, // trusted correlation strength
		final double strength_rfloor, // strength floor - relative to trusted
		@@ -545,7 +549,7 @@ public class BiScan {
		final boolean use_alt, // use tiles from other scans if they fit better
		final double goal_fraction_rms, // Try to make rms to be this fraction of maximal acceptable by removing outliers
		final double boost_low_density, // 0 - strength is proportional to 1/density, 1.0 - same as remaining tiles
		final double [][] smooth_ds, // optionally fill disaprity/strength instead of the target_disparity
		final double [][] smooth_ds, // optionally fill disparity/strength instead of the target_disparity
		final int fourq_min, // each of the 4 corners should have at least this number of tiles.
		final int fourq_gap, // symmetrical vertical and horizontal center areas that do not belong to any corner
		final int dbg_x,
		@@ -627,7 +631,8 @@ public class BiScan {
		threads[ithread] = new Thread() {
		@Override
		public void run() {
		for (int nTile = ai.getAndIncrement(); nTile < num_tiles; nTile = ai.getAndIncrement()) if (discard_strong \|\| !trusted_sw[nTile]){
		for (int nTile = ai.getAndIncrement(); nTile < num_tiles; nTile = ai.getAndIncrement()) if (
		((area_of_interest == null) \|\| area_of_interest[nTile]) && (discard_strong \|\| !trusted_sw[nTile])){
		boolean debug = nTile == dbg_tile;
		if (debug) {
		System.out.println("suggestNewScan(): debbugging nTile="+nTile);
		@@ -864,6 +869,8 @@ public class BiScan {
		return num_new.get();
		}



		private int findBetterFitToPlane(
		int smpl_radius,
		int nTile,
		@@ -1948,32 +1955,49 @@ public class BiScan {
		* Select low-textured tiles for averaging measurements
		* @param min_disparity minimal disparity to accept
		* @param max_density maximal trusted tile density (density varies from 0.0 to 1.0)
		* @param grow grow selection. When combined with shrink, fills small gaps. Both grow and shrink step
		* advances either horizontally or vertically (alternating), so to expand by 1 pixel in all directions
		* the value should be set to 2,
		* @param shrink shrink selection after expanding to fill small gaps
		* @param grow how many layers of tiles should be added after filling gaps and removing small clusters
		* @param max_gap_radius maximal radius of a void to be filled
		* @param min_clust_radius minimal original cluster radius to survive
		* @param density per-tile values of the density of trusted tiles around it.
		* @param src_disparity - source disparity array
		* @param src_disparity - source disparity array. If null will only use density (that should be > 0)
		* @return selection of the low-textured tiles to be processed with averaging correlation (3x3 or 5x5 tiles)
		*/
		public boolean [] selectLowTextures(
		double min_disparity,
		double max_density,
		int grow,
		int shrink,
		int max_gap_radius,
		int min_clust_radius,
		double [] density,
		double [] src_disparity)
		{
		boolean [] selection = new boolean [density.length];
		if (src_disparity == null) {
		for (int nTile = 0; nTile < selection.length; nTile++) {
		if ((density[nTile] <= max_density) && (density[nTile] <= max_density)) { // disparity has NaN-s, they will fail comparisons
		selection[nTile] = true;
		}
		}
		} else {
		for (int nTile = 0; nTile < selection.length; nTile++) {
		if ((src_disparity[nTile] >= min_disparity) && (density[nTile] <= max_density)) { // disparity has NaN-s, they will fail comparisons
		selection[nTile] = true;
		}
		}
		}
		final TileNeibs tnImage = biCamDSI.tnImage;

		tnImage.growSelection(
		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
		2* max_gap_radius, // 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, // boolean [] tiles,
		null); // boolean [] prohibit)

		tnImage.shrinkSelection(
		2*(max_gap_radius + min_clust_radius), // 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, // boolean [] tiles,
		null); // boolean [] prohibit)
		tnImage.growSelection(
		2 * (min_clust_radius + 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, // boolean [] tiles,
		null); // boolean [] prohibit)
		return selection;
		@@ -2023,6 +2047,7 @@ public class BiScan {
		for (int num_iter = 0; num_iter < max_iterations; num_iter++) {
		ai.set(0);
		ai_numThread.set(0);
		final AtomicInteger ai_count=new AtomicInteger(0);
		for (int i = 0; i < max_changes.length; i++) max_changes[i] = 0.0;
		final int fnum_iter = num_iter;
		for (int ithread = 0; ithread < threads.length; ithread++) {
		@@ -2070,6 +2095,7 @@ public class BiScan {
		new_strength[nTile] = (w_mean * neib_pull + src_strength[nTile])/(neib_pull + 1);
		}
		}
		ai_count.getAndIncrement();
		double adiff = Math.abs(new_disparity[nTile] - disparity[nTile]); // disparity[nTile] may be NaN then adiff will be NaN as intended
		if (!(adiff < max_changes[numThread])) {
		max_changes[numThread] = adiff; // NaN will be copied
		@@ -2098,7 +2124,7 @@ public class BiScan {
		}
		}
		if (debugLevel > -2) {
		System.out.println("fillAndSmooth(): iteration "+fnum_iter+" change="+change+" (min_change="+min_change+")");
		System.out.println("fillAndSmooth(): iteration "+fnum_iter+" change="+change+" (min_change="+min_change+")+ tiles updated="+ai_count.get());
		}
		if (change <= min_change) { // change may be NaN
		break; // from the main loop

src/main/java/TwoQuadCLT.java

+385 −49

File changed.

Preview size limit exceeded, changes collapsed.

Admin message