Merge branch 'foliage-gpu' working on the airplane mode

src/main/java/com/elphel/imagej/tileprocessor/ErsCorrection.java

@@ -231,8 +231,10 @@ public class ErsCorrection extends GeometryCorrection {
 			boolean use_ERS_roll) {
 		boolean [] param_select = new boolean[DP_NUM_PARS];
 //		for              (int i:DP_ZR_INDICES)      param_select[i] = true;
-		if (use_Z || use_XY)                        param_select[DP_DSZ] = true;
-		if (use_R || use_AT)                        param_select[DP_DSRL] = true;
+//		if (use_Z || use_XY)                        param_select[DP_DSZ] = true;
+//		if (use_R || use_AT)                        param_select[DP_DSRL] = true;
+		if (use_Z)                                  param_select[DP_DSZ] = true; // 12/12/2025 - removed ||
+		if (use_R)                                  param_select[DP_DSRL] = true; // 12/12/2025 - removed ||
 		if (use_XY) for  (int i:DP_XY_INDICES)      param_select[i] = true;
 		if (use_AT) for  (int i:DP_AT_INDICES)      param_select[i] = true;
 		if (use_ERS)                 param_select[DP_DSVAZ] = true;

src/main/java/com/elphel/imagej/tileprocessor/Interscene.java

@@ -1426,11 +1426,13 @@ public class Interscene {
 	        System.out.println();
 		}
 		// Now always, then - conditional
-		boolean adjust_disparity_ims = (debugLevel < 1000);
+		boolean adjust_disparity_ims = clt_parameters.imp.air_mode_en;
+		boolean apply_disparity_ims =  clt_parameters.imp.air_disp_corr;
 		if (adjust_disparity_ims) {
 	    	double scale_img = OpticalFlow.getImgImsScale( // correctInfinityFromIMS(
 	    			quadCLTs, // QuadCLT []       quadCLTs,
-	    			quadCLTs[ref_index]) ; // QuadCLT          master_CLT)
+	    			quadCLTs[ref_index], // QuadCLT          master_CLT)
+	    			earliest_scene);     // int              earliest_scene)
 			
 			double inf_disp = OpticalFlow.getImsDisparityCorrection(
 					scale_img,           // double           scale_img,
@@ -1439,10 +1441,12 @@ public class Interscene {
 	    	if (debugLevel > -3) {
 	    		System.out.println("Disparity at infinity ="+inf_disp+" in reference scene "+quadCLTs[ref_index].getImageName()+", scale_img="+scale_img);
 	    	}
+	    	
+	    	if (apply_disparity_ims) {
 	    		// Update DSI_MAIN with disparity at infinity. Store it somewhere in quadCLTs[ref_index]
 	    		quadCLTs[ref_index].offsetDSI(
-	    			-inf_disp); // double inf_disp)
-	    	quadCLTs[ref_index].setDispInfinityRef(
+	    				inf_disp); // double inf_disp)
+	    		quadCLTs[ref_index].setDispInfinityRef( // may use incDispInfinityRef() - was 0 before
 	    				inf_disp); // double disp)
 	    		// correct xyz
 	    		OpticalFlow.scaleImgXYZ(
@@ -1460,8 +1464,11 @@ public class Interscene {
 	    		quadCLTs[ref_index].saveDSIAll (
 	    				"-DSI_MAIN", // String suffix, // "-DSI_MAIN"
 	    				quadCLTs[ref_index].dsi);
-
-	    	
+	    	} else {
+		    	if (debugLevel > -3) {
+		    		System.out.println("Skipping application of disparity adjustment in reference scene "+quadCLTs[ref_index].getImageName()+", scale_img="+scale_img);
+		    	}
+	    	}
 		}
 		
 		quadCLTs[ref_index].set_orient(1); // first orientation

src/main/java/com/elphel/imagej/tileprocessor/OpticalFlow.java

@@ -103,6 +103,10 @@ public class OpticalFlow {
 	public static int COMBO_DSN_INDX_TERRAIN =    14; // Smooth ground surface w/o vegetation
 	
 	public static int [] COMBO_DSN_NONNAN = {COMBO_DSN_INDX_STRENGTH, COMBO_DSN_INDX_STRENGTH_BG,COMBO_DSN_INDX_SFM_GAIN};
+	public static int [] COMBO_DSN_DISPARITY = {COMBO_DSN_INDX_DISP,COMBO_DSN_INDX_LMA,COMBO_DSN_INDX_DISP_BG,COMBO_DSN_INDX_LMA_BG,
+			COMBO_DSN_INDX_DISP_FG,COMBO_DSN_INDX_DISP_BG_ALL,COMBO_DSN_INDX_GROUND,COMBO_DSN_INDX_TERRAIN};
+	
+	
 // move to Interscene class?	
 	// interscene adjustments failure reasons.
 	public static final int FAIL_REASON_LMA =            1; // LMA failed
@@ -5834,6 +5838,98 @@ public class OpticalFlow {
 								!batch_mode,    // boolean        test_motion_blur,
 								debugLevel) ;   // int            debugLevel)
 					}else {
+						if (clt_parameters.imp.air_mode_en) {
+							boolean apply_disparity_ims =  clt_parameters.imp.air_disp_corr;
+							// So far the same parameters. Modify - use IMS A,T,R,(Z ?), adjust X,Y, (Z?), same as for initial adjustment
+							earliest_scene = Interscene.reAdjustPairsLMAInterscene( // after combo dsi is available and preliminary poses are known
+									clt_parameters, // CLTParameters  clt_parameters,
+									mb_max_gain,    // double         mb_max_gain,
+									lma_use_Z,      // boolean use_Z,
+									lma_use_R,      // boolean use_R,
+									disable_ers,    // boolean        disable_ers,
+									disable_ers_y,  // boolean        disable_ers_y,
+									disable_ers_r,  // boolean        disable_ers_r,
+									lma_xyzatr,     // boolean        lma_xyzatr,
+									configured_lma, // boolean        configured_lma,
+									lpf_xy,         // boolean        lpf_xy,       // lpf x and y, re-adjust X,Y,Z,A,T,R with pull for X,Y. Disables  
+									avg_rlen,       // double         avg_rlen,
+									readjust_xy_ims,// boolean        readjust_xy_ims,  // readjust X,Y fromIMS linear velocities and full X,Y movement
+									// from the previous adjustment. Adjust A,T,R,Z (and optionally
+									// angular velocities) freely
+									reg_weight_xy,  // double         reg_weight_xy, // regularization weight for X and Y
+									reliable_ref,   // boolean []     reliable_ref, // null or bitmask of reliable reference tiles
+									quadCLTs,       // QuadCLT []     quadCLTs,
+									ref_index,      // int            ref_index,
+									new int [] {earliest_scene, last_index},  //int     []     range,
+									ers_mode,       // int            ers_mode, // 0 - keep, 1 - set from velocity, 2 - set from IMS
+									!batch_mode,    // boolean        test_motion_blur,
+									debugLevel) ;   // int            debugLevel)
+							if ((earliest_scene >= 0) && (earliest_scene < ref_index)) {
+								// adjust xyz from IMS, increment quadCLTs[ref_index] disparity at infinity (to be used by sfm)
+						    	double scale_img = OpticalFlow.getImgImsScale( // correctInfinityFromIMS(
+						    			quadCLTs, // QuadCLT []       quadCLTs,
+						    			quadCLTs[ref_index], // QuadCLT          master_CLT)
+						    			earliest_scene);     // int              earliest_scene)
+								double inf_disp = OpticalFlow.getImsDisparityCorrection(
+										scale_img,           // double           scale_img,
+										quadCLTs[ref_index], // QuadCLT          master_CLT,
+										debugLevel);         // final int        debugLevel) {
+						    	if (debugLevel > -3) {
+						    		System.out.println("Disparity at infinity ="+inf_disp+" in reference scene "+quadCLTs[ref_index].getImageName()+", scale_img="+scale_img);
+						    	}
+						    	if (apply_disparity_ims) {
+						    		// Update DSI_MAIN with disparity at infinity. Store it somewhere in quadCLTs[ref_index]
+						    		// Modify to update INTER-INTRA, not DSI_MAIN. Or always update both (if exists)
+						    		boolean updated = quadCLTs[ref_index].offsetComboDSI(
+						    				clt_parameters, // CLTParameters clt_parameters,
+						    				inf_disp,       // double        inf_disp,
+						    				false);         // boolean       silent) {
+						    		if (!updated) {
+						    			quadCLTs[ref_index].offsetDSI(
+							    				inf_disp);     // double        inf_disp,
+							    		quadCLTs[ref_index].saveDSIAll (
+							    				"-DSI_MAIN", // String suffix, // "-DSI_MAIN"
+							    				quadCLTs[ref_index].dsi);
+							    		if (debugLevel > -3) {
+							    			System.out.println("combo_dsi did not exist, updating DSI-MAIN with updated disparity at infinity for reference scene "+quadCLTs[ref_index].getImageName());
+							    		}
+						    		} else {
+							    		if (debugLevel > -3) {
+							    			System.out.println("Updated combo_dsi (-INTER-INTRA) for reference scene "+quadCLTs[ref_index].getImageName());
+							    		}
+						    			
+						    		}
+						    		quadCLTs[ref_index].incDispInfinityRef( // add to previous value that was used to generate INTER-INTRA... (intersceneExport or SFM
+						    				inf_disp); // double disp)
+						    		// correct xyz
+						    		OpticalFlow.scaleImgXYZ(
+						    				1.0/scale_img, //  double           scale_xyz,
+						    				quadCLTs, //, // QuadCLT []       quadCLTs,
+						    				quadCLTs[ref_index]); //QuadCLT          master_CLT)
+						    		quadCLTs[ref_index].saveInterProperties( // save properties for interscene processing (extrinsics, ers, ...)
+						    				null, // String path,             // full name with extension or w/o path to use x3d directory
+						    				//							 	null, // Properties properties,   // if null - will only save extrinsics)
+						    				debugLevel);
+						    		/*
+						    		if (debugLevel > -3) {
+						    			System.out.println("Updating DSI-MAIN with updated disparity at infinity for reference scene "+quadCLTs[ref_index].getImageName());
+						    		}
+						    		quadCLTs[ref_index].saveDSIAll (
+						    				"-DSI_MAIN", // String suffix, // "-DSI_MAIN"
+						    				quadCLTs[ref_index].dsi);
+						    				*/
+						    	} else {
+							    	if (debugLevel > -3) {
+							    		System.out.println("Skipping application of disparity adjustment in reference scene "+quadCLTs[ref_index].getImageName()+", scale_img="+scale_img);
+							    	}
+						    	}
+
+								
+								
+							}
+							
+							
+						} else {
 							earliest_scene = Interscene.reAdjustPairsLMAInterscene( // after combo dsi is available and preliminary poses are known
 									clt_parameters, // CLTParameters  clt_parameters,
 									mb_max_gain,    // double         mb_max_gain,
@@ -5858,6 +5954,7 @@ public class OpticalFlow {
 									!batch_mode,    // boolean        test_motion_blur,
 									debugLevel) ;   // int            debugLevel)
 						}
+					}
 					// should update earliest_scene
 					if ((last_index - earliest_scene + 1) < min_num_scenes) {
 						System.out.println("After reAdjustPairsLMAInterscene() total number of useful scenes = "+(ref_index - earliest_scene + 1)+
@@ -5951,6 +6048,7 @@ public class OpticalFlow {
 					quadCLTs,           // QuadCLT []      quadCLTs,	    		
 					master_CLT,         // QuadCLT         master_CLT,
 					quadCLT_main,       // QuadCLT          quadCLT_main,
+					earliest_scene,     // int              earliest_scene)
 					debugLevel       ); // final int       debugLevel)
 			return null;
 		}
@@ -7492,10 +7590,12 @@ public class OpticalFlow {
     public static double getImsDisparityCorrection(
     		QuadCLT []       quadCLTs,
     		QuadCLT          master_CLT,
-    		final int        debugLevel) {
+    		final int        debugLevel,
+			int              earliest_scene) {
     	double scale_img = getImgImsScale( // correctInfinityFromIMS(
     			quadCLTs, // QuadCLT []       quadCLTs,
-    			master_CLT) ; // QuadCLT          master_CLT)
+    			master_CLT, // QuadCLT          master_CLT)
+    			earliest_scene);     // int              earliest_scene)
 		double [] disparity_dsi = master_CLT.getDLS()[1]; // null
 		double [] strength = master_CLT.getDLS()[2];
 		double sw=0,swd=0; // old, new-old
@@ -7541,11 +7641,13 @@ public class OpticalFlow {
     		QuadCLT []       quadCLTs,
     		QuadCLT          master_CLT,
     		QuadCLT          quadCLT_main,
+    		int              earliest_scene,
     		final int        debugLevel) {
     	double magic_coeff = 0.365; // how much disparity increases per 1 pixel sym_vector[0]
     	double scale_img = getImgImsScale( // correctInfinityFromIMS(
     			quadCLTs, // QuadCLT []       quadCLTs,
-    			master_CLT) ; // QuadCLT          master_CLT)
+    			master_CLT, // QuadCLT          master_CLT)
+    			earliest_scene);     // int              earliest_scene)
 		double [] disparity_dsi = master_CLT.getDLS()[1]; // null
 		double [] strength = master_CLT.getDLS()[2];
 		double sw=0,swd=0; // old, new-old
@@ -7597,12 +7699,13 @@ public class OpticalFlow {
     
     public static double getImgImsScale( // correctInfinityFromIMS(
 			QuadCLT []       quadCLTs,
-			QuadCLT          master_CLT) {
+			QuadCLT          master_CLT,
+			int              earliest_scene) {
 		ErsCorrection ers_reference = master_CLT.getErsCorrection();
 		// find first and last initialized scenes, assuming approximate moving in the same direction
 		double [] xyz0 = null, xyz1 = null;
 		Did_ins_2 d2_0 = null,   d2_1 = null;
-		for (int nscene = 0; nscene < quadCLTs.length; nscene++) {
+		for (int nscene = earliest_scene; nscene < quadCLTs.length; nscene++) {
 			QuadCLT scene = quadCLTs[nscene];
 			String ts = scene.getImageName();
 			if ((ers_reference.getSceneXYZ(ts) != null) && (scene.did_ins_2 != null)) {
@@ -7628,7 +7731,6 @@ public class OpticalFlow {
 			travel_ims2 += dned[i]*dned[i]; 
 		}
     	double img_scale = Math.sqrt(travel_visual2/travel_ims2);
-    	
     	return img_scale;
     }
     
@@ -7857,7 +7959,8 @@ public class OpticalFlow {
 				double avg_z = ref_scene.getGeometryCorrection().getZFromDisparity(disp_avg);
 		    	double scale_img = getImgImsScale( // correctInfinityFromIMS(
 		    			quadCLTs,              // QuadCLT []       quadCLTs,
-		    			ref_scene);            // QuadCLT          master_CLT)
+		    			ref_scene,             // QuadCLT          master_CLT)
+		    			0); // earliest_scene);       // int              earliest_scene)		    			
 		    	inf_disp_ref = disp_avg * (1.0 - scale_img);
 		    	System.out.println("inf_disp_ref="+inf_disp_ref);
 				

src/main/java/com/elphel/imagej/tileprocessor/QuadCLTCPU.java

@@ -291,7 +291,7 @@ public class QuadCLTCPU {
      * Increment disparity at infinity for this scene when it is a reference one.
      * @param disp disparity at infinity value to add to the previous one. Will be used when calculating INTER-INTRA
      */
-    public void IncDispInfinityRef(
+    public void incDispInfinityRef(
     		double disp) {
     	disp_infinity_ref += disp;
     }
@@ -6389,12 +6389,49 @@ public class QuadCLTCPU {
 		for (int nslice:TwoQuadCLT.DSI_DISPARITY)  if (dsi[nslice] != null){
 			double [] slice = dsi[nslice];
 			for (int i = 0; i < slice.length; i++) {
-				slice[i] += inf_disp;
+				slice[i] -= inf_disp;
 			}
 		}
 		return;
 	}
 	
+	public boolean offsetComboDSI(
+			CLTParameters clt_parameters,
+			double        inf_disp,
+			boolean       silent) {
+		double [][] combo_dsi = restoreComboDSI ( silent);
+		if (combo_dsi==null) {
+			return false;
+		}
+		offsetComboDSI(
+				inf_disp, // double inf_disp,
+				combo_dsi); // double [][] dsi)
+		String rslt_suffix = "-INTER-INTRA";
+		rslt_suffix += (clt_parameters.correlate_lma?"-LMA":"-NOLMA");
+		saveDoubleArrayInModelDirectory( // error
+				rslt_suffix,           // String      suffix,
+				OpticalFlow.COMBO_DSN_TITLES, // combo_dsn_titles_full, // null,          // String []   labels, // or null
+				combo_dsi,             // dbg_data,         // double [][] data,
+				getTilesX(),                // int         width,
+				getTilesY());               // int         height)
+		return true;
+	}
+	
+	
+	public static void offsetComboDSI(
+			double inf_disp,
+			double [][] combo_dsi) {
+		if (combo_dsi == null) {
+			throw new IllegalArgumentException ("offsetDSI(): can not apply as dsi==null");
+		}
+		for (int nslice:OpticalFlow.COMBO_DSN_DISPARITY)  if (combo_dsi[nslice] != null){
+			double [] slice = combo_dsi[nslice];
+			for (int i = 0; i < slice.length; i++) {
+				slice[i] -= inf_disp;
+			}
+		}
+		return;
+	}
 	
 
 	// Save GT from main and AUX calculated DS