package com.elphel.imagej.orthomosaic;

import java.awt.Point;
import java.awt.Rectangle;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

import com.elphel.imagej.calibration.CalibrationFileManagement;
import com.elphel.imagej.cameras.CLTParameters;
import com.elphel.imagej.common.DoubleGaussianBlur;
import com.elphel.imagej.common.GenericJTabbedDialog;
import com.elphel.imagej.common.PolynomialApproximation;
import com.elphel.imagej.common.ShowDoubleFloatArrays;
import com.elphel.imagej.gpu.GPUTileProcessor;
import com.elphel.imagej.gpu.TpTask;
import com.elphel.imagej.tileprocessor.ImageDtt;
import com.elphel.imagej.tileprocessor.IntersceneMatchParameters;
import com.elphel.imagej.tileprocessor.OpticalFlow;
import com.elphel.imagej.tileprocessor.TDCorrTile;
import com.elphel.imagej.tileprocessor.TileNeibs;

import ij.IJ;
import ij.ImagePlus;
import ij.ImageStack;
import ij.Prefs;
import ij.gui.PointRoi;
import ij.io.FileSaver;
import ij.process.FloatPolygon;
import ij.text.TextWindow;


public class OrthoMapsCollection  implements Serializable{
	private static final long serialVersionUID = 1L;
	public static final int MODE_IMAGE = 0;
	public static final int MODE_ALT =   1;
	public static final int MODE_MASK =  2;
	
	public static final int VERSION_PRE_ORIENT =  100;
	public static final int VERSION_POST_ORIENT = 101;
	public static final int VERSION_ORANGE =      102;
	
	public static int       LATEST_VERSION = VERSION_ORANGE; // 100; // use when read from .list
///	public transient int    current_version = LATEST_VERSION;
	public static int       CURRENT_VERSION = LATEST_VERSION;
	
	/*
	public static final int PAIR_NONE =      0;
	public static final int PAIR_DEFINED =   1;
	public static final int PAIR_UNDEFINED = 2;
	public static final int PAIR_FAILED =   -1;
	
	public static final int HEUR_LAST_SEQ =  1; // use last of connected following this  
	public static final int HEUR_DIV_LONG =  2; // divide long connected series  
	public static final int HEUR_MIN_DIA =   4; // minimal diameter increase (or no increase)  
	public static final int HEUR_SAME_DIA =  8; // minimal diameter increase (or no increase)
	*/  
	
	public static final String [] KEY_DIRS= {"rootDirectory", // from EyesisCorrectionParameters
			"sourceDirectory","linkedModels","linkedCenters","videoDirectory","x3dDirectory","resultsDirectory","scenesDirectory",
			"kernelsDirectory", "patternsDirectory","cuasSeed"};
	public static final String [] NAME_FH = {"full","half"};
	public static final String [] NAME_MO = {"main","other"};
	
	public            OrthoMap []                       ortho_maps;
	private           HashMap<String,ModelRegex>        model_regexes;
	private           String                            current_model_regex="";
	private           ArrayList<AltitudeMismatchKernel> kernels;
	private           ArrayList<GroundObjectPattern>    patterns;
	
	// real transient:
	public  transient long                              version = -1;
	private transient HashMap<Double,Integer>           map_index;
	private transient HashMap<String,Integer>           map_index_string;
	
	
	private void writeObject(ObjectOutputStream oos) throws IOException { // ?
		oos.defaultWriteObject();
		oos.writeObject(AltitudeMismatchKernel.getKernelsDirectory());
//		oos.writeObject(kernels);
		oos.writeObject(GroundObjectPattern.getPatternsDirectory());		
//		oos.writeObject(patterns);
//		oos.writeObject(path);
		// ortho_maps is not transient
	}
//	@SuppressWarnings("unchecked")
	private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
		ois.defaultReadObject();
		AltitudeMismatchKernel.setKernelsDirectory((String) ois.readObject());
//		kernels = (ArrayList<AltitudeMismatchKernel>) ois.readObject();
		GroundObjectPattern.setPatternsDirectory((String) ois.readObject());
//		patterns = (ArrayList<GroundObjectPattern>)   ois.readObject();
		
		reindex(); // will recreate map_index, map_index_string
		// lla is not transient
	}
	
	public OrthoMapsCollection(
			String path, // lit file
			OrthoMapsCollection orthoMapsCollection) { // if null will create new, if not null - will update other  
		if (path.endsWith(".list")) {
//			String[] scenes0 = new String[1];
			kernels = new ArrayList<AltitudeMismatchKernel>(); 
			patterns = new ArrayList<GroundObjectPattern>();
			model_regexes = new HashMap<String,ModelRegex>();
			String [] regex_use_p = new String[1];
			String[] paths = getPathsAndScenesFromSourceList(
					path,
					null, // scenes0,
					kernels,       // ArrayList<AltitudeMismatchKernel> kernels,
					patterns,      // ArrayList<GroundObjectPattern>    patterns);
					model_regexes, // ArrayList<ModelRegex>             model_regexes,
					regex_use_p,   // String []                         regex_use) {
					null,          // ArrayList<AffineImport>           affine_import,
					null);         // ArrayList<Affine2Import>          affine2_import) {

			current_model_regex = regex_use_p[0];
			paths = ModelRegex.removeDuplicatesSort(paths);        
			String [] orig_paths = paths.clone();
			boolean [] replaced = new boolean [paths.length];
			if (current_model_regex != null) {
				ModelRegex regex = model_regexes.get(current_model_regex);
				int num_replaced = 0;
				int num_changed = 0;
				if (regex != null) {
					for (int i = 0; i < paths.length;i++) {
						String replacement = regex.replaceByFilter(paths[i]);
						if (replacement != null) {
							paths[i] = replacement; 
							replaced[i] = true;
							num_replaced++;
							if (!replacement.equals(orig_paths[i])) {
								num_changed++;
							}
						}
					}
					System.out.println(String.format("Replacing with regex \"%s\" (%s)",
							regex.name, regex.regex));
					System.out.println(String.format("Replaced %d files (of %d), changed %d.", num_replaced, paths.length,num_changed));
				} else {
					System.out.println("Replacement regex \""+current_model_regex+"\" does not exist");
				}
			}
//			String scenes_path = scenes0[0]; // not used!
			ArrayList<String> new_paths = new ArrayList<String>();
			if (orthoMapsCollection != null) {
				 // 1. update existing maps
				for (int i = 0; i < paths.length; i++) {
					String name = OrthoMap.getNameFromPath(paths[i]);
					int indx = orthoMapsCollection.getIndex(name);
					if (indx >= 0) {
						OrthoMap omap = orthoMapsCollection.ortho_maps[indx];
						omap.orig_image = new FloatImageData(path); // always replace (nothing to preserve
///						omap.dt = omap.orig_image.getDT(); // just in case?
						// see if alt image is already initialized
						if (omap.alt_image != null) {
							FloatImageData alt_image = OrthoMap.getAlt(path);
							if (alt_image != null) {
								omap.alt_image = alt_image;
							} else {
								System.out.println("New altitude file does not exist, keeping old one: "+omap.alt_image.path);
							}
						}
					} else {
						new_paths.add(paths[i]);
					}
				}
			 // 2. add new maps (none will be removed)
				if (!new_paths.isEmpty()) {
					// need to create new maps, increase orthoMapsCollection.ortho_maps, reorder and reindex it
					int num_old_maps = orthoMapsCollection.ortho_maps.length;
					int num_new_maps = new_paths.size();
					ortho_maps = new OrthoMap[num_old_maps+num_new_maps];
					System.arraycopy(
							orthoMapsCollection.ortho_maps, 0,
							ortho_maps, 0,
							num_old_maps);
					int map_index = num_old_maps;
					for (String scene_path: new_paths) {
						ortho_maps[map_index] = new OrthoMap(scene_path); // , scene_path);
						ortho_maps[map_index++].setAffine();
					}
					Arrays.sort(ortho_maps); // mixed old+new, previous scene numbers will no longer be valui
					orthoMapsCollection.ortho_maps = ortho_maps; 
					orthoMapsCollection.reindex();
					
				} else {
					System.out.println("No new scenes added");
				}
				return; // Constructed this should not be used, only the old orthoMapsCollection
			}
			ortho_maps = new OrthoMap[paths.length];
			for (int n = 0; n < ortho_maps.length; n++) {
				ortho_maps[n] = new OrthoMap(paths[n]); // , scene_path);
				ortho_maps[n].setAffine();
			}
			Arrays.sort(ortho_maps);
			reindex();
		} else {
			System.out.println("OrthoMapsCollection(): path should end with \".list\"");
		}
	}
	
	public OrthoMap getMap(String name) {
		int indx = getIndex(name);
		if (indx < 0) return null;
		return ortho_maps[indx];
	}
	
	public static double [][] unityAffine() {
		return new double [][] {{1,0,0},{0,1,0}};
	}
	
	public void updateFiles (
			String path) {
		if (path.endsWith(".list")) {
			new OrthoMapsCollection(path, this); // will update this instead of creating a new instance
		} else {
			System.out.println("updateFiles(): path should end with \".list\"");
		}
	}
	
	// add update kernels, update patterns
	public void updateKernels (
			String path) {
		if (path.endsWith(".list")) {
			kernels = new ArrayList<AltitudeMismatchKernel>(); 
			getPathsAndScenesFromSourceList(
					path,
					null,
					kernels, // ArrayList<AltitudeMismatchKernel> kernels,
					null,    // ArrayList<GroundObjectPattern>    patterns);
					null,    // ArrayList<ModelRegex>             model_regexes,
					null,    // String []                         regex_use) {
					null,    // ArrayList<AffineImport>           affine_import,
					null);   // ArrayList<Affine2Import>          affine2_import) {
		} else {
			System.out.println("updateKernels(): path should end with \".list\"");
		}
	}
	
	public void updatePatterns (
			String path) {
		if (path.endsWith(".list")) {
			patterns = new ArrayList<GroundObjectPattern>();
			getPathsAndScenesFromSourceList(
					path,
					null,
					null,     // ArrayList<AltitudeMismatchKernel> kernels,
					patterns, // ArrayList<GroundObjectPattern>    patterns);
					null,     // ArrayList<ModelRegex>             model_regexes,
					null,     // String []                         regex_use) {
					null,     // ArrayList<AffineImport>           affine_import,
					null);    // ArrayList<Affine2Import>          affine2_import) {
					
		} else {
			System.out.println("updatePatterns(): path should end with \".list\"");
		}
	}
	
	
	static String getSceneDir(String scenes_path, String name) {
		File [] scene_dirs = (new File(scenes_path)).listFiles(); // may contain non-directories, will be filtered by filterScenes
		//scene_dirs[3].listFiles()
		Arrays.sort(scene_dirs);
		for (int i = scene_dirs.length-1; i>=0; i--) {
			if (scene_dirs[i].isDirectory()) {
				String dirname = scene_dirs[i].getName();
				if (name.compareTo(dirname) >= 0) {
					// verify it has needed scene
					File [] segment = scene_dirs[i].listFiles();
					for (int j = 0; j < segment.length; j++) {
						if (segment[j].getName().equals(name)) {
							return segment[j].toString(); 
						}
					}
				}
			}
		}
		return null;
	}
	
	
	
	public int reindex() {
		map_index = new HashMap<Double,Integer>();
		map_index_string = new HashMap<String,Integer>();
		for (int i = 0; i < ortho_maps.length; i++) {
			map_index.put(ortho_maps[i].getTimeStamp(), i);
			map_index_string.put(ortho_maps[i].name,i);
		}
//		updateNumberScenes();
		return ortho_maps.length;
	}
	
	OrthoMap [] getMaps() {
		return ortho_maps;
	}
	
	public String[] getNames() {
		String [] names = new String [ortho_maps.length];
		for (int n = 0; n < ortho_maps.length; n++) {
			names[n] = ortho_maps[n].getName();
		}
		return names;
	}

	public void getAllTemperatures() {
		for (int n = 0; n < ortho_maps.length; n++) {
			ortho_maps[n].getTemperature();
			ortho_maps[n].getTemperatureAndTelemetry();
		}
	}
	
	public void updateLLA() { // make automatic by saving/testing file modification stamp?
		for (int n = 0; n < ortho_maps.length; n++) {
			if (n == 530) {
				System.out.println("updateLLa(): n="+n);
			}
			ortho_maps[n].updateLLA();
			IJ.showStatus("Updating LLA "+n+" of "+ortho_maps.length);
			IJ.showProgress(1.0*n/ortho_maps.length);
		}
		updateAGL();
	}
	
	public void updateAGL() {
		for (int n = 0; n < ortho_maps.length; n++) {
			IJ.showStatus("Updating AGL "+n+" of "+ortho_maps.length);
			ortho_maps[n].agl = Double.NaN;
			ortho_maps[n].agl = ortho_maps[n].getAGL();
			IJ.showProgress(1.0*n/ortho_maps.length);
			
		}		
	}
	
	public void updateNumberScenes() {
		for (int n = 0; n < ortho_maps.length; n++) {
			ortho_maps[n].num_scenes = -1;
			ortho_maps[n].num_scenes = ortho_maps[n].getNumberScenes();
		}		
	}	
	
	public void updateSfmGain() {
		for (int n = 0; n < ortho_maps.length; n++) {
			ortho_maps[n].sfm_gain = Double.NaN;
			ortho_maps[n].sfm_gain = ortho_maps[n].getSfmGain();
		}		
	}	
	
	/*
	public static String[] getPathsFromSorceList(
			String files_list) {
		return getPathsAndScenesFromSourceList(files_list, null);
	}
    */
	public static String[] getPathsAndScenesFromSourceList(
			String files_list,
			String[] scenes0,
			ArrayList<AltitudeMismatchKernel> kernels,
			ArrayList<GroundObjectPattern>    patterns,
			HashMap<String,ModelRegex>        model_regexes,
			String []                         regex_use,
			ArrayList<AffineImport>           affine_import,
			ArrayList<Affine2Import>          affine2_import) {
		List<String> lines;
		List<String> rel_files = new ArrayList<String>(); 
		Path seq_path = Paths.get(files_list);
		try {
			lines = Files.readAllLines(seq_path, StandardCharsets.UTF_8);
			//                lines.stream().forEach(System.out::println);
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
		Path base_path = seq_path.getParent();
		HashMap<String,String> dir_map = new HashMap<String,String>();
		for (String line:lines){
			if (line.split("#").length > 0) {
				String[] tokens = line.split("#")[0].trim().split("[\\s,;=]+");
				if ((tokens.length > 2) && (tokens[0].toUpperCase().equals("SET"))) {
					parse_set:
					{
						for (String dir_name:KEY_DIRS) if (dir_name.equals(tokens[1])) {
							dir_map.put(dir_name,tokens[2]);
							System.out.println("Parsed SET: "+tokens[1]+" in line: "+line);
							break parse_set;
						}
						System.out.println("*********** Unknown SET: "+tokens[1]+" in line: "+line);
					}
				} else if ((tokens.length > 0) && (tokens[0].toUpperCase().equals("KERNEL"))) {
					if ((kernels != null) && (tokens.length > 4)) {
						kernels.add(new AltitudeMismatchKernel(
								tokens[1],
								Integer.parseInt(tokens[2]),
								Double.parseDouble(tokens[3]),
								Double.parseDouble(tokens[4])));
					}
				} else if ((tokens.length > 0) && (tokens[0].toUpperCase().equals("PATTERN"))) {
					if ((patterns != null) && (tokens.length > 4)) {
						patterns.add(new GroundObjectPattern(
								tokens[1],
								Integer.parseInt(tokens[2]),
								tokens[3],
								LocalDateTime.parse(tokens[4])));
					}
				} else if ((tokens.length > 0) && (tokens[0].toUpperCase().equals("REGEX"))) {
					if ((model_regexes != null) && (tokens.length > 4)) {
						model_regexes.put(tokens[1],new  ModelRegex(
								tokens[1],                        // String        name,
								tokens[2],                        //	String        regex,
								LocalDateTime.parse(tokens[3]),   // LocalDateTime start_date,
								LocalDateTime.parse(tokens[4]))); // 	LocalDateTime end_date);
					}
				} else if ((tokens.length > 0) && (tokens[0].toUpperCase().equals("REGEX_USE"))) {
					if ((regex_use != null) && (tokens.length > 1)) {
						regex_use[0] = tokens[1];
					}
				} else if ((tokens.length > 0) && AffineImport.matches(tokens)) {
					if (affine_import != null) {
						affine_import.add(new AffineImport(tokens));
					}
				} else if ((tokens.length > 0) && Affine2Import.matches(tokens)) {
					if (affine2_import != null) {
						affine2_import.add(new Affine2Import(tokens));
					}
					
				} else if ((tokens.length == 1) && (tokens[0].length() > 0)) {
					rel_files.add(tokens[0]);
				}
			}
		}
		if (dir_map.containsKey("rootDirectory")) {
			base_path=base_path.resolve(Paths.get(dir_map.get("rootDirectory")));
			File base_dir = new File(base_path.toString());
		}
		String sourceDirectory = base_path.toString();
		// set sourceDirectory: 
		if (dir_map.containsKey("sourceDirectory")) {
			sourceDirectory=(base_path.resolve(Paths.get(dir_map.get("sourceDirectory")))).toString();
		}
		Path source_path = Paths.get(sourceDirectory);
		//			File source_dir = new File(source_path.toString());
		String [] paths = new String[rel_files.size()];
		for (int i = 0; i < paths.length; i++) {
			paths[i] = (source_path.resolve(Paths.get(rel_files.get(i)))).toString();
		}
		if (dir_map.containsKey("scenesDirectory")) {
			if (scenes0 != null) {
				scenes0[0]=(base_path.resolve(Paths.get(dir_map.get("scenesDirectory")))).toString();
			}
		}
		
		String kernelsDirectory = base_path.toString();
		// set sourceDirectory: 
		if (dir_map.containsKey("kernelsDirectory")) {
			kernelsDirectory=(base_path.resolve(Paths.get(dir_map.get("kernelsDirectory")))).toString();
		}
		AltitudeMismatchKernel.setKernelsDirectory(kernelsDirectory);
		
		String patternsDirectory = base_path.toString();
		// set sourceDirectory: 
		if (dir_map.containsKey("patternsDirectory")) {
			patternsDirectory=(base_path.resolve(Paths.get(dir_map.get("patternsDirectory")))).toString();
		}
		GroundObjectPattern.setPatternsDirectory(patternsDirectory);
		
		return paths;
	}
	
	
	/**
	 * Get rectified bounds of all provided ortho images relative to the origin (vertical
	 * point) of the first one in pixels at the provided zoom level. Center of the first
	 * image correspond to the {0,0} point from which the bounds are counted
	 * @param zoom_level zoom level - 0 corresponds to 1pix=1cm scale, +1 - to 1pix = 0.5cm
	 * @return {{min_x,max_x},{min_y, max_y}} relative to the origin of the first image
	 */
	public int [][] getBoundsPixels(
			int zoom_level, // maps[0] as a reference
			int [] indices) {
		double [][] bounds_meters = getBoundsMeters(indices);
		double pix_size = OrthoMap.getPixelSizeMeters (zoom_level);
		int [][] bounds_pix = new int[2][2];
		for (int n = 0; n < bounds_pix.length; n++) {
			bounds_pix[n][0] = (int) Math.floor(bounds_meters[n][0]/pix_size);
			bounds_pix[n][1] = (int) Math.ceil (bounds_meters[n][1]/pix_size);
		}
		return bounds_pix;
	}
	public int [][] getBoundsPixels(
			int           zoom_level, // maps[0] as a reference
			int []        indices,
			double [][][] affines) {
		double [][] bounds_meters = (affines == null) ? getBoundsMeters(indices):getBoundsMeters(indices,affines);
		double pix_size = OrthoMap.getPixelSizeMeters (zoom_level);
		int [][] bounds_pix = new int[2][2];
		for (int n = 0; n < bounds_pix.length; n++) {
			bounds_pix[n][0] = (int) Math.floor(bounds_meters[n][0]/pix_size);
			bounds_pix[n][1] = (int) Math.ceil (bounds_meters[n][1]/pix_size);
		}
		return bounds_pix;
	}

	public int [][] getBoundsPixels(
			int zoom_level) { // maps[0] as a reference
		return getBoundsPixels(zoom_level, null);
	}
	//double [][][] affines
	/**
	 * Get rectified bounds of all provided ortho images relative to the origin (vertical
	 * point) of the first one in meters
	 * @return {{min_x,max_x},{min_y,max_y}} bounds that include all provided maps
	 *         relative to the origin (vertical point) of the first image
	 */
	/*
	public double [][] getBoundsMeters(){ // maps[0] as a reference
		double [][] bounds = ortho_maps[0].getBoundsMeters(true);
		for (int nmap = 1; nmap < ortho_maps.length; nmap++) {
			double [][] bounds_other = ortho_maps[nmap].getBoundsMeters(true);
			double [] enuOffset = ortho_maps[0].enuOffsetTo(ortho_maps[nmap]);
			double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
			for (int n = 0; n < bounds.length; n++) {
				bounds[n][0] = Math.min(bounds[n][0],bounds_other[n][0]+ rd[n]);
				bounds[n][1] = Math.max(bounds[n][1],bounds_other[n][1]+ rd[n]);
			}
		}
		return bounds;
	}
	*/
	public double [][] getBoundsMeters(){ // maps[0] as a reference
		return getBoundsMeters(null);
	}
	/**
	 * Get rectified bounds of all (if indices==null) or selected by indices[] 
	 * provided ortho images relative to the origin (vertical
	 * point) of the first one in meters
	 * @param indices - image indices to process or null to process all images
	 * @return {{min_x,max_x},{min_y,max_y}} bounds that include all provided maps
	 *         relative to the origin (vertical point) of the first image
	 */

	public double [][] getBoundsMeters(int [] indices){ // maps[0] as a reference
		if (indices == null) {
			indices = new int [ortho_maps.length];
			for (int i = 0; i < indices.length; i++) {
				indices[i] = i;
			}
		}
		double [][] bounds = ortho_maps[indices[0]].getBoundsMeters(true);
		for (int imap = 1; imap < indices.length; imap++) {
			int nmap = indices[imap];
			double [][] bounds_other = ortho_maps[nmap].getBoundsMeters(true);
			double [] enuOffset = ortho_maps[indices[0]].enuOffsetTo(ortho_maps[nmap]);
			double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
			for (int n = 0; n < bounds.length; n++) {
				bounds[n][0] = Math.min(bounds[n][0],bounds_other[n][0]+ rd[n]);
				bounds[n][1] = Math.max(bounds[n][1],bounds_other[n][1]+ rd[n]);
			}
		}
		return bounds;
	}

	public double [][] getBoundsMeters(
			int    [] indices,
			double [][][] affines){ // maps[0] as a reference
		if (indices == null) {
			indices = new int [ortho_maps.length];
			for (int i = 0; i < indices.length; i++) {
				indices[i] = i;
			}
		}
		if (affines == null) {
			affines = new double [ortho_maps.length][][];
			for (int i = 0; i < affines.length; i++) {
				affines[i] = ortho_maps[indices[i]].affine;
			}
		}
		double [][] bounds = ortho_maps[indices[0]].getBoundsMeters(true,affines[0]);
		for (int imap = 1; imap < indices.length; imap++) {
			int nmap = indices[imap];
			double [][] bounds_other = ortho_maps[nmap].getBoundsMeters(true,affines[imap]);
			double [] enuOffset = ortho_maps[indices[0]].enuOffsetTo(ortho_maps[nmap]);
			double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
			for (int n = 0; n < bounds.length; n++) {
				bounds[n][0] = Math.min(bounds[n][0],bounds_other[n][0]+ rd[n]);
				bounds[n][1] = Math.max(bounds[n][1],bounds_other[n][1]+ rd[n]);
			}
		}
		return bounds;
	}
	
	
	/**
	 * Get rectified overlap bounds of two provided ortho images relative to the origin (vertical
	 * point) of the first one in meters. Use specified affine transforms, not saved with the orto map
	 * @param ref_index - index of the first (reference) map
	 * @param other_index - index of the second (other) map
	 * @param ref_affine - specified affine transform of the reference image (referenced to its vertical_point)
	 * @param other_affine - specified affine transform of the other image (referenced to its vertical_point)
	 * @return {{min_x,max_x},{min_y,max_y}} bounds that include an overlap of the two provided maps
	 *         relative to the origin (vertical point) of the first image.
	 * Returns null if there is no overlap
	 */
	private double [][] getOverlapMeters(
			int ref_index,
			int other_index,
			double [][] ref_affine,
			double [][] other_affine){
		double [][] bounds = ortho_maps[ref_index].getBoundsMeters(true,ref_affine);
		double [][] bounds_other = ortho_maps[other_index].getBoundsMeters(true,other_affine);
		double [] enuOffset = ortho_maps[ref_index].enuOffsetTo(ortho_maps[other_index]);
		double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
		for (int n = 0; n < bounds.length; n++) {
			bounds[n][0] = Math.max(bounds[n][0],bounds_other[n][0]+ rd[n]);
			bounds[n][1] = Math.min(bounds[n][1],bounds_other[n][1]+ rd[n]);
			if (bounds[n][0] > bounds[n][1]) {
				return null;
			}
		}
		return bounds;
	}
	
	/**
	 * Use object coordinates (now metric) on the composite image to
	 * determine corresponding pixel coordinates of the source images
	 * @param objects ArrayList of objects with the scene name and xy coordinates
	 *                in the composite image. Will fill in pixel coordinates of the objects 
	 * @param zoom_level zoom level of the composite image
	 */
	public void reverseRender(
			ArrayList<ObjectLocation> objects,
			int         zoom_level,
			int []      indices){ // null or selected image indices
		int [][] bounds = getBoundsPixels( // should be for rectified, {-bounds[0][0], -bounds[0][1]} - exact center
				zoom_level,
				indices); 
		int width =  bounds[0][1] - bounds[0][0]; // bounds[x][0] - negative 
		int height = bounds[1][1] - bounds[1][0];
		/*
		int [] indices = new int [ortho_maps.length]; //maybe will get rid of
		for (int i = 0; i < indices.length; i++) {
			indices[i] = i;
		}
		*/
		final int reference_index = (indices == null)?0:indices[0]; 
		for (ObjectLocation ol: objects) {
			int nmap =getIndex(ol.getName());
			final double scale = 1.0/OrthoMap.getPixelSizeMeters(zoom_level);
			final double src_scale = 1.0/OrthoMap.getPixelSizeMeters(ortho_maps[nmap].getImage().getZoomLevel()); // pix per meter
			double [][] mbounds = ortho_maps[nmap].getBoundsMeters(true); // keep original bounds
			double [] enu_offset = ortho_maps[reference_index].enuOffsetTo(ortho_maps[nmap]);
			double [] scaled_out_center = { // xy center to apply affine to
					-bounds[0][0] + scale * enu_offset[0],
					-bounds[1][0] - scale * enu_offset[1]};
			double [] metric_center = { // back to meters to match objects
					scaled_out_center[0]/scale,
					scaled_out_center[1]/scale};
			double dX = ol.getMetric()[0]-metric_center[0]; // matching dX, dY in renderMulti()
			double dY = ol.getMetric()[1]-metric_center[1];
			
//			final int [][] obounds = new int [2][2]; // output (rectified, combined) image bounds, relative to thje top-left
//			for (int n = 0; n< 2; n++) {
//				obounds[n][0] = (int) Math.floor(scaled_out_center[n] + scale*mbounds[n][0]);
//				obounds[n][1] = (int) Math.ceil (scaled_out_center[n] + scale*mbounds[n][1]);
//			}
			// Output window size (keep original affine - OK if will not exactly fit)
//			final int ownd_width =  obounds[0][1] - obounds[0][0];
//			final int ownd_height = obounds[1][1] - obounds[1][0];
//			final int ownd_len = ownd_width * ownd_height;
			double [][] src_bounds=ortho_maps[nmap].getBoundsMeters (true); // using original affines
			final double [] src_center = {-src_bounds[0][0],-src_bounds[1][0]}; // x,y center offset in the source image
			final double [][] affine = ortho_maps[nmap].affine; // only here use provided
//			final int src_width =      ortho_maps[nmap].getImageData().width;
//			final int src_height =     ortho_maps[nmap].getImageData().height;
//			final float [] src_img =   ortho_maps[nmap].getImageData().data; // FIXME: will not use
			double [] xy_src = { // pixels of the source image
					src_scale * (affine[0][0]*dX + affine[0][1]*dY + affine[0][2] + src_center[0]),
					src_scale * (affine[1][0]*dX + affine[1][1]*dY + affine[1][2] + src_center[1])};
			ol.setPixels(xy_src);
		}
	}

	public ImagePlus renderMulti (
			String        title,
			int           eq_mode, // 0 - ignore equalization, 1 - use stored equalization, 2 - calculate equalization 
			int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
			boolean       bounds_to_indices,
			int           temp_mode, // 0 - do nothing, 1 - equalize average,2 - try to correct
			double [][][] affines, // null or [indices.length][2][3] 
			FineXYCorr    warp,    // use for a single pair only
			boolean       show_centers,
			int           zoom_level,
			int []        origin){
		boolean show_2d_histogram = true; // false;
		int num_images =  (indices != null)? indices.length : ortho_maps.length;
		int []     wh = new int[2];
		double [][] centers = new double [(indices !=null)? indices.length: ortho_maps.length][];
		double [][] dmulti = renderMultiDouble (
				null,              // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
				indices,           // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
				bounds_to_indices, // boolean       bounds_to_indices,
				affines,           // affines,    // double [][][] affines, // null or [indices.length][2][3]
				null,              // double [][]   equalize,
				(eq_mode != 1),    // boolean       ignore_equalize,
				null,              // warp,       // FineXYCorr    warp,,
				zoom_level,        // int         zoom_level,
				wh,                // int []      wh,
				origin,            // int []      origin){ // maps[0] as a reference
				centers);          // double [][] centers)
		
		if ((eq_mode == 2) && (num_images == 2)) {
			boolean [] mask = null;
			if (show_2d_histogram) {
				mask = new boolean [dmulti[0].length];
				//			int hist_min = -140,hist_max=135; // 700,200
				//			int hist_min = -100,hist_max=100; // 700,200
				int hist_min = -350, hist_max=350; // 700,200
				int hist_width= hist_max-hist_min;
				double [] hist = new double [hist_width*hist_width];
				for (int i = 0; i < dmulti[0].length; i++) if (!Double.isNaN(dmulti[0][i]) && !Double.isNaN(dmulti[1][i])){
					int x = (int) Math.round(dmulti[0][i]) - hist_min;
					int y = (int) Math.round(dmulti[1][i]) - hist_min;
					if ((x>=0) && (y>=0) && (x < hist_width)  && (y < hist_width)) {
						int indx = y*hist_width+x;
						hist[indx] += 1.0;
						mask[i] = true;
					}
				}
				ShowDoubleFloatArrays.showArrays(
						hist,
						hist_width,
						hist_width,
						title+"hist_"+hist_min+"_"+hist_max);
			}
			double [] regression = PolynomialApproximation.getOrthoRegression(
					dmulti[0], // final double []  data_x,
					dmulti[1], // final double []  data_y,
					mask);     // final boolean [] mask)
			double [] inv_regression = PolynomialApproximation.invertRegression(regression);
			double [] regression10 = PolynomialApproximation.getOrthoRegression(
					dmulti[1], // final double []  data_x,
					dmulti[0], // final double []  data_y,
					mask);     // final boolean [] mask)
			/*
			double [] dmulti1 = dmulti[1].clone();
			double [] regression00 = PolynomialApproximation.getOrthoRegression(
					dmulti[0], // final double []  data_x,
					dmulti[0], // final double []  data_y,
					mask);     // final boolean [] mask)
			double [] regression11 = PolynomialApproximation.getOrthoRegression(
					dmulti[1], // final double []  data_x,
					dmulti[1], // final double []  data_y,
					mask);     // final boolean [] mask)
			*/
			PolynomialApproximation.applyRegression(
					dmulti[1], // dmulti1,       // final double [] data, // clone by caller
					inv_regression); // final double [] regression) {
			/*
			double [] regression01 = PolynomialApproximation.getOrthoRegression(
					dmulti[0], // final double []  data_x,
					dmulti1, // final double []  data_y,
					mask);     // final boolean [] mask)
			double [] dmulti12 = dmulti[1].clone();
			for (int i = 0; i < dmulti12.length; i++) {
				dmulti12[i] = 2.0*dmulti12[i]+10; 
			}
			double [] regression012 = PolynomialApproximation.getOrthoRegression(
					dmulti[0], // final double []  data_x,
					dmulti12, // final double []  data_y,
					mask);     // final boolean [] mask)
			double [] dmulti13 = dmulti[1].clone();
			for (int i = 0; i < dmulti13.length; i++) {
				dmulti13[i] = dmulti13[i]+10; 
			}
			double [] regression013 = PolynomialApproximation.getOrthoRegression(
					dmulti[0], // final double []  data_x,
					dmulti13, // final double []  data_y,
					mask);     // final boolean [] mask)
			double [] dmulti14 = dmulti[1].clone();
			for (int i = 0; i < dmulti14.length; i++) {
				dmulti14[i] = 2*dmulti14[i]; 
			}
			double [] regression014 = PolynomialApproximation.getOrthoRegression(
					dmulti[0], // final double []  data_x,
					dmulti14, // final double []  data_y,
					mask);     // final boolean [] mask)
			double [] regression_single = getYXRegression(
					dmulti[0], // final double []  data_x,
					dmulti[1]); // final double []  data_y,
			*/
			System.out.println();
		}
		
		
		
		String [] map_names = new String[num_images + (((num_images==2))? 1 : 0)];
//		float [][] extra_multi = new float [map_names.length][];
		double [][] extra_multi = new double [map_names.length][];
		for (int n = 0; n <num_images; n++) {
			int mapn= (indices != null)? indices[n] : n;
			map_names[n] = ortho_maps[mapn].getName()+"_"+ortho_maps[mapn].getLocalDateTime().toString().replace("T","_")+"_UTC";
			map_names[n] += String.format(" raw=%7.1f", ortho_maps[mapn].getTemperature());
			extra_multi[n] = dmulti[n];
		}
		if (map_names.length > num_images) { // inefficient way, only for display
			// correct(offset) pixel values relative to multi[0]
			int map0= (indices != null)? indices[0] : 0;
			for (int n = 1; n < num_images; n++) {
				//temp_mode, // 0 - do nothing, 1 - equalize average,2 - try to correct
				int mapn= (indices != null)? indices[n] : n;
				double offs = 0;
				switch (temp_mode) {
				case 1:
					offs = ortho_maps[map0].getAveragePixel()-ortho_maps[mapn].getAveragePixel();
					break;
				case 2:
					offs = ortho_maps[mapn].getTemperature()-ortho_maps[mapn].getAveragePixel()
					-(ortho_maps[map0].getTemperature()-ortho_maps[map0].getAveragePixel());
					break;
				}
//				float foffs= (float) offs;
				for (int i = 0; i < extra_multi[n].length; i++) if (!Double.isNaN(extra_multi[n][i])) {
					extra_multi[n][i]+= offs;
				}
			}
			map_names[num_images] = "Diff 0-1";
			extra_multi[num_images] = new double[extra_multi[0].length];
			for (int i = 0; i < extra_multi[num_images].length; i++) {
				extra_multi[num_images][i] = extra_multi[1][i]-extra_multi[0][i];
			}
		}
		ImageStack stack;
			stack = ShowDoubleFloatArrays.makeStack( 
        		extra_multi,
        		wh[0],
        		wh[1],
        		map_names,
        		false);
        ImagePlus imp = new ImagePlus(title, stack);
        if (show_centers) {
        	PointRoi roi = new PointRoi();
        	for (int i = 0; i < centers.length; i++) {
        		roi.addPoint(centers[i][0],centers[i][1], i+1);
        	}
        	roi.setOptions("label");
        	imp.setRoi(roi);
        }
        imp.show(); // debugging
        return imp;
	}
	
	public static double [] getYXRegression(
			final double []  data_x,
			final double []  data_y) {
		double s0=0,sx=0,sx2=0,sy = 0, sxy=0;
		for (int i = 0; i < data_x.length; i++) {
			double x = data_x[i];
			double y = 2*data_x[i];
			if (!Double.isNaN(x) && !Double.isNaN(y)) {
				s0+= 1.0;
				sx+= x;
				sx2+=x*x;
				sy+= y;
				sxy += x*y;
			}
		}
		double d = (s0*sx2-sx*sx);
		double a = (sxy*s0-sy*sx)/d;
		double b = (sy*sx2-sx*sxy)/d;
		return new double [] {a,b};
	}
	
	/**
	 * Rectify and render multiple images (as slices) matching vert_meters to
	 * their (vert_meters points) provided IMS coordinates
	 * @param maps array of the ortho images 
	 * @param zoom_level zoom level (0 - 1pix=1cm, 1 - 1pix=0.5cm, -1 - 1pix=2cm
	 * @param wh null or int [2], will return {width, height}
	 * @param origin - null or double [2], will return {x0, y0} in pixels
	 * @param centers - null or double[maps.length][] - will return image centers coordinates
	 * @return
	 */
	
	public float [][] renderMulti (
			int mode,    // 0 - regular image, 1 - altitudes, 2 - black/white mask			
			int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
			boolean       bounds_to_indices,
			double [][][] affines, // null or [indices.length][2][3] 
			FineXYCorr    warp,
			int           zoom_level,
			int []        wh,
			int []        origin, // maps[0] as a reference
			double [][]   centers){
		final boolean use_alt = mode == MODE_ALT;
		final int dbg_x=2783, dbg_y=-5228;
		int [][] bounds;
		if (affines == null) {
			bounds = getBoundsPixels( // should be for rectified, {-bounds[0][0], -bounds[0][1]} - exact center
					zoom_level,
					bounds_to_indices? indices: null);
		} else {
			bounds = getBoundsPixels( // should be for rectified, {-bounds[0][0], -bounds[0][1]} - exact center
					zoom_level,
					bounds_to_indices? indices: null,
							affines);
		}
		int width =  bounds[0][1] - bounds[0][0]; // bounds[x][0] - negative 
		int height = bounds[1][1] - bounds[1][0];
		if (wh != null) {
			wh[0] = width;
			wh[1] = height;
		}
		if (origin != null) {
			origin[0] = -bounds[0][0];
			origin[1] = -bounds[1][0];
		}
		if (indices == null) {
			indices = new int [ortho_maps.length];
			for (int i = 0; i < indices.length; i++) {
				indices[i] = i;
			}
		}
		
		final float [][] fpixels = new float [indices.length][width * height];
		for (int indx = 0; indx < indices.length; indx++) { //:indices) { // = 0; nmap< ortho_maps.length; nmap++) {
			final int findx= indx;
			final int nmap = indices[indx]; // nmap;
			final double [][] affine = (affines !=null) ? affines[indx]: ortho_maps[nmap].affine; // only here use provided
			Arrays.fill(fpixels[findx], Float.NaN);
			final double scale = 1.0/OrthoMap.getPixelSizeMeters(zoom_level);
//			final int orig_zoom_level = getOriginalZoomLevel()
			final int orig_zoom_level = use_alt? ortho_maps[nmap].getAlt().getZoomLevel(): ortho_maps[nmap].getImage().getZoomLevel();
			final double src_scale = 1.0/OrthoMap.getPixelSizeMeters(orig_zoom_level); // pix per meter
//			double [][] mbounds = ortho_maps[nmap].getBoundsMeters(true); // keep original bounds
			double [][] mbounds = ortho_maps[nmap].getBoundsMeters(true,affine); // keep original bounds
			double [] enu_offset = ortho_maps[indices[0]].enuOffsetTo(ortho_maps[nmap]);
			final double [] scaled_out_center = { // xy center to apply affine to in output pixels
					-bounds[0][0] + scale * enu_offset[0],
					-bounds[1][0] - scale * enu_offset[1]};
			if (centers != null) {
				centers[findx] = scaled_out_center;
			}
			final int [][] obounds = new int [2][2]; // output (rectified, combined) image bounds, relative to the top-left
			for (int n = 0; n< 2; n++) { // output pixels
				obounds[n][0] = (int) Math.floor(scaled_out_center[n] + scale*mbounds[n][0]);
				obounds[n][1] = (int) Math.ceil (scaled_out_center[n] + scale*mbounds[n][1]);
			}
			// Output window size (keep original affine - OK if will not exactly fit)
			final int ownd_width =  obounds[0][1] - obounds[0][0];
			final int ownd_height = obounds[1][1] - obounds[1][0];
			final int ownd_len = ownd_width * ownd_height;
//			double [][] src_bounds=ortho_maps[nmap].getBoundsMeters (true); // using original affines
			double [][] src_bounds=ortho_maps[nmap].getBoundsMeters (false,affine); // using provided affines
			final double [] src_center = {-src_bounds[0][0],-src_bounds[1][0]}; // x,y center offset in the source image
			final int src_width = use_alt? ortho_maps[nmap].getAltData().width: ortho_maps[nmap].getImageData().width;
			final int src_height = use_alt? ortho_maps[nmap].getAltData().height : ortho_maps[nmap].getImageData().height;
			if ((indx==0) && (warp != null)) { // set center from the first image
				warp.setRender(
						zoom_level, // int zoom_lev,
						scaled_out_center[0], // double px0, // in render pixels
						scaled_out_center[1]); // // double py0);
			}
			final float [] src_img = use_alt? ortho_maps[nmap].getAltData().readFData() : ortho_maps[nmap].getImageData().readFData();
			final Rectangle warp_woi =((indx==1) && (warp != null))? warp.getRenderWOI():null; 
			final Thread[] threads = ImageDtt.newThreadArray();
			final AtomicInteger ai = new AtomicInteger(0);
			/*
			boolean tilt_alt = (ground_planes != null) && (ground_planes[indx] != null);
			final float [] src_img = use_alt?
					(tilt_alt? ortho_maps[nmap].getAltData().data.clone(): ortho_maps[nmap].getAltData().data) :
						ortho_maps[nmap].getImageData().data;
			if (tilt_alt) {
				// apply tilt to the source altitudes								
				double [] vert_meters = ortho_maps[nmap].getVertMeters();
				// altitude at top-left pixel;
				final double top_left_alt = 
						ground_planes[indx][2] - vert_meters[0]*ground_planes[indx][0] - vert_meters[1]*ground_planes[indx][1];
				final double [] tilt_XY = {ground_planes[indx][0]/src_scale, ground_planes[indx][1]/src_scale};
				for (int ithread = 0; ithread < threads.length; ithread++) {
					threads[ithread] = new Thread() {
						public void run() {
							for (int nPix = ai.getAndIncrement(); nPix < src_img.length; nPix = ai.getAndIncrement()) {
								int py = nPix / src_width;
								int px = nPix % src_width;
								src_img[nPix] -= (top_left_alt + px * tilt_XY[0] + py * tilt_XY[1]);
							}
						}
					};
				}		      
				ImageDtt.startAndJoin(threads);
				ai.set(0);
			}
			 */
			for (int ithread = 0; ithread < threads.length; ithread++) {
				threads[ithread] = new Thread() {
					public void run() {
						for (int nPix = ai.getAndIncrement(); nPix < ownd_len; nPix = ai.getAndIncrement()) {
							int opX = nPix % ownd_width + obounds[0][0]; // absolute output pX, pY
							int opY = nPix / ownd_width + obounds[1][0];
							double dX = (opX - scaled_out_center[0]) /scale; // in meters
							double dY = (opY - scaled_out_center[1]) /scale;
							double [] xy_src = { // pixels of the source image
									src_scale * (affine[0][0]*dX + affine[0][1]*dY + affine[0][2] + src_center[0]),
									src_scale * (affine[1][0]*dX + affine[1][1]*dY + affine[1][2] + src_center[1])};
							// limit to the source image
							if ((((int) opX)==dbg_x) && (((int) opY)==dbg_y)) {
								System.out.println("opX="+opX+", opy="+opY);
							}
							if ((warp_woi != null) && (warp_woi.contains(opX,opY))) {
								double [] dxy = warp.getWarp(opX,opY);
								xy_src[0] += dxy[0];
								xy_src[1] += dxy[1];
							}
							
							if  ((xy_src[0] >= 0) && (xy_src[0] < (src_width-1)) &&
									(xy_src[1] >= 0) && (xy_src[1] < (src_height-1))) { 
								int [] ixy_src = {(int) Math.floor(xy_src[0]), (int)Math.floor(xy_src[1]) };
								double [] kxy = {xy_src[0]-ixy_src[0], xy_src[1]-ixy_src[1]}; 
								int indx00 = ixy_src[0] + ixy_src[1] * src_width; 
								double d00 = src_img[indx00];
								if (!Double.isNaN(d00)) {
									double d01 = src_img[indx00 + 1];
									double d10 = src_img[indx00 + src_width];
									double d11 = src_img[indx00 + src_width + 1];
									double d = d00*(1.0 - kxy[0])*(1.0 - kxy[1])+
											d01*       kxy[0] *(1.0 - kxy[1])+
											d10*(1.0 - kxy[0])*       kxy[1]+
											d11*       kxy[0] *       kxy[1];
									fpixels[findx][opX + opY*width] = (float) d;
								}
							}
						}
					}
				};
			}		      
			ImageDtt.startAndJoin(threads);
		}
		return fpixels;
	}
	
	
	public double [][] renderMultiDouble ( // should work with just a single image (indice.length ==1)?
			double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][] for old way alt
			int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
			boolean       bounds_to_indices,
			double [][][] affines, // null or [indices.length][2][3]
			double [][]   equalize_in,
			boolean       ignore_equalize,
			FineXYCorr    warp,
			int           zoom_level,
			int []        wh,
			int []        origin, // maps[0] as a reference
			double [][]   centers){
		boolean updateStatus = true;
		boolean use_alt = ground_planes != null;
		final int dbg_x=707, dbg_y=-615;
		int [][] bounds;
		if (affines == null) {
			bounds = getBoundsPixels( // should be for rectified, {-bounds[0][0], -bounds[0][1]} - exact center
					zoom_level,
					bounds_to_indices? indices: null);
		} else {
			bounds = getBoundsPixels( // should be for rectified, {-bounds[0][0], -bounds[0][1]} - exact center
					zoom_level,
					bounds_to_indices? indices: null,
							affines);
		}
		int width =  bounds[0][1] - bounds[0][0]; // bounds[x][0] - negative 
		int height = bounds[1][1] - bounds[1][0];
		if (wh != null) {
			wh[0] = width;
			wh[1] = height;
		}
		if (origin != null) {
			origin[0] = -bounds[0][0];
			origin[1] = -bounds[1][0];
		}
		if (indices == null) {
			indices = new int [ortho_maps.length];
			for (int i = 0; i < indices.length; i++) {
				indices[i] = i;
			}
		}
		
		final double [][] dpixels = new double [indices.length][width * height];
		for (int indx = 0; indx < indices.length; indx++) { //:indices) { // = 0; nmap< ortho_maps.length; nmap++) {
			if (updateStatus) IJ.showStatus("Preparing slice "+indx+" of "+indices.length);
			final int findx= indx;
			final int nmap = indices[indx]; // nmap;
			final double [][] affine = (affines !=null) ? affines[indx]: ortho_maps[nmap].affine; // only here use provided
			final double [] equalize = ignore_equalize ? null:((equalize_in != null) ? equalize_in[indx] : ortho_maps[nmap].equalize);
			Arrays.fill(dpixels[findx], Float.NaN);
			final double scale = 1.0/OrthoMap.getPixelSizeMeters(zoom_level);
			final int orig_zoom_level = use_alt? ortho_maps[nmap].getAlt().getZoomLevel(): ortho_maps[nmap].getImage().getZoomLevel();
			final double src_scale = 1.0/OrthoMap.getPixelSizeMeters(orig_zoom_level); // pix per meter
//			final double src_scale = 1.0/OrthoMap.getPixelSizeMeters(ortho_maps[nmap].orig_zoom_level); // pix per meter
		// metric bounds of the rectified image relative to its origin
///			double [][] mbounds = ortho_maps[nmap].getBoundsMeters(true); // keep original bounds
			double [][] mbounds = ortho_maps[nmap].getBoundsMeters(true,affine); // keep original bounds
			double [] enu_offset = ortho_maps[indices[0]].enuOffsetTo(ortho_maps[nmap]);
			final double [] scaled_out_center = { // xy center to apply affine to in output pixels
					-bounds[0][0] + scale * enu_offset[0],
					-bounds[1][0] - scale * enu_offset[1]};
			if (centers != null) {
				centers[findx] = scaled_out_center;
			}
			final int [][] obounds = new int [2][2]; // output (rectified, combined) image bounds, relative to the top-left
			for (int n = 0; n< 2; n++) { // output pixels
				obounds[n][0] = (int) Math.floor(scaled_out_center[n] + scale*mbounds[n][0]);
				obounds[n][1] = (int) Math.ceil (scaled_out_center[n] + scale*mbounds[n][1]);
			}
			// Output window size (keep original affine - OK if will not exactly fit)
			final int ownd_width =  obounds[0][1] - obounds[0][0];
			final int ownd_height = obounds[1][1] - obounds[1][0];
			final int ownd_len = ownd_width * ownd_height;
///			final double [][] affine = (affines !=null) ? affines[indx]: ortho_maps[nmap].affine; // only here use provided
///			double [][] src_bounds=ortho_maps[nmap].getBoundsMeters (true); // using original affines
			double [][] src_bounds=ortho_maps[nmap].getBoundsMeters (false,affine); // using provided affines
			final double [] src_center = {-src_bounds[0][0],-src_bounds[1][0]}; // x,y center offset in the source image
			final int src_width = use_alt? ortho_maps[nmap].getAltData().width: ortho_maps[nmap].getImageData().width;
			final int src_height = use_alt? ortho_maps[nmap].getAltData().height : ortho_maps[nmap].getImageData().height;
//			final float [] src_img = use_alt? ortho_maps[nmap].getAltData().data : ortho_maps[nmap].getImageData().data;
			if ((indx==0) && (warp != null)) { // set center from the first image
				warp.setRender(
						zoom_level, // int zoom_lev,
						scaled_out_center[0], // double px0, // in render pixels
						scaled_out_center[1]); // // double py0);
			}
			boolean tilt_alt = (ground_planes != null) && (ground_planes[indx] != null);
			final float [] src_img = use_alt?
					(tilt_alt? ortho_maps[nmap].getAltData().readFData().clone(): ortho_maps[nmap].getAltData().readFData()) :
						ortho_maps[nmap].getImageData().readFData();
			
			final Rectangle warp_woi =((indx==1) && (warp != null))? warp.getRenderWOI():null; 
			final Thread[] threads = ImageDtt.newThreadArray();
			final AtomicInteger ai = new AtomicInteger(0);
			if (tilt_alt) {
				// apply tilt to the source altitudes								
				double [] vert_meters = ortho_maps[nmap].getVertMeters();
				// altitude at top-left pixel;
				final double top_left_alt = 
						ground_planes[indx][2] - vert_meters[0]*ground_planes[indx][0] - vert_meters[1]*ground_planes[indx][1];
				final double [] tilt_XY = {ground_planes[indx][0]/src_scale, ground_planes[indx][1]/src_scale};
				for (int ithread = 0; ithread < threads.length; ithread++) {
					threads[ithread] = new Thread() {
						public void run() {
							for (int nPix = ai.getAndIncrement(); nPix < src_img.length; nPix = ai.getAndIncrement()) {
								int py = nPix / src_width;
								int px = nPix % src_width;
								src_img[nPix] -= (top_left_alt + px * tilt_XY[0] + py * tilt_XY[1]);
							}
						}
					};
				}		      
				ImageDtt.startAndJoin(threads);
				ai.set(0);
			}
			for (int ithread = 0; ithread < threads.length; ithread++) {
				threads[ithread] = new Thread() {
					public void run() {
						for (int nPix = ai.getAndIncrement(); nPix < ownd_len; nPix = ai.getAndIncrement()) {
							int opX = nPix % ownd_width + obounds[0][0]; // absolute output pX, pY
							int opY = nPix / ownd_width + obounds[1][0];
							double dX = (opX - scaled_out_center[0]) /scale; // in meters
							double dY = (opY - scaled_out_center[1]) /scale; // in meters, Y-down
							double [] xy_src = { // pixels of the source image
									src_scale * (affine[0][0]*dX + affine[0][1]*dY + affine[0][2] + src_center[0]),
									src_scale * (affine[1][0]*dX + affine[1][1]*dY + affine[1][2] + src_center[1])};
							// limit to the source image
							if ((((int) opX)==dbg_x) && (((int) opY)==dbg_y)) {
								System.out.println("opX="+opX+", opy="+opY);
							}
							if ((warp_woi != null) && (warp_woi.contains(opX,opY))) {
								double [] dxy = warp.getWarp(opX,opY);
								xy_src[0] += dxy[0];
								xy_src[1] += dxy[1];
							}
							if  ((xy_src[0] >= 0) && (xy_src[0] < (src_width-1)) &&
									(xy_src[1] >= 0) && (xy_src[1] < (src_height-1))) { 
								int [] ixy_src = {(int) Math.floor(xy_src[0]), (int)Math.floor(xy_src[1]) };
								double [] kxy = {xy_src[0]-ixy_src[0], xy_src[1]-ixy_src[1]}; 
								int indx00 = ixy_src[0] + ixy_src[1] * src_width; 
								double d00 = src_img[indx00];
								if (!Double.isNaN(d00)) {
									double d01 = src_img[indx00 + 1];
									double d10 = src_img[indx00 + src_width];
									double d11 = src_img[indx00 + src_width + 1];
									double d = d00*(1.0 - kxy[0])*(1.0 - kxy[1])+
											d01*       kxy[0] *(1.0 - kxy[1])+
											d10*(1.0 - kxy[0])*       kxy[1]+
											d11*       kxy[0] *       kxy[1];
									if (equalize != null) {
										d = equalize[0] * d + equalize[1];
									}
									dpixels[findx][opX + opY*width] = d;
								}
							}
						}
					}
				};
			}		      
			ImageDtt.startAndJoin(threads);
		}
		return dpixels;
	}

	
	public int getIndex(String sindx) {
		Integer indx = map_index_string.get(sindx);
		if (indx == null) {
			return -1;
		}
		return indx;
	}
	
	/*
	public float [][] getPaddedPairGPU(
			String [] spair,
			int       zoom_lev){
		int [] pair = new int [spair.length];
		for (int i = 0; i < pair.length; i++) {
			pair[i] = getIndex(spair[i]);
		}
		return getPaddedPairGPU(
				pair, // int [] pair,
				zoom_lev); // int    zoom_lev,
	}

	private float [][] getPaddedPairGPU(
			int [] pair,
			int    zoom_lev){
		float [][] gpu_pair_img = new  float [2][];
		for (int n = 0; n < pair.length; n++) {
			gpu_pair_img[n] = ortho_maps[pair[n]].getPaddedGPU (
							zoom_lev); // int zoom_level,
		}
		return gpu_pair_img;
	}
	*/
	
    
	public PairwiseOrthoMatch SpiralMatch (
			CLTParameters    clt_parameters,
			double           frac_remove, //  =        0.25
			double           metric_error,
			boolean          pmtch_use_affine,
			double           max_std,     // maximal standard deviation to limit center area  
			double           min_std_rad, // minimal radius of the central area (if less - fail)
			double           rad_fraction,
			double           max_tile_rad, //  = 30;			
			double           fill_fraction,
			double           fill_fraction_final,
			double           ease_nosfm,
			int []           gpu_pair,
			double [][][]    affines_init,  // here in meters, relative to vertical points
			int              zoom_lev,
			double           pix_step,
			double           pix_range,
			double           good_rms,
			double           max_rms,
			int              num_tries, //  = 5
			int              min_overlap, //  = 5
			boolean          ignore_rms,
			double []        max_rms_iter, //  = {1.0, 0.6};//
			double           overlap,
			double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
			double           pull_tilt,        // > 0
			double           pull_scale,       // = 0
			int              debugLevel){
		double [][] affine1 = new double [][] {affines_init[1][0].clone(),affines_init[1][1].clone()};
		double [][][] affines = new double [][][] {affines_init[0],affine1};
		boolean  show_vf = false;
		boolean  batch_mode = true;
		double [][] ground_planes = null; // null or double[2] - will return ground planes:
		double pix_size = OrthoMap.getPixelSizeMeters (zoom_lev);
		int nx = 0, ny=0; // number of steps (pix_step size) in hor and vert directions (both pos and neg)
		int nabs = (int) Math.ceil(pix_range/pix_step);
		PairwiseOrthoMatch 	pairwiseOrthoMatch = new PairwiseOrthoMatch(
				affines[1], //  double [][] affine,
				null, // double [][] jtj,
				Double.NaN, // double rms,
				zoom_lev, // int zoom_lev);
				overlap); // double overlap);
//		double           max_std =     0.5;      // maximal standard deviation to limit center area  
//		double           min_std_rad = 2.0;  // minimal radius of the central area (if less - fail)
		int best_nx = -1, best_ny = -1;
		PairwiseOrthoMatch best_pom = null;
		while ((Math.abs(nx) <= nabs) && (Math.abs(ny) <= nabs)) {
			for (int i = 0; i < affines_init.length; i++) {
				System.arraycopy(affines_init[1][i], 0, affine1[i], 0, affine1[i].length);
			}
			affine1[0][2] += pix_step * pix_size * nx;
			affine1[1][2] += pix_step * pix_size * ny;
			pairwiseOrthoMatch.rms = Double.NaN;
			
			correlateOrthoPair(
					clt_parameters,  // CLTParameters    clt_parameters,
					pairwiseOrthoMatch, //PairwiseOrthoMatch pairwiseOrthoMatch, // will return statistics
					min_overlap,     // 			int              min_overlap,
					max_std,         // double           max_std,      // maximal standard deviation to limit center area  
					min_std_rad,     // double           min_std_rad,  // minimal radius of the central area (if less - fail)
					frac_remove,     // double           frac_remove, //  =        0.25
					metric_error,    // 			double           metric_error,
					ignore_rms,      // boolean ignore_prev_rms,
					num_tries,       //  = 5int              num_tries, //  = 5
					false,           // boolean          calc_warp, (will return null if false)
					batch_mode,      // boolean          batch_mode,
					gpu_pair,        // String []        gpu_spair,
					affines,         // double [][][]    affines, // on top of GPS offsets
					null,            // woi,             // Rectangle        woi,
					zoom_lev,        // int              zoom_lev,
					show_vf,         // boolean show_vf,
					ground_planes,   // double [][]      ground_planes, // null or double[2] - will return ground planes
					rad_fraction,    // double           rad_fraction,
					max_tile_rad,    // double           max_tile_rad, //  = 30;
					fill_fraction,   // double           fill_fraction,
					fill_fraction_final, // double           fill_fraction_final,
					ease_nosfm,      // double           ease_nosfm,
					max_rms_iter, // double []        max_rms_iter, //  = {1.0, 0.6};//
					pull_skew,        // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
					pull_tilt,        // double           pull_tilt,        // > 0
					pull_scale,       // double           pull_scale,       // = 0
					debugLevel-4);     // final int        debugLevel)
			pairwiseOrthoMatch.setAffine(affines[1]); // modified by correlateOrthoPair
			if (debugLevel > -4) {
				System.out.println(String.format("SpiralMatch(): %3d-%3d nx = %3d, ny=%3d, RMSE=%8.6f",
						gpu_pair[0], gpu_pair[1], nx,ny,pairwiseOrthoMatch.rms)); // if NaN - provide reason
			}
			if (!Double.isNaN(pairwiseOrthoMatch.rms) && ((best_pom == null) || !(best_pom.rms <= pairwiseOrthoMatch.rms))) {
				pairwiseOrthoMatch.nxy = new int [] {nx,ny};
				best_pom = pairwiseOrthoMatch.clone();
				best_nx = nx;
				best_ny = ny;
//				System.out.println("best_pom.rms = "+best_pom.rms);
			}
			if (pairwiseOrthoMatch.rms < good_rms) {
				break;
			}
			// update nx, ny
			if ((nx >   ny) && (nx > -ny)){
				ny++;
			} else if ((nx <=  ny) && (nx > -ny)){
				nx--;
			} else if ((ny <= -nx) && (ny >  nx)){
				ny--;
			} else {
				nx++;
			}
		}
		
		if (pairwiseOrthoMatch.rms < good_rms) { // immediately OK
			best_pom.ok = true;
			if (debugLevel > -4) {
				System.out.println("SpiralMatch(): best RMSE="+best_pom.rms+" < "+good_rms+
						" for nx = "+best_nx+", ny="+best_ny+", using it.");
			}
			return best_pom; // pairwiseOrthoMatch; // pairwiseOrthoMatch.affine will have adjusted affine[1]
		}
		if ((best_pom != null) && (best_pom.rms <= max_rms)) {
			if (debugLevel > -4) {
				System.out.println("SpiralMatch(): best RMSE="+best_pom.rms+" < "+max_rms+
						" for nx = "+best_nx+", ny="+best_ny+", using it.");
			}
			best_pom.ok = true;
			return best_pom;
		}
		// delegating too large rms to the caller (it will have best_pom.ok==false
		if ((debugLevel > -4) && ((best_pom == null) || Double.isNaN(best_pom.rms))){
			System.out.println("SpiralMatch(): Failed to find a good match candidate. Best RMSE="+
			((best_pom != null)? best_pom.rms:"N/A")+", max_rms= "+max_rms+"");
		}
		return best_pom; // null; // pairwiseOrthoMatch.affine will have adjusted affine[1]
	}
	
	
	public FineXYCorr correlateOrthoPair(
			CLTParameters    clt_parameters,
			PairwiseOrthoMatch pairwiseOrthoMatch, // will return statistics, may be null if not needed
			int              min_overlap,
			double           max_std,      // maximal standard deviation to limit center area  
			double           min_std_rad,  // minimal radius of the central area (if less - fail)
			double           frac_remove, //  =        0.25
			double           metric_error,
			boolean          ignore_prev_rms,
			int              num_tries, //  = 5
			boolean          calc_warp,
			boolean          batch_mode,
			int []           gpu_pair,
			double [][][]    affines,  // here in meters, relative to vertical points
			Rectangle        woi,
			int              zoom_lev,
			boolean          show_vf,
			double [][]      ground_planes, // null or double[2] - will return ground planes:
			double           rad_fraction,
			double           max_tile_rad, //  = 30;
			double           fill_fraction,
			double           fill_fraction_final,
			double           ease_nosfm,
			double []        max_rms_iter, //  = {1.0, 0.6};//
			double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
			double           pull_tilt,        // > 0
			double           pull_scale,       // = 0
			int              debugLevel){
		double vf_drop_big = 0.9; // 0.5? If vector_field threshold drops more, allow RMS to increase
//		double rad_fraction =        0.5; // center circle radius fraction of 0.5* min(width, height) in tiles
//		double fill_fraction =       0.25; // should be populated not less than this
//		double fill_fraction_final = 0.4; // should be populated not less than this
//		double ease_nosfm =          2.0; // ease metric_error when no SfM gain == 0;
//		double max_tile_rad = 30;
		double center_radius_change = 1.5; // if increases by more than this, disregard RMSE worsening
		boolean show_lma_dbg = !batch_mode && (debugLevel > 1); 
		if (woi == null) {
			woi = new Rectangle();
		}
		int min_tiles_overlap = min_overlap/GPUTileProcessor.DTT_SIZE/GPUTileProcessor.DTT_SIZE;
	 	if (pairwiseOrthoMatch != null) {
	 		pairwiseOrthoMatch.rms = Double.NaN; // mark as failed
	 	}
		boolean show_gpu_img = true; // (debugLevel > 1);
		boolean show_tile_centers = false; // true; // (debugLevel > 1);
		if (!batch_mode) {
			debugLevel = 0;
		} else {
			show_gpu_img =      false; // (debugLevel > 1);
			show_tile_centers = false; // true; // (debugLevel > 1);
		}
    	boolean show_vector_field = show_vf || (!batch_mode && (debugLevel>-1)); // true;
		double [][] bounds_overlap_meters = getOverlapMeters(
				gpu_pair[0],  // int ref_index,
				gpu_pair[1],  // int other_index)
				affines[0],   // double [][] ref_affine,
				affines[1]);  // double [][] other_affine
				
		if ((bounds_overlap_meters == null) || (bounds_overlap_meters[0] == null) || (bounds_overlap_meters[1] == null)) {
			if (debugLevel > -4) {
				System.out.println("correlateOrthoPair(): no overlap");
			}
			return null;
		}
		double pix_size = OrthoMap.getPixelSizeMeters (zoom_lev);
	    int [] overlap_wh_pixel = new int [2];
	    for (int i = 0; i < 2; i++) {
	    	overlap_wh_pixel[i] = (
	    			(int) Math.ceil(bounds_overlap_meters[i][1]/pix_size))
	    			- ((int) Math.floor(bounds_overlap_meters[i][0]/pix_size));
	    }
		// convert to pixels,shift top-left to [0,0] (remember offsets, limit w,h,
		// change to pixels last, remember TL in meters?
		// keep center where it was
		// {bounds_overlap_meters[0][0],bounds_overlap_meters[1][0],
		double [] enuOffset = ortho_maps[gpu_pair[0]].enuOffsetTo(ortho_maps[gpu_pair[1]]);
		double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
		double [][] tlo_rect_metric = new double [2][2]; // top-left of overlap referenced to it's own vertical point (subtract!)
		tlo_rect_metric[0][0] = bounds_overlap_meters[0][0]; // relative to ref vert_meters
		tlo_rect_metric[0][1] = bounds_overlap_meters[1][0]; // vert_meters
		tlo_rect_metric[1][0] = bounds_overlap_meters[0][0] - rd[0];  // relative to other vert_meters
		tlo_rect_metric[1][1] = bounds_overlap_meters[1][0] - rd[1];

		double [][] tlo_src_metric = new double[tlo_rect_metric.length][2]; // relative to it's own vert_meters
		for (int n=0; n <tlo_src_metric.length; n++) {
			for (int i = 0; i < 2; i++) { // subtracting tl_rect_metric[n] (-1)
				tlo_src_metric[n][i] =
						tlo_rect_metric[n][0] * affines[n][i][0] +
						tlo_rect_metric[n][1] * affines[n][i][1] + affines[n][i][2];
			}
		}
		/// referenced to top-left pixel of the gpu image
		double [][] tlo_source_pixel = new double[tlo_src_metric.length][2];
		for (int n=0; n <tlo_source_pixel.length; n++) {
			for (int i = 0; i < 2; i++) {
				tlo_source_pixel[n][i] = (tlo_src_metric[n][i] + ortho_maps[gpu_pair[n]].getVertMeters()[i])/pix_size;
			}
		}
		
		double [][][] affines_gpu = new double [affines.length][2][3]; // relative to top left corners, in pixels
		float [][] gpu_pair_img = new  float [2][];
		for (int n = 0; n < gpu_pair.length; n++) {
			for (int i = 0; i < 2; i++) {
				for (int j = 0; j < 2; j++) {
					affines_gpu[n][i][j] = affines[n][i][j]; 
				}
				affines_gpu[n][i][2] = tlo_source_pixel[n][i];
			}
			gpu_pair_img[n] = ortho_maps[gpu_pair[n]].getPaddedGPU (zoom_lev); // int zoom_level,
		}
		boolean invert_second = (debugLevel > 1000);
		if (debugLevel > 10) {
			return null;
		}
		if (invert_second) {
			for (int i = 0; i < gpu_pair_img[1].length; i++) {
				gpu_pair_img[1][i]= -gpu_pair_img[1][i];
			}
		}
		if (show_gpu_img) {
			String [] dbg_titles = {ortho_maps[gpu_pair[0]].getName(),ortho_maps[gpu_pair[1]].getName()};
    		ShowDoubleFloatArrays.showArrays(
    				gpu_pair_img,
    				OrthoMap.gpu_width,
    				OrthoMap.gpu_height,
    				true,
    				"gpu_img",
    				dbg_titles);

		}
		woi.width =  overlap_wh_pixel[0];
		woi.height = overlap_wh_pixel[1]; // = new Rectangle(0, 0, overlap_wh_pixel[0], overlap_wh_pixel[1]);
		if (woi.width * woi.height < min_overlap) {
		 	if (debugLevel > -4) {
		 		System.out.println("correlateOrthoPair(): too small overlap: "+
		 				woi.width+" * "+ woi.height+" = "+(woi.width * woi.height)+" < "+min_overlap+"");
		 	}
		 	return null;
		}
		if (woi.width > OrthoMap.gpu_width) {
			if (debugLevel > -3) {
				System.out.println("correlateOrthoPair() correlation woi.width="+woi.width+" > gpu_width="+OrthoMap.gpu_width+". Truncating.");
			}
			woi.width = OrthoMap.gpu_width;
		}
		if (woi.height > OrthoMap.gpu_height) {
			if (debugLevel > -3) {
				System.out.println("correlateOrthoPair() correlation woi.height="+woi.height+" > gpu_height="+OrthoMap.gpu_height+". Truncating.");
			}
			woi.height = OrthoMap.gpu_height;
		}
		
		double tile_rad = rad_fraction * 0.5*Math.min(woi.width, woi.height)/GPUTileProcessor.DTT_SIZE;
		tile_rad = Math.min(tile_rad, max_tile_rad); 
		int min_tiles_rad = (int) (fill_fraction * 4 * tile_rad * tile_rad);
		
		final int  gpu_width = OrthoMap.gpu_width; // static
		final int  gpu_height = OrthoMap.gpu_height; // static
		int tilesX = gpu_width/GPUTileProcessor.DTT_SIZE; 
    	int tilesY =  gpu_height/GPUTileProcessor.DTT_SIZE;
    	Rectangle tile_woi = scaleRectangle (woi, GPUTileProcessor.DTT_SIZE);
		// uses fixed_size gpu image size
		TpTask [][] tp_tasks = new TpTask [2][];
		
//		int num_tries = 5;
		double [] prev_rms = {Double.NaN,Double.NaN};
		double rel_improve = 1E-3;
		double [][] elevations = new double [tp_tasks.length][];
		double [][] ground_planes_metric = new double [tp_tasks.length][];
		boolean [][] ground_planes_masks = new boolean[2][];
		double    initial_above = 3; // m
		double    initial_below = 5; //3; // m
		int       num_refine =    3;
		double    frac_above =    0.5; // 0.3;
		double    frac_below =    0.01; // 0.1;
		double [][] jtj = null;
		double [] rms =      {Double.NaN, Double.NaN};
		double [] rms_pure = {Double.NaN, Double.NaN};
		double last_center_radius = 0;
		double previous_center_radius = 1.0;
		OrthoPairLMA  orthoPairLMA = null;
		double [][][] vector_field = new double[gpu_pair.length][][];
		double [][]   tile_centers = null;
		double [] ground_planes_weight = null;	
		double previous_vf_threshold = Double.POSITIVE_INFINITY;
		double vf_threshold = 0;
		for (int ntry = 0; ntry < num_tries; ntry++) {
			if (!batch_mode) {
				if (debugLevel>-3) {
					System.out.println("correlateOrthoPair(): ntry="+ntry);
				}
			}
			String dbg_suffix = batch_mode? null: String.format("_%02d", ntry);
			vector_field = 
					ComboMatch.rectilinearVectorField(//rectilinearCorrelate_TD( // scene0/scene1
							clt_parameters,      // final CLTParameters          clt_parameters,
							gpu_pair_img,        // final float  [][]            fpixels, // to check for empty
							gpu_width,           // final int                    img_width,
							woi,                 // Rectangle                    woi, // if null, use full GPU window
							affines_gpu,         // final double [][][]          affine,  // [2][2][3] affine coefficients to translate common to 2 images
							tp_tasks,            // TpTask [][]                  tp_tasks_o,
							batch_mode,          // final boolean                batch_mode,
							dbg_suffix,          //  final String                 dbg_suffix, // for image_names
							debugLevel);         // final int                    debugLevel);
			if (tp_tasks[0].length < min_tiles_overlap) {
				if (pairwiseOrthoMatch != null) {
					pairwiseOrthoMatch.rms = Double.NaN; // mark as failed
				}
				if (debugLevel > -4) {
					System.out.println("correlateOrthoPair(): too small non-null overlap: "+
							tp_tasks[0].length +" < "+min_tiles_overlap+"");
				}
				return null;
			}
			
			// get elevations
//			double ease_nosfm = 3.0;
			int zoom_lev_tiles = zoom_lev-3;
			ground_planes_weight = null;
			for (int num_elevations = 0; num_elevations < 1; num_elevations++) {
				for (int n = 0; n < gpu_pair.length; n++) {
					double sfm_gain = ortho_maps[gpu_pair[n]].getSfmGain();
					double metric_error_adj = metric_error;
					if (sfm_gain == 0.0) {
						metric_error_adj *= ease_nosfm;
						if (debugLevel > -3) {
							System.out.println("SfM gain == 0 for scene #"+gpu_pair[n]+
									", icreasing metric_error to "+metric_error_adj);
						}
					}
					elevations[n] = ortho_maps[gpu_pair[n]].getTileElevations(
							zoom_lev, // final int zoom_level,
							tp_tasks[n], // final TpTask [] tp_tasks, 
							tilesX, // final int tilesX,
							tilesY, // final int tilesY,
							debugLevel); // final int debugLevel)
					String debug_title = (show_vector_field && (ntry==0))? (ortho_maps[gpu_pair[n]].getName()+"_plane"+dbg_suffix):null;
					ground_planes_metric[n] = ortho_maps[gpu_pair[n]].getPlaneMeters (
							zoom_lev_tiles, // int       zoom_lev, // of the data (3 levels down for tiles)
							elevations[n],  // double [] elev,
							tilesX,         // int       width,
							initial_above,  // double    initial_above, // from average
							initial_below,  // double    initial_below, // from average, // positive value
							num_refine,     // int       num_refine,
							frac_above,     // double    frac_above,
							frac_below,     // double    frac_below,
							null, // 			double [][] tile_plane_elev, // null or double[2][] will return per-tile elevations
							debug_title);   // String    debug_title)
					ground_planes_masks[n] = ortho_maps[gpu_pair[n]].removeHighElevationMismatch (
							zoom_lev_tiles,          // int        zoom_lev, // of the data (3 levels down for tiles)
							elevations[n],           // double []  elev,
							tilesX, // int        width,
							ground_planes_metric[n], // double []  plane_metric, // tiltx,tilty, offs - in meters
							metric_error_adj);           // double     metric_error);
				}
				ground_planes_weight = new double[ ground_planes_masks[0].length];
				int num_left = 0; // , num_was = tp_tasks[0].length;
				for (int i = 0; i < ground_planes_weight.length; i++) {
					if (ground_planes_masks[0][i] && ground_planes_masks[1][i]) {
						num_left++;
						ground_planes_weight[i] = 1.0;
					}
				}
				if (debugLevel > -3) {
					System.out.println("correlateOrthoPair(): left "+num_left+" tiles (was "+tp_tasks[0].length+" before filtering). metric_error="+metric_error);
					System.out.println();
				}
				if (num_left < tp_tasks[0].length/4) {
					num_elevations--;
					if (debugLevel > -4) {
						System.out.println("too few tiles remain, try again. metric_error="+metric_error);
					}
					pairwiseOrthoMatch.rms = Double.NaN; // failed
					return null;
				}
				if (num_left < min_tiles_overlap) {
					if (pairwiseOrthoMatch != null) {
						pairwiseOrthoMatch.rms = Double.NaN; // mark as failed
					}
					if (debugLevel > -4) {
						System.out.println("correlateOrthoPair(): too small non-null, filtered by elevations overlap: "+
								num_left +" < "+min_tiles_overlap+"");
					}
					return null;
				}
				
			}
			
	    	double max_err=              7.0;
	    	int num_bins =            1000;
	    	boolean ignore_strength = false;
	    	//double  frac_remove =        0.15;
	    	double [][] vf_error2 = new double [vector_field.length][]; // may be able to skip [0]
	    	double [][][] vector_field_bkp = show_vector_field? new double[vector_field.length][][]:null;
	    	if (vector_field_bkp != null) {
	    		for (int i = 0; i < vector_field_bkp.length; i++) {
	    			vector_field_bkp[i] = vector_field[i].clone(); 
	    		}
	    	}
	    	for (int nvf_mode = 0; nvf_mode < vector_field.length; nvf_mode++) {
	    		vf_error2[nvf_mode] = getVectorFieldError2(
	    				vector_field[nvf_mode], // double [][] vector_field,
	    			    tilesX,                 // int         width, // tilesX
	    			    tile_woi);              // Rectangle   twoi); // in tiles
	    		double threshold = filterVectorField(
	    				vector_field[nvf_mode], // final double [][] vector_field,
	    				vf_error2[nvf_mode],    // final double []   vf_error2,
	    				frac_remove,            // final double      frac_remove,
	    				ignore_strength,        // final boolean     ignore_strength,
	    				num_bins,               // final int         num_bins,
	    				max_err,                // final double      max_err,
	    				tilesX, // final int         width, // tilesX
	    				tile_woi);              //final Rectangle   twoi); // in tiles
	    		if (nvf_mode == 0) {
	    			vf_threshold = threshold; // if it drops significantly - ignore rms increase
	    		}
				if (debugLevel>-3) {
					System.out.println("vector_field layer= "+nvf_mode+" error threshold = "+threshold+" pix.");
				}
	    	}
	    	
	    	// TODO: use crop, keep (0,0) (woi.x+woi.width, woi.y+woi.height 
			if (vector_field_bkp != null) { // show_vector_field) {
				int dbg_width =  tile_woi.x+tile_woi.width;
				int dbg_height = tile_woi.y+tile_woi.height;
				double [][][][] vf_all = {vector_field_bkp,vector_field};
				double [][] dbg_vf = new double [8 * vector_field.length+5][dbg_width * dbg_height];
				String [] dbg_titles = new String[dbg_vf.length];
				String [] prefix= {"single","single_filtered","neibs","neibs_filtered"};
				for (int n = 0; n < 2*vector_field.length; n++) {
					dbg_titles [4*n+0] = prefix[n]+"-vx";	
					dbg_titles [4*n+1] = prefix[n]+"-vy";	
					dbg_titles [4*n+2] = prefix[n]+"-str";	
					dbg_titles [4*n+3] = prefix[n]+"-err";	
				}
				dbg_titles [8 * vector_field.length + 0] = "mask-elev";
				dbg_titles [8 * vector_field.length + 1] = "elev-0";
				dbg_titles [8 * vector_field.length + 2] = "elev-1";
				dbg_titles [8 * vector_field.length + 3] = "mask-0";
				dbg_titles [8 * vector_field.length + 4] = "mask-1";
						
				for (int i = 0; i < dbg_vf.length; i++) {
					Arrays.fill(dbg_vf[i], Double.NaN);
					
				}
				for (int l = 0; l<dbg_vf[0].length; l++) { // local tile
					int lx = l % dbg_width;
					int ly = l / dbg_width;
					int t = lx + ly * tilesX; // full width
					for (int n = 0; n < vector_field.length; n++) {
						for (int m = 0; m < vf_all.length; m++) {
							if (vf_all[m][n][t] != null) {
								for (int k = 0; k < 3; k++) {
									dbg_vf[m*4 + n*8 + k][l] = vf_all[m][n][t][k];
								}
								// will automatically apply filtered
								dbg_vf[m*4 + n*8 + 3][l] = Math.sqrt(vf_error2[n][t]);
							}
						}
					}
					dbg_vf [8 * vector_field.length + 0][l] = ground_planes_weight[t];
					dbg_vf [8 * vector_field.length + 1][l] = elevations[0][t];
					dbg_vf [8 * vector_field.length + 2][l] = elevations[1][t];
					dbg_vf [8 * vector_field.length + 3][l] = ground_planes_masks[0][t]?1.0:0.0;
					dbg_vf [8 * vector_field.length + 4][l] = ground_planes_masks[1][t]?1.0:0.0;
				}
	    		ShowDoubleFloatArrays.showArrays(
	    				dbg_vf,
	    				dbg_width,
	    				dbg_height,
	    				true,
	    				"vector_field"+dbg_suffix,
	    				dbg_titles);
			}

			
			
			
			// may use tl_rect_metric to remap to the original image
			tile_centers = new double [vector_field[0].length][];
			for (TpTask task: tp_tasks[1]) {
				int ti = task.getTileY() * tilesX + task.getTileX();
				tile_centers[ti] = task.getDoubleCenterXY();
			}
			if (show_tile_centers){
				double [][] dbg_img = new double [6][tile_centers.length];
				String [] dbg_titles = {"cX","cY","px0","py0", "px1","py1"};
				for (int i = 0; i< dbg_img.length;i++) Arrays.fill(dbg_img[i], Double.NaN);
				for (int t = 0; t < tp_tasks[0].length; t++) {
					TpTask task0 = tp_tasks[0][t];
					TpTask task1 = tp_tasks[1][t];
					int ti = task0.getTileY() * tilesX + task0.getTileX();
					dbg_img[0][ti] = task0.getDoubleCenterXY()[0]; // same for task0, task1 
					dbg_img[1][ti] = task1.getDoubleCenterXY()[1]; 
					dbg_img[2][ti] = task0.getXY()[0][0];
					dbg_img[3][ti] = task0.getXY()[0][1];
					dbg_img[4][ti] = task1.getXY()[0][0];
					dbg_img[5][ti] = task1.getXY()[0][1];
				} // getXY()
				ShowDoubleFloatArrays.showArrays(
						dbg_img,
						tilesX,
						tile_centers.length/tilesX,
						true,
						"tile_centers"+dbg_suffix,
						dbg_titles);
			}
			if (!batch_mode) {
				if (debugLevel>-3) {
					System.out.println("correlateOrthoPair(): before LMA, ntry="+ntry);
				}
			}
			boolean origin_center = true; // false - old mode

			orthoPairLMA = new OrthoPairLMA(origin_center);
			// vector_field[1] - neighbors
			double lambda =            0.1;
			double lambda_scale_good = 0.5;
			double lambda_scale_bad =  8.0;
			double lambda_max =      100;
			double rms_diff =          0.001;
			int    num_iter =         20;
			boolean last_run =       false;
			int min_good_tiles =      min_tiles_overlap/2;
			
			// show_lma_dbg
			String dbg_lma_prefix = show_lma_dbg? ("LMA_"+gpu_pair[0]+"-"+gpu_pair[1]+"_ntry"+ntry+"_"):null;
			
			int num_good_tiles = orthoPairLMA.prepareLMA(
					// will always calculate relative affine, starting with unity
					tilesX,          // int           width,
					vector_field[1], // double [][]   vector_XYS,    // optical flow X,Y, confidence obtained from the correlate2DIterate()
					tile_centers,    // double [][]   centers,       // tile centers (in pixels)
					ground_planes_weight, // null,            // double []     weights_extra, // optional, may be null 
					true,            // boolean       first_run,
					min_good_tiles,  // int           min_good_tiles,
					max_std,         // double        max_std,      // maximal standard deviation to limit center area  
					min_std_rad,     // double        min_std_rad,  // minimal radius of the central area (if less - fail)
					tile_rad ,       // double        tile_rad,
					min_tiles_rad,   // int           min_tiles_rad,
					affines_gpu[1],  // double [][]   src_affine,
					pull_skew,       // double        pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
					pull_tilt,       // double        pull_tilt,        // > 0
					pull_scale,      // double        pull_scale,       // = 0
					debugLevel);     // final int     debug_level)
			last_center_radius = orthoPairLMA.getCenterRadius();
			double center_radius_increase = 
					Double.isInfinite(previous_center_radius)?
							(Double.isInfinite(last_center_radius)?1:0):
								last_center_radius/previous_center_radius;
			if ((ntry == 0) && Double.isInfinite(last_center_radius)) {
				center_radius_increase = 1.0; // if starts with infinity - no increase  
			}
			if ((min_std_rad >0) && (last_center_radius < 1)) {
				if (debugLevel>-3) {
					System.out.println("correlateOrthoPair(): center_radius="+
							orthoPairLMA.getCenterRadius()+" < "+ 1);
				}
				return null;
			}
			
			if (num_good_tiles < min_good_tiles) {
				if (debugLevel>-4) {
					System.out.println("correlateOrthoPair(): num_good_tiles="+
				    num_good_tiles+ " < "+min_good_tiles);
				}
			 	if (pairwiseOrthoMatch != null) {
			 		pairwiseOrthoMatch.rms = Double.NaN; // mark as failed
			 	}
				return null;
			}
			int lma_rslt = orthoPairLMA.runLma( // <0 - failed, >=0 iteration number (1 - immediately)
					lambda,             // double lambda,           // 0.1
					lambda_scale_good,  // double lambda_scale_good,// 0.5
					lambda_scale_bad,   // double lambda_scale_bad, // 8.0
					lambda_max,         // double lambda_max,       // 100
					rms_diff,           // double rms_diff,         // 0.001
					num_iter,           // int    num_iter,         // 20
					last_run,           // boolean last_run,
					dbg_lma_prefix,     // String dbg_prefix,
					debugLevel);        // int    debug_level)
			if (debugLevel > -3) {
				System.out.println("LMA result = "+lma_rslt);
			}
			if (lma_rslt < 0) {
				System.out.println("LMA failed, result="+lma_rslt);
				return null;
			}
			rms =      orthoPairLMA.getRms();
			if (debugLevel > -3) {
				System.out.println("RMS= "+rms[0]+" ("+orthoPairLMA.getInitialRms()[0]+
						"), RMS pure="+rms[1]+" ("+orthoPairLMA.getInitialRms()[1]+")");
			}
			if (max_rms_iter != null) {
				int max_rms_index = Math.min(max_rms_iter.length-1, ntry);
				if (rms[0] > max_rms_iter[max_rms_index]) {
					if (debugLevel > -3) {
						System.out.println("RMS= "+rms[0]+" > max_rms_iter["+
								max_rms_index+"] = "+max_rms_iter[max_rms_index]);
					}
					return null;
				}
			}
			
			if (rms[0] > prev_rms[0]) {
				if (debugLevel > -3) {
					if ((rms[0]-prev_rms[0])/prev_rms[0] < rel_improve) {
						System.out.println("LMA RMSE worsened, but less than improvement threshold: new "+rms[0]+" ("+ orthoPairLMA.getInitialRms()[0]+"), prev="+prev_rms[0]);
					} else {
						System.out.println("LMA RMSE worsened: new "+rms[0]+" ("+ orthoPairLMA.getInitialRms()[0]+"), prev="+prev_rms[0]);
					}
				}
				if (ignore_prev_rms) {
					if (debugLevel > -3) {
						System.out.println("Will continue, as ignore_prev_rms is set");
					}					
				} else {
					if (center_radius_increase > center_radius_change) {
						if (debugLevel > -3) {
							System.out.println("Will continue, as center_radius increased from "+
									previous_center_radius+" to "+	last_center_radius +" (more than "+
									center_radius_change+"x).");
						}
					} else {
						if (vf_threshold <  (vf_drop_big * previous_vf_threshold)) {
							if (debugLevel > -3) {
								System.out.println("Will continue, as vf_threshold dropped from "+
										previous_vf_threshold+" to "+	vf_threshold +" (more than "+
										vf_drop_big+"x).");
							}
						} else {
							break;
						}
					}
				}
			}
			affines_gpu[1]=OrthoMap.combineAffine(affines_gpu[1], orthoPairLMA.getAffine());
			jtj = orthoPairLMA.getLastJtJ();
			if ((rms[0] <= prev_rms[0]) && ((prev_rms[0] - rms[0])/prev_rms[0] < rel_improve)) {
				if (debugLevel > -2) {
					System.out.println("LMA relative RMSE improvement = "+((prev_rms[0] - rms[0])/prev_rms[0])+" < "+rel_improve+", exiting.");
				}
				if (ignore_prev_rms) {
					if (debugLevel > -3) {
						System.out.println("Will continue, as ignore_prev_rms is set");
					}					
				} else {
					if (center_radius_increase > center_radius_change) {
						if (debugLevel > -3) {
							System.out.println("Will continue, as center_radius increased from "+
									previous_center_radius+" to "+	last_center_radius +" (more than "+
									center_radius_change+"x).");
						}
					} else {
						if (vf_threshold <  (vf_drop_big * previous_vf_threshold)) {
							if (debugLevel > -3) {
								System.out.println("Will continue, as vf_threshold dropped from "+
										previous_vf_threshold+" to "+	previous_vf_threshold +" (more than "+
										vf_drop_big+"x).");
							}
						} else {
							break;
						}
					}
				}
			}

			if (center_radius_increase > center_radius_change) {
				num_tries ++;
				if (debugLevel > -2) {
					System.out.println("Increasing num_tries to "+num_tries+", as center_radius increased from "+
							previous_center_radius+" to "+	last_center_radius +" (more than "+
							center_radius_change+"x).");
				}
			}
			
			
			prev_rms=rms.clone();
			previous_center_radius = last_center_radius;
			previous_vf_threshold = vf_threshold;
			
		} // for (int ntry = 0; ntry < num_tries; ntry++) {
		// recheck here
//		double tile_rad = rad_fraction * 0.5*Math.min(woi.width, woi.height)/GPUTileProcessor.DTT_SIZE;
		if (num_tries > 0) {
			min_tiles_rad = (int) (fill_fraction_final * 4 * tile_rad * tile_rad);
			last_center_radius = orthoPairLMA.getCenterRadius(
					max_std,         // final double      max_std,      // maximal standard deviation to limit center area
					tile_rad,        // final double      min_radius,
					min_tiles_rad,   // final int         min_tiles,
					vector_field[1], // final double [][] vector_XYS,
					ground_planes_weight, //, // null,            // final double []   weights_extra, // null or additional weights (such as elevation-based)
					tile_centers);   // final double [][] centers)

			if ((min_std_rad > 0) && (last_center_radius < min_std_rad)) {
				if (debugLevel>-3) {
					System.out.println("correlateOrthoPair(): center_radius="+
							last_center_radius+" < "+ min_std_rad);
				}
				return null;
			}
		}
		
		if (pairwiseOrthoMatch != null) {
			pairwiseOrthoMatch.jtj = jtj;
			pairwiseOrthoMatch.rms=  rms[1]; // pure rms
			pairwiseOrthoMatch.zoom_lev = zoom_lev;
		}
		
		double [] tlo_src_metric_other = new double[2]; // check affines[][][] here - 
		for (int i = 0; i < 2; i++) {
			tlo_src_metric_other[i] = affines_gpu[1][i][2] * pix_size - ortho_maps[gpu_pair[1]].getVertMeters()[i];
			for (int j = 0; j < 2; j++) {
				affines[1][i][j] = affines_gpu[1][i][j];
			}
		}
		for (int i = 0; i < 2; i++) {
			affines[1][i][2] = tlo_src_metric_other[i]  -
					tlo_rect_metric[1][0] * affines[1][i][0] -
					tlo_rect_metric[1][1] * affines[1][i][1];
		}
		
		if (debugLevel>-3) {
			System.out.println("correlateOrthoPair(): adjusted affines[1]");
			System.out.println("[["+affines[1][0][0]+","+affines[1][0][1]+","+affines[1][0][2]+"],");
			System.out.println(" ["+affines[1][1][0]+","+affines[1][1][1]+","+affines[1][1][2]+"]]");
		}
		
		// modify affines[1]
		
		if ((debugLevel > 1) && (num_tries>0)) {// show result here
			String [] map_names = {ortho_maps[gpu_pair[0]].getName(),ortho_maps[gpu_pair[1]].getName()};
			ShowDoubleFloatArrays.showArrays( 
					gpu_pair_img,
					OrthoMap.gpu_width,
					OrthoMap.gpu_height,
					true,
					"gpu_pair-zoom"+zoom_lev+"-"+ortho_maps[gpu_pair[0]].getName()+"-"+ortho_maps[gpu_pair[1]].getName(),
					map_names);
		}
		if (calc_warp) {
			double scale = 2.0;
			String dbg_suffix = batch_mode? null: "_warp";

		// return only neighbors vector field
			double [][] vf = ComboMatch.rectilinearVectorField(//rectilinearCorrelate_TD( // scene0/scene1
					clt_parameters,    // final CLTParameters          clt_parameters,
					gpu_pair_img,      // final float  [][]            fpixels, // to check for empty
					gpu_width,         // final int                    img_width,
					woi,               // Rectangle                    woi, // if null, use full GPU window
					affines_gpu,       // final double [][][]          affine,  // [2][2][3] affine coefficients to translate common to 2 images
					tp_tasks,          // TpTask [][]                  tp_tasks_o,
					batch_mode,        // final boolean                batch_mode,
					dbg_suffix,        // final String                 dbg_suffix,
					debugLevel)[1];    // final int                    debugLevel);
			double [][] tile_elevs = null;
			if (ground_planes != null) {
				for (int n = 0; n < ground_planes.length; n++) {
					ground_planes[n] = getGroundPlane(
							gpu_pair[n],     // int         scene_num,
							tp_tasks[n],     // TpTask [] tp_tasks,
							zoom_lev,        // int         zoom_lev,
							tilesX,          // int         tilesX,
							tilesY,          // int         tilesY,
							debugLevel);     // int         debugLevel)
				}
			}
			if (show_vf && (num_tries == 0) && (debugLevel > 1)) { // not needed now
				tile_elevs = new double [tp_tasks.length][];
				for (int n = 0; n < tile_elevs.length; n++) {
					String debug_title = (show_vector_field && (debugLevel>0))? (ortho_maps[gpu_pair[n]].getName()+"_plane"+dbg_suffix):null;
					tile_elevs[n] = getTileElevations(
							gpu_pair[n],     // int         scene_num,
							tp_tasks[n],     // TpTask [] tp_tasks,
							zoom_lev,        // int         zoom_lev,
							tilesX,          // int         tilesX,
							tilesY,          // int         tilesY,
							tile_woi,        // Rectangle tile_woi, // only width, height are used top-left corners are the same
							debug_title,     // String      debug_title,
							debugLevel);     // int         debugLevel)
				}
				String [] dbg_titles = new String[tile_elevs.length];
				String dbg_title = "tile_elevations";
				for (int i =0; i < tile_elevs.length; i++) {
					dbg_titles[i] = ortho_maps[gpu_pair[i]].getName();
					dbg_title += "-"+ortho_maps[gpu_pair[i]].getName();
				}
	    		ShowDoubleFloatArrays.showArrays(
	    				tile_elevs,
	    				tile_woi.width,
	    				tile_woi.height,
	    				true,
	    				dbg_title ,
	    				dbg_titles);
				System.out.println();
			}
			
			double [][] vf_interpolated = interpolateVectorField(
					vf,                // final double [][] vector_field, // sparse {vx,vy,strength}
					tp_tasks[1],       // final TpTask []   tp_tasks, // to remove no-overlap tiles
					tilesX,            // final int gpu_tilesX, // 512
					tile_woi,          // final Rectangle tile_woi, // only width, height are used top-left corners are the same
					scale,             // final double scale,
					1);                // final int debugLevel); // vector_filed_filled - use 2
			double [] tl_metric = {bounds_overlap_meters[0][0],bounds_overlap_meters[1][0]};
			
			FineXYCorr warp = new FineXYCorr(
					zoom_lev,          // int zoom_lev,
					tile_woi.width,    // int width,
					tl_metric,         // double [] tl_metric,// relative to the reference image vertical point, normally negative
					vf_interpolated);  // double [][] vf);
			return warp;
		}
		return null;
	}
	
	public double [] getTileElevations(
			int         scene_num,
			TpTask []   tp_tasks,
			int         zoom_lev,
			int         tilesX,
			int         tilesY,
			final Rectangle   tile_woi, // only width, height are used top-left corners are the same
			String      debug_title,
			int         debugLevel) {
		double    initial_above = 3; // m
		double    initial_below = 3; // m
		int       num_refine =    3;
		double    frac_above =    0.3;
		double    frac_below =    0.1;
		int zoom_lev_tiles = zoom_lev-3;
			double [] elevations = ortho_maps[scene_num].getTileElevations(
					zoom_lev, // final int zoom_level,
					tp_tasks, // final TpTask [] tp_tasks, 
					tilesX, // final int tilesX,
					tilesY, // final int tilesY,
					debugLevel); // final int debugLevel)
			double [] tile_plane_elev = new double [elevations.length];
			double [] ground_planes_metric = ortho_maps[scene_num].getPlaneMeters (
					zoom_lev_tiles,  // int       zoom_lev, // of the data (3 levels down for tiles)
					elevations,      // double [] elev,
					tilesX,          // int       width,
					initial_above,   // double    initial_above, // from average
					initial_below,   // double    initial_below, // from average, // positive value
					num_refine,      // int       num_refine,
					frac_above,      // double    frac_above,
					frac_below,      // double    frac_below,
					tile_plane_elev, // 			double [][] tile_plane_elev, // null or double[2][] will return per-tile elevations
					debug_title);    // String    debug_title)
		// tile_woi, //
			
		double [] elev_crop = new double[tile_woi.width*tile_woi.height];
		for (int row = 0; row < tile_woi.height; row++) {
			System.arraycopy(
					tile_plane_elev,
					row * tilesX,
					elev_crop,
					row*tile_woi.width,
					tile_woi.width);
		}
			
		return elev_crop;
	}
	
	/**
	 *  Get planar approximation of the ground
	 * @param scene_num scene index
	 * @param tp_tasks
	 * @param tp_tasks array of non-empty tiles to be processed in the GPU. Integer tx and ty reference
	 *        tile on a tile grid (8x8 pix), center X,Y for the only "sensor" 0 - float coordinates
	 *        corresponding to the current GPU zoom level
	 * @param zoom_lev zoom level of the GPU image, 0 is 1pix=1cm, -1 is 1pix=2cm
	 * @param tilesX
	 * @param tilesY
	 * @param debugLevel
	 * @return plane parameters - all metric, relative to the vertical point:
	 *         {tilt_x (m/m), tilt_y (m/m), offset (elevation at vertical point in meters)      
	 */
	public double [] getGroundPlane(
			int         scene_num,
			TpTask []   tp_tasks,
			int         zoom_lev,
			int         tilesX,
			int         tilesY,
			int         debugLevel) {
		double    initial_above = 3; // m
		double    initial_below = 3; // m
		int       num_refine =    3;
		double    frac_above =    0.3;
		double    frac_below =    0.1;
		int zoom_lev_tiles = zoom_lev-3;
			double [] elevations = ortho_maps[scene_num].getTileElevations(
					zoom_lev, // final int zoom_level,
					tp_tasks, // final TpTask [] tp_tasks, 
					tilesX, // final int tilesX,
					tilesY, // final int tilesY,
					debugLevel); // final int debugLevel)
			double [] ground_plane_metric = ortho_maps[scene_num].getPlaneMeters (
					zoom_lev_tiles,  // int       zoom_lev, // of the data (3 levels down for tiles)
					elevations,      // double [] elev,
					tilesX,          // int       width,
					initial_above,   // double    initial_above, // from average
					initial_below,   // double    initial_below, // from average, // positive value
					num_refine,      // int       num_refine,
					frac_above,      // double    frac_above,
					frac_below,      // double    frac_below,
					null, // 			double [][] tile_plane_elev, // null or double[2][] will return per-tile elevations
					null);    // String    debug_title)
		// tile_woi, //
		return ground_plane_metric;
	}

	
	
	
	
	/**
	 * Project object offset to along and perpendicular to the scenes offset
	 * @param object_offset object center pixel x and y offset between images (y - down) 
	 * @param scene_offset pixel offset between images 
	 * @return A pair of offsets: parallel (to scene offset) and perpendicular. Negative parallel
	 * offsets corresponds to objects above ground  
	 */
	public static double [] projectOffsetOnVector(
			double [] object_offset,
			double [] scene_offset) {
		double l1 = Math.sqrt(scene_offset[0]*scene_offset[0] + scene_offset[1]*scene_offset[1]);
		if (!(l1 > 0.00001)) {
			double [] offs_rot = new double [2];
			offs_rot[0] = ( object_offset[0]*scene_offset[0] + object_offset[1]*scene_offset[1]) / l1;
			offs_rot[1] = (-object_offset[0]*scene_offset[1] + object_offset[1]*scene_offset[0]) / l1;
			return offs_rot;
		}
		return object_offset;
	}
	
	/**
	 * Estimate object height if its offset between image is caused by its elevation
	 * @param object_offset object center pixel x and y offset between images (y - down) 
	 * @param scene_offset pixel offset between images 
	 * @param zoom_level images zoom level
	 * @param agl scene (second) altitude above ground in meters
	 * @return Estimated object elevation above ground in meters
	 */
	public static double offsetToElevation(
			double [] object_offset,
			double [] scene_offset,
			int       zoom_level,
			double    agl) {
		double l1 = Math.sqrt(scene_offset[0]*scene_offset[0] + scene_offset[1]*scene_offset[1]);
		double offs_par = projectOffsetOnVector(object_offset, scene_offset)[0]; // *OrthoMap.getPixelSizeMeters(zoom_level);
		return -agl * offs_par / l1 ;
	}
	
	/**
	 * Calculate (negative) pixel offset parallel to the scene offset corresponding to object height
	 * @param height
	 * @param scene_offset
	 * @param zoom_level
	 * @param agl
	 * @return
	 */
	public static double elevationToParallelOffset(
			double    height,
			double [] scene_offset,
			int       zoom_level,
			double    agl) {
		double l1 = Math.sqrt(scene_offset[0]*scene_offset[0] + scene_offset[1]*scene_offset[1]);
		return -height/agl * l1 ;
	}
	
	
	
	public static Rectangle scaleRectangle(
			Rectangle woi,
			int tile_size){
		int min_tx = woi.x/tile_size;
		int min_ty = woi.y/tile_size;
		int max_tx1 = (woi.x + woi.width +  (tile_size -1)) / tile_size; 
		int max_ty1 = (woi.y + woi.height + (tile_size -1)) / tile_size; 
		return new Rectangle(min_tx,min_ty,max_tx1 - min_tx,max_ty1 - min_ty);
	}
	
	public static double [] getVectorFieldError2(
			double [][] vector_field,
			int         width, // tilesX
			Rectangle   twoi) { // in tiles
		final Rectangle woi = (twoi != null)? twoi: (new Rectangle (0,0,width,vector_field.length/width));
		final int num_tiles = woi.width*woi.height;
		final int tlTile = width * woi.y + woi.x;
		final double [] vf_error2 = new double [vector_field.length];
//		Arrays.fill(vf_error2, Double.NaN);
		final Thread[] threads = ImageDtt.newThreadArray();
		final AtomicInteger ai = new AtomicInteger(0);
		for (int ithread = 0; ithread < threads.length; ithread++) {
			threads[ithread] = new Thread() {
				public void run() {
					for (int nTile = ai.getAndIncrement(); nTile < num_tiles; nTile = ai.getAndIncrement()) {
						int itileX= nTile%woi.width;
						int itileY= nTile/woi.width;
						int tile = tlTile + itileY * width + itileX;
						if (vector_field[tile] != null) {
							double [] xys = vector_field[tile];
							vf_error2[tile] += xys[0]*xys[0]+xys[1]*xys[1]; 
						}
					}
				}
			};
		}		      
		ImageDtt.startAndJoin(threads);
		return vf_error2;
	}
	
	public static double filterVectorField(
			final double [][] vector_field,
			final double []   vf_error2,
			final double      frac_remove,
			final boolean     ignore_strength,
			final int         num_bins,
			final double      max_err,
			final int         width, // tilesX
			final Rectangle   twoi) { // in tiles
		final Rectangle woi = (twoi != null)? twoi: (new Rectangle (0,0,width,vector_field.length/width));
		final int STRENGTH_INDEX=2;
		final double max_err2 = max_err*max_err;
		final double scale = num_bins/max_err2;
		final int num_tiles = woi.width*woi.height;
		final int tlTile = width * woi.y + woi.x;
		final Thread[] threads = ImageDtt.newThreadArray();
		final AtomicInteger ai = new AtomicInteger(0);
		final AtomicInteger ati = new AtomicInteger(0);
		final double [][] hist2 = new double [threads.length][num_bins];
		for (int ithread = 0; ithread < threads.length; ithread++) {
			threads[ithread] = new Thread() {
				public void run() {
					int thread_num = ati.getAndIncrement();
					for (int nTile = ai.getAndIncrement(); nTile < num_tiles; nTile = ai.getAndIncrement()) {
						int itileX= nTile%woi.width;
						int itileY= nTile/woi.width;
						int tile = tlTile + itileY * width + itileX;
						if (!Double.isNaN(vf_error2[tile]) && (vector_field[tile] != null)){ // one test is enough
							int bin = (int) Math.round(vf_error2[tile]*scale);
							if (bin >= num_bins) {
								bin= num_bins - 1;
							}
							hist2[thread_num][bin] += ignore_strength? 1.0 : vector_field[tile][STRENGTH_INDEX]; 
						}
					}
				}
			};
		}		      
		ImageDtt.startAndJoin(threads);
		ai.set(0);
		final double [] hist =    new double [num_bins];
		for (int ithread = 0; ithread < threads.length; ithread++) {
			threads[ithread] = new Thread() {
				public void run() {
					for (int bin = ai.getAndIncrement(); bin < num_bins; bin = ai.getAndIncrement()) {
						for (int i = 0; i < hist2.length; i++) {
							hist[bin]+= hist2[i][bin];
						}
					}
				}
			};
		}		      
		ImageDtt.startAndJoin(threads);
		double sw = 0;
		for (int bin = 0; bin < num_bins; bin++) {
			sw += hist[bin];
		}
		double aremove = sw * frac_remove;
		double sh = 0, shp = 0;
		double t2 = max_err2;
		for (int bin = num_bins-1; bin>=0; bin--) {
			shp = sh;
			sh += hist[bin];
			if (sh > aremove) {
				double r = (sh-aremove)/(sh-shp);
				t2 = (bin + r)/scale;
				break;
			}
		}
		final double threshold2 = t2;
		// remove bad tiles
		ai.set(0);
		for (int ithread = 0; ithread < threads.length; ithread++) {
			threads[ithread] = new Thread() {
				public void run() {
					for (int nTile = ai.getAndIncrement(); nTile < num_tiles; nTile = ai.getAndIncrement()) {
						int itileX= nTile%woi.width;
						int itileY= nTile/woi.width;
						int tile = tlTile + itileY * width + itileX;
						if ((vector_field[tile] != null) && !(vf_error2[tile] <= threshold2)){
							vector_field[tile]= null;
						}
					}
				}
			};
		}		      
		ImageDtt.startAndJoin(threads);
		return Math.sqrt(threshold2);
	}	
	
	
	
	
	/**
	 * Start with this when reading from saved data
	 * @param path
	 * @return
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	public static OrthoMapsCollection readOrthoMapsCollection (
			String path) throws IOException, ClassNotFoundException {
		// try reading current_version, if fails - restart without it (for older formats)
		FileInputStream fileInputStream  = new FileInputStream(path);
		ObjectInputStream objectInputStream  = new ObjectInputStream(fileInputStream);
		int current_version = (int) objectInputStream.readObject(); // reads OrthoMapsCollection
		OrthoMapsCollection.CURRENT_VERSION = current_version; // trying here 08.29.2024 - before orthoMapsCollection exists
		System.out.println("readOrthoMapsCollection(): got current_version="+current_version);
		OrthoMapsCollection orthoMapsCollection = (OrthoMapsCollection) objectInputStream.readObject();
		objectInputStream.close();
		System.out.println("readOrthoMapsCollection(): got orthoMapsCollection, current_version="+current_version);
		return orthoMapsCollection;
	}
	
	public void writeOrthoMapsCollection (String path) throws IOException {
		FileOutputStream fileOutputStream = new FileOutputStream(path);
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
 		objectOutputStream.writeObject(LATEST_VERSION); // current_version);
		objectOutputStream.writeObject(this);
	    objectOutputStream.flush();
	    objectOutputStream.close();
	}
	
	public static double [][] interpolateVectorField(
			final double [][] vector_field, // sparse {vx,vy,strength}
			final TpTask []   tp_tasks, // to remove no-overlap tiles
			final int         gpu_tilesX, // 512
			final Rectangle   tile_woi, // only width, height are used top-left corners are the same
			final double      scale,
			final int         debugLevel) {
		final int tiles = tile_woi.width*tile_woi.height;
		final double [][] vf = new double[2][tile_woi.width*tile_woi.height];
		for (int i = 0; i < vf.length; i++) {
			Arrays.fill(vf[i], Double.NaN);
		}
		final boolean [] mask = (tp_tasks==null)? null: new boolean [tiles];
		final Thread[] threads = ImageDtt.newThreadArray();
		final AtomicInteger ai = new AtomicInteger(0);
		for (int ithread = 0; ithread < threads.length; ithread++) {
			threads[ithread] = new Thread() {
				public void run() {
					for (int ipix = ai.getAndIncrement(); ipix < tiles; ipix = ai.getAndIncrement()) {
						int y = ipix / tile_woi.width;
						int x = ipix % tile_woi.width;
						double [] v = vector_field[y*gpu_tilesX+x];
						if (v != null) {
							for (int i = 0; i < vf.length; i++) {
								vf[i][ipix] = scale*v[i];
							}
						}
					}
				}
			};
		}		      
		ImageDtt.startAndJoin(threads);

		if (mask != null) {
			ai.set(0);
			for (int ithread = 0; ithread < threads.length; ithread++) {
				threads[ithread] = new Thread() {
					public void run() {
						for (int iTile = ai.getAndIncrement(); iTile < tp_tasks.length; iTile = ai.getAndIncrement()) {
							TpTask task = tp_tasks[iTile];
							int[] txy = task.getTileXY();
							if ((txy[0] < tile_woi.width) && (txy[1] < tile_woi.height)) {
								mask[txy[0] + txy[1] * tile_woi.width] = true;
							}
						}
					}
				};
			}		      
			ImageDtt.startAndJoin(threads);
		}
        
        // now fill NaNs in each of vf[0], vf[1]
        double [][]  vf_filled = new double[vf.length][];
		int       num_passes = 100;
		double    max_diff = 1E-4;
    	for (int i = 0; i < vf.length; i++) {
    		vf_filled[i] = OpticalFlow.fillGapsDouble(
    				vf[i],                // double []  data,
    				mask,                 // boolean [] mask_in, // do not process if false (may be null)
    				tile_woi.width,       // int       width,
    				0,                    // int       max_grow,
    				num_passes,           // int       num_passes,
    				max_diff,             // double    max_diff,
    				ImageDtt.THREADS_MAX, // int       threadsMax,
    				debugLevel-1);        // int       debug_level)
    	}		
		if (debugLevel > 0) {
			String [] dbg_titles = {"x-raw","x_filled","y-raw","y_filled"};
			double [][] dbg_img = {vf[0], vf_filled[0],vf[1], vf_filled[1]};
    		ShowDoubleFloatArrays.showArrays(
    				dbg_img,
    				tile_woi.width,
    				dbg_img[0].length / tile_woi.width,
    				true,
    				"vector_field_filled",
    				dbg_titles);
		}
		double [][] vf_out = new double [tiles][];
		ai.set(0);
		for (int ithread = 0; ithread < threads.length; ithread++) {
			threads[ithread] = new Thread() {
				public void run() {
					for (int ipix = ai.getAndIncrement(); ipix < tiles; ipix = ai.getAndIncrement()) {
						if (!Double.isNaN(vf_filled[0][ipix]) && !Double.isNaN(vf_filled[1][ipix])) {
							vf_out[ipix] = new double[] {vf_filled[0][ipix],vf_filled[1][ipix]};
						}
					}
				}
			};
		}		      
		ImageDtt.startAndJoin(threads);
		return vf_out;
	}
	
	public ImagePlus patternMatchDualWrap (
			int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
			double [][][] affines, // null or [indices.length][2][3] 
			FineXYCorr    warp,
			double [][]   ground_planes) { // null or) {    // use for a single pair only
		//indices //getAGL()
		OrthoMapsParameters omp = new OrthoMapsParameters(); // will set defaults

		double scene0_agl = ortho_maps[indices[0]].getAGL();
		// Overwrite some defaults based on AGL
		if (scene0_agl <= ((50+75)/2)) { // add versions for morning/morning or morning/evening
			omp.setDefaults50();
		} else if (scene0_agl < ((75+100)/2)) { // 75m defaults
			omp.setDefaults75();
		} else { // 100m defaults
			omp.setDefaults100();
		}
		omp.setupDialog(
				indices,
				ortho_maps);
		
		return patternMatchDual (
				indices,             // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
				affines,             // double [][][] affines, // null or [indices.length][2][3] 
				warp,                // FineXYCorr    warp);
				ground_planes,       // double [][]   ground_planes,
				omp);//OrthoMapsParameters omp );
	}

	public ImagePlus patternMatchDual (
			int []              indices, // null or which indices to use (normally just 2 for pairwise comparison)
			double [][][]       affines, // null or [indices.length][2][3] 
			FineXYCorr          warp,    // use for a single pair only
			double [][]         ground_planes,
			OrthoMapsParameters omp) {
		boolean sort_by_best = true; // false - as was, by selected pattern
		double ease_first_best = 0.9; // before recenter
		String basename = OrthoMapsParameters.getBaseName(
				ortho_maps, // OrthoMap []           ortho_maps,			
				indices);   // int []                indices) 
		int         debugLevel            = omp.debugLevel;		
		
		// sample around + and - 128/spectrum_sample[0]
		// from (128/spectrum_sample[0])/spectrum_sample[1]
		// to (128/spectrum_sample[0])*spectrum_sample[1].
		// Calculate average of FFT power spectrum on both sides, in both directions and get ratio
		double [] spectrum_sample = {14, 1.5, 1.0};
		 
		double search_radius_recenter = 3; // how far to look for updated correlation peak after recenter
		if (warp != null) {
			warp.scale_warp = omp.scale_warp;
		}
		int last_scene = indices.length-1;
    	int min_zoom_lev = ortho_maps[indices[0]].getOriginalZoomLevel();
    	int max_zoom_lev = ortho_maps[indices[0]].getOriginalZoomLevel();

    	for (int i = 0; i < indices.length; i++) {
    		min_zoom_lev = Math.min(min_zoom_lev, ortho_maps[indices[i]].getOriginalZoomLevel());
    		max_zoom_lev = Math.max(max_zoom_lev, ortho_maps[indices[i]].getOriginalZoomLevel());
    	}
		int     zoom_level = min_zoom_lev;
		int []  wh = new int[2];
		int []  origin = new int[2];
		double [][] centers = new double [indices.length][];
		double [][] dmulti = renderMultiDouble (
				null,       // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
				indices,    // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
				true,       // boolean       bounds_to_indices,
				affines,    // double [][][] affines, // null or [indices.length][2][3]
				null,       // double [][]   equalize,
				false,      // boolean       ignore_equalize,
				warp,       // FineXYCorr    warp,,
				zoom_level, // int         zoom_level,
				wh,         // int []      wh,
				origin,     // int []      origin){ // maps[0] as a reference
				centers);   // double [][] centers)
		double [][] dalt = null;
		if (ground_planes != null) {
			dalt = renderMultiDouble (
					ground_planes, // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
					indices,       // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
					true,          // boolean       bounds_to_indices,
					affines,       // double [][][] affines, // null or [indices.length][2][3]
					null,         // double [][]   equalize,
					true,         // boolean       ignore_equalize,
					warp,          // FineXYCorr    warp,,
					zoom_level,    // int         zoom_level,
					wh,            // int []      wh,
					origin,        // int []      origin){ // maps[0] as a reference
					null); // centers);      // double [][] centers) // already set with dmulti
		}
		
		
		int width =  wh[0];
		int height = wh[1];
		String [] dbg_titles = new String[dmulti.length];
		for (int i = 0; i < dbg_titles.length; i++) {
			dbg_titles[i] = ""+i;
		}
		ImagePlus img_first = ShowDoubleFloatArrays.makeArrays(
				dmulti,
				width,
				height,
				basename, // ortho_maps[indices[0]].getName(),
				dbg_titles);
		showSaveImagePlus(
				img_first, // ImagePlus imp,
				omp.show_images, // boolean   show,
				omp.save_images, // boolean   save,
				omp.save_dir, // String    save_dir,
				debugLevel); // int       debugLevel)
		if (dalt != null) {
			ImagePlus img_alt = ShowDoubleFloatArrays.makeArrays(
					dalt,
					width,
					height,
					basename + "-alt", // ortho_maps[indices[0]].getName()+"-alt",
					dbg_titles);
			showSaveImagePlus(
					img_alt, // ImagePlus imp,
					omp.show_images, // boolean   show,
					omp.save_images, // boolean   save,
					omp.save_dir, // String    save_dir,
					debugLevel); // int       debugLevel)
		}
		
		
		double [][] src_marks = null;
		
		double [][][] patterns_all =   new double [indices.length][][];
		double [][] kernels_all =      new double [indices.length][];
		
		GroundObjectPattern [] gops =  new GroundObjectPattern[indices.length];
		AltitudeMismatchKernel[] ak =  new AltitudeMismatchKernel[indices.length]; 
		int [] pattern_sizes =         new int[indices.length];
		String [][]  pattern_labels =  new String[indices.length][];
		double [][][] corrs_out =      new double[indices.length][][]; 
		double [][][] corr_patterns =  new double[indices.length][][];
		int    [][][] icorr_patterns=  new int[indices.length][][]; // will only be used for main !
		
		int []        zoomout =        new int[indices.length];
		double [][]   bestcorr =       new double[indices.length][];
		double [][]   fullcorr =       new double[indices.length][];
		int [][]      bestpatt =       new int   [indices.length][];
		double []     min_corrs_full = new double[indices.length];
		ArrayList <ItemMatch> matches_list = new ArrayList <ItemMatch>();
		double []    adv_radii =             new double[indices.length];
		int    []    corr_radius =           new int [indices.length];
		for (int scene_num = 0; scene_num < indices.length; scene_num++) { // will probably just use first one, second - derivative
			gops[scene_num] = GroundObjectPattern.getPattern(
					omp.object_type, // String        object_type,
					ortho_maps[indices[scene_num]].getLocalDateTime(), // LocalDateTime utcDateTime,
					patterns); // ArrayList<GroundObjectPattern> patterns)
			if (gops[scene_num] == null) {
				System.out.println("Failed to find a pattern for object \""+omp.object_type+"\", aborting operation.");
				return null;
			}
			zoomout[scene_num] = 1;
			for (int i = zoom_level; i < gops[scene_num].getZoomLevel();i++) {
				zoomout[scene_num] *= 2;
			}
			adv_radii[scene_num] = omp.adv_radius/zoomout[scene_num];
			corr_radius[scene_num] = (int) (Math.sqrt(0.5)* adv_radii[scene_num]) -1 ;
			
			
			ImagePlus imp_pattern = new ImagePlus(gops[scene_num].getPatternPath());
			pattern_sizes[scene_num] =  imp_pattern.getWidth();
			if (pattern_sizes[scene_num] == 0) {
				System.out.println("testPatternCorrelate(): pattern \""+gops[scene_num].getPatternPath()+"\" is not found.");
				return null;
			}
			ImageStack stack_pattern = imp_pattern.getStack();
			int nSlices =       stack_pattern.getSize();
			patterns_all[scene_num] =   new double[nSlices][];
			pattern_labels[scene_num] = new String[nSlices];
			for (int k = 0; k < patterns_all[scene_num].length; k++) {
				pattern_labels[scene_num][k]=stack_pattern.getShortSliceLabel(k+1);
				float [] fpixels_pattern = (float[]) stack_pattern.getPixels(k+1);
				patterns_all[scene_num][k]=new double[fpixels_pattern.length];
				for (int i = 0; i < fpixels_pattern.length; i++) {
					patterns_all[scene_num][k][i] = fpixels_pattern[i];
				}
			}
			ak[scene_num] = AltitudeMismatchKernel.getKernel(
					gops[scene_num].getZoomLevel(), // zoom_level,       // int                               zoom_level,
					gops[scene_num].getAGL(), // double                            agl_from,
					ortho_maps[indices[scene_num]].getAGL(), // double                            agl_to,
					kernels); // ArrayList<AltitudeMismatchKernel> kernels)
			if (ak[scene_num] != null) {
				String kernel_path = ak[scene_num].getKernelPath();
				ImagePlus imp_kernel = new ImagePlus(kernel_path);
				if (imp_kernel.getWidth() > 0) {
					float [] kernel_pixels = (float[]) imp_kernel.getProcessor().getPixels();
					kernels_all[scene_num] = new double[kernel_pixels.length];
					for (int i = 0; i < kernel_pixels.length; i++) {
						kernels_all[scene_num][i] = kernel_pixels[i];
					}
				}
			}
			corrs_out[scene_num] =     new double[patterns_all[scene_num].length][]; 
			corr_patterns[scene_num] = new double[patterns_all[scene_num].length][];
			
			for (int n = 0; n < patterns_all[scene_num].length; n++) {
				if (omp.convolve_after) {
					corr_patterns[scene_num][n] = OrthoMap.patternZoomCropPad(
							patterns_all[scene_num][n],      // double [] pattern,
							pattern_sizes[scene_num],        // int       pattern_size,
							omp.corr_size,                       // int       size,
							zoomout[scene_num],              // int       zoomout,
							false);                          // out_normalize); // boolean   normalize) 
					if (kernels_all[scene_num] != null) {
						corr_patterns[scene_num][n] = OrthoMap.convolveWithKernel(
								corr_patterns[scene_num][n], // final double [] data,
								kernels_all[scene_num],      // final double [] kernel,
								omp.corr_size);                  // final int width)
					}
				} else {
					double [] pattern = patterns_all[scene_num][n].clone();
					if (kernels_all[scene_num] != null) {
						pattern = OrthoMap.convolveWithKernel(
								pattern,                 // final double [] data,
								kernels_all[scene_num],  // final double [] kernel,
								pattern_sizes[scene_num]);              // final int width)
					}
					corr_patterns[scene_num][n] = OrthoMap.patternZoomCropPad(
							pattern,                     // double [] pattern,
							pattern_sizes[scene_num],    // int       pattern_size,
							omp.corr_size,                   // int       size,
							zoomout[scene_num],          // int       zoomout,
							false);                      // out_normalize); // boolean   normalize) 
				}
			}
			if (scene_num == 0) {
				boolean debug = false; // debugLevel > 0; // 1;
				icorr_patterns[scene_num] =  OrthoMap.getIntPatterns(
						corr_patterns[scene_num], // double [][] patterns,
						omp.abs_edge_frac,                // double edge_frac, // 0.15
						omp.abs_oversize,                 // double oversize,
						debug);                       // boolean debug);
			}
			// so far contrast is only for the main scene
			if ((debugLevel > -1) && (omp.show_images || omp.save_images) && (scene_num == 0)) {
				String [] pattern_titles = new String[corr_patterns[scene_num].length];
				for (int i = 0; i < pattern_titles.length; i++) {
					pattern_titles[i] = "patt-"+i;
				}
				ImagePlus imp = ShowDoubleFloatArrays.makeArrays(
						corr_patterns[scene_num],
						omp.corr_size,
						omp.corr_size,
						"pattern-"+scene_num+"_"+omp.corr_size+"x"+omp.corr_size+(omp.convolve_after?"_convolved_after":"_convolved_before"),
						pattern_titles);
			    showSaveImagePlus(
			    		imp,         // ImagePlus imp,
			    		omp.show_images, // boolean   show,
			    		omp.save_images, // boolean   save,
			    		omp.save_dir,    // String    save_dir,
			            debugLevel); // int       debugLevel)
				double [][] dbg_img = new double [icorr_patterns[scene_num].length][icorr_patterns[scene_num][0].length];
				for (int n = 0; n < dbg_img.length; n++) {
					for (int i= 0; i < dbg_img[n].length; i++) if (icorr_patterns[scene_num][n][i] != 0){
						switch (icorr_patterns[scene_num][n][i]) {
						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;
						}
					}
				}
				ImagePlus imp1 = ShowDoubleFloatArrays.makeArrays(
						dbg_img,
						omp.corr_size,
						omp.corr_size,
						"integer_patterns",
						pattern_titles);
			    showSaveImagePlus(
			    		imp1,         // ImagePlus imp,
			    		omp.show_images, // boolean   show,
			    		omp.save_images, // boolean   save,
			    		omp.save_dir,    // String    save_dir,
			            debugLevel); // int       debugLevel)
			}
		}
		
		// Splitting - above done for both scenes, below - just for the main one
		int scene_num = 0;
		double hi_lo_freq = 0.0;
		double [][] hi_freq_arr = null;
		int []  hi_freq_wh = new int[2];
		{
			// Just testing for now
			int shrink_sel = 4;
			double spectrum_sigma = 2.0;
			int blank_xy = (int) Math.round(spectrum_sample[1]);
			double [][] hi_freq = OrthoMap.getHiFreqCirc(
					dmulti[scene_num],  // final double [] data,
					width,              // final int       width,
					omp.corr_size,          // final int       size,      // power of 2, such as 64
					spectrum_sample[0], // final double    center_period,// center frequency is size/center_period
					spectrum_sample[1], // final double    range_period, // ~1.5 - from center/range to center*range
					blank_xy,           // final int       blank_xy, //
					hi_freq_wh,         // final int []    wh,           // result size
					debugLevel);        // final int       debugLevel);
			hi_freq_arr = new double [4][hi_freq.length];
			for (int i = 0; i < hi_freq_arr.length; i++) {
				Arrays.fill(hi_freq_arr[i], Double.NaN);
			}
			for (int i = 0; i < hi_freq.length;i++) if (hi_freq[i] != null) {
				hi_freq_arr[2][i] = hi_freq[i][0];
				hi_freq_arr[3][i] = hi_freq[i][1];
				hi_freq_arr[1][i] = hi_freq[i][1]/hi_freq[i][0];
			}
			
			hi_freq_arr[0] = hi_freq_arr[1].clone();
			TileNeibs tn =  new TileNeibs(hi_freq_wh[0],hi_freq_wh[1]); 
			OrthoMap.fillNaNs(
					hi_freq_arr[0], // double [] data,
					tn, // TileNeibs tn,
					3); // int min_neibs)
			(new DoubleGaussianBlur()).blurDouble(
					hi_freq_arr[0], // double[] pixels,
					hi_freq_wh[0], // int width,
					hi_freq_wh[1], // int height,
					spectrum_sigma, // double sigmaX,
					spectrum_sigma, // double sigmaY,
					0.01); // double accuracy);
			boolean [] mask = new boolean[hi_freq.length];
			for (int i = 0; i < mask.length;i++) {
				mask[i] = hi_freq[i] != null;
			}
			tn.shrinkSelection(
					shrink_sel, // final int        shrink,           // grow tile selection by 1 over non-background tiles 1: 4 directions, 2 - 8 directions, 3 - 8 by 1, 4 by 1 more
					mask,       // final boolean [] tiles,  
					null);      // final boolean [] prohibit)
			double swd = 0.0, sw = 0.0;
			for (int i = 0; i < mask.length;i++) if (mask[i]){
				swd += hi_freq[i][1]/hi_freq[i][0];
				sw+= 1.0;
			}
			hi_lo_freq = swd/sw;
			String [] hi_freq_titles = {"blur","ratio","low","high"};
			ImagePlus img_hi_freq = ShowDoubleFloatArrays.makeArrays(
					hi_freq_arr,
					hi_freq_wh[0],
					hi_freq_wh[1],
//					indices[scene_num]+"-"+ortho_maps[indices[scene_num]].getName()+"-HIGH_FREQ",
					basename+"-HIGH_FREQ", // 
					hi_freq_titles);
			showSaveImagePlus(
					img_hi_freq,         // ImagePlus imp,
					omp.show_images, // boolean   show,
					omp.save_images, // boolean   save,
					omp.save_dir,    // String    save_dir,
					debugLevel); // int       debugLevel)
			
			System.out.println("Average hi_lo_freq="+hi_lo_freq);
			System.out.println();
		}
		
		
		corrs_out[scene_num] = correlateAllPatterns(
				dmulti[scene_num],           // double []    data,
				width,                       // int          width,
				omp.corr_size,                   // int          corr_size,    
				corr_patterns[scene_num],    // double [][]  patterns,  
				false,                       // boolean      convolve, 
				omp.phaseCoeff[scene_num],       // double       phaseCoeff,
				omp.lpf_sigma[scene_num],        //double       lpf_sigma,
				src_marks,                   // double [][]  src_marks,
				ortho_maps[indices[scene_num]].getName(), // String       prefix, // ortho_maps[indices[scene_num]].getName()
				omp.save_dir,                    // String       save_dir,
				omp.show_images,                 // boolean      show,
				omp.save_images,                 // boolean      save,
				debugLevel);                 // int          debugLevel)
		bestcorr[scene_num] = new double [dmulti[scene_num].length];
		fullcorr[scene_num] = new double [dmulti[scene_num].length];
		bestpatt[scene_num] = new int [bestcorr[scene_num].length];
		min_corrs_full[scene_num] = omp.min_corrs[scene_num] * omp.min_corr_full_rel;

		// TODO: scale adv_radius, corr_radius
		ArrayList<Point> plist =OrthoMap.combineDirCorrs (
				corrs_out[scene_num],      // final double [][] corrs,
				width,                     // final int         width,
				fullcorr[scene_num],       // final double []   fullcorr_in,
				bestcorr[scene_num],       // final double []   bestcorr_in
				bestpatt[scene_num],       // final int []      bestpatt_in,
				ease_first_best*omp.min_corrs[scene_num],      // final double      min_corr,
				min_corrs_full[scene_num], // final double      min_corr_full,
				omp.full_preference,           // final double      full_preference,
				omp.max_min_ratio,             // final double      max_min_ratio,
				omp.combine_full[0],           // final boolean     combine_full,    // multiply by normalized full pattern correlation maximum
				adv_radii[scene_num],      // final double      adv_radius,
				corr_radius[scene_num]);   // final int         corr_radius)

		for (Point p : plist) {
			double [] matches = new double [corrs_out[scene_num].length + 1];
			double [] match_xy = {p.x%width, p.x/width}; // here int values
			int    best_patt = p.y + 1;
			matches[0] = bestcorr[scene_num][p.x];
			for (int i = 1; i < matches.length; i++) {
				matches[i] = corrs_out[scene_num][i-1][p.x];
			}
			ItemMatch item_match = new ItemMatch (
					indices.length,
					match_xy); 
			item_match.addPatternMatches(
					gops[scene_num],        // GroundObjectPattern groundObjectPattern,
					matches,    // double [] matches,
					best_patt); // int      best_sub);
			matches_list.add(item_match);
		}
///		int sort_pattern_index = 0; // used in other places, not just for sorting
		int sort_pattern_mode = sort_by_best? -1 : 0; // -1 - best match, regardles off best pointer 0; //combo. 1 - full pattern
		ArrayList<Integer> match_sort =  ItemMatch.sortByMatch(
				matches_list,        // ArrayList<ItemMatch> match_list,
				gops[scene_num],
				false,               // boolean              keep_removed,// GroundObjectPattern groundObjectPattern,
				sort_pattern_mode); // int indx)
		// Print all results
		String log_lines = "\n====="+
		(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(Calendar.getInstance().getTime())+
				"=====\n");
		log_lines += "Match candidates ("+match_sort.size()+
				") that exceed minimal correlation strength of "+omp.min_corrs[scene_num]+"\n";
		
		System.out.println("Match candidates ("+match_sort.size()+
				") that exceed minimal correlation strength of "+omp.min_corrs[scene_num]);
		// remove non-overlapped from the list
		int num_non_overlap = 0;
		for (int i = match_sort.size()-1; i >=0; i--) {
			int indx =match_sort.get(i);
			ItemMatch match = matches_list.get(indx);
			int [] icenter_xy = match.getIntXY();
			for (int sn = 1; sn < indices.length; sn++) {
				if (Double.isNaN(dmulti[sn][icenter_xy[0] + icenter_xy[1] * width])) {
					match.remove();       // mark as removed
					match_sort.remove(i); // remove from index list
					log_lines += "Removed object at x="+icenter_xy[0]+", y="+icenter_xy[1]+
							" as it is not in the scenes overlap area\n";
					if (debugLevel > -1) {
						System.out.println("Removed object at x="+icenter_xy[0]+", y="+icenter_xy[1]+
								" as it is not in the scenes overlap area");
					}
					num_non_overlap++;
					break;
				}
			}
		}

		// near the edge - check both images
		for (int i = match_sort.size()-1; i >=0; i--) {
			int indx =match_sort.get(i);
			ItemMatch match = matches_list.get(indx);
			int [] icenter_xy = match.getIntXY();
			boolean has_NaN = true;
			seach_NaN: {
				int half_size=omp.corr_size/2;
				if  ((icenter_xy[0] < half_size) || (icenter_xy[1] < half_size) ||
						(icenter_xy[0] > (width - half_size)) || (icenter_xy[1] > (height - half_size))) {
					break seach_NaN;								
				}
				for (int y = (icenter_xy[1] - half_size); y < (icenter_xy[1] + half_size); y++) {
					int indx0 = y * width;
					for (int dy =- half_size; dy < half_size; dy++) {
						for (int x = (icenter_xy[0] - half_size); x < (icenter_xy[0] + half_size); x++) {
							int indx1 = indx0 + x;
							for (int sn = 0; sn < indices.length; sn++) {
								if (Double.isNaN(dmulti[sn][indx1])) {
									break seach_NaN;								
								}
							}
						}
					}

				}
				has_NaN = false;
			}
			if (has_NaN) {
				match.remove();       // mark as removed
				match_sort.remove(i); // remove from index list
				log_lines += "Removed object at x="+icenter_xy[0]+", y="+icenter_xy[1]+
						" as it is near the edge of one of the images\n";
				
				if (debugLevel > -1) {
					System.out.println("Removed object at x="+icenter_xy[0]+", y="+icenter_xy[1]+
							" as it is near the edge of one of the images");
				}
				num_non_overlap++;
			}
		}

		if (num_non_overlap > 0) {
			log_lines += "Removed "+num_non_overlap+" objects outside of the scenes overlap, "+
					match_sort.size()+" remain\n";
			System.out.println("Removed "+num_non_overlap+" objects outside of the scenes overlap, "+
					match_sort.size()+" remain");
		}
		
		if (omp.append_log) { // starting log with a date/time separator
			String log_path = omp.save_dir+basename+OrthoMapsParameters.LOG_SUFFIX;
			CalibrationFileManagement.saveStringToFile (
					log_path,      //String path,
					log_lines, // data,
					true);         // boolean append)
		}
		double [] scene_xy_offset =   {centers[last_scene][0]-centers[0][0],centers[last_scene][1]-centers[0][1]};
		double    scene_agl = gops[last_scene].getAGL(); // second scene agl
		
		omp.generateReport( // only goes to log
				null,                        // String                log_line, // should end with \n or be null
				false,                       // boolean               show, // ands with .show_images
				false,                       // boolean               save, // ands with .save_images
				true,                        // boolean               gen_results,
				false,                       // boolean               gen_parameters,
				ortho_maps,                  // OrthoMap []           ortho_maps,			
				new int [] {indices[0]},     // int []                indices,
				match_sort,                  // ArrayList<Integer>    match_sort,
				matches_list,                // ArrayList <ItemMatch> matches_list,
				zoom_level,                  // int                   zoom_level,
				scene_xy_offset,             // double []             scene_xy_offset,
				scene_agl,                   // double                scene_agl,
				corrs_out[scene_num].length, // int                   num_patterns, // corrs_out[scene_num].length
				origin,                      // int []                origin,
				centers,                     // double [][]           centers,
				gops[scene_num],             // GroundObjectPattern   gop,
				hi_lo_freq,                  // double                hi_lo_freq,
				hi_freq_wh,                  // int []                hi_freq_wh,
				hi_freq_arr);                // double [][]           hi_freq_arr,
		if (debugLevel > 0) { 
			omp.printReport(
					true,                        // boolean               gen_results,
					false,                       // boolean               gen_parameters,
					ortho_maps,                  // OrthoMap []           ortho_maps,			
					new int [] {indices[0]},     // int []                indices,
					match_sort,                  // ArrayList<Integer>    match_sort,
					matches_list,                // ArrayList <ItemMatch> matches_list,
					zoom_level,                  // int                   zoom_level,
					scene_xy_offset,             // double []             scene_xy_offset,
					scene_agl,                   // double                scene_agl,
					corrs_out[scene_num].length, // int                   num_patterns, // corrs_out[scene_num].length
					origin,                      // int []                origin,
					centers,                     // double [][]           centers,
					gops[scene_num],             // GroundObjectPattern   gop,
					hi_lo_freq,                  // double                hi_lo_freq,
					hi_freq_wh,                  // int []                hi_freq_wh,
					hi_freq_arr);                // double [][]           hi_freq_arr,
		}
		PointRoi roi = new PointRoi();
		roi.setOptions("nolabel"); // label");
		for (int mn=0; mn < match_sort.size(); mn++) {
			roi.addPoint(omp.extr_size/2,omp.extr_size/2,mn+1); // ,1);
		}

		// Extract main scene areas around candidates
		ItemMatch.setExtractedObjects(
				scene_num,          // int                   scene_num,
				omp.extr_size,          // int                   extr_size,
				gops[scene_num],    //GroundObjectPattern   gop,
				matches_list,       // ArrayList <ItemMatch> matches_list,
				match_sort,         // ArrayList<Integer>    match_sort,
				dmulti[scene_num],  // double[]              data,
				width,              // int                   width,
				debugLevel);        // int                   debugLevel)
		// calculate absolute contrasts for all patterns, update best_sub modes: 0 - keep, 1 - keep type, 2 keep type and if half +/-1,
		// 3 - free, 4 - force round objects. This may change best subpattern and should be reflected by filters. Maybe even reorder candidates?
		if (omp.corr_centered) { // re-evaluate correlations centered, recreate and reorder list
			log_lines = "";
			
			for (int mn=0; mn < match_sort.size(); mn++) {
				int indx =match_sort.get(mn);
				ItemMatch match = matches_list.get(indx);
				double [] center_xy = match.getXY();
				// correlate each extracted object with all patterns, save to corrs_out_centered
				// get correlation for the pattern[0] and re-center if needed
				//						CorrelationPeakStats[] filter_data = new CorrelationPeakStats[2];
				double [] corrs_centered = OrthoMap.correlateWithPattern(
						match.extracted_nodc[scene_num],     // extr_data[mn],                       // final double [] data,
						omp.corr_size,                           // final int       width,
						omp.corr_size,                           // final int       psize,      // power of 2, such as 64
						corr_patterns[scene_num][0], // final double [] pattern,    // [psize*psize]
						false,                               // final boolean   convolve,   // convolve, not correlate
						omp.phaseCoeff[scene_num],               // final double    phaseCoeff,
						omp.lpf_sigma[scene_num],                // final double    lpf_sigma, // 0 - do not filter
						debugLevel);                         // final int       debugLevel) {
				match.setCorrFull(
						scene_num, // int scene_num,
						corr_patterns[scene_num].length, // int num_patt,
						corrs_centered); // double [] corr_data)
				match.filter_data[scene_num][0] = new CorrelationPeakStats( // null pointer
						match.getCorr(scene_num,0),
						// corrs_centered, // double [] data, // square data
						null,                      // double [] cent_xy, // if null, use center of the square
						search_radius_recenter,    // search_radius,            // double    radius, // search for maximum within this radius. Should radius be 0 here?
						omp.filt_frac_max,                  // double    frac_max)
						0,                         // filt_other_rad,           // double    other_radius,
						debugLevel);
				double [] matches = new double [corr_patterns[scene_num].length + 1];
				int best_indx = 0;
				if (Double.isNaN(match.filter_data[scene_num][0].best_d)) {
					log_lines += "Could not find recentered maximum for ["+center_xy[0]+"/"+center_xy[1]+
							"], removing this peak.\n";
					if (debugLevel > -4) {
						System.out.println("Could not find recentered maximum for ["+center_xy[0]+"/"+center_xy[1]+
								"], removing this peak.");
					}
					// will add fake with all 0
				} else {
					//							double [] cent_offs = filter_data[0].cent_offs;
					double [] cent_offs = match.filter_data[scene_num][0].cent_offs;
					int [] old_xy = new int [] {(int) Math.round(center_xy[0]), (int) Math.round(center_xy[1])};
					center_xy[0]+=cent_offs[0];
					center_xy[1]+=cent_offs[1];
					int [] new_xy = new int [] {(int) Math.round(center_xy[0]), (int) Math.round(center_xy[1])};
					match.setComboPXY(center_xy); // update center
					if ((new_xy[0] != old_xy[0]) || (new_xy[1] != old_xy[1])) {
						log_lines += "Centered object position shifted from ["+old_xy[0]+"/"+old_xy[1]+
								"], to ["+new_xy[0]+"/"+new_xy[1]+"], rebuilding extracts.\n";
						if (debugLevel > -4) {
							System.out.println("Centered object position shifted from ["+old_xy[0]+"/"+old_xy[1]+
									"], to ["+new_xy[0]+"/"+new_xy[1]+"], rebuilding extracts.");
						}
						match.extractObject(
								dmulti[scene_num], // double [] data,
								width,             // int       width,
								scene_num,         // int       scene_num,
								omp.extr_size);        // int       extr_size);

						corrs_centered = OrthoMap.correlateWithPattern(
								match.extracted_nodc[scene_num],     // final double [] data,
								omp.corr_size,                           // final int       width,
								omp.corr_size,                           // final int       psize,      // power of 2, such as 64
								corr_patterns[scene_num][0], // final double [] pattern,    // [psize*psize]
								false,                               // final boolean   convolve,   // convolve, not correlate
								omp.phaseCoeff[scene_num],               // final double    phaseCoeff,
								omp.lpf_sigma[scene_num],                // final double    lpf_sigma, // 0 - do not filter
								debugLevel);                         // final int       debugLevel) {
						match.setCorr (
								scene_num,       // int scene_num,
								0,               // int patt_index,
								corrs_centered); // double [] corr_data)


					}
					// calculate correlations for the rest of patterns
					for (int patt_indx = 1; patt_indx < corr_patterns[scene_num].length; patt_indx++) {
						corrs_centered = OrthoMap.correlateWithPattern(
								match.extracted_nodc[scene_num],     // final double [] data,
								omp.corr_size,                           // final int       width,
								omp.corr_size,                           // final int       psize,      // power of 2, such as 64
								corr_patterns[scene_num][patt_indx], // final double [] pattern,    // [psize*psize]
								false,                               // final boolean   convolve,   // convolve, not correlate
								omp.phaseCoeff[scene_num],               // final double    phaseCoeff,
								omp.lpf_sigma[scene_num],                // final double    lpf_sigma, // 0 - do not filter
								debugLevel);                         // final int       debugLevel) {
						match.setCorr (
								scene_num,       // int scene_num,
								patt_indx,       // int patt_index,
								corrs_centered); // double [] corr_data)
					}
					double [][] corrs_all = match.getCorrs(
							scene_num); // int scene_num);
					int cent_indx = (omp.corr_size+1)*omp.corr_size/2;
					double best_v = corrs_all[1][cent_indx]; 
					double worst_v = best_v;
					double full_v = corrs_all[0][cent_indx];
					best_indx=1;
					for (int patt_indx = 2; patt_indx < corrs_all.length; patt_indx++) {
						if (corrs_all[patt_indx][cent_indx] > best_v) {
							best_v=corrs_all[patt_indx][cent_indx];
							best_indx = patt_indx;
						}
						if (corrs_all[patt_indx][cent_indx] < worst_v) {
							worst_v = corrs_all[patt_indx][cent_indx];
						}
					}
					if (full_v * omp.full_preference > best_v) {
						best_indx = 0;
					} else {
						if ((worst_v > 0) && (best_v/worst_v < omp.max_min_ratio)) {
							best_indx = 0;
						}
					}
					matches[0] = corrs_all[best_indx][cent_indx];
					for (int i = 1; i < matches.length; i++) {
						matches[i] = corrs_all[i-1][cent_indx];
					}
				}
				// select best pattern similar to combineDirCorrs(), using center pixel
				// add to a new list (and then replace main list and reorder?)
				//matches_list_centered
				match.addPatternMatches(  // will update existing match too
						gops[scene_num],  // GroundObjectPattern groundObjectPattern,
						matches,          // double [] matches,
						best_indx + 1);   // int      best_sub);

			} // for (int mn=0; mn < match_sort.size(); mn++) {
			// some matches are already marked as removed
			match_sort =  ItemMatch.sortByMatch(
					matches_list,        // ArrayList<ItemMatch> match_list,
					gops[scene_num],     // GroundObjectPattern groundObjectPattern,
					false,               // boolean              keep_removed,// GroundObjectPattern groundObjectPattern,
					sort_pattern_mode);  // int indx)
			// Print all results
			log_lines += "Centered match candidates ("+match_sort.size()+")\n";

			System.out.println("Centered match candidates ("+match_sort.size()+
					")"); // +min_corrs[scene_num]);
			if (omp.append_log) { // starting log with a date/time separator
				String log_path = omp.save_dir+basename+OrthoMapsParameters.LOG_SUFFIX;
				CalibrationFileManagement.saveStringToFile (
						log_path,      //String path,
						log_lines, // data,
						true);         // boolean append)
			}
			
			
			// print updated list
			omp.generateReport( // only goes to log
					null,                        // String                log_line, // should end with \n or be null
					false,                       // boolean               show, // ands with .show_images
					false,                       // boolean               save, // ands with .save_images
					true,                        // boolean               gen_results,
					false,                       // boolean               gen_parameters,
					ortho_maps,                  // OrthoMap []           ortho_maps,			
					new int [] {indices[0]},     // int []                indices,
					match_sort,                  // ArrayList<Integer>    match_sort,
					matches_list,                // ArrayList <ItemMatch> matches_list,
					zoom_level,                  // int                   zoom_level,
					scene_xy_offset,             // double []             scene_xy_offset,
					scene_agl,                   // double                scene_agl,
					corrs_out[scene_num].length, // int                   num_patterns, // corrs_out[scene_num].length
					origin,                      // int []                origin,
					centers,                     // double [][]           centers,
					gops[scene_num],             // GroundObjectPattern   gop,
					hi_lo_freq,                  // double                hi_lo_freq,
					hi_freq_wh,                  // int []                hi_freq_wh,
					hi_freq_arr);                // double [][]           hi_freq_arr,
			if (debugLevel > 0) { 
				omp.printReport(
						true,                        // boolean               gen_results,
						false,                       // boolean               gen_parameters,
						ortho_maps,                  // OrthoMap []           ortho_maps,			
						new int [] {indices[0]},     // int []                indices,
						match_sort,                  // ArrayList<Integer>    match_sort,
						matches_list,                // ArrayList <ItemMatch> matches_list,
						zoom_level,                  // int                   zoom_level,
						scene_xy_offset,             // double []             scene_xy_offset,
						scene_agl,                   // double                scene_agl,
						corrs_out[scene_num].length, // int                   num_patterns, // corrs_out[scene_num].length
						origin,                      // int []                origin,
						centers,                     // double [][]           centers,
						gops[scene_num],             // GroundObjectPattern   gop,
						hi_lo_freq,                  // double                hi_lo_freq,
						hi_freq_wh,                  // int []                hi_freq_wh,
						hi_freq_arr);                // double [][]           hi_freq_arr,
			}
		} else { // reuse already calculated correlations
			for (int mn=0; mn < match_sort.size(); mn++) {
				int indx =match_sort.get(mn);
				ItemMatch match = matches_list.get(indx);
				match.extractCorrs( // copy all 9 layers
						corrs_out[scene_num], // double [][] corr_data,
						width, // int         width,
						scene_num, // int         scene_num,
						omp.extr_size); // int         extr_size)
			}
		}

		setAbsoluteContrasts( // move later than corr_centered
				omp,                       // OrthoMapsParameters   omp
				gops[scene_num],           // GroundObjectPattern   gop,
				matches_list,              // ArrayList <ItemMatch> matches_list,
				match_sort,                // ArrayList<Integer>    match_sort,
				scene_num,                 // int                   scene_num,
				icorr_patterns[scene_num], // int [][]              ipatterns,
				debugLevel); // int                   debugLevel

		for (int mn=0; mn < match_sort.size(); mn++) {
			int indx =match_sort.get(mn);
			ItemMatch match = matches_list.get(indx);
			// should be already updated by setAbsoluteContrasts();
			int best_patt = match.getPatternMatch(gops[scene_num]).getBestSub() - 1;
			//					double [] center_xy = match.getXY();
			match.filter_data[scene_num][0] = new CorrelationPeakStats( // null pointer
					match.getCorr(scene_num,0),// corrs_centered, // double [] data, // square data
					null,                      // double [] cent_xy, // if null, use center of the square
					omp.search_radius,             // search_radius,            // double    radius, // search for maximum within this radius. Should radius be 0 here?
					omp.filt_frac_max,                  // double    frac_max)
					omp.filt_other_rad,            // filt_other_rad,           // double    other_radius,
					debugLevel);

			match.setCorrHalf(
					scene_num, // int scene_num,
					best_patt, // int     best_patt,
					omp.combine_full[0]); // boolean combine_full) {

			match.filter_data[scene_num][1] = new CorrelationPeakStats(
					match.getCorrHalf(scene_num), // double [] data, // square data
					null,                         // double [] cent_xy, // if null, use center of the square
					omp.search_radius,                // double    radius, // search for maximum within this radius. Should radius be 0 here?
					omp.filt_frac_max,                     // double    frac_max)
					omp.filt_other_rad,               // double    other_radius,
					debugLevel);                  // final int       debugLevel) {
		}

		boolean               show_centers = true;
		if (indices.length == 1) { // for a single-scene show before filtering by the first(only) scene
			for (int sn = 0; sn < indices.length; sn++) {
				String prefix = ortho_maps[indices[sn]].getName()+"-prefilter1";
				String suffix0 = "_pc"+omp.phaseCoeff[sn]+"_lpf"+omp.lpf_sigma[sn];
				for (int mode = 0; mode < 4; mode++) { // all 4 image types
					String suffix = (mode <2)? "":suffix0;
					if ((sn == 0) || (mode == 0)) {
						ItemMatch.getImageExtracts(
								prefix,          // String                prefix, // include PC, filter here
								suffix,          // String                suffix, // w/o .tiff
								omp.show_images,     // boolean               show,
								omp.save_images,     // boolean               save,
								false,           // boolean               show_removed,
								omp.save_dir,        // String                save_dir,
								sn,              // int                   scene_num,
								omp.remove_dc,       // boolean               nodc,
								mode,            // int                   mode, // 0 - extract, 1 - masked, 2 - corr full, 3 - corr half
								show_centers,    // boolean               show_centers,
								omp.extr_size,       // int                   extr_size,
								gops[scene_num], // GroundObjectPattern   gop,
								matches_list,    // ArrayList <ItemMatch> matches_list,
								match_sort,      // ArrayList<Integer>    match_sort,
								debugLevel);     // int                   debugLevel)
					}
				}
			}
		}
		if (!omp.filt_atonce) { // first filter using scene 1 only
			boolean[] filt_main_other = new boolean [indices.length]; //{true,false};
			filt_main_other[0] = true;
			int num_removed = filterCandidates(
					omp,                // OrthoMapsParameters   omp,
					basename,           // String                basename,
					filt_main_other,    // new boolean []        filt_main_other,
					gops[scene_num],    // GroundObjectPattern   gop,
					zoom_level,         // int       zoom_level,
					scene_agl,          // double                scene_agl,
					scene_xy_offset,    // double []             scene_xy_offset, //second scene vertical projection offset from the first scene
					matches_list,       // ArrayList <ItemMatch> matches_list,
					match_sort,         // ArrayList<Integer>    match_sort,
					debugLevel);        // int                   debugLevel )
//			if (!filt_keep_pre && (removed.length > match_sort.size())) { // decimate data arrays
//				removed = new boolean [match_sort.size()];
//			}
		}
		if (indices.length > 1) { // for a multi-scene show after filtering by the first scene
			// here extract for the second scene
			for (int sn = 1; sn < indices.length; sn++) {
				ItemMatch.setExtractedObjects(
						sn,           // int                   scene_num,
						omp.extr_size,    // int                   extr_size,
						gops[sn],     // GroundObjectPattern   gop,
						matches_list, // ArrayList <ItemMatch> matches_list,
						match_sort,   // ArrayList<Integer>    match_sort,
						dmulti[sn],   // double[]              data,
						width,        // int                   width,
						debugLevel);  // int                   debugLevel)
			}					

			for (int sn = 0; sn < indices.length; sn++) {
				String prefix = ortho_maps[indices[sn]].getName()+"-postfilter1";
				String suffix0 = "_pc"+omp.phaseCoeff[sn]+"_lpf"+omp.lpf_sigma[sn];
				for (int mode = 0; mode < 4; mode++) { // all 4 image types
					String suffix = (mode <2)? "":suffix0;
					if ((sn == 0) || (mode == 0)) {
						ItemMatch.getImageExtracts(
								prefix,          // String                prefix, // include PC, filter here
								suffix,          // String                suffix, // w/o .tiff
								omp.show_images,     // boolean               show,
								omp.save_images,     // boolean               save,
								false,           // boolean               show_removed,
								omp.save_dir,        // String                save_dir,
								sn,              // int                   scene_num,
								omp.remove_dc,       // boolean               nodc,
								mode,            // int                   mode, // 0 - extract, 1 - masked, 2 - corr full, 3 - corr half
								show_centers,    // boolean               show_centers,
								omp.extr_size,       // int                   extr_size,
								gops[scene_num], // GroundObjectPattern   gop,
								matches_list,    // ArrayList <ItemMatch> matches_list,
								match_sort,      // ArrayList<Integer>    match_sort,
								debugLevel);     // int                   debugLevel)
					}
				}
			}
		}
		// display extracted correlations for the main scene:
		if (indices.length > 1) {
			// print updated table after some scenes may be removed by the filter
			omp.generateReport( // only goes to log
					"\nAfter first scene filtering:\n", // String                log_line, // should end with \n or be null
					false,                       // boolean               show, // ands with .show_images
					false,                       // boolean               save, // ands with .save_images
					true,                        // boolean               gen_results,
					false,                       // boolean               gen_parameters,
					ortho_maps,                  // OrthoMap []           ortho_maps,			
					new int [] {indices[0]},     // int []                indices,
					match_sort,                  // ArrayList<Integer>    match_sort,
					matches_list,                // ArrayList <ItemMatch> matches_list,
					zoom_level,                  // int                   zoom_level,
					scene_xy_offset,             // double []             scene_xy_offset,
					scene_agl,                   // double                scene_agl,
					corrs_out[scene_num].length, // int                   num_patterns, // corrs_out[scene_num].length
					origin,                      // int []                origin,
					centers,                     // double [][]           centers,
					gops[scene_num],             // GroundObjectPattern   gop,
					hi_lo_freq,                  // double                hi_lo_freq,
					hi_freq_wh,                  // int []                hi_freq_wh,
					hi_freq_arr);                // double [][]           hi_freq_arr,
			if (debugLevel > 0) { 
				System.out.println("\nAfter first scene filtering:");
				omp.printReport(
						true,                        // boolean               gen_results,
						false,                        // boolean               gen_parameters,
						ortho_maps,                  // OrthoMap []           ortho_maps,			
						new int [] {indices[0]},     // int []                indices,
						match_sort,                  // ArrayList<Integer>    match_sort,
						matches_list,                // ArrayList <ItemMatch> matches_list,
						zoom_level,                  // int                   zoom_level,
						scene_xy_offset,             // double []             scene_xy_offset,
						scene_agl,                   // double                scene_agl,
						corrs_out[scene_num].length, // int                   num_patterns, // corrs_out[scene_num].length
						origin,                      // int []                origin,
						centers,                     // double [][]           centers,
						gops[scene_num],             // GroundObjectPattern   gop,
						hi_lo_freq,                  // double                hi_lo_freq,
						hi_freq_wh,                  // int []                hi_freq_wh,
						hi_freq_arr);                // double [][]           hi_freq_arr,
			}
		}

		// Correlate second scene only for selected fragments
		for (int scene_other = 1; scene_other < indices.length; scene_other++) { // normally just 1
			for (int mn=0; mn < match_sort.size(); mn++) {
				int indx =match_sort.get(mn);
				ItemMatch match = matches_list.get(indx);
				int best_patt = match.getPatternMatch(gops[scene_num]).getBestSub() - 1;
				// correlate extracted squares of the other scene with full pattern 
				double [] corr_full = OrthoMap.correlateWithPattern(
						match.extracted_nodc[scene_other],   // extr_data[mn],                       // final double [] data,
						omp.corr_size,                           // final int       width,
						omp.corr_size,                           // final int       psize,      // power of 2, such as 64
						corr_patterns[scene_other][0],       // final double [] pattern,    // [psize*psize]
						false,                               // final boolean   convolve,   // convolve, not correlate
						omp.phaseCoeff[scene_other],             // final double    phaseCoeff,
						omp.lpf_sigma[scene_other],              // final double    lpf_sigma, // 0 - do not filter
						debugLevel);                         // final int       debugLevel) {
				// set [9] array of correlations and copy full pattern ([0]) data. Other (1-9) will not be used
				// for scene_other 
				match.setCorrFull(
						scene_other,                         // int scene_num,
						corr_patterns[scene_other].length,   // int num_patt,
						corr_full);                     // double [] corr_data)

				match.filter_data[scene_other][0] = new CorrelationPeakStats( // null pointer
						match.getCorr(scene_other,0),        // double [] data, // square data
						null,                                // double [] cent_xy, // if null, use center of the square
						omp.search_radius,                       // search_radius,            // double    radius, // search for maximum within this radius. Should radius be 0 here?
						omp.filt_frac_max,                            // double    frac_max)
						omp.filt_other_rad,                      // double    other_radius,
						debugLevel);
				if (best_patt > 0) { // not full match - for full match it will copy full correlation
					double [] corr_half = OrthoMap.correlateWithPattern(
							match.extracted_nodc[scene_other],     // extr_data[mn],                       // final double [] data,
							omp.corr_size,                             // final int       width,
							omp.corr_size,                             // final int       psize,      // power of 2, such as 64
							corr_patterns[scene_other][best_patt], // final double [] pattern,    // [psize*psize]
							false,                                 // final boolean   convolve,   // convolve, not correlate
							omp.phaseCoeff[scene_other],               // final double    phaseCoeff,
							omp.lpf_sigma[scene_other],                // final double    lpf_sigma, // 0 - do not filter
							debugLevel);                           // final int       debugLevel) {
					// setting only one correlation of 8 halves 
					match.setCorr (
							scene_other,     // int scene_num,
							best_patt,       // int patt_index,
							corr_half);      // double [] corr_data)
				}
				// Do it in any case, if best_patt==0 it will copy, optionally limit by 0 and square full correlation
				match.setCorrHalf( // D
						scene_other, // int scene_num,
						best_patt, // int     best_patt,
						omp.combine_full[1]); // boolean combine_full) {
				// set statistics for half-correlations of the second scene
				// before it was just a copy of full, regardless of combine_full[1]
				match.filter_data[scene_other][1] = new CorrelationPeakStats(
						match.getCorrHalf(scene_other), // double [] data, // square data
						null,                           // double [] cent_xy, // if null, use center of the square
						omp.search_radius,                  // double    radius, // search for maximum within this radius. Should radius be 0 here?
						omp.filt_frac_max,                       // double    frac_max)
						omp.filt_other_rad,                 // double    other_radius,
						debugLevel);                    // final int       debugLevel) {
			}
			// show correlations for the second scene
			String prefix = ortho_maps[indices[scene_num]].getName()+"-postfilter1";
			String suffix0 = "_pc"+omp.phaseCoeff[scene_other]+"_lpf"+omp.lpf_sigma[scene_other];
			for (int mode = 2; mode < 4; mode++) { // all 2 correlation types (full and half)
				String suffix = (mode < 2)? "":suffix0;
				ItemMatch.getImageExtracts(
						prefix,          // String                prefix, // include PC, filter here
						suffix,          // String                suffix, // w/o .tiff
						omp.show_images,     // boolean               show,
						omp.save_images,     // boolean               save,
						false,           // boolean               show_removed,
						omp.save_dir,        // String                save_dir,
						scene_other,     // int                   scene_num,
						omp.remove_dc,       // boolean               nodc,
						mode,            // int                   mode, // 0 - extract, 1 - masked, 2 - corr full, 3 - corr half
						show_centers,    // boolean               show_centers,
						omp.extr_size,       // int                   extr_size,
						gops[scene_num], // GroundObjectPattern   gop,
						matches_list,    // ArrayList <ItemMatch> matches_list,
						match_sort,      // ArrayList<Integer>    match_sort,
						debugLevel);     // int                   debugLevel)
			}
		}
		// final filter
		boolean[] filt_main_other = new boolean [indices.length]; //{true,false};
		Arrays.fill(filt_main_other, true);
///		int num_removed = 
				filterCandidates( // will filter again if already
				omp,                // OrthoMapsParameters   omp,
				basename,           // String                basename,
				filt_main_other,    // new boolean []            filt_main_other,
				gops[scene_num],    // GroundObjectPattern   gop,
				zoom_level,         // int                   zoom_level,
				scene_agl,          // double                scene_agl,
				scene_xy_offset,    // double []             scene_xy_offset, //second scene vertical projection offset from the first scene
				matches_list,       // ArrayList <ItemMatch> matches_list,
				match_sort,         // ArrayList<Integer>    match_sort,
				debugLevel);        // int                   debugLevel )

		if (!omp.filt_keep) { // show final filtered images again - just extracts (2) and all correlations (4)
			for (int sn = 0; sn < indices.length; sn++) {
				String prefix = ortho_maps[indices[sn]].getName()+"-final";
				String suffix0 = "_pc"+omp.phaseCoeff[sn]+"_lpf"+omp.lpf_sigma[sn];
				for (int mode = 0; mode < 4; mode++) { // all 4 image types
					String suffix = (mode <2)? "":suffix0;
					if ((sn == 0) || (mode != 1)) { // masked - for main scene only
						ItemMatch.getImageExtracts(
								prefix,          // String                prefix, // include PC, filter here
								suffix,          // String                suffix, // w/o .tiff
								omp.show_images,     // boolean               show,
								omp.save_images,     // boolean               save,
								false,           // boolean               show_removed,
								omp.save_dir,        // String                save_dir,
								sn,              // int                   scene_num,
								omp.remove_dc,       // boolean               nodc,
								mode,            // int                   mode, // 0 - extract, 1 - masked, 2 - corr full, 3 - corr half
								show_centers,    // boolean               show_centers,
								omp.extr_size,       // int                   extr_size,
								gops[scene_num], // GroundObjectPattern   gop,
								matches_list,    // ArrayList <ItemMatch> matches_list,
								match_sort,      // ArrayList<Integer>    match_sort,
								debugLevel);     // int                   debugLevel)
					}
				}
			}
		}

		omp.generateReport( // final
				null,                        // String                log_line, // should end with \n or be null
				true,                        // boolean              show, // ands with .show_images
				true,                        // boolean               save, // ands with .save_images
				true,                        // boolean               gen_results,
				true,                        // boolean               gen_parameters,
				ortho_maps,                  // OrthoMap []           ortho_maps,			
				indices,                     // int []                indices,
				match_sort,                  // ArrayList<Integer>    match_sort,
				matches_list,                // ArrayList <ItemMatch> matches_list,
				zoom_level,                  // int                   zoom_level,
				scene_xy_offset,             // double []             scene_xy_offset,
				scene_agl,                   // double                scene_agl,
				corrs_out[scene_num].length, // int                   num_patterns, // corrs_out[scene_num].length
				origin,                      // int []                origin,
				centers,                     // double [][]           centers,
				gops[scene_num],             // GroundObjectPattern   gop,
				hi_lo_freq,                  // double                hi_lo_freq,
				hi_freq_wh,                  // int []                hi_freq_wh,
				hi_freq_arr);                // double [][]           hi_freq_arr,
		if (debugLevel > -3) { 
			omp.printReport(
					true,                        // boolean               gen_results,
					true,                        // boolean               gen_parameters,
					ortho_maps,                  // OrthoMap []           ortho_maps,			
					indices,                     // int []                indices,
					match_sort,                  // ArrayList<Integer>    match_sort,
					matches_list,                // ArrayList <ItemMatch> matches_list,
					zoom_level,                  // int                   zoom_level,
					scene_xy_offset,             // double []             scene_xy_offset,
					scene_agl,                   // double                scene_agl,
					corrs_out[scene_num].length, // int                   num_patterns, // corrs_out[scene_num].length
					origin,                      // int []                origin,
					centers,                     // double [][]           centers,
					gops[scene_num],             // GroundObjectPattern   gop,
					hi_lo_freq,                  // double                hi_lo_freq,
					hi_freq_wh,                  // int []                hi_freq_wh,
					hi_freq_arr);                // double [][]           hi_freq_arr,
		}		
		
		ImagePlus img_final = null;
		{ // Create image with marked mines				
			PointRoi final_roi = new PointRoi();
			final_roi.setOptions("label");
			for (int i = 0; i < match_sort.size(); i++) {
				int indx =match_sort.get(i);
				ItemMatch match = matches_list.get(indx);
				//						double [] match_values = match.getMatchValues(gops[scene_num]);
				double [] center_xy = match.getXY();
				final_roi.addPoint(center_xy[0], center_xy[1]); // ,1);
			}
			String []  final_titles = new String[indices.length];
			double [][] final_map = new double [indices.length][];
			for (int i = 0; i < final_map.length; i++) {
				final_titles[i] = ortho_maps[indices[i]].getName();
				final_map[i] =  dmulti[i];
			}
			String final_title =indices[0]+"";
			for (int i = 1; i < final_map.length; i++) {
				final_title +="-"+indices[i];
			}
			final_title += "_"+final_titles[0];
			for (int i = 1; i < final_map.length; i++) {
				final_title +="-"+final_titles[i];
			}
			final_title += "-MARKED_"+omp.object_type+"_"+match_sort.size()+"_OBJECTS";
			img_final = ShowDoubleFloatArrays.makeArrays(
					final_map,
					width,
					height,
					final_title,				
					final_titles);
			img_final.setRoi(final_roi);
			showSaveImagePlus(
					img_final,            // ImagePlus imp,
					omp.show_final_image, // boolean   show,
					omp.save_images,      // boolean   save,
					omp.save_dir,         // String    save_dir,
					debugLevel);          // int       debugLevel)
		}

		System.out.println("patternMatchDual(): all correlations DONE");
		return img_final;
	}
	
	public static double[][]  correlateAllPatterns(
			double []    data,
			int          width,
			int          corr_size,    
			double [][]  patterns,  
			boolean      convolve, 
			double       phaseCoeff,
			double       lpf_sigma,
			double [][]  src_marks,
			String       prefix, // ortho_maps[indices[scene_num]].getName(). null - do not show
			String       save_dir,
			boolean      show,
			boolean      save,
			int          debugLevel) {
		double [][] corrs_out = new double [patterns.length][];
		for (int n = 0; n < patterns.length; n++) {
			corrs_out[n]= OrthoMap.correlateWithPattern(
					data,        // final double [] data,
					width,       // final int       width,
					corr_size,   // final int       psize,      // power of 2, such as 64
					patterns[n], // final double [] pattern,    // [psize*psize]
					convolve,    // final boolean   convolve,   // convolve, not correlate
					phaseCoeff,  // final double    phaseCoeff,
					lpf_sigma,   // final double    lpf_sigma, // 0 - do not filter
					debugLevel); // final int       debugLevel) {
		}
		if ((prefix != null) && (show || save)) {
			String [] patt_titles = new String[corrs_out.length];
			for (int i = 0; i < patt_titles.length; i++) {
				patt_titles[i] = "patt_"+i;
			}
			int height = data.length/width;
			ImagePlus imp_corr = ShowDoubleFloatArrays.makeArrays(
					corrs_out,
					width,
					height,
					prefix+"-PATTERN_CORRS_PC"+phaseCoeff+"_LPF"+lpf_sigma,				
					patt_titles); // test_titles,
			if (src_marks != null) {
				PointRoi roi = new PointRoi();
				roi.setOptions("label");
				for (int i = 0; i < src_marks.length; i++) {
					roi.addPoint(src_marks[i][0],src_marks[i][1]); // ,1);
				}
				imp_corr.setRoi(roi);
			}
		    showSaveImagePlus(
		    		imp_corr,         // ImagePlus imp,
		            show, // boolean   show,
		            save, // boolean   save,
		            save_dir,    // String    save_dir,
		            debugLevel); // int       debugLevel)
//			imp_corr.show();
		}
		return corrs_out;
	}
	
	/**
	 * Returns boolean array of original length
	 * @param filt_keep
	 * @param filt_main_other
	 * @param min_corrs
	 * @param min_corr_full_rel
	 * @param filt_max_radius
	 * @param filt_elongation
	 * @param filt_dist
	 * @param filt_height
	 * @param filter_data
	 * @param scene_xy_offset
	 * @param matches_list
	 * @param match_sort
	 * @param debugLevel
	 * @return
	 */
	public static int filterCandidates(
			OrthoMapsParameters   omp,
			String                basename,
			boolean []            filt_main_other, // length== number of scenes
			GroundObjectPattern   gop,
			int                   zoom_level,
			double                scene_agl,
			double []             scene_xy_offset, //second scene vertical projection offset from the first scene
			ArrayList <ItemMatch> matches_list,
			ArrayList<Integer>    match_sort,
			int                   debugLevel ) { // >0 - print
		StringBuffer sb =    new StringBuffer();
		int num_scenes = filt_main_other.length;
		int num_removed = 0;
		double [][] min_corrs_other = {
				{omp.min_corrs[0]*omp.min_corr_full_rel, omp.min_corrs[0]},
				{omp.min_corrs[1]*omp.min_corr_full_rel, omp.min_corrs[1]}};
		double offset_from_height = elevationToParallelOffset( // will be negative
				omp.filt_height,     // double    height,
				scene_xy_offset, // double [] scene_offset,
				zoom_level,      // int       zoom_level,
				scene_agl) ;//  double    agl)
		for (int mn=0; mn < match_sort.size(); mn++){
			ItemMatch match = matches_list.get(match_sort.get(mn));
			if (match.isRemoved()) {
				continue; // already removed
			}
			CorrelationPeakStats[][] filter_data = match.filter_data;
			
			int [] ixy = match.getIntXY();
			String name = ixy[0]+"/"+ixy[1];
			double abs_contrast = match.getAbsoluteContrast();
			double roundness = match.getRoundness(gop);
			int best_patt= match.getPatternMatch(gop).getBestSub(); // 1-based
			double best_value = match.getMatchBestValue(gop);
			boolean is_partial = best_patt != 1; // only apply to combined full/half correlations, just full may have nearby maximums near the same size
			double [] strength_full_half_ratio = new double[num_scenes];
			for (int scene_num = 0; scene_num < num_scenes; scene_num++) if (filt_main_other[scene_num] && (filter_data[scene_num] != null)){
					strength_full_half_ratio[scene_num] = filter_data[scene_num][0].best_d / filter_data[scene_num][1].best_d;
			}
			// filt_abs_easepart
			double min_abs_contrast = omp.filt_abs_contrast;
			if (is_partial) {
				min_abs_contrast *= omp.filt_abs_easepart;
			}
			if (abs_contrast < min_abs_contrast) {
				sb.append(name+": filtered out by "+NAME_MO[0]+" scene because its absolute contrast = "+
						abs_contrast+ " < "+min_abs_contrast+(is_partial?(". Eased for partial from "+omp.filt_abs_contrast):""));
				sb.append("\n");
				if (!match.isRemoved()) num_removed++;
				match.remove();
			}
			if (!is_partial && !(roundness >= omp.filt_roundness[0])) { // NaN - also bad
				sb.append(name+": filtered out by "+NAME_MO[0]+" scene because it is full/round, and its roundness = "+
						roundness+ " < "+omp.filt_roundness[0]);
				sb.append("\n");
				if (!match.isRemoved()) num_removed++;
				match.remove();
			}
			// only apply to full patterns, because partial can be filtered without it
			if (!is_partial && !(best_value >= omp.filt_best[0])) { // NaN - also bad
				sb.append(name+": filtered out by "+NAME_MO[0]+
						" scene because it is full-pattern and its best correlation value = "+
						best_value+ " < "+omp.filt_best[0]);
				sb.append("\n");
				if (!match.isRemoved()) num_removed++;
				match.remove();
			}
			
			for (int hf = 0; hf < 2; hf++) {
				for (int scene_num = 0; scene_num < num_scenes; scene_num++) if (filt_main_other[scene_num]){
					if (Double.isNaN(filter_data[scene_num][hf].best_d)) {
						sb.append(name+": filtered out by "+NAME_MO[scene_num]+"/"+NAME_FH[hf]+
								" as correlation maximum is not found");
						sb.append("\n");						
						if (!match.isRemoved()) num_removed++;
						match.remove();
						continue;
					}
					double eff_rad =       filter_data[scene_num][hf].eff_rad;
					double elong =         filter_data[scene_num][hf].elong;
					double corr_val =      filter_data[scene_num][hf].best_d;
					double dist =          filter_data[scene_num][hf].dist;
					double near_max_frac = filter_data[scene_num][hf].max_other;
					double [] second_xy_offsets = filter_data[scene_num][hf].cent_offs;					
					// calculate projection
					double [] scnd_xy_proj =  projectOffsetOnVector(
							second_xy_offsets, // double [] object_offset,
							scene_xy_offset); // double [] scene_offset)
					if (corr_val < min_corrs_other[scene_num][hf]) {
						sb.append(name+": filtered out by "+NAME_MO[scene_num]+" correlation maximum value for "+
								NAME_FH[hf]+ " = "+corr_val+" < "+ min_corrs_other[scene_num][hf]);
						sb.append("\n");						if (scene_num == 0) {
							sb.append(
							"For the main scene it could happen if the sub_pattern index changed after"+
							" the absolute contrast evaluation.");
							sb.append("\n");
						}
						if (!match.isRemoved()) num_removed++;
						match.remove();
					}
					if (is_partial && (hf > 0) && (corr_val < omp.min_corr_half_rel * omp.min_corrs[scene_num])) {
						sb.append(name+": filtered out by "+NAME_MO[scene_num]+
								" because it is partial and correlation maximum value for "+
								NAME_FH[hf]+ " = "+corr_val+" < "+ omp.min_corr_half_rel*min_corrs_other[scene_num][hf]+
								" (increased by "+omp.min_corr_half_rel+" from base "+omp.min_corrs[scene_num]+").");
						sb.append("\n");
						if (!match.isRemoved()) num_removed++;
						match.remove();
					}
					
					if (scene_num > 0) { // other scene
						//	{best_d, eff_rad, elong, dist, cent_offs[0], cent_offs[1]} ;
						if (dist > omp.filt_dist[0]) {
							sb.append(name+": filtered out by "+NAME_MO[scene_num]+" distance from the main scene peak "+
									NAME_FH[hf]+ " = "+dist+" > "+omp.filt_dist[0]);
							sb.append("\n");
							if (!match.isRemoved()) num_removed++;
							match.remove();
						}
						// distance for main only or both?
						if (Math.abs(scnd_xy_proj[1]) > omp.filt_dist[1]) {
							sb.append(name+": filtered out by "+NAME_MO[scene_num]+" distance from the main scene peak perpendicular to the scene offset vector "+
									NAME_FH[hf]+ " = "+scnd_xy_proj[1]+", abs() > "+omp.filt_dist[1]);
							sb.append("\n");
							if (!match.isRemoved()) num_removed++;
							match.remove();
						}
						// offset_from_height
						if (scnd_xy_proj[0] > omp.filt_dist[1]) {
							sb.append(name+": filtered out by "+NAME_MO[scene_num]+
									" distance from the main scene peak parallel to the scene offset vector "+
									NAME_FH[hf]+ " = "+scnd_xy_proj[0]+" > "+omp.filt_dist[1]+
									" it could happen if the object is deep below average ground surface.");
							sb.append("\n");
							if (!match.isRemoved()) num_removed++;
							match.remove();
						}
						if (scnd_xy_proj[0] < (-omp.filt_dist[1]+offset_from_height)) {
							sb.append(name+": filtered out by "+NAME_MO[scene_num]+
									" distance from the main scene peak parallel to the scene offset vector "+
									NAME_FH[hf]+ " = "+scnd_xy_proj[0]+" < "+(-omp.filt_dist[1]+offset_from_height)+
									".\n This limit accounts for objects above ground up to "+omp.filt_height+" meters ("+
									offset_from_height+" pix.");
							sb.append("\n");
							if (!match.isRemoved()) num_removed++;
							match.remove();
						}
					}
					if (eff_rad > omp.filt_max_radius[scene_num][hf]) {
						sb.append(name+": filtered out by "+NAME_MO[scene_num]+" scene radius for "+
								NAME_FH[hf]+ " pattern: "+eff_rad+" > "+ omp.filt_max_radius[scene_num][hf]);
						sb.append("\n");
						if (!match.isRemoved()) num_removed++;
						match.remove();
					}
					if (elong > omp.filt_elongation[scene_num][hf]) {
						sb.append(name+": filtered out by "+NAME_MO[scene_num]+" scene peak cros-section elongation for "+
								NAME_FH[hf]+ " pattern: "+elong+" > "+ omp.filt_elongation[scene_num][hf]);
						sb.append("\n");
						if (!match.isRemoved()) num_removed++;
						match.remove();
					}
					if (is_partial && (omp.filt_other_frac != null) && (hf > 0) && (near_max_frac > omp.filt_other_frac[scene_num])) {
						sb.append(name+": filtered out by "+NAME_MO[scene_num]+
								" because it matches partial pattern ("+best_patt+") and combined full/partial correlation has a near peak "+
								near_max_frac+" > "+ omp.filt_other_frac[scene_num]+" of the used peak.");
						sb.append("\n");
						if (!match.isRemoved()) num_removed++;
						match.remove();
					}
					if (hf==0) {
						if ( strength_full_half_ratio[scene_num] < omp.filt_full_half_frac[scene_num]) {
							sb.append(name+": filtered out by "+NAME_MO[scene_num]+
									" because its correlation with the full patern strengh ratio to the partial pattern one = "+
									strength_full_half_ratio[scene_num]+" < "+ omp.filt_full_half_frac[scene_num]+" (minimum allowed).");
							sb.append("\n");
							if (!match.isRemoved()) num_removed++;
							match.remove();
						}
					}
				}				
			}
		}
		StringBuffer sb1 = new StringBuffer();
		if (! omp.filt_keep) {
			if (num_removed > 0) {
				for (int mn=match_sort.size()-1; mn >=0; mn--) {
					ItemMatch match = matches_list.get(match_sort.get(mn));
					if (match.isRemoved()) {
						match_sort.remove(mn);
					}
				}
				sb1.append("Filtered out "+num_removed+
						" scenes by the filter.\n");
			} else {
				sb1.append("No scenes were filtered out by the filter\n");
			}
			sb1.append(match_sort.size()+" candidate(s) remain\n");
		}
		if (debugLevel > 0) {
			System.out.println(sb.toString());
		}
		if (debugLevel > -3) {
			System.out.println(sb1.toString());
		}
		sb.append(sb1);
		if (omp.append_log && (omp.save_dir!= null)) {
			String log_path = omp.save_dir+basename+OrthoMapsParameters.LOG_SUFFIX;
			CalibrationFileManagement.saveStringToFile (
					log_path,      //String path,
					sb.toString(), // data,
					true);         // boolean append)
		}
		return num_removed;
	}

	/**
	 * Set absolute contrasts for each object, optionally changing sub-pattern index. Absolute contrast
	 * is a difference between average (w/o outliers) data value in zone1 (center area of the pattern) and
	 * the ring around it (zone2).
	 * On return the matches_list data is modified - absolute contrasts are set, and best_pattern may be
	 * updated. 
	 * Gets extracted_objects square arrays for each of the object, so the center of objects is in the
	 * center of the square from ItemMatch instance from the list. Calculated (for debug) masked image is 
	 * also saved there.
	 * 
	 * @param force_round overwrite mode with 4 - force pattern index to full (round) one
	 * @param mode Update of the best sub-pattern index:
	 *             0 - keep current
	 *             1 - keep type (full/half) and allow half direction to change by -1,0, or +1
	 *             2 - keep type (full/half)
	 *             3 - no restrictions - find the best sub-pattern index from scratch,
	 *             4 - force round (full pattern)
	 * @param neg_better    center lower (colder) than around
	 * @param outliers_frac fraction of outliers to remove while calculating averages
	 * @param obscure_warm allow obscurant (that makes half-pattern from a full one only to be warmer
	 *        than the object (defined below fraction between the object center region and peripheral
	 *        ring. For hot objects obscurant should be colder than such fraction.
	 * @param obscure_frac fraction between center average and peripheral ring to compare when obscure_warm
	 *        is set.
	 * @param gop  GroundObjectPattern instance used
	 * @param matches_list list of pattern matches
	 * @param match_sort   sorted list of indices in pattern matches list, so the first is the best match.
	 * @param scene_num - 0 for main, 1 - "other" 
	 * @param ipatterns integer square patterns with the same dimensions as the extracted_objects. Value
	 *        0 - do not use this pixel, 1 - Zone1 (inside the pattern), 2 - Zone2 - reference ring around
	 *        the pattern.
	 * @param debugLevel debug level. >0 - display images, >-4 - print.
	 * @return true
	 */
	public static boolean setAbsoluteContrasts(
			OrthoMapsParameters   omp,
			/*
			boolean               force_round,
			int                   mode, //  0 - keep, 1 keep type and if half +/-1, 2 - keep type, 3 - any
			boolean               neg_better, // more negative is difference - stronger result
			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
			*/ 
			GroundObjectPattern   gop,
			ArrayList <ItemMatch> matches_list,
			ArrayList<Integer>    match_sort,
			int                   scene_num,
			int [][]              ipatterns,
			int                   debugLevel) {
		boolean   debug = debugLevel > 1; 
		int mode = omp.abs_mode;
		for (int mn=0; mn < match_sort.size(); mn++) {
			if (debugLevel > 1) {
				System.out.println("setAbsoluteContrasts(): Calculating absolute contrast for match #"+mn);
			}
			int indx =match_sort.get(mn);
			ItemMatch match = matches_list.get(indx);
			boolean [] try_sub = new boolean [ipatterns.length];
			int best_patt= match.getPatternMatch(gop).getBestSub() - 1; // 0-based
			int num_halves = ipatterns.length - 1; // == 8
			if (omp.abs_force_round) {
				mode = 4;
			}
			switch (mode) {
			case 0: try_sub[best_patt] = true; 	break; // only one
			case 1: // keep type and +-1 for direction
				if (best_patt == 0) {
					try_sub[0] = true;
				} else {
					for (int offs = -1; offs <= 1 ; offs++) {
						int i = best_patt+offs;
						if (i < 1) {
							i += num_halves;
						} else if (i > num_halves) {
							i -= num_halves;
						}
						try_sub[i] = true;
					}
				}
				break;
			case 2: // keep type
				if (best_patt == 0) {
					try_sub[0] = true;
				} else {
					for (int i = 1; i < try_sub.length; i++) {
						try_sub[i] = true;
					}
				}
				break;
			case 3: // any
				for (int i = 0; i < try_sub.length; i++) {
					try_sub[i] = true;
				}
				break;
			case 4: try_sub[0] = true; 	break; // only full pattern
			}
			double [][] dir_contrasts = new double [try_sub.length][];
			int best_index = -1;
			for (int i = 0; i < try_sub.length; i++) if ((i==0) || try_sub[i]) {
				dir_contrasts[i]= OrthoMap.getAbsoluteContrast(
						match.extracted_objects[scene_num], // extracted_objects[mn], // double [] data,
						ipatterns[i],                       // int    [] ipattern,
						omp.abs_outliers_frac,                      // double    outliers_frac,
						omp.abs_obscure_frac,                       // double    obscure_frac, //  0.25; // obscured threshold between center and outer 
						null,
						debug);                             // boolean   debug)				
				if (omp.abs_invert) {
					dir_contrasts[i][0] *= -1;
				}
				boolean bad_obscurant = omp.abs_obscure_warm && (dir_contrasts[i][1] < 0);
				if (try_sub[i] && (dir_contrasts[i][0] > 0)) {
					if (bad_obscurant) {
						if (debugLevel > -4) {
							System.out.println("setAbsoluteContrasts(): removing pattern_sub="+i
									+", match object="+mn+" because of the bad obscurant (cold for cold object)");
						}
					} else {
						best_index = i;
					}
				}
				
			}
			if (best_index < 0) {
				best_index = 0;
				
				if (debugLevel > -3) {
					System.out.println("setAbsoluteContrasts(): no candidates found (probably after removing bad obscurants) #"
							+mn+", giving a chance as full pattern. Was (1 for full):"+
							(best_patt+1)+", new is "+(best_index + 1));
				}
			}
			if (best_index != best_patt) {
				if (debugLevel > -3) {
					System.out.println("setAbsoluteContrasts(): updating best pattern index for match #"
							+mn+". Was (1 for full):"+(best_patt+1)+", new is "+(best_index + 1));
				}
				match.getPatternMatch(gop).setBestSub(best_index + 1);
			}
			match.setAbsoluteContrast(dir_contrasts[best_index][0]); // the higher the better
			if (debugLevel > -3) {
				System.out.println("setAbsoluteContrasts(): Set absolute contrast for match #"+mn+" = "+
						dir_contrasts[best_index][0]+
						", over threshold="+dir_contrasts[best_index][1]+".");
			}
			match.extracted_masked[scene_num] = new double [match.extracted_objects[scene_num].length];
			OrthoMap.getAbsoluteContrast( // calculate and set extracted_masked
					match.extracted_objects[scene_num], // double [] data,
					ipatterns[best_index],              // int    [] ipattern,
					omp.abs_outliers_frac,              // double    outliers_frac,
					omp.abs_obscure_frac,               // double    obscure_frac, //  0.25; // obscured threshold between center and outer 
					match.extracted_masked[scene_num],
					debug);                             // boolean   debug)				
		}		
		return true;
	}
	
	
	public String selectOneScene(
			int num_scene,
			int default_choice,
			int num_choice_lines) {
		String [] fs = {"first","second"};
		String [] lines = new String [ortho_maps.length];
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy HH:mm:ss.SS zzz");// may be VV instead of zzz
		for (int indx = 0; indx < ortho_maps.length; indx++) {
			OrthoMap map = ortho_maps[indx];
			LocalDateTime ldt = map.getLocalDateTime();
			ZonedDateTime zonedUTC = ldt.atZone(ZoneId.of("UTC")); // that time is UTC
			ZonedDateTime zonedDateTime = zonedUTC.withZoneSameInstant(ZoneId.of("Europe/Kyiv"));
			String sdt = zonedDateTime.format(formatter);
			String name = map.getName();
			double agl = map.getAGL();
			lines[indx]=String.format(
					"%3d %17s %26s %6.2f",indx, name, sdt, agl);
		}
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Select the "+fs[num_scene]+" image from the list ",1200,100);
		gd.addChoice(fs[num_scene]+" image:",
				lines,
				lines[default_choice],
				"Select "+fs[num_scene]+" scene", num_choice_lines);
		gd.showDialog();
		if (gd.wasCanceled()) return null;
		int scene_number= gd.getNextChoiceIndex();
		return ortho_maps[scene_number].getName();
	}

	public String[] selectTwoScenes(
			int default_choice,
			int num_choice_lines) {
		String [] fs = {"first","second"};
		String [] lines = new String [ortho_maps.length];
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy HH:mm:ss.SS zzz");// may be VV instead of zzz
		for (int indx = 0; indx < ortho_maps.length; indx++) {
			OrthoMap map = ortho_maps[indx];
			LocalDateTime ldt = map.getLocalDateTime();
			ZonedDateTime zonedUTC = ldt.atZone(ZoneId.of("UTC")); // that time is UTC
			ZonedDateTime zonedDateTime = zonedUTC.withZoneSameInstant(ZoneId.of("Europe/Kyiv"));
			String sdt = zonedDateTime.format(formatter);
			String name = map.getName();
			double agl = map.getAGL();
			lines[indx]=String.format(
					"%3d %17s %26s %6.2f",indx, name, sdt, agl);
		}
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Select two image scenes",1200,150);
		for (int num_scene = 0; num_scene < 2; num_scene++) {
			gd.addChoice(fs[num_scene]+" image:",
					lines,
					lines[default_choice],
					"Select "+fs[num_scene]+" scene", num_choice_lines);
		}
		gd.showDialog();
		if (gd.wasCanceled()) return null;
		String [] names = new String[2];
		for (int num_scene = 0; num_scene < 2; num_scene++) {
			int scene_number= gd.getNextChoiceIndex();
			names[num_scene] = ortho_maps[scene_number].getName();
		}		
		return names;
	}

	
	
	public String [] getScenesList(int [] indices) {
		if (indices == null) {
			indices = new int [ortho_maps.length];
			for (int indx = 0; indx < ortho_maps.length; indx++) {
				indices[indx] = indx;	
			}
		}
		String [] lines = new String [indices.length];
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy HH:mm:ss.SS zzz");// may be VV instead of zzz
		int dbg_indx = -530;
		for (int i = 0; i < indices.length; i++) {
			int indx = indices[i];
			if (indx == dbg_indx) {
				System.out.println("indx="+indx);
			}
			OrthoMap map = ortho_maps[indx];
			LocalDateTime ldt = map.getLocalDateTime();
			ZonedDateTime zonedUTC = ldt.atZone(ZoneId.of("UTC")); // that time is UTC
			ZonedDateTime zonedDateTime = zonedUTC.withZoneSameInstant(ZoneId.of("Europe/Kyiv"));
			String sdt = zonedDateTime.format(formatter);
			String name = map.getName();
			double agl = map.getAGL();
			lines[i]=String.format(
					"%3d %17s %26s %6.2f",indx, name, sdt, agl);
		}
		return lines;
	}

	public int [] getScenesSelection(
			CLTParameters    clt_parameters,			
			String purpose) { // " to generate stats", " to generate images"
		boolean  filter_scenes = true;
		boolean  select_scenes = true;
		double   flt_min_sfm = clt_parameters.imp.flt_min_sfm;
		double   flt_max_sfm = clt_parameters.imp.flt_max_sfm;
//		int      flt_alt = clt_parameters.imp.flt_alt;
		int      flt_orient = clt_parameters.imp.flt_orient;
		boolean  flt_update_config = false;
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Select scenes filter",800,400);
		gd.addCheckbox    ("Filter scenes",               filter_scenes, "Filter scenes.");
		gd.addCheckbox    ("Select scenes",               select_scenes, "Select scenes manually.");
		gd.addNumericField("Minimal SfM gain",            flt_min_sfm,  3,7,"","Minimal SfM gain of the scenes.");
		gd.addNumericField("Maximal SfM gain",            flt_max_sfm,  3,7,"","Maximal SfM gain of the scenes.");
//		gd. addChoice("Filter by pairwise ALT availability",IntersceneMatchParameters.FLT_ALT_MODES, IntersceneMatchParameters.FLT_ALT_MODES[flt_alt],"Filter by pairwise ALT availability.");
		gd. addChoice("Filter by orientation availability",IntersceneMatchParameters.FLT_ORIENT_MODES, IntersceneMatchParameters.FLT_ORIENT_MODES[flt_orient],"Filter by the scene orientation availability.");
		gd.addCheckbox    ("Update configuration",        flt_update_config, "Update matching configuration parameters to be saved as defaults.");

		gd.showDialog();
		if (gd.wasCanceled()) return null;
		filter_scenes =        gd.getNextBoolean();
		select_scenes =        gd.getNextBoolean();
		flt_min_sfm =          gd.getNextNumber();
		flt_max_sfm =          gd.getNextNumber();
//        flt_alt =              gd.getNextChoiceIndex();
        flt_orient =           gd.getNextChoiceIndex();
        flt_update_config =    gd.getNextBoolean();
        if (flt_update_config) {
    		clt_parameters.imp.flt_min_sfm = flt_min_sfm;
    		clt_parameters.imp.flt_max_sfm = flt_max_sfm; 
//    		clt_parameters.imp.flt_alt =     flt_alt;     
    		clt_parameters.imp.flt_orient =  flt_orient;  
        }
		int [] indices = new int [ortho_maps.length];
		for (int indx = 0; indx < ortho_maps.length; indx++) {
			indices[indx] = indx;	
		}
		if (filter_scenes) {
			boolean [] selection = new boolean [ortho_maps.length];
			int num_selected = 0;
			for (int indx = 0; indx < ortho_maps.length; indx++) {
				if ((ortho_maps[indx].getSfmGain()<flt_min_sfm) || (ortho_maps[indx].getSfmGain()>flt_max_sfm)) {
					selection[indx]=false;
					continue;
				}
				if ((ortho_maps[indx].getQOrinet()==null) && (flt_orient == 1)) {
					selection[indx]=false;
					continue;
				}
				if ((ortho_maps[indx].getQOrinet()!=null) && (flt_orient == 2)) {
					selection[indx]=false;
					continue;
				}
				selection[indx]=true;
				num_selected++;
			}
			int [] selected_indices = new int [num_selected];
			int indx = 0;
			for (int i = 0; i < ortho_maps.length; i++) if (selection[i]){
				selected_indices[indx++] = i;
			}
			indices = selected_indices;
		}
		if (select_scenes) {
			String [] lines = getScenesList(indices);
			boolean [] selection = new boolean [indices.length];
			gd = new GenericJTabbedDialog("Select scenes",1200,1000);
			gd.addCheckbox    ("Select all",   false, "Select all scenes listed");
			for (int i = 0; i < lines.length; i++) {
				gd.addCheckbox    (lines[i],   false, "Select scene number "+indices[i]);
			}
			gd.showDialog();
			if (gd.wasCanceled()) return null;
			boolean sel_all =  gd.getNextBoolean();
			int num_selected = 0;
			for (int i = 0; i < lines.length; i++) {
				selection[i] = gd.getNextBoolean();
				if (selection[i]) num_selected++;
			}
			if (sel_all) {
				Arrays.fill(selection,  true);
			} else {
				int [] sel_indices = new int [num_selected];
				int indx=0;
				for (int i = 0; i < lines.length; i++) if (selection[i]) {
					sel_indices[indx++] = indices[i];
				}
				indices = sel_indices;
			}
		}
		return indices;
	}
	
	public int [] getScenesSelection(
			boolean [] pre_selects,
			String purpose) { // " to generate stats", " to generate images"
		String [] lines = getScenesList(null);
		int [] sel_50 = {125,126,127,129,135,136,137,138,139,140,141,144,145,146,147,148,155,156,157,158};
		int [] sel_75 = {170,177,178,183,187,188,189,192,193,199,200,204};
		int [] sel_100 = {207,208,212,213,214,215,218,220};
		int [] range_50_evn=  {  0, 48};
		int [] range_25_mor=  { 49,124};
		int [] range_50_mor=  {125,164};
		int [] range_75_mor=  {166,204};
		int [] range_100_mor= {205,221};
		int [][] ranges = {null,null,null,null,range_50_evn,range_25_mor,range_50_mor,range_75_mor,range_100_mor};
		
		boolean [] selection = new boolean [lines.length];
		if (pre_selects != null) {
			if (pre_selects[0]) {
				Arrays.fill(selection, true);
			}
			if (pre_selects[1]) {
				for (int i:sel_50) {
					selection[i] = true;
				}
			}
			if (pre_selects[2]) {
				for (int i:sel_75) {
					selection[i] = true;
				}
			}
			if (pre_selects[3]) {
				for (int i:sel_100) {
					selection[i] = true;
				}
			}
			for (int n = 4; n < 9; n++) if (pre_selects[n]){
				for (int i = ranges[n][0]; i<=ranges[n][1]; i++) {
					selection[i] = true;
				}
			}
		}
		pre_selects = new boolean[9];
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Select scenes",1200,1000);
		gd.addCheckbox    ("Select all maps",         pre_selects[0], "Select all scenes, reopen this dialog.");
		gd.addCheckbox    ("Select  50m used maps",   pre_selects[1], "Select 50m scenes, reopen this dialog.");
		gd.addCheckbox    ("Select  75m used maps",   pre_selects[2], "Select 50m scenes, reopen this dialog.");
		gd.addCheckbox    ("Select 100m used maps",   pre_selects[3], "Select 50m scenes, reopen this dialog.");
		gd.addCheckbox    ("Select all 50m evening",  pre_selects[4], "Select all 50m evening scenes, reopen this dialog.");
		gd.addCheckbox    ("Select all 25m morning",  pre_selects[5], "Select all 25m morning scenes, reopen this dialog.");
		gd.addCheckbox    ("Select all 50m morning",  pre_selects[6], "Select all 50m morning scenes, reopen this dialog.");
		gd.addCheckbox    ("Select all 75m morning",  pre_selects[7], "Select all 75m morning scenes, reopen this dialog.");
		gd.addCheckbox    ("Select all 100m morning", pre_selects[8], "Select all 100m morning scenes, reopen this dialog.");
		for (int i = 0; i < lines.length; i++) {
			gd.addCheckbox    (lines[i],   selection[i], "Select scene number "+i);
		}
		gd.showDialog();
		if (gd.wasCanceled()) return null;
		boolean presel_any = false;
		for (int i = 0; i < pre_selects.length; i++) { 
			pre_selects[i]= gd.getNextBoolean();
			presel_any |= pre_selects[i]; 
		}
		if (presel_any) {
			return getScenesSelection(pre_selects, purpose);
		}
		int num_sel = 0;
		for (int i = 0; i < selection.length; i++) {
			selection[i] = gd.getNextBoolean();
			if (selection[i]) {
				num_sel++;
			}
		}
		int [] indices = new int [num_sel];
		int indx=0;
		for (int i = 0; i < selection.length; i++) if (selection[i]) {
			indices[indx++] = i;
		}		
		return indices;
	}
	
	public boolean equalizeIntersectedPairs(
			CLTParameters    clt_parameters,
			String orthoMapsCollection_path) {
		boolean  use_inv = false;
		int [] indices = getScenesSelection(
				clt_parameters, // CLTParameters       clt_parameters,				
				" to build a equalize intensities"); // String purpose)
		PairwiseOrthoMatch [][] matches = new PairwiseOrthoMatch[indices.length][indices.length];
		ArrayList<Point> pairs_list = new ArrayList<Point>();
		int num_new = 0;
		for (int i = 0; i < indices.length-1; i++) {
			int scene0 = indices[i]; 
			for (int j = i+1; j < indices.length; j++){
				int scene1 = indices[j];
				PairwiseOrthoMatch match = ortho_maps[scene0].getMatch(ortho_maps[scene1].getName());
				PairwiseOrthoMatch inv_match = use_inv? ortho_maps[scene1].getMatch(ortho_maps[scene0].getName()):null;
				if ((match != null) || (inv_match != null)){
					if (match == null) {
						double [] enuOffset = ortho_maps[scene0].enuOffsetTo(ortho_maps[scene1]);
						double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
						match = inv_match.getInverse(rd);
					}
					if (inv_match == null) {
						double [] enuOffset = ortho_maps[scene1].enuOffsetTo(ortho_maps[scene0]);
						double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
						inv_match = match.getInverse(rd);
					}
				}
				if (match != null) {
					if (!match.isSetEqualize2to1()) {
						num_new++;
					}
					matches[i][j] = match;
					matches[j][i] = inv_match;
					pairs_list.add(new Point(i,j)); // only once?
				}
			}
		}
	
		boolean      skip_exist    = clt_parameters.imp.pwise_skip_exist;   //
		boolean      save_each     = clt_parameters.imp.pwise_save_each;    // save state file after each match
		boolean      log_append    = clt_parameters.imp.pwise_log_append;   //
		String       log_path      = clt_parameters.imp.pwise_log_path;     // 
		int          debugLevel    = clt_parameters.imp.pwise_debug;        //

		GenericJTabbedDialog gd = new GenericJTabbedDialog("Pairwise Match Parameters",1200,1000);
		gd.addMessage("Number of scenes - "+indices.length+
				", number of pairs - "+pairs_list.size()+
				", number of new pairs - "+num_new);
	    gd.addCheckbox    ("Skip existing",              skip_exist, "Do not regenerate if match with same or higher resolution exists.");
   	    gd.addCheckbox    ("Save state after each pair", save_each, "Update state file after each match generation to mitigate possible crashes.");
	    gd.addCheckbox    ("Write log file",              log_append, "Enable writing log file with matching results.");
	    gd.addStringField ("Log file full path",          log_path, 150, "Path of the log file to be appended.");	
		gd.addNumericField("Pairwise match debug level",  debugLevel, 0,3,"","Debug level during Spiral search.");
 		gd.showDialog();
		if (gd.wasCanceled()) return false;
		skip_exist       = gd.getNextBoolean();
		save_each        = gd.getNextBoolean();
		log_append       = gd.getNextBoolean();
		log_path         = gd.getNextString();
		debugLevel = (int) gd.getNextNumber();
		if (log_append && (log_path != null)) { // assuming directory exists
			StringBuffer sb = new StringBuffer();
			sb.append(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(Calendar.getInstance().getTime())+"\n");
			sb.append("num_scenes\t"+  indices.length+"\n");
			sb.append("num_pairs\t"+   pairs_list.size()+"\n");
			sb.append("num_new\t"+     num_new+"\n");
			sb.append(String.format("%4s\t%4s\t%17s\t%17s\t%6s\t%3s\t%6s\t%8s\t%4s\n",
					"scn1","scn2","timestamp1","timestamp2","ovrlp","zl","a","b","old"));
			CalibrationFileManagement.saveStringToFile (
					log_path,          //String path,
					sb.toString(), // data,
					true); // boolean append)
			if (debugLevel>-3) {
				System.out.print(sb.toString());
			}
		}
		
		for (Point p:pairs_list) {
			StringBuffer sb = new StringBuffer();
			PairwiseOrthoMatch match = matches[p.x][p.y];
			int scene0 = indices[p.x]; 
			int scene1 = indices[p.y];
			int [] indices_pair = {scene0,scene1}; 

			if (skip_exist && match.isSetEqualize2to1()) {
				sb.append(String.format("%4d\t%4d\t%s\t%s\t%6.4f\t%3d\t%6.4f\t%8.4f\tOLD\n",
						scene0, scene1, ortho_maps[scene0].getName(), ortho_maps[scene1].getName(),
						match.overlap,  match.zoom_lev, match.equalize1to0[0],match.equalize1to0[1]));
				
			} else {
				double [][][] affines = {{{1,0,0},{0,1,0}},match.getAffine()};
				int []     wh = new int[2];
				int [] origin = new int[2];			
				double [][] centers = new double [indices.length][];
				double [][] dmulti = renderMultiDouble (
						null,              // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
						indices_pair,           // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
						true, // boolean       bounds_to_indices,
						affines,           // affines,    // double [][][] affines, // null or [indices.length][2][3]
						null,              // double [][]   equalize,
						true,              // boolean       ignore_equalize,
						null,              // warp,       // FineXYCorr    warp,,
						match.zoom_lev,    // int         zoom_level,
						wh,                // int []      wh,
						origin,            // int []      origin){ // maps[0] as a reference
						centers);          // double [][] centers)

				double [] regression = PolynomialApproximation.getOrthoRegression(
						dmulti[0], // final double []  data_x,
						dmulti[1], // final double []  data_y,
						null);     // final boolean [] mask)
				double [] inv_regression = PolynomialApproximation.invertRegression(regression);
				PolynomialApproximation.applyRegression(
						dmulti[1], // dmulti1,       // final double [] data, // clone by caller
						inv_regression); // final double [] regression) {
				match.setEqualize2to1(inv_regression);
				if (save_each && (orthoMapsCollection_path != null)) {
					try {
						writeOrthoMapsCollection(orthoMapsCollection_path);
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					if (debugLevel > -4) {
						System.out.println("Saved data to "+ orthoMapsCollection_path);
					}
				}
				sb.append(String.format("%4d\t%4d\t%s\t%s\t%6.4f\t%3d\t%6.4f\t%8.4f\tNEW\n",
						scene0, scene1, ortho_maps[scene0].getName(), ortho_maps[scene1].getName(),
						match.overlap,  match.zoom_lev, match.equalize1to0[0],match.equalize1to0[1]));
			}
			if (log_append && (log_path != null)) { // assuming directory exists
				CalibrationFileManagement.saveStringToFile (
						log_path,          //String path,
						sb.toString(), // data,
						true); // boolean append)
			}			
			if (debugLevel>-3) {
				System.out.print(sb.toString());
			}
			
		}
		
		if (orthoMapsCollection_path != null) {
			try {
				writeOrthoMapsCollection(orthoMapsCollection_path);
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			if (debugLevel > -4) {
				System.out.println("Saved data to "+ orthoMapsCollection_path);
			}
		}
		StringBuffer sb = new StringBuffer();
		sb.append("\nSUMMARY\n");
		sb.append("processed\t"+(skip_exist?num_new:pairs_list.size()) +"\n");
		sb.append("new\t"+ num_new+"\n");
		sb.append("skipped\t"+(skip_exist?(pairs_list.size()-num_new):0)+"\n");
    	if (debugLevel > -3) {
    		System.out.print(sb.toString());
    	}
		if (log_append && (log_path != null)) { // assuming directory exists
			CalibrationFileManagement.saveStringToFile (
					log_path,          //String path,
					sb.toString(), // data,
					true); // boolean append)
        	if (debugLevel > -4) {
        		System.out.println("Appended log file "+ log_path);
        	}
		}		
		return true;
	}
	
	public boolean getOverlapPairs(
			CLTParameters    clt_parameters,
			String orthoMapsCollection_path) {

		int [] indices = getScenesSelection(
				clt_parameters, // CLTParameters       clt_parameters,				
				" to find intersects"); // String purpose)
		if (indices == null) {
			return false;
		}
		int     zoom_lev =          clt_parameters.imp.pwise_zoom; // -5;
		double  min_overlap_frac =  clt_parameters.imp.pwise_overlap; // 0.25;
		boolean ignore_affines =    false;
		boolean from_scratch =      false;

		
		
		boolean bounds_to_indices = true;
		int debugLevel = clt_parameters.imp.pwise_debug;
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Get scene intersections",1200,300);
		gd.addNumericField("Zoom level",                 zoom_lev,  0,4,"",
				"Zoom level: +1 - zoom in twice, -1 - zoom out twice");
		gd.addNumericField("Minimal overlap",            min_overlap_frac,    3,7,"",
				"Minimal overlap as a fraction of the smaller image.");
	    gd.addCheckbox    ("Ignore known affines",       ignore_affines, "Ignore previously calculated scenes' affines.");
	    gd.addCheckbox    ("Start from scratch",         from_scratch,   "Remove all pairwise affines (false - keep them).");

		gd.addNumericField("Pairwise match debug level",  debugLevel, 0,3,"","Debug level during Spiral search.");

		gd.showDialog();
		if (gd.wasCanceled()) return false;
		zoom_lev =     (int) gd.getNextNumber();
		min_overlap_frac =   gd.getNextNumber();
		ignore_affines =     gd.getNextBoolean();
		from_scratch =       gd.getNextBoolean();
		debugLevel=    (int) gd.getNextNumber();
		int [] wh =     new int[2];
		int [] origin = new int[2];
		double [][] centers =new double [indices.length][];
		double [][][] affines = null;
		if (ignore_affines) {
			affines = new double [indices.length][2][3];
			for (int i = 0; i < affines.length; i++) {
				affines[i][0][0] = 1.0;
				affines[i][1][1] = 1.0;
			}
		}
		for (int i = 0; i < indices.length; i++) {
			// 	public void unsetMatches(boolean undefined_only) {
			ortho_maps[indices[i]].unsetMatches(!from_scratch);

		}
		double [][] dmulti = renderMultiDouble (
				null,              // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
				indices,           // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
				bounds_to_indices, // boolean       bounds_to_indices,
				affines,           // affines,    // double [][][] affines, // null or [indices.length][2][3]
				null,              // double [][]   equalize,
				true,              // boolean       ignore_equalize,
				null,              // warp,       // FineXYCorr    warp,,
				zoom_lev,          // int         zoom_level,
				wh,                // int []      wh,
				origin,            // int []      origin){ // maps[0] as a reference
				centers);          // double [][] centers)

		double [] overlaps = getFracOverlaps(
				dmulti); // final double [][] dmulti) {
		int num_overlaps_all = 0, num_overlaps_sel = 0;
		boolean [][] intersects = new boolean [dmulti.length][dmulti.length];
		for (int i = 0; i < dmulti.length-1; i++) {
			for (int j = i+1; j < dmulti.length; j++) {
				int indx = i*dmulti.length+j;
				double overlap = overlaps[indx];
				if (overlap > 0) {
					num_overlaps_all++;
					if (overlap > min_overlap_frac) {
						String name2 = ortho_maps[indices[j]].getName();
						PairwiseOrthoMatch match = ortho_maps[indices[i]].getMatch(name2);
						if (match == null) {
							match = new PairwiseOrthoMatch (
									null,              // double [][] affine,
									new double [6][6], // double [][] jtj,
									Double.NaN,        // double rms,
									zoom_lev,          // int zoom_lev,
									overlap);          // double overlap)
							ortho_maps[indices[i]].setMatch(name2, match);
						} else {
							match.setOverlap(overlap); // just update overlap
						}
						num_overlaps_sel++;
						intersects[i][j] = true;
					}
				}
			}
		}
		
		int [] groups = new int [dmulti.length];
		for (int i = 0; i < groups.length; i++) {
			groups[i] = i;
		}
		for (int i = 0; i< (groups.length-1); i++) {
			for (int j = i+1; j < groups.length; j++) if (intersects[i][j] && (groups[j] != groups[i])){
				int g0 =  groups[i];
				int g1 =  groups[j];
				for (int k = 0; k < groups.length; k++) {
					if (groups[k] == g1) {
						groups[k] = g0;
					}
				}
			}
		}
		HashSet<Integer> hs = new HashSet<Integer>();
		for (int i:groups) {
			hs.add(i);
		}
		System.out.println("getIntersectedPairs(): num_overlaps_all="+num_overlaps_all+
				", num_overlaps_sel="+num_overlaps_sel+", number of disconnected groups="+hs.size());
		if (debugLevel > -4) {
			ShowDoubleFloatArrays.showArrays( 
					overlaps,
					"Overlaps");
		}
		if (orthoMapsCollection_path != null) {
        	try {
        		writeOrthoMapsCollection(orthoMapsCollection_path);
        	} catch (IOException e) {
        		// TODO Auto-generated catch block
        		e.printStackTrace();
        	}
        	if (debugLevel > -4) {
        		System.out.println("Saved data to "+ orthoMapsCollection_path);
        	}
		}
		return true;
	}

	
	
	
	
	public boolean getIntersectedPairs(
			CLTParameters    clt_parameters,
			String orthoMapsCollection_path) {

		int [] indices = getScenesSelection(
				clt_parameters, // CLTParameters       clt_parameters,				
				" to find intersects"); // String purpose)
		if (indices == null) {
			return false;
		}
		int     zoom_lev =     clt_parameters.imp.pwise_zoom; // -5;
		double  min_overlap_frac =  clt_parameters.imp.pwise_overlap; // 0.25;
		boolean bounds_to_indices = true;
		int debugLevel = clt_parameters.imp.pwise_debug;
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Get scene intersections",1200,300);
		gd.addNumericField("Zoom level",                 zoom_lev,  0,4,"",
				"Zoom level: +1 - zoom in twice, -1 - zoom out twice");
		gd.addNumericField("Minimal overlap",                min_overlap_frac,    3,7,"",
				"Minimal overlap as a fraction of the smaller image.");
		gd.addNumericField("Pairwise match debug level",  debugLevel, 0,3,"","Debug level during Spiral search.");

		gd.showDialog();
		if (gd.wasCanceled()) return false;
		zoom_lev =     (int) gd.getNextNumber();
		min_overlap_frac =   gd.getNextNumber();
		debugLevel=    (int) gd.getNextNumber();
		int [] wh =     new int[2];
		int [] origin = new int[2];
		double [][] centers =new double [indices.length][];			
		double [][] dmulti = renderMultiDouble (
				null,              // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
				indices,           // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
				bounds_to_indices, // boolean       bounds_to_indices,
				null,              // affines,    // double [][][] affines, // null or [indices.length][2][3]
				null,              // double [][]   equalize,
				true,              // boolean       ignore_equalize,
				null,              // warp,       // FineXYCorr    warp,,
				zoom_lev,          // int         zoom_level,
				wh,                // int []      wh,
				origin,            // int []      origin){ // maps[0] as a reference
				centers);          // double [][] centers)

		double [] overlaps = getFracOverlaps(
				dmulti); // final double [][] dmulti) {
		int num_overlaps_all = 0, num_overlaps_sel = 0;
		boolean [][] intersects = new boolean [dmulti.length][dmulti.length];
		for (int i = 0; i < overlaps.length; i++) if (overlaps[i] > 0){
			num_overlaps_all++;
			if (overlaps[i] >= min_overlap_frac) {
				num_overlaps_sel++;
				int row = i / dmulti.length;
				int col = i % dmulti.length;
				intersects[row][col] = true;
			}
		}
		int [] groups = new int [dmulti.length];
		for (int i = 0; i < groups.length; i++) {
			groups[i] = i;
		}
		for (int i = 0; i< (groups.length-1); i++) {
			for (int j = i+1; j < groups.length; j++) if (intersects[i][j] && (groups[j] != groups[i])){
				int g0 =  groups[i];
				int g1 =  groups[j];
				for (int k = 0; k < groups.length; k++) {
					if (groups[k] == g1) {
						groups[k] = g0;
					}
				}
			}
		}
		HashSet<Integer> hs = new HashSet<Integer>();
		for (int i:groups) {
			hs.add(i);
		}
		System.out.println("getIntersectedPairs(): num_overlaps_all="+num_overlaps_all+
				", num_overlaps_sel="+num_overlaps_sel+", number of disconnected groups="+hs.size());
		if (debugLevel > -4) {
			ShowDoubleFloatArrays.showArrays( 
					overlaps,
					"Overlaps");
		}

		boolean matches_ok= generatePairwiseMatches(
				clt_parameters,            // CLTParameters clt_parameters,
				min_overlap_frac,          // double  min_overlap_frac
				indices,                   // int []        indices,
				overlaps,                  // double [] overlaps,
				//			intersects,                // boolean [][]  boverlaps)
				orthoMapsCollection_path); // String orthoMapsCollection_path
		return matches_ok;
	}
	
	
	
	
	public boolean generatePairwiseMatches(
			CLTParameters clt_parameters,
			double        min_overlap_frac,
			int []        indices,
			double []     overlaps,			
			String        orthoMapsCollection_path) {
// gen number of pairs:
		int num_scenes = indices.length;
		int num_pairs = 0;
		int num_new = 0;
		for (int i = 0; i < indices.length-1; i++) {
			for (int j = i+1; j < indices.length; j++) if (overlaps[i * indices.length +j] >= min_overlap_frac){
				num_pairs++;
				int [] ipair = {indices[i], indices[j]};
				if ((ortho_maps[ipair[0]].getMatch(ortho_maps[ipair[1]].getName()) == null) &&
						(ortho_maps[ipair[1]].getMatch(ortho_maps[ipair[0]].getName()) == null)){
					num_new++;
				}
			}
		}
		
		boolean      skip_exist    = clt_parameters.imp.pwise_skip_exist;   // 
		boolean      refine_exist  = clt_parameters.imp.pwise_refine_exist; // if false, start from scratch, true - start from previous
		boolean      delete_failed = clt_parameters.imp.pwise_delete_fail;  // delete existing match if now failed
		boolean      gen_inverse   = clt_parameters.imp.pwise_gen_inverse;  // generate inverse matches
		boolean      save_each     = clt_parameters.imp.pwise_save_each;    // save state file after each match
		boolean      log_append    = clt_parameters.imp.pwise_log_append;   //
		String       log_path      = clt_parameters.imp.pwise_log_path;     // 
		int          debugLevel    = clt_parameters.imp.pwise_debug;        //
		
		//Initial spiral search for image matching
		double  search_step =         clt_parameters.imp.ospir_step;     // 8.0; // pix
		double  search_range =        clt_parameters.imp.ospir_range;    // 50.0; // pix
		double  double_threshold =    clt_parameters.imp.ospir_double;   //
		double  good_rms =            clt_parameters.imp.ospir_good_rms; // 0.27; //
		double  max_rms =             clt_parameters.imp.ospir_max_rms;  // 0.35; //
		int     min_overlap =         clt_parameters.imp.ospir_overlap;  // 3000; // do not try to match if there is too small overlap (scaled pixels)
		int     num_iter_lma =        clt_parameters.imp.ospir_num_iter; // 5;
		double [] max_rms_iter =      clt_parameters.imp.ospir_rms_iter; // {1.0, 0.6};//
		boolean spiral_ignore_rms =   clt_parameters.imp.ospir_ignore_rms; // false
		int     spiral_debug =        clt_parameters.imp.ospir_debug;    // 0;
		
		//Final pairwise scenes matching
		double  frac_remove  =        clt_parameters.imp.pmtch_frac_remove;// 0.15;
		double  metric_err =          clt_parameters.imp.pmtch_metric_err;// 0.05; // 0.02;//  2 cm
		boolean pmtch_use_affine =    clt_parameters.imp.pmtch_use_affine;		
		double  max_std =             clt_parameters.imp.pmtch_max_std;// 1.5;      // maximal standard deviation to limit center area  
		double  min_std_rad =         clt_parameters.imp.pmtch_min_std_rad;// 2.0;  // minimal radius of the central area (if less - fail)
		boolean ignore_prev_rms =     clt_parameters.imp.pmtch_ignore_rms;// true; 
		int     num_tries =           clt_parameters.imp.pmtch_num_iter;// 10;
		
		double rad_fraction =         clt_parameters.imp.pmtch_cent_rad; // center circle radius fraction of 0.5* min(width, height) in tiles
		double max_tile_rad =         clt_parameters.imp.pmtch_max_cent_rad;// maximal center radius in tiles (limit pmtch_cent_rad)
		double fill_fraction =        clt_parameters.imp.pmtch_cent_fill; // should be populated not less than this
		double fill_fraction_final =  clt_parameters.imp.pmtch_cent_final; // should be populated not less than this during final pass
		double ease_nosfm =           clt_parameters.imp.pmtch_ease_nosfm; // ease metric_error when no SfM gain == 0;
		double pull_skew =            clt_parameters.imp.pmtch_pull_skew;        // ~rotation, = 0 fraction of the total weight == 1
		double pull_tilt =            clt_parameters.imp.pmtch_pull_tilt;     // > 0
		double pull_scale =           clt_parameters.imp.pmtch_pull_scale;       // = 0
		
		int min_scene =              0;
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Pairwise Match Parameters",1200,1000);
		gd.addMessage("Number of scenes - "+num_scenes+
				", number of pairs (w/o inverse) - "+num_pairs+
				", number of new pairs - "+num_new);
	    gd.addCheckbox    ("Skip existing",               skip_exist, "Do not regenerate if match with same or higher resolution exists.");
	    gd.addCheckbox    ("Refine existing",             refine_exist, "Refine existing matches (false - start from scratch with spiral search).");
		gd.addCheckbox    ("Delete failed",               delete_failed, "Delete previous matches if it failed now.");
	    gd.addCheckbox    ("Generate inverse matches",    gen_inverse, "Generate (refine if exist and enabled) inverse matches.");
	    
	    gd.addCheckbox    ("Save state after each match", save_each, "Update state file after each match generation to mitigate possible crashes.");
	    gd.addCheckbox    ("Write log file",              log_append, "Enable writing log file with matching results.");
	    gd.addStringField ("Log file full path",          log_path, 150, "Path of the log file to be appended.");	
		gd.addNumericField("Pairwise match debug level",  debugLevel, 0,3,"","Debug level during Spiral search.");
		
		gd.addMessage  ("Initial spiral search for image matching");
		gd.addNumericField("Spiral search step",          search_step,  3,7,"scaled pix",	"Distance between spiral search probes, in scaled pixels.");
		gd.addNumericField("Spiral search radius",        search_range, 3,7,"scaled pix",	"Maximal radius of the spiral search, in scaled pixels.");
		gd.addNumericField("Mitigate small overlap",      double_threshold, 3,7,"","For small overlaps increase zoom by 1 and range - twice.");
		gd.addNumericField("RMSE to end search",          good_rms,     3,7,"scaled pix",	"Maximal RMSE to consider match, in scaled pixels.");
		gd.addNumericField("Satisfactory RMSE",           max_rms,      3,7,"scaled pix",	"Maximal RMSE to consider match, in scaled pixels.");
		gd.addNumericField("Minimal overlap",             min_overlap,  0,4,"scaled pix ^ 2","Minimal overlap area in square scaled pixels.");
		gd.addNumericField("LMA iterations",              num_iter_lma, 0,2,"",              "Number of LMA iterations during spiral search.");
		gd.addNumericField("RMSE at first iteration",     max_rms_iter[0],  3,7,"scaled pix","Maximal RMSE at first iteration.");
		gd.addNumericField("RMSE at second iteration",    max_rms_iter[1],  3,7,"scaled pix","Maximal RMSE at second iteration.");
		
		gd.addCheckbox    ("Ignore worsening RMSE",       spiral_ignore_rms, "Ignore worsening/not improving RMSE during spiral search.");
		gd.addNumericField("Spiral search debug level",   spiral_debug, 0,3,"","Debug level during Spiral search.");

		gd.addMessage  ("Final pairwise scenes matching");
		gd.addNumericField("Remove fraction of worst matches", frac_remove,  3,7,"",	"When fitting scenes remove this fraction of worst match tiles.");
		gd.addNumericField("Maximal metric error",             metric_err,  3,7,"m",	"Maximal tolerable fitting error caused by elevation variations.");
		gd.addCheckbox    ("Use scenes' affine",               pmtch_use_affine, "Use known scenes' affine matrices, false - start from scratch (unity) ones.");
		gd.addNumericField("Central area standard deviation",  max_std,  3,7,"",	"Central area limit by the standard deviation.");
		gd.addNumericField("Central area minimal radius",      min_std_rad,  3,7,"tile",	"Minimal radius of the central area after all LMA passes.");
		gd.addCheckbox    ("Ignore previous RMSE",             ignore_prev_rms, "Do not exit full fitting cycles if the RMSE worsened/not improved.");
		gd.addNumericField("Number of fitting iterations",     num_tries, 0,3,"","number of full fittng iterations.");
		gd.addNumericField("Central area radius as fraction",  rad_fraction,   3,7,"",	"Central area radius as fraction of half minimal WOI dimension.");
		gd.addNumericField("Maximal central area radius",      max_tile_rad,   3,7,"tiles",	"Absolute limit to the center area radius (eases bad peripheral matching).");
		gd.addNumericField("Central area minimal fill",        fill_fraction,  3,7,"",	"Central area minimal fill for all but the last iteration.");
		gd.addNumericField("Central area minimal fill final",  fill_fraction_final, 3,7,"",	"Central area minimal fill for the last iteration.");
		gd.addNumericField("Relax metric error for no-SfM",    ease_nosfm, 3,7,"",	"Relax metric error for no-SfM scenes (sfm_gain==0).");
		gd.addNumericField("Pull skew (rotation)",             pull_skew, 3,7,"",	"Prevent pairwise match from rotation.");
		gd.addNumericField("Pull tilt",                        pull_tilt, 3,7,"",	"Prevent pairwise match from tilt.");
		gd.addNumericField("Pull scale",                       pull_scale, 3,7,"",	"Prevent pairwise match from scaling.");
		gd.addNumericField("Start scene (skip all earlier)",   min_scene, 0,3,"","To be able to continue skipping some.");
		//
		
		gd.showDialog();
		if (gd.wasCanceled()) return false;
		skip_exist       = gd.getNextBoolean();
		refine_exist     = gd.getNextBoolean();
		delete_failed    = gd.getNextBoolean();
		gen_inverse      = gd.getNextBoolean();
		save_each        = gd.getNextBoolean();
		log_append       = gd.getNextBoolean();
		log_path         = gd.getNextString();
		debugLevel = (int) gd.getNextNumber(); 	
		
		search_step      =       gd.getNextNumber();        
		search_range     =       gd.getNextNumber();
		double_threshold =       gd.getNextNumber();
		good_rms         =       gd.getNextNumber();
		max_rms          =       gd.getNextNumber();
		min_overlap      = (int) gd.getNextNumber();
		num_iter_lma     = (int) gd.getNextNumber();
		max_rms_iter[0]  =       gd.getNextNumber();
		max_rms_iter[1]  =       gd.getNextNumber();
		spiral_ignore_rms=       gd.getNextBoolean();
		spiral_debug     = (int) gd.getNextNumber();
		                         
		frac_remove      =       gd.getNextNumber();
		metric_err       =       gd.getNextNumber();
		pmtch_use_affine=        gd.getNextBoolean();
		max_std          =       gd.getNextNumber();
		min_std_rad      =       gd.getNextNumber();
		ignore_prev_rms  =       gd.getNextBoolean();
		num_tries        = (int) gd.getNextNumber();		

		rad_fraction =           gd.getNextNumber();
		max_tile_rad =           gd.getNextNumber();		
		fill_fraction =          gd.getNextNumber();  
		fill_fraction_final=     gd.getNextNumber();   
		ease_nosfm =             gd.getNextNumber();
		pull_skew =              gd.getNextNumber();
		pull_tilt =              gd.getNextNumber();
		pull_scale =             gd.getNextNumber();
		min_scene =        (int) gd.getNextNumber();
		
		return generatePairwiseMatches(
				clt_parameters,           // CLTParameters clt_parameters,
				min_overlap_frac,          // double  min_overlap_frac,
				indices,                  // int []       indices,
				overlaps,                 // double [] overlaps,
				skip_exist,               // boolean      skip_existing,
				refine_exist,             // boolean      refine_existing, // if false, start from scratch, true - start from previous
				delete_failed,            // boolean       delete_failed,   // if false, start from scratch, true - start from previous
				gen_inverse,              // boolean      gen_inverse,    // generate inverse matches
				save_each,                // boolean      save_each,       // save state file after each match
				log_append,               // boolean      log_append,      //
				log_path,                 // String       log_path,
				orthoMapsCollection_path, // String orthoMapsCollection_path
				search_step,              // double        search_step,
				search_range,             // double        search_range,
				good_rms,                 // double        good_rms,
				max_rms,                  // double        max_rms,
				min_overlap,              // int           min_overlap,
				num_iter_lma,             // int           num_iter_lma,
				spiral_ignore_rms,        // boolean       ignore_rms,
				spiral_debug,             // int           spiral_debug,
				frac_remove,              // double        frac_remove,
				metric_err,               // double        metric_error,
				pmtch_use_affine,         // boolean       pmtch_use_affine,				
				max_std,                  // double        max_std,  
				min_std_rad,              // double        min_std_rad,
				ignore_prev_rms,          // boolean       ignore_prev_rms, 
				num_tries,                // int           num_tries,
				rad_fraction,             // double        rad_fraction,
				max_tile_rad,             // double        max_tile_rad,
				fill_fraction,            // double        fill_fraction,
				fill_fraction_final,      // double        fill_fraction_final,
				ease_nosfm,               // double        ease_nosfm,
				double_threshold,         // double        double_threshold,
				max_rms_iter,             // double []     max_rms_iter,
				min_scene,                // int           min_scene,
				pull_skew,                // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
				pull_tilt,                // double           pull_tilt,        // > 0
				pull_scale,               // double           pull_scale,       // = 0
				debugLevel);              // int          debugLevel
	}
	
	public boolean generatePairwiseMatches(
			CLTParameters clt_parameters,
			double        min_overlap_frac,
			int []        indices,
			double []     overlaps,
			boolean       skip_existing,
			boolean       refine_existing, // if false, start from scratch, true - start from previous
			boolean       delete_failed,   // if false, start from scratch, true - start from previous
			boolean       gen_inverse,     // generate inverse matches
			boolean       save_each,       // save state file after each match
			boolean       log_append,      //
			String        log_path,
			String        orthoMapsCollection_path,
			
			double        search_step,
			double        search_range_in,
			double        good_rms,
			double        max_rms,
			int           min_overlap,
			int           num_iter_lma,
			boolean       ignore_rms,
			int           spiral_debug,
			
			double        frac_remove,
			double        metric_error,
			boolean       pmtch_use_affine,			
			double        max_std,  
			double        min_std_rad,
			boolean       ignore_prev_rms, 
			int           num_tries,
			double        rad_fraction,
			double        max_tile_rad,
			double        fill_fraction,
			double        fill_fraction_final,
			double        ease_nosfm,
			double        double_threshold,
			double []     max_rms_iter,
			int           min_scene,
			double        pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
			double        pull_tilt,        // > 0
			double        pull_scale,       // = 0
			int           debugLevel) {
		
		boolean batch_mode = true;
		int num_scenes = indices.length;
		int num_pairs = 0;
		int num_new = 0;
		
		ArrayList<Point> pairs = new ArrayList<Point>();
		for (int i = 0; i < indices.length-1; i++) {
			for (int j = i+1; j < indices.length; j++) if (overlaps[i * indices.length +j] >= min_overlap_frac){
				pairs.add(new Point(i,j));
				if (gen_inverse) {
					pairs.add(new Point(j,i));
				}
				num_pairs++;
				int [] ipair = {indices[i], indices[j]};
				if ((ortho_maps[ipair[0]].getMatch(ortho_maps[ipair[1]].getName()) == null) &&
						(ortho_maps[ipair[1]].getMatch(ortho_maps[ipair[0]].getName()) == null)){
					num_new++;
				}
			}
		}
		
		if (log_append && (log_path != null)) { // assuming directory exists
			StringBuffer sb = new StringBuffer();
			sb.append(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(Calendar.getInstance().getTime())+"\n");
			sb.append("num_scenes\t"+  num_scenes+"\n");
			sb.append("pairs.size()\t"+pairs.size()+"\n");
			sb.append("num_pairs\t"+   num_pairs+"\n");
			sb.append("num_new\t"+     num_new+"\n");
			sb.append(String.format("%4s\t%4s\t%17s\t%17s\t%6s\t%3s\t%4s,\t%4s\t%6s\t%6s\t%7s\n",
					"scn1","scn2","timestamp1","timestamp2","ovrlp","zl","nx","ny","RMS-sp","RMSfin","fzl","removed"));
			CalibrationFileManagement.saveStringToFile (
					log_path,          //String path,
					sb.toString(), // data,
					true); // boolean append)
			if (debugLevel>-3) {
				System.out.print(sb.toString());
			}
		}
		ArrayList<Point> failed_pairs = new ArrayList<Point>();
		ArrayList<Point> new_pairs =    new ArrayList<Point>(); // started from spiral, not from the same or inverse
		for (Point pair:pairs) {
			int [] ipair = {indices[pair.x], indices[pair.y]};
			if (ipair[0] < min_scene) {
				System.out.println ("Skipping "+ipair[0]+":"+ipair[1]+" until "+min_scene);
				continue;
			}
			boolean direct = indices[pair.x] < indices[pair.y];
	    	int min_zoom_lev = ortho_maps[ipair[0]].getOriginalZoomLevel();
	    	int max_zoom_lev = ortho_maps[ipair[0]].getOriginalZoomLevel();
	    	double max_agl =   ortho_maps[ipair[0]].getAGL();
	    	for (int i = 0; i < ipair.length; i++) {
	    		max_agl =      Math.max(max_agl, ortho_maps[ipair[i]].getAGL());	    		
	    		min_zoom_lev = Math.min(min_zoom_lev, ortho_maps[ipair[i]].getOriginalZoomLevel());
	    		max_zoom_lev = Math.max(max_zoom_lev, ortho_maps[ipair[i]].getOriginalZoomLevel());
	    	}
        	double agl_ratio = max_agl/50.0;
        	double metric_error_adj = metric_error * agl_ratio * agl_ratio; // metric_error settings is good for 50m. Increase for higher Maybe squared?
	    	int initial_zoom = max_zoom_lev - 4;  // another algorithm?
	    	// overlaps
	    	int overlap_indx = direct ? (pair.x * indices.length + pair.y) : (pair.y * indices.length + pair.x);
	    	double overlap_frac = overlaps[overlap_indx];
	    	double search_range = search_range_in;
	    	while (overlap_frac < double_threshold) {
	    		overlap_frac *= 2;
	    		initial_zoom += 1;
	    		search_range *= 2;
	    	}
	    	
			PairwiseOrthoMatch direct_match = ortho_maps[ipair[0]].getMatch(ortho_maps[ipair[1]].getName());
			PairwiseOrthoMatch inv_match =  ortho_maps[ipair[1]].getMatch(ortho_maps[ipair[0]].getName());
			boolean use_direct =  false;
			boolean use_inverse = false;
			boolean skip =        false;
			if (!direct && (inv_match != null)) { // prefer inverse
				use_inverse = true;
			} else if (direct_match != null) {
				if (skip_existing && (direct_match.overlap > 0)) { // do not skip old pairs - refine them
					skip = true;
				} else if (refine_existing) {
					use_direct = true;
				} // else will start from scratch
			} else if (inv_match != null) {
				if (direct && refine_existing) {
					use_inverse = true;
				}
			}
			if (skip) {
				if (log_append && (log_path != null)) { // assuming directory exists
					StringBuffer sb = new StringBuffer();
					sb.append(String.format("%4d\t%4d\t%s\t%s\t%6.4f\t%3d\tSKIP\t\t\t%6.4f\t%3d\n",
							ipair[0], ipair[1],
							ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
							overlaps[overlap_indx],
							initial_zoom,
							direct_match.rms,
							direct_match.zoom_lev));
					CalibrationFileManagement.saveStringToFile (
							log_path,          //String path,
							sb.toString(), // data,
							true); // boolean append)
				}
				continue;
			}
			PairwiseOrthoMatch pairwiseOrthoMatch = null;
			
			// unityAffine()
			
			double [][] affine0 = pmtch_use_affine?ortho_maps[ipair[0]].getAffine():unityAffine(); // {{1,0,0},{0,1,0}}; // will always stay the same
			double [][] affine1 = pmtch_use_affine?ortho_maps[ipair[0]].getAffine():unityAffine(); // {{1,0,0},{0,1,0}}; // here (manual mode) start from the center, may use prediction in auto
			double [][][] affines = new double[][][] {affine0,affine1};
			double spiral_rms = Double.NaN;
			if (use_direct) {
				pairwiseOrthoMatch=direct_match;
			} else if (use_inverse) {
				double [] enuOffset = ortho_maps[ipair[0]].enuOffsetTo(ortho_maps[ipair[1]]);
				double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
				// create inverted pairwiseOrthoMatch
				pairwiseOrthoMatch = inv_match.getInverse(rd);
			} else { // run spiral search
				// now always unity, but after partial adjustment may be non-unity
				// TODO: Not yet tested with intermediate adjustment.
				pairwiseOrthoMatch = SpiralMatch (
						clt_parameters,  // CLTParameters    clt_parameters,
						frac_remove,     // double           frac_remove, //  =        0.25
						metric_error_adj,// double           metric_error,
						pmtch_use_affine, // boolean          pmtch_use_affine,
						max_std,         // double           max_std,     // maximal standard deviation to limit center area  
						min_std_rad,     // double           min_std_rad, // minimal radius of the central area (if less - fail)
						rad_fraction,    // double           rad_fraction,
						max_tile_rad,    // double           max_tile_rad, //  = 30;						
						fill_fraction,   // double           fill_fraction,
						fill_fraction_final, // double           fill_fraction_final,
						ease_nosfm,      // double           ease_nosfm,
						ipair,           // int []           gpu_pair,
						affines,         // double [][][]    affines_init,  // here in meters, relative to vertical points
						initial_zoom,    // int              zoom_lev,
						search_step,     // double           pix_step,
						search_range,    // double           pix_range,
						good_rms,        // double           good_rms,
						max_rms,         // 			double           max_rms,
						num_iter_lma,    // int              num_tries, //  = 5
						min_overlap,     // int              min_overlap, // 3000
						ignore_rms,      // boolean          ignore_rms,
						max_rms_iter,    // double []        max_rms_iter, //  = {1.0, 0.6};//
						overlaps[overlap_indx], // double           overlap,
						pull_skew,        // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
						pull_tilt,        // double           pull_tilt,        // > 0
						pull_scale,       // double           pull_scale,       // = 0
						spiral_debug);   // int              debugLevel)
				// late failure
				if ((pairwiseOrthoMatch != null) && !Double.isNaN(pairwiseOrthoMatch.rms) && !pairwiseOrthoMatch.ok) {
//					String str_failed = delete_failed?
//							"%4d\t%4d\t%s\t%s\t%6.4f\t%3d\tFAILED\tREMOVED\n":
//							"%4d\t%4d\t%s\t%s\t%6.4f\t%3d\tFAILED\n";
					String str_failed = delete_failed?
							"%4d\t%4d\t%s\t%s\t%6.4f\t%3d\t%3d\t%3d\t%6.4f\tREMOVED\n":
							"%4d\t%4d\t%s\t%s\t%6.4f\t%3d\t%3d\t%3d\t%6.4f\n";
					if (log_append && (log_path != null)) { // assuming directory exists
						StringBuffer sb = new StringBuffer();
						sb.append(String.format(str_failed,
								ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
								overlaps[overlap_indx],  initial_zoom,
								pairwiseOrthoMatch.nxy[0],pairwiseOrthoMatch.nxy[1],pairwiseOrthoMatch.rms));
						CalibrationFileManagement.saveStringToFile (
								log_path,          //String path,
								sb.toString(), // data,
								true); // boolean append)
					}
				}
				if ((pairwiseOrthoMatch == null) || !pairwiseOrthoMatch.ok) {
					if (delete_failed) {
						ortho_maps[ipair[0]].unsetMatch(ortho_maps[ipair[1]].getName());
					}
					if ((pairwiseOrthoMatch != null) && Double.isNaN(pairwiseOrthoMatch.rms)) {
						String str_failed = delete_failed?"%4d\t%4d\t%s\t%s\t%6.4f\t%3d\tFAILED\tREMOVED\n":"%4d\t%4d\t%s\t%s\t%6.4f\t%3d\tFAILED\n";
						if (log_append && (log_path != null)) { // assuming directory exists
							StringBuffer sb = new StringBuffer();
							sb.append(String.format(str_failed,
									ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
									overlaps[overlap_indx],  initial_zoom));
							CalibrationFileManagement.saveStringToFile (
									log_path,          //String path,
									sb.toString(), // data,
									true); // boolean append)
						}
					}
					failed_pairs.add(pair);
					pairwiseOrthoMatch = null;
					continue;
				} else {
					spiral_rms = pairwiseOrthoMatch.rms;
					new_pairs.add(pair); // adjusted with spiral
				}
			}
			// refine match with high resolution
			affines[1] = pairwiseOrthoMatch.getAffine();
			affines[1][0] = affines[1][0].clone(); 
			affines[1][1] = affines[1][1].clone();
			Rectangle woi = new Rectangle(); // used to return actual woi from correlateOrthoPair()			
			correlateOrthoPair(
					clt_parameters,  // CLTParameters    clt_parameters,
					pairwiseOrthoMatch, //PairwiseOrthoMatch pairwiseOrthoMatch, // will return statistics
					0,                // 			int              min_overlap,
					max_std,         // double           max_std,      // maximal standard deviation to limit center area  
					min_std_rad,     // double           min_std_rad,  // minimal radius of the central area (if less - fail)
					frac_remove,     // double           frac_remove, //  =        0.25
					metric_error_adj,// 			double           metric_error,
					ignore_prev_rms, // boolean ignore_prev_rms,
					num_tries,       //  = 5int              num_tries, //  = 5
					false, // ,            // boolean          calc_warp, (will return null if false)
					batch_mode,      // boolean          batch_mode,
					ipair,           // String []        gpu_spair,
					affines,         // double [][][]    affines, // on top of GPS offsets
					woi,             // Rectangle        woi,
					min_zoom_lev,    // int              zoom_lev,
					false, // show_vf,         // boolean show_vf,
					null, // ground_planes,   // double [][]      ground_planes, // null or double[2] - will return ground planes
					rad_fraction,    // double           rad_fraction,
					max_tile_rad,    // double           max_tile_rad, //  = 30;
					fill_fraction,   // double           fill_fraction,
					fill_fraction_final, // double           fill_fraction_final,
					ease_nosfm,      // double           ease_nosfm,
					null,            //  double []        max_rms_iter, //  = {1.0, 0.6};//	
					pull_skew,        // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
					pull_tilt,        // double           pull_tilt,        // > 0
					pull_scale,       // double           pull_scale,       // = 0
					debugLevel-4);   // final int        debugLevel)
			boolean failed_refine = Double.isNaN(pairwiseOrthoMatch.rms);
			// Create log line and write it
			StringBuffer sb = new StringBuffer();
			sb.append(String.format("%4d\t%4d\t%s\t%s\t%6.4f\t%3d",
					ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
					overlaps[overlap_indx],  initial_zoom));

			if (use_direct || use_inverse) {
				sb.append("\t\t\t"); 
			} else {
				sb.append(String.format("\t%3d\t%3d\t%6.4f",
						pairwiseOrthoMatch.nxy[0],pairwiseOrthoMatch.nxy[1],spiral_rms)); 
			}
			if (failed_refine) {
				if (delete_failed) {
					ortho_maps[ipair[0]].unsetMatch(ortho_maps[ipair[1]].getName());
				}
				String str_failed = delete_failed?"\tFAILED\t\tREMOVED\n":"\tFAILED\n";

				failed_pairs.add(pair);
				sb.append(String.format(str_failed));
				if (debugLevel > -4) System.out.print("Final adjustment (1)"+str_failed);				
			} else {
				pairwiseOrthoMatch.overlap = overlaps[overlap_indx]; // needed here if refining old/manual w/o overlap 
				sb.append(String.format("\t%6.4f\t%3d\n",pairwiseOrthoMatch.rms,pairwiseOrthoMatch.zoom_lev)); 
				if (debugLevel > -4) System.out.println("Final adjustment (2) RMSE="+pairwiseOrthoMatch.rms+
						", overlap = "+pairwiseOrthoMatch.overlap);				
				ortho_maps[ipair[0]].setMatch(ortho_maps[ipair[1]].getName(),pairwiseOrthoMatch);
				if (save_each && (orthoMapsCollection_path != null)) {
		        	try {
		        		writeOrthoMapsCollection(orthoMapsCollection_path);
		        	} catch (IOException e) {
		        		// TODO Auto-generated catch block
		        		e.printStackTrace();
		        	}
		        	if (debugLevel > -4) {
		        		System.out.println("Saved data to "+ orthoMapsCollection_path);
		        	}
				}
			}
			if (log_append && (log_path != null)) { // assuming directory exists
				CalibrationFileManagement.saveStringToFile (
						log_path,          //String path,
						sb.toString(), // data,
						true); // boolean append)
			}			
			// save if save_each
			// does it have direct or inverted pair
		}
		if (log_append && (log_path != null)) { // assuming directory exists
			StringBuffer sb = new StringBuffer();
			sb.append("\nSUMMARY\n");
			sb.append("good\t"+(pairs.size()-failed_pairs.size())+"\n");
			sb.append("new\t"+ new_pairs.size()+"\n");
			sb.append("failed\t"+failed_pairs.size()+"\n");
			if (!failed_pairs.isEmpty()) {
				for (int i = 0; i < failed_pairs.size(); i++) {
					int [] ipair = {indices[failed_pairs.get(i).x], indices[failed_pairs.get(i).y]};
					sb.append(String.format("%4d\t%4d\t%s\t%s\n",
							ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName()));
				}
			}
			CalibrationFileManagement.saveStringToFile (
					log_path,          //String path,
					sb.toString(), // data,
					true); // boolean append)
        	if (debugLevel > -4) {
        		System.out.println("Appended log file "+ log_path);
        	}
		}
		if (orthoMapsCollection_path != null) {
        	try {
        		writeOrthoMapsCollection(orthoMapsCollection_path);
        	} catch (IOException e) {
        		// TODO Auto-generated catch block
        		e.printStackTrace();
        	}
        	if (debugLevel > -4) {
        		System.out.println("Saved data to "+ orthoMapsCollection_path);
        	}
		}
		return true;
	}


	
	/**
	 * Add new scene pairs from the already adjusted scenes
	 * @param clt_parameters
	 * @param orthoMapsCollection_path
	 * @return
	 */
	
	public boolean augmentPairwiseAffines(
			CLTParameters clt_parameters,
			String        orthoMapsCollection_path) {
		// Create list of all pairs (after recreating all overlaps with updated affines)
		ArrayList<Point> pairs_list = new ArrayList<Point>(); 
		for (OrthoMap map : ortho_maps) {
			for (String other_name: map.pairwise_matches.keySet()) {
				pairs_list.add(new Point(
						getIndex(map.getName()),
						getIndex(other_name)));
			}
		}
		// sort pairs_list by x then y
		Collections.sort(pairs_list, new Comparator<Point>() {
			@Override
			public int compare(Point lhs, Point rhs) {
				return (rhs.x > lhs.x) ? -1 : (rhs.x < lhs.x) ? 1 :
					((rhs.y > lhs.y) ? -1 : (rhs.y < lhs.y) ? 1 : 0); // increasing
			}
		});

		// convert ArrayList<Point> to array int[][]
		int [][] available_pairs = new int [pairs_list.size()][2];
		for (int i = 0; i < available_pairs.length; i++) {
			available_pairs[i][0] = pairs_list.get(i).x;
			available_pairs[i][1] = pairs_list.get(i).y;
		}
		
		boolean flt_undef_only =     false; // clt_parameters.imp.flt_undef_only;    //  false;
		double  flt_min_overlap =    clt_parameters.imp.flt_min_overlap;   //  0.0;
		double  flt_max_overlap =    clt_parameters.imp.flt_max_overlap;   //  1.0;
		boolean flt_filt_zoom =      clt_parameters.imp.flt_filt_zoom;     //  true;
		int     flt_min_zoom =       clt_parameters.imp.flt_min_zoom;      // -2;
		int     flt_max_zoom =       clt_parameters.imp.flt_max_zoom;      // 10;
		double  flt_min_sfm =        clt_parameters.imp.flt_min_sfm;       //  0.0;
		double  flt_max_sfm =        clt_parameters.imp.flt_max_sfm;       //1000.0;
        int     flt_alt =            clt_parameters.imp.flt_alt;           // 0;

//		double  flt_min_rms =        0;     // clt_parameters.imp.flt_min_rms;       //  0.0;
//		double  flt_max_rms =        2.0;   // clt_parameters.imp.flt_max_rms;       //  2.0;
        double  flt_min_rms =        clt_parameters.imp.flt_min_rms;       //  0.0;
		double  flt_max_rms =        clt_parameters.imp.flt_max_rms;       //  2.0;
		boolean flt_nan_rms =        true;  // clt_parameters.imp.flt_nan_rms;       //  false;
        
		boolean flt_show_names =     true;  // clt_parameters.imp.flt_show_names;    //  true;
		boolean flt_show_overlaps =  true;  // clt_parameters.imp.flt_show_overlaps; //  true;
		boolean flt_show_rms =       true;  // clt_parameters.imp.flt_show_rms;      //  true;
		boolean flt_show_zoom =      true;  // clt_parameters.imp.flt_show_zoom;     //  true;
		boolean flt_show_alt =       true;  // clt_parameters.imp.flt_show_alt;     //  true;
		//Initial spiral search for image matching		
		boolean ospir_augment =       clt_parameters.imp.ospir_augment;    // true
		double  max_rms =             clt_parameters.imp.ospir_max_rms;    // 0.35; //
		double  max_rms_refine =      clt_parameters.imp.pwise_max_rms;    // 0.35; //
		int     min_overlap_tiles =   clt_parameters.imp.ospir_overlap;    // 3000; // do not try to match if there is too small overlap (scaled pixels)
		double  double_threshold =    clt_parameters.imp.ospir_double;     // increase resolution if too small overlap in tiles
		int     num_iter_lma =        clt_parameters.imp.ospir_num_iter;   // 5;
		double [] max_rms_iter =      clt_parameters.imp.ospir_rms_iter;   // {1.0, 0.6};//
		boolean lores_ignore_rms =    clt_parameters.imp.ospir_ignore_rms; // false
		
		//Final pairwise scenes matching
		double  frac_remove  =        clt_parameters.imp.pmtch_frac_remove;// 0.15;
		double  metric_err =          clt_parameters.imp.pmtch_metric_err;// 0.05; // 0.02;//  2 cm
//		boolean pmtch_use_affine =    clt_parameters.imp.pmtch_use_affine;		
		double  max_std =             clt_parameters.imp.pmtch_max_std;// 1.5;      // maximal standard deviation to limit center area  
		double  min_std_rad =         clt_parameters.imp.pmtch_min_std_rad;// 2.0;  // minimal radius of the central area (if less - fail)
		boolean ignore_prev_rms =     clt_parameters.imp.pmtch_ignore_rms;// true; 
		int     num_tries =           clt_parameters.imp.pmtch_num_iter;// 10;
		double rad_fraction =         clt_parameters.imp.pmtch_cent_rad; // center circle radius fraction of 0.5* min(width, height) in tiles
		double max_tile_rad =         clt_parameters.imp.pmtch_max_cent_rad;// maximal center radius in tiles (limit pmtch_cent_rad)
		double fill_fraction =        clt_parameters.imp.pmtch_cent_fill; // should be populated not less than this
		double fill_fraction_final =  clt_parameters.imp.pmtch_cent_final; // should be populated not less than this during final pass
		double ease_nosfm =           clt_parameters.imp.pmtch_ease_nosfm; // ease metric_error when no SfM gain == 0;
		int    min_scene =            0;
		double pull_skew =            clt_parameters.imp.pmtch_pull_skew;        // ~rotation, = 0 fraction of the total weight == 1
		double pull_tilt =            clt_parameters.imp.pmtch_pull_tilt;     // > 0
		double pull_scale =           clt_parameters.imp.pmtch_pull_scale;       // = 0
		// log/save parameters
		boolean save_each     =       clt_parameters.imp.pwise_save_each;    // save state file after each match
		boolean log_append    =       clt_parameters.imp.pwise_log_append;   //
		String  log_path      =       clt_parameters.imp.pwise_log_path;     // 
		int     debugLevel    =       clt_parameters.imp.pwise_debug;        //
		
		boolean flt_update_config =  false;
		
		GenericJTabbedDialog gdf = new GenericJTabbedDialog("Select pairs filter/display",800,1200);
		gdf.addMessage("Filter pairs parameters");
		gdf.addNumericField("Minimal scene overlap (0..1)",flt_min_overlap,  3,7,"", "Minimal overlap of the scenes to keep (0-no overlap, 1.0 - smaller scene is inside the parger one.");
		gdf.addNumericField("Maximal scene overlap (0..1)",flt_max_overlap,  3,7,"", "Maximal overlap of the scenes to keep (0-no overlap, 1.0 - smaller scene is inside the parger one.");
		gdf.addCheckbox    ("Filter by zoom level"  ,      flt_filt_zoom, "Filter by the zoom level used for matching.");
		gdf.addNumericField("Minimal zoom",                flt_min_zoom, 0,3,"","Minimal zoom level used for matching.");
		gdf.addNumericField("Maximal zoom",                flt_max_zoom, 0,3,"","Maximal zoom level used for matching.");
		gdf.addNumericField("Minimal SfM gain",            flt_min_sfm,  3,7,"","Minimal SfM gain of the minimum in the scene pair.");
		gdf.addNumericField("Maximal SfM gain",            flt_max_sfm,  3,7,"","Maximal SfM gain of the minimum in the scene pair.");
		gdf.addMessage("Normally, NaN RMS should be selected for new pairs. Other settings to re-adjust previously adjusted ones!!!");
 		gdf.addNumericField("Minimal RMSE",                flt_min_rms,  3,7,"",	 "Minimal LMA RMSE of the scene pair.");
		gdf.addNumericField("Maximal RMSE",                flt_max_rms,  3,7,"",	 "Maximal LMA RMSE of the scene pair.");
		gdf.addCheckbox    ("NaN RMS (failed match)",      flt_nan_rms, "Keep only failed matches with RMSE=NaN.");
		
		gdf. addChoice("Filter by pairwise ALT availability",IntersceneMatchParameters.FLT_ALT_MODES, IntersceneMatchParameters.FLT_ALT_MODES[flt_alt],"Filter by pairwise ALT availability.");

		gdf.addMessage("Low-resolution match parameters");
		gdf.addCheckbox    ("Use low-res in augmentation", ospir_augment, "Use low-res matching during augmenting (false - skip, go to high-res).");
		gdf.addNumericField("Good RMSE, low-res",          max_rms,      3,7,"scaled pix",	"Maximal RMSE to consider match, in scaled pixels, during spiral.");
		gdf.addNumericField("Good RMSE, final",            max_rms_refine,3,7,"scaled pix",	"Maximal RMSE to consider match, in scaled pixels, during refine.");
		gdf.addNumericField("Minimal overlap",             min_overlap_tiles,  0,4,"scaled pix ^ 2","Minimal overlap area in square scaled pixels.");
		gdf.addNumericField("Mitigate small overlap",      double_threshold, 3,7,"","For small overlaps increase zoom by 1 and range - twice.");
		gdf.addNumericField("LMA iterations",              num_iter_lma, 0,2,"",              "Number of LMA iterations during spiral search.");
		gdf.addNumericField("RMSE at first iteration",     max_rms_iter[0],  3,7,"scaled pix","Maximal RMSE at first iteration.");
		gdf.addNumericField("RMSE at second iteration",    max_rms_iter[1],  3,7,"scaled pix","Maximal RMSE at second iteration.");
		gdf.addCheckbox    ("Ignore worsening low-res RMSE",lores_ignore_rms, "Ignore worsening/not improving RMSE low-res matching.");
		gdf.addMessage  ("Final (high-res) pairwise scenes matching");
		gdf.addNumericField("Remove fraction of worst matches", frac_remove,  3,7,"",	"When fitting scenes remove this fraction of worst match tiles.");
		gdf.addNumericField("Maximal metric error",             metric_err,  3,7,"m",	"Maximal tolerable fitting error caused by elevation variations.");
//		gdf.addCheckbox    ("Use scenes' affine",               pmtch_use_affine, "Use known scenes' affine matrices, false - start from scratch (unity) ones.");
		gdf.addNumericField("Central area standard deviation",  max_std,  3,7,"",	"Central area limit by the standard deviation.");
		gdf.addNumericField("Central area minimal radius",      min_std_rad,  3,7,"tile",	"Minimal radius of the central area after all LMA passes.");
		gdf.addCheckbox    ("Ignore previous RMSE",             ignore_prev_rms, "Do not exit full fitting cycles if the RMSE worsened/not improved.");
		gdf.addNumericField("Number of fitting iterations",     num_tries, 0,3,"","number of full fittng iterations.");
		gdf.addNumericField("Central area radius as fraction",  rad_fraction,   3,7,"",	"Central area radius as fraction of half minimal WOI dimension.");
		gdf.addNumericField("Maximal central area radius",      max_tile_rad,   3,7,"tiles",	"Absolute limit to the center area radius (eases bad peripheral matching).");
		gdf.addNumericField("Central area minimal fill",        fill_fraction,  3,7,"",	"Central area minimal fill for all but the last iteration.");
		gdf.addNumericField("Central area minimal fill final",  fill_fraction_final, 3,7,"",	"Central area minimal fill for the last iteration.");
		gdf.addNumericField("Relax metric error for no-SfM",    ease_nosfm, 3,7,"",	"Relax metric error for no-SfM scenes (sfm_gain==0).");
		gdf.addNumericField("Pull skew (rotation)",             pull_skew, 3,7,"",	"Prevent pairwise match from rotation.");
		gdf.addNumericField("Pull tilt",                        pull_tilt, 3,7,"",	"Prevent pairwise match from tilt.");
		gdf.addNumericField("Pull scale",                       pull_scale, 3,7,"",	"Prevent pairwise match from scaling.");

		gdf.addMessage("Log and Save, and Debug parameters");
	    gdf.addCheckbox    ("Save state after each match", save_each, "Update state file after each match generation to mitigate possible crashes.");
	    gdf.addCheckbox    ("Write log file",              log_append, "Enable writing log file with matching results.");
	    gdf.addStringField ("Log file full path",          log_path, 150, "Path of the log file to be appended.");	
		gdf.addNumericField("Debug level",  debugLevel, 0,3,"","Debug level during Spiral search.");
		gdf.addNumericField("Start scene (skip all earlier)",   min_scene, 0,3,"","To be able to continue skipping some.");
		gdf.addCheckbox    ("Update configuration",        flt_update_config, "Update matching configuration parameters to be saved as defaults.");
		
		gdf.showDialog();
		if (gdf.wasCanceled()) return false;
		flt_min_overlap   =       gdf.getNextNumber();
		flt_max_overlap   =       gdf.getNextNumber();
        flt_filt_zoom     =       gdf.getNextBoolean();
        flt_min_zoom      = (int) gdf.getNextNumber(); 
        flt_max_zoom      = (int) gdf.getNextNumber(); 
        flt_min_sfm       =       gdf.getNextNumber();
        flt_max_sfm       =       gdf.getNextNumber();
		flt_min_rms       =       gdf.getNextNumber();
		flt_max_rms       =       gdf.getNextNumber();
		flt_nan_rms       =       gdf.getNextBoolean();
        flt_alt           =       gdf.getNextChoiceIndex();
		ospir_augment     =       gdf.getNextBoolean();
		max_rms           =       gdf.getNextNumber();	
		max_rms_refine    =       gdf.getNextNumber();
		min_overlap_tiles = (int) gdf.getNextNumber();
		double_threshold  =       gdf.getNextNumber();
		num_iter_lma      = (int) gdf.getNextNumber();
		max_rms_iter[0]   =       gdf.getNextNumber();
		max_rms_iter[1]   =       gdf.getNextNumber();
		lores_ignore_rms =        gdf.getNextBoolean();
		frac_remove      =        gdf.getNextNumber();
		metric_err       =        gdf.getNextNumber();
//		pmtch_use_affine=         gdf.getNextBoolean();
		max_std          =        gdf.getNextNumber();
		min_std_rad      =        gdf.getNextNumber();
		ignore_prev_rms  =        gdf.getNextBoolean();
		num_tries        =  (int) gdf.getNextNumber();		
		rad_fraction =            gdf.getNextNumber();
		max_tile_rad =            gdf.getNextNumber();		
		fill_fraction =           gdf.getNextNumber();  
		fill_fraction_final=      gdf.getNextNumber();   
		ease_nosfm =              gdf.getNextNumber();
		pull_skew =               gdf.getNextNumber();
		pull_tilt =               gdf.getNextNumber();
		pull_scale =              gdf.getNextNumber();

		save_each         =       gdf.getNextBoolean();
		log_append        =       gdf.getNextBoolean();
		log_path          =       gdf.getNextString();
		debugLevel =        (int) gdf.getNextNumber();
		min_scene =         (int) gdf.getNextNumber();
		flt_update_config =       gdf.getNextBoolean();
		
		if (flt_update_config) {
			clt_parameters.imp.flt_min_overlap =   flt_min_overlap;
			clt_parameters.imp.flt_max_overlap =   flt_max_overlap;
			clt_parameters.imp.flt_filt_zoom =     flt_filt_zoom;
			clt_parameters.imp.flt_min_zoom =      flt_min_zoom;
			clt_parameters.imp.flt_max_zoom =      flt_max_zoom;
    		clt_parameters.imp.flt_min_sfm =       flt_min_sfm;
    		clt_parameters.imp.flt_max_sfm =       flt_max_sfm;
			clt_parameters.imp.flt_alt =           flt_alt;			
			clt_parameters.imp.ospir_augment =     ospir_augment;       
			clt_parameters.imp.ospir_max_rms =     max_rms;
			clt_parameters.imp.pwise_max_rms =     max_rms_refine;
			clt_parameters.imp.ospir_overlap =     min_overlap_tiles;
			clt_parameters.imp.ospir_double =      double_threshold;
			clt_parameters.imp.ospir_num_iter =    num_iter_lma;
			clt_parameters.imp.ospir_rms_iter =    max_rms_iter;
			clt_parameters.imp.ospir_ignore_rms =  lores_ignore_rms;   
			clt_parameters.imp.pmtch_frac_remove =  frac_remove;
			clt_parameters.imp.pmtch_metric_err =   metric_err;
//			clt_parameters.imp.pmtch_use_affine =   pmtch_use_affine;
			clt_parameters.imp.pmtch_max_std =      max_std;
			clt_parameters.imp.pmtch_min_std_rad =  min_std_rad;
			clt_parameters.imp.pmtch_ignore_rms =   ignore_prev_rms;
			clt_parameters.imp.pmtch_num_iter =     num_tries;
			clt_parameters.imp.pmtch_cent_rad =     rad_fraction;
			clt_parameters.imp.pmtch_max_cent_rad = max_tile_rad;
			clt_parameters.imp.pmtch_cent_fill =    fill_fraction;
			clt_parameters.imp.pmtch_cent_final =   fill_fraction_final;
			clt_parameters.imp.pmtch_ease_nosfm =   ease_nosfm;
			clt_parameters.imp.pmtch_pull_skew =    pull_skew;
			clt_parameters.imp.pmtch_pull_tilt =    pull_tilt;
			clt_parameters.imp.pmtch_pull_scale =   pull_scale;

			clt_parameters.imp.pwise_save_each  = save_each;  
			clt_parameters.imp.pwise_log_append = log_append; 
			clt_parameters.imp.pwise_log_path   = log_path;   
			clt_parameters.imp.pwise_debug      = debugLevel; 
		}

		available_pairs = filterPairs(
				available_pairs, // int [][] plist_in,
				flt_undef_only,  // boolean  undef_only,
				flt_min_overlap, // double   min_overlap,
				flt_max_overlap, // double   max_overlap,
				flt_min_rms,     // double   min_rms,
				flt_max_rms,     // double   max_rms,
				flt_nan_rms,     // boolean  nan_rms)
				flt_filt_zoom,   // boolean          filt_zoom,
				flt_min_zoom,    // int              min_zoom,
				flt_max_zoom,    // int              max_zoom)
				flt_min_sfm,     // double           min_sfm,
				flt_max_sfm,     // double           max_sfm,
				flt_alt);       // int               flt_alt)
		String [] choices_all = textPairs (
				available_pairs,   // int [][] plist,
				flt_show_names,    // boolean          show_names,
				flt_show_overlaps, // boolean          show_overlap,
				flt_show_rms,      // boolean          show_rms,
				flt_show_zoom,     // boolean          show_zoom,
				flt_show_alt,      // boolean          show_alt,
				true,              // boolean          use_tab,
				null);             // String           extra_line)
		if (debugLevel > 0) {
			System.out.println("Selected "+available_pairs.length+" scene pairs for matching");
			for (int i = 0; i < available_pairs.length; i++) {
				System.out.println(String.format("%4d:%s",i,choices_all[i]));
			}
		}
		if (available_pairs.length == 0) {
			return false;
		}
		
		return augmentPairwiseAffines(
				clt_parameters,	     // CLTParameters clt_parameters,
				available_pairs,     // int [][]      available_pairs, 
				//Initial spiral search for image matching		
				ospir_augment,	     // boolean       ospir_augment,
				max_rms,	         // double        max_rms,
				max_rms_refine,	     // double        max_rms_refine,
				min_overlap_tiles,   // int           min_overlap_tiles,
				double_threshold,    // double        double_threshold, 
				num_iter_lma,	     // int           num_iter_lma,
				max_rms_iter,	     // double []     max_rms_iter,
				lores_ignore_rms,    // boolean       lores_ignore_rms
				//Final pairwise scenes matching
				frac_remove,	     // double        frac_remove,
				metric_err,	         // double        metric_error,
//				pmtch_use_affine,    // boolean       pmtch_use_affine,
				max_std,	         // double        max_std,
				min_std_rad,	     // double        min_std_rad,
				ignore_prev_rms,     // boolean       ignore_prev_rms,
				num_tries,	         // int           num_tries,
				rad_fraction,	     // double        rad_fraction,
				max_tile_rad,	     // double        max_tile_rad,
				fill_fraction,	     // double        fill_fraction,
				fill_fraction_final, //	double        fill_fraction_final,
				ease_nosfm,	         // double        ease_nosfm,
				min_scene,           // int           min_scene,
				pull_skew,	         // double        pull_skew,
				pull_tilt,	         // double        pull_tilt,
				pull_scale,	         // double        pull_scale,
				// log/save parameters
				save_each,	         // boolean        save_each,
				log_append,	         // boolean        log_append,
				log_path,	         // String         log_path,
				orthoMapsCollection_path, // String orthoMapsCollection_path
				debugLevel);         // int           debugLevel)
	}
	
	
	public boolean generatePairwiseAffines(
			CLTParameters clt_parameters,
			String        orthoMapsCollection_path) {
		int [] indices = getScenesSelection(
				clt_parameters, // CLTParameters       clt_parameters,				
				" to find intersects"); // String purpose)
		if ((indices == null) || (indices.length < 2)) {
			System.out.println ("generatePairwiseAffines(): indices[] is null or too short, exiting");
			return false;
		}
		
		int [] groups = new int [indices.length];
		for (int i = 0; i < indices.length; i++) {
			groups[i] = i;
		}
		int num_defined = 0;
		int num_undefined = 0;
		boolean single_pair = indices.length==2;
		for (int i = 0; i < indices.length-1; i++) {
			for (int j = i+1; j < indices.length; j++){
				String name2 = ortho_maps[indices[j]].getName();
				PairwiseOrthoMatch match = ortho_maps[indices[i]].getMatch(name2,true);
				if (match != null) {
					if (match.isDefined() && !single_pair) {
						num_defined++;
					} else {
						num_undefined++;
					}
				}
			}
		}
		HashSet<Integer> hs = new HashSet<Integer>();
		for (int i:groups) {
			hs.add(i);
		}
		
		boolean      dry_run       = false; 
		boolean      save_each     = clt_parameters.imp.pwise_save_each;    // save state file after each match
		boolean      log_append    = clt_parameters.imp.pwise_log_append;   //
		String       log_path      = clt_parameters.imp.pwise_log_path;     // 
		int          debugLevel    = clt_parameters.imp.pwise_debug;        //
		double    min_overlap_frac = clt_parameters.imp.pwise_overlap; // 0.25;
		
		//Initial spiral search for image matching
		
		double  search_step =         clt_parameters.imp.ospir_step;     // 8.0; // pix
		double  search_range =        clt_parameters.imp.ospir_range;    // 50.0; // pix
		double  double_threshold =    clt_parameters.imp.ospir_double;   //
		double  good_rms =            clt_parameters.imp.ospir_good_rms; // 0.27; //
		double  max_rms =             clt_parameters.imp.ospir_max_rms;  // 0.35; //
		double  max_rms_refine =      clt_parameters.imp.pwise_max_rms;  // 0.35; //
		int     min_overlap =         clt_parameters.imp.ospir_overlap;  // 3000; // do not try to match if there is too small overlap (scaled pixels)
		int     num_iter_lma =        clt_parameters.imp.ospir_num_iter; // 5;
		double [] max_rms_iter =      clt_parameters.imp.ospir_rms_iter; // {1.0, 0.6};//
		boolean spiral_ignore_rms =   clt_parameters.imp.ospir_ignore_rms; // false
		int     spiral_debug =        clt_parameters.imp.ospir_debug;    // 0;
		
		//Final pairwise scenes matching
		double  frac_remove  =        clt_parameters.imp.pmtch_frac_remove;// 0.15;
		double  metric_err =          clt_parameters.imp.pmtch_metric_err;// 0.05; // 0.02;//  2 cm
		boolean pmtch_use_affine =    clt_parameters.imp.pmtch_use_affine;		
		double  max_std =             clt_parameters.imp.pmtch_max_std;// 1.5;      // maximal standard deviation to limit center area  
		double  min_std_rad =         clt_parameters.imp.pmtch_min_std_rad;// 2.0;  // minimal radius of the central area (if less - fail)
		boolean ignore_prev_rms =     clt_parameters.imp.pmtch_ignore_rms;// true; 
		int     num_tries =           clt_parameters.imp.pmtch_num_iter;// 10;
		
		double rad_fraction =         clt_parameters.imp.pmtch_cent_rad; // center circle radius fraction of 0.5* min(width, height) in tiles
		double max_tile_rad =         clt_parameters.imp.pmtch_max_cent_rad;// maximal center radius in tiles (limit pmtch_cent_rad)
		double fill_fraction =        clt_parameters.imp.pmtch_cent_fill; // should be populated not less than this
		double fill_fraction_final =  clt_parameters.imp.pmtch_cent_final; // should be populated not less than this during final pass
		double ease_nosfm =           clt_parameters.imp.pmtch_ease_nosfm; // ease metric_error when no SfM gain == 0;

		double pull_skew =            clt_parameters.imp.pmtch_pull_skew;        // ~rotation, = 0 fraction of the total weight == 1
		double pull_tilt =            clt_parameters.imp.pmtch_pull_tilt;     // > 0
		double pull_scale =           clt_parameters.imp.pmtch_pull_scale;       // = 0
		
		boolean use_multi = true;
		int                          heur = 15;
		int min_scene =              0;
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Pairwise Match Parameters",1200,1100);
		gd.addMessage("Number of scenes - "+indices.length+
				", number of defined pairs - "+num_defined+
				", number of undefined pairs - "+num_undefined);
//	            +", number of disconnected groups - "+hs.size());
		//
	    gd.addCheckbox    ("Dry run",                     dry_run,   "Create pairs, do not adjust.");
///	    gd.addCheckbox    ("Skip existing",               skip_exist, "Do not regenerate if match with same or higher resolution exists.");
///	    gd.addCheckbox    ("Refine existing",             refine_exist, "Refine existing matches (false - start from scratch with spiral search).");
///		gd.addCheckbox    ("Delete failed",               delete_failed, "Delete previous matches if it failed now.");
///	    gd.addCheckbox    ("Generate inverse matches",    gen_inverse, "Generate (refine if exist and enabled) inverse matches.");
	    
	    gd.addCheckbox    ("Save state after each match", save_each, "Update state file after each match generation to mitigate possible crashes.");
	    gd.addCheckbox    ("Write log file",              log_append, "Enable writing log file with matching results.");
	    gd.addStringField ("Log file full path",          log_path, 150, "Path of the log file to be appended.");	
		gd.addNumericField("Pairwise match debug level",  debugLevel, 0,3,"","Debug level during Spiral search.");
		gd.addNumericField("Minimal overlap fraction",    min_overlap_frac,  3,7,"",	    "Minimal overlap fraction.");
		
		gd.addMessage  ("Initial spiral search for image matching");
		gd.addNumericField("Spiral search step",          search_step,  3,7,"scaled pix",	"Distance between spiral search probes, in scaled pixels.");
		gd.addNumericField("Spiral search radius",        search_range, 3,7,"scaled pix",	"Maximal radius of the spiral search, in scaled pixels.");
		gd.addNumericField("Mitigate small overlap",      double_threshold, 3,7,"","For small overlaps increase zoom by 1 and range - twice.");
		gd.addNumericField("RMSE to end search",          good_rms,     3,7,"scaled pix",	"Maximal RMSE to consider match, in scaled pixels.");
		gd.addNumericField("Satisfactory RMSE, spiral",   max_rms,      3,7,"scaled pix",	"Maximal RMSE to consider match, in scaled pixels, during spiral.");
		gd.addNumericField("Satisfactory RMSE, final",    max_rms_refine,3,7,"scaled pix",	"Maximal RMSE to consider match, in scaled pixels, during refine.");
		gd.addNumericField("Minimal overlap",             min_overlap,  0,4,"scaled pix ^ 2","Minimal overlap area in square scaled pixels.");
		gd.addNumericField("LMA iterations",              num_iter_lma, 0,2,"",              "Number of LMA iterations during spiral search.");
		gd.addNumericField("RMSE at first iteration",     max_rms_iter[0],  3,7,"scaled pix","Maximal RMSE at first iteration.");
		gd.addNumericField("RMSE at second iteration",    max_rms_iter[1],  3,7,"scaled pix","Maximal RMSE at second iteration.");
		
		gd.addCheckbox    ("Ignore worsening RMSE",       spiral_ignore_rms, "Ignore worsening/not improving RMSE during spiral search.");
		gd.addNumericField("Spiral search debug level",   spiral_debug, 0,3,"","Debug level during Spiral search.");

		gd.addMessage  ("Final pairwise scenes matching");
		gd.addNumericField("Remove fraction of worst matches", frac_remove,  3,7,"",	"When fitting scenes remove this fraction of worst match tiles.");
		gd.addNumericField("Maximal metric error",             metric_err,  3,7,"m",	"Maximal tolerable fitting error caused by elevation variations.");
		gd.addCheckbox    ("Use scenes' affine",               pmtch_use_affine, "Use known scenes' affine matrices, false - start from scratch (unity) ones.");
		gd.addNumericField("Central area standard deviation",  max_std,  3,7,"",	"Central area limit by the standard deviation.");
		gd.addNumericField("Central area minimal radius",      min_std_rad,  3,7,"tile",	"Minimal radius of the central area after all LMA passes.");
		gd.addCheckbox    ("Ignore previous RMSE",             ignore_prev_rms, "Do not exit full fitting cycles if the RMSE worsened/not improved.");
		gd.addNumericField("Number of fitting iterations",     num_tries, 0,3,"","number of full fittng iterations.");
		gd.addNumericField("Central area radius as fraction",  rad_fraction,   3,7,"",	"Central area radius as fraction of half minimal WOI dimension.");
		gd.addNumericField("Maximal central area radius",      max_tile_rad,   3,7,"tiles",	"Absolute limit to the center area radius (eases bad peripheral matching).");
		gd.addNumericField("Central area minimal fill",        fill_fraction,  3,7,"",	"Central area minimal fill for all but the last iteration.");
		gd.addNumericField("Central area minimal fill final",  fill_fraction_final, 3,7,"",	"Central area minimal fill for the last iteration.");
		gd.addNumericField("Relax metric error for no-SfM",    ease_nosfm, 3,7,"",	"Relax metric error for no-SfM scenes (sfm_gain==0).");
		
		gd.addNumericField("Pull skew (rotation)",             pull_skew, 3,7,"",	"Prevent pairwise match from rotation.");
		gd.addNumericField("Pull tilt",                        pull_tilt, 3,7,"",	"Prevent pairwise match from tilt.");
		gd.addNumericField("Pull scale",                       pull_scale, 3,7,"",	"Prevent pairwise match from scaling.");
		
		gd.addNumericField("Start scene (skip all earlier)",   min_scene, 0,3,"","To be able to continue skipping some.");
		gd.addNumericField("Heuristics bitmap",                heur, 0,3,"","Bitmap of modes to suggest the next pair.");
		gd.addCheckbox    ("Use multiple threads",             use_multi, "Use multiple threads (may be disabled in debug mode).");
		//
		
		gd.showDialog();
		if (gd.wasCanceled()) return false;
		dry_run          = gd.getNextBoolean();
///		skip_exist       = gd.getNextBoolean();
///		refine_exist     = gd.getNextBoolean();
///		delete_failed    = gd.getNextBoolean();
///		gen_inverse      = gd.getNextBoolean();
		save_each        = gd.getNextBoolean();
		log_append       = gd.getNextBoolean();
		log_path         = gd.getNextString();
		debugLevel = (int) gd.getNextNumber(); 	
		min_overlap_frac =       gd.getNextNumber(); 
		search_step      =       gd.getNextNumber();        
		search_range     =       gd.getNextNumber();
		double_threshold =       gd.getNextNumber();
		good_rms         =       gd.getNextNumber();
		max_rms          =       gd.getNextNumber();
		max_rms_refine   =       gd.getNextNumber();
		min_overlap      = (int) gd.getNextNumber();
		num_iter_lma     = (int) gd.getNextNumber();
		max_rms_iter[0]  =       gd.getNextNumber();
		max_rms_iter[1]  =       gd.getNextNumber();
		spiral_ignore_rms=       gd.getNextBoolean();
		spiral_debug     = (int) gd.getNextNumber();
		                         
		frac_remove      =       gd.getNextNumber();
		metric_err       =       gd.getNextNumber();
		pmtch_use_affine=        gd.getNextBoolean();
		max_std          =       gd.getNextNumber();
		min_std_rad      =       gd.getNextNumber();
		ignore_prev_rms  =       gd.getNextBoolean();
		num_tries        = (int) gd.getNextNumber();		

		rad_fraction =           gd.getNextNumber();
		max_tile_rad =           gd.getNextNumber();		
		fill_fraction =          gd.getNextNumber();  
		fill_fraction_final=     gd.getNextNumber();   
		ease_nosfm =             gd.getNextNumber();
		
		pull_skew =              gd.getNextNumber();
		pull_tilt =              gd.getNextNumber();
		pull_scale =             gd.getNextNumber();
		
		min_scene =        (int) gd.getNextNumber();
		heur =             (int) gd.getNextNumber();
		use_multi =              gd.getNextBoolean();
		double max_rmse_reuse= max_rms_refine;
		int [][] pairs_defined = single_pair?(new int[0][]):filterPairs(
				indices,          // int []  indices_in,
				min_overlap_frac, // double  min_overlap_frac,
				max_rmse_reuse,   // double  max_rmse,
				true,             // boolean max_resolution,
				null);            // int [][] remove_pairs
		int [][] pairs_undefined = filterPairs(
				indices,          // int []  indices_in,
				min_overlap_frac, // double  min_overlap_frac,
				0,                // max_rmse_reuse,   // double  max_rmse,
				false,            // boolean max_resolution,
				pairs_defined);   // int [][] remove_pairs
		/*
		PairsGraph  pairsGraph = new PairsGraph(
				this,             // OrthoMapsCollection orthoMapsCollection,
				indices,          // int []  indices,
				min_overlap_frac, // double  min_overlap_frac,
				max_rmse_reuse,   // double  max_rmse_reuse,
				use_multi,        // boolean multi,
				debugLevel);      // int     debugLevel);
		*/
		PairsGraph  pairsGraph = new PairsGraph(
				this,             // OrthoMapsCollection orthoMapsCollection,
				pairs_undefined,  // int [][] undefined_pairs,
				pairs_defined,    // int [][] defined_pairs,
				use_multi,        // boolean multi,
				debugLevel);      // int     debugLevel);
		
		if (dry_run) {
			return pairsGraph.dryRun(
					heur,        // int heur,
					debugLevel); // int debugLevel)
			
		} else {
			if (log_append && (log_path != null)) { // assuming directory exists
				StringBuffer sb = new StringBuffer();
				sb.append(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(Calendar.getInstance().getTime())+"\n");
				sb.append("num_scenes\t"+     indices.length+"\n");
				sb.append("num_defined\t"+    num_defined+"\n");
				sb.append("num_undefined\t"+  num_undefined+"\n");
				sb.append("num_groups\t"+     pairsGraph.getNumberOfGroups()+"\n");
				sb.append(String.format("%4s\t%4s\t%17s\t%17s\t%6s\t%3s\t%4s,\t%4s\t%6s\t%6s\t%7s\n",
						"scn1","scn2","timestamp1","timestamp2","ovrlp","zl","nx","ny","RMS-sp","RMSfin","fzl","removed"));
				CalibrationFileManagement.saveStringToFile (
						log_path,          //String path,
						sb.toString(), // data,
						true); // boolean append)
				if (debugLevel>-3) {
					System.out.print(sb.toString());
				}
			}
			
		return generatePairwiseAffines(
				clt_parameters,           // CLTParameters clt_parameters,
				pairsGraph,               // PairsGraph    pairsGraph,
				heur,                     // int           heur,
				min_overlap_frac,         // double  min_overlap_frac,
//				indices,                  // int []       indices,
//				overlaps,                 // double [] overlaps,
//				skip_exist,               // boolean      skip_existing,
//				refine_exist,             // boolean      refine_existing, // if false, start from scratch, true - start from previous
//				delete_failed,            // boolean       delete_failed,   // if false, start from scratch, true - start from previous
//				gen_inverse,              // boolean      gen_inverse,    // generate inverse matches
				save_each,                // boolean      save_each,       // save state file after each match
				log_append,               // boolean      log_append,      //
				log_path,                 // String       log_path,
				orthoMapsCollection_path, // String orthoMapsCollection_path
				search_step,              // double        search_step,
				search_range,             // double        search_range,
				good_rms,                 // double        good_rms,
				max_rms,                  // double        max_rms,
				max_rms_refine,           // double        max_rms_refine,
				min_overlap,              // int           min_overlap,
				num_iter_lma,             // int           num_iter_lma,
				spiral_ignore_rms,        // boolean       ignore_rms,
				spiral_debug,             // int           spiral_debug,
				frac_remove,              // double        frac_remove,
				metric_err,               // double        metric_error,
				pmtch_use_affine,         // boolean       pmtch_use_affine,				
				max_std,                  // double        max_std,  
				min_std_rad,              // double        min_std_rad,
				ignore_prev_rms,          // boolean       ignore_prev_rms, 
				num_tries,                // int           num_tries,
				rad_fraction,             // double        rad_fraction,
				max_tile_rad,             // double        max_tile_rad,
				fill_fraction,            // double        fill_fraction,
				fill_fraction_final,      // double        fill_fraction_final,
				ease_nosfm,               // double        ease_nosfm,
				double_threshold,         // double        double_threshold,
				max_rms_iter,             // double []     max_rms_iter,
				min_scene,                // int           min_scene,
				pull_skew,        // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
				pull_tilt,        // double           pull_tilt,        // > 0
				pull_scale,       // double           pull_scale,       // = 0
				debugLevel);              // int          debugLevel
		}
	}
	
	public boolean augmentPairwiseAffines(
			CLTParameters clt_parameters,
			int [][]      available_pairs, 
			//Initial spiral search for image matching		
			boolean       ospir_augment,
			double        max_rms,
			double        max_rms_refine,
			int           min_overlap_tiles,
			double        double_threshold,
			int           num_iter_lma,
			double []     max_rms_iter,
			boolean       lores_ignore_rms,
			//Final pairwise scenes matching
			double        frac_remove,
			double        metric_error,
			double        max_std,
			double        min_std_rad,
			boolean       ignore_prev_rms,
			int           num_tries,
			double        rad_fraction,
			double        max_tile_rad,
			double        fill_fraction,
			double        fill_fraction_final,
			double        ease_nosfm,
			int           min_scene,
			double        pull_skew,
			double        pull_tilt,
			double        pull_scale,
			// log/save parameters
			boolean       save_each,
			boolean       log_append,
			String        log_path,
			String        orthoMapsCollection_path,
			int           debugLevel) {
		boolean batch_mode = true;
		boolean  show_vf = false;
		boolean use_degrees = true;
		double [][] ground_planes = null; // null or double[2] - will return ground planes:
		if (log_append && (log_path != null)) { // assuming directory exists
			String svd_title=SingularValueDecomposition.titleString(use_degrees);
			StringBuffer sb = new StringBuffer();
			sb.append(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(Calendar.getInstance().getTime())+"\n");
			sb.append("number of scenes pairs\t"+     available_pairs.length+"\n");
			sb.append(String.format("%4s\t%4s\t%17s\t%17s\t%6s\t%3s\t%6s\t%6s\t%7s\t%7s\t%s\n",
					"scn1","scn2","timestamp1","timestamp2","ovrlp","zl","RMS-sp","RMSfin","fzl","removed",svd_title));
			CalibrationFileManagement.saveStringToFile (
					log_path,          //String path,
					sb.toString(), // data,
					true); // boolean append)
			if (debugLevel>-3) {
				System.out.print(sb.toString());
			}
		}
		
		int num_pairs = 0; // available_pairs.length
		ArrayList<Point> failed_pairs = new ArrayList<Point>();
		for (int npair = 0; npair < available_pairs.length; npair++) {
			int [] ipair = available_pairs[npair];
			PairwiseOrthoMatch pairwiseOrthoMatch = ortho_maps[ipair[0]].getMatch(ortho_maps[ipair[1]].getName(), true);
			double [][] daffine = null;
    		if (pairwiseOrthoMatch != null) {
    			double [][] aff0 = ortho_maps[ipair[0]].getAffine();            			
    			double [][] aff1 = ortho_maps[ipair[1]].getAffine();
    			double [] enuOffset = ortho_maps[ipair[1]].enuOffsetTo(ortho_maps[ipair[0]]);
    			double [] rd = {enuOffset[0], -enuOffset[1]}; // {right,down} of the image 
    			PairwiseOrthoMatch aff_match = new PairwiseOrthoMatch (
    					aff0, // double [][] affine0,
    					aff1, // double [][] affine1,
    					rd);  // double [] rd);
    			daffine = aff_match.getAffine();
    			pairwiseOrthoMatch.setAffine(daffine);
    		} else {
    			System.out.println("BUG: Missing pair for ["+ipair[0]+", "+ipair[1]+"] ");
    			continue;
    		}
			if (ipair[0] < min_scene) {
				System.out.println ("Skipping "+ipair[0]+":"+ipair[1]+" until "+min_scene);
				continue;
			}
			
			// only do low-res if ospir_augment
			
//			boolean direct = ipair[0] < ipair[1]; // always?
	    	int min_zoom_lev = ortho_maps[ipair[0]].getOriginalZoomLevel();
	    	int max_zoom_lev = ortho_maps[ipair[0]].getOriginalZoomLevel();
	    	double max_agl =   ortho_maps[ipair[0]].getAGL();
	    	for (int i = 0; i < ipair.length; i++) {
	    		max_agl =      Math.max(max_agl, ortho_maps[ipair[i]].getAGL());	    		
	    		min_zoom_lev = Math.min(min_zoom_lev, ortho_maps[ipair[i]].getOriginalZoomLevel());
	    		max_zoom_lev = Math.max(max_zoom_lev, ortho_maps[ipair[i]].getOriginalZoomLevel());
	    	}
        	double agl_ratio = max_agl/50.0;
        	double metric_error_adj = metric_error * agl_ratio * agl_ratio; // metric_error settings is good for 50m. Increase for higher Maybe squared?
	    	int initial_zoom = max_zoom_lev - 4;  // another algorithm?
	    	// overlaps
	    	double overlap_frac = pairwiseOrthoMatch.getOverlap(); // .pairsGraph.getOverlap(next_pair);
	    	double overlap_frac_mod = overlap_frac;
	    	while (overlap_frac_mod < double_threshold) {
	    		overlap_frac_mod *= 2;
	    		initial_zoom += 1;
	    	}
			// unityAffine()
	    	// use unityAffine() for 0; getaffine for second?
			double [][] affine0 = unityAffine(); // ortho_maps[ipair[0]].getAffine();
			double [][] affine1 = daffine; // ortho_maps[ipair[1]].getAffine();
			double [][][] affines = new double[][][] {affine0,affine1};
			boolean success = true;
			Point pair = new Point(ipair[0],ipair[1]);
			if (ospir_augment) {
				correlateOrthoPair(
						clt_parameters,     // CLTParameters    clt_parameters,
						pairwiseOrthoMatch, // PairwiseOrthoMatch pairwiseOrthoMatch, // will return statistics
						min_overlap_tiles,  // int              min_overlap,
						max_std,            // double           max_std,      // maximal standard deviation to limit center area  
						min_std_rad,        // double           min_std_rad,  // minimal radius of the central area (if less - fail)
						frac_remove,        // double           frac_remove, //  =        0.25
						metric_error_adj, // metric_error,       // 			double           metric_error,
						lores_ignore_rms,   // boolean ignore_prev_rms,
						num_tries,          //  = 5int              num_tries, //  = 5
						false,              // boolean          calc_warp, (will return null if false)
						batch_mode,         // boolean          batch_mode,
						ipair,              // int []           gpu_pair,
						affines,            // double [][][]    affines, // on top of GPS offsets
						null,               // woi,             // Rectangle        woi,
						initial_zoom,       // int              zoom_lev,
						show_vf,            // boolean show_vf,
						ground_planes,      // double [][]      ground_planes, // null or double[2] - will return ground planes
						rad_fraction,       // double           rad_fraction,
						max_tile_rad,       // double           max_tile_rad, //  = 30;
						fill_fraction,      // double           fill_fraction,
						fill_fraction_final,// double           fill_fraction_final,
						ease_nosfm,         // double           ease_nosfm,
						max_rms_iter,       // double []        max_rms_iter, //  = {1.0, 0.6};//
						pull_skew,          // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
						pull_tilt,          // double           pull_tilt,        // > 0
						pull_scale,         // double           pull_scale,       // = 0
						debugLevel-4);     // final int        debugLevel)
				pairwiseOrthoMatch.setAffine(affines[1]); // modified by correlateOrthoPair ALREADY SET
				if (debugLevel > -4) {
					System.out.println(String.format("Low-res Match(): %3d-%3d RMSE=%8.6f",
							ipair[0], ipair[1], pairwiseOrthoMatch.rms)); // if NaN - provide reason
				}
				if (pairwiseOrthoMatch.rms < max_rms) {
					pairwiseOrthoMatch.ok = true;
				}
				success &= pairwiseOrthoMatch.ok; // && !Double.isNaN(pairwiseOrthoMatch.rms)
				
				if (!success) {
					String str_failed = "%4d\t%4d\t%s\t%s\t%6.4f\t%3d\t%6.4f\tFAILED\n";
					if (log_append && (log_path != null)) { // assuming directory exists
						StringBuffer sb = new StringBuffer();
						sb.append(String.format(str_failed,
								ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
								overlap_frac,  initial_zoom,
//								pairwiseOrthoMatch.nxy[0],pairwiseOrthoMatch.nxy[1],
								pairwiseOrthoMatch.rms));
						CalibrationFileManagement.saveStringToFile (
								log_path,          //String path,
								sb.toString(), // data,
								true); // boolean append)
					}
					failed_pairs.add(pair);
					continue;
				}
			} // if (ospir_augment) {
//			PairwiseOrthoMatch pairwiseOrthoMatch_lores =  pairwiseOrthoMatch.clone();
			double lores_rms = pairwiseOrthoMatch.getRMS();
			// high-res

			affines[1][0] = affines[1][0].clone(); 
			affines[1][1] = affines[1][1].clone();
			Rectangle woi = new Rectangle(); // used to return actual woi from correlateOrthoPair()			
			correlateOrthoPair(
					clt_parameters,  // CLTParameters    clt_parameters,
					pairwiseOrthoMatch, //PairwiseOrthoMatch pairwiseOrthoMatch, // will return statistics
					0,                // 			int              min_overlap,
					max_std,         // double           max_std,      // maximal standard deviation to limit center area  
					min_std_rad,     // double           min_std_rad,  // minimal radius of the central area (if less - fail)
					frac_remove,     // double           frac_remove, //  =        0.25
					metric_error_adj,// 			double           metric_error,
					ignore_prev_rms, // boolean ignore_prev_rms,
					num_tries,       //  = 5int              num_tries, //  = 5
					false, // ,            // boolean          calc_warp, (will return null if false)
					batch_mode,      // boolean          batch_mode,
					ipair,           // String []        gpu_spair,
					affines,         // double [][][]    affines, // on top of GPS offsets
					woi,             // Rectangle        woi,
					min_zoom_lev,    // int              zoom_lev,
					false,           // show_vf,         // boolean show_vf,
					null,            // ground_planes,   // double [][]      ground_planes, // null or double[2] - will return ground planes
					rad_fraction,    // double           rad_fraction,
					max_tile_rad,    // double           max_tile_rad, //  = 30;
					fill_fraction,   // double           fill_fraction,
					fill_fraction_final, // double           fill_fraction_final,
					ease_nosfm,      // double           ease_nosfm,
					null,            //  double []        max_rms_iter, //  = {1.0, 0.6};//
					pull_skew,       // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
					pull_tilt,       // double           pull_tilt,        // > 0
					pull_scale,      // double           pull_scale,       // = 0
					debugLevel-4);   // final int        debugLevel)
			boolean failed_refine = Double.isNaN(pairwiseOrthoMatch.rms) || (pairwiseOrthoMatch.rms > max_rms_refine);
			// Create log line and write it
			StringBuffer sb = new StringBuffer();
			sb.append(String.format("%4d\t%4d\t%s\t%s\t%6.4f\t%3d",
					ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
					overlap_frac,  initial_zoom));

			sb.append(String.format("\t%6.4f",
//					pairwiseOrthoMatch.nxy[0],pairwiseOrthoMatch.nxy[1],
					lores_rms)); 
			if (failed_refine) {
				String str_failed = String.format("\t%6.4f\tFAILED\n",pairwiseOrthoMatch.rms);
				failed_pairs.add(pair);
				sb.append(String.format(str_failed));
				if (debugLevel > -4) System.out.print("Final adjustment (3)"+str_failed);				
			} else {
				pairwiseOrthoMatch.overlap = overlap_frac; // needed here if refining old/manual w/o overlap 
				SingularValueDecomposition svd = SingularValueDecomposition.singularValueDecompose(pairwiseOrthoMatch.getAffine());
				String ssvd = svd.toString(use_degrees, 1);
				sb.append(String.format("\t%6.4f\t%3d\t       \t%s\n",pairwiseOrthoMatch.rms,pairwiseOrthoMatch.zoom_lev, ssvd)); 
				if (debugLevel > -4) System.out.println("Final adjustment (4) RMSE="+pairwiseOrthoMatch.rms+
						", overlap = "+pairwiseOrthoMatch.overlap);				
				ortho_maps[ipair[0]].setMatch(ortho_maps[ipair[1]].getName(),pairwiseOrthoMatch);
				if (save_each && (orthoMapsCollection_path != null)) {
					try {
						writeOrthoMapsCollection(orthoMapsCollection_path);
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					if (debugLevel > -4) {
						System.out.println("Saved data to "+ orthoMapsCollection_path);
					}
				}
			}
			if (log_append && (log_path != null)) { // assuming directory exists
				CalibrationFileManagement.saveStringToFile (
						log_path,          //String path,
						sb.toString(), // data,
						true); // boolean append)
			}
			success &= !failed_refine;
			if (success) {
				num_pairs++;
			}
		} // for (int npair = 0; npair < available_pairs.length; npair++) {
		if (log_append && (log_path != null)) { // assuming directory exists
			StringBuffer sb = new StringBuffer();
			sb.append(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(Calendar.getInstance().getTime())+"\n");
			sb.append("\nSUMMARY\n");
			sb.append("new\t"+ num_pairs+"\n");
//			sb.append("new\t"+ new_pairs.size()+"\n");
			sb.append("failed\t"+failed_pairs.size()+"\n");
			if (!failed_pairs.isEmpty()) {
				for (int i = 0; i < failed_pairs.size(); i++) {
//					int [] ipair = {indices[failed_pairs.get(i).x], indices[failed_pairs.get(i).y]};
					int [] ipair = {failed_pairs.get(i).x, failed_pairs.get(i).y};
					sb.append(String.format("%4d\t%4d\t%s\t%s\n",
							ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName()));
				}
			}
			CalibrationFileManagement.saveStringToFile (
					log_path,          //String path,
					sb.toString(), // data,
					true); // boolean append)
        	if (debugLevel > -4) {
        		System.out.println("Appended log file "+ log_path);
        	}
		}
		if (orthoMapsCollection_path != null) {
        	try {
        		writeOrthoMapsCollection(orthoMapsCollection_path);
        	} catch (IOException e) {
        		// TODO Auto-generated catch block
        		e.printStackTrace();
        	}
        	if (debugLevel > -4) {
        		System.out.println("Saved data to "+ orthoMapsCollection_path);
        	}
		}
		return true;
	}
	
	
	
	
	public boolean generatePairwiseAffines(
			CLTParameters clt_parameters,
			PairsGraph    pairsGraph,
			int           heur,
			double        min_overlap_frac,
//			int []        indices,
//			double []     overlaps,
//			boolean       skip_existing,
//			boolean       refine_existing, // if false, start from scratch, true - start from previous
//			boolean       delete_failed,   // if false, start from scratch, true - start from previous
//			boolean       gen_inverse,     // generate inverse matches
			boolean       save_each,       // save state file after each match
			boolean       log_append,      //
			String        log_path,
			String        orthoMapsCollection_path,
			
			double        search_step,
			double        search_range_in,
			double        good_rms,
			double        max_rms,
			double        max_rms_refine,
			int           min_overlap,
			int           num_iter_lma,
			boolean       ignore_rms,
			int           spiral_debug,
			double        frac_remove,
			double        metric_error,
			boolean       pmtch_use_affine,			
			double        max_std,  
			double        min_std_rad,
			boolean       ignore_prev_rms, 
			int           num_tries,
			double        rad_fraction,
			double        max_tile_rad,
			double        fill_fraction,
			double        fill_fraction_final,
			double        ease_nosfm,
			double        double_threshold,
			double []     max_rms_iter,
			int           min_scene,
			double        pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
			double        pull_tilt,        // > 0
			double        pull_scale,       // = 0
			int           debugLevel) {
		int []       indices = pairsGraph.getIndices();
		boolean batch_mode = true;
//		int num_scenes = indices.length;
		int num_pairs = 0;
		ArrayList<Point> failed_pairs = new ArrayList<Point>();
		int ok_dist = 1;
		int [] start_ij = {0,0};
		int [] next_pair;

		while (!pairsGraph.isSingleConnected()) {
			next_pair = pairsGraph.suggestPairSingle( // single-connected, no cycles
					// add some parameters
					heur, // int         heur,
					ok_dist, // int         ok_dist)
					start_ij, // int []      start_ij) //  = new int [indices.length];
					pairsGraph.useMultiThreaded(), // multi,
					debugLevel);
			if (next_pair == null) {
				System.out.println("No pairs suggested,  isSingleConnected()="+pairsGraph.isSingleConnected());
				break;
			}
			
			if (next_pair[2] > PairsGraph.HEUR_LAST_SEQ) {
				heur &= ~PairsGraph.HEUR_LAST_SEQ;
			}
			if (next_pair[2] > PairsGraph.HEUR_DIV_LONG) {
				heur &= ~PairsGraph.HEUR_DIV_LONG;
			}
			if (next_pair.length > 3) {
				ok_dist = next_pair[3];
				start_ij[0] = next_pair[0];
				start_ij[1] = next_pair[1];
				if (debugLevel > 0) {
					System.out.println(String.format("%3d: %3d-%3d %2d (%3d)", num_pairs,next_pair[0], next_pair[1],next_pair[2],next_pair[3]));
				}

			} else {
				if (debugLevel > 0) {
					System.out.println(String.format("%3d: %3d-%3d %2d", num_pairs,next_pair[0], next_pair[1],next_pair[2]));
				}
			}
			
			int [] ipair = {indices[next_pair[0]], indices[next_pair[1]]};
			if (ipair[0] < min_scene) {
				System.out.println ("Skipping "+ipair[0]+":"+ipair[1]+" until "+min_scene);
				continue;
			}
			boolean direct = ipair[0] < ipair[1]; // always?
	    	int min_zoom_lev = ortho_maps[ipair[0]].getOriginalZoomLevel();
	    	int max_zoom_lev = ortho_maps[ipair[0]].getOriginalZoomLevel();
	    	double max_agl =   ortho_maps[ipair[0]].getAGL();
	    	for (int i = 0; i < ipair.length; i++) {
	    		max_agl =      Math.max(max_agl, ortho_maps[ipair[i]].getAGL());	    		
	    		min_zoom_lev = Math.min(min_zoom_lev, ortho_maps[ipair[i]].getOriginalZoomLevel());
	    		max_zoom_lev = Math.max(max_zoom_lev, ortho_maps[ipair[i]].getOriginalZoomLevel());
	    	}
        	double agl_ratio = max_agl/50.0;
        	double metric_error_adj = metric_error * agl_ratio * agl_ratio; // metric_error settings is good for 50m. Increase for higher Maybe squared?
	    	int initial_zoom = max_zoom_lev - 4;  // another algorithm?
	    	// overlaps
	    	double overlap_frac = pairsGraph.getOverlap(next_pair);
	    	double overlap_frac_mod = overlap_frac;
	    	double search_range = search_range_in;
	    	while (overlap_frac_mod < double_threshold) {
	    		overlap_frac_mod *= 2;
	    		initial_zoom += 1;
	    		search_range *= 2;
	    	}
			// unityAffine()
			
			double [][] affine0 = pmtch_use_affine?ortho_maps[ipair[0]].getAffine():unityAffine(); // {{1,0,0},{0,1,0}}; // will always stay the same
			double [][] affine1 = pmtch_use_affine?ortho_maps[ipair[1]].getAffine():unityAffine(); // {{1,0,0},{0,1,0}}; // here (manual mode) start from the center, may use prediction in auto
			double [][][] affines = new double[][][] {affine0,affine1};
			double spiral_rms = Double.NaN;
				// now always unity, but after partial adjustment may be non-unity
				// TODO: Not yet tested with intermediate adjustment.
			PairwiseOrthoMatch pairwiseOrthoMatch = SpiralMatch (
					clt_parameters,  // CLTParameters    clt_parameters,
					frac_remove,     // double           frac_remove, //  =        0.25
					metric_error_adj,// double           metric_error,
					pmtch_use_affine, // boolean          pmtch_use_affine,
					max_std,         // double           max_std,     // maximal standard deviation to limit center area  
					min_std_rad,     // double           min_std_rad, // minimal radius of the central area (if less - fail)
					rad_fraction,    // double           rad_fraction,
					max_tile_rad,    // double           max_tile_rad, //  = 30;						
					fill_fraction,   // double           fill_fraction,
					fill_fraction_final, // double           fill_fraction_final,
					ease_nosfm,      // double           ease_nosfm,
					ipair,           // int []           gpu_pair,
					affines,         // double [][][]    affines_init,  // here in meters, relative to vertical points
					initial_zoom,    // int              zoom_lev,
					search_step,     // double           pix_step,
					search_range,    // double           pix_range,
					good_rms,        // double           good_rms,
					max_rms,         // 			double           max_rms,
					num_iter_lma,    // int              num_tries, //  = 5
					min_overlap,     // int              min_overlap, // 3000
					ignore_rms,      // boolean          ignore_rms,
					max_rms_iter,    // double []        max_rms_iter, //  = {1.0, 0.6};//
					overlap_frac,    // double           overlap, // OR IS IT overlap_frac_mod ?
					pull_skew,       // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
					pull_tilt,       // double           pull_tilt,        // > 0
					pull_scale,      // double           pull_scale,       // = 0
					spiral_debug);   // int              debugLevel)
			
			// late failure
			if ((pairwiseOrthoMatch != null) && !Double.isNaN(pairwiseOrthoMatch.rms) && !pairwiseOrthoMatch.ok) {
				String str_failed = "%4d\t%4d\t%s\t%s\t%6.4f\t%3d\t%3d\t%3d\t%6.4f\tFAILED\n";
				if (log_append && (log_path != null)) { // assuming directory exists
					StringBuffer sb = new StringBuffer();
					sb.append(String.format(str_failed,
							ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
							overlap_frac,  initial_zoom,
							pairwiseOrthoMatch.nxy[0],pairwiseOrthoMatch.nxy[1],pairwiseOrthoMatch.rms));
					CalibrationFileManagement.saveStringToFile (
							log_path,          //String path,
							sb.toString(), // data,
							true); // boolean append)
				}
			}
			Point pair = new Point(next_pair[0],next_pair[1]);
			boolean success = (pairwiseOrthoMatch != null) && pairwiseOrthoMatch.ok; // && !Double.isNaN(pairwiseOrthoMatch.rms)
			if (!success) { // not yet add to pairsGraph until verified with high-res
				if ((pairwiseOrthoMatch == null) || Double.isNaN(pairwiseOrthoMatch.rms)) { // too high RMS already reported
					String str_failed = "%4d\t%4d\t%s\t%s\t%6.4f\t%3d\tFAILED\n";
					if (log_append && (log_path != null)) { // assuming directory exists
						StringBuffer sb = new StringBuffer();
						sb.append(String.format(str_failed,
								ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
								overlap_frac,
								initial_zoom));
						CalibrationFileManagement.saveStringToFile (
								log_path,          //String path,
								sb.toString(), // data,
								true); // boolean append)
					}
				}
				failed_pairs.add(pair);
			} else { // success!
				spiral_rms = pairwiseOrthoMatch.rms;
//				new_pairs.add(pair); // adjusted with spiral
			// refine match with high resolution
				affines[1] = pairwiseOrthoMatch.getAffine();
				affines[1][0] = affines[1][0].clone(); 
				affines[1][1] = affines[1][1].clone();
				Rectangle woi = new Rectangle(); // used to return actual woi from correlateOrthoPair()			
				correlateOrthoPair(
						clt_parameters,  // CLTParameters    clt_parameters,
						pairwiseOrthoMatch, //PairwiseOrthoMatch pairwiseOrthoMatch, // will return statistics
						0,                // 			int              min_overlap,
						max_std,         // double           max_std,      // maximal standard deviation to limit center area  
						min_std_rad,     // double           min_std_rad,  // minimal radius of the central area (if less - fail)
						frac_remove,     // double           frac_remove, //  =        0.25
						metric_error_adj,// 			double           metric_error,
						ignore_prev_rms, // boolean ignore_prev_rms,
						num_tries,       //  = 5int              num_tries, //  = 5
						false, // ,            // boolean          calc_warp, (will return null if false)
						batch_mode,      // boolean          batch_mode,
						ipair,           // String []        gpu_spair,
						affines,         // double [][][]    affines, // on top of GPS offsets
						woi,             // Rectangle        woi,
						min_zoom_lev,    // int              zoom_lev,
						false, // show_vf,         // boolean show_vf,
						null, // ground_planes,   // double [][]      ground_planes, // null or double[2] - will return ground planes
						rad_fraction,    // double           rad_fraction,
						max_tile_rad,    // double           max_tile_rad, //  = 30;
						fill_fraction,   // double           fill_fraction,
						fill_fraction_final, // double           fill_fraction_final,
						ease_nosfm,      // double           ease_nosfm,
						null,            //  double []        max_rms_iter, //  = {1.0, 0.6};//
						pull_skew,        // double           pull_skew,        // ~rotation, = 0 fraction of the total weight == 1
						pull_tilt,        // double           pull_tilt,        // > 0
						pull_scale,       // double           pull_scale,       // = 0
						debugLevel-4);   // final int        debugLevel)
				boolean failed_refine = Double.isNaN(pairwiseOrthoMatch.rms) || (pairwiseOrthoMatch.rms > max_rms_refine);
				// Create log line and write it
				StringBuffer sb = new StringBuffer();
				sb.append(String.format("%4d\t%4d\t%s\t%s\t%6.4f\t%3d",
						ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName(),
						overlap_frac,  initial_zoom));

				sb.append(String.format("\t%3d\t%3d\t%6.4f",
						pairwiseOrthoMatch.nxy[0],pairwiseOrthoMatch.nxy[1],spiral_rms)); 
				if (failed_refine) {
					String str_failed = String.format("\t%6.4f\tFAILED\n",pairwiseOrthoMatch.rms);
					failed_pairs.add(pair);
					sb.append(String.format(str_failed));
					if (debugLevel > -4) System.out.print("Final adjustment (3)"+str_failed);				
				} else {
					pairwiseOrthoMatch.overlap = overlap_frac; // needed here if refining old/manual w/o overlap 
					sb.append(String.format("\t%6.4f\t%3d\n",pairwiseOrthoMatch.rms,pairwiseOrthoMatch.zoom_lev)); 
					if (debugLevel > -4) System.out.println("Final adjustment (4) RMSE="+pairwiseOrthoMatch.rms+
							", overlap = "+pairwiseOrthoMatch.overlap);				
					ortho_maps[ipair[0]].setMatch(ortho_maps[ipair[1]].getName(),pairwiseOrthoMatch);
					if (save_each && (orthoMapsCollection_path != null)) {
						try {
							writeOrthoMapsCollection(orthoMapsCollection_path);
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						if (debugLevel > -4) {
							System.out.println("Saved data to "+ orthoMapsCollection_path);
						}
					}
				}
				if (log_append && (log_path != null)) { // assuming directory exists
					CalibrationFileManagement.saveStringToFile (
							log_path,          //String path,
							sb.toString(), // data,
							true); // boolean append)
				}
				success &= !failed_refine;
			}
			pairsGraph.recordPair(
					next_pair,    // int []   pair,
					success,      // boolean  success,
					pairsGraph.useMultiThreaded());
			if (success) {
				num_pairs++;
			}
		} // next pair
		
		if (log_append && (log_path != null)) { // assuming directory exists
			StringBuffer sb = new StringBuffer();
			sb.append("\nSUMMARY\n");
			sb.append("new\t"+ num_pairs+"\n");
//			sb.append("new\t"+ new_pairs.size()+"\n");
			sb.append("failed\t"+failed_pairs.size()+"\n");
			if (!failed_pairs.isEmpty()) {
				for (int i = 0; i < failed_pairs.size(); i++) {
					int [] ipair = {indices[failed_pairs.get(i).x], indices[failed_pairs.get(i).y]};
					sb.append(String.format("%4d\t%4d\t%s\t%s\n",
							ipair[0], ipair[1], ortho_maps[ipair[0]].getName(), ortho_maps[ipair[1]].getName()));
				}
			}
			CalibrationFileManagement.saveStringToFile (
					log_path,          //String path,
					sb.toString(), // data,
					true); // boolean append)
        	if (debugLevel > -4) {
        		System.out.println("Appended log file "+ log_path);
        	}
		}
		if (orthoMapsCollection_path != null) {
        	try {
        		writeOrthoMapsCollection(orthoMapsCollection_path);
        	} catch (IOException e) {
        		// TODO Auto-generated catch block
        		e.printStackTrace();
        	}
        	if (debugLevel > -4) {
        		System.out.println("Saved data to "+ orthoMapsCollection_path);
        	}
		}
		return true;
	}
	
	
	public boolean altutudeMatchPairs(
			CLTParameters clt_parameters,
			String        orthoMapsCollection_path) {
        //OrientationSceneLMA.testGetPairErrQuaternion ();	


        
        
        // Create list of all pairs (after recreating all overlaps with updated affines)
		ArrayList<Point> pairs_list = new ArrayList<Point>();
		boolean dbg00 = false;
		for (OrthoMap map : ortho_maps) {
//			if (getIndex(map.getName()) == 87) {
//				System.out.println("index="+getIndex(map.getName()));
//			}
			for (String other_name: map.pairwise_matches.keySet()) {
				pairs_list.add(new Point(
						getIndex(map.getName()),
						getIndex(other_name)));
				if (dbg00) {
					System.out.println(getIndex(map.getName())+"-"+getIndex(other_name)+" "+map.getName()+"-"+other_name);
					if(getIndex(map.getName()) == getIndex(other_name)) {
						System.out.println();
					}
				}
			}
		}
		// sort pairs_list by x then y
		Collections.sort(pairs_list, new Comparator<Point>() {
			@Override
			public int compare(Point lhs, Point rhs) {
				return (rhs.x > lhs.x) ? -1 : (rhs.x < lhs.x) ? 1 :
					((rhs.y > lhs.y) ? -1 : (rhs.y < lhs.y) ? 1 : 0); // increasing
			}
		});

		// convert ArrayList<Point> to array int[][]
		int [][] available_pairs = new int [pairs_list.size()][2];
		for (int i = 0; i < available_pairs.length; i++) {
			available_pairs[i][0] = pairs_list.get(i).x;
			available_pairs[i][1] = pairs_list.get(i).y;
		}
		
		boolean flt_undef_only =     false; // clt_parameters.imp.flt_undef_only;    //  false;
		double  flt_min_overlap =    clt_parameters.imp.flt_min_overlap;   //  0.0;
		double  flt_max_overlap =    clt_parameters.imp.flt_max_overlap;   //  1.0;
		double  flt_min_rms =        clt_parameters.imp.flt_min_rms;       //  0.0;
		double  flt_max_rms =        clt_parameters.imp.flt_max_rms;       //  2.0;
		boolean flt_nan_rms =        clt_parameters.imp.flt_nan_rms;       //  false;
		
		boolean flt_filt_zoom =      clt_parameters.imp.flt_filt_zoom;     //  true;
		int     flt_min_zoom =       clt_parameters.imp.flt_min_zoom;      // -2;
		int     flt_max_zoom =       clt_parameters.imp.flt_max_zoom;      // 10;
		double  flt_min_sfm =        clt_parameters.imp.flt_min_sfm;       //  0.0;
		double  flt_max_sfm =        clt_parameters.imp.flt_max_sfm;       //1000.0;
        int     flt_alt =            clt_parameters.imp.flt_alt;           // 0;
		boolean flt_show_names =     true;  // clt_parameters.imp.flt_show_names;    //  true;
		boolean flt_show_overlaps =  true;  // clt_parameters.imp.flt_show_overlaps; //  true;
		boolean flt_show_rms =       true;  // clt_parameters.imp.flt_show_rms;      //  true;
		boolean flt_show_zoom =      true;  // clt_parameters.imp.flt_show_zoom;     //  true;
		boolean flt_show_alt =       true;  // clt_parameters.imp.flt_show_alt;     //  true;

		boolean alt_overwrite =      clt_parameters.imp.alt_overwrite; // false; // overwrite existing altitude match pairs
		boolean alt_pairwise =       clt_parameters.imp.alt_pairwise; // false; // overwrite existing altitude match pairs
		
		double  alt_sigma =          clt_parameters.imp.alt_sigma;        // 5.0; Reduce weight of the border tiles, Gaussian sigma in tiles to apply to weights.
		double  alt_abs_outliers =   clt_parameters.imp.alt_abs_outliers; // 3.0;     // remove absolute outliers when fitting planes 
		double  alt_outliers =       clt_parameters.imp.alt_outliers;     // 0.05; Remove outliers when fitting planes, removed fraction.
		int     alt_refine =         clt_parameters.imp.alt_refine;       // 1; Refine altitude difference plane after removing outliers (0 - no outlier removal, 1 - remove outliers and refine once, ...)
		
		double  metric_err =         clt_parameters.imp.pmtch_metric_err;// 0.05; // 0.02;//  2 cm

		double  weight_rot =         clt_parameters.imp.alt_weight_rot;    // >0 weight of pairs errors in qn3
		double  weight_tilt =        clt_parameters.imp.alt_weight_tilt;   // >0 weight of pairs errors in qn1, qn2
		double  weight_scale =       clt_parameters.imp.alt_weight_scale;  // >0 weight in pairs scale-1.0 errors
		double  pull  =              clt_parameters.imp.alt_pull;          // 0 <= pull <1 - fraction of all RMS contributors
		double  pull_rots =          clt_parameters.imp.alt_pull_rots;     // >=0 weight of sum of rotations, may be 0, normalized by pull value 
		double  pull_tilts  =        clt_parameters.imp.alt_pull_tilts;    // >=0 weights of sum of qn1 and qn2 of scenes, normalized by pull value
		double  pull_scales  =       clt_parameters.imp.alt_pull_scales;   // >=0 weights of scales of scenes, normalized by pull value
		
		// log/save parameters
		boolean save_each     =      clt_parameters.imp.pwise_save_each;    // save state file after each match
		boolean log_append    =      clt_parameters.imp.pwise_log_append;   //
		String  log_path      =      clt_parameters.imp.pwise_log_path;     // 
		int     debugLevel    =      clt_parameters.imp.pwise_debug;        //
		
		boolean flt_update_config =  false;
		boolean select_pairs =       false;
		
		GenericJTabbedDialog gdf = new GenericJTabbedDialog("Select pairs filter/display",800,1200);
		gdf.addMessage("Filter pairs parameters");
		gdf.addNumericField("Minimal scene overlap (0..1)",flt_min_overlap,  3,7,"", "Minimal overlap of the scenes to keep (0-no overlap, 1.0 - smaller scene is inside the parger one.");
		gdf.addNumericField("Maximal scene overlap (0..1)",flt_max_overlap,  3,7,"", "Maximal overlap of the scenes to keep (0-no overlap, 1.0 - smaller scene is inside the parger one.");
		gdf.addCheckbox    ("Filter by zoom level"  ,      flt_filt_zoom, "Filter by the zoom level used for matching.");
		gdf.addNumericField("Minimal zoom",                flt_min_zoom, 0,3,"","Minimal zoom level used for matching.");
		gdf.addNumericField("Maximal zoom",                flt_max_zoom, 0,3,"","Maximal zoom level used for matching.");
		gdf.addNumericField("Minimal SfM gain",            flt_min_sfm,  3,7,"","Minimal SfM gain of the minimum in the scene pair.");
		gdf.addNumericField("Maximal SfM gain",            flt_max_sfm,  3,7,"","Maximal SfM gain of the minimum in the scene pair.");
 		gdf.addNumericField("Minimal RMSE",                flt_min_rms,  3,7,"",	 "Minimal LMA RMSE of the scene pair.");
		gdf.addNumericField("Maximal RMSE",                flt_max_rms,  3,7,"",	 "Maximal LMA RMSE of the scene pair.");
		gdf.addCheckbox    ("NaN RMS (failed match)",      flt_nan_rms, "Keep only failed matches with RMSE=NaN.");
		
		gdf.addChoice("Filter by pairwise ALT availability",IntersceneMatchParameters.FLT_ALT_MODES, IntersceneMatchParameters.FLT_ALT_MODES[flt_alt],"Filter by pairwise ALT availability.");
		gdf.addMessage("Alt match parameters");
		gdf.addCheckbox    ("Overwrite existing alt_data", alt_overwrite, "Overwrite already defined altitude match pairs.");
		gdf.addCheckbox    ("Use pairwise affines",        alt_pairwise,  "Use pairwise affines if available (false - always recalculate from individual).");
		gdf.addNumericField("Border sigma",                alt_sigma,  3,7,"tiles",	"Reduce weight of the border tiles, Gaussian sigma in tiles to apply to weights.");
		gdf.addNumericField("Absolute outliers offset",    alt_abs_outliers,  3,7,"m","Remove absolute outliers when fitting planes.");
		gdf.addNumericField("Fraction of ouliers",         alt_outliers,  3,7,"",	"Remove outliers when fitting planes, removed fraction.");
		gdf.addNumericField("Number of alt plane refines", alt_refine, 0,3,"",      "Refine altitude difference plane after removing outliers (0 - no outlier removal, 1 - remove outliers and refine once, ...)");
		
		
		
		gdf.addMessage("Log and Save, and Debug parameters");
	    gdf.addCheckbox    ("Save state after each match", save_each, "Update state file after each match generation to mitigate possible crashes.");
	    gdf.addCheckbox    ("Write log file",              log_append, "Enable writing log file with matching results.");
	    gdf.addStringField ("Log file full path",          log_path, 150, "Path of the log file to be appended.");	
		gdf.addNumericField("Debug level",  debugLevel, 0,3,"","Debug level during Spiral search.");
		gdf.addCheckbox    ("Update configuration",        flt_update_config, "Update matching configuration parameters to be saved as defaults.");
		gdf.addCheckbox    ("Select filtered pairs",       select_pairs, "Manually select from the filtered pairs.");
		
		gdf.showDialog();
		if (gdf.wasCanceled()) return false;
		flt_min_overlap   =       gdf.getNextNumber();
		flt_max_overlap   =       gdf.getNextNumber();
        flt_filt_zoom     =       gdf.getNextBoolean();
        flt_min_zoom      = (int) gdf.getNextNumber(); 
        flt_max_zoom      = (int) gdf.getNextNumber();
        flt_min_sfm       =       gdf.getNextNumber();
        flt_max_sfm       =       gdf.getNextNumber();
		flt_min_rms       =       gdf.getNextNumber();
		flt_max_rms       =       gdf.getNextNumber();
		flt_nan_rms       =       gdf.getNextBoolean();
        flt_alt           =       gdf.getNextChoiceIndex();
        alt_overwrite     =       gdf.getNextBoolean();
        alt_pairwise      =       gdf.getNextBoolean();
        alt_sigma         =       gdf.getNextNumber();
        alt_abs_outliers  =       gdf.getNextNumber();
        alt_outliers      =       gdf.getNextNumber();
        alt_refine        = (int) gdf.getNextNumber();
		save_each         =       gdf.getNextBoolean();
		log_append        =       gdf.getNextBoolean();
		log_path          =       gdf.getNextString();
		debugLevel =        (int) gdf.getNextNumber();
		flt_update_config =       gdf.getNextBoolean();
		select_pairs =            gdf.getNextBoolean();
		
		if (flt_update_config) {
			clt_parameters.imp.flt_min_overlap =   flt_min_overlap;
			clt_parameters.imp.flt_max_overlap =   flt_max_overlap;
			clt_parameters.imp.flt_filt_zoom =     flt_filt_zoom;
			clt_parameters.imp.flt_min_zoom =      flt_min_zoom;
			clt_parameters.imp.flt_max_zoom =      flt_max_zoom;
    		clt_parameters.imp.flt_min_sfm =       flt_min_sfm;
    		clt_parameters.imp.flt_max_sfm =       flt_max_sfm;
			clt_parameters.imp.flt_min_rms =       flt_min_rms;
			clt_parameters.imp.flt_max_rms =       flt_max_rms;
			clt_parameters.imp.flt_nan_rms =       flt_nan_rms;
			
			clt_parameters.imp.flt_alt =           flt_alt;
			clt_parameters.imp.alt_overwrite =     alt_overwrite; 
			clt_parameters.imp.alt_pairwise =      alt_pairwise;
   			clt_parameters.imp.alt_sigma    =      alt_sigma;
			clt_parameters.imp.alt_abs_outliers =  alt_abs_outliers;
			clt_parameters.imp.alt_outliers =      alt_outliers;
			clt_parameters.imp.alt_refine   =      alt_refine;
			
			clt_parameters.imp.pwise_save_each  = save_each;  
			clt_parameters.imp.pwise_log_append = log_append; 
			clt_parameters.imp.pwise_log_path   = log_path;   
			clt_parameters.imp.pwise_debug      = debugLevel; 
		}

		available_pairs = filterPairs(
				available_pairs, // int [][] plist_in,
				flt_undef_only,  // boolean  undef_only,
				flt_min_overlap, // double   min_overlap,
				flt_max_overlap, // double   max_overlap,
				flt_min_rms,     // double   min_rms,
				flt_max_rms,     // double   max_rms,
				flt_nan_rms,     // boolean  nan_rms)
				flt_filt_zoom,   // boolean          filt_zoom,
				flt_min_zoom,    // int              min_zoom,
				flt_max_zoom,    // int              max_zoom)
				flt_min_sfm,     // double           min_sfm,
				flt_max_sfm,     // double           max_sfm,
				flt_alt);       // int               flt_alt)\
		if (select_pairs) {
			String [] choices_all = textPairs (
					available_pairs,   // int [][] plist,
					flt_show_names,    // boolean          show_names,
					flt_show_overlaps, // boolean          show_overlap,
					flt_show_rms,      // boolean          show_rms,
					flt_show_zoom,     // boolean          show_zoom,
					flt_show_alt,      // boolean          show_alt,
					false,             // boolean          use_tab,
					null); // flt_extra_line);   // String           extra_line)
			GenericJTabbedDialog gdc = new GenericJTabbedDialog("Select image pairs",1200,1000);
			boolean [] bselected_pairs = new boolean [choices_all.length];
			for (int i = 0; i < choices_all.length; i++) {
				gdc.addCheckbox    (i+": "+choices_all[i],    bselected_pairs[i],  "Select this scene pair for processing.");
			}
			gdc.showDialog();
			if (gdc.wasCanceled()) return false;
			int num_pairs = 0;
			for (int i = 0; i < choices_all.length; i++) {
				bselected_pairs[i] = gdc.getNextBoolean();
				if (bselected_pairs[i]) num_pairs++;
			}
			int [][] selected_pairs = new int[num_pairs][];
			int indx = 0;
			for (int i = 0; i < bselected_pairs.length; i++) if (bselected_pairs[i]){
				selected_pairs[indx++]= available_pairs[i];
			}
			available_pairs = selected_pairs;
		}
		
		
		
		String [] choices_all = textPairs (
				available_pairs,   // int [][] plist,
				flt_show_names,    // boolean          show_names,
				flt_show_overlaps, // boolean          show_overlap,
				flt_show_rms,      // boolean          show_rms,
				flt_show_zoom,     // boolean          show_zoom,
				flt_show_alt,      // boolean          show_alt,
				true,              // boolean          use_tab,
				null);             // String           extra_line)
		if (debugLevel > 0) {
			System.out.println("Selected "+available_pairs.length+" scene pairs for matching");
			for (int i = 0; i < available_pairs.length; i++) {
				System.out.println(String.format("%4d:%s",i,choices_all[i]));
			}
		}
		if (available_pairs.length == 0) {
			return false;
		}
	////
	return 	OrthoAltitudeMatch.altutudeMatchPairs(
			clt_parameters,           // CLTParameters clt_parameters,
			this,                     // OrthoMapsCollection orthoMapsCollection, 
			available_pairs,          // int [][]      available_pairs,
			select_pairs || alt_overwrite,            // boolean             alt_overwrite, // overwrite existing altitude match pairs
			alt_pairwise,             // boolean             alt_pairwise,  // use pairwise affines if available
			alt_sigma,                // double  alt_sigma,     // 5.0; Reduce weight of the border tiles, Gaussian sigma in tiles to apply to weights.
			alt_abs_outliers,         //double              alt_abs_outliers, //  =   3.0;     // remove absolute outliers when fitting planes 
			alt_outliers,             // double  alt_outliers,  // 0.05; Remove outliers when fitting planes, removed fraction.
			alt_refine,               // int     alt_refine,    // 1; Refine altitude difference plane after removing outliers (0 - no outlier removal, 1 - remove outliers and refine once, ...)
			metric_err,               // double  metric_error,
			weight_rot,               // double  weight_rot,    // >0 weight of pairs errors in qn3
			weight_tilt,              // double  weight_tilt,   // >0 weight of pairs errors in qn1, qn2
			weight_scale,             // double  weight_scale,  // >0 weight in pairs scale-1.0 errors
			pull,                     // double  pull,          // 0 <= pull <1 - fraction of all RMS contributors
			pull_rots,                // double  pull_rots,     // >=0 weight of sum of rotations, may be 0, normalized by pull value 
			pull_tilts,               // double  pull_tilts,    // >=0 weights of sum of qn1 and qn2 of scenes, normalized by pull value
			pull_scales,              // double  pull_scales,   // >=0 weights of scales of scenes, normalized by pull value
			// log/save parameters
			save_each,                // boolean save_each,
			log_append,               // boolean log_append,
			log_path,                 // String  log_path,
			orthoMapsCollection_path, // String  orthoMapsCollection_path,
			debugLevel);              // int     debugLevel)
    }		
		
	public boolean displayScenePairs(
			CLTParameters clt_parameters,
			String        orthoMapsCollection_path) {
		// Create list of all pairs (after recreating all overlaps with updated affines)
		ArrayList<Point> pairs_list = new ArrayList<Point>(); 
		boolean dbg00=false;
		for (OrthoMap map : ortho_maps) {
			if (getIndex(map.getName()) == 87) {
				System.out.println("index="+getIndex(map.getName()));
			}
			for (String other_name: map.pairwise_matches.keySet()) {
				pairs_list.add(new Point(
						getIndex(map.getName()),
						getIndex(other_name)));
				if (dbg00) {
					System.out.println(getIndex(map.getName())+"-"+getIndex(other_name)+" "+map.getName()+"-"+other_name);
					if(getIndex(map.getName()) == getIndex(other_name)) {
						System.out.println();
					}
				}
			}
		}
		// sort pairs_list by x then y
		Collections.sort(pairs_list, new Comparator<Point>() {
			@Override
			public int compare(Point lhs, Point rhs) {
				return (rhs.x > lhs.x) ? -1 : (rhs.x < lhs.x) ? 1 :
					((rhs.y > lhs.y) ? -1 : (rhs.y < lhs.y) ? 1 : 0); // increasing
			}
		});

		// convert ArrayList<Point> to array int[][]
		int [][] available_pairs = new int [pairs_list.size()][2];
		for (int i = 0; i < available_pairs.length; i++) {
			available_pairs[i][0] = pairs_list.get(i).x;
			available_pairs[i][1] = pairs_list.get(i).y;
		}
		
		boolean flt_undef_only =     false; // clt_parameters.imp.flt_undef_only;    //  false;
		double  flt_min_overlap =    clt_parameters.imp.flt_min_overlap;   //  0.0;
		double  flt_max_overlap =    clt_parameters.imp.flt_max_overlap;   //  1.0;
		double  flt_min_rms =        clt_parameters.imp.flt_min_rms;       //  0.0;
		double  flt_max_rms =        clt_parameters.imp.flt_max_rms;       //  2.0;
		boolean flt_nan_rms =        clt_parameters.imp.flt_nan_rms;       //  false;
		
		boolean flt_filt_zoom =      clt_parameters.imp.flt_filt_zoom;     //  true;
		int     flt_min_zoom =       clt_parameters.imp.flt_min_zoom;      // -2;
		int     flt_max_zoom =       clt_parameters.imp.flt_max_zoom;      // 10;
		double  flt_min_sfm =        clt_parameters.imp.flt_min_sfm;       //  0.0;
		double  flt_max_sfm =        clt_parameters.imp.flt_max_sfm;       //1000.0;
        int     flt_alt =            clt_parameters.imp.flt_alt;           // 0;
		boolean flt_show_names =     true;  // clt_parameters.imp.flt_show_names;    //  true;
		boolean flt_show_overlaps =  true;  // clt_parameters.imp.flt_show_overlaps; //  true;
		boolean flt_show_rms =       true;  // clt_parameters.imp.flt_show_rms;      //  true;
		boolean flt_show_zoom =      true;  // clt_parameters.imp.flt_show_zoom;     //  true;
		boolean flt_show_alt =       true;  // clt_parameters.imp.flt_show_alt;     //  true;
		boolean flt_show_svd =       true;
		boolean flt_show_degrees =   true;
		

		boolean alt_overwrite =      clt_parameters.imp.alt_overwrite; // false; // overwrite existing altitude match pairs
		boolean alt_pairwise =       clt_parameters.imp.alt_pairwise; // false; // overwrite existing altitude match pairs
		double  metric_err =         clt_parameters.imp.pmtch_metric_err;// 0.05; // 0.02;//  2 cm

		// log/save parameters
		boolean save_each     =      clt_parameters.imp.pwise_save_each;    // save state file after each match
		boolean log_append    =      clt_parameters.imp.pwise_log_append;   //
		String  log_path      =      clt_parameters.imp.pwise_log_path;     // 
		int     debugLevel    =      clt_parameters.imp.pwise_debug;        //
		
		boolean flt_update_config =  false;
		
		
		GenericJTabbedDialog gdf = new GenericJTabbedDialog("Select pairs filter/display",800,1200);
		gdf.addMessage("Filter pairs parameters");
		gdf.addNumericField("Minimal scene overlap (0..1)",flt_min_overlap,  3,7,"", "Minimal overlap of the scenes to keep (0-no overlap, 1.0 - smaller scene is inside the parger one.");
		gdf.addNumericField("Maximal scene overlap (0..1)",flt_max_overlap,  3,7,"", "Maximal overlap of the scenes to keep (0-no overlap, 1.0 - smaller scene is inside the parger one.");
		gdf.addCheckbox    ("Filter by zoom level"  ,      flt_filt_zoom, "Filter by the zoom level used for matching.");
		gdf.addNumericField("Minimal zoom",                flt_min_zoom, 0,3,"","Minimal zoom level used for matching.");
		gdf.addNumericField("Maximal zoom",                flt_max_zoom, 0,3,"","Maximal zoom level used for matching.");
		gdf.addNumericField("Minimal SfM gain",            flt_min_sfm,  3,7,"","Minimal SfM gain of the minimum in the scene pair.");
		gdf.addNumericField("Maximal SfM gain",            flt_max_sfm,  3,7,"","Maximal SfM gain of the minimum in the scene pair.");
 		gdf.addNumericField("Minimal RMSE",                flt_min_rms,  3,7,"",	 "Minimal LMA RMSE of the scene pair.");
		gdf.addNumericField("Maximal RMSE",                flt_max_rms,  3,7,"",	 "Maximal LMA RMSE of the scene pair.");
		gdf.addCheckbox    ("NaN RMS (failed match)",      flt_nan_rms, "Keep only failed matches with RMSE=NaN.");
		
		gdf.addChoice("Filter by pairwise ALT availability",IntersceneMatchParameters.FLT_ALT_MODES, IntersceneMatchParameters.FLT_ALT_MODES[flt_alt],"Filter by pairwise ALT availability.");
		gdf.addMessage("Alt match parameters");
		gdf.addCheckbox    ("Overwrite existing alt_data", alt_overwrite, "Overwrite already defined altitude match pairs.");
		gdf.addCheckbox    ("Use pairwise affines",        alt_pairwise,  "Use pairwise affines if available (false - always recalculate from individual).");
		gdf.addMessage("Log and Save, and Debug parameters");
	    gdf.addCheckbox    ("Save state after each match", save_each, "Update state file after each match generation to mitigate possible crashes.");
	    gdf.addCheckbox    ("Write log file",              log_append, "Enable writing log file with matching results.");
	    gdf.addStringField ("Log file full path",          log_path, 150, "Path of the log file to be appended.");	
		gdf.addNumericField("Debug level",  debugLevel, 0,3,"","Debug level during Spiral search.");
		gdf.addCheckbox    ("Update configuration",        flt_update_config, "Update matching configuration parameters to be saved as defaults.");
		
		gdf.showDialog();
		if (gdf.wasCanceled()) return false;
		flt_min_overlap   =       gdf.getNextNumber();
		flt_max_overlap   =       gdf.getNextNumber();
        flt_filt_zoom     =       gdf.getNextBoolean();
        flt_min_zoom      = (int) gdf.getNextNumber(); 
        flt_max_zoom      = (int) gdf.getNextNumber();
        flt_min_sfm       =       gdf.getNextNumber();
        flt_max_sfm       =       gdf.getNextNumber();
		flt_min_rms       =       gdf.getNextNumber();
		flt_max_rms       =       gdf.getNextNumber();
		flt_nan_rms       =       gdf.getNextBoolean();
        flt_alt           =       gdf.getNextChoiceIndex();
        alt_overwrite     =       gdf.getNextBoolean();
        alt_pairwise     =        gdf.getNextBoolean();
		save_each         =       gdf.getNextBoolean();
		log_append        =       gdf.getNextBoolean();
		log_path          =       gdf.getNextString();
		debugLevel =        (int) gdf.getNextNumber();
		flt_update_config =       gdf.getNextBoolean();
		
		if (flt_update_config) {
			clt_parameters.imp.flt_min_overlap =   flt_min_overlap;
			clt_parameters.imp.flt_max_overlap =   flt_max_overlap;
			clt_parameters.imp.flt_filt_zoom =     flt_filt_zoom;
			clt_parameters.imp.flt_min_zoom =      flt_min_zoom;
			clt_parameters.imp.flt_max_zoom =      flt_max_zoom;
    		clt_parameters.imp.flt_min_sfm =       flt_min_sfm;
    		clt_parameters.imp.flt_max_sfm =       flt_max_sfm;
			clt_parameters.imp.flt_min_rms =       flt_min_rms;
			clt_parameters.imp.flt_max_rms =       flt_max_rms;
			clt_parameters.imp.flt_nan_rms =       flt_nan_rms;
			
			clt_parameters.imp.flt_alt =           flt_alt;
			clt_parameters.imp.alt_overwrite =     alt_overwrite; 
			clt_parameters.imp.alt_pairwise =      alt_pairwise; 
			clt_parameters.imp.pwise_save_each  = save_each;  
			clt_parameters.imp.pwise_log_append = log_append; 
			clt_parameters.imp.pwise_log_path   = log_path;   
			clt_parameters.imp.pwise_debug      = debugLevel; 
		}

		available_pairs = filterPairs(
				available_pairs, // int [][] plist_in,
				flt_undef_only,  // boolean  undef_only,
				flt_min_overlap, // double   min_overlap,
				flt_max_overlap, // double   max_overlap,
				flt_min_rms,     // double   min_rms,
				flt_max_rms,     // double   max_rms,
				flt_nan_rms,     // boolean  nan_rms)
				flt_filt_zoom,   // boolean          filt_zoom,
				flt_min_zoom,    // int              min_zoom,
				flt_max_zoom,    // int              max_zoom)
				flt_min_sfm,     // double           min_sfm,
				flt_max_sfm,     // double           max_sfm,
				flt_alt);       // int               flt_alt)
		boolean use_tab=true;
		boolean flt_show_sfm=flt_show_alt;
		String [] choices_all = textPairs (
				available_pairs,   // int [][] plist,
				flt_show_names,    // boolean          show_names,
				flt_show_overlaps, // boolean          show_overlap,
				flt_show_rms,      // boolean          show_rms,
				flt_show_zoom,     // boolean          show_zoom,
				flt_show_alt,      // boolean          show_alt,
				use_tab,           // boolean          use_tab,
				null,              // String           extra_line)
				flt_show_svd,      // boolean          show_svd,
				flt_show_degrees); // boolean          use_degrees);
			
		{
			System.out.println("Selected\t"+available_pairs.length+"\tscene pairs for matching");
			if (use_tab) {
				System.out.print(String.format("#\t%3s\t%3s","i0","i1"));
				if (flt_show_names)    System.out.print(String.format("\t%17s\t%17s","timestamp 0","timestamp 1"));
				if (flt_show_overlaps) System.out.print(String.format("\t%5s", "olap%"));
				if (flt_show_rms)      System.out.print(String.format("\t%5s", "RMSE"));
				if (flt_show_zoom)     System.out.print(String.format("\t%4s", "Zoom"));
				if (flt_show_alt)      System.out.print(String.format("\t%7s\t%7s\t%7s", "tiltX","tiltY","offs"));
				if (flt_show_sfm)      System.out.print(String.format("\t%5s\t%5s", "SfM0","SfM1"));
				if (flt_show_svd) {
					String svd_title=SingularValueDecomposition.titleString(flt_show_degrees);
					System.out.print("\t"+ svd_title);
				}
				System.out.println();
			}
			for (int i = 0; i < available_pairs.length; i++) {
//				System.out.println(String.format("%4d:%s",i,choices_all[i]));
				System.out.println(String.format(use_tab?"%4d\t%s":"%4d:%s",i,choices_all[i]));
			}
		}
		if (available_pairs.length == 0) {
			return false;
		}
	////
		return true;
	}	
	
	
	public boolean processComboMap(
			CLTParameters    clt_parameters,
			int debugLevel) {
		int [] indices = getScenesSelection(
				clt_parameters, // CLTParameters       clt_parameters,				
				" to process/display"); // String purpose)
		if (indices == null) {
			return false;
		}
		boolean more = true;
		while (more) { // generate multiple images/stats for the same selection
			more = processComboSelection(
					clt_parameters, // CLTParameters    clt_parameters,
					indices,
					debugLevel);
		}
		return true;
	}
	
	public boolean processComboSelection(
			CLTParameters    clt_parameters,
			int [] indices,
			int debugLevel) {
		boolean show_map_stats =      false;      
		boolean show_combo_map =      false; // true;  // false; // true;
		boolean show_alt_map =        false;
		boolean show_combo_mask =     false; // generate image mas (where it is defined)
		boolean show_frames =         false;
		int     frame_shrink =        4; 
		int     frame_grow =          4;
		double  frame_blur =          1.0;
		double  frame_cut_frac =      0.01;
		int     zoom_lev =           -2; // 0; // +1 - zoom in twice, -1 - zoom out twice
		int     margins =             0; // 10;
		boolean show_centers =        true;
		boolean bounds_to_indices =   true;
		boolean merge_layers =        false;  // instead of individuals
		boolean ignore_affines =      false;
		boolean ignore_equalize =     false;
		boolean use_orientations =    true;
		boolean keep_window =         true;
		double  scale_tilt =          1.0;
		

//		String        save_top_dir =      "/media/elphel/NVME/lwir16-proc/ortho_videos/debug/sept12-13/pattern_match/";
//		String        sub_dir =           "combo_maps";
		String        save_top_dir =      clt_parameters.imp.patt_save_top;
		String        sub_dir =           clt_parameters.imp.patt_save_subdir;
		boolean       show_images =       true;
		boolean       save_images =       true;
		
		GenericJTabbedDialog gd = new GenericJTabbedDialog("Combo map/stats generation",1200,1000);
		gd.addCheckbox    ("Show statistics for ortho images", show_map_stats,  "Generate and show statistics for ortho maps.");
		gd.addCheckbox    ("Show image map",             show_combo_map,  "Generate composite map of images.");
		gd.addCheckbox    ("Show altitudes",             show_alt_map,    "Generate composite process altitude maps.");
		gd.addCheckbox    ("Show image masks",           show_combo_mask, "Generate composite binary image.");
		gd.addCheckbox    ("Show image frames",          show_frames,     "Generate image borders.");
		gd.addNumericField("Shrink inner frames",        frame_shrink,  0,4,"pix","Shrink inner of the frames from the actual image borders.");
		gd.addNumericField("Grow outer frames",          frame_grow,    0,4,"pix","Grow outer of the frames from the actual image borders.");
		gd.addNumericField("Blur frames",                frame_blur,    3,7,"pix","Blur frames for anti-aliasing.");
		gd.addNumericField("Cut threshold",              frame_cut_frac, 3,7,"","After blurring, replace lower values by NaN.");
 		
		gd.addNumericField("Zoom level",                 zoom_lev,  0,4,"",
				"Zoom level: +1 - zoom in twice, -1 - zoom out twice");
		gd.addNumericField("Margins",                    margins,  0,4,"",
				"Add margins around images");

  		gd.addCheckbox    ("Show transformation centers",show_centers, "Mark verticals from the UAS on the ground.");
		gd.addCheckbox    ("Bounds to selected images",  bounds_to_indices, "Set combo image bounds to selected images only. False - all images.");
		gd.addCheckbox    ("Merge layers",               merge_layers, "Generate composite binary image.");

		gd.addCheckbox    ("Ignore affines",             ignore_affines,   "Ignore available affines, use unity.");
		gd.addCheckbox    ("Ignore equalization",        ignore_equalize,  "Ignore available intensity equalization, use unity.");
		gd.addCheckbox    ("Use scene orientations",     use_orientations, "Do not resize window to accomodate transformed image.");
		gd.addCheckbox    ("Keep sorce window",          keep_window,      "Use scenes scales/orientations.");
		gd.addNumericField("Scale tilt",                 scale_tilt,    3,7,"pix","Blur frames for anti-aliasing.");

		
		
		gd.addStringField ("Pattern match save directory",      save_top_dir, 120, "Top directory to save combo maps");
		gd.addStringField ("Save subdirectory",                 sub_dir, 80, "Subdirectory for versions of the same scene/pair of scenes");
		gd.addCheckbox    ("Show generated images",             show_images, "Display generated images.");
		gd.addCheckbox    ("Save generated images",             save_images, "Save generated image to the location defined by above..");
		
		gd.showDialog();
		if (gd.wasCanceled()) return false;
		show_map_stats =     gd.getNextBoolean();
		show_combo_map =     gd.getNextBoolean();
		show_alt_map =       gd.getNextBoolean();
		show_combo_mask =    gd.getNextBoolean();
		
		show_frames =        gd.getNextBoolean(); 
		frame_shrink = (int) gd.getNextNumber();
		frame_grow =   (int) gd.getNextNumber();
		frame_blur =         gd.getNextNumber();
		frame_cut_frac =     gd.getNextNumber();
		zoom_lev =     (int) gd.getNextNumber();
		margins =      (int) gd.getNextNumber();
		show_centers =       gd.getNextBoolean();
		bounds_to_indices =  gd.getNextBoolean();
		merge_layers =       gd.getNextBoolean();
		ignore_affines =     gd.getNextBoolean();
		ignore_equalize =    gd.getNextBoolean();
		use_orientations =   gd.getNextBoolean();
		keep_window =        gd.getNextBoolean();
		scale_tilt =         gd.getNextNumber();
		
		save_top_dir=        gd.getNextString();
		sub_dir=             gd.getNextString();
		show_images=         gd.getNextBoolean();
		save_images=         gd.getNextBoolean();
		
		String save_dir = null;
		if (save_images) {
			if (!save_top_dir.endsWith(Prefs.getFileSeparator())) {
				save_top_dir+= Prefs.getFileSeparator();
			}
			if (indices.length == 1) {
				save_dir=String.format("%s%03d-%s",
						save_top_dir,indices[0],ortho_maps[indices[0]].getName());
			} else if (indices.length == 2) {
				save_dir=String.format("%s%03d-%03d_%s-%s",
						save_top_dir,indices[0],indices[1],ortho_maps[indices[0]].getName(),ortho_maps[indices[1]].getName());
			}
			save_dir=save_top_dir;

			if (!sub_dir.equals("")) {
				save_dir+= Prefs.getFileSeparator()+sub_dir;
			}
			// create if it does not exist
			File  fsave_dir = new File(save_dir);
			fsave_dir.mkdirs();
			save_dir += Prefs.getFileSeparator();
		}
		
		if (show_map_stats) {
			String time_zone_name = "Europe/Kyiv";
			String [] stats = getScenesStats(indices, time_zone_name); // int [] indices)
			TextWindow tw = new TextWindow("Ortho_images_stats", stats[0], stats[1], 1250,1000);
			if (save_images && (save_dir != null)) {
				String path = save_dir+"ortho_images_stats.csv";
				tw.getTextPanel().saveAs(path);
				if (debugLevel > -4) {
					System.out.println("Saved stats to "+path);
				}
			}
		}
		
		double pix_m = OrthoMap.getPixelSizeMeters (zoom_lev);
		if (use_orientations) {
			System.out.println("using orientations");
			for (int nscene=0; nscene<indices.length; nscene++) {
				int indx = indices[nscene];
				System.out.println("Scene="+indx+", agl="+ortho_maps[indx].getAGL());
				
				double [] qorient = ortho_maps[indx].getQOrinet(); // QuatUtils.invert(ortho_maps[indx].getQOrinet());
				if (qorient == null) {
					qorient = new double [] {1,0,0,0};
				}
				final int src_width = ortho_maps[indx].getImageData().width;   // assuming same image size for alt and texture
				final int src_height = ortho_maps[indx].getImageData().height; // assuming same image size for alt and texture
				final double [] image_data = ortho_maps[indx].getImageData().getDData();
				final double [] alt_data = ortho_maps[indx].getAltData().getDData();
				double    pix_size_meters = OrthoMap.getPixelSizeMeters(ortho_maps[indx].getOriginalZoomLevel());
				//ortho_maps[indx]
				int hwidth = src_width/2;
				int hheight = src_height/2;
				double [] xyz_center = {hwidth, hheight, alt_data[hheight*src_width + hwidth]/ pix_size_meters}; // in "pixels"
				Rectangle owoi = new Rectangle();
				int       stride = 4; // >2, 3 - OK
				double    rfz = 0.3; // w= 1/(x^2+y^2+rfz^2)
				
				double [][] rotation_map_notilt = 	rotateAltCenter(
						qorient,      // final double [] quat_in,
						xyz_center,   // final double [] xyz_center,
						alt_data,     // final double [] alt_in,
						src_width,    // final int       width,
						pix_size_meters, // final double    pix_size_meters,
						owoi,         // final Rectangle owoi, // should not be null - will provide offset and new size
						stride,       // final int       stride, // >=2, use 4?
						rfz,          // final double    rfz,   // 0.3 w= 1/(x^2+y^2+rfz^2)
						keep_window,  // final boolean keep_window,
						0, // scale_tilt,   // final double  scale_tilt,
						debugLevel);  // final int debugLevel)
				double [] image_out_notilt = applySceneRotation(
						image_data,   // final double []   texture_in,
						src_width,    // final int         width_in,
						rotation_map_notilt, // final double [][] rotation_map,
						debugLevel);  // final int debugLevel)
				double [] alt_out_notilt =  getRotatedAlt(
						rotation_map_notilt);// final double [][] rotation_map)
				
				
				double [][] rotation_map = 	rotateAltCenter(
						qorient,      // final double [] quat_in,
						xyz_center,   // final double [] xyz_center,
						alt_data,     // final double [] alt_in,
						src_width,    // final int       width,
						pix_size_meters, // final double    pix_size_meters,
						owoi,         // final Rectangle owoi, // should not be null - will provide offset and new size
						stride,       // final int       stride, // >=2, use 4?
						rfz,          // final double    rfz,   // 0.3 w= 1/(x^2+y^2+rfz^2)
						keep_window,  // final boolean keep_window,
						scale_tilt,   // final double  scale_tilt,
						debugLevel);  // final int debugLevel)
				final double [] xy_center_out = {xyz_center[0]-owoi.x, xyz_center[1]-owoi.y}; // do outside by caller - new rotation center
				double [] image_out = applySceneRotation(
						image_data,   // final double []   texture_in,
						src_width,    // final int         width_in,
						rotation_map, // final double [][] rotation_map,
						debugLevel);  // final int debugLevel)
				double [] alt_out =  getRotatedAlt(
						rotation_map);// final double [][] rotation_map)
				double [] image_data_padded = debugPadInToOut(
						image_data,  // final double []   texture_in,
						src_width,   // final int         width_in,
						owoi);       // final Rectangle   woi)
				double [] alt_data_padded = debugPadInToOut(
						alt_data,    // final double []   texture_in,
						src_width,   // final int         width_in,
						owoi);       // final Rectangle   woi)
				String [] titles= {"img_src","img_rot","img_out","alt_src","alt_rot","alt_out"};
				double [][] dbg_img = {image_data_padded,image_out_notilt,image_out,alt_data_padded, alt_out_notilt, alt_out};
				String title = String.format("%03d-%s", indx, ortho_maps[indx].getName()+"-ROTATION_DBG");
				ImageStack stack = ShowDoubleFloatArrays.makeStack( 
						dbg_img,
						owoi.width,
						owoi.height,
						titles,
						false);
				ImagePlus imp = new ImagePlus(title, stack);
				if (show_centers) {
					PointRoi roi = new PointRoi();
					roi.addPoint(xy_center_out[0], xy_center_out[1], 0+1);
					roi.setOptions("label");
					imp.setRoi(roi);
		        }
		        imp.show(); // debugging
			}
			
		}
		if (show_combo_map) {
			int [] wh =     new int[2];
			int [] origin = new int[2];
			double [][] centers = show_centers? (new double [indices.length][]): null;
			double [][][] affines = null;
			if (ignore_affines) {
				affines = new double [indices.length][2][3];
				for (int i = 0; i < indices.length; i++) {
					affines[i][0][0] = 1;
					affines[i][1][1] = 1;
				}
			}
			
			double [][] dmulti = renderMultiDouble (
					null,              // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
					indices,           // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
					bounds_to_indices, // boolean       bounds_to_indices,
					affines,           // null,            // affines,    // double [][][] affines, // null or [indices.length][2][3]
					null,              // double [][]   equalize,
					ignore_equalize,   // true,              // boolean       ignore_equalize,
					null,              // warp,       // FineXYCorr    warp,,
					zoom_lev,          // int         zoom_level,
					wh,                // int []      wh,
					origin,            // int []      origin){ // maps[0] as a reference
					centers);          // double [][] centers)
			if (margins > 0) {
				addMargins(
						dmulti,   // double [][] dmulti,
						wh,       // int width,
						margins); // int margins)
			}
			showSaveMap(
					indices, // int []      indices,
					dmulti,  // double [][] dmulti,
					wh[0],   // int         width,
					
					centers, // int    [][] centers,
					merge_layers, // boolean     merge_layers,
					false,   // boolean     use_max,
					show_images, // boolean     show,
					save_images, // boolean     save,
					save_dir, // String      save_dir,
					"_"+indices.length+"_MAP-"+pix_m, // String      suffix
					debugLevel); // int         debugLevel)			
		}
		if (show_alt_map) {
			int [] wh =     new int[2];
			int [] origin = new int[2];
			double [][] centers = show_centers? (new double [indices.length][]): null;
			double [][] dmulti = renderMultiDouble (
					new double [indices.length][] , // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
					indices,                        // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
					bounds_to_indices,              // boolean       bounds_to_indices,
					null,                           // affines,    // double [][][] affines, // null or [indices.length][2][3]
					null,                           // double [][]   equalize,
					true,                           // boolean       ignore_equalize,
					null,                           // warp,       // FineXYCorr    warp,,
					zoom_lev,                       // int         zoom_level,
					wh,                             // int []      wh,
					origin,                         // int []      origin){ // maps[0] as a reference
					centers);                       // double [][] centers)
			if (margins > 0) {
				addMargins(
						dmulti,   // double [][] dmulti,
						wh,       // int width,
						margins); // int margins)
			}
			showSaveMap(
					indices, // int []      indices,
					dmulti,  // double [][] dmulti,
					wh[0],   // int         width,
					centers, // int    [][] centers,
					merge_layers, // boolean     merge_layers,
					false,   // boolean     use_max,
					show_images, // boolean     show,
					save_images, // boolean     save,
					save_dir, // String      save_dir,
					"_"+indices.length+"_ALT-"+pix_m, // String      suffix
					debugLevel); // int         debugLevel)			
		}
		if (show_combo_mask) {
			int [] wh =     new int[2];
			int [] origin = new int[2];
			double [][] centers = show_centers? (new double [indices.length][]): null;
			double [][] dmulti = renderMultiDouble (
					null,              // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
					indices,           // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
					bounds_to_indices, // boolean       bounds_to_indices,
					null,              // affines,    // double [][][] affines, // null or [indices.length][2][3]
					null,              // double [][]   equalize,
					true,              // boolean       ignore_equalize,
					null,              // warp,       // FineXYCorr    warp,,
					zoom_lev,          // int         zoom_level,
					wh,                // int []      wh,
					origin,            // int []      origin){ // maps[0] as a reference
					centers);          // double [][] centers)
			if (margins > 0) {
				addMargins(
						dmulti,   // double [][] dmulti,
						wh,       // int width,
						margins); // int margins)
			}
			for (int n = 0; n < dmulti.length; n++) {
				for (int i = 0; i < dmulti[n].length; i++) {
					dmulti[n][i] = Double.isNaN(dmulti[n][i])? 0:1;
				}
			}
			showSaveMap(
					indices, // int []      indices,
					dmulti,  // double [][] dmulti,
					wh[0],   // int         width,
					centers, // int    [][] centers,
					merge_layers, // boolean     merge_layers,
					true,    // boolean     use_max,
					show_images, // boolean     show,
					save_images, // boolean     save,
					save_dir, // String      save_dir,
					"_"+indices.length+"_MASK-"+pix_m, // String      suffix
					debugLevel); // int         debugLevel)			
		}

		if (show_frames) {
			int [] wh =     new int[2];
			int [] origin = new int[2];
			double [][] centers = show_centers? (new double [indices.length][]): null;
			double [][] dmulti = renderMultiDouble (
					null,              // double [][]   ground_planes, // null - images, non-null altitudes. use new double[2][3] for old way alt
					indices,           // int []        indices, // null or which indices to use (normally just 2 for pairwise comparison)
					bounds_to_indices, // boolean       bounds_to_indices,
					null,              // affines,    // double [][][] affines, // null or [indices.length][2][3]
					null,              // double [][]   equalize,
					true,              // boolean       ignore_equalize,
					null,              // warp,       // FineXYCorr    warp,,
					zoom_lev,          // int         zoom_level,
					wh,                // int []      wh,
					origin,            // int []      origin){ // maps[0] as a reference
					centers);          // double [][] centers)
			if (margins > 0) {
				addMargins(
						dmulti,   // double [][] dmulti,
						wh,       // int width,
						margins); // int margins)
			}
			double [][] dframes = new double [dmulti.length][];
			for (int n = 0; n < dmulti.length; n++) {
				dframes[n] = createBorderByNaN(
						dmulti[n],       // double [] data,
						wh[0],           // int width,
						frame_shrink,    // int     frame_shrink, 
						frame_grow,      // int     frame_grow,
						frame_blur,      // double  frame_blur,
						frame_cut_frac); // double  cut_frac)
				
//				for (int i = 0; i < dmulti[n].length; i++) {
//					dmulti[n][i] = Double.isNaN(dmulti[n][i])? 0:1;
//				}
			}
			showSaveMap(
					indices, // int []      indices,
					dframes,  // double [][] dmulti,
					wh[0],   // int         width,
					centers, // int    [][] centers,
					merge_layers, // boolean     merge_layers,
					true,   // boolean     use_max,
					show_images, // boolean     show,
					save_images, // boolean     save,
					save_dir, // String      save_dir,
					"_"+indices.length+"_FRAME-"+pix_m, // String      suffix
					debugLevel); // int         debugLevel)			
		}
		
		/*
		show_frames =        gd.getNextBoolean(); 
		frame_shrink = (int) gd.getNextNumber();
		frame_grow =   (int) gd.getNextNumber();
		frame_blur =         gd.getNextNumber();
 
		 */
		//showScenesStats
		//show_combo_mask
		return true;
	}
	public static void addMargins(
			double [][] dmulti,
			int [] wh,
			int margins){
		int width = wh[0];
		int height = dmulti[0].length/width;
		int widthm = width+2*margins;
		int heightm = height + 2* margins;
		int indx0m = (widthm + 1) * margins;
		for (int n = 0; n < dmulti.length; n++) {
			double [] d = new double[widthm*heightm];
			Arrays.fill(d, Double.NaN);
			for (int row = 0; row < height; row++) {
				System.arraycopy(
						dmulti[n],
						row*width,
						d,
						indx0m + widthm * row,
						width);
			}
			dmulti[n] = d;
		}
		wh[0] = widthm;
		wh[1] = heightm;
	}
	
	public static double [] createBorderByNaN(
			double [] data,
			int width,
			int     frame_shrink, 
			int     frame_grow,
			double  frame_blur,
			double  cut_frac) {
		double [] dframe =new double [data.length];
		int height = data.length/width;
		final TileNeibs tnSurface = new TileNeibs(width, height);
        boolean [] mask_in = new boolean[data.length];
        for (int i = 0; i < data.length; i++) {
        	mask_in[i] = !Double.isNaN(data[i]);
        }
		boolean [] mask_out = mask_in.clone();
		tnSurface.shrinkSelection(
				frame_shrink, // shrink,
				mask_in,      // tiles,
				null);        // prohibit);
		tnSurface.growSelection(
				frame_grow,   // grow,
				mask_out,     // tiles,
				null);        // prohibit);
		if (frame_blur > 0) {
			for (int i = 0; i < dframe.length; i++) {
				dframe[i] = (mask_out[i] && !mask_in[i]) ? 1.0 : 0.0;
			}
//			DoubleGaussianBlur gb = new DoubleGaussianBlur();
			(new DoubleGaussianBlur()).blurDouble(
					dframe,
					width,
					height,
					frame_blur,
					frame_blur,
					0.01);
			double max = 0.0;
			for (int i = 0; i < dframe.length; i++) {
				max = Math.max(max, dframe[i]);
			}
			double threshold = max*cut_frac;
			for (int i = 0; i < dframe.length; i++) {
				if (dframe[i] < threshold) {
					dframe[i] = Double.NaN;
				}
			}
		} else {
			for (int i = 0; i < dframe.length; i++) {
				dframe[i] = (mask_out[i] && !mask_in[i]) ? 1.0 : Double.NaN;
			}
		}

		
		return dframe;
		
	}
	
	public void showSaveMap(
			int []      indices,
			double [][] dmulti,
			int         width,
			double [][] centers,
			boolean     merge_layers,
			boolean     use_max,
			boolean     show,
			boolean     save,
			String      save_dir,
			String      suffix, // "_"+indices.length+"_MAP"
			int         debugLevel) {
		boolean     show_centers = centers != null;
		if (merge_layers) {
			dmulti = new double [][] {mergeLayers(dmulti,use_max)};
		}
		String [] titles = new String[dmulti.length];
		for (int i = 0; i < titles.length; i++) {
			titles[i] = String.format("%03d-%s", indices[i], ortho_maps[indices[i]].getName());
		}
		ImagePlus imp = ShowDoubleFloatArrays.makeArrays(
				dmulti,
				width,
				dmulti[0].length/width,
				ortho_maps[indices[0]].getName()+(merge_layers? "_MERGED":"")+suffix+".tiff",
				titles);
        if (show_centers) {
        	PointRoi roi = new PointRoi();
        	for (int i = 0; i < centers.length; i++) {
        		roi.addPoint(centers[i][0],centers[i][1], 1+(merge_layers?0:i));
        	}
        	roi.setOptions("label");
        	imp.setRoi(roi);
        }
		showSaveImagePlus(
				imp,        // ImagePlus imp,
				show, // boolean   show,
				save, // boolean   save,
				save_dir, // String    save_dir,
				debugLevel); // int       debugLevel)
		
	}
	
	
	public static double [] mergeLayers(
			double [][] layers,
			boolean use_max) { // false - use last
		if ((layers == null) || (layers.length == 0)){
			return null;
		}
		double [] merged = layers[0].clone();
		for (int n = 1; n < layers.length; n++) {
			if (use_max) {
				for (int i = 0; i < merged.length; i++) if (!Double.isNaN(layers[n][i])) {
					if (Double.isNaN(merged[i])) {
						merged[i] = layers[n][i];
					} else {
						merged[i] = Math.max(layers[n][i],merged[i]);
					}
				}

			} else {
				for (int i = 0; i < merged.length; i++) if (!Double.isNaN(layers[n][i])) {
					merged[i] = layers[n][i];
				}
			}
		}
		return merged;
	}
	
	/*
	public boolean showScenesStats() {
		String time_zone_name = "Europe/Kyiv";
		int [] indices = getScenesSelection(
				
				null, // boolean select_all,
				" to generate stats"); // String purpose)
		if (indices == null) {
			return false;
		}
		String [] stats = getScenesStats(indices, time_zone_name); // int [] indices)
		new TextWindow("Ortho_images_stats", stats[0], stats[1], 1250,1000);
		return true;
	}
	*/
	
	public String[] getScenesStats(int [] indices, String time_zone_name) {
		if (indices == null) {
			indices = new int [ortho_maps.length];
			for (int i = 0; i < indices.length; i++) {
				indices[i] = i;
			}
		}
		boolean y_down_ccw = true;
		String [] stats = new String[2]; // header, body
		StringBuffer sb = new StringBuffer();
//		String head_fmt = "%3s\t%17s\t%26s\t%13s\t%13s\t%7s\t%6s\t%7s\t%6s\t%6s\t%6s\t%6s\n";
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy hh:mm:ss.SS zzz");// may be VV instead of zzz
		//
		stats [0] = String.format(
				"%3s\t%17s\t%26s\t%11s\t%11s\t%7s\t"+
						"%6s\t%7s\t%6s\t%6s\t%6s\t%6s\t"+
						"%6s\t%6s\t"+
						"%7s\t%7s\t%7s\t%7s\t%7s\t%7s\t"+
						"%7s\t%7s\t%7s\t%7s",
						"#", "timestamp", "date/time", "latitude", "longitude", "GND-ASL",
						"AGL","pix(cm)", "width", "height","vert_x","vert_y",
						"scenes", "sfm",
						"scale","tilt","beta","rot","offs-X","offs-Y",
						"a00","a01","a10","a11");
		for (int indx:indices) {
			OrthoMap map = ortho_maps[indx];
			LocalDateTime ldt = map.getLocalDateTime();
			ZonedDateTime zonedUTC = ldt.atZone(ZoneId.of("UTC")); // that time is UTC
			ZonedDateTime zonedDateTime = zonedUTC.withZoneSameInstant(ZoneId.of(time_zone_name));
			String sdt = zonedDateTime.format(formatter);
			String name = map.getName();
			double [] lla = map.getLLA();
			double agl = map.getAGL();
			double pix_size_cm =  100*map.getOrigPixMeters();
			int width = map.getWidth();
			int height = map.getHeight();
			int [] vert_pix = map.getVertPixels();
			double sfm_gain = map.getSfmGain();
			int scenes = map.getNumberScenes();
			double [][] affine = map.getAffine();
			SingularValueDecomposition svd_st =SingularValueDecomposition.singularValueDecomposeScaleTiltGamma(
					affine,
					y_down_ccw); // boolean y_down_ccw)
//			double [] svd_st = OrthoMap.singularValueDecomposeScaleTilt(
//					affine,
//					y_down_ccw); // boolean y_down_ccw)
			// svd_st[0] - now gamma - short axis relative to map 
			sb.append(String.format(
					"%3d\t%17s\t%26s\t%11.6f\t%11.6f\t%7.2f\t"+
							"%6.2f\t%7.4f\t%6d\t%6d\t%6d\t%6d\t"+
							"%6d\t%6.2f"+
							"\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.3f\t%7.3f"+
							"\t%7.4f\t%7.4f\t%7.4f\t%7.4f\n",
							indx, name, sdt, lla[0], lla[1], lla[2] - agl,//  ground level
							agl, pix_size_cm, width, height, vert_pix[0], vert_pix[1],
							scenes, sfm_gain,
							svd_st.scale,svd_st.ratio,svd_st.beta,svd_st.rot, affine[0][2], affine[1][2],
							affine[0][0], affine[0][1], affine[1][0], affine[1][1]));
		}
		stats[1] = sb.toString();
		return stats;
	}
	public static void showSaveImagePlus(
			ImagePlus imp,
			boolean   show,
			boolean   save,
			String    save_dir,
			int       debugLevel) {
		if (save && (save_dir != null)) {
			if (!save_dir.endsWith(Prefs.getFileSeparator())) {
				save_dir += Prefs.getFileSeparator();
			}
			String save_path = save_dir+imp.getTitle();
			if (!save_path.endsWith(".tiff")) {
				save_path+=".tiff";
			}
			FileSaver imp_fs = new FileSaver(imp);
			imp_fs.saveAsTiff(save_path);
			if (debugLevel > -4) {
				System.out.println("Saved "+save_path);	
			}
		}
		if (show) {
			imp.show();
		}
	}
	
	public static double [] getFracOverlaps(
			final double [][] dmulti) {
		final double [] overlaps = new double [dmulti.length*dmulti.length];

		final Thread[] threads = ImageDtt.newThreadArray();
		final AtomicInteger ai = new AtomicInteger(0);
		for (int ithread = 0; ithread < threads.length; ithread++) {
			threads[ithread] = new Thread() {
				public void run() {
					for (int nscene = ai.getAndIncrement(); nscene < (dmulti.length-1); nscene = ai.getAndIncrement()) {
						double [] data0 = dmulti[nscene];
						int num0 = 0;
						for (int i = 0; i < data0.length; i++) if (!Double.isNaN(data0[i])) {
							num0++;
						}

						for (int nscene1 = nscene+1; nscene1 < dmulti.length; nscene1++) {
							double [] data1 = dmulti[nscene1];
							int num1 = 0, num_intersect=0; 
							for (int i = 0; i < data0.length; i++) if (!Double.isNaN(data1[i])) {
								num1++;
								if (!Double.isNaN(data0[i])) {
									num_intersect++;
								}
							}
							overlaps[nscene * dmulti.length  + nscene1] = (1.0 * num_intersect)/ Math.min(num0, num1);
						}
					}
				}
			};
		}		      
		ImageDtt.startAndJoin(threads);
		return overlaps;
	}
	
	public int [][] filterPairs(
			int []   indices_in,
			double   min_overlap_frac,
			double   max_rmse,
			boolean  max_resolution, // require defined and full resolution
			int [][] remove_pairs) { 
		if (indices_in == null) {
			indices_in = new int [ortho_maps.length];
			for (int i = 0; i < indices_in.length; i++) {
				indices_in[i] = i;
			}
		}
		boolean [] used_scenes = new boolean [ortho_maps.length];
		for (int i:indices_in) {
			used_scenes[i] = true;
		}
		HashSet <Point> donotuse_set = new HashSet<Point>();
		if (remove_pairs != null) {
			for (int [] p: remove_pairs) {
				donotuse_set.add(new Point(p[0],p[1]));
			}
		}
		ArrayList<Point> pairs_list = new ArrayList<Point>();
		for (int scene0:indices_in) {
			Set<String> match_names = ortho_maps[scene0].pairwise_matches.keySet();
			ArrayList<String> names_list = new ArrayList<String>();
			names_list.addAll(match_names);
			Collections.sort(names_list);
			for (String scene1_name:names_list) {
				PairwiseOrthoMatch match = ortho_maps[scene0].getMatch(scene1_name, !max_resolution); // may be not defined only
				if (match != null) {
					int scene1 = getIndex(scene1_name);
					if ( used_scenes[scene1] && (!max_resolution || match.isDefined()) &&
							(match.getOverlap() >= min_overlap_frac) &&
							((max_rmse <= 0) || (match.getRMS() <= max_rmse))
							){
						if (max_resolution) {
							int min_zoom = Math.min(ortho_maps[scene0].getOriginalZoomLevel(), ortho_maps[scene1].getOriginalZoomLevel());
							if (match.getZoomLevel() < min_zoom) {
								continue;
							}
						}
						Point p = new Point(scene0, scene1);
						if (remove_pairs != null) {
							if (donotuse_set.contains(p)) {
								continue;
							}
						}
						System.out.println(String.format("%5d: %3d-%3d, %7.4f, %7.4f",
								pairs_list.size(), scene0, scene1, match.getOverlap(), match.getRMS()));
						pairs_list.add(p);
					}
				}
			}
		}
		int [][] pairs = new int [pairs_list.size()][2];
		for (int i = 0; i < pairs.length; i++) {
			Point p = pairs_list.get(i);
			pairs[i][0] = p.x;
			pairs[i][1] = p.y;
		}
		return pairs;
	}
	
	public int [] getScenesFromPairs(
			int [][] pairs,
			int [] indices_in) { // preselected indices or null
		boolean [] used_scenes = new boolean [ortho_maps.length];
		if (indices_in != null) {
			for (int i:indices_in) {
				used_scenes[i] = true;
			}
		}
		for (int [] p:pairs) {
			used_scenes[p[0]] = true;
			used_scenes[p[1]] = true;
		}
		int indx = 0;
		for (int i = 0; i < used_scenes.length; i++) if (used_scenes[i]){
			indx++;	
		}
		int [] indices = new int [indx];
		indx = 0;
		for (int i = 0; i < used_scenes.length; i++) if (used_scenes[i]){
			indices[indx++] = i;	
		}
		return indices;
	}
	/**
	 * Re-index pairs to exclude scenes not present in indices[] 
	 * @param pairs   - array of start,end absolute scene numbers
	 * @param indices - ascending array of used scenes (or null - all scenes)
	 * @return  re-indexed pairs, indices exclude scenes that are not in indices[]
	 */
	public int [][] condensePairs(
			int [][] pairs_all,
			int [] indices) {
		if (indices == null) {
			return pairs_all;
		}
		int [] reindex = new int [ortho_maps.length];
		int [][] pairs = new int [pairs_all.length][2];
		Arrays.fill(reindex, -1);
		for (int i = 0; i < indices.length; i++) {
			reindex[indices[i]] = i;
		}
		for (int i = 0; i < pairs.length; i++) {
			pairs[i][0] = reindex[pairs_all[i][0]];
			pairs[i][1] = reindex[pairs_all[i][1]];
		}
		return pairs;
	}

	/**
	 * Filter list of image pairs by overlap and RMSE
	 * @param list_in     array of image pairs indices
	 * @param undef_only  only keep undefined pairs (no affine transform), ignore RMSE parameters
	 * @param min_overlap minimal pair overlap
	 * @param max_overlap maximal pair overlap
	 * @param min_rms     minimal RMSE 
	 * @param max_rms     maximal RMSE 
	 * @param nan_rms     use only NaN RMSE pairs
	 * @param filt_zoom   filter by zoom
	 * @param min_zoom    minimal zoom (including)
	 * @param max_zoom    maximal zoom (including)
	 * @param min_sfm     minimal SfM gain of the minimum in the scene pair 
	 * @param max_sfm     maximal SfM gain of the minimum in the scene pair 
	 * @param filt_alt    filter by alt data availability (0 - no filter, 1 - with alt only, 2 - without ALT only)
	 * @return            filtered array of pair indices
	 */
	
	public int [][] filterPairs(
			int [][]         list_in,
			boolean          undef_only,
			double           min_overlap,
			double           max_overlap,
			double           min_rms,
			double           max_rms,
			boolean          nan_rms,
			boolean          filt_zoom,
			int              min_zoom,
			int              max_zoom,
			double           min_sfm,
			double           max_sfm,
			int              filt_alt){
		ArrayList<Point> plist = new ArrayList<Point>();
		int num_all = 0;
		int num_def = 0;
		for (int [] ipair: list_in) {
			Point pair = new Point(ipair[0],ipair[1]);

			PairwiseOrthoMatch pairwiseOrthoMatch = ortho_maps[pair.x].getMatch(
					ortho_maps[pair.y].getName(), undef_only || nan_rms);
			double sfm_gain = Math.min(ortho_maps[pair.x].getSfmGain(), ortho_maps[pair.y].getSfmGain());
			if (pairwiseOrthoMatch != null) {
				num_all++;
				boolean defined = pairwiseOrthoMatch.isDefined();
				if (defined) {
					num_def++;
				}
				if (filt_alt != 0) { // has alt data
					if (pairwiseOrthoMatch.alt_data != null) {
						if (filt_alt == 2) {
							continue; // skip if no-ALT only
						}
					} else { // does not have alt data
						if (filt_alt == 1) {
							continue; // skip if ALT only
						}
					}
				}

				if ((sfm_gain < min_sfm) || (sfm_gain > max_sfm)) {
					continue;
				}
				
				if (undef_only) {
					if (!defined) {
						plist.add(pair);
					}
				} else {
					if ((pairwiseOrthoMatch.overlap >= min_overlap) && (pairwiseOrthoMatch.overlap <= max_overlap)) {
						if (nan_rms) {
							if (Double.isNaN(pairwiseOrthoMatch.rms)) {
								plist.add(pair);
							}
						} else if ((pairwiseOrthoMatch.rms >= min_rms) && (pairwiseOrthoMatch.rms <= max_rms)) {
							if (!filt_zoom || 
									((pairwiseOrthoMatch.zoom_lev >= min_zoom) && (pairwiseOrthoMatch.zoom_lev <= max_zoom))) {
								plist.add(pair);
							}
						}
					}
				}
			} else {
//				System.out.println("pair=["+pair.x+","+pair.y+"] "+
//						ortho_maps[pair.x].getName()+"->"+ortho_maps[pair.y].getName());
			}
		}
		System.out.println("num_all = "+num_all+", num_def="+num_def+", remained="+plist.size());
		int [][] pairs = new int [plist.size()][2];
		for (int i = 0; i < pairs.length; i++) {
			pairs[i][0] = plist.get(i).x;
			pairs[i][1] = plist.get(i).y;
		}
		return pairs;
	}
	
	/**
	 * Create text representation of the image pairs for drop-down selection lists
	 * @param plist ArrayList<Point> as pairs of scenes indices
	 * @param show_names   show full scene names (timestamps)
	 * @param show_overlap show scene overlap in percents
	 * @param show_rms     show pairs RMSE
	 * @param show_zoom    show pairs zoom level
	 * @param show_alt     show altitude data
	 * @param extra_line   null or an extra string to be added as a last element
	 * @return Array of    strings to be shown in a drop-down list
	 */
	public String [] textPairs (
			int [][] plist,
			boolean          show_names,
			boolean          show_overlap,
			boolean          show_rms,
			boolean          show_zoom,
			boolean          show_alt,
			boolean          use_tab,
			String           extra_line) {
		return 	textPairs (
				plist, // int [][] plist,
				show_names, // boolean          show_names,
				show_overlap, // boolean          show_overlap,
				show_rms, // boolean          show_rms,
				show_zoom, // boolean          show_zoom,
				show_alt, // boolean          show_alt,
				use_tab, // boolean          use_tab,
				extra_line, // String           extra_line,
				false, // boolean          show_svd,
				false); // boolean          use_degrees);

	}	
	public String [] textPairs (
			int [][] plist,
			boolean          show_names,
			boolean          show_overlap,
			boolean          show_rms,
			boolean          show_zoom,
			boolean          show_alt,
			boolean          use_tab,
			String           extra_line,
			boolean          show_svd,
			boolean          use_degrees) {
		boolean show_sfm = show_alt;

		// TODO: show SfM of each scene
		String [] text_pairs = new String [plist.length+((extra_line !=null)? 1 : 0)];
		for (int i = 0; i < plist.length; i++) {
			int [] pair = plist[i];
			double [] sfm_gain = {ortho_maps[pair[0]].getSfmGain(), ortho_maps[pair[1]].getSfmGain()};
			PairwiseOrthoMatch pairwiseOrthoMatch = ortho_maps[pair[0]].getMatch(
	                ortho_maps[pair[1]].getName(), true); // include undefined
//			if (pairwiseOrthoMatch== null) {
//				System.out.println("pair=["+pair[0]+","+pair[1]+"] "+
//						ortho_maps[pair[0]].getName()+"->"+ortho_maps[pair[1]].getName());
//			}
			text_pairs[i] =  String.format(use_tab?"%3d\t%3d":"%3d -> %3d", pair[0], pair[1]);
			if (show_names)	text_pairs[i] +=  String.format(use_tab?"\t%17s\t%17s":" (%17s -> %17s)", ortho_maps[pair[0]].getName(),ortho_maps[pair[1]].getName());
			if (pairwiseOrthoMatch != null) {
				if (show_overlap) text_pairs[i] +=  String.format(use_tab?"\t%5.1f%%":" %5.1f%%", 100*pairwiseOrthoMatch.overlap);
				if (show_rms) text_pairs[i] +=  String.format(use_tab?"\t%5.3f":" %5.3f", pairwiseOrthoMatch.rms);
				if (show_zoom) text_pairs[i] +=  String.format(use_tab?"\t%4d":" Z%3d", pairwiseOrthoMatch.zoom_lev);
				if (show_alt){
					if (pairwiseOrthoMatch.alt_data != null) {
						text_pairs[i] +=  String.format(use_tab?"\t%7.4f\t%7.4f\t%7.3f":" A %7.4f %7.4f %7.3f",
								pairwiseOrthoMatch.alt_data[0],pairwiseOrthoMatch.alt_data[1],pairwiseOrthoMatch.alt_data[2]); //" ALT";
					} else if (use_tab) {
						text_pairs[i] +=  String.format("\t%7s\t%7s\t%7s","---","---","---");
					}
				}
				if (show_sfm) text_pairs[i] +=  String.format(use_tab?"\t%5.1f\t%5.1f":" S %5.1f %5.1f", sfm_gain[0],sfm_gain[1]);
				if (show_svd && use_tab && (pairwiseOrthoMatch.getAffine()!=null)) { // now only for tab
					SingularValueDecomposition svd = SingularValueDecomposition.singularValueDecompose(pairwiseOrthoMatch.getAffine());
					String ssvd = svd.toString(use_degrees, 1);
					text_pairs[i] +=  "\t"+ssvd;
				}
			}
		}
		if (extra_line !=null) {
			text_pairs[plist.length] = extra_line;
		}
		return text_pairs;
	}
	
	public static double [][] rotateAltCenter(
			final double [] quat_in,
			final double [] xyz_center,
			final double [] alt_in,
			final int       width,
			final double    pix_size_meters,
			final Rectangle owoi, // should not be null - will provide offset and new size
			final int       stride, // >=2, use 4?
			final double    rfz,   // 0.3 w= 1/(x^2+y^2+rfz^2)
			final boolean keep_window,
			final double  scale_tilt,
			final int debugLevel) {
		final double discard_frac = 0.1; // discard interpolation if it is extrapolation more than this 
		final int    len_in = alt_in.length;
		final int    height = len_in/width;
		final double r2fz = rfz*rfz; 
		final double x0=xyz_center[0], y0=xyz_center[1],z0=xyz_center[2]; // xyz_center[2] now in "pixels"
		final double scale = QuatUtils.norm(quat_in);
		System.out.println("scale = "+scale+", NOT USED - set to k=1.0");
		final double k = 1.0;
		final double [] quat = QuatUtils.normalize(quat_in);
		quat[2]*= -1; // y is down
		quat[3]*= -1; // rotation does not match tilts
		
		quat[1]*=scale_tilt;
		quat[2]*=scale_tilt;
		QuatUtils.normalizeInPlace(quat);
		
		final double [][] xyz1 = new double [alt_in.length][];
		final Thread[] threads = ImageDtt.newThreadArray();
		
		final double [][][] xy_mn_mx_thread= new double [threads.length][2][2];
		final double [] pos_neg_inf = {Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY};
		final double [][] xy_mn_mx= {pos_neg_inf.clone(),pos_neg_inf.clone()}; 
		for (int nthread=0; nthread <  threads.length; nthread++) {
			xy_mn_mx_thread[nthread] = new double [][] {pos_neg_inf.clone(),pos_neg_inf.clone()};
		}
//		Arrays.fill(xy_mn_mx_thread,xy_mn_mx);
		final AtomicInteger ai = new AtomicInteger(0);
		final AtomicInteger ati = new AtomicInteger(0);
        for (int ithread = 0; ithread < threads.length; ithread++) {
            threads[ithread] = new Thread() {
                public void run() {
                	int nthread = ati.getAndIncrement();
                	double [] xyz = new double[3];
                	double [] xyz_out = new double[3];
                    for (int ipix = ai.getAndIncrement(); ipix < alt_in.length; ipix = ai.getAndIncrement()) if (!Double.isNaN(alt_in[ipix])){
                    	xyz[0] = ipix % width - x0;
                    	xyz[1] = ipix/ width -  y0;
                    	xyz[2] = alt_in[ipix]/ pix_size_meters - z0 ; // meters -> pix
                    	QuatUtils.applyTo(
                    			k,     // final double    k, // scale
                    			quat,  // final double [] q,
                    			xyz,   // final double [] in,
                    			xyz_out); // final double [] out)
                    	xyz1[ipix]= new double[3];
                    	xyz1[ipix][0]=xyz_out[0]+x0;
                    	xyz1[ipix][1]=xyz_out[1]+y0;
                    	xyz1[ipix][2]=xyz_out[2]+z0;
                    	xy_mn_mx_thread[nthread][0][0] = Math.min(xy_mn_mx_thread[nthread][0][0], xyz1[ipix][0]);
                    	xy_mn_mx_thread[nthread][0][1] = Math.max(xy_mn_mx_thread[nthread][0][1], xyz1[ipix][0]);
                    	xy_mn_mx_thread[nthread][1][0] = Math.min(xy_mn_mx_thread[nthread][1][0], xyz1[ipix][1]);
                    	xy_mn_mx_thread[nthread][1][1] = Math.max(xy_mn_mx_thread[nthread][1][1], xyz1[ipix][1]);
                    }
                }
            };
        }		      
        ImageDtt.startAndJoin(threads);
		for (int i = 0; i < xy_mn_mx_thread.length; i++) {
			xy_mn_mx[0][0]=Math.min(xy_mn_mx[0][0], xy_mn_mx_thread[i][0][0]);
			xy_mn_mx[0][1]=Math.max(xy_mn_mx[0][1], xy_mn_mx_thread[i][0][1]);
			xy_mn_mx[1][0]=Math.min(xy_mn_mx[1][0], xy_mn_mx_thread[i][1][0]);
			xy_mn_mx[1][1]=Math.max(xy_mn_mx[1][1], xy_mn_mx_thread[i][1][1]);
		}
		int x_min = keep_window ? 0:      ((int) Math.floor(xy_mn_mx[0][0])-1); 
		int y_min = keep_window ? 0:      ((int) Math.floor(xy_mn_mx[1][0])-1); 
		int x_max = keep_window ? width:  ((int) Math.ceil(xy_mn_mx[0][1]) +1); 
		int y_max = keep_window ? height: ((int) Math.ceil(xy_mn_mx[1][1]) +1);
		//final Rectangle 
			owoi.x = x_min;
			owoi.y = y_min;
			owoi.width= x_max-x_min;
			owoi.height=y_max-y_min;
		final int olen = owoi.width*owoi.height;
		final double [][] alt_out = new double [olen][]; // from rectified to alt_in, each element - {x,y,z}
		
		final double [] xyz_center_out = {xyz_center[0]-x_min, xyz_center[1]-y_min}; // do outside by caller - new rotation center
		// shift x,y in xyz1 to match new window
		ai.set(0);
        for (int ithread = 0; ithread < threads.length; ithread++) {
            threads[ithread] = new Thread() {
                public void run() {
                    for (int ipix = ai.getAndIncrement(); ipix < alt_in.length; ipix = ai.getAndIncrement()) if (xyz1[ipix] != null){
                    	xyz1[ipix][0] -= owoi.x;
                    	xyz1[ipix][1] -= owoi.y;
                    }
                }
            };
        }		      
        ImageDtt.startAndJoin(threads);

		final double [] weights = new double [owoi.width*owoi.height]; // when mixing same result from multiple sources
		final int stride_w = (width -1) / stride + 1;
		final int stride_h = (height -1) / stride + 1;
		final int stride_l = stride_w * stride_h;
		
		final int [] neib_oindices = { 0,  1, owoi.width, owoi.width+1}; // output indices, Z-order 
		final int [] neib_in_indices = { 0,  1, width, width+1}; // input indices, Z-order 
		final int [][] neib2_indices = { // Z-shape
				{-width-1, -width,        -1,       0}, // top-left (each also in Z-order)
				{-width,   -width+1,       0,       1}, // top-right (each also in Z-order)
				{      -1,        0, width-1, width  }, // bottom-left (each also in Z-order)
				{       0,        1, width,   width+1}  // bottom-right (each also in Z-order)
		};
		for (int offs_y = 0; offs_y < stride; offs_y++) {
			for (int offs_x = 0; offs_x < stride; offs_x++) {
				final int foffs_y = offs_y, foffs_x=offs_x;
				ai.set(0);
		        for (int ithread = 0; ithread < threads.length; ithread++) {
		            threads[ithread] = new Thread() {
		                public void run() {
		                	double [] vh = new double[2], vv=new double[2], v=new double[2], o=new double[2];
		                	double [] xyz = new double[3];
            				double [][] oxyz4 =  new double[4][];
            				double [][] ixyz4 =  new double[4][3];
		                    for (int ipix = ai.getAndIncrement(); ipix < stride_l; ipix = ai.getAndIncrement()) {
		                    	int pix_y = (ipix/stride_w)*stride + foffs_y; 
		                    	int pix_x = (ipix%stride_w)*stride + foffs_x;
		                    	if ((pix_x < width) && (pix_y < height)) {
		                    		int pix = pix_y * width + pix_x;
		                    		double [] xyz1p = xyz1[pix];
//		                    		int x1 = (int) xyz1p[0];
//		                    		int y1 = (int) xyz1p[1];
		                    		
		                    		if (xyz1p != null) {
			                    		int x1 = (int) Math.floor(xyz1p[0]);
			                    		int y1 = (int) Math.floor(xyz1p[1]);
			                    		int x2 = (int) Math.ceil(xyz1p[0]);
			                    		int y2 = (int) Math.ceil(xyz1p[1]);
		                    			// accumulate 4 corners around the fractional
		                    			int [][] xy_dir= {{x1,y1},{x2,y1},{x1,y2},{x2,y2}};
		                    			for (int dir = 0; dir < 4; dir++) {
		                    				int [] indices_in =  neib2_indices[dir];  // input indices (presumably) around output
		                    				// make sure all defined and surround an output node
		                    				boolean defined4 = true;
//		                    				double [][] oxyz4 =  new double[4][];
//		                    				double [][] ixyz4 =  new double[4][];
		                    				for (int i = 0; i < 4; i++) {
		                    					int indx= pix+indices_in[i];
		                    					if ((indx < 0) || (indx >= len_in) || (xyz1[indx] == null)) {
		                    						defined4 = false;
		                    						break;
		                    					}
		                    					oxyz4[i] = xyz1[indx];
		                    					ixyz4[i][0]= indx%width;
		                    					ixyz4[i][1]= indx/width;
		                    					ixyz4[i][2]= xyz1[indx][2]; // Z same as in in oxyz4
		                    				}
		                    				if (!defined4) {
		                    					continue;
		                    				}
		                    				int oindx = neib_oindices[dir]+ (y1*owoi.width + x1);
		                    				if ((oindx < 0) || (oindx >= olen)) {
		                    					continue;
		                    				}
		                    				o[0] = oindx % owoi.width; // output integer coordinates that should be inside oxyz4
		                    				o[1] = oindx / owoi.width;
		                    				// average horizontal and vertical vectors
		                    				for (int i = 0; i < 2; i++) {
		                    					vh[i] = (oxyz4[1][i]-oxyz4[0][i]+oxyz4[3][i]-oxyz4[2][i])/2;
		                    					vv[i] = (oxyz4[2][i]-oxyz4[0][i]+oxyz4[3][i]-oxyz4[1][i])/2;
		                    					v[i]= o[i] - oxyz4[0][i]; 
		                    				}
		                    				// find ax, ay for bilinear interpolation
		                    				double lvh = Math.sqrt(vh[0]*vh[0]+vh[1]*vh[1]);
		                    				double lvv = Math.sqrt(vv[0]*vv[0]+vv[1]*vv[1]);
		                    				double lv =  Math.sqrt( v[0]* v[0]+ v[1]* v[1]);
		                    				double ax = (v[0]*vh[0]+v[1]*vh[1])/lv/lvh;
		                    				double ay = (v[0]*vv[0]+v[1]*vv[1])/lv/lvv;
		                    				// discard interpolation if it is extrapolation by more than discard_frac
		                    				if ((ax < -discard_frac) || (ay < -discard_frac) || (ax > 1 + discard_frac) || (ax > 1 + discard_frac)) {
		                    					continue;
		                    				}
		                    				//xyz = new double[3];
		                    				for (int i = 0; i <3; i++) {
		                    					xyz[i] = (1-ax)*(1-ay)*ixyz4[0][i]+
		                    							 (  ax)*(1-ay)*ixyz4[1][i]+
		                    							 (1-ax)*(  ay)*ixyz4[2][i]+
		                    							 (  ax)*(  ay)*ixyz4[3][i];
		                    				}
		                    				xyz[2] *=  pix_size_meters; // pix-> meters
		                    				
		                    				double dax = (ax > 0.5) ? (1-ax) : ax;
		                    				double day = (ay > 0.5) ? (1-ay) : ay;
		                    				double w =r2fz / (dax*dax+day*day+r2fz);

		                    				//weights[]
		                    				if (alt_out[oindx] == null) {
		                    					alt_out[oindx] = xyz.clone();
		                    					weights[oindx] = w;
		                    				} else {
		                    					double w_new = (weights[oindx]+ w);
		                    					double w0 = weights[oindx]/w_new;
		                    					double w1 = w /w_new;
		                    					for (int i = 0; i < xyz.length; i++) {
		                    						alt_out[oindx][i] = w0 * alt_out[oindx][i] + w1 * xyz[i];
		                    					}
		                    					weights[oindx] = w_new;
		                    				}
		                    			}
		                    		}
		                    	}
		                    }
		                }
		            };
		        }		      
		        ImageDtt.startAndJoin(threads);
			}
		}
		return  alt_out;
	}
	
	public static double [] applySceneRotation(
			final double []   texture_in,
			final int         width_in,
			final double [][] rotation_map,
//			final int         width_out,
			final int debugLevel) {
		final int    height_in = texture_in.length/width_in;
		final double [] texture_out = new double[rotation_map.length];
		Arrays.fill(texture_out, Double.NaN);
		final Thread[] threads = ImageDtt.newThreadArray();
		final AtomicInteger ai = new AtomicInteger(0);
        for (int ithread = 0; ithread < threads.length; ithread++) {
            threads[ithread] = new Thread() {
                public void run() {
                    for (int opix = ai.getAndIncrement(); opix < rotation_map.length; opix = ai.getAndIncrement()) if (rotation_map[opix] != null){
//                    	int x = opix % width_out;
//                   	int y = opix / width_out;
                    	double [] xyz = rotation_map[opix];
                    	int ipx0 = (int) Math.floor(xyz[0]);
                    	int ipy0 = (int) Math.floor(xyz[1]);
                    	if ((ipx0 >= width_in) || (ipy0 >= height_in)) {
                    		continue;
                    	}
                    	int ipx1 = ipx0 + 1;
                    	if (ipx1 >= width_in) ipx1 = width_in-1; 
                    	int ipy1 = ipy0 + 1;
                    	if (ipy1 >= height_in) ipy1 = height_in-1;
                    	if ((ipx1 < 0) || (ipy1 < 0)) {
                    		continue;
                    	}
                    	if (ipx0 < 0) ipx0 = ipx1;
                    	if (ipy0 < 0) ipy0 = ipy1;
                    	
                    	
                    	double fx = xyz[0] - ipx0;
                    	double fy = xyz[1] - ipy0;
                    	texture_out[opix] =
                    			(1-fx) * (1-fy) * texture_in[ipy0 * width_in + ipx0] +
                    			(  fx) * (1-fy) * texture_in[ipy0 * width_in + ipx1] +
                    			(1-fx) * (  fy) * texture_in[ipy1 * width_in + ipx0] +
                    			(  fx) * (  fy) * texture_in[ipy1 * width_in + ipx1];
                    }
                }
            };
        }		      
        ImageDtt.startAndJoin(threads);
		return texture_out;
	}

	public static double [] getRotatedAlt(
			final double [][] rotation_map) {
		final double [] alt_out = new double[rotation_map.length];
		Arrays.fill(alt_out, Double.NaN);
		final Thread[] threads = ImageDtt.newThreadArray();
		final AtomicInteger ai = new AtomicInteger(0);
        for (int ithread = 0; ithread < threads.length; ithread++) {
            threads[ithread] = new Thread() {
                public void run() {
                    for (int opix = ai.getAndIncrement(); opix < rotation_map.length; opix = ai.getAndIncrement()) if (rotation_map[opix] != null){
                    	alt_out[opix] = rotation_map[opix][2];
                    }
                }
            };
        }		      
        ImageDtt.startAndJoin(threads);
		return alt_out;
		
	}
	
	public static double [] debugPadInToOut(
			final double []   texture_in,
			final int         width_in,
			final Rectangle   woi) {
		final int height_in = texture_in.length/width_in;
		final double [] texture_out = new double[woi.width*woi.height];
		Arrays.fill(texture_out, Double.NaN);
		final Thread[] threads = ImageDtt.newThreadArray();
		final AtomicInteger ai = new AtomicInteger(0);
        for (int ithread = 0; ithread < threads.length; ithread++) {
            threads[ithread] = new Thread() {
                public void run() {
                    for (int opix = ai.getAndIncrement(); opix < texture_out.length; opix = ai.getAndIncrement()) {
                    	int x_out = opix % woi.width;
                    	int y_out = opix / woi.width;
                    	int x_in = x_out+woi.x;
                    	int y_in = y_out+woi.y;
                    	if ((x_in >=0) && (y_in >= 0) && (x_in < width_in) && (y_in < height_in)) {
                    		texture_out[opix] = texture_in[y_in * width_in + x_in];	
                    	}
                    }
                }
            };
        }		      
        ImageDtt.startAndJoin(threads);
        return texture_out;
		
	}
	

}
