Using main camera -only DSI in the model where aux camera is occluded (b5f3d42a) · Commits · Elphel / imagej-elphel

src/main/java/BiQuadParameters.java

+33 −7

Original line number	Diff line number	Diff line
		@@ -237,9 +237,13 @@ public class BiQuadParameters {
		public double rf_min_disp = 0.02; // Minimal tile disparity to keep in scan
		public boolean rf_remove_unselected = true; // Remove tiles that are not selected

		public boolean oc_fill_aux_occl = true; // Fill rig DSI gaps non-zero for the main camera
		public double oc_min_disparity = 15; // Tile occlusions can only happen for near objects
		public double oc_min_strength = 0.1; // Minimal main camera strength


		public boolean ml_generate = false; // Generate ML data automatically when running ground truth

		// public boolean ml_generate = false; // Generate ML data automatically when running ground truth - MOVED to BATCH parameters
		public boolean ml_poles = true; // Generate ML data from the DSI that includes extracted poles
		public boolean ml_copyJP4 = true; // Copy source jp4 files when running "Ground truth" command

		@@ -631,11 +635,17 @@ public class BiQuadParameters {
		"Minimal disparity (in master camera pixels) for the tile to be saved for plane extraction");
		gd.addCheckbox ("Remove tiles that are not selected", this.rf_remove_unselected,
		"Remove (set strength to 0.0, disparity to Double.NaN for all tiles that are not selected");
		gd.addCheckbox ("Fill rig gaps by the main camera", this.oc_fill_aux_occl,
		"Areas where aux camera image is occluded");
		gd.addNumericField("Minimal main camera disparity to use for rig DSI gaps", this.oc_min_disparity, 3,6,"pix",
		"Legitimate full tile occlusions can happen for near objects only");
		gd.addNumericField("Minimal main camera strength to fill rig DSI gaps", this.oc_min_strength, 3,6,"",
		"Filter out too weak replacements");

		gd.addTab("ML","Parameters related to the ML files generation for the dual-quad camera rig");

		gd.addCheckbox ("Generate ML data automatically", this.ml_generate,
		"Generate ML data automatically when running ground truth (may run separately from a command button)");
		// gd.addCheckbox ("Generate ML data automatically", this.ml_generate,
		// "Generate ML data automatically when running ground truth (may run separately from a command button)");
		gd.addCheckbox ("Generate ML data from the DSI that includes extracted poles", this.ml_poles,
		"If unchecked - use DSI w/o poles data");
		gd.addCheckbox ("Copy JP4 source images when generating ML data", this.ml_copyJP4,
		@@ -853,8 +863,12 @@ public class BiQuadParameters {

		this.rf_min_disp= gd.getNextNumber();
		this.rf_remove_unselected= gd.getNextBoolean();
		this.oc_fill_aux_occl= gd.getNextBoolean();
		this.oc_min_disparity= gd.getNextNumber();
		this.oc_min_strength= gd.getNextNumber();


		this.ml_generate= gd.getNextBoolean();
		// this.ml_generate= gd.getNextBoolean();
		this.ml_poles= gd.getNextBoolean();
		this.ml_copyJP4= gd.getNextBoolean();

		@@ -1061,7 +1075,11 @@ public class BiQuadParameters {
		properties.setProperty(prefix+"rf_min_disp", this.rf_min_disp+"");
		properties.setProperty(prefix+"rf_remove_unselected", this.rf_remove_unselected+"");

		properties.setProperty(prefix+"ml_generate", this.ml_generate+"");
		properties.setProperty(prefix+"oc_fill_aux_occl", this.oc_fill_aux_occl+"");
		properties.setProperty(prefix+"oc_min_disparity", this.oc_min_disparity+"");
		properties.setProperty(prefix+"oc_min_strength", this.oc_min_strength+"");

		// properties.setProperty(prefix+"ml_generate", this.ml_generate+"");
		properties.setProperty(prefix+"ml_poles", this.ml_poles+"");
		properties.setProperty(prefix+"ml_copyJP4", this.ml_copyJP4+"");
		properties.setProperty(prefix+"ml_hwidth", this.ml_hwidth+"");
		@@ -1264,7 +1282,11 @@ public class BiQuadParameters {
		if (properties.getProperty(prefix+"rf_min_disp")!=null) this.rf_min_disp=Double.parseDouble(properties.getProperty(prefix+"rf_min_disp"));
		if (properties.getProperty(prefix+"rf_remove_unselected")!=null) this.rf_remove_unselected=Boolean.parseBoolean(properties.getProperty(prefix+"rf_remove_unselected"));

		if (properties.getProperty(prefix+"ml_generate")!=null) this.ml_generate=Boolean.parseBoolean(properties.getProperty(prefix+"ml_generate"));
		if (properties.getProperty(prefix+"oc_fill_aux_occl")!=null) this.oc_fill_aux_occl=Boolean.parseBoolean(properties.getProperty(prefix+"oc_fill_aux_occl"));
		if (properties.getProperty(prefix+"oc_min_disparity")!=null) this.oc_min_disparity=Double.parseDouble(properties.getProperty(prefix+"oc_min_disparity"));
		if (properties.getProperty(prefix+"oc_min_strength")!=null) this.oc_min_strength=Double.parseDouble(properties.getProperty(prefix+"oc_min_strength"));

		// if (properties.getProperty(prefix+"ml_generate")!=null) this.ml_generate=Boolean.parseBoolean(properties.getProperty(prefix+"ml_generate"));
		if (properties.getProperty(prefix+"ml_poles")!=null) this.ml_poles=Boolean.parseBoolean(properties.getProperty(prefix+"ml_poles"));
		if (properties.getProperty(prefix+"ml_copyJP4")!=null) this.ml_copyJP4=Boolean.parseBoolean(properties.getProperty(prefix+"ml_copyJP4"));
		if (properties.getProperty(prefix+"ml_hwidth")!=null) this.ml_hwidth=Integer.parseInt(properties.getProperty(prefix+"ml_hwidth"));
		@@ -1468,7 +1490,11 @@ public class BiQuadParameters {
		bqp.rf_min_disp= this.rf_min_disp;
		bqp.rf_remove_unselected= this.rf_remove_unselected;

		bqp.ml_generate= this.ml_generate;
		bqp.oc_fill_aux_occl = this.oc_fill_aux_occl;
		bqp.oc_min_disparity = this.oc_min_disparity;
		bqp.oc_min_strength = this.oc_min_strength;

		// bqp.ml_generate= this.ml_generate;
		bqp.ml_poles= this.ml_poles;
		bqp.ml_copyJP4= this.ml_copyJP4;
		bqp.ml_hwidth= this.ml_hwidth;

src/main/java/EyesisCorrectionParameters.java

+83 −3

Original line number	Diff line number	Diff line
		@@ -134,6 +134,7 @@ public class EyesisCorrectionParameters {
		public boolean clt_batch_surf = true; // Create super-tile 2.5d surfaces
		public boolean clt_batch_assign = true; // Assign tiles to surfaces
		public boolean clt_batch_gen3d = true; // Generate 3d output: x3d and/or obj+mtl
		public boolean clt_batch_genMl = true; // Generate ML output
		public boolean clt_batch_dbg1 = true; // Generate debug images if a single set is selected
		public boolean clt_batch_dsi = true; // Create and save DSI combo image with the model
		public boolean clt_batch_dsi_aux = false; // Calculate and save aux camera DSI (currently it is offset from the main/rig data
		@@ -268,6 +269,7 @@ public class EyesisCorrectionParameters {
		cp.clt_batch_surf= this.clt_batch_surf;
		cp.clt_batch_assign= this.clt_batch_assign;
		cp.clt_batch_gen3d= this.clt_batch_gen3d;
		cp.clt_batch_genMl= this.clt_batch_genMl;
		cp.clt_batch_dbg1= this.clt_batch_dbg1;

		cp.clt_batch_dsi= this.clt_batch_dsi;
		@@ -422,6 +424,8 @@ public class EyesisCorrectionParameters {
		properties.setProperty(prefix+"clt_batch_surf", this.clt_batch_surf+"");
		properties.setProperty(prefix+"clt_batch_assign", this.clt_batch_assign+"");
		properties.setProperty(prefix+"clt_batch_gen3d", this.clt_batch_gen3d+"");
		properties.setProperty(prefix+"clt_batch_genMl", this.clt_batch_genMl+"");

		properties.setProperty(prefix+"clt_batch_dbg1", this.clt_batch_dbg1+"");

		properties.setProperty(prefix+"clt_batch_dsi", this.clt_batch_dsi+"");
		@@ -571,6 +575,8 @@ public class EyesisCorrectionParameters {
		if (properties.getProperty(prefix+"clt_batch_surf")!= null) this.clt_batch_surf=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_surf"));
		if (properties.getProperty(prefix+"clt_batch_assign")!= null) this.clt_batch_assign=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_assign"));
		if (properties.getProperty(prefix+"clt_batch_gen3d")!= null) this.clt_batch_gen3d=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_gen3d"));

		if (properties.getProperty(prefix+"clt_batch_genMl")!= null) this.clt_batch_genMl=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_genMl"));
		if (properties.getProperty(prefix+"clt_batch_dbg1")!= null) this.clt_batch_dbg1=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_dbg1"));

		if (properties.getProperty(prefix+"clt_batch_dsi")!= null) this.clt_batch_dsi=Boolean.parseBoolean(properties.getProperty(prefix+"clt_batch_dsi"));
		@@ -919,6 +925,8 @@ public class EyesisCorrectionParameters {
		gd.addCheckbox ("Create super-tile 2.5d surfaces", this.clt_batch_surf); // 26
		gd.addCheckbox ("Assign tiles to surfaces", this.clt_batch_assign); // 27
		gd.addCheckbox ("Generate 3d output: x3d and/or obj+mtl", this.clt_batch_gen3d); // 28
		gd.addCheckbox ("Generate ML output files", this.clt_batch_genMl); // 28

		gd.addCheckbox ("Generate debug images if a single set is selected", this.clt_batch_dbg1); // 29

		gd.addCheckbox ("Create DSI combo image", this.clt_batch_dsi,
		@@ -1000,6 +1008,7 @@ public class EyesisCorrectionParameters {
		this.clt_batch_surf= gd.getNextBoolean(); // 26
		this.clt_batch_assign= gd.getNextBoolean(); // 27
		this.clt_batch_gen3d= gd.getNextBoolean(); // 28
		this.clt_batch_genMl= gd.getNextBoolean(); // 28
		this.clt_batch_dbg1= gd.getNextBoolean(); // 29
		this.clt_batch_dsi= gd.getNextBoolean();
		this.clt_batch_dsi_aux= gd.getNextBoolean();
		@@ -2642,6 +2651,7 @@ public class EyesisCorrectionParameters {
		public int ly_par_sel = 0; // Manually select the parameter mask bit 0 - sym0, bit1 - sym1, ... (0 - use checkbox selections above)

		public double ly_inf_frac = 0.5; // Relative weight of infinity calibration data
		public double ly_inf_max_disparity = 0.2; // Maximal disparity to be treated as infinity when adjusting with rig data
		public boolean ly_inf_disp= false; // Correct disparity for infinity tiles
		public boolean ly_inf_force= false; // Force convergence correction during extrinsic, even with no infinity data
		public boolean ly_poly = false; // Use polynomial correction, false - correct tilt/azimuth/roll of each sensor
		@@ -3222,8 +3232,10 @@ public class EyesisCorrectionParameters {
		public PoleProcessorParameters poles = new PoleProcessorParameters();
		public MeasuredLayersFilterParameters mlfp = new MeasuredLayersFilterParameters();

		public HashMap<String,Double> z_corr_map = new HashMap<String,Double>();
		public HashMap<String,Double> z_corr_map = new HashMap<String,Double>(); //old one
		public HashMap<String,Double> infinity_distace_map = new HashMap<String,Double>(); //new one
		public static String Z_CORR_PREFIX = "z_corr.";
		public static String INFINITY_DISTANCE_PREFIX = "infinity_distance.";

		public boolean batch_run = false; // turned on only while running in batch mode

		@@ -3369,6 +3381,7 @@ public class EyesisCorrectionParameters {

		properties.setProperty(prefix+"ly_inf_frac", this.ly_inf_frac +"");

		properties.setProperty(prefix+"ly_inf_max_disparity",this.ly_inf_max_disparity +"");
		properties.setProperty(prefix+"ly_inf_disp", this.ly_inf_disp+"");
		properties.setProperty(prefix+"ly_inf_force", this.ly_inf_force+"");
		properties.setProperty(prefix+"ly_poly", this.ly_poly+"");
		@@ -3888,13 +3901,29 @@ public class EyesisCorrectionParameters {
		properties.setProperty(prefix+Z_CORR_PREFIX+entry.getKey(), entry.getValue().toString());
		}
		}
		setPropertiesInfinityDistance(prefix, properties);
		/*
		if (infinity_distace_map != null) {
		for (HashMap.Entry<String,Double> entry : infinity_distace_map.entrySet()){
		properties.setProperty(prefix+INFINITY_DISTANCE_PREFIX+entry.getKey(), entry.getValue().toString());
		}
		}
		*/
		img_dtt.setProperties (prefix+"_img_dtt", properties);
		mlfp.setProperties (prefix+"_mlfp", properties);
		rig.setProperties (prefix+"_rig", properties);
		poles.setProperties (prefix+"_poles", properties);
		}


		public void setPropertiesInfinityDistance(String prefix,Properties properties){
		if (infinity_distace_map != null) {
		for (HashMap.Entry<String,Double> entry : infinity_distace_map.entrySet()){
		properties.setProperty(prefix+INFINITY_DISTANCE_PREFIX+entry.getKey(), entry.getValue().toString());
		}
		}
		}


		public void getProperties(String prefix,Properties properties){
		if (properties.getProperty(prefix+"transform_size")!=null) this.transform_size=Integer.parseInt(properties.getProperty(prefix+"transform_size"));
		if (properties.getProperty(prefix+"clt_window")!=null) this.clt_window=Integer.parseInt(properties.getProperty(prefix+"clt_window"));
		@@ -4035,6 +4064,7 @@ public class EyesisCorrectionParameters {
		if (properties.getProperty(prefix+"ly_par_sel")!=null) this.ly_par_sel=Integer.parseInt(properties.getProperty(prefix+"ly_par_sel"));

		if (properties.getProperty(prefix+"ly_inf_frac")!=null) this.ly_inf_frac=Double.parseDouble(properties.getProperty(prefix+"ly_inf_frac"));
		if (properties.getProperty(prefix+"ly_inf_max_disparity")!=null) this.ly_inf_max_disparity=Double.parseDouble(properties.getProperty(prefix+"ly_inf_max_disparity"));

		if (properties.getProperty(prefix+"ly_inf_disp")!=null) this.ly_inf_disp=Boolean.parseBoolean(properties.getProperty(prefix+"ly_inf_disp"));

		@@ -4568,6 +4598,13 @@ public class EyesisCorrectionParameters {
		z_corr_map.put(s.substring(li), Double.parseDouble(properties.getProperty(s)));
		}
		}
		String full_prefix_infinity_distance = prefix+INFINITY_DISTANCE_PREFIX;
		int lii = full_prefix_infinity_distance.length();
		for (String s:ss){
		if (s.indexOf(full_prefix_infinity_distance) == 0){
		infinity_distace_map.put(s.substring(lii), Double.parseDouble(properties.getProperty(s)));
		}
		}
		img_dtt.getProperties (prefix+"_img_dtt", properties);
		mlfp.getProperties (prefix+"_mlfp", properties);
		rig.getProperties (prefix+"_rig", properties);
		@@ -4744,6 +4781,10 @@ public class EyesisCorrectionParameters {
		gd.addNumericField("Manual parameter mask selection (0 use checkboxes above)", this.ly_par_sel, 0, 5,"",
		"bit 0 - sym0, bit1 - sym1, ...");
		gd.addNumericField("Relative weight of infinity calibration data", this.ly_inf_frac, 3);

		gd.addNumericField("Maximal disparity to be treated as infinity when adjusting with the rig data", this.ly_inf_max_disparity, 8,3,"pix",
		"Only used in guided (by rig data) mode");

		gd.addCheckbox ("Correct disparity for infinity tiles )has to disable until code fixed)", this.ly_inf_disp);
		gd.addCheckbox ("Force convergence correction during extrinsic, even with no infinity data", this.ly_inf_force);
		gd.addCheckbox ("*Use polynomial correction, false - correct tilt/azimuth/roll of each sensor)", this.ly_poly);
		@@ -5514,6 +5555,7 @@ public class EyesisCorrectionParameters {
		this.ly_par_sel= (int) gd.getNextNumber();

		this.ly_inf_frac= gd.getNextNumber();
		this.ly_inf_max_disparity= gd.getNextNumber();

		this.ly_inf_disp= gd.getNextBoolean();
		this.ly_inf_force= gd.getNextBoolean();
		@@ -6228,6 +6270,44 @@ public class EyesisCorrectionParameters {
		}
		return true;
		}
		public boolean modifyInfCorr (String title) {
		if (infinity_distace_map == null){
		infinity_distace_map = new HashMap<String,Double>();
		}
		GenericDialog gd = new GenericDialog(title);
		if (infinity_distace_map.size() > 0) {
		gd.addMessage("Edit \"infinity\" (when mountains are too close) distance (in m), set == 0.0 to remove for the following");
		gd.addMessage("Press \"Cancel\" to exit");
		for (HashMap.Entry<String,Double> entry : infinity_distace_map.entrySet()){
		gd.addNumericField(entry.getKey(), entry.getValue(), 1,6, "m");
		}
		}
		gd.addMessage("Add new infinity correction");
		gd.addStringField ("Timestamp string (seconds_microseconds):", "", 40);
		gd.addNumericField("Infinity distance", 0, 1,6,"m");
		gd.addCheckbox ("Clear list", false);
		WindowTools.addScrollBars(gd);
		gd.showDialog();
		if (gd.wasCanceled()) return false;
		HashMap<String,Double> new_map = new HashMap<String,Double>();
		for (HashMap.Entry<String,Double> entry : infinity_distace_map.entrySet()){
		double d = gd.getNextNumber();
		if (d != 0.0) {
		new_map.put(entry.getKey(),d);
		}
		}
		String new_ts = gd.getNextString();
		double d = gd.getNextNumber();
		if (gd.getNextBoolean()){
		infinity_distace_map = new HashMap<String,Double>();
		} else {
		infinity_distace_map = new_map;
		}
		if(new_ts.length() > 0){
		infinity_distace_map.put(new_ts, d);
		}
		return true;
		}
		}

		public static class DCTParameters {

src/main/java/Eyesis_Correction.java

+66 −13

Original line number	Diff line number	Diff line
		@@ -583,6 +583,8 @@ private Panel panel1,
		// addButton("CLT 2*4 images", panelClt4, color_conf_process);
		// addButton("CLT 2*4 images - 2", panelClt4, color_conf_process);
		// addButton("CLT 2*4 images - 3", panelClt4, color_conf_process);
		addButton("Rig offset", panelClt4, color_configure);
		addButton("Save offset", panelClt4, color_process);
		addButton("SHOW extrinsics", panelClt4, color_configure);
		addButton("RIG DSI", panelClt4, color_conf_process);
		addButton("MAIN extrinsics", panelClt4, color_process);
		@@ -1171,6 +1173,12 @@ private Panel panel1,
		return;
		/* ======================================================================== */

		} else if (label.equals("Save offset")) {

		saveInfinityOffsets(null,CORRECTION_PARAMETERS.resultsDirectory);
		return;
		/* ======================================================================== */

		} else if (label.equals("Restore")) {
		String path= loadProperties(null,CORRECTION_PARAMETERS.resultsDirectory,true, PROPERTIES);
		if (path != null) {
		@@ -3703,6 +3711,12 @@ private Panel panel1,
		if (!CLT_PARAMETERS.modifyZCorr("Modify infinity per image set disparity corrections")) break;
		}
		return;
		/* ======================================================================== */
		} else if (label.equals("Rig offset")) {
		while (true) {
		if (!CLT_PARAMETERS.modifyInfCorr("Modify infinity offset per image set disparity corrections")) break;
		}
		return;
		/* ======================================================================== */
		} else if (label.equals("Select CLT image")) {
		DEBUG_LEVEL=MASTER_DEBUG_LEVEL;
		@@ -5360,19 +5374,6 @@ private Panel panel1,

		public boolean batchRig() {
		long startTime=System.nanoTime();
		/* if ((QUAD_CLT == null) \|\| (QUAD_CLT.tp == null) \|\| (QUAD_CLT.tp.clt_3d_passes == null) \|\| (QUAD_CLT.tp.clt_3d_passes.size() == 0)) {

		boolean OK = clt3d(
		false, // boolean adjust_extrinsics,
		false); // boolean adjust_poly);
		if (! OK) {
		String msg = "DSI data is not available and \"CLT 3D\" failed";
		IJ.showMessage("Error",msg);
		System.out.println(msg);
		return false;
		}
		}
		*/
		// load needed sensor and kernels files
		if (!prepareRigImages()) return false;
		String configPath=getSaveCongigPath();
		@@ -6709,7 +6710,59 @@ private Panel panel1,

		}

		public void saveInfinityOffsets(
		String path, // full path or null
		String directory) { // use as default directory if path==null
		String [] patterns= {".corr-xml",".xml"};
		if (path==null) {
		path= selectFile(true, // save
		"Save configuration selection", // title
		"Select configuration file", // button
		new MultipleExtensionsFileFilter(patterns, "XML Configuration files (*.corr-xml)"), // filter
		directory); // may be ""
		} else path+=patterns[0];
		if (path==null) return;
		Properties properties = new Properties();

		CLT_PARAMETERS.setPropertiesInfinityDistance("CLT_PARAMETERS.", properties);
		// setAllProperties(properties);

		OutputStream os;
		try {
		os = new FileOutputStream(path);
		} catch (FileNotFoundException e1) {
		// missing config directory
		File dir = (new File(path)).getParentFile();
		if (!dir.exists()){
		dir.mkdirs();
		try {
		os = new FileOutputStream(path);
		} catch (FileNotFoundException e2) {
		IJ.showMessage("Error","Failed to create directory "+dir.getName()+" to save configuration file: "+path);
		return;
		}
		} else {
		IJ.showMessage("Error","Failed to open configuration file: "+path);
		return;
		}
		}
		try {
		properties.storeToXML(os,
		"last updated " + new java.util.Date(), "UTF8");

		} catch (IOException e) {
		IJ.showMessage("Error","Failed to write XML configuration file: "+path);
		return;
		}
		try {
		os.close();
		} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
		}
		if (DEBUG_LEVEL> -3) System.out.println("Configuration parameters are saved to "+path);

		}


		/* ======================================================================== */

src/main/java/GeometryCorrection.java

+91 −85

File changed.

Preview size limit exceeded, changes collapsed.

src/main/java/ImageDtt.java

+13 −2

Original line number	Diff line number	Diff line
		@@ -7589,6 +7589,8 @@ public class ImageDtt {
		final double [][][][][][] clt_kernels_aux, // [channel_in_quad][color][tileY][tileX][band][pixel] , size should match image (have 1 tile around)
		final double corr_magic_scale, // still not understood coefficient that reduces reported disparity value. Seems to be around 0.85
		final boolean keep_clt_data,
		final int [][] woi_tops,
		final double [][][] ers_delay, // if not null - fill with tile center acquisition delay
		final int threadsMax, // maximal number of threads to launch
		final int debugLevel)
		{
		@@ -7717,8 +7719,12 @@ public class ImageDtt {
		}
		}

		// final double [] corr_max_weights_poly =(((clt_parameters.max_corr_sigma > 0) && (disparity_bimap != null))?
		// setMaxXYWeights(clt_parameters.max_corr_sigma,max_search_radius_poly): null); // here use square anyway
		if (ers_delay != null) {
		ers_delay[0] = new double [quad_main][];
		for (int i = 0; i < quad_main; i++) ers_delay[0][i] = new double [tilesX*tilesY];
		ers_delay[1] = new double [quad_aux][];
		for (int i = 0; i < quad_aux; i++) ers_delay[1][i] = new double [tilesX*tilesY];
		}

		dtt.set_window(clt_parameters.clt_window);
		final double [] lt_window = dtt.getWin2d(); // [256]
		@@ -7820,6 +7826,11 @@ public class ImageDtt {
		centerX,
		centerY,
		disparity_aux); // + disparity_corr);
		// acquisition time of the tiles centers in scanline times
		if (ers_delay != null) {
		for (int i = 0; i < quad_main; i++) ers_delay[0][i][nTile] = centersXY_main[i][1]-woi_tops[0][i];
		for (int i = 0; i < quad_aux; i++) ers_delay[1][i][nTile] = centersXY_aux[i][1]- woi_tops[1][i];
		}

		if ((globalDebugLevel > 0) && (tileX == debug_tileX) && (tileY == debug_tileY)) {
		for (int i = 0; i < quad_main; i++) {

Admin message