added preliminary inter-camera correlation, but it is not working yet (83946ca3) · Commits · Elphel / imagej-elphel

src/main/java/BiQuadParameters.java

+9 −1

Original line number	Diff line number	Diff line
		@@ -78,6 +78,7 @@ public class BiQuadParameters {
		public boolean ml_keep_aux = true; // include auxiliary camera data in the ML output
		public boolean ml_keep_inter = true; // include inter-camera correlation data in the ML output
		public boolean ml_keep_hor_vert = true; // include combined horizontal and vertical pairs data in the ML output
		public boolean ml_keep_tbrl = true; // include individual top, bottom, right, left pairs
		public boolean ml_keep_debug= true; // include debug layer(s) data in the ML output
		public boolean ml_8bit= true; // output in 8-bit format (default - 32-bit TIFF
		public double ml_limit_extrim = 0.00001; // ignore lowest and highest values when converting to 8 bpp
		@@ -180,8 +181,11 @@ public class BiQuadParameters {
		"ML output will have the second set of the layers for the auxiliary camera. Disparity values should be scaled for the camera baseline");
		gd.addCheckbox ("Keep inter-camera correlation data", this.ml_keep_inter,
		"Inter-camera correlation data has only one layer (and one correlation pair). It is used to generate ground truth data. Usable disparity range (measured in the main camera pixels) is ~1/5 of teh main camera");
		gd.addCheckbox ("Keep combine horizonta/vertical pairs", this.ml_keep_hor_vert,
		gd.addCheckbox ("Keep individual top, bottom, right, and left pairs", this.ml_keep_tbrl,
		"Each of these two layers per camera are calculated from a pair of top/bottom and left/right pairs. Can possibly be used instead of originals to reduce amount of input data");
		gd.addCheckbox ("Keep combined horizonta/vertical pairs", this.ml_keep_hor_vert,
		"Individual horizontal and vertical pairs (4 total). Can be replaced by two combined (horizontal+vertical) ones");

		gd.addCheckbox ("Keep debug layer(s)", this.ml_keep_debug,
		"Keep additional (debug) layers that may change for different file versions");
		gd.addCheckbox ("Use 8 bpp TIFF (default - 32 bpp)", this.ml_8bit,
		@@ -241,6 +245,7 @@ public class BiQuadParameters {
		this.ml_sweep_steps= (int) gd.getNextNumber();
		this.ml_keep_aux= gd.getNextBoolean();
		this.ml_keep_inter= gd.getNextBoolean();
		this.ml_keep_tbrl= gd.getNextBoolean();
		this.ml_keep_hor_vert= gd.getNextBoolean();
		this.ml_keep_debug= gd.getNextBoolean();
		this.ml_8bit= gd.getNextBoolean();
		@@ -299,6 +304,7 @@ public class BiQuadParameters {
		properties.setProperty(prefix+"ml_sweep_steps", this.ml_sweep_steps+"");
		properties.setProperty(prefix+"ml_keep_aux", this.ml_keep_aux+"");
		properties.setProperty(prefix+"ml_keep_inter", this.ml_keep_inter+"");
		properties.setProperty(prefix+"ml_keep_tbrl", this.ml_keep_tbrl+"");
		properties.setProperty(prefix+"ml_keep_hor_vert", this.ml_keep_hor_vert+"");
		properties.setProperty(prefix+"ml_keep_debug", this.ml_keep_debug+"");
		properties.setProperty(prefix+"ml_8bit", this.ml_8bit+"");
		@@ -355,6 +361,7 @@ public class BiQuadParameters {
		if (properties.getProperty(prefix+"ml_sweep_steps")!=null) this.ml_sweep_steps=Integer.parseInt(properties.getProperty(prefix+"ml_sweep_steps"));
		if (properties.getProperty(prefix+"ml_keep_aux")!=null) this.ml_keep_aux=Boolean.parseBoolean(properties.getProperty(prefix+"ml_keep_aux"));
		if (properties.getProperty(prefix+"ml_keep_inter")!=null) this.ml_keep_inter=Boolean.parseBoolean(properties.getProperty(prefix+"ml_keep_inter"));
		if (properties.getProperty(prefix+"ml_keep_tbrl")!=null) this.ml_keep_tbrl=Boolean.parseBoolean(properties.getProperty(prefix+"ml_keep_tbrl"));
		if (properties.getProperty(prefix+"ml_keep_hor_vert")!=null) this.ml_keep_hor_vert=Boolean.parseBoolean(properties.getProperty(prefix+"ml_keep_hor_vert"));
		if (properties.getProperty(prefix+"ml_keep_debug")!=null) this.ml_keep_debug=Boolean.parseBoolean(properties.getProperty(prefix+"ml_keep_debug"));
		if (properties.getProperty(prefix+"ml_8bit")!=null) this.ml_8bit=Boolean.parseBoolean(properties.getProperty(prefix+"ml_8bit"));
		@@ -411,6 +418,7 @@ public class BiQuadParameters {
		bqp.ml_sweep_steps= this.ml_sweep_steps;
		bqp.ml_keep_aux= this.ml_keep_aux;
		bqp.ml_keep_inter= this.ml_keep_inter;
		bqp.ml_keep_tbrl= this.ml_keep_tbrl;
		bqp.ml_keep_hor_vert= this.ml_keep_hor_vert;
		bqp.ml_keep_debug= this.ml_keep_debug;
		bqp.ml_8bit= this.ml_8bit;

src/main/java/EyesisCorrections.java

+6 −4

Original line number	Diff line number	Diff line
		@@ -476,12 +476,14 @@ public class EyesisCorrections {
		}
		if (correctionsParameters.isJP4()) imp=JP4_INSTANCE.demuxImage(imp_composite, subChannel);
		if (imp==null) imp=imp_composite; // not a composite image
		int [] widthHeight={imp.getWidth(),imp.getHeight()};
		this.channelWidthHeight[srcChannel]=widthHeight;

		// int [] widthHeight={imp.getWidth(),imp.getHeight()};

		// this.channelWidthHeight[srcChannel]=widthHeight;
		this.channelVignettingCorrection[srcChannel]=this.pixelMapping.getBayerFlatFieldFloat(
		srcChannel,
		this.channelWidthHeight[srcChannel][0],
		this.channelWidthHeight[srcChannel][1],
		// this.channelWidthHeight[srcChannel][0],
		// this.channelWidthHeight[srcChannel][1],
		bayer);
		if (this.debugLevel>0){
		System.out.println("Created vignetting info for channel "+srcChannel+

src/main/java/GeometryCorrection.java

+91 −7

Original line number	Diff line number	Diff line
		@@ -85,6 +85,11 @@ public class GeometryCorrection {
		public RigOffset rigOffset = null;


		public int [] getSensorWH() {
		int [] wh = {this.pixelCorrectionWidth, this.pixelCorrectionHeight};
		return wh;
		}

		public GeometryCorrection(double [] extrinsic_corr)
		{
		this.extrinsic_corr = new CorrVector(extrinsic_corr);
		@@ -98,6 +103,11 @@ public class GeometryCorrection {
		return (use_rig && (rigOffset != null)) ? rigOffset.rXY_aux: rXY ;
		}

		// public double [] getAuxOffset(boolean use_rig){
		// double [] main_offset = {0.0,0.0};
		// return (use_rig && (rigOffset != null)) ? rigOffset.getAuxOffset(): main_offset ;
		// }

		public Matrix getRotMatrix(boolean use_rig){
		return (use_rig && (rigOffset != null)) ? rigOffset.getRotMatrix(): null ;
		}
		@@ -656,6 +666,10 @@ public class GeometryCorrection {
		return vector;
		}

		// public double [] getAuxOffset() {
		// double [] aux_offset= {baseline * Math.cos(aux_angle)/getDisparityRadius(), baseline * Math.sin(aux_angle)/getDisparityRadius()};
		// return aux_offset;
		// }
		public void recalcRXY() {
		if (rXY != null) {
		// rXY_aux = rXY; // FIXME: put real stuff !!!
		@@ -695,10 +709,6 @@ public class GeometryCorrection {
		{ xc_pix, yc_pix},
		{dxc_dangle, dyc_dangle},
		{dxc_baseline, dyc_baseline}};
		/* double [][] rslt = {
		{ -xc_pix, -yc_pix},
		{-dxc_dangle, -dyc_dangle},
		{-dxc_baseline, -dyc_baseline}}; */
		return rslt;
		}

		@@ -2236,8 +2246,13 @@ matrix([[-0.125, -0.125, 0.125, 0.125, -0.125, 0.125, -0. , -0. , -0.
		double ri_scale = 0.001 * gc_main.pixelSize / gc_main.distortionRadius;

		// non-distorted XY relative to the auxiliary camera center if it was parallel to the main one
		double pXci0 = pXc - disparity * aux_offset_derivs[0][0]; // in pixels
		double pYci0 = pYc - disparity * aux_offset_derivs[0][1]; // in pixels
		// Allow aux_offset_derivs null only if disparity == 0.0;
		double pXci0 = pXc; // - disparity * aux_offset_derivs[0][0]; // in pixels
		double pYci0 = pYc; // - disparity * aux_offset_derivs[0][1]; // in pixels
		if (disparity != 0.0) { // aux_offset_derivs != null)
		pXci0 -= disparity * aux_offset_derivs[0][0]; // in pixels
		pYci0 -= disparity * aux_offset_derivs[0][1]; // in pixels
		}
		// rectilinear here

		// Convert a 2-d non-distorted vector to 3d at fl_pix distance in z direction
		@@ -2246,7 +2261,7 @@ matrix([[-0.125, -0.125, 0.125, 0.125, -0.125, 0.125, -0. , -0. , -0.

		// Apply port-individual combined rotation/zoom matrix

		Matrix rvi = aux_rot.times(vi);
		Matrix rvi = (aux_rot == null) ? vi: aux_rot.times(vi);


		// get back to the projection plane by normalizing vector
		@@ -2480,6 +2495,51 @@ matrix([[-0.125, -0.125, 0.125, 0.125, -0.125, 0.125, -0. , -0. , -0.
		return pXY;
		}

		/*
		public double [] getAuxCoordinatesRigIdeal( // used in macro mode
		GeometryCorrection gc_main,
		Matrix rots,
		double px,
		double py,
		double disparity)
		{
		// reverse getPortsCoordinates
		double c_roll = 1.0; // Math.cos(( - this.common_roll) * Math.PI/180.0);
		double s_roll = 0.0; // Math.sin(( - this.common_roll) * Math.PI/180.0);
		double pXcd0 = px - 0.5 * this.pixelCorrectionWidth;
		double pYcd0 = py - 0.5 * this.pixelCorrectionWidth;
		double pXcd = c_roll * pXcd0 - s_roll* pYcd0;
		double pYcd = s_roll * pXcd0 + c_roll* pYcd0;
		double rD = Math.sqrt(pXcdpXcd + pYcdpYcd)0.001this.pixelSize; // distorted radius in a virtual center camera
		double rND2R=getRByRDist(rD/this.distortionRadius, (debugLevel > -1));
		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 [] a={this.distortionC,this.distortionB,this.distortionA,this.distortionA5,this.distortionA6,this.distortionA7,this.distortionA8};
		double [] pXY = new double[2];
		// calculate for aux (this) camera
		double [][] aux_offset = getAuxOffsetAndDerivatives(gc_main);
		// non-distorted XY of the shifted location of the individual sensor
		double pXci = pXc - disparity * aux_offset[0][0]; // in pixels
		double pYci = pYc - disparity * aux_offset[0][1];

		// calculate back to distorted
		double rNDi = Math.sqrt(pXcipXci + pYcipYci); // in pixels
		// Rdist/R=A8R^7+A7R^6+A6R^5+A5R^4+AR^3+BR^2+C*R+(1-A8-A7-A6-A5-A-B-C)");
		double ri = rNDi* 0.001 * this.pixelSize / this.distortionRadius; // relative to distortion radius
		// double rD2rND = (1.0 - distortionA8 - distortionA7 - distortionA6 - distortionA5 - distortionA - distortionB - distortionC);
		double rD2rND = 1.0;
		double rri = 1.0;
		for (int j = 0; j < a.length; j++){
		rri *= ri;
		rD2rND += a[j]*(rri - 1.0);
		}
		double pXid = pXci * rD2rND;
		double pYid = pYci * rD2rND;
		pXY[i][0] = c_roll * pXid + s_roll* pYid + 0.5 * this.pixelCorrectionWidth; // this.pXY0[i][0];
		pXY[i][1] = -s_roll * pXid + c_roll* pYid + 0.5 * this.pixelCorrectionWidth; // this.pXY0[i][1];
		return pXY;
		}
		*/


		public double [][] getPortsCoordinatesIdeal(
		@@ -2500,6 +2560,30 @@ matrix([[-0.125, -0.125, 0.125, 0.125, -0.125, 0.125, -0. , -0. , -0.
		return coords;
		}

		public double [] getRigAuxCoordinatesIdeal(
		int macro_scale, // 1 for pixels, 8 - for tiles when correlating tiles instead of the pixels
		GeometryCorrection gc_main,
		Matrix aux_rot,
		double px,
		double py,
		double disparity)
		{
		double [] xy = getRigAuxCoordinatesAndDerivatives(
		gc_main, // GeometryCorrection gc_main,
		aux_rot, // Matrix aux_rot,
		null, // Matrix [] aux_rot_derivs,
		null, // double [][] aux_offset_derivs,
		null, // double [][] pXYderiv, // if not null, should be double[6][]
		px * macro_scale, // double px,
		py * macro_scale, // double py,
		disparity); // double disparity);
		double [] coords = {xy[0]/macro_scale,xy[1]/macro_scale};
		return coords;
		}





		// Copied from PixelMapping
		/**

Admin message