Skip to content

I
imagej-elphel
Commit d1ddd6b3 authored by Andrey Filippov's avatar Andrey Filippov
Browse files
Options

fixed LMA for offsets of the multi-tile clusters

parent fb44bc1a
Hide whitespace changes
Inline Side-by-side
Showing with 549 additions and 285 deletions
src/main/java/com/elphel/imagej/tileprocessor/Corr2dLMA.java
View file @ d1ddd6b3
......@@ -71,66 +71,59 @@ import Jama.Matrix;
public class Corr2dLMA {
final static int NUM_CAMS = 4; // not all have to be used, so it is maximal number of cameras
final static int NUM_PAIRS = NUM_CAMS* (NUM_CAMS -1)/2; // number of possible pairs
final static int DISP_INDEX = 0; // common/average disparity
final static int A_INDEX = 1; // A*(x-x0)^2
final static int B_INDEX = 2; // 2*B*(x-x0)*(y-y0)
final static int CMA_INDEX = 3; // C*(y-y0)^2, encode C-A
final static int G0_INDEX = 4; // scale of correlation pair,
final static int TILE_PARAMS = G0_INDEX + NUM_PAIRS; // number of tile-individual parameters
// final static int DDISP_INDEX = G0_INDEX + NUM_PAIRS; // disparity offset per camera (at least 1 should be disabled)
// final static int NDISP_INDEX = DDISP_INDEX + NUM_CAMS; // disparity offset per camera - none should be disable
// final static int NUM_ALL_PARS = NDISP_INDEX+ NUM_CAMS; // maximal number of parameters
private int DDISP_INDEX; // = G0_INDEX + NUM_PAIRS; // disparity offset per camera (at least 1 should be disabled)
private int NDISP_INDEX; // = DDISP_INDEX + NUM_CAMS; // disparity offset per camera - none should be disable
private int NUM_ALL_PARS; // = NDISP_INDEX+ NUM_CAMS; // maximal number of parameters
final int [] USED_CAMS_MAP = new int[NUM_CAMS]; // for each camera index return used index ???
// final int [][] USED_PAIRS_MAP = new int[NUM_CAMS][NUM_CAMS]; // for each camera index return used index ??
private int [][][] USED_PAIRS_MAP; // for each camera index return used index ??
final static String [] PAR_NAMES = {"DISP","A","B","C-A"};
final static String PAR_NAME_SCALE = "SCALE";
final static String PAR_NAME_CORRDISP = "CORR-DISP";
final static String PAR_NAME_CORRNDISP = "CORR-NDISP";
double [] all_pars;
boolean [] par_mask;
int [] par_map;
double [] vector;
double [] scales = {1.0, 2.0, 4.0};
ArrayList<Sample> samples = new ArrayList<Sample>();
//// double [] pair_weights = null; // per pair weights (sum == 1.0) Not really needed?
double [] weights; // normalized so sum is 1.0 for all - samples and extra regularization terms
double pure_weight; // weight of samples only
double [] values;
final static int NUM_CAMS = 4; // not all have to be used, so it is maximal number of cameras
final static int NUM_PAIRS = NUM_CAMS* (NUM_CAMS -1)/2; // number of possible pairs
final static int DISP_INDEX = 0; // common/average disparity
final static int A_INDEX = 1; // A*(x-x0)^2
final static int B_INDEX = 2; // 2*B*(x-x0)*(y-y0)
final static int CMA_INDEX = 3; // C*(y-y0)^2, encode C-A
final static int G0_INDEX = 4; // scale of correlation pair,
final static int TILE_PARAMS = G0_INDEX + NUM_PAIRS; // number of tile-individual parameters
final static String [] PAR_NAMES = {"DISP","A","B","C-A"};
final static String PAR_NAME_SCALE = "SCALE";
final static String PAR_NAME_CORRDISP = "CORR-DISP";
final static String PAR_NAME_CORRNDISP = "CORR-NDISP";
double [] all_pars;
private boolean [] par_mask;
private int [] par_map;
private double [] vector;
private ArrayList<Sample> samples = new ArrayList<Sample>();
private double [] weights; // normalized so sum is 1.0 for all - samples and extra regularization terms
private double pure_weight; // weight of samples only
private double [] values;
// next values are only updated after success
double [] last_rms = null; // {rms, rms_pure}, matching this.vector
double [] good_or_bad_rms = null; // just for diagnostics, to read last (failed) rms
double [] initial_rms = null; // {rms, rms_pure}, first-calcualted rms
double [] last_ymfx = null;
double [][] last_jt = null;
double [] poly_coeff = null; // 6 elements - Xc, Yx, f(x,y), A, B, C (from A*x^2 + B*y^2 +C*x*y+...)
double [] poly_xyvwh = null; // result of 2-d polynomial approximation instead of the LMA - used for lazy eye correction
private final int transform_size;
private double [] last_rms = null; // {rms, rms_pure}, matching this.vector
private double [] good_or_bad_rms = null; // just for diagnostics, to read last (failed) rms
private double [] initial_rms = null; // {rms, rms_pure}, first-calcualted rms
private double [] last_ymfx = null;
private double [][] last_jt = null;
private int ddisp_index; // = G0_INDEX + NUM_PAIRS; // disparity offset per camera (at least 1 should be disabled)
private int ndisp_index; // = ddisp_index + NUM_CAMS; // disparity offset per camera - none should be disable
private int num_all_pars; // = ndisp_index+ NUM_CAMS; // maximal number of parameters
private int [] used_cams_map = new int[NUM_CAMS]; // for each camera index return used index ???
private int [] used_cams_rmap; // variable-length list of used cameras numbers
private int [][][] used_pairs_map; // for each camera index return used index ??
private final int transform_size;
private final double [][] corr_wnd;
private boolean [] used_cameras;
// private final Matrix [] m_disp = new Matrix[NUM_CAMS];
private Matrix [][] m_disp;
private int ncam; // number of used cameras
private int [] npairs; // number of used pairs per tile
private int last_cam; // index of the last camera (special treatment for disparity correction)
// private boolean second_last; // there is a pair where the second camera is the last one (false: first in a pair is the last one)
// private final Matrix [][] m_pairs = new Matrix[NUM_CAMS][NUM_CAMS];
private Matrix [][][] m_pairs;
// private final Matrix [][] m_pairs_last = new Matrix[NUM_CAMS][NUM_CAMS];
private final int [][] pindx = new int [NUM_CAMS][NUM_CAMS];
private int numTiles = 1;
public boolean gaussian_mode = true;
private boolean [] used_cameras;
private Matrix [][] m_disp;
private int ncam; // number of used cameras
private int [] npairs; // number of used pairs per tile
private int last_cam; // index of the last camera (special treatment for disparity correction)
private int pre_last_cam; // index of the pre-last camera (special treatment for disparity correction)
private Matrix [][][] m_pairs;
private final int [][] pindx = new int [NUM_CAMS][NUM_CAMS];
private int numTiles = 1;
private Matrix mddnd; // Matrix to calculate 2 last corrections in disparity direction and 1 ortho from the first ones (normally 2+3=5)
private boolean gaussian_mode = true;
private boolean lazy_eye; // calculate parameters/derivatives for the "lazy eye" parameters
private double [][] rXY;
private int [] dd_indices; //normally 5-long (2 * ncam -3), absolute parameter indices for dd_pre_last, dd_last and nd_last
public class Sample{ // USED in lwir
int tile; // tile in a cluster
......@@ -161,11 +154,13 @@ public class Corr2dLMA {
public Corr2dLMA (
int numTiles,
int ts, // null - use default table
int numTiles,
int ts, // null - use default table
double [][] corr_wnd, // may be null
boolean gaussian_mode
double [][] rXY, // non-distorted X,Y offset per nominal pixel of disparity
boolean gaussian_mode
) {
this.rXY = rXY;
this.gaussian_mode = gaussian_mode;
for (int f = 0; f < NUM_CAMS; f++) {
pindx[f][f]=-1;
......@@ -175,9 +170,9 @@ public class Corr2dLMA {
}
}
this.numTiles = numTiles;
DDISP_INDEX = this.numTiles * TILE_PARAMS;
NDISP_INDEX = DDISP_INDEX + NUM_CAMS; // disparity offset per camera - none should be disable
NUM_ALL_PARS = NDISP_INDEX+ NUM_CAMS; // maximal number of parameters
ddisp_index = this.numTiles * TILE_PARAMS;
ndisp_index = ddisp_index + NUM_CAMS; // disparity offset per camera - none should be disable
num_all_pars = ndisp_index+ NUM_CAMS; // maximal number of parameters
boolean sq = false;
this.transform_size = ts;
......@@ -212,11 +207,44 @@ public class Corr2dLMA {
}
}
}
public static double [][] getCorrWnd(int transform_size){
return getCorrWnd(transform_size, false);
}
public double[][] getCorrWnd() {
return this.corr_wnd;
public static double [][] getCorrWnd(int transform_size, boolean sq){ // sq = false
double [][] corr_wnd = new double[2 * transform_size - 1][2 * transform_size - 1];
int tsm1 = transform_size - 1; // 7
int dtsm1 = 2 * transform_size - 1; // 15
corr_wnd[tsm1][tsm1] = 1.0;
for (int i = 1; i < transform_size; i++) {
corr_wnd[tsm1 + i][tsm1 ] = Math.cos(Math.PI*i/(2 * transform_size));
corr_wnd[tsm1 - i][tsm1 ] = Math.cos(Math.PI*i/(2 * transform_size));
corr_wnd[tsm1 ][tsm1 + i] = Math.cos(Math.PI*i/(2 * transform_size));
corr_wnd[tsm1 ][tsm1 - i] = Math.cos(Math.PI*i/(2 * transform_size));
}
for (int i = 1; i < transform_size; i++) {
for (int j = 1; j < transform_size; j++) {
double d = corr_wnd[tsm1 + i][tsm1] * corr_wnd[tsm1 + j][tsm1];
corr_wnd[tsm1 + i][tsm1 + j] = d;
corr_wnd[tsm1 + i][tsm1 - j] = d;
corr_wnd[tsm1 - i][tsm1 + j] = d;
corr_wnd[tsm1 - i][tsm1 - j] = d;
}
}
if (sq) {
for (int i = 0; i < dtsm1; i++) {
for (int j = 0; j < dtsm1; j++) {
corr_wnd[i][j] *= corr_wnd[i][j];
}
}
}
return corr_wnd;
}
// public double[][] getCorrWnd() {
// return this.corr_wnd;
// }
public void addSample( // x = 0, y=0 - center
int tile,
int fcam, // first camera index
......@@ -255,7 +283,7 @@ public class Corr2dLMA {
if (mode == 0) d = s.v;
else if (mode == 1) d = s.w;
else if (mode == 2) d = fx[ns];
// int np = USED_PAIRS_MAP[0][s.fcam][s.scam]; ////////////////////
// int np = used_pairs_map[0][s.fcam][s.scam]; ////////////////////
int np = comb_map[s.fcam][s.scam]; ////////////////////
rslt[s.tile][np][s.iy*size + s.ix] = d;
}
......@@ -266,8 +294,8 @@ public class Corr2dLMA {
public String [] dbgGetSliceTiles(int ntile) {
String [] srslt = new String [npairs[ntile]];
for (int f = 0; f < NUM_CAMS; f++) for (int s = 0; s < NUM_CAMS; s++) {
if (USED_PAIRS_MAP[ntile][f][s] >= 0) {
srslt[USED_PAIRS_MAP[ntile][f][s]] = ""+f+"->"+s;
if (used_pairs_map[ntile][f][s] >= 0) {
srslt[used_pairs_map[ntile][f][s]] = ""+f+"->"+s;
}
}
return srslt;
......@@ -292,7 +320,7 @@ public class Corr2dLMA {
for (int t = 0; t < numTiles; t++) {
for (int f = 0; f < NUM_CAMS; f++) for (int s = 0; s < NUM_CAMS; s++) {
comb_pairs[f][s] |= USED_PAIRS_MAP[t][f][s] >= 0;
comb_pairs[f][s] |= used_pairs_map[t][f][s] >= 0;
}
}
int np = 0;
......@@ -339,26 +367,91 @@ public class Corr2dLMA {
}
}
/**
* Calculate matrices to find two last offsets in the disparity direction (ddl1, ddl) and one last offset in ortho to disparity,so
* 1: sum all dd is zero (not changing actual disparity that is individual to each tile in a cluster)
* 2: dd, nd offsets keep average x,y ot zero
*/
private void setOffsetMatrices() {
boolean invert_ortho = true;
Matrix A33;
Matrix A35;
if (invert_ortho) {
double [][] aA33 =
{ {rXY[pre_last_cam][0], rXY[last_cam][0], -rXY[last_cam][1]}, // sum(x) = d
{rXY[pre_last_cam][1], rXY[last_cam][1], rXY[last_cam][0]}, // sum(y) = 0
{1.0, 1.0, 0.0 }}; // sum(dd) = 0
A33 = new Matrix(aA33);
double [][] aA35 = new double [3][2 * ncam-3];
for (int i = 0; i < (ncam-2); i++) { // coefficients for dd[i]
int n = used_cams_rmap[i];
aA35[0][i] = -rXY[n][0];
aA35[1][i] = -rXY[n][1];
aA35[2][i] = -1.0;
}
for (int i = 0; i < (ncam-1); i++) { // coefficients for nd[i]
int n = used_cams_rmap[i];
int i1 = ncam - 2 + i;
aA35[0][i1] = rXY[n][1];
aA35[1][i1] = -rXY[n][0];
// aA35[2][i] = 0.0; // already 0.0
}
A35 = new Matrix(aA35);
} else {
double [][] aA33 =
{ {rXY[pre_last_cam][0], rXY[last_cam][0], rXY[last_cam][1]}, // sum(x) = d
{rXY[pre_last_cam][1], rXY[last_cam][1], -rXY[last_cam][0]}, // sum(y) = 0
{1.0, 1.0, 0.0 }}; // sum(dd) = 0
A33 = new Matrix(aA33);
double [][] aA35 = new double [3][2 * ncam-3];
for (int i = 0; i < (ncam-2); i++) { // coefficients for dd[i]
int n = used_cams_rmap[i];
aA35[0][i] = -rXY[n][0];
aA35[1][i] = -rXY[n][1];
aA35[2][i] = -1.0;
}
for (int i = 0; i < (ncam-1); i++) { // coefficients for nd[i]
int n = used_cams_rmap[i];
int i1 = ncam - 2 + i;
aA35[0][i1] = -rXY[n][1];
aA35[1][i1] = rXY[n][0];
// aA35[2][i] = 0.0; // already 0.0
}
A35 = new Matrix(aA35);
}
// Matrix A33_inv = A33.inverse();
mddnd = A33.inverse().times(A35);
// mddnd . times (({dd0},{dd1},{nd0},{nd1},{nd2}}) -> {{dd2},{dd3},{nd3}} if all 4 cameras are used
// mddnd itself provides derivatives
}
public void initVector( // USED in lwir
boolean adjust_width, // adjust width of the maximum - lma_adjust_wm
boolean adjust_scales, // adjust 2D correlation scales - lma_adjust_ag
boolean adjust_ellipse, // allow non-circular correlation maximums lma_adjust_wy
boolean adjust_lazyeye_par, // adjust disparity corrections parallel to disparities lma_adjust_wxy
boolean adjust_lazyeye_ortho, // adjust disparity corrections orthogonal to disparities lma_adjust_ly1
boolean adjust_lazyeye_ortho, // obsolete - make == adjust_lazyeye_par adjust disparity corrections orthogonal to disparities lma_adjust_ly1
double [][] disp_str, // initial value of disparity
// double disp0, // initial value of disparity
double half_width, // A=1/(half_widh)^2 lma_half_width
double cost_lazyeye_par, // cost for each of the non-zero disparity corrections lma_cost_wy
double cost_lazyeye_odtho // cost for each of the non-zero ortho disparity corrections lma_cost_wxy
) {
adjust_lazyeye_ortho = adjust_lazyeye_par; // simplify relations for the calculated/dependent parameters
lazy_eye = adjust_lazyeye_par | adjust_lazyeye_ortho;
// int [][] pindx = new int [NUM_CAMS][NUM_CAMS];
USED_PAIRS_MAP = new int [numTiles][NUM_CAMS][NUM_CAMS];
used_pairs_map = new int [numTiles][NUM_CAMS][NUM_CAMS];
used_cameras = new boolean[NUM_CAMS];
boolean [][] used_pairs = new boolean[numTiles][NUM_PAIRS];
// 0-weight values and NaN-s should be filtered on input!
last_cam = -1;
for (int t = 0; t < numTiles; t++) for (int f = 0; f < NUM_CAMS; f++) for (int s = 0; s < NUM_CAMS; s++) {
USED_PAIRS_MAP[t][f][s] = -1;
used_pairs_map[t][f][s] = -1;
}
boolean [][][] used_pairs_dir = new boolean [numTiles][NUM_CAMS][NUM_CAMS];
for (Sample s:samples) { // ignore zero-weight samples
......@@ -370,12 +463,22 @@ public class Corr2dLMA {
ncam = 0;
npairs =new int [numTiles];
for (int i = 0; i < NUM_CAMS; i++) {
USED_CAMS_MAP[i] = ncam;
used_cams_map[i] = ncam;
if (used_cameras[i]) {
last_cam = ncam;
ncam++;
}
}
used_cams_rmap = new int [ncam];
ncam = 0;
for (int i = 0; i < NUM_CAMS; i++) {
if (used_cameras[i]) {
used_cams_rmap[ncam++] = i;
}
}
last_cam = (ncam > 1)? used_cams_rmap[ncam - 1] :-1;
pre_last_cam = (ncam > 2)? used_cams_rmap[ncam - 2] :-1;
setOffsetMatrices();
for (int nTile = 0; nTile < numTiles; nTile++) {
int [] upmam = new int[NUM_PAIRS];
for (int i = 0; i < NUM_PAIRS; i++) {
......@@ -385,14 +488,14 @@ public class Corr2dLMA {
for (int f = 0; f < NUM_CAMS; f++) {
for (int s = f+1; s < NUM_CAMS; s++) {
int npair = upmam[pindx[f][s]];
if (used_pairs_dir[nTile][f][s]) USED_PAIRS_MAP[nTile][f][s] = npair; // either or, can not be f,s and s,f pairs
else if (used_pairs_dir[nTile][s][f]) USED_PAIRS_MAP[nTile][s][f] = npair;
if (used_pairs_dir[nTile][f][s]) used_pairs_map[nTile][f][s] = npair; // either or, can not be f,s and s,f pairs
else if (used_pairs_dir[nTile][s][f]) used_pairs_map[nTile][s][f] = npair;
}
}
}
this.all_pars = new double[NUM_ALL_PARS];
this.par_mask = new boolean[NUM_ALL_PARS];
this.all_pars = new double[num_all_pars];
this.par_mask = new boolean[num_all_pars];
// per-tile parameters
for (int nTile = 0; nTile < numTiles; nTile++) {
this.all_pars[DISP_INDEX + nTile*TILE_PARAMS] = disp_str[nTile][0]; // disp0;
......@@ -410,18 +513,18 @@ public class Corr2dLMA {
}
// common for all tiles parameters
for (int i = 0; i <NUM_CAMS; i++) {
this.all_pars[DDISP_INDEX + i] = 0.0; // C-A
this.par_mask[DDISP_INDEX + i] = used_cameras[i] & adjust_lazyeye_par & (i != last_cam);
this.all_pars[NDISP_INDEX + i] = 0.0; // C-A
this.par_mask[NDISP_INDEX + i] = used_cameras[i] & adjust_lazyeye_ortho;
this.all_pars[ddisp_index + i] = 0.0; // C-A
this.par_mask[ddisp_index + i] = used_cameras[i] & adjust_lazyeye_par & (i != last_cam) & (i != pre_last_cam);
this.all_pars[ndisp_index + i] = 0.0; // C-A
this.par_mask[ndisp_index + i] = used_cameras[i] & adjust_lazyeye_ortho & (i != last_cam);
}
int np = samples.size();
weights = new double [np + 2 * NUM_CAMS]; // npairs];
values = new double [np + 2 * NUM_CAMS]; // npairs];
for (int i = 0; i < NUM_CAMS; i++) {
weights[np + i] = (used_cameras[i] & adjust_lazyeye_par)? (cost_lazyeye_par * numTiles) : 0.0; // ddisp - including last_camera
weights[np + NUM_CAMS + i] = (used_cameras[i] & adjust_lazyeye_ortho)? (cost_lazyeye_odtho * numTiles) : 0.0; // ndisp
weights[np + i] = (used_cameras[i] & adjust_lazyeye_par)? (cost_lazyeye_par * numTiles) : 0.0; // ddisp - including last_cameras
weights[np + NUM_CAMS + i] = (used_cameras[i] & adjust_lazyeye_ortho)? (cost_lazyeye_odtho * numTiles) : 0.0; // ndisp - including last_camera
values [np + i] = 0.0;
values [np + NUM_CAMS + i] = 0.0;
}
......@@ -449,24 +552,24 @@ public class Corr2dLMA {
for (int i = 0; i < weights.length; i++) weights[i] *= kw;
pure_weight *= kw; // it is now fraction (0..1.0), and weights are normalized
}
/*****
double spw = 0;
for (int i = 0; i < NUM_PAIRS; i++) {
spw += pair_weights[i];
}
if (spw > 0) {
double rspw = 1.0/spw;
for (int i = 0; i < NUM_PAIRS; i++) {
pair_weights[i]*=rspw;
}
}
*/
par_map = new int [par_mask.length];
int par_indx = 0;
for (int i = 0; i < par_mask.length; i++) {
if (par_mask[i]) par_map[i] = par_indx++;
else par_map[i] = -1;
}
// private int [] dd_indices; //normally 5-long (2 * ncam -3), absolute parameter indices for dd_pre_last, dd_last and nd_last
dd_indices = lazy_eye? new int [2 * ncam -3] : null;
if (dd_indices != null) {
int pi = 0;
for (int i = 0; i < NUM_CAMS; i++) {
if (par_map[ddisp_index + i] >=0) dd_indices[pi++] = par_map[ddisp_index + i];
}
for (int i = 0; i < NUM_CAMS; i++) {
if (par_map[ndisp_index + i] >=0) dd_indices[pi++] = par_map[ndisp_index + i];
}
}
toVector();
}
......@@ -474,27 +577,14 @@ public class Corr2dLMA {
public void initMatrices() { // should be called after initVector and after setMatrices
m_pairs = new Matrix[USED_PAIRS_MAP.length][NUM_CAMS][NUM_CAMS];
for (int nTile = 0; nTile < USED_PAIRS_MAP.length; nTile++) {
m_pairs = new Matrix[used_pairs_map.length][NUM_CAMS][NUM_CAMS];
for (int nTile = 0; nTile < used_pairs_map.length; nTile++) {
for (int f = 0; f < NUM_CAMS; f++) for (int s = 0; s < NUM_CAMS; s++) {
m_pairs[nTile][f][s] = null;
// m_pairs_last[f][s] = null;
if (USED_PAIRS_MAP[nTile][f][s] >= 0) {
if (used_pairs_map[nTile][f][s] >= 0) {
m_pairs[nTile][f][s] = m_disp[nTile][f].minus(m_disp[nTile][s]);
}
/*
if (f == last_cam) {
m_pairs_last[f][s] = m_disp[s].uminus();
for (int i = 0; i < NUM_CAMS; i++) if (used_cameras[i] && (i != last_cam) ){
m_pairs_last[f][s].minusEquals(m_disp[i]);
}
} else if (s == last_cam) {
m_pairs_last[f][s] = m_disp[f].copy();
for (int i = 0; i < NUM_CAMS; i++) if (used_cameras[i] && (i != last_cam) ){
m_pairs_last[f][s].plusEquals(m_disp[i]);
}
}
*/
}
}
}
......@@ -519,7 +609,7 @@ public class Corr2dLMA {
double [] CT = new double [numTiles]; // A + av[CMA_INDEX];
for (int nTile = 0; nTile < numTiles; nTile++) {
for (int i = 0; i < NUM_CAMS; i++) if (used_cameras[i]) {
double [] add_dnd = {av[DISP_INDEX+ nTile * TILE_PARAMS]+ av[DDISP_INDEX + i], av[NDISP_INDEX + i]};
double [] add_dnd = {av[DISP_INDEX+ nTile * TILE_PARAMS]+ av[ddisp_index + i], av[ndisp_index + i]};
xcam_ycam[nTile][i] = m_disp[nTile][i].times(new Matrix(add_dnd,2));
}
for (int f = 0; f < NUM_CAMS; f++) if (used_cameras[f]) {
......@@ -534,9 +624,6 @@ public class Corr2dLMA {
int num_samples = samples.size();
double [] fx= new double [num_samples + 2 * NUM_CAMS];
// double A = av[A_INDEX];
// double B = av[B_INDEX];
// double C = A + av[CMA_INDEX];
//corr_wnd
for (int ns = 0; ns < num_samples; ns++) {
Sample s = samples.get(ns);
......@@ -571,76 +658,171 @@ public class Corr2dLMA {
for (int p = 0; p < npairs[s.tile]; p++) { // par_mask[G0_INDEX + p] as all pairs either used, or not - then npairs == 0
if (par_map[G0_INDEX + p + s.tile*TILE_PARAMS] >= 0) jt[par_map[G0_INDEX + p + s.tile*TILE_PARAMS]][ns] = (p== pair)? d : 0.0; // (par_mask[G0_INDEX + pair])? d;
}
// process ddisp (last camera not used, is equal to minus sum of others to make a sum == 0)
for (int f = 0; f < NUM_CAMS; f++) if (par_map[DDISP_INDEX + f] >= 0) { // -1 for the last_cam
jt[par_map[DDISP_INDEX + f]][ns] = 0.0;
}
if (par_map[DDISP_INDEX + s.fcam] >= 0){ // par_map[DDISP_INDEX + last_cam] always <0
jt[par_map[DDISP_INDEX + s.fcam]][ns] += 2 * WGp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 0));
} else if (s.fcam == last_cam) {
for (int c = 0; c < NUM_CAMS; c++) if ((c != last_cam) && (par_map[DDISP_INDEX + c] >=0)) {
jt[par_map[DDISP_INDEX + c]][ns] -= 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 0)+
// obsolete: process ddisp (last camera not used, is equal to minus sum of others to make a sum == 0)
if (lazy_eye) {
for (int f = 0; f < NUM_CAMS; f++) { // -1 for the last_cam and pre_last_cam
if (par_map[ddisp_index + f] >= 0) jt[par_map[ddisp_index + f]][ns] = 0.0;
if (par_map[ndisp_index + f] >= 0) jt[par_map[ndisp_index + f]][ns] = 0.0;
}
double [] dd_deriv = new double[3]; // derivatives by dependent dd_pre_lars, dd_last and nd_last (calculated on demand) with sign according to first/second in a pair
if ((s.fcam == pre_last_cam)) {
dd_deriv[0] = 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][pre_last_cam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][pre_last_cam].get(1, 0));
} else if ((s.scam == pre_last_cam)) {
dd_deriv[0] = -2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][pre_last_cam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][pre_last_cam].get(1, 0));
}
if ((s.fcam == last_cam)) {
dd_deriv[1] = 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][last_cam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][last_cam].get(1, 0));
dd_deriv[2] = 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][last_cam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][last_cam].get(1, 1));
} else if ((s.scam == last_cam)) {
dd_deriv[1] = -2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][last_cam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][last_cam].get(1, 0));
dd_deriv[2] = -2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][last_cam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][last_cam].get(1, 1));
}
// now accumulate derivatives:
// first calculate contributions of the dd, nd directly:
if (par_map[ddisp_index + s.fcam] >= 0){ // par_map[ddisp_index + last_cam] always <0
jt[par_map[ddisp_index + s.fcam]][ns] += 2 * WGp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 0));
}
}
if (par_map[DDISP_INDEX + s.scam]>= 0){ // par_map[DDISP_INDEX + last_cam] always <0
jt[par_map[DDISP_INDEX + s.scam]][ns] -= 2 * WGp *
if (par_map[ddisp_index + s.scam]>= 0){ // par_map[ddisp_index + last_cam] always <0
jt[par_map[ddisp_index + s.scam]][ns] -= 2 * WGp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 0));
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 0));
}
if (par_map[ndisp_index + s.fcam] >=0){
jt[par_map[ndisp_index + s.fcam]][ns] += 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 1));
}
if (par_map[ndisp_index + s.scam] >= 0) {
} else if (s.scam == last_cam) {
for (int c = 0; c < NUM_CAMS; c++) if ((c != last_cam) && (par_map[DDISP_INDEX + c] >= 0)) {
jt[par_map[DDISP_INDEX + c]][ns] += 2 * WGp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 0));
jt[par_map[ndisp_index + s.scam]][ns] -= 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 1));
}
}
// now calculate indirect ones through derivatives by dd_pre_last (dd_deriv[0]), dd_last (dd_deriv[1]) and nd_last (dd_deriv[2])
//// private int [] dd_indices; //normally 5-long (2 * ncam -3), absolute parameter indices for dd_pre_last, dd_last and nd_last
for (int ddn = 0; ddn < 3; ddn++) if (dd_deriv[ddn] != 0.0) {
for (int i = 0; i < dd_indices.length; i++) {
jt[dd_indices[i]][ns] += dd_deriv[ddn] * mddnd.get(ddn, i);
}
}
/*
// process ndisp
for (int f = 0; f < ncam; f++) if (par_map[NDISP_INDEX + f] >= 0) {
jt[par_map[NDISP_INDEX + f]][ns] = 0.0;
}
if (par_map[NDISP_INDEX + s.fcam] >=0){
jt[par_map[NDISP_INDEX + s.fcam]][ns] += 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 1));
}
// private Matrix mddnd; // Matrix to calculate 2 last corrections in disparity direction and 1 ortho from the first ones (normally 2+3=5)
if (par_map[ddisp_index + s.fcam] >= 0){ // par_map[ddisp_index + last_cam] always <0
jt[par_map[ddisp_index + s.fcam]][ns] += 2 * WGp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 0));
} else if (s.fcam == pre_last_cam) {
for (int c = 0; c < NUM_CAMS; c++) if ((c != last_cam) && (par_map[ddisp_index + c] >=0)) {
jt[par_map[ddisp_index + c]][ns] -= 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 0));
}
} else if (s.fcam == last_cam) {
for (int c = 0; c < NUM_CAMS; c++) if ((c != last_cam) && (par_map[ddisp_index + c] >=0)) {
jt[par_map[ddisp_index + c]][ns] -= 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 0));
}
}
if (par_map[ddisp_index + s.scam]>= 0){ // par_map[ddisp_index + last_cam] always <0
jt[par_map[ddisp_index + s.scam]][ns] -= 2 * WGp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 0));
} else if (s.scam == last_cam) {
for (int c = 0; c < NUM_CAMS; c++) if ((c != last_cam) && (par_map[ddisp_index + c] >= 0)) {
jt[par_map[ddisp_index + c]][ns] += 2 * WGp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 0));
}
}
// process ndisp
// for (int f = 0; f < ncam; f++) if (par_map[ndisp_index + f] >= 0) {
// jt[par_map[ndisp_index + f]][ns] = 0.0;
// }
if (par_map[ndisp_index + s.fcam] >=0){
jt[par_map[ndisp_index + s.fcam]][ns] += 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 1));
}
if (par_map[NDISP_INDEX + s.scam] >= 0) {
if (par_map[ndisp_index + s.scam] >= 0) {
jt[par_map[NDISP_INDEX + s.scam]][ns] -= 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 1));
jt[par_map[ndisp_index + s.scam]][ns] -= 2 * WGp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 1));
}
*/
}
}
}
for (int n = 0; n < NUM_CAMS; n++) { // av[DDISP_INDEX +last_cam] is already populated
fx[num_samples + n] = av[DDISP_INDEX + n];
fx[num_samples + NUM_CAMS + n] = av[NDISP_INDEX + n];
}
if (lazy_eye) {
for (int n = 0; n < NUM_CAMS; n++) { // av[ddisp_index +last_cam] and other 2 are already populated
fx[num_samples + n] = av[ddisp_index + n];
fx[num_samples + NUM_CAMS + n] = av[ndisp_index + n];
}
// and derivatives
// and derivatives
if (jt != null) {
for (int i = 0; i < NUM_CAMS; i++) {
if ((i != last_cam) && (i != pre_last_cam) && (par_map[ddisp_index + i] >= 0)) {
jt[par_map[ddisp_index + i]][num_samples + i] = 1.0;
}
if ((i != last_cam) && (par_map[ndisp_index + i] >= 0)) {
jt[par_map[ndisp_index + i] ][num_samples + NUM_CAMS + i] = 1.0;
}
}
for (int i = 0; i < dd_indices.length; i++) {
jt[dd_indices[i]][num_samples + pre_last_cam] = mddnd.get(0, i);
jt[dd_indices[i]][num_samples + last_cam] = mddnd.get(1, i);
jt[dd_indices[i]][num_samples + NUM_CAMS + last_cam] = mddnd.get(2, i);
}
}
}
/*
if (jt != null) {
for (int i = 0; i < NUM_CAMS; i++) {
if ((i != last_cam) && (par_map[DDISP_INDEX + i] >= 0)) {
if ((i != last_cam) && (par_map[ddisp_index + i] >= 0)) {
for (int j = 0; j < NUM_CAMS; j++) { // j - column
jt[par_map[DDISP_INDEX + i]][num_samples + j] = (i==j)? 1.0 : 0.0;
jt[par_map[ddisp_index + i]][num_samples + j] = (i==j)? 1.0 : 0.0;
}
jt[par_map[DDISP_INDEX + i]][num_samples + last_cam] = -1.0;
jt[par_map[ddisp_index + i]][num_samples + last_cam] = -1.0;
}
}
for (int i = 0; i < NUM_CAMS; i++) {
if (par_map[NDISP_INDEX + i] >= 0) {
if (par_map[ndisp_index + i] >= 0) {
for (int j = 0; j < NUM_CAMS; j++) { // j - column
jt[par_map[NDISP_INDEX + i] ][num_samples + NUM_CAMS + j] = (i==j)? 1.0 : 0.0;
jt[par_map[ndisp_index + i] ][num_samples + NUM_CAMS + j] = (i==j)? 1.0 : 0.0;
}
}
}
}
*/
return fx;
}
......@@ -658,7 +840,7 @@ public class Corr2dLMA {
double [] CT = new double [numTiles]; // A + av[CMA_INDEX];
for (int nTile = 0; nTile < numTiles; nTile++) {
for (int i = 0; i < NUM_CAMS; i++) if (used_cameras[i]) {
double [] add_dnd = {av[DISP_INDEX+ nTile * TILE_PARAMS]+ av[DDISP_INDEX + i], av[NDISP_INDEX + i]};
double [] add_dnd = {av[DISP_INDEX+ nTile * TILE_PARAMS]+ av[ddisp_index + i], av[ndisp_index + i]};
xcam_ycam[nTile][i] = m_disp[nTile][i].times(new Matrix(add_dnd,2));
}
for (int f = 0; f < NUM_CAMS; f++) if (used_cameras[f]) {
......@@ -704,97 +886,121 @@ public class Corr2dLMA {
if (jt != null) {
if (par_map[DISP_INDEX + s.tile*TILE_PARAMS] >= 0) jt[par_map[DISP_INDEX + s.tile*TILE_PARAMS]][ns] = 2 * WGpexp *
((A * xmxp + B * ymyp) * m_pairs[s.tile][s.fcam][s.scam].get(0, 0)+
(B * xmxp + C * ymyp) * m_pairs[s.tile][s.fcam][s.scam].get(1, 0));
(B * xmxp + C * ymyp) * m_pairs[s.tile][s.fcam][s.scam].get(1, 0));
if (par_map[A_INDEX + s.tile*TILE_PARAMS] >= 0) jt[par_map[A_INDEX + s.tile*TILE_PARAMS]][ns] = -WGpexp*(xmxp2 + ymyp2);
if (par_map[B_INDEX + s.tile*TILE_PARAMS] >= 0) jt[par_map[B_INDEX + s.tile*TILE_PARAMS]][ns] = -WGpexp* 2 * xmxp_ymyp;
if (par_map[CMA_INDEX + s.tile*TILE_PARAMS] >= 0) jt[par_map[CMA_INDEX + s.tile*TILE_PARAMS]][ns] = -WGp* ymyp2 * exp;
if (par_map[CMA_INDEX + s.tile*TILE_PARAMS] >= 0) jt[par_map[CMA_INDEX + s.tile*TILE_PARAMS]][ns] = -WGpexp* ymyp2;
for (int p = 0; p < npairs[s.tile]; p++) { // par_mask[G0_INDEX + p] as all pairs either used, or not - then npairs == 0
if (par_map[G0_INDEX + p + s.tile*TILE_PARAMS] >= 0) jt[par_map[G0_INDEX + p + s.tile*TILE_PARAMS]][ns] = (p== pair)? comm : 0.0; // (par_mask[G0_INDEX + pair])? d;
}
// process ddisp (last camera not used, is equal to minus sum of others to make a sum == 0)
if (lazy_eye) {
for (int f = 0; f < NUM_CAMS; f++) if (par_map[ddisp_index + f] >= 0) { // -1 for the last_cam
jt[par_map[ddisp_index + f]][ns] = 0.0;
jt[par_map[ndisp_index + f]][ns] = 0.0;
}
for (int f = 0; f < NUM_CAMS; f++) if (par_map[DDISP_INDEX + f] >= 0) { // -1 for the last_cam
jt[par_map[DDISP_INDEX + f]][ns] = 0.0;
}
if (par_map[DDISP_INDEX + s.fcam] >= 0){ // par_map[DDISP_INDEX + last_cam] always <0
jt[par_map[DDISP_INDEX + s.fcam]][ns] += 2 * WGpexp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 0));
} else if (s.fcam == last_cam) {
for (int c = 0; c < NUM_CAMS; c++) if ((c != last_cam) && (par_map[DDISP_INDEX + c] >=0)) {
jt[par_map[DDISP_INDEX + c]][ns] -= 2 * WGpexp *
double [] dd_deriv = new double[3]; // derivatives by dependent dd_pre_lars, dd_last and nd_last (calculated on demand) with sign according to first/second in a pair
if ((s.fcam == pre_last_cam)) {
dd_deriv[0] = 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][pre_last_cam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][pre_last_cam].get(1, 0));
} else if ((s.scam == pre_last_cam)) {
dd_deriv[0] = -2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][pre_last_cam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][pre_last_cam].get(1, 0));
}
if ((s.fcam == last_cam)) {
dd_deriv[1] = 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][last_cam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][last_cam].get(1, 0));
dd_deriv[2] = 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][last_cam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][last_cam].get(1, 1));
} else if ((s.scam == last_cam)) {
dd_deriv[1] = -2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][last_cam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][last_cam].get(1, 0));
dd_deriv[2] = -2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][last_cam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][last_cam].get(1, 1));
}
// now accumulate derivatives:
// first calculate contributions of the dd, nd directly:
if (par_map[ddisp_index + s.fcam] >= 0){ // par_map[ddisp_index + last_cam] always <0
jt[par_map[ddisp_index + s.fcam]][ns] += 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 0));
}
}
if (par_map[DDISP_INDEX + s.scam]>= 0){ // par_map[DDISP_INDEX + last_cam] always <0
jt[par_map[DDISP_INDEX + s.scam]][ns] -= 2 * WGpexp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 0));
} else if (s.scam == last_cam) {
for (int c = 0; c < NUM_CAMS; c++) if ((c != last_cam) && (par_map[DDISP_INDEX + c] >= 0)) {
jt[par_map[DDISP_INDEX + c]][ns] += 2 * WGpexp *
((A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 0));
if (par_map[ddisp_index + s.scam]>= 0){ // par_map[ddisp_index + last_cam] always <0
jt[par_map[ddisp_index + s.scam]][ns] -= 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 0)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 0));
}
}
// process ndisp
for (int f = 0; f < ncam; f++) if (par_map[NDISP_INDEX + f] >= 0) {
jt[par_map[NDISP_INDEX + f]][ns] = 0.0;
}
if (par_map[NDISP_INDEX + s.fcam] >=0){
jt[par_map[NDISP_INDEX + s.fcam]][ns] += 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 1));
}
if (par_map[ndisp_index + s.fcam] >=0){
jt[par_map[ndisp_index + s.fcam]][ns] += 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.fcam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.fcam].get(1, 1));
}
if (par_map[ndisp_index + s.scam] >= 0) {
if (par_map[NDISP_INDEX + s.scam] >= 0) {
jt[par_map[ndisp_index + s.scam]][ns] -= 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 1));
}
jt[par_map[NDISP_INDEX + s.scam]][ns] -= 2 * WGpexp *
( (A * xmxp + B * ymyp) * m_disp[s.tile][s.scam].get(0, 1)+
(B * xmxp + C * ymyp) * m_disp[s.tile][s.scam].get(1, 1));
// now calculate indirect ones through derivatives by dd_pre_last (dd_deriv[0]), dd_last (dd_deriv[1]) and nd_last (dd_deriv[2])
//// private int [] dd_indices; //normally 5-long (2 * ncam -3), absolute parameter indices for dd_pre_last, dd_last and nd_last
for (int ddn = 0; ddn < 3; ddn++) if (dd_deriv[ddn] != 0.0) {
for (int i = 0; i < dd_indices.length; i++) {
jt[dd_indices[i]][ns] += dd_deriv[ddn] * mddnd.get(ddn, i);
}
}
}
}
}
for (int n = 0; n < NUM_CAMS; n++) { // av[DDISP_INDEX +last_cam] is already populated
fx[num_samples + n] = av[DDISP_INDEX + n];
fx[num_samples + NUM_CAMS + n] = av[NDISP_INDEX + n];
}
if (lazy_eye) {
for (int n = 0; n < NUM_CAMS; n++) { // av[ddisp_index +last_cam] and other 2 are already populated
fx[num_samples + n] = av[ddisp_index + n];
fx[num_samples + NUM_CAMS + n] = av[ndisp_index + n];
}
// and derivatives
if (jt != null) {
for (int i = 0; i < NUM_CAMS; i++) {
if ((i != last_cam) && (par_map[DDISP_INDEX + i] >= 0)) {
for (int j = 0; j < NUM_CAMS; j++) { // j - column
jt[par_map[DDISP_INDEX + i]][num_samples + j] = (i==j)? 1.0 : 0.0;
// and derivatives
if (jt != null) {
for (int i = 0; i < NUM_CAMS; i++) {
if ((i != last_cam) && (i != pre_last_cam) && (par_map[ddisp_index + i] >= 0)) {
jt[par_map[ddisp_index + i]][num_samples + i] = 1.0;
}
jt[par_map[DDISP_INDEX + i]][num_samples + last_cam] = -1.0;
}
}
for (int i = 0; i < NUM_CAMS; i++) {
if (par_map[NDISP_INDEX + i] >= 0) {
for (int j = 0; j < NUM_CAMS; j++) { // j - column
jt[par_map[NDISP_INDEX + i] ][num_samples + NUM_CAMS + j] = (i==j)? 1.0 : 0.0;
if ((i != last_cam) && (par_map[ndisp_index + i] >= 0)) {
jt[par_map[ndisp_index + i] ][num_samples + NUM_CAMS + i] = 1.0;
}
}
for (int i = 0; i < dd_indices.length; i++) {
jt[dd_indices[i]][num_samples + pre_last_cam] = mddnd.get(0, i);
jt[dd_indices[i]][num_samples + last_cam] = mddnd.get(1, i);
jt[dd_indices[i]][num_samples + NUM_CAMS + last_cam] = mddnd.get(2, i);
}
}
}
return fx;
}
public void printParams() { // not used in lwir
// to make sure it is updated
System.out.println();
// all_pars = fromVector(vector);
for (int np = 0; np < all_pars.length; np++) {
String parname;
// if (np < G0_INDEX) parname = PAR_NAMES[np];
// else if (np < DDISP_INDEX) parname = PAR_NAME_SCALE;
// else if (np < NDISP_INDEX) parname = PAR_NAME_CORRDISP;
// else if (np < ddisp_index) parname = PAR_NAME_SCALE;
// else if (np < ndisp_index) parname = PAR_NAME_CORRDISP;
// else parname = PAR_NAME_CORRNDISP;
if (np >= NDISP_INDEX) parname = PAR_NAME_CORRNDISP + (np - NDISP_INDEX);
else if (np >= DDISP_INDEX) parname = PAR_NAME_CORRDISP + (np - DDISP_INDEX);
if (np >= ndisp_index) parname = PAR_NAME_CORRNDISP + (np - ndisp_index);
else if (np >= ddisp_index) parname = PAR_NAME_CORRDISP + (np - ddisp_index);
else {
int ntile = np / TILE_PARAMS;
int anpr = np % TILE_PARAMS;
......@@ -873,7 +1079,7 @@ public class Corr2dLMA {
public double [] getLazyEye() {
double [] rslt = new double [2 * NUM_CAMS];
for (int i = 0; i < rslt.length; i++) {
rslt[i] = all_pars[DDISP_INDEX + i];
rslt[i] = all_pars[ddisp_index + i];
}
return rslt;
}
......@@ -888,31 +1094,44 @@ public class Corr2dLMA {
public void updateFromVector() { // USED in lwir
int np = 0;
// all_pars = fromVector(vector);//
for (int i = 0; i < par_mask.length; i++) if (par_mask[i]) all_pars[i] = vector[np++];
// just for reporting
all_pars[DDISP_INDEX + last_cam] = 0.0;
for (int i = 0; i < NUM_CAMS; i++) {
if (used_cameras[i] & (i != last_cam)) {
all_pars[DDISP_INDEX + last_cam] -= all_pars[DDISP_INDEX + i];
}
double [] a5 = new double [2 * ncam-3];
for (int i = 0; i < (ncam - 2); i++) {
a5[i] = all_pars[ddisp_index + used_cams_rmap[i]];
}
for (int i = 0; i < (ncam - 1); i++) {
a5[ncam - 2 + i] = all_pars[ndisp_index + used_cams_rmap[i]];
}
Matrix m5 = new Matrix(a5,a5.length); // single column, normally 5 rows
Matrix m3 = mddnd.times(m5);
all_pars[ddisp_index + used_cams_rmap[pre_last_cam]] = m3.get(0, 0);
all_pars[ddisp_index + used_cams_rmap[last_cam]] = m3.get(1, 0);
all_pars[ndisp_index + used_cams_rmap[last_cam]] = m3.get(2, 0);
}
public double [] fromVector(double [] vector) { // mix fixed and variable parameters // USED in lwir
if ( all_pars == null) return null;
double [] ap = all_pars.clone();
int np = 0;
for (int i = 0; i < par_mask.length; i++) if (par_mask[i]) ap[i] = vector[np++];
ap[DDISP_INDEX + last_cam] = 0.0;
for (int i = 0; i < NUM_CAMS; i++) {
if (used_cameras[i] & (i != last_cam)) {
ap[DDISP_INDEX + last_cam] -= ap[DDISP_INDEX + i];
}
// Fill in missing values (2 last dd-s, 1 last nd)
double [] a5 = new double [2 * ncam-3];
for (int i = 0; i < (ncam - 2); i++) {
a5[i] = ap[ddisp_index + used_cams_rmap[i]];
}
for (int i = 0; i < (ncam - 1); i++) {
a5[ncam - 2 + i] = ap[ndisp_index + used_cams_rmap[i]];
}
Matrix m5 = new Matrix(a5,a5.length); // single column, normally 5 rows
Matrix m3 = mddnd.times(m5);
ap[ddisp_index + used_cams_rmap[pre_last_cam]] = m3.get(0, 0);
ap[ddisp_index + used_cams_rmap[last_cam]] = m3.get(1, 0);
ap[ndisp_index + used_cams_rmap[last_cam]] = m3.get(2, 0);
return ap;
}
......@@ -935,8 +1154,8 @@ public class Corr2dLMA {
System.out.print(String.format("Til P %3s: %10s ", "#", "fx"));
for (int anp = 0; anp< all_pars.length; anp++) if(par_mask[anp]){
String parname;
if (anp >= NDISP_INDEX) parname = PAR_NAME_CORRNDISP + (anp - NDISP_INDEX);
else if (anp >= DDISP_INDEX) parname = PAR_NAME_CORRDISP + (anp - DDISP_INDEX);
if (anp >= ndisp_index) parname = PAR_NAME_CORRNDISP + (anp - ndisp_index);
else if (anp >= ddisp_index) parname = PAR_NAME_CORRDISP + (anp - ddisp_index);
else {
int ntile = anp / TILE_PARAMS;
int anpr = anp % TILE_PARAMS;
......@@ -949,7 +1168,7 @@ public class Corr2dLMA {
int npair0 = -1;
for (int i = 0; i < num_points; i++) {
if (i < samples.size()) {
int npair = USED_PAIRS_MAP[samples.get(i).tile][samples.get(i).fcam][samples.get(i).scam];
int npair = used_pairs_map[samples.get(i).tile][samples.get(i).fcam][samples.get(i).scam];
if (npair !=npair0) {
if (npair0 >=0) System.out.println();
npair0 = npair;
......@@ -968,7 +1187,13 @@ public class Corr2dLMA {
}
System.out.println();
}
System.out.print(String.format(" %15s ", "Maximal diff:"));
double tmd = 0.0;
for (int np = 0; np < num_pars; np++) {
if (max_diff[np] > tmd) tmd= max_diff[np];
}
// System.out.print(String.format(" %15s ", "Maximal diff:"));
System.out.print(String.format("Max diff.(%10.5f):", tmd));
for (int np = 0; np < num_pars; np++) {
System.out.print(String.format("|%8s %8.5f ", "1/1000×", 1000*max_diff[np]));
}
......
src/main/java/com/elphel/imagej/tileprocessor/Correlation2d.java
View file @ d1ddd6b3
......@@ -1810,9 +1810,9 @@ public class Correlation2d {
double [] corr_wnd_inv_limited, // correlation window, limited not to be smaller than threshold - used for finding max/convex areas (or null)
double [][][] corrs, // per tile, per pair, 2 correlation in line-scan order
double [][][] disp_dist, // per tile, per camera disparity matrix as a 1d (linescan order)
double [][] rXY, // non-distorted X,Y offset per nominal pixel of disparity
int pair_mask, // which pairs to process
boolean run_poly_instead, // true - run LMA, false - run 2d polynomial approximation
// double sigma, // low-pass sigma to find maximum (and convex too
double[][] xcenter_str, // preliminary center x in pixels for largest baseline
double vasw_pwr, // value as weight to this power,
int debug_level,
......@@ -1823,7 +1823,7 @@ public class Correlation2d {
// corrs are organized as PAIRS, some are null if not used
// for each enabled and available pair find a maximum, filter convex and create sample list
boolean debug_graphic = (debug_level > -1);
boolean debug_second_all = false; // true;
boolean debug_second_all = false; // true; // alse; // true;
int clust_height = corrs.length/clust_width;
int ntiles = corrs.length;
DoubleGaussianBlur gb = null;
......@@ -1834,6 +1834,7 @@ public class Correlation2d {
corrs.length,
transform_size,
corr_wnd,
rXY, //double [][] rXY, // non-distorted X,Y offset per nominal pixel of disparity
imgdtt_params.lma_gaussian//boolean gaussian_mode
);
......@@ -1989,13 +1990,13 @@ public class Correlation2d {
}
lmaSuccess = lma.runLma(
imgdtt_params.lma_lambda_initial, // double lambda, // 0.1
imgdtt_params.lma_lambda_scale_good, // double lambda_scale_good,// 0.5
imgdtt_params.lma_lambda_scale_bad, // double lambda_scale_bad, // 8.0
imgdtt_params.lma_lambda_max, // double lambda_max, // 100
imgdtt_params.lma_rms_diff, // double rms_diff, // 0.001
imgdtt_params.lma_num_iter, // int num_iter, // 20
2); //4); // debug_level); // int debug_level) // > 3
imgdtt_params.lma_lambda_initial, // double lambda, // 0.1
imgdtt_params.lma_lambda_scale_good, // double lambda_scale_good, // 0.5
imgdtt_params.lma_lambda_scale_bad, // double lambda_scale_bad, // 8.0
imgdtt_params.lma_lambda_max, // double lambda_max, // 100
imgdtt_params.lma_rms_diff, // double rms_diff, // 0.001
imgdtt_params.lma_num_iter, // int num_iter, // 20
imgdtt_params.lma_debug_level1); //4); // debug_level); // int debug_level) // > 3
lma.updateFromVector();
double [] rms = lma.getRMS();
......@@ -2124,15 +2125,15 @@ public class Correlation2d {
return lmaSuccess? lma: null;
}
public Corr2dLMA corrLMA2( // single tile
public Corr2dLMA corrLMA2( // single tile ************* Will be obsolete ????
ImageDttParameters imgdtt_params,
double [][] corr_wnd, // correlation window to save on re-calculation of the window
double [] corr_wnd_inv_limited, // correlation window, limited not to be smaller than threshold - used for finding max/convex areas (or null)
double [][] corrs,
double [][] disp_dist, // per camera disparity matrix as a 1d (linescan order)
double [][] rXY, // non-distorted X,Y offset per nominal pixel of disparity
int pair_mask, // which pairs to process
boolean run_poly_instead, // true - run LMA, false - run 2d polynomial approximation
// double sigma, // low-pass sigma to find maximum (and convex too
double xcenter, // preliminary center x in pixels for largest baseline
double vasw_pwr, // value as weight to this power,
int debug_level,
......@@ -2151,7 +2152,8 @@ public class Correlation2d {
1,
transform_size,
corr_wnd,
imgdtt_params.lma_gaussian//boolean gaussian_mode
rXY, //double [][] rXY, // non-distorted X,Y offset per nominal pixel of disparity
imgdtt_params.lma_gaussian //boolean gaussian_mode
);
......@@ -2312,19 +2314,6 @@ public class Correlation2d {
return lmaSuccess? lma: null;
}
/*
double [][] dbg_w = repackCluster(
dbg_weights,
clust_width);
(new ShowDoubleFloatArrays()).showArrays(
dbg_w,
dbg_out_width,
dbg_out_height,
true,
"corr_weights"+"_x"+tileX+"_y"+tileY);
*/
public Correlations2dLMA corrLMA( // USED in lwir
ImageDttParameters imgdtt_params,
......
src/main/java/com/elphel/imagej/tileprocessor/ImageDtt.java
View file @ d1ddd6b3
......@@ -1577,12 +1577,13 @@ public class ImageDtt {
final int globalDebugLevel)
{
final boolean debug_distort= true;
// final double [][] debug_offsets = null;
final double [][] debug_offsets = imgdtt_params.lma_dbg_offset;
// final double [][] debug_offsets = {{ 0.5, 0.0},{ -0.5, 0.0},{-0.5, 0.0},{ 0.5, 0.0}}; // add to calculated CenterXY for evaluating new LMA
// final double [][] debug_offsets = {{ 1.0, 0.0},{ -1.0, 0.0},{-1.0, 0.0},{ 1.0, 0.0}}; // add to calculated CenterXY for evaluating new LMA
// final double [][] debug_offsets = {{ 0.0, 1.0},{ 0.0, -1.0},{ 0.0, -1.0},{ 0.0, 1.0}}; // add to calculated CenterXY for evaluating new LMA
//lma_dbg_scale
final double [][] debug_offsets = new double[imgdtt_params.lma_dbg_offset.length][2];
for (int i = 0; i < debug_offsets.length; i++) for (int j = 0; j < debug_offsets[i].length; j++) {
debug_offsets[i][j] = imgdtt_params.lma_dbg_offset[i][j]*imgdtt_params.lma_dbg_scale;
}
final int quad = 4; // number of subcameras
final int numcol = 3; // number of colors // keep the same, just do not use [0] and [1], [2] - green
......@@ -1605,6 +1606,15 @@ public class ImageDtt {
final double [] col_weights= new double [numcol]; // colors are RBG
final double [][] dbg_distort = debug_distort? (new double [4*quad][tilesX*tilesY]) : null;
final double [][] corr_wnd = Corr2dLMA.getCorrWnd(transform_size);
final double [] corr_wnd_inv_limited = (imgdtt_params.lma_min_wnd <= 1.0)? new double [corr_wnd.length * corr_wnd[0].length]: null;
if (corr_wnd_inv_limited != null) {
for (int i = imgdtt_params.lma_hard_marg; i < (corr_wnd.length - imgdtt_params.lma_hard_marg); i++) {
for (int j = imgdtt_params.lma_hard_marg; j < (corr_wnd.length - imgdtt_params.lma_hard_marg); j++) {
corr_wnd_inv_limited[i * (corr_wnd.length) + j] = 1.0/Math.max(Math.pow(corr_wnd[i][j],imgdtt_params.lma_wnd_pwr), imgdtt_params.lma_min_wnd);
}
}
}
// keep for now for mono, find out what do they mean for macro mode
if (isMonochrome()) {
......@@ -1746,7 +1756,8 @@ public class ImageDtt {
double centerX; // center of aberration-corrected (common model) tile, X
double centerY; //
double [][] fract_shiftsXY = new double[quad][];
double [][] corr_wnd = (new Corr2dLMA(1, transform_size, null,imgdtt_params.lma_gaussian)).getCorrWnd();
// double [][] corr_wnd = Corr2dLMA.getCorrWnd(transform_size);
/*
double [] corr_wnd_inv_limited = null;
if (imgdtt_params.lma_min_wnd <= 1.0) {
corr_wnd_inv_limited = new double [corr_wnd.length * corr_wnd[0].length];
......@@ -1756,7 +1767,7 @@ public class ImageDtt {
}
}
}
*/
Correlation2d corr2d = new Correlation2d(
imgdtt_params, // ImageDttParameters imgdtt_params,
transform_size, // int transform_size,
......@@ -1768,6 +1779,13 @@ public class ImageDtt {
imgdtt_params.getEnhOrthoScale(isAux()), //double getEnhOrthoScale(isAux()),
(imgdtt_params.lma_debug_level > 1)); // boolean debug);
double [][] rXY;
if (use_main) {
rXY = geometryCorrection.getRXY(true); // boolean use_rig_offsets,
} else {
rXY = geometryCorrection.getRXY(false); // boolean use_rig_offsets,
}
// for (int nTile = ai.getAndIncrement(); nTile < nTilesInChn; nTile = ai.getAndIncrement()) {
for (int nCluster = ai.getAndIncrement(); nCluster < nClustersInChn; nCluster = ai.getAndIncrement()) {
clustY = nCluster / clustersX;
......@@ -2068,6 +2086,7 @@ public class ImageDtt {
corr_wnd_inv_limited, // corr_wnd_inv_limited, // correlation window, limited not to be smaller than threshold - used for finding max/convex areas (or null)
corrs[cTile], // double [][] corrs,
disp_dist[cTile],
rXY, // double [][] rXY, // non-distorted X,Y offset per nominal pixel of disparity
imgdtt_params.dbg_pair_mask, // int pair_mask, // which pairs to process
false, // boolean run_poly_instead, // true - run LMA, false - run 2d polynomial approximation
corr_stat[cTile][0], // double xcenter, // preliminary center x in pixels for largest baseline
......@@ -2096,6 +2115,7 @@ public class ImageDtt {
corr_wnd_inv_limited, // corr_wnd_inv_limited, // correlation window, limited not to be smaller than threshold - used for finding max/convex areas (or null)
corrs, // [tIndex], // double [][] corrs,
disp_dist, // [tIndex],
rXY, // double [][] rXY, // non-distorted X,Y offset per nominal pixel of disparity
imgdtt_params.dbg_pair_mask, // int pair_mask, // which pairs to process
false, // boolean run_poly_instead, // true - run LMA, false - run 2d polynomial approximation
corr_stat, // double[][] xcenter_str, // preliminary center x in pixels for largest baseline
......@@ -2230,7 +2250,15 @@ public class ImageDtt {
final AtomicInteger ai = new AtomicInteger(0);
final double [] col_weights= new double [numcol]; // colors are RBG
final double [][] dbg_distort = debug_distort? (new double [4*quad][tilesX*tilesY]) : null;
final double [][] corr_wnd = Corr2dLMA.getCorrWnd(transform_size);
final double [] corr_wnd_inv_limited = (imgdtt_params.lma_min_wnd <= 1.0)? new double [corr_wnd.length * corr_wnd[0].length]: null;
if (corr_wnd_inv_limited != null) {
for (int i = imgdtt_params.lma_hard_marg; i < (corr_wnd.length - imgdtt_params.lma_hard_marg); i++) {
for (int j = imgdtt_params.lma_hard_marg; j < (corr_wnd.length - imgdtt_params.lma_hard_marg); j++) {
corr_wnd_inv_limited[i * (corr_wnd.length) + j] = 1.0/Math.max(Math.pow(corr_wnd[i][j],imgdtt_params.lma_wnd_pwr), imgdtt_params.lma_min_wnd);
}
}
}
// keep for now for mono, find out what do they mean for macro mode
if (macro_mode) { // all the same as they now mean different
......@@ -2431,7 +2459,8 @@ public class ImageDtt {
double [][][] tcorr_partial = null; // [quad][numcol+1][15*15]
double [][][][] tcorr_tpartial = null; // [quad][numcol+1][4][8*8]
double [] ports_rgb = null;
double [][] corr_wnd = (new Corr2dLMA(1, transform_size, null,imgdtt_params.lma_gaussian)).getCorrWnd();
// double [][] corr_wnd = Corr2dLMA.getCorrWnd(transform_size);
/*
double [] corr_wnd_inv_limited = null;
if (imgdtt_params.lma_min_wnd <= 1.0) {
corr_wnd_inv_limited = new double [corr_wnd.length * corr_wnd[0].length];
......@@ -2441,7 +2470,14 @@ public class ImageDtt {
}
}
}
*/
double [][] rXY;
if (use_main) {
rXY = geometryCorrection.getRXY(true); // boolean use_rig_offsets,
} else {
rXY = geometryCorrection.getRXY(false); // boolean use_rig_offsets,
}
Correlation2d corr2d = new Correlation2d(
imgdtt_params, // ImageDttParameters imgdtt_params,
transform_size, // int transform_size,
......@@ -2978,6 +3014,7 @@ public class ImageDtt {
corr_wnd_inv_limited, // corr_wnd_limited, // correlation window, limited not to be smaller than threshold - used for finding max/convex areas (or null)
corrs, // double [][] corrs,
disp_dist,
rXY, // double [][] rXY, // non-distorted X,Y offset per nominal pixel of disparity
imgdtt_params.dbg_pair_mask, // int pair_mask, // which pairs to process
false, // boolean run_poly_instead, // true - run LMA, false - run 2d polynomial approximation
corr_stat[0], // double xcenter, // preliminary center x in pixels for largest baseline
......
src/main/java/com/elphel/imagej/tileprocessor/ImageDttParameters.java
View file @ d1ddd6b3
......@@ -128,9 +128,11 @@ public class ImageDttParameters {
public double lma_rms_diff = 0.001; //
public int lma_num_iter = 20; //
public int lma_debug_level = 3; //
public int lma_debug_level1 = 2; //
public boolean corr_var_cam = true; // New correlation mode compatible with 8 subcameras
public double cm_max_normalization = 0.55; // fraction of correlation maximum radius, being squared multiplied by maximum to have the same total mass
public double [][] lma_dbg_offset = new double [4][2]; //{{ 1.0, 0.0},{ -1.0, 0.0},{-1.0, 0.0},{ 1.0, 0.0}}; // new double [4][2];
public double lma_dbg_scale = 0.0; // scale lma_dbg_offset
public double [][] lma_dbg_offset = {{ 1.0, 0.0},{ -1.0, 0.0},{-1.0, 0.0},{ 1.0, 0.0}}; // new double [4][2];
public int getEnhOrthoWidth(boolean aux) {
return aux ? enhortho_width_aux : enhortho_width;
......@@ -316,13 +318,16 @@ public class ImageDttParameters {
"Limit LMA cycles, so it will exit after certain number of small improvements");
gd.addNumericField("LMA debug level", this.lma_debug_level, 0, 3, "",
"Debug/verbosity level for the LMA correaltion maximum fitting");
gd.addNumericField("LMA debug level1", this.lma_debug_level1, 0, 3, "",
"Debug/verbosity level for the new LMA correaltion maximum fitting");
gd.addCheckbox ("Use new correlation methods compatible with x8 camera", this.corr_var_cam,
"Debug feature to compare old/new methods");
gd.addNumericField("Normalization for the CM correlation strength", this.cm_max_normalization, 6, 8, "",
gd.addNumericField("Normalization for the CM correlation strength", this.cm_max_normalization, 6, 8, "",
"Fraction of correlation maximum radius, being squared multiplied by maximum to have the same total mass. ~= 0.5, the lower the value, the higher strength reported by the CM");
gd.addMessage("Cameras offsets in the disparity direction and orthogonal to disparity (debugging LMA)");
gd.addNumericField("LMA debug offsets scale", this.lma_dbg_scale, 6, 8, "",
"Scale the following offsets by this value");
gd.addNumericField("LMA debug offset: camera0, parallel", this.lma_dbg_offset[0][0], 6, 8, "pix",
"Add camera offset in the direction of disparity (to/from center)");
gd.addNumericField("LMA debug offset: camera0, ortho", this.lma_dbg_offset[0][1], 6, 8, "pix",
......@@ -441,8 +446,10 @@ public class ImageDttParameters {
this.lma_num_iter= (int) gd.getNextNumber();
this.lma_debug_level= (int) gd.getNextNumber();
this.lma_debug_level1= (int) gd.getNextNumber();
this.corr_var_cam = gd.getNextBoolean();
this.cm_max_normalization= gd.getNextNumber();
this.lma_dbg_scale= gd.getNextNumber();
for (int i = 0; i < 4; i++) for (int j=0; j < 2; j++) {
this.lma_dbg_offset[i][j]= gd.getNextNumber();
......@@ -459,14 +466,14 @@ public class ImageDttParameters {
properties.setProperty(prefix+"poly_corr_scale", this.poly_corr_scale+"");
properties.setProperty(prefix+"poly_pwr", this.poly_pwr+"");
properties.setProperty(prefix+"poly_value_to_weight", this.poly_vasw_pwr+"");
properties.setProperty(prefix+"poly_vasw_pwr", this.poly_vasw_pwr+"");
properties.setProperty(prefix+"corr_magic_scale_cm", this.corr_magic_scale_cm+"");
properties.setProperty(prefix+"corr_magic_scale_poly",this.corr_magic_scale_poly+"");
properties.setProperty(prefix+"ortho_height", this.ortho_height+"");
properties.setProperty(prefix+"ortho_eff_height", this.ortho_eff_height+"");
properties.setProperty(prefix+"ortho_nsamples", this.ortho_nsamples+"");
properties.setProperty(prefix+"ortho_vasw", this.ortho_vasw_pwr+"");
properties.setProperty(prefix+"ortho_vasw_pwr", this.ortho_vasw_pwr+"");
properties.setProperty(prefix+"enhortho_width", this.enhortho_width +"");
properties.setProperty(prefix+"enhortho_width_aux", this.enhortho_width_aux +"");
......@@ -545,10 +552,13 @@ public class ImageDttParameters {
properties.setProperty(prefix+"lma_num_iter", this.lma_num_iter +"");
properties.setProperty(prefix+"lma_debug_level", this.lma_debug_level +"");
properties.setProperty(prefix+"lma_debug_level1", this.lma_debug_level1 +"");
properties.setProperty(prefix+"corr_var_cam", this.corr_var_cam +"");
properties.setProperty(prefix+"cm_max_normalization", this.cm_max_normalization +"");
for (int i = 0; i < 4; i++) for (int j=0; j < 2; j++) {
properties.setProperty(prefix+"lma_dbg_scale", this.lma_dbg_scale +"");
for (int i = 0; i < 4; i++) for (int j=0; j < 2; j++) {
properties.setProperty(prefix+"lma_dbg_offset_"+i+"_"+j, this.lma_dbg_offset[i][j] +"");
}
......@@ -655,10 +665,11 @@ public class ImageDttParameters {
if (properties.getProperty(prefix+"lma_num_iter")!=null) this.lma_num_iter=Integer.parseInt(properties.getProperty(prefix+"lma_num_iter"));
if (properties.getProperty(prefix+"lma_debug_level")!=null) this.lma_debug_level=Integer.parseInt(properties.getProperty(prefix+"lma_debug_level"));
if (properties.getProperty(prefix+"lma_debug_level1")!=null) this.lma_debug_level1=Integer.parseInt(properties.getProperty(prefix+"lma_debug_level1"));
if (properties.getProperty(prefix+"corr_var_cam")!=null) this.corr_var_cam=Boolean.parseBoolean(properties.getProperty(prefix+"corr_var_cam"));
if (properties.getProperty(prefix+"cm_max_normalization")!=null) this.cm_max_normalization=Double.parseDouble(properties.getProperty(prefix+"cm_max_normalization"));
if (properties.getProperty(prefix+"lma_dbg_scale")!=null) this.lma_dbg_scale=Double.parseDouble(properties.getProperty(prefix+"lma_dbg_scale"));
for (int i = 0; i < 4; i++) for (int j=0; j < 2; j++) {
if (properties.getProperty(prefix+"lma_dbg_offset_"+i+"_"+j)!=null) this.lma_dbg_offset[i][j]=Double.parseDouble(properties.getProperty(prefix+"lma_dbg_offset_"+i+"_"+j));
}
......@@ -765,9 +776,11 @@ public class ImageDttParameters {
idp.lma_num_iter = this.lma_num_iter;
idp.lma_debug_level = this.lma_debug_level;
idp.lma_debug_level1 = this.lma_debug_level1;
idp.corr_var_cam = this.corr_var_cam;
idp.cm_max_normalization= this.cm_max_normalization;
idp.lma_dbg_scale= this.lma_dbg_scale;
idp.lma_dbg_offset= new double [this.lma_dbg_offset.length][];
for (int i = 0; i < idp.lma_dbg_offset.length; i++) {
idp.lma_dbg_offset[i] = this.lma_dbg_offset[i].clone();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment