plane detection (3f6c6c63) · Commits · Elphel / imagej-elphel

src/main/java/CLTPass3d.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -516,7 +516,7 @@ public class CLTPass3d{
		}


		public void setSuperTiles(
		public SuperTiles setSuperTiles(
		double step_near,
		double step_far,
		double step_threshold,
		@@ -536,6 +536,7 @@ public class CLTPass3d{
		strength_floor,
		strength_pow,
		stBlurSigma);
		return this.superTiles;
		}
		public double [] showDisparityHistogram()
		{

src/main/java/DisparityProcessor.java

+5 −3

Original line number	Diff line number	Diff line
		@@ -398,7 +398,7 @@ public class DisparityProcessor {
		ImageDtt.startAndJoin(threads);
		double [][] dbg_data = {measured_disparity,disp_data[0],disp_data[1],dbg_pull[0],dbg_pull[1],dbg_pull[2],strength};
		String [] titles = {"measured","[0]","[1]","avg","meas","pull","strength"};
		if ((debugLevel>0) && ((pass ==0) \|\| (pass >= (num_passes-2)))){
		if ((debugLevel> 2) && ((pass ==0) \|\| (pass >= (num_passes-2)))){
		sdfa_instance.showArrays(dbg_data,tilesX, tilesY, true, "disp_smoothed",titles);
		}

		@@ -978,7 +978,9 @@ public class DisparityProcessor {
		int ty1 = ty + TRANSITIONS[tDir][dirChoice][1];
		int tDir1 = TRANSITIONS[tDir][dirChoice][2];
		// Was already here (in the same direction?
		if (field[ty1][tx1][tDir1] == FLD_WALKED) {
		if ((tx1 < 0) \|\| (ty1 < 0) \|\| (tx1 > tilesX) \|\| (ty1 > tilesY)){
		prohib = true;
		} else if (field[ty1][tx1][tDir1] == FLD_WALKED) { // 325
		break walking;
		} else if (field[ty1][tx1][tDir1] == FLD_EMPTY) {
		tx = tx1;
		@@ -1103,7 +1105,7 @@ public class DisparityProcessor {

		geom[nTile] = new int [8];
		int [] dbg_geom = geom[nTile];
		int [] dbg_neib = {neighbors[nTile - tilesX],neighbors[nTile + 1] , neighbors[nTile + tilesX],neighbors[nTile - 1]};
		// int [] dbg_neib = {neighbors[nTile - tilesX],neighbors[nTile + 1] , neighbors[nTile + tilesX],neighbors[nTile - 1]}; // out of bounds
		int neib = neighbors[nTile];
		if (neib != 0b11111111){ // do nothing for internal tiles
		int tileY = nTile/tilesX;

src/main/java/EyesisCorrectionParameters.java

+38 −1

Original line number	Diff line number	Diff line
		@@ -2028,6 +2028,7 @@ public class EyesisCorrectionParameters {
		public double min_clstr_max = 0.25; // Minimal maximal strength of the cluster

		public int fill_gaps = 4; // same as in grow - 1: 4 directions by 1 step, 2: 8 directions by 1 step. +2*n - alternating hor/vert
		public int fill_final = 50; // same as fill_gaps, on the final pass
		public int min_clstr_block = 3; // number of tiles in a cluster to block (just non-background?)
		public int bgnd_grow = 2; // number of tiles to grow (1 - hor/vert, 2 - hor/vert/diagonal)

		@@ -2113,7 +2114,7 @@ public class EyesisCorrectionParameters {
		public double stStepNear = 0.5; // Disaprity histogram step for near objects
		public double stStepThreshold = 1.0; // Disaprity threshold to switch cfrom linear to logarithmic steps
		public double stMinDisparity = 0.0; // Minimal disparity (center of a bin)
		public double stMaxDisparity = 50.0; // Maximal disparity (center of a bin)
		public double stMaxDisparity = 15.0; // Maximal disparity (center of a bin)
		public double stFloor = 0.15; // Subtract from strength, discard negative
		public double stPow = 1.0; // raise strength to this power
		public double stSigma = 1.5; // Blur disparity histogram (sigma in bins)
		@@ -2141,6 +2142,13 @@ public class EyesisCorrectionParameters {
		public double grow_disp_step = 6.0; // Increase disparity (from maximal tried) if nothing found in that tile // TODO: handle enclosed dips?
		public double grow_min_diff = 0.5; // Grow more only if at least one channel has higher variance from others for the tile

		public double plDispNorm = 3.0; // Normalize disparities to the average if above (now only for eigenvalue comparison)
		public int plMinPoints = 5; // Minimal number of points for plane detection
		public double plTargetEigen = 0.1; // Remove outliers until main axis eigenvalue (possibly scaled by plDispNorm) gets below
		public double plFractOutliers = 0.3; // Maximal fraction of outliers to remove
		public int plMaxOutliers = 20; // Maximal number of outliers to remove


		// other debug images
		public boolean show_ortho_combine = false; // Show 'ortho_combine'
		public boolean show_refine_supertiles = false; // show 'refine_disparity_supertiles'
		@@ -2266,6 +2274,7 @@ public class EyesisCorrectionParameters {
		properties.setProperty(prefix+"min_clstr_max", this.min_clstr_max +"");

		properties.setProperty(prefix+"fill_gaps", this.fill_gaps+"");
		properties.setProperty(prefix+"fill_final", this.fill_final+"");
		properties.setProperty(prefix+"min_clstr_block", this.min_clstr_block+"");
		properties.setProperty(prefix+"bgnd_grow", this.bgnd_grow+"");

		@@ -2372,6 +2381,12 @@ public class EyesisCorrectionParameters {
		properties.setProperty(prefix+"grow_disp_step", this.grow_disp_step +"");
		properties.setProperty(prefix+"grow_min_diff", this.grow_min_diff +"");

		properties.setProperty(prefix+"plDispNorm", this.plDispNorm +"");
		properties.setProperty(prefix+"plMinPoints", this.plMinPoints+"");
		properties.setProperty(prefix+"plTargetEigen", this.plTargetEigen +"");
		properties.setProperty(prefix+"plFractOutliers", this.plFractOutliers +"");
		properties.setProperty(prefix+"plMaxOutliers", this.plMaxOutliers+"");

		properties.setProperty(prefix+"show_ortho_combine", this.show_ortho_combine+"");
		properties.setProperty(prefix+"show_refine_supertiles", this.show_refine_supertiles+"");
		properties.setProperty(prefix+"show_bgnd_nonbgnd", this.show_bgnd_nonbgnd+"");
		@@ -2490,6 +2505,7 @@ public class EyesisCorrectionParameters {


		if (properties.getProperty(prefix+"fill_gaps")!=null) this.fill_gaps=Integer.parseInt(properties.getProperty(prefix+"fill_gaps"));
		if (properties.getProperty(prefix+"fill_final")!=null) this.fill_final=Integer.parseInt(properties.getProperty(prefix+"fill_final"));
		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"));

		@@ -2593,6 +2609,12 @@ public class EyesisCorrectionParameters {
		if (properties.getProperty(prefix+"grow_disp_step")!=null) this.grow_disp_step=Double.parseDouble(properties.getProperty(prefix+"grow_disp_step"));
		if (properties.getProperty(prefix+"grow_min_diff")!=null) this.grow_min_diff=Double.parseDouble(properties.getProperty(prefix+"grow_min_diff"));

		if (properties.getProperty(prefix+"plDispNorm")!=null) this.plDispNorm=Double.parseDouble(properties.getProperty(prefix+"plDispNorm"));
		if (properties.getProperty(prefix+"plMinPoints")!=null) this.plMinPoints=Integer.parseInt(properties.getProperty(prefix+"plMinPoints"));
		if (properties.getProperty(prefix+"plTargetEigen")!=null) this.plTargetEigen=Double.parseDouble(properties.getProperty(prefix+"plTargetEigen"));
		if (properties.getProperty(prefix+"plFractOutliers")!=null) this.plFractOutliers=Double.parseDouble(properties.getProperty(prefix+"plFractOutliers"));
		if (properties.getProperty(prefix+"plMaxOutliers")!=null) this.plMaxOutliers=Integer.parseInt(properties.getProperty(prefix+"plMaxOutliers"));

		if (properties.getProperty(prefix+"show_ortho_combine")!=null) this.show_ortho_combine=Boolean.parseBoolean(properties.getProperty(prefix+"show_ortho_combine"));
		if (properties.getProperty(prefix+"show_refine_supertiles")!=null) this.show_refine_supertiles=Boolean.parseBoolean(properties.getProperty(prefix+"show_refine_supertiles"));
		if (properties.getProperty(prefix+"show_bgnd_nonbgnd")!=null) this.show_bgnd_nonbgnd=Boolean.parseBoolean(properties.getProperty(prefix+"show_bgnd_nonbgnd"));
		@@ -2725,6 +2747,7 @@ public class EyesisCorrectionParameters {
		gd.addNumericField("Minimal maximal strength of the cluster", this.min_clstr_max, 3);

		gd.addNumericField("Fill gaps betsween clusters, see comments for 'grow'", this.fill_gaps, 0);
		gd.addNumericField("Same as fill_gaps above, on the final pass", this.fill_final, 0);
		gd.addNumericField("Number of tiles in a cluster to block (just non-background?)", this.min_clstr_block, 0);
		gd.addNumericField("Number of tiles to grow tile selection (1 - hor/vert, 2 - hor/vert/diagonal)", this.bgnd_grow, 0);

		@@ -2835,6 +2858,13 @@ public class EyesisCorrectionParameters {
		gd.addNumericField("Trust measured disparity within +/- this value", this.grow_disp_trust, 6);
		gd.addNumericField("Increase disparity (from maximal tried) if nothing found in that tile", this.grow_disp_step, 6);
		gd.addNumericField("Grow more only if at least one channel has higher variance from others for the tile", this.grow_min_diff, 6);
		gd.addMessage ("--- Planes detection ---");
		gd.addNumericField("Normalize disparities to the average if above", this.plDispNorm, 6);
		gd.addNumericField("Minimal number of points for plane detection", this.plMinPoints, 0);
		gd.addNumericField("Remove outliers until main axis eigenvalue (possibly scaled by plDispNorm) gets below", this.plTargetEigen, 6);
		gd.addNumericField("Maximal fraction of outliers to remove", this.plFractOutliers, 6);
		gd.addNumericField("Maximal number of outliers to remove", this.plMaxOutliers, 0);

		gd.addMessage ("--- Other debug images ---");
		gd.addCheckbox ("Show 'ortho_combine'", this.show_ortho_combine);
		gd.addCheckbox ("Show 'refine_disparity_supertiles'", this.show_refine_supertiles);
		@@ -2960,6 +2990,7 @@ public class EyesisCorrectionParameters {
		this.min_clstr_max= gd.getNextNumber();

		this.fill_gaps= (int) gd.getNextNumber();
		this.fill_final= (int) gd.getNextNumber();
		this.min_clstr_block= (int) gd.getNextNumber();
		this.bgnd_grow= (int) gd.getNextNumber();

		@@ -3065,6 +3096,12 @@ public class EyesisCorrectionParameters {
		this.grow_disp_step= gd.getNextNumber();
		this.grow_min_diff= gd.getNextNumber();

		this.plDispNorm= gd.getNextNumber();
		this.plMinPoints= (int) gd.getNextNumber();
		this.plTargetEigen= gd.getNextNumber();
		this.plFractOutliers= gd.getNextNumber();
		this.plMaxOutliers= (int) gd.getNextNumber();

		this.show_ortho_combine= gd.getNextBoolean();
		this.show_refine_supertiles= gd.getNextBoolean();
		this.show_bgnd_nonbgnd= gd.getNextBoolean(); // first on second pass

src/main/java/GeometryCorrection.java

+312 −3

Original line number	Diff line number	Diff line
		@@ -329,8 +329,13 @@ public class GeometryCorrection {
		}


		/*
		/**
		* Get real world coordinates from pixel coordinates and nominal disparity
		* @param px horizontal pixel coordinate (right)
		* @param py vertical pixel coordinate (down)
		* @param disparity nominal disparity (pixels)
		* @param correctDistortions true: correct lens distortions, false - no lens distortions
		* @return {x, y, z} in meters
		*/
		public double [] getWorldCoordinates(
		double px,
		@@ -350,9 +355,224 @@ public class GeometryCorrection {
		double [] xyz = {x,y,z};
		return xyz;
		}

		/* Just for testing using delta instead of d */
		public double [][] getWorldJacobian(
		double px,
		double py,
		double disparity,
		boolean correctDistortions, // correct distortion (will need corrected background too !)
		double delta)
		{
		double [] dpxpy0 = {disparity,px,py};
		double [][] jacobian = new double [3][3];
		double [] xyz0 = getWorldCoordinates(dpxpy0[1],dpxpy0[2],dpxpy0[0],correctDistortions);
		for (int i = 0; i< 3; i++){
		double [] dpxpy = dpxpy0.clone();
		dpxpy[i] += delta;
		double [] xyz = getWorldCoordinates(dpxpy[1],dpxpy[2],dpxpy[0],correctDistortions);
		for (int j = 0; j<3; j++){
		jacobian[j][i] = (xyz[j] - xyz0[j])/delta;
		}
		}
		return jacobian;
		}


		/**
		* Get jacobian matrix - derivatives of real world [x,y,z] (in meters, right, up, to camera) by [disparity, px,py] (in pixels disparity, right, down)
		* @param px horizontal pixel coordinate (right)
		* @param py vertical pixel coordinate (down)
		* @param disparity nominal disparity (pixels)
		* @param correctDistortions true: correct lens distortions, false - no lens distortions
		* @return {{dx/ddisparity, dx/dpx, dx/dpy},{dy/ddisparity, dy/dpx, dy/dpy},{dz/ddisparity, dz/dpx, dz/dpy}}
		*/
		public double [][] getWorldJacobian(
		double px,
		double py,
		double disparity,
		boolean correctDistortions, // correct distortion (will need corrected background too !)
		boolean debug)
		{
		double pXcd = px - 0.5 * this.pixelCorrectionWidth;
		double pYcd = py - 0.5 * this.pixelCorrectionHeight;

		double d_pXcd_d_px = 1.0;
		double d_pYcd_d_py = 1.0;

		double pXcd2_pYcd2 = pXcdpXcd + pYcdpYcd;
		double rD = Math.sqrt(pXcd2_pYcd2)0.001this.pixelSize; // distorted radius in a virtual center camera

		double rrD = rD / this.distortionRadius;
		double d_rRD_d_px = pXcd * rD / pXcd2_pYcd2 / this.distortionRadius;
		double d_rRD_d_py = pYcd * rD / pXcd2_pYcd2 / this.distortionRadius;



		double rND2R = correctDistortions?(getRByRDist(rrD, false)): 1.0;



		double rrND = rND2R * rrD; // relative to distortion radius non-distorted radius


		// k = rD/r
		double d_k_d_rrND = correctDistortions?getDerivRDistFromR(rrND):0.0;
		double d_rND2R_d_rrD = - rND2R * rND2R * d_k_d_rrND / ( d_k_d_rrND * rrND + 1.0/ rND2R); // rrND);
		/*

		double d_rND2R_d_rrD0 = correctDistortions?(getDerivRByRDist(rrD, false)): 0.0;

		double d_rND2R_d_rrD1 = correctDistortions?(getDerivRByRDist(rrD, false, 0.00001)): 0.0;
		if (debug) {
		System.out.println("getWorldJacobian(): d_rND2R_d_rrD="+d_rND2R_d_rrD+", d_rND2R_d_rrD0="+d_rND2R_d_rrD0+", d_rND2R_d_rrD1="+d_rND2R_d_rrD1 );
		}
		*/

		double d_rND2R_d_px = d_rND2R_d_rrD * d_rRD_d_px;
		double d_rND2R_d_py = d_rND2R_d_rrD * d_rRD_d_py;

		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 d_pXc_d_px = pXcd * d_rND2R_d_px + d_pXcd_d_px * rND2R; // incorrect
		double d_pYc_d_py = pYcd * d_rND2R_d_py + d_pYcd_d_py * rND2R; // incorrect

		double d_pXc_d_py = pXcd * d_rND2R_d_py; // incorrect (too small)?
		double d_pYc_d_px = pYcd * d_rND2R_d_px; // incorrect (too small)?

		double z = -SCENE_UNITS_SCALE * this.focalLength * this.disparityRadius / (disparity * 0.001*this.pixelSize); // "+" - near, "-" far
		double kx = SCENE_UNITS_SCALE * this.disparityRadius / disparity;
		double ky = -SCENE_UNITS_SCALE * this.disparityRadius / disparity;
		double x = kx * pXc;
		double y = ky * pYc;

		double d_z_d_disparity = -z / disparity;
		double d_x_d_disparity = -x / disparity;
		double d_y_d_disparity = -y / disparity;
		// d_z_d_px == d_z_d_py ==0
		double [][] jacobian =
		{ {d_x_d_disparity, kx * d_pXc_d_px, kx * d_pXc_d_py},
		{d_y_d_disparity, ky * d_pYc_d_px, ky * d_pYc_d_py},
		{d_z_d_disparity, 0.0, 0.0}};
		return jacobian; // xyz;
		}

		/**
		* Get pixel disparity and coordinates from the real world coordinates (in meters)
		* @param xyz real world coordinates {x, y, z} in meters (right up, towards camera)
		* @param correctDistortions true: correct lens distortions, false - no lens distortions
		* @return {disparity, px, py} (right, down)
		*/
		public double [] getImageCoordinates(
		double [] xyz,
		boolean correctDistortions) // correct distortion (will need corrected background too !)
		{
		double x = xyz[0];
		double y = xyz[1];
		double z = xyz[2];
		double disparity = -SCENE_UNITS_SCALE * this.focalLength * this.disparityRadius / (z * 0.001*this.pixelSize);
		// non-distorted coordinates relative to the (0.5 * this.pixelCorrectionWidth, 0.5 * this.pixelCorrectionHeight)in mm
		double pXc = x * disparity / (SCENE_UNITS_SCALE * this.disparityRadius); // pixels
		double pYc =-y * disparity / (SCENE_UNITS_SCALE * this.disparityRadius); // pixels
		double rND = Math.sqrt(pXcpXc + pYcpYc)0.001this.pixelSize; // mm
		double rD2RND = correctDistortions?getRDistByR(rND/this.distortionRadius):1.0;
		double px = pXc * rD2RND + 0.5 * this.pixelCorrectionWidth; // distorted coordinates relative to the (0.5 * this.pixelCorrectionWidth, 0.5 * this.pixelCorrectionHeight)
		double py = pYc * rD2RND + 0.5 * this.pixelCorrectionHeight; // in pixels
		double [] dxy = {disparity, px, py};
		return dxy;
		}

		/* Just for testing using delta instead of d */
		public double [][] getImageJacobian(
		double [] xyz0,
		boolean correctDistortions, // correct distortion (will need corrected background too !)
		double delta)
		{
		double [][] jacobian = new double [3][3];
		double [] dpxpy0 = getImageCoordinates(xyz0,correctDistortions);
		for (int i = 0; i< 3; i++){
		double [] xyz = xyz0.clone();
		xyz[i] += delta;
		double [] dpxpy = getImageCoordinates(xyz,correctDistortions);
		for (int j = 0; j<3; j++){
		jacobian[j][i] = (dpxpy[j] - dpxpy0[j])/delta;
		}
		}
		return jacobian;
		}


		/**
		* Get jacobian matrix - derivatives of [disparity, px,py] (in pixels disparity, right, down) by real world [x,y,z] (in meters, right, up, to camera)
		* @param xyz real world coordinates {x, y, z} in meters (right up, towards camera)
		* @param correctDistortions true: correct lens distortions, false - no lens distortions
		* @return {{dx/ddisparity, dx/dpx, dx/dpy},{dy/ddisparity, dy/dpx, dy/dpy},{dz/ddisparity, dz/dpx, dz/dpy}}
		*/
		public double [][] getImageJacobian(
		double [] xyz,
		boolean correctDistortions,
		int debugLevel)
		{
		if (debugLevel > 0){
		System.out.println("getImageJacobian():");
		}
		double x = xyz[0];
		double y = xyz[1];
		double z = xyz[2];
		double disparity = -SCENE_UNITS_SCALE * this.focalLength * this.disparityRadius / (z * 0.001*this.pixelSize);

		double d_disparity_d_z = -disparity / z; // no dependence on x,y
		// non-distorted coordinates relative to the (0.5 * this.pixelCorrectionWidth, 0.5 * this.pixelCorrectionHeight)in mm
		double pXc = x * disparity / (SCENE_UNITS_SCALE * this.disparityRadius);
		double pYc =-y * disparity / (SCENE_UNITS_SCALE * this.disparityRadius);

		double d_pXc_d_z = -pXc / z; // pXc/disparity * d_disparity_d_z = pXc/disparity * (-disparity / z);
		double d_pYc_d_z = -pYc / z; // pYc/disparity * d_disparity_d_z = pYc/disparity * (-disparity / z);

		double d_pXc_d_x = disparity / (SCENE_UNITS_SCALE * this.disparityRadius);
		double d_pYc_d_y = -disparity / (SCENE_UNITS_SCALE * this.disparityRadius);


		double rND2 = pXcpXc + pYcpYc;
		double rrND = Math.sqrt(rND2)0.001this.pixelSize/this.distortionRadius; // relative to distortion radius;


		double d_rrND_d_pXc = pXc*rrND/rND2;
		double d_rrND_d_pYc = pYc*rrND/rND2;


		double rD2RND = correctDistortions?getRDistByR(rrND):1.0;
		double d_rD2RND_d_rrND = correctDistortions?getDerivRDistFromR(rrND) : 0.0;
		/*
		double d_rD2RND_d_rrND0 = correctDistortions?getDerivRDistFromR(rrND,0.000001) : 0.0;
		if (debugLevel > 0){
		System.out.println("getImageJacobian():, d_rD2RND_d_rrND0 = "+d_rD2RND_d_rrND0+" ("+0.000001+"), d_rD2RND_d_rrND="+d_rD2RND_d_rrND);
		}
		*/
		double p_px_d_x = d_pXc_d_x * (pXc * (d_rD2RND_d_rrND * d_rrND_d_pXc) + rD2RND); // / (0.001 * this.pixelSize);
		double p_py_d_y = d_pYc_d_y * (pYc * (d_rD2RND_d_rrND * d_rrND_d_pYc) + rD2RND); // / (0.001 * this.pixelSize);


		double p_px_d_y = pXc * (d_rD2RND_d_rrND * d_rrND_d_pYc * d_pYc_d_y); // / (0.001 * this.pixelSize);
		double p_py_d_x = pYc * (d_rD2RND_d_rrND * d_rrND_d_pXc * d_pXc_d_x); // / (0.001 * this.pixelSize);

		double d_rrND_d_z = d_rrND_d_pXc * d_pXc_d_z + d_rrND_d_pYc * d_pYc_d_z;

		double p_px_d_z = (pXc * (d_rD2RND_d_rrND * d_rrND_d_z) + (d_pXc_d_z * rD2RND)); // / (0.001 * this.pixelSize);
		double p_py_d_z = (pYc * (d_rD2RND_d_rrND * d_rrND_d_z) + (d_pYc_d_z * rD2RND)); // / (0.001 * this.pixelSize);

		double [][] jacobian = {
		{ 0.0, 0.0, d_disparity_d_z},
		{p_px_d_x,p_px_d_y, p_px_d_z},
		{p_py_d_x,p_py_d_y, p_py_d_z}};

		return jacobian;
		}

		/*
		* 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
		* and generic disparity, measured in pixels
		*/

		public double [][] getPortsCoordinates(
		@@ -452,6 +672,51 @@ public class GeometryCorrection {
		return true;
		}

		/**
		* Get relative (to distortion radius) distorted radius ratio to non-distorted from non-distorted
		* @param r non-distorted radius (1.0 is 2.8512mm)
		* @return ratio of distorted to non-distorted radius
		*/
		public double getRDistByR(double r) // relative to distortion radius
		{
		boolean use8=(this.distortionA8!=0.0) \|\| (this.distortionA7!=0.0) \|\| (this.distortionA6!=0.0);
		double d=1.0-this.distortionA8-this.distortionA7-this.distortionA6-this.distortionA5-this.distortionA-this.distortionB-this.distortionC;

		double k;
		if (use8){
		k=(((((((this.distortionA8)r+this.distortionA7)r+this.distortionA6)r+this.distortionA5)r + this.distortionA)r+this.distortionB)r+this.distortionC)*r+d;
		} else {
		k=(((this.distortionA5r + this.distortionA)r+this.distortionB)r+this.distortionC)r+d;
		}
		return k;
		}

		/**
		* Get derivative of relative (to distortion radius) d_Rdist/d_R from relative (to distortion radius) non-distorted radius
		* @param r non-distorted relative radius
		* @return derivative d_Rdist/d_R from (relative to relative)
		*/
		public double getDerivRDistFromR(double r) // relative to distortion radius
		{
		boolean use8=(this.distortionA8!=0.0) \|\| (this.distortionA7!=0.0) \|\| (this.distortionA6!=0.0);
		// double d=1.0-this.distortionA8-this.distortionA7-this.distortionA6-this.distortionA5-this.distortionA-this.distortionB-this.distortionC;
		double drDistDr;
		if (use8){
		drDistDr=(((((((7this.distortionA8)r + 6this.distortionA7)r + 5this.distortionA6)r + 4this.distortionA5)r + 3this.distortionA)r+2this.distortionB)r+1*this.distortionC); // +d;
		} else {
		// drDistDr=(((4this.distortionA5r + 3this.distortionA)r+2this.distortionB)r+1this.distortionC)r;
		drDistDr=((4this.distortionA5r + 3this.distortionA)r+2this.distortionB)r+1*this.distortionC;
		}
		return drDistDr;
		}

		public double getDerivRDistFromR(double r, double delta) // relative to distortion radius
		{
		return (getRDistByR(r+delta) -getRDistByR(r))/delta;

		}


		public double getRByRDist(double rDist, boolean debug){
		// add exceptions;
		if (this.rByRDist==null) {
		@@ -479,6 +744,50 @@ public class GeometryCorrection {
		return result;
		}

		/*
		public double getDerivRByRDist(double rDist, boolean debug, double delta){
		return (getRByRDist(rDist+delta, false) - getRByRDist(rDist, false))/delta;
		}

		public double getDerivRByRDist(double rDist, boolean debug){
		// add exceptions;
		if (this.rByRDist==null) {
		calcReverseDistortionTable();
		if (debug)System.out.println("getDerivRByRDist("+IJ.d2s(rDist,3)+"): this.rByRDist==null");
		// return Double.NaN;
		}
		if (rDist<0) {
		if (debug)System.out.println("getDerivRByRDist("+IJ.d2s(rDist,3)+"): rDist<0");
		return Double.NaN;
		}
		int index=(int) Math.floor(rDist/this.stepR);
		if (index>=(this.rByRDist.length-1)) {
		if (debug) System.out.println("getDerivRByRDist("+IJ.d2s(rDist,3)+"): index="+index+">="+(this.rByRDist.length-1));
		return Double.NaN;
		}
		double result=this.rByRDist[index+1]-this.rByRDist[index];
		if ((index > 0) \|\| (index < (this.rByRDist.length-2))){ // interpolate
		double a = rDist/this.stepR-index; // fractional part, 0..1.0
		if ( a <= 0.5){
		result= 2 * (0.5 - a) * (this.rByRDist[index+1] - this.rByRDist[index]) +
		a * (this.rByRDist[index+1] - this.rByRDist[index-1]);
		} else {
		result= 2 * (1.0 - a) * (this.rByRDist[index+1] - this.rByRDist[index]) +
		(a - 0.5) * (this.rByRDist[index+2] - this.rByRDist[index]);

		}

		}
		if (Double.isNaN(result)){
		if (debug) System.out.println("this.rByRDist["+index+"]="+this.rByRDist[index]);
		if (debug) System.out.println("this.rByRDist["+(index+1)+"]="+this.rByRDist[index+1]);
		if (debug) System.out.println("rDist="+rDist);
		if (debug) System.out.println("(rDist/this.stepR="+(rDist/this.stepR));

		}
		return result/this.stepR;
		}
		*/


		}

src/main/java/QuadCLT.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -5059,7 +5059,7 @@ public class QuadCLT {
		geometryCorrection,
		threadsMax, // maximal number of threads to launch
		updateStatus,
		debugLevel);
		2); // debugLevel);
		// get images for predefined regions and disparities. First - with just fixed scans 1 .. list.size()

		tp.showScan(

Admin message