Working on 100m AGL

src/main/java/com/elphel/imagej/orthomosaic/ItemMatch.java

@@ -69,6 +69,24 @@ public class ItemMatch {
 		}
 		return match.getMatch(indx);
 	}
+
+	/**
+	 * Return correlation value as the one of the pattern correlations pointed
+	 * by the best subpattern index.
+	 * @param groundObjectPattern
+	 * @return selected correlation value
+	 */
+	public double getMatchValue(GroundObjectPattern groundObjectPattern) {
+		return getMatchValue(groundObjectPattern.getPatternPath());
+	}
+	
+	
+	public double getMatchValue(String pattern_path) {
+		int indx = getPatternMatch(pattern_path).getBestSub(); // -1;
+		return getMatchValue(pattern_path,indx);
+	}
+	
+	
 	
 	public double getMatchValue(GroundObjectPattern groundObjectPattern, int indx) {
 		return getMatchValue(groundObjectPattern.getPatternPath(), indx);

src/main/java/com/elphel/imagej/orthomosaic/OrthoMap.java

@@ -2073,18 +2073,28 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 	 * @param ipattern square pattern array corresponding to data. 1 means 
 	 *                 average (w/o outliers) and add, 2 - average and subtract
 	 * @param outliers_frac - fraction of outliers to remove while averaging
+	 * @param obscure_frac fraction between center average and peripheral ring to compare when obscure_warm
+	 *        is set.
 	 * @param masked_data null or double[data.length] - will return a copy of data
 	 *        with NaN for all unused for averaging 
 	 * @param debug show debug images
-	 * @return difference between average in-pattern (1) and outside (2) average
-	 *         values  
+	 * @return a pair of : difference between average in-pattern (1) and outside (2) average
+	 *         values, and difference between third zone and a threshold between averages of zone1
+	 *         and zone2. For full patterns (no zone3) this value is NaN. Positive values are good,
+	 *         regardless the cold or warm center. For cold patterns (morning) positive means
+	 *         that zone 3 minimum is warmer than fraction point between zone1 and zone2 (cold 
+	 *         object obscured by something warmer, for hot - that obscurant is colder.
+	 *           
 	 */
-	public static double getAbsoluteContrast(
+	public static double [] getAbsoluteContrast(
 			double [] data,
 			int    [] ipattern,
 			double    outliers_frac,
+//			boolean   obscure_warm, // =  true; // obscured can only be by warmer objects 
+			double    obscure_frac, //  0.25; // obscured threshold between center and outer 
 			double [] masked_data, // null or double [data.length] to return masked data
 			boolean   debug) {
+		int num_segments = 3;
 		if (debug) {
 			int size = (int) Math.sqrt(data.length);
 			ShowDoubleFloatArrays.showArrays(
@@ -2095,11 +2105,14 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 			
 		}
 		ArrayList<ArrayList<Integer>> lists = new ArrayList<ArrayList<Integer>>();
-		for (int i = 0; i < 2; i++) {
+		for (int i = 0; i < num_segments; i++) {
 			lists.add(new ArrayList<Integer>());
 		}
-		double [] swd = new double [2],sw = new double [2], avg= new double[2], fracw=new double[2];
-		for (int n = 0; n < swd.length; n++) {
+		double [] swd = new double [num_segments],
+				sw = new double [num_segments],
+				avg= new double[num_segments],
+				fracw=new double[num_segments];
+		for (int n = 0; n < num_segments; n++) { // swd.length; n++) {
 			ArrayList<Integer> list = lists.get(n);
 			int n1 = n+1;
 			for (int i = 0; i < ipattern.length; i++) if (ipattern[i] == n1){
@@ -2110,9 +2123,23 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 			avg[n] = swd[n]/sw[n];
 			fracw[n] = (1.0-outliers_frac) * sw[n];
 		}
+		double [] zone3_min_max = {Double.NaN, Double.NaN};
+		int zone3=3;
+		for (int i:lists.get(zone3-1)) {
+			if (Double.isNaN(zone3_min_max[0]) || (data[i] < zone3_min_max[0])) {
+				zone3_min_max[0] = data[i];
+			}
+			if (Double.isNaN(zone3_min_max[1]) || (data[i] > zone3_min_max[1])) {
+				zone3_min_max[1] = data[i];
+			}
+		}
+
+		
+		
 		if (debug) {
 			System.out.println("getAbsoluteContrast() before outliers: avg[0] ="+avg[0]+", avg[1]="+avg[1]+", avg[0]-avg[1]="+(avg[0]-avg[1]));
 		}
+		
 		if (outliers_frac > 0) {
 			for (int n = 0; n < swd.length; n++) {
 				ArrayList<Integer> list = lists.get(n);
@@ -2124,7 +2151,7 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 						return (rhsd > lhsd) ? -1 : (rhsd < lhsd) ? 1 : 0;
 					}
 				});
-				while (sw[n] >= fracw[n]) {
+				while (!list.isEmpty() && (sw[n] >= fracw[n])) {
 					int indx_first = list.get(0);
 					int indx_last = list.get(list.size()-1);
 					boolean remove_first = Math.abs(data[indx_first] - avg[n]) > Math.abs(data[indx_last] - avg[n]);
@@ -2137,6 +2164,11 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 				}
 			}
 		}
+		
+		double threshold = obscure_frac * avg[0] + (1.0 - obscure_frac) * avg[1];
+		double over_thresh = (avg[0] < avg[1]) ? (zone3_min_max[0] - threshold) : (threshold - zone3_min_max[1]);
+		
+		
 		if (masked_data != null) {
 			Arrays.fill(masked_data, Double.NaN);
 			for (int n = 0; n < lists.size(); n++) {
@@ -2175,14 +2207,15 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 		if (debug) {
 			System.out.println("getAbsoluteContrast() after outliers: avg[0] ="+avg[0]+", avg[1]="+avg[1]+", avg[0]-avg[1]="+(avg[0]-avg[1]));
 		}
-		return avg[0]-avg[1];
+		return new double [] {avg[0]-avg[1], over_thresh};
 	}
 	
 	/**
 	 * From existing pattern (only for simple dark main scene)
 	 * create two zones to calculate average (w/o outliers) inside
-	 * the pattern and around it. Mark inner with 1, outer - 2, keep
-	 * other 0. Then later find 2 averages (removing outliers) and their
+	 * the pattern and around it. Mark inner with 1, outer - 2,
+	 * 3 - potential obscurant for partial patterns
+	 * keep other 0. Then later find 2 averages (removing outliers) and their
 	 * difference - absolute contrast.
 	 * @param patterns set of square patterns, first [0] for full pattern,
 	 *                 others - for half-patterns cut in different directions. 
@@ -2287,6 +2320,8 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 								(  fys)*(  fxs)*npatterns[n][sindx+size+1]; 
 						if (sdn/sd0 > 0.5) {
 							ipatterns[n][indx] = ipatterns[0][indx]; // =2
+						} else {
+							ipatterns[n][indx] = 3; // =2
 						}
 					}
 				}
@@ -2303,8 +2338,9 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 			for (int n = 0; n < ipatterns.length; n++) {
 				for (int i= 0; i < ipatterns[n].length; i++) if (ipatterns[n][i] != 0){
 					switch (ipatterns[n][i]) {
-					case 1: dbg_img[n][i] = 1.0; break;
+					case 1: dbg_img[n][i] =  1.0; break;
 					case 2: dbg_img[n][i] = -1.0; break;
+					case 3: dbg_img[n][i] = -2.0; break;
 					}
 				}
 			}
@@ -4297,7 +4333,7 @@ public class OrthoMap implements Comparable <OrthoMap>, Serializable{
 		final int dbg_pix3 = 1439211; // 2827822; 
 		final int dbg_x = 1445;
 		final int dbg_y = 2338;
-		final int dbg_tolerance = 10;
+		final int dbg_tolerance = -10;
 		for (int ithread = 0; ithread < threads.length; ithread++) {
 			threads[ithread] = new Thread() {
 				public void run() {