Skip to content

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

redid composite passes

parent 369f2898
Hide whitespace changes
Inline Side-by-side
Showing with 799 additions and 181 deletions
src/main/java/EyesisCorrectionParameters.java
View file @ 41b267b4
...@@ -2114,6 +2114,7 @@ public class EyesisCorrectionParameters { ...@@ -2114,6 +2114,7 @@ public class EyesisCorrectionParameters {
public double stMinBgDisparity = 0.0; // Minimal backgroubnd disparity to extract as a maximum from the supertiles public double stMinBgDisparity = 0.0; // Minimal backgroubnd disparity to extract as a maximum from the supertiles
public double stMinBgFract = 0.1; // Minimal fraction of the disparity histogram to use as background public double stMinBgFract = 0.1; // Minimal fraction of the disparity histogram to use as background
public double stUseDisp = 0.15; // Use background disparity from supertiles if tile strength is less public double stUseDisp = 0.15; // Use background disparity from supertiles if tile strength is less
public double stStrengthScale = 50.0; // Multiply st strength if used instead of regular strength
public double outlayerStrength = 0.3; // Outlayer tiles weaker than this may be replaced from neighbors public double outlayerStrength = 0.3; // Outlayer tiles weaker than this may be replaced from neighbors
public double outlayerDiff = 0.4; // Replace weak outlayer tiles that do not have neighbors within this disparity difference public double outlayerDiff = 0.4; // Replace weak outlayer tiles that do not have neighbors within this disparity difference
...@@ -2123,6 +2124,8 @@ public class EyesisCorrectionParameters { ...@@ -2123,6 +2124,8 @@ public class EyesisCorrectionParameters {
// TODO: Make refine skip if already good? // TODO: Make refine skip if already good?
public boolean combine_refine = true; // combine with all previous after refine pass public boolean combine_refine = true; // combine with all previous after refine pass
public double combine_min_strength = 0.12; // Disregard weaker tiles when combining scans public double combine_min_strength = 0.12; // Disregard weaker tiles when combining scans
public double combine_min_hor = 0.12; // Disregard weaker tiles when combining scans for horizontal correlation
public double combine_min_vert = 0.12; // Disregard weaker tiles when combining scans for vertical correlation
public double unique_tolerance = 0.1; // Do not re-measure correlation if target disparity differs from some previous by this public double unique_tolerance = 0.1; // Do not re-measure correlation if target disparity differs from some previous by this
// Multi-pass growing disparity // Multi-pass growing disparity
...@@ -2337,6 +2340,7 @@ public class EyesisCorrectionParameters { ...@@ -2337,6 +2340,7 @@ public class EyesisCorrectionParameters {
properties.setProperty(prefix+"stMinBgDisparity", this.stMinBgDisparity +""); properties.setProperty(prefix+"stMinBgDisparity", this.stMinBgDisparity +"");
properties.setProperty(prefix+"stMinBgFract", this.stMinBgFract +""); properties.setProperty(prefix+"stMinBgFract", this.stMinBgFract +"");
properties.setProperty(prefix+"stUseDisp", this.stUseDisp +""); properties.setProperty(prefix+"stUseDisp", this.stUseDisp +"");
properties.setProperty(prefix+"stStrengthScale", this.stStrengthScale +"");
properties.setProperty(prefix+"outlayerStrength", this.outlayerStrength +""); properties.setProperty(prefix+"outlayerStrength", this.outlayerStrength +"");
properties.setProperty(prefix+"outlayerDiff", this.outlayerDiff +""); properties.setProperty(prefix+"outlayerDiff", this.outlayerDiff +"");
properties.setProperty(prefix+"outlayerDiffPos", this.outlayerDiffPos +""); properties.setProperty(prefix+"outlayerDiffPos", this.outlayerDiffPos +"");
...@@ -2345,6 +2349,8 @@ public class EyesisCorrectionParameters { ...@@ -2345,6 +2349,8 @@ public class EyesisCorrectionParameters {
properties.setProperty(prefix+"combine_refine", this.combine_refine+""); properties.setProperty(prefix+"combine_refine", this.combine_refine+"");
properties.setProperty(prefix+"combine_min_strength", this.combine_min_strength +""); properties.setProperty(prefix+"combine_min_strength", this.combine_min_strength +"");
properties.setProperty(prefix+"combine_min_hor", this.combine_min_hor +"");
properties.setProperty(prefix+"combine_min_vert", this.combine_min_vert +"");
properties.setProperty(prefix+"unique_tolerance", this.unique_tolerance +""); properties.setProperty(prefix+"unique_tolerance", this.unique_tolerance +"");
properties.setProperty(prefix+"grow_sweep", this.grow_sweep+""); properties.setProperty(prefix+"grow_sweep", this.grow_sweep+"");
properties.setProperty(prefix+"grow_disp_max", this.grow_disp_max +""); properties.setProperty(prefix+"grow_disp_max", this.grow_disp_max +"");
...@@ -2547,6 +2553,7 @@ public class EyesisCorrectionParameters { ...@@ -2547,6 +2553,7 @@ public class EyesisCorrectionParameters {
if (properties.getProperty(prefix+"stMinBgDisparity")!=null) this.stMinBgDisparity=Double.parseDouble(properties.getProperty(prefix+"stMinBgDisparity")); if (properties.getProperty(prefix+"stMinBgDisparity")!=null) this.stMinBgDisparity=Double.parseDouble(properties.getProperty(prefix+"stMinBgDisparity"));
if (properties.getProperty(prefix+"stMinBgFract")!=null) this.stMinBgFract=Double.parseDouble(properties.getProperty(prefix+"stMinBgFract")); if (properties.getProperty(prefix+"stMinBgFract")!=null) this.stMinBgFract=Double.parseDouble(properties.getProperty(prefix+"stMinBgFract"));
if (properties.getProperty(prefix+"stUseDisp")!=null) this.stUseDisp=Double.parseDouble(properties.getProperty(prefix+"stUseDisp")); if (properties.getProperty(prefix+"stUseDisp")!=null) this.stUseDisp=Double.parseDouble(properties.getProperty(prefix+"stUseDisp"));
if (properties.getProperty(prefix+"stStrengthScale")!=null) this.stStrengthScale=Double.parseDouble(properties.getProperty(prefix+"stStrengthScale"));
if (properties.getProperty(prefix+"outlayerStrength")!=null) this.outlayerStrength=Double.parseDouble(properties.getProperty(prefix+"outlayerStrength")); if (properties.getProperty(prefix+"outlayerStrength")!=null) this.outlayerStrength=Double.parseDouble(properties.getProperty(prefix+"outlayerStrength"));
if (properties.getProperty(prefix+"outlayerDiff")!=null) this.outlayerDiff=Double.parseDouble(properties.getProperty(prefix+"outlayerDiff")); if (properties.getProperty(prefix+"outlayerDiff")!=null) this.outlayerDiff=Double.parseDouble(properties.getProperty(prefix+"outlayerDiff"));
if (properties.getProperty(prefix+"outlayerDiffPos")!=null) this.outlayerDiffPos=Double.parseDouble(properties.getProperty(prefix+"outlayerDiffPos")); if (properties.getProperty(prefix+"outlayerDiffPos")!=null) this.outlayerDiffPos=Double.parseDouble(properties.getProperty(prefix+"outlayerDiffPos"));
...@@ -2555,6 +2562,8 @@ public class EyesisCorrectionParameters { ...@@ -2555,6 +2562,8 @@ public class EyesisCorrectionParameters {
if (properties.getProperty(prefix+"combine_refine")!=null) this.combine_refine=Boolean.parseBoolean(properties.getProperty(prefix+"combine_refine")); if (properties.getProperty(prefix+"combine_refine")!=null) this.combine_refine=Boolean.parseBoolean(properties.getProperty(prefix+"combine_refine"));
if (properties.getProperty(prefix+"combine_min_strength")!=null) this.combine_min_strength=Double.parseDouble(properties.getProperty(prefix+"combine_min_strength")); if (properties.getProperty(prefix+"combine_min_strength")!=null) this.combine_min_strength=Double.parseDouble(properties.getProperty(prefix+"combine_min_strength"));
if (properties.getProperty(prefix+"combine_min_hor")!=null) this.combine_min_hor=Double.parseDouble(properties.getProperty(prefix+"combine_min_hor"));
if (properties.getProperty(prefix+"combine_min_vert")!=null) this.combine_min_vert=Double.parseDouble(properties.getProperty(prefix+"combine_min_vert"));
if (properties.getProperty(prefix+"unique_tolerance")!=null) this.unique_tolerance=Double.parseDouble(properties.getProperty(prefix+"unique_tolerance")); if (properties.getProperty(prefix+"unique_tolerance")!=null) this.unique_tolerance=Double.parseDouble(properties.getProperty(prefix+"unique_tolerance"));
if (properties.getProperty(prefix+"grow_sweep")!=null) this.grow_sweep=Integer.parseInt(properties.getProperty(prefix+"grow_sweep")); if (properties.getProperty(prefix+"grow_sweep")!=null) this.grow_sweep=Integer.parseInt(properties.getProperty(prefix+"grow_sweep"));
if (properties.getProperty(prefix+"grow_disp_max")!=null) this.grow_disp_max=Double.parseDouble(properties.getProperty(prefix+"grow_disp_max")); if (properties.getProperty(prefix+"grow_disp_max")!=null) this.grow_disp_max=Double.parseDouble(properties.getProperty(prefix+"grow_disp_max"));
...@@ -2779,6 +2788,7 @@ public class EyesisCorrectionParameters { ...@@ -2779,6 +2788,7 @@ public class EyesisCorrectionParameters {
gd.addNumericField("Minimal backgroubnd disparity to extract as a maximum from the supertiles", this.stMinBgDisparity, 6); gd.addNumericField("Minimal backgroubnd disparity to extract as a maximum from the supertiles", this.stMinBgDisparity, 6);
gd.addNumericField("Minimal fraction of the disparity histogram to use as background", this.stMinBgFract, 6); gd.addNumericField("Minimal fraction of the disparity histogram to use as background", this.stMinBgFract, 6);
gd.addNumericField("Use background disparity from supertiles if tile strength is less", this.stUseDisp, 6); gd.addNumericField("Use background disparity from supertiles if tile strength is less", this.stUseDisp, 6);
gd.addNumericField("Multiply st strength if used instead of regular strength ", this.stStrengthScale, 6);
gd.addNumericField("Outlayer tiles weaker than this may be replaced from neighbors", this.outlayerStrength, 6); gd.addNumericField("Outlayer tiles weaker than this may be replaced from neighbors", this.outlayerStrength, 6);
gd.addNumericField("Replace weak outlayer tiles that do not have neighbors within this disparity difference", this.outlayerDiff, 6); gd.addNumericField("Replace weak outlayer tiles that do not have neighbors within this disparity difference", this.outlayerDiff, 6);
gd.addNumericField("Replace weak outlayer tiles that have higher disparity than weighted average", this.outlayerDiffPos, 6); gd.addNumericField("Replace weak outlayer tiles that have higher disparity than weighted average", this.outlayerDiffPos, 6);
...@@ -2786,6 +2796,8 @@ public class EyesisCorrectionParameters { ...@@ -2786,6 +2796,8 @@ public class EyesisCorrectionParameters {
gd.addCheckbox ("Combine with all previous after refine pass", this.combine_refine); gd.addCheckbox ("Combine with all previous after refine pass", this.combine_refine);
gd.addNumericField("Disregard weaker tiles when combining scans", this.combine_min_strength, 6); gd.addNumericField("Disregard weaker tiles when combining scans", this.combine_min_strength, 6);
gd.addNumericField("Disregard weaker tiles when combining scans for horizontal correlation", this.combine_min_hor, 6);
gd.addNumericField("Disregard weaker tiles when combining scans for vertical correlation", this.combine_min_vert, 6);
gd.addNumericField("Do not re-measure correlation if target disparity differs from some previous by this",this.unique_tolerance, 6); gd.addNumericField("Do not re-measure correlation if target disparity differs from some previous by this",this.unique_tolerance, 6);
gd.addMessage ("--- Growing disparity range to scan ---"); gd.addMessage ("--- Growing disparity range to scan ---");
...@@ -2997,6 +3009,7 @@ public class EyesisCorrectionParameters { ...@@ -2997,6 +3009,7 @@ public class EyesisCorrectionParameters {
this.stMinBgDisparity= gd.getNextNumber(); this.stMinBgDisparity= gd.getNextNumber();
this.stMinBgFract= gd.getNextNumber(); this.stMinBgFract= gd.getNextNumber();
this.stUseDisp= gd.getNextNumber(); this.stUseDisp= gd.getNextNumber();
this.stStrengthScale= gd.getNextNumber();
this.outlayerStrength= gd.getNextNumber(); this.outlayerStrength= gd.getNextNumber();
this.outlayerDiff= gd.getNextNumber(); this.outlayerDiff= gd.getNextNumber();
this.outlayerDiffPos= gd.getNextNumber(); this.outlayerDiffPos= gd.getNextNumber();
...@@ -3005,6 +3018,8 @@ public class EyesisCorrectionParameters { ...@@ -3005,6 +3018,8 @@ public class EyesisCorrectionParameters {
this.combine_refine= gd.getNextBoolean(); this.combine_refine= gd.getNextBoolean();
this.combine_min_strength= gd.getNextNumber(); this.combine_min_strength= gd.getNextNumber();
this.combine_min_hor= gd.getNextNumber();
this.combine_min_vert= gd.getNextNumber();
this.unique_tolerance= gd.getNextNumber(); this.unique_tolerance= gd.getNextNumber();
this.grow_sweep= (int) gd.getNextNumber(); this.grow_sweep= (int) gd.getNextNumber();
......
src/main/java/Eyesis_Correction.java
View file @ 41b267b4
...@@ -4665,6 +4665,8 @@ private Panel panel1, ...@@ -4665,6 +4665,8 @@ private Panel panel1,
} }
} }
QUAD_CLT.tp.resetCLTPasses(); QUAD_CLT.tp.resetCLTPasses();
QUAD_CLT.tp.setTrustedCorrelation(CLT_PARAMETERS.grow_disp_trust);
return; return;
/// ============================================ /// ============================================
......
src/main/java/QuadCLT.java
View file @ 41b267b4
...@@ -64,6 +64,7 @@ public class QuadCLT { ...@@ -64,6 +64,7 @@ public class QuadCLT {
clt_parameters.transform_size, clt_parameters.transform_size,
clt_parameters.stSize, clt_parameters.stSize,
clt_parameters.corr_magic_scale, clt_parameters.corr_magic_scale,
clt_parameters.grow_disp_trust,
threadsMax); threadsMax);
} }
} }
...@@ -4714,6 +4715,7 @@ public class QuadCLT { ...@@ -4714,6 +4715,7 @@ public class QuadCLT {
clt_parameters, clt_parameters,
threadsMax); threadsMax);
tp.resetCLTPasses(); tp.resetCLTPasses();
tp.setTrustedCorrelation(clt_parameters.grow_disp_trust);
final int tilesX = tp.getTilesX(); final int tilesX = tp.getTilesX();
final int tilesY = tp.getTilesY(); final int tilesY = tp.getTilesY();
...@@ -4773,7 +4775,7 @@ public class QuadCLT { ...@@ -4773,7 +4775,7 @@ public class QuadCLT {
int [] numLeftRemoved = tp.makeUnique( int [] numLeftRemoved = tp.makeUnique(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes, tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
0, // final int firstPass, 0, // final int firstPass,
refine_pass - 1, // final int lastPassPlus1, refine_pass, // - 1, // final int lastPassPlus1,
tp.clt_3d_passes.get(refine_pass), // final CLTPass3d new_scan, tp.clt_3d_passes.get(refine_pass), // final CLTPass3d new_scan,
clt_parameters.unique_tolerance, // final double unique_tolerance, clt_parameters.unique_tolerance, // final double unique_tolerance,
clt_parameters.show_unique); // final boolean show_unique) clt_parameters.show_unique); // final boolean show_unique)
...@@ -4794,23 +4796,166 @@ public class QuadCLT { ...@@ -4794,23 +4796,166 @@ public class QuadCLT {
} }
if (clt_parameters.combine_refine){ if (clt_parameters.combine_refine){
// TileProcessor.CLTPass3d scan = tp.clt_3d_passes.get(scanIndex); TileProcessor.CLTPass3d combo_pass = tp.compositeScan(
TileProcessor.CLTPass3d combo_pass = tp.combinePasses(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes, tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
bg_pass, // final int firstPass, bg_pass, // final int firstPass,
tp.clt_3d_passes.size(), // final int lastPassPlus1, tp.clt_3d_passes.size(), // final int lastPassPlus1,
true, // skip_combo, // do not process other combo scans tp.getTrustedCorrelation(), // final double trustedCorrelation,
true, // final boolean use_last, // use last scan data if nothing better 0.0, // clt_parameters.bgnd_range, // final double disp_far, // limit results to the disparity range
false, // not calculated yet! true, // final boolean useCombo, // use combined disparity/strength (false - use measured full correlation clt_parameters.grow_disp_max, // final double disp_near,
false, // final boolean usePoly, // use polynomial method to find max), valid if useCombo == false clt_parameters.combine_min_strength, // final double minStrength,
clt_parameters.combine_min_strength, // final double minStrength, // ignore too weak tiles clt_parameters.combine_min_hor, // final double minStrengthHor,
clt_parameters.show_combined); clt_parameters.combine_min_vert, // final double minStrengthVert,
false, // final boolean use_last, //
// TODO: when useCombo - pay attention to borders (disregard)
false); // final boolean usePoly) // use polynomial method to find max), valid if useCombo == false
tp.showScan(
combo_pass, // CLTPass3d scan,
"after_compositeScan-"+tp.clt_3d_passes.size());
tp.clt_3d_passes.add(combo_pass); tp.clt_3d_passes.add(combo_pass);
// refine_pass = tp.clt_3d_passes.size(); // refine_pass = tp.clt_3d_passes.size();
} }
} }
// process once more to try combining of processed // above - multiple refinements (reduce, make conditional?)
int num_extended = -1;
int [] numLeftRemoved;
// process once more to try combining of processed
for (int num_expand = 0; (num_expand < 2) && (num_extended != 0); num_expand++) {
refine_pass = tp.clt_3d_passes.size(); // 1
tp.refinePassSetup( // prepare tile tasks for the refine pass (re-measure disparities)
// final double [][][] image_data, // first index - number of image in a quad
clt_parameters,
clt_parameters.stUseRefine, // use supertiles
bg_pass,
// disparity range - differences from
clt_parameters.bgnd_range, // double disparity_far,
clt_parameters.grow_disp_max, // other_range, //double disparity_near, //
clt_parameters.bgnd_sure, // double this_sure, // minimal strength to be considered definitely background
clt_parameters.bgnd_maybe, // double this_maybe, // maximal strength to ignore as non-background
clt_parameters.sure_smth, // sure_smth, // if 2-nd worst image difference (noise-normalized) exceeds this - do not propagate bgnd
ImageDtt.DISPARITY_INDEX_CM, // index of disparity value in disparity_map == 2 (0,2 or 4)
geometryCorrection,
threadsMax, // maximal number of threads to launch
updateStatus,
debugLevel);
tp.showScan(
tp.clt_3d_passes.get(refine_pass), // CLTPass3d scan,
"after_refine-"+refine_pass);
tp.calcMaxTried(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
bg_pass, // final int firstPass,
refine_pass, // may add 1 to include current (for future?) // final int lastPassPlus1,
tp.clt_3d_passes.get(refine_pass)); // final int lastPassPlus1,
TileProcessor.CLTPass3d extended_pass = tp.compositeScan(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
bg_pass, // final int firstPass,
tp.clt_3d_passes.size(), // final int lastPassPlus1,
tp.getTrustedCorrelation(), // final double trustedCorrelation,
0.0, // clt_parameters.bgnd_range, // final double disp_far, // limit results to the disparity range
clt_parameters.grow_disp_max, // final double disp_near,
clt_parameters.combine_min_strength, // final double minStrength,
clt_parameters.combine_min_hor, // final double minStrengthHor,
clt_parameters.combine_min_vert, // final double minStrengthVert,
true, // false, // final boolean use_last, //
// TODO: when useCombo - pay attention to borders (disregard)
false); // final boolean usePoly) // use polynomial method to find max), valid if useCombo == false
tp.showScan(
tp.clt_3d_passes.get(refine_pass), // CLTPass3d scan,
"after_refine-combine-"+(tp.clt_3d_passes.size() - 1));
num_extended = tp.setupExtendDisparity(
extended_pass, // final CLTPass3d scan, // combined scan with max_tried_disparity, will be modified to re-scan
tp.clt_3d_passes.get(refine_pass), // final CLTPass3d last_scan, // last prepared tile - can use last_scan.disparity, .border_tiles and .selected
tp.clt_3d_passes.get(bg_pass), // final CLTPass3d bg_scan, // background scan data
clt_parameters.grow_sweep, // 8; // Try these number of tiles around known ones
clt_parameters.grow_disp_max, // = 50.0; // Maximal disparity to try
0.5 * clt_parameters.grow_disp_trust, // = 4.0; // Trust measured disparity within +/- this value
clt_parameters.grow_disp_step, // = 6.0; // Increase disparity (from maximal tried) if nothing found in that tile // TODO: handle enclosed dips?
clt_parameters.grow_min_diff, // = 0.5; // Grow more only if at least one channel has higher variance from others for the tile
clt_parameters, // EyesisCorrectionParameters.CLTParameters clt_parameters,
geometryCorrection, // GeometryCorrection geometryCorrection,
true, // final boolean show_debug,
threadsMax, // maximal number of threads to launch
updateStatus,
debugLevel);
//TODO: break if nothing wanted? - no, there are some left to be refined
refine_pass = tp.clt_3d_passes.size(); // 1
tp.clt_3d_passes.add(extended_pass);
numLeftRemoved = tp.makeUnique(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
0, // final int firstPass,
refine_pass, // - 1, // final int lastPassPlus1,
tp.clt_3d_passes.get(refine_pass), // final CLTPass3d new_scan,
clt_parameters.unique_tolerance, // final double unique_tolerance,
clt_parameters.show_unique); // final boolean show_unique)
tp.showScan(
tp.clt_3d_passes.get(refine_pass), // CLTPass3d scan,
"before_measure-"+refine_pass); //String title)
if (debugLevel > -1){
System.out.println("last makeUnique("+refine_pass+") -> left: "+numLeftRemoved[0]+", removed:" + numLeftRemoved[1]);
}
//TODO: break if nothing wanted? - here yes, will make sens
// refine_pass = tp.clt_3d_passes.size(); //
CLTMeasure( // perform single pass according to prepared tiles operations and disparity
image_data, // first index - number of image in a quad
clt_parameters,
refine_pass,
threadsMax, // maximal number of threads to launch
updateStatus,
debugLevel);
tp.showScan(
tp.clt_3d_passes.get(refine_pass), // CLTPass3d scan,
"after_measure-"+refine_pass); //String title)
if (debugLevel > -1){
System.out.println("extending: CLTMeasure("+refine_pass+")");
}
TileProcessor.CLTPass3d combo_pass = tp.compositeScan(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
bg_pass, // final int firstPass,
tp.clt_3d_passes.size(), // final int lastPassPlus1,
tp.getTrustedCorrelation(), // final double trustedCorrelation,
0.0, // clt_parameters.bgnd_range, // final double disp_far, // limit results to the disparity range
clt_parameters.grow_disp_max, // final double disp_near,
clt_parameters.combine_min_strength, // final double minStrength,
clt_parameters.combine_min_hor, // final double minStrengthHor,
clt_parameters.combine_min_vert, // final double minStrengthVert,
false, // final boolean use_last, //
// TODO: when useCombo - pay attention to borders (disregard)
false); // final boolean usePoly) // use polynomial method to find max), valid if useCombo == false
tp.clt_3d_passes.add(combo_pass);
// refine_pass = tp.clt_3d_passes.size();
// }
tp.showScan(
tp.clt_3d_passes.get(refine_pass), // CLTPass3d scan,
"after_combo_pass-"+(tp.clt_3d_passes.size()-1)); //String title)
}
refine_pass = tp.clt_3d_passes.size(); // 1 refine_pass = tp.clt_3d_passes.size(); // 1
// Refine after extension
tp.refinePassSetup( // prepare tile tasks for the refine pass (re-measure disparities) tp.refinePassSetup( // prepare tile tasks for the refine pass (re-measure disparities)
// final double [][][] image_data, // first index - number of image in a quad // final double [][][] image_data, // first index - number of image in a quad
clt_parameters, clt_parameters,
...@@ -4826,123 +4971,34 @@ public class QuadCLT { ...@@ -4826,123 +4971,34 @@ public class QuadCLT {
geometryCorrection, geometryCorrection,
threadsMax, // maximal number of threads to launch threadsMax, // maximal number of threads to launch
updateStatus, updateStatus,
debugLevel); debugLevel); // 2); // debugLevel);
numLeftRemoved = tp.makeUnique(
TileProcessor.CLTPass3d extended_pass = tp.combinePasses(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
bg_pass, // final int firstPass,
tp.clt_3d_passes.size(), // final int lastPassPlus1,
false, // skip_combo, // do not process other combo scans
true, // final boolean use_last, // use last scan data if nothing better
true, // not calculated yet! true, // final boolean useCombo, // use combined disparity/strength (false - use measured full correlation
false, // final boolean usePoly, // use polynomial method to find max), valid if useCombo == false
clt_parameters.combine_min_strength, // final double minStrength, // ignore too weak tiles
true); // clt_parameters.show_combined);
tp.setupExtendDisparity(
extended_pass, // final CLTPass3d scan, // combined scan with max_tried_disparity, will be modified to re-scan
tp.clt_3d_passes.get(refine_pass), // final CLTPass3d last_scan, // last prepared tile - can use last_scan.disparity, .border_tiles and .selected
tp.clt_3d_passes.get(bg_pass), // final CLTPass3d bg_scan, // background scan data
clt_parameters.grow_sweep, // 8; // Try these number of tiles around known ones
clt_parameters.grow_disp_max, // = 50.0; // Maximal disparity to try
clt_parameters.grow_disp_trust, // = 4.0; // Trust measured disparity within +/- this value
clt_parameters.grow_disp_step, // = 6.0; // Increase disparity (from maximal tried) if nothing found in that tile // TODO: handle enclosed dips?
clt_parameters.grow_min_diff, // = 0.5; // Grow more only if at least one channel has higher variance from others for the tile
clt_parameters, // EyesisCorrectionParameters.CLTParameters clt_parameters,
geometryCorrection, // GeometryCorrection geometryCorrection,
true, // final boolean show_debug,
threadsMax, // maximal number of threads to launch
updateStatus,
debugLevel);
refine_pass = tp.clt_3d_passes.size(); // 1
tp.clt_3d_passes.add(extended_pass);
int [] numLeftRemoved = tp.makeUnique(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes, tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
0, // final int firstPass, 0, // final int firstPass,
refine_pass - 1, // final int lastPassPlus1, refine_pass, // - 1, // final int lastPassPlus1,
tp.clt_3d_passes.get(refine_pass), // final CLTPass3d new_scan, tp.clt_3d_passes.get(refine_pass), // final CLTPass3d new_scan,
clt_parameters.unique_tolerance, // final double unique_tolerance, clt_parameters.unique_tolerance, // final double unique_tolerance,
clt_parameters.show_unique); // final boolean show_unique) clt_parameters.show_unique); // final boolean show_unique)
if (debugLevel > -1){ if (debugLevel > -1){
System.out.println("last makeUnique("+refine_pass+") -> left: "+numLeftRemoved[0]+", removed:" + numLeftRemoved[1]); System.out.println("makeUnique("+refine_pass+") -> left: "+numLeftRemoved[0]+", removed:" + numLeftRemoved[1]);
} }
// refine_pass = tp.clt_3d_passes.size(); //
CLTMeasure( // perform single pass according to prepared tiles operations and disparity
image_data, // first index - number of image in a quad
clt_parameters,
refine_pass,
threadsMax, // maximal number of threads to launch
updateStatus,
debugLevel);
if (debugLevel > -1){
System.out.println("extending: CLTMeasure("+refine_pass+")");
}
if (clt_parameters.combine_refine){
// TileProcessor.CLTPass3d scan = tp.clt_3d_passes.get(scanIndex);
TileProcessor.CLTPass3d combo_pass = tp.combinePasses( // TEMPORARY EXIT
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
bg_pass, // final int firstPass, if (tp.clt_3d_passes.size() > 0) return null; // just to fool compiler
tp.clt_3d_passes.size(), // final int lastPassPlus1,
true, // skip_combo, // do not process other combo scans
true, // final boolean use_last, // use last scan data if nothing better // testing 2-nd pass
false, // not calculated yet! true, // final boolean useCombo, // use combined disparity/strength (false - use measured full correlation
false, // final boolean usePoly, // use polynomial method to find max), valid if useCombo == false
clt_parameters.combine_min_strength, // final double minStrength, // ignore too weak tiles
clt_parameters.show_combined);
tp.clt_3d_passes.add(combo_pass);
// refine_pass = tp.clt_3d_passes.size();
}
refine_pass = tp.clt_3d_passes.size(); // 1
// Refine after extension
tp.refinePassSetup( // prepare tile tasks for the refine pass (re-measure disparities)
// final double [][][] image_data, // first index - number of image in a quad
clt_parameters,
clt_parameters.stUseRefine, // use supertiles
bg_pass,
// disparity range - differences from
clt_parameters.bgnd_range, // double disparity_far,
clt_parameters.grow_disp_max, // other_range, //double disparity_near, //
clt_parameters.bgnd_sure, // double this_sure, // minimal strength to be considered definitely background
clt_parameters.bgnd_maybe, // double this_maybe, // maximal strength to ignore as non-background
clt_parameters.sure_smth, // sure_smth, // if 2-nd worst image difference (noise-normalized) exceeds this - do not propagate bgnd
ImageDtt.DISPARITY_INDEX_CM, // index of disparity value in disparity_map == 2 (0,2 or 4)
geometryCorrection,
threadsMax, // maximal number of threads to launch
updateStatus,
2); // debugLevel);
numLeftRemoved = tp.makeUnique(
tp.clt_3d_passes, // final ArrayList <CLTPass3d> passes,
0, // final int firstPass,
refine_pass - 1, // final int lastPassPlus1,
tp.clt_3d_passes.get(refine_pass), // final CLTPass3d new_scan,
clt_parameters.unique_tolerance, // final double unique_tolerance,
clt_parameters.show_unique); // final boolean show_unique)
if (debugLevel > -1){
System.out.println("makeUnique("+refine_pass+") -> left: "+numLeftRemoved[0]+", removed:" + numLeftRemoved[1]);
}
// TEMPORARY EXIT
if (tp.clt_3d_passes.size() > 0) return null; // just to fool compiler
// testing 2-nd pass
int next_pass = tp.clt_3d_passes.size(); // 2 int next_pass = tp.clt_3d_passes.size(); // 2
tp.secondPassSetup( // prepare tile tasks for the second pass based on the previous one(s) tp.secondPassSetup( // prepare tile tasks for the second pass based on the previous one(s)
// final double [][][] image_data, // first index - number of image in a quad // final double [][][] image_data, // first index - number of image in a quad
clt_parameters, clt_parameters,
clt_parameters.stUsePass2, // use supertiles clt_parameters.stUsePass2, // use supertiles
bg_pass, bg_pass,
// disparity range - differences from // disparity range - differences from
clt_parameters.bgnd_range, // double disparity_far, clt_parameters.bgnd_range, // double disparity_far,
clt_parameters.grow_disp_max, // other_range, //double disparity_near, // clt_parameters.grow_disp_max, // other_range, //double disparity_near, //
......
src/main/java/TileProcessor.java
View file @ 41b267b4
...@@ -31,9 +31,10 @@ public class TileProcessor { ...@@ -31,9 +31,10 @@ public class TileProcessor {
public ArrayList <CLTPass3d> clt_3d_passes = null; public ArrayList <CLTPass3d> clt_3d_passes = null;
private int tilesX; private int tilesX;
private int tilesY; private int tilesY;
private double corr_magic_scale = 0.85; // reported correlation offset vs. actual one (not yet understood) private double corr_magic_scale = 0.85; // reported correlation offset vs. actual one (not yet understood)
private double trustedCorrelation = 4.0; // trusted measured disparity difference (before scaling)
private int tileSize = 8; // number of linear pixels in a tile (tile is square tileSize*tileSize) private int tileSize = 8; // number of linear pixels in a tile (tile is square tileSize*tileSize)
private int superTileSize = 8; // number of linear tiles in a super-tile (supretile is square superTileSize*superTileSize tiles private int superTileSize = 8; // number of linear tiles in a super-tile (supertile is square superTileSize*superTileSize tiles
// or (superTileSize*tileSize) * (superTileSize*tileSize) pixels, currently 64x64 pixels) // or (superTileSize*tileSize) * (superTileSize*tileSize) pixels, currently 64x64 pixels)
public int threadsMax = 100; // maximal number of frames to run public int threadsMax = 100; // maximal number of frames to run
public int globalDebugLevel = 0; public int globalDebugLevel = 0;
...@@ -46,6 +47,7 @@ public class TileProcessor { ...@@ -46,6 +47,7 @@ public class TileProcessor {
int tileSize, int tileSize,
int superTileSize, int superTileSize,
double scale, double scale,
double trustedCorrelation,
int threadsMax) int threadsMax)
{ {
this.tilesX = tilesX; this.tilesX = tilesX;
...@@ -53,15 +55,24 @@ public class TileProcessor { ...@@ -53,15 +55,24 @@ public class TileProcessor {
this.tileSize = tileSize; this.tileSize = tileSize;
this.superTileSize = superTileSize; this.superTileSize = superTileSize;
this.corr_magic_scale = scale; this.corr_magic_scale = scale;
this.trustedCorrelation = trustedCorrelation;
this.threadsMax = threadsMax; this.threadsMax = threadsMax;
} }
public int getTilesX() {return tilesX;}; public int getTilesX() {return tilesX;};
public int getTilesY() {return tilesY;}; public int getTilesY() {return tilesY;};
public void setTrustedCorrelation(double trustedCorrelation)
public void setMagicScale (double scale)
{ {
this.corr_magic_scale = scale; this.trustedCorrelation = trustedCorrelation;
} }
public double getTrustedCorrelation()
{
return this.trustedCorrelation;
}
// public void setMagicScale (double scale)
// {
// this.corr_magic_scale = scale;
// }
public class CLTPass3d{ public class CLTPass3d{
public double [][] disparity; // per-tile disparity set for the pass[tileY][tileX] public double [][] disparity; // per-tile disparity set for the pass[tileY][tileX]
public int [][] tile_op; // what was done in the current pass public int [][] tile_op; // what was done in the current pass
...@@ -117,7 +128,7 @@ public class TileProcessor { ...@@ -117,7 +128,7 @@ public class TileProcessor {
} }
public boolean isMeasured(){ public boolean isMeasured(){
return disparity_map != null; return (disparity_map != null) && (disparity != null); // disparity == null for composite scans
} }
public boolean isCombo(){ public boolean isCombo(){
...@@ -168,6 +179,8 @@ public class TileProcessor { ...@@ -168,6 +179,8 @@ public class TileProcessor {
} }
public double [] combineSuper( public double [] combineSuper(
boolean updateStrength, // use ST strength if true, keep original (update disparity only) if false
double stStrengthScale,
double useSuper){ double useSuper){
if (bgTileDisparity == null) { // no supertile disparity is available if (bgTileDisparity == null) { // no supertile disparity is available
return null; return null;
...@@ -177,7 +190,10 @@ public class TileProcessor { ...@@ -177,7 +190,10 @@ public class TileProcessor {
double [] disparity = getDisparity(0); double [] disparity = getDisparity(0);
for (int i = 0; i < disparity.length; i++){ for (int i = 0; i < disparity.length; i++){
if (strength[i] < useSuper) disparity[i] = bgTileDisparity[i]; if (strength[i] < useSuper) {
disparity[i] = bgTileDisparity[i];
if (updateStrength) strength[i] = stStrengthScale*bgTileStrength[i];
}
} }
return disparity; return disparity;
} }
...@@ -191,6 +207,11 @@ public class TileProcessor { ...@@ -191,6 +207,11 @@ public class TileProcessor {
public double [] getStrength(){ public double [] getStrength(){
if (strength == null){ if (strength == null){
strength = disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX].clone(); strength = disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX].clone();
if (trustedCorrelation > 0.0){
for (int i = 0; i < strength.length; i++){
if (Math.abs(disparity_map[disparity_index][i]) > trustedCorrelation) strength[i] = 0.0; // too far
}
}
} }
return strength; return strength;
} }
...@@ -208,6 +229,11 @@ public class TileProcessor { ...@@ -208,6 +229,11 @@ public class TileProcessor {
public double [] getHorStrength(){ public double [] getHorStrength(){
if (strength_hor == null) { if (strength_hor == null) {
strength_hor = disparity_map[ImageDtt.DISPARITY_INDEX_HOR_STRENGTH].clone(); strength_hor = disparity_map[ImageDtt.DISPARITY_INDEX_HOR_STRENGTH].clone();
if (trustedCorrelation > 0.0){
for (int i = 0; i < strength_hor.length; i++){
if (Math.abs(disparity_map[ImageDtt.DISPARITY_INDEX_HOR][i]) > trustedCorrelation) strength_hor[i] = 0.0; // too far
}
}
} }
return strength_hor; return strength_hor;
} }
...@@ -218,6 +244,12 @@ public class TileProcessor { ...@@ -218,6 +244,12 @@ public class TileProcessor {
public double [] getVertStrength(){ public double [] getVertStrength(){
if (strength_vert == null) { if (strength_vert == null) {
strength_vert = disparity_map[ImageDtt.DISPARITY_INDEX_VERT_STRENGTH].clone(); strength_vert = disparity_map[ImageDtt.DISPARITY_INDEX_VERT_STRENGTH].clone();
if (trustedCorrelation > 0.0){
for (int i = 0; i < strength_vert.length; i++){
if (Math.abs(disparity_map[ImageDtt.DISPARITY_INDEX_VERT][i]) > trustedCorrelation) strength_vert[i] = 0.0; // too far
}
}
} }
return strength_vert; return strength_vert;
} }
...@@ -247,7 +279,8 @@ public class TileProcessor { ...@@ -247,7 +279,8 @@ public class TileProcessor {
case 1: return calc_disparity; case 1: return calc_disparity;
case 2: return calc_disparity_hor; case 2: return calc_disparity_hor;
case 3: return calc_disparity_vert; case 3: return calc_disparity_vert;
default: return calc_disparity_combo; default: if (calc_disparity_combo == null) calc_disparity_combo = calc_disparity.clone();
return calc_disparity_combo;
} }
} }
...@@ -292,7 +325,8 @@ public class TileProcessor { ...@@ -292,7 +325,8 @@ public class TileProcessor {
final double maxDiffPos, // Replace weak outlayer tiles that have higher disparity than weighted average final double maxDiffPos, // Replace weak outlayer tiles that have higher disparity than weighted average
final double maxDiffNeg, // Replace weak outlayer tiles that have lower disparity than weighted average final double maxDiffNeg, // Replace weak outlayer tiles that have lower disparity than weighted average
final double disparityFar, final double disparityFar,
final double disparityNear) final double disparityNear,
final int debugLevel)
{ {
final int nTiles = tilesX*tilesY; final int nTiles = tilesX*tilesY;
final boolean [] weakOutlayers = new boolean [nTiles]; final boolean [] weakOutlayers = new boolean [nTiles];
...@@ -302,7 +336,7 @@ public class TileProcessor { ...@@ -302,7 +336,7 @@ public class TileProcessor {
final double [] strength = getStrength(); final double [] strength = getStrength();
final double absMinDisparity = 0.5 * disparityFar; // adjust? below this is definitely wrong (weak) final double absMinDisparity = 0.5 * disparityFar; // adjust? below this is definitely wrong (weak)
final double absMaxDisparity = 1.5 * disparityNear; // change? final double absMaxDisparity = 1.5 * disparityNear; // change?
final int dbg_nTile = 42228; // x = 108, y = 130 46462; // 41545; final int dbg_nTile = (debugLevel > 0) ? 43493: -1; // x=77,y=134; // 42228; // x = 108, y = 130 46462; // 41545;
final Thread[] threads = ImageDtt.newThreadArray(threadsMax); final Thread[] threads = ImageDtt.newThreadArray(threadsMax);
// first pass = find outlayers // first pass = find outlayers
final AtomicInteger ai = new AtomicInteger(0); final AtomicInteger ai = new AtomicInteger(0);
...@@ -1148,8 +1182,6 @@ public class TileProcessor { ...@@ -1148,8 +1182,6 @@ public class TileProcessor {
clt_3d_passes = new ArrayList<CLTPass3d>(); clt_3d_passes = new ArrayList<CLTPass3d>();
} }
/** /**
* Basic combining: find smallest residual disparity and use the tile data from it * Basic combining: find smallest residual disparity and use the tile data from it
* Copy link to texture tile from the same pass, "forced" bit in tile_op is copied too * Copy link to texture tile from the same pass, "forced" bit in tile_op is copied too
...@@ -1163,13 +1195,13 @@ public class TileProcessor { ...@@ -1163,13 +1195,13 @@ public class TileProcessor {
* @param debugLevel debug level * @param debugLevel debug level
* @return combined pass, contains same data as after the measuremnt of the actual one * @return combined pass, contains same data as after the measuremnt of the actual one
*/ */
public CLTPass3d combinePasses( public CLTPass3d combinePassesOld(
final ArrayList <CLTPass3d> passes, final ArrayList <CLTPass3d> passes,
final int firstPass, final int firstPass,
final int lastPassPlus1, final int lastPassPlus1,
final boolean skip_combo, // do not process other combo scans final boolean skip_combo, // do not process other combo scans
final boolean use_last, // use last scan data if nothing better final boolean use_last, // use last scan data if nothing better
final boolean useCombo, // use combined disparity/strength (false - use measured full correlation final boolean useCalc, // use calculated combined disparity/strength (false - use measured full correlation
// TODO: when useCombo - pay attention to borders (disregard) // TODO: when useCombo - pay attention to borders (disregard)
final boolean usePoly, // use polynomial method to find max), valid if useCombo == false final boolean usePoly, // use polynomial method to find max), valid if useCombo == false
...@@ -1216,30 +1248,40 @@ public class TileProcessor { ...@@ -1216,30 +1248,40 @@ public class TileProcessor {
int nt = ty * tilesX + tx; int nt = ty * tilesX + tx;
int best_index = -1; int best_index = -1;
int best_weak_index = -1; int best_weak_index = -1;
// for "strong" result (above minStrength) the best fit is with smallest residual disparity
// for weak ones - the strongest.
// TODO: handle ortho (if requested so)
// after refine - use last, after extend - use strongest of all
double adiff_best = Double.NaN; double adiff_best = Double.NaN;
double adiff_best_weak = Double.NaN; // double adiff_best_weak = Double.NaN;
combo_pass.max_tried_disparity[ty][tx] = 0.0; double strongest_weak = 0.0;
if (useCombo && (nt == dbg_tile)){ combo_pass.max_tried_disparity[ty][tx] = Double.NaN;
System.out.println("combinePasses(): nt = "+nt+", tx = "+tx+", ty = "+ty+", useCombo = "+useCombo); if (useCalc && (nt == dbg_tile)){
System.out.println("combinePasses(): nt = "+nt+", tx = "+tx+", ty = "+ty+", useCalc = "+useCalc);
} }
for (int ipass = firstPass; ipass <lastPassPlus1; ipass++ ){ for (int ipass = firstPass; ipass <lastPassPlus1; ipass++ ){
CLTPass3d pass = passes.get(ipass); CLTPass3d pass = passes.get(ipass);
if (useCombo && (nt == dbg_tile)) { if (useCalc && (nt == dbg_tile)) {
System.out.println("combinePasses(): ipass = "+ipass+" nt = "+nt+" pass.tile_op["+ty+"]["+tx+"]="+pass.tile_op[ty][tx]+ System.out.println("combinePasses(): ipass = "+ipass+" nt = "+nt+" pass.tile_op["+ty+"]["+tx+"]="+pass.tile_op[ty][tx]+
" pass.isCombo()="+(pass.isCombo())+" pass.isProcessed()="+(pass.isProcessed())); " pass.isCombo()="+(pass.isCombo())+" pass.isProcessed()="+(pass.isProcessed()));
} }
if ( (pass.tile_op[ty][tx] != 0) && if ( // (pass.tile_op[ty][tx] != 0) && // only for measured passes?
(useCombo ? pass.isProcessed() : pass.isMeasured()) && (useCalc ? pass.isProcessed() : (pass.isMeasured() )) &&
!(skip_combo && pass.isCombo())){ !(skip_combo && pass.isCombo())){
if (pass.disparity[ty][tx] > combo_pass.max_tried_disparity[ty][tx]) combo_pass.max_tried_disparity[ty][tx] = pass.disparity[ty][tx]; if (pass.isMeasured() &&
if (!useCombo || pass.isProcessed()) { (Double.isNaN(combo_pass.max_tried_disparity[ty][tx]) ||
(pass.disparity[ty][tx] > combo_pass.max_tried_disparity[ty][tx]))){
combo_pass.max_tried_disparity[ty][tx] = pass.disparity[ty][tx];
}
if (!useCalc || pass.isProcessed()) {
double adiff, strength; double adiff, strength;
if (useCombo && (nt == dbg_tile)){ if (useCalc && (nt == dbg_tile)){
System.out.println("combinePasses(): pass.calc_disparity["+nt+"]="+pass.calc_disparity[nt]+ System.out.println("combinePasses(): pass.calc_disparity["+nt+"]="+pass.calc_disparity[nt]+
" pass.disparity["+ty+"]["+tx+"] = "+pass.disparity[ty][tx]); " pass.disparity["+ty+"]["+tx+"] = "+pass.disparity[ty][tx]);
} }
if (useCombo) { // compare difference between preset disparity and the combined one if (useCalc) { // compare difference between preset disparity and the combined one
adiff = Math.abs(pass.calc_disparity[nt] - pass.disparity[ty][tx]); adiff = Math.abs(pass.calc_disparity[nt] - pass.disparity[ty][tx]);
strength = pass.strength[nt]; strength = pass.strength[nt];
} else if (usePoly) { // just an amplitude of the polynomial maximum calculated disparity } else if (usePoly) { // just an amplitude of the polynomial maximum calculated disparity
...@@ -1251,9 +1293,9 @@ public class TileProcessor { ...@@ -1251,9 +1293,9 @@ public class TileProcessor {
} }
if ((strength > 0.0) && if ((strength > 0.0) &&
!Double.isNaN(adiff) && !Double.isNaN(adiff) &&
((best_weak_index < 0) || (adiff < adiff_best_weak))) { ((best_weak_index < 0) || (strongest_weak < strength))) {
best_weak_index = ipass; best_weak_index = ipass;
adiff_best_weak = adiff; strongest_weak = strength;
} }
if ((strength > minStrength) && if ((strength > minStrength) &&
!Double.isNaN(adiff) && !Double.isNaN(adiff) &&
...@@ -1261,17 +1303,19 @@ public class TileProcessor { ...@@ -1261,17 +1303,19 @@ public class TileProcessor {
best_index = ipass; best_index = ipass;
adiff_best = adiff; adiff_best = adiff;
} }
if (useCombo && (nt == dbg_tile)){ if (useCalc && (nt == dbg_tile)){
System.out.println("combinePasses(): strength="+strength+" best_weak_index="+best_weak_index+ System.out.println("combinePasses(): strength="+strength+" best_weak_index="+best_weak_index+
" best_index="+best_index+" adiff_best="+adiff_best+" ipass="+ipass+"adiff="+adiff); " best_index="+best_index+" adiff_best="+adiff_best+" ipass="+ipass+"adiff="+adiff);
} }
} }
} }
} }
if (use_last && (best_index < 0)) { if (best_index < 0) {
CLTPass3d pass = passes.get(lastPassPlus1 - 1); if (use_last && (passes.get(lastPassPlus1 - 1).tile_op[ty][tx] != 0)) { // last is prevferred and has some data
if (pass.tile_op[ty][tx] !=0 ) best_index = lastPassPlus1 - 1; best_index = lastPassPlus1 - 1;
else if (best_weak_index >= 0) best_index = best_weak_index; } else { // just use result with strongest correlation
best_index = best_weak_index;
}
} }
if (best_index >= 0){ if (best_index >= 0){
CLTPass3d pass = passes.get(best_index); CLTPass3d pass = passes.get(best_index);
...@@ -1311,6 +1355,405 @@ public class TileProcessor { ...@@ -1311,6 +1355,405 @@ public class TileProcessor {
return combo_pass; return combo_pass;
} }
/**
* Basic combining: find smallest residual disparity and use the tile data from it
* Copy link to texture tile from the same pass, "forced" bit in tile_op is copied too
* Even when this method compares calculated values, it still only copies raw ones, all derivatives should
* be re-calculated for the new combined pass
*
* Calculates max_tried_disparity that shows maximal tried dieparity for each tile, regardless of the reulsts/strength
* @param passes list of passes to merge
* @param firstPass first index in the list to use
* @param lastPass last index in the list to use
* @param debugLevel debug level
* @return combined pass, contains same data as after the measuremnt of the actual one
*/
public CLTPass3d combinePasses(
final ArrayList <CLTPass3d> passes,
final int firstPass,
final int lastPassPlus1,
final boolean skip_combo, // do not process other combo scans
final boolean use_last, // use last scan data if nothing better
// TODO: when useCombo - pay attention to borders (disregard)
final boolean usePoly, // use polynomial method to find max), valid if useCombo == false
final double minStrength, // ignore too weak tiles
final boolean show_combined)
{
CLTPass3d combo_pass = new CLTPass3d();
final int tlen = tilesX * tilesY;
combo_pass.disparity = new double [tilesY][tilesX];
combo_pass.tile_op = new int [tilesY][tilesX];
combo_pass.disparity_map = new double [ImageDtt.DISPARITY_TITLES.length][tlen];
combo_pass.texture_tiles = new double [tilesY][tilesX][][];
combo_pass.max_tried_disparity = new double [tilesY][tilesX];
combo_pass.is_combo = true;
showDoubleFloatArrays sdfa_instance = null;
String[] titles = null;
int dbg_tile = -1; // 27669;
double [][] dbg_data = null;
if (show_combined) {
sdfa_instance = new showDoubleFloatArrays(); // just for debugging?
int numScans = lastPassPlus1 - firstPass;
titles = new String [3 * (numScans + 1) + 1];
dbg_data = new double [titles.length][tlen];
for (int i = 0; i < numScans; i++) {
CLTPass3d dbg_pass = passes.get(firstPass + i);
if (dbg_pass.disparity_map != null) {
for (int ty = 0; ty < tilesY; ty++) for (int tx = 0; tx < tilesX; tx++){
int nt = ty * tilesX +tx;
dbg_data[i ][nt] = dbg_pass.disparity[ty][tx];
dbg_data[i + 1 * (numScans + 1)][nt] = dbg_pass.disparity_map[ImageDtt.DISPARITY_INDEX_CM][nt];
dbg_data[i + 2 * (numScans + 1)][nt] = dbg_pass.disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX][nt];
}
titles[i ] = "disparity_"+i;
titles[i + 1 * (numScans + 1)] = "cm_disparity_"+i;
titles[i + 2 * (numScans + 1)] = "strength_"+i;
}
}
}
for (int ty = 0; ty < tilesY; ty ++) for (int tx = 0; tx < tilesX; tx ++) combo_pass.texture_tiles[ty][tx] = null;
for (int ty = 0; ty < tilesY; ty ++) {
for (int tx = 0; tx < tilesX; tx ++){
int nt = ty * tilesX + tx;
int best_index = -1;
int best_weak_index = -1;
// for "strong" result (above minStrength) the best fit is with smallest residual disparity
// for weak ones - the strongest.
// TODO: handle ortho (if requested so)
// after refine - use last, after extend - use strongest of all
double adiff_best = Double.NaN;
double strongest_weak = 0.0;
combo_pass.max_tried_disparity[ty][tx] = Double.NaN;
for (int ipass = firstPass; ipass <lastPassPlus1; ipass++ ){
CLTPass3d pass = passes.get(ipass);
if (nt == dbg_tile) {
System.out.println("combinePasses(): ipass = "+ipass+" nt = "+nt+" pass.tile_op["+ty+"]["+tx+"]="+pass.tile_op[ty][tx]+
" pass.isCombo()="+(pass.isCombo())+" pass.isProcessed()="+(pass.isProcessed()));
}
if ( pass.isMeasured() &&
(pass.tile_op[ty][tx] != 0 )) {
if ( (Double.isNaN(combo_pass.max_tried_disparity[ty][tx]) ||
(pass.disparity[ty][tx] > combo_pass.max_tried_disparity[ty][tx]))){
combo_pass.max_tried_disparity[ty][tx] = pass.disparity[ty][tx];
}
double adiff, strength;
if (nt == dbg_tile){
System.out.println("combinePasses(): pass.calc_disparity["+nt+"]="+pass.calc_disparity[nt]+
" pass.disparity["+ty+"]["+tx+"] = "+pass.disparity[ty][tx]);
}
if (usePoly) { // just an amplitude of the polynomial maximum calculated disparity
adiff = Math.abs(pass.disparity_map[ImageDtt.DISPARITY_INDEX_POLY][nt]); // polynomial method
} else { // just an amplitude of center of mass calculated disparity
adiff = Math.abs(pass.disparity_map[ImageDtt.DISPARITY_INDEX_CM][nt]); // center mass method
}
strength = Math.abs(pass.disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX][nt]);
if ((strength > 0.0) &&
!Double.isNaN(adiff) &&
((best_weak_index < 0) || (strongest_weak < strength))) {
best_weak_index = ipass;
strongest_weak = strength;
}
if ((strength > minStrength) &&
!Double.isNaN(adiff) &&
((best_index < 0) || (adiff < adiff_best))) {
best_index = ipass;
adiff_best = adiff;
}
if (nt == dbg_tile){
System.out.println("combinePasses(): strength="+strength+" best_weak_index="+best_weak_index+
" best_index="+best_index+" adiff_best="+adiff_best+" ipass="+ipass+"adiff="+adiff);
}
}
}
if (best_index < 0) {
if (use_last && (passes.get(lastPassPlus1 - 1).tile_op[ty][tx] != 0)) { // last is prevferred and has some data
best_index = lastPassPlus1 - 1;
} else { // just use result with strongest correlation
best_index = best_weak_index;
}
}
if (best_index >= 0){
CLTPass3d pass = passes.get(best_index);
combo_pass.tile_op[ty][tx] = pass.tile_op[ty][tx];
combo_pass.disparity[ty][tx] = pass.disparity[ty][tx];
if ((pass.texture_tiles == null) ||(combo_pass.texture_tiles == null)) {
if ((ty==0) && (tx==0)) {
System.out.println("BUG: best_index="+best_index);
}
} else {
combo_pass.texture_tiles[ty][tx] = pass.texture_tiles[ty][tx];
for (int i = 0; i < ImageDtt.DISPARITY_TITLES.length; i++){
combo_pass.disparity_map[i][nt] = pass.disparity_map[i][nt];
}
}
// do not copy any of the calculated values - they should be re-calculated
}
}
}
if (show_combined) {
int numScans = lastPassPlus1 - firstPass;
for (int ty = 0; ty < tilesY; ty++) for (int tx = 0; tx < tilesX; tx++){
int nt = ty * tilesX +tx;
dbg_data[numScans ][nt] = combo_pass.disparity[ty][tx];
dbg_data[numScans + 1 * (numScans + 1)][nt] = combo_pass.disparity_map[ImageDtt.DISPARITY_INDEX_CM][nt];
dbg_data[numScans + 2 * (numScans + 1)][nt] = combo_pass.disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX][nt];
dbg_data[3 * (numScans + 1)][nt] = combo_pass.max_tried_disparity[ty][tx];
}
titles[numScans ] = "disparity_combo";
titles[numScans + 1 * (numScans + 1)] = "cm_disparity_combo";
titles[numScans + 2 * (numScans + 1)] = "strength_combo";
titles[3 * (numScans + 1)] = "max_tried_disparity";
sdfa_instance.showArrays(dbg_data, tilesX, tilesY, true, "combo_scan_"+lastPassPlus1,titles);
}
return combo_pass;
}
/**
* Calculates calc_disparity, calc_disparity_hor, calc_disparity_vert, strength, strength_hor, strength_vert,
* max_tried_disparity from the subset of a list of measurement passes (skipping non-measured)
* disparity, strength, *_hor and vert may come from the different scans.
* tile_op is set to 0/non-0 to show which tiles contain valid data
* disparity (target disparity) array is set to null as it can not be made valid (different values for disparity,
* disparity_hor and disparity_vert.
* @param passes list of scan passes to take data from
* @param firstPass index of the first pass to use
* @param lastPassPlus1 index plus 1 of the last pass to use
* @param trustedCorrelation maximal absolute value of measured correlation (no scaling) to trust (may use global trustedCorrelation)
* @param disp_far lowest disparity value to consider (does not apply to max_tried_disparity)
* @param disp_near highest disparity value to consider (does not apply to max_tried_disparity)
* @param minStrength full correlation strength to consider data to be reliable
* @param minStrengthHor horizontal (for vertical features) correlation strength to consider data to be reliable
* @param minStrengthVert vertical (for horizontal features) correlation strength to consider data to be reliable
* @param use_last use last scan data if nothing strong enough (false - use the strongest)
* @param usePoly use polynomial method to find max for full correlation, false - use center of mass
* @return new composite scan pass (not added to the list
*/
public CLTPass3d compositeScan(
final ArrayList <CLTPass3d> passes,
final int firstPass,
final int lastPassPlus1,
// final boolean skip_combo, // do not process other combo scans
final double trustedCorrelation,
final double disp_far, // limit results to the disparity range
final double disp_near,
final double minStrength,
final double minStrengthHor,
final double minStrengthVert,
final boolean use_last, //
// TODO: when useCombo - pay attention to borders (disregard)
final boolean usePoly) // use polynomial method to find max), valid if useCombo == false
{
int dbg_tile = -1; // 27669;
CLTPass3d combo_pass = new CLTPass3d();
final int tlen = tilesX * tilesY;
final int disparity_index = usePoly ? ImageDtt.DISPARITY_INDEX_POLY : ImageDtt.DISPARITY_INDEX_CM;
combo_pass.tile_op = new int [tilesY][tilesX]; // for just non-zero
combo_pass.disparity_map = new double [ImageDtt.DISPARITY_TITLES.length][];
for (int i = 0; i< ImageDtt.QUAD; i++) combo_pass.disparity_map[ImageDtt.IMG_DIFF0_INDEX + i] = new double[tlen];
// for now - will copy from the best full correlation measurement
combo_pass.texture_tiles = new double [tilesY][tilesX][][];
combo_pass.max_tried_disparity = new double [tilesY][tilesX];
combo_pass.is_combo = true;
combo_pass.calc_disparity = new double [tlen];
combo_pass.calc_disparity_hor = new double [tlen];
combo_pass.calc_disparity_vert = new double [tlen];
combo_pass.strength = new double [tlen];
combo_pass.strength_hor = new double [tlen];
combo_pass.strength_vert = new double [tlen];
// * Calculates calc_disparity, calc_disparity_hor, calc_disparity_vert, strength, strength_hor, strength_vert,
for (int ty = 0; ty < tilesY; ty ++) for (int tx = 0; tx < tilesX; tx ++) combo_pass.texture_tiles[ty][tx] = null;
for (int ty = 0; ty < tilesY; ty ++) {
for (int tx = 0; tx < tilesX; tx ++){
int nt = ty * tilesX + tx;
int best_index = -1;
int best_index_hor = -1;
int best_index_vert = -1;
int best_weak_index = -1;
int best_weak_index_hor = -1;
int best_weak_index_vert = -1;
// for "strong" result (above minStrength) the best fit is with smallest residual disparity
// for weak ones - the strongest.
// TODO: handle ortho (if requested so)
// after refine - use last, after extend - use strongest of all
double adiff_best = Double.NaN;
double adiff_best_hor = Double.NaN;
double adiff_best_vert = Double.NaN;
double strongest_weak = 0.0;
double strongest_weak_hor = 0.0;
double strongest_weak_vert = 0.0;
combo_pass.max_tried_disparity[ty][tx] = Double.NaN;
for (int ipass = firstPass; ipass <lastPassPlus1; ipass++ ){
CLTPass3d pass = passes.get(ipass);
if (nt == dbg_tile) {
System.out.println("compositeScan(): ipass = "+ipass+" nt = "+nt+" pass.tile_op["+ty+"]["+tx+"]="+pass.tile_op[ty][tx]+
" pass.isCombo()="+(pass.isCombo())+" pass.isProcessed()="+(pass.isProcessed()));
}
if ( pass.isMeasured() && (pass.tile_op[ty][tx] != 0 )) { // current tile has valid data
if ( (Double.isNaN(combo_pass.max_tried_disparity[ty][tx]) ||
(pass.disparity[ty][tx] > combo_pass.max_tried_disparity[ty][tx]))){
combo_pass.max_tried_disparity[ty][tx] = pass.disparity[ty][tx];
}
boolean last = (ipass == (lastPassPlus1-1)) && use_last;
double mdisp = pass.disparity_map[disparity_index][nt];
double mdisp_hor = pass.disparity_map[ImageDtt.DISPARITY_INDEX_HOR][nt];
double mdisp_vert = pass.disparity_map[ImageDtt.DISPARITY_INDEX_VERT][nt];
double strength = pass.disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX][nt];
double strength_hor = pass.disparity_map[ImageDtt.DISPARITY_INDEX_HOR_STRENGTH][nt];
double strength_vert = pass.disparity_map[ImageDtt.DISPARITY_INDEX_VERT_STRENGTH][nt];
double adiff = Math.abs(mdisp);
double adiff_hor = Math.abs(mdisp_hor);
double adiff_vert = Math.abs(mdisp_vert);
if (adiff <= trustedCorrelation){
double disp = mdisp/corr_magic_scale + pass.disparity[ty][tx];
if ((disp >= disp_far) && (disp <= disp_near) && !Double.isNaN(adiff)){
if (strength >= minStrength) {
if (!(adiff >= adiff_best)){ // adiff_best == Double.NaN works too
adiff_best = adiff;
best_index = ipass;
}
} else {
if ((last && (strength > 0.0)) || (strength > strongest_weak)){
strongest_weak = strength;
best_weak_index = ipass;
}
}
}
}
if (adiff_hor <= trustedCorrelation){
double disp_hor = mdisp_hor/corr_magic_scale + pass.disparity[ty][tx];
if ((disp_hor >= disp_far) && (disp_hor <= disp_near) && !Double.isNaN(adiff_hor)){
if (strength_hor >= minStrength) {
if (!(adiff_hor >= adiff_best_hor)){ // adiff_best == Double.NaN works too
adiff_best_hor = adiff_hor;
best_index_hor = ipass;
}
} else {
if ((last && (strength_hor > 0.0)) || (strength_hor > strongest_weak_hor)){
strongest_weak_hor = strength_hor;
best_weak_index_hor = ipass;
}
}
}
}
if (adiff_vert <= trustedCorrelation){
double disp_vert = mdisp_vert/corr_magic_scale + pass.disparity[ty][tx];
if ((disp_vert >= disp_far) && (disp_vert <= disp_near) && !Double.isNaN(adiff_vert)){
if (strength_vert >= minStrength) {
if (!(adiff_vert >= adiff_best_vert)){ // adiff_best == Double.NaN works too
adiff_best_vert = adiff_vert;
best_index_vert = ipass;
}
} else {
if ((last && (strength_vert > 0.0)) || (strength_vert > strongest_weak_vert)){
strongest_weak_vert = strength_vert;
best_weak_index_vert = ipass;
}
}
}
}
}
}
if (best_index < 0) best_index = best_weak_index;
if (best_index_hor < 0) best_index_hor = best_weak_index_hor;
if (best_index_vert < 0) best_index_vert = best_weak_index_vert;
if (best_index >= 0){
CLTPass3d pass = passes.get(best_index);
combo_pass.tile_op[ty][tx] = pass.tile_op[ty][tx];
if (pass.texture_tiles != null) {
combo_pass.texture_tiles[ty][tx] = pass.texture_tiles[ty][tx];
}
combo_pass.calc_disparity[nt] = pass.disparity_map[disparity_index][nt]/corr_magic_scale + pass.disparity[ty][tx];
combo_pass.strength[nt] = pass.disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX][nt];
for (int i = 0; i< ImageDtt.QUAD; i++) combo_pass.disparity_map[ImageDtt.IMG_DIFF0_INDEX + i][nt] = pass.disparity_map[ImageDtt.IMG_DIFF0_INDEX + i][nt];
} else {
combo_pass.calc_disparity[nt] = Double.NaN;
combo_pass.strength[nt] = 0.0;
}
if (best_index_hor >= 0){
CLTPass3d pass = passes.get(best_index_hor);
combo_pass.tile_op[ty][tx] = pass.tile_op[ty][tx]; // just non-zero
combo_pass.calc_disparity_hor[nt] = pass.disparity_map[ImageDtt.DISPARITY_INDEX_HOR][nt]/corr_magic_scale + pass.disparity[ty][tx];
combo_pass.strength_hor[nt] = pass.disparity_map[ImageDtt.DISPARITY_INDEX_HOR_STRENGTH][nt];
} else {
combo_pass.calc_disparity_hor[nt] = Double.NaN;
combo_pass.strength_hor[nt] = 0.0;
}
if (best_index_vert >= 0){
CLTPass3d pass = passes.get(best_index_vert);
combo_pass.tile_op[ty][tx] = pass.tile_op[ty][tx]; // just non-zero
combo_pass.calc_disparity_vert[nt] = pass.disparity_map[ImageDtt.DISPARITY_INDEX_VERT][nt]/corr_magic_scale + pass.disparity[ty][tx];
combo_pass.strength_vert[nt] = pass.disparity_map[ImageDtt.DISPARITY_INDEX_VERT_STRENGTH][nt];
} else {
combo_pass.calc_disparity_vert[nt] = Double.NaN;
combo_pass.strength_vert[nt] = 0.0;
}
}
}
return combo_pass;
}
//trustedCorrelation
/**
* Calculate max_tried_disparity from the provided scans (use only actually measured ones)
* @param passes list of passes
* @param firstPass index of the first pass to look at
* @param lastPassPlus1 last index plus 1 of the pass to look at (may include the current one too if it is measured - will be used)
* @param new_scan current scan to attach result to
*/
public void calcMaxTried(
final ArrayList <CLTPass3d> passes,
final int firstPass,
final int lastPassPlus1,
final CLTPass3d new_scan)
{
new_scan.max_tried_disparity = new double [tilesY][tilesX];
// new_scan.is_combo = true;
int dbg_tile = -1; // 27669;
for (int ty = 0; ty < tilesY; ty ++) {
for (int tx = 0; tx < tilesX; tx ++){
int nt = ty * tilesX + tx;
if (nt == dbg_tile){
System.out.println("calcMaxTried(): nt = "+nt+", tx = "+tx+", ty = "+ty);
}
new_scan.max_tried_disparity[ty][tx] = Double.NaN;
for (int ipass = firstPass; ipass <lastPassPlus1; ipass++ ){
CLTPass3d pass = passes.get(ipass);
if ( pass.isMeasured() &&
(pass.tile_op[ty][tx] != 0 ) &&
(Double.isNaN(new_scan.max_tried_disparity[ty][tx]) ||
(pass.disparity[ty][tx] > new_scan.max_tried_disparity[ty][tx]))){
new_scan.max_tried_disparity[ty][tx] = pass.disparity[ty][tx];
}
}
}
}
}
public int [] makeUnique( public int [] makeUnique(
final ArrayList <CLTPass3d> passes, final ArrayList <CLTPass3d> passes,
final int firstPass, final int firstPass,
...@@ -1333,7 +1776,7 @@ public class TileProcessor { ...@@ -1333,7 +1776,7 @@ public class TileProcessor {
total ++; total ++;
for (int ipass = firstPass; ipass <lastPassPlus1; ipass++ ){ for (int ipass = firstPass; ipass <lastPassPlus1; ipass++ ){
CLTPass3d pass = passes.get(ipass); CLTPass3d pass = passes.get(ipass);
if (pass.tile_op[ty][tx] != 0){ if ((pass.tile_op[ty][tx] != 0) && pass.isMeasured()){
if (Math.abs(new_scan.disparity[ty][tx] - pass.disparity[ty][tx]) < unique_tolerance){ if (Math.abs(new_scan.disparity[ty][tx] - pass.disparity[ty][tx]) < unique_tolerance){
new_scan.tile_op[ty][tx] = 0; new_scan.tile_op[ty][tx] = 0;
removed++; removed++;
...@@ -1356,13 +1799,13 @@ public class TileProcessor { ...@@ -1356,13 +1799,13 @@ public class TileProcessor {
return rslt; return rslt;
} }
public void setupExtendDisparity( public int setupExtendDisparity( // returns number of new tiles to try
final CLTPass3d scan, // combined scan with max_tried_disparity, will be modified to re-scan final CLTPass3d scan, // combined scan with max_tried_disparity, will be modified to re-scan
final CLTPass3d last_scan, // last prepared tile - can use last_scan.disparity, .border_tiles and .selected final CLTPass3d last_scan, // last prepared tile - can use last_scan.disparity, .border_tiles and .selected
final CLTPass3d bg_scan, // background scan data final CLTPass3d bg_scan, // background scan data
final int grow_sweep, // 8; // Try these number of tiles around known ones final int grow_sweep, // 8; // Try these number of tiles around known ones
final double grow_disp_max, // = 50.0; // Maximal disparity to try final double grow_disp_max, // = 50.0; // Maximal disparity to try
final double grow_disp_trust, // = 4.0; // Trust measured disparity within +/- this value final double tried_margin, // = 4.0; // consider alrdeady tried if within this margin from already tried
final double grow_disp_step, // = 6.0; // Increase disparity (from maximal tried) if nothing found in that tile // TODO: handle enclosed dips? final double grow_disp_step, // = 6.0; // Increase disparity (from maximal tried) if nothing found in that tile // TODO: handle enclosed dips?
final double grow_min_diff, // = 0.5; // Grow more only if at least one channel has higher variance from others for the tile final double grow_min_diff, // = 0.5; // Grow more only if at least one channel has higher variance from others for the tile
EyesisCorrectionParameters.CLTParameters clt_parameters, EyesisCorrectionParameters.CLTParameters clt_parameters,
...@@ -1372,6 +1815,7 @@ public class TileProcessor { ...@@ -1372,6 +1815,7 @@ public class TileProcessor {
final boolean updateStatus, final boolean updateStatus,
final int debugLevel) final int debugLevel)
{ {
final int dbg_tile = 54627; // ty=159, tx = 249
final int tlen = tilesY * tilesX; final int tlen = tilesY * tilesX;
double [][] dbg_img = null; double [][] dbg_img = null;
String [] dbg_titles = null; String [] dbg_titles = null;
...@@ -1383,6 +1827,10 @@ public class TileProcessor { ...@@ -1383,6 +1827,10 @@ public class TileProcessor {
these_no_border[i] = last_scan.selected[i] && !last_scan.border_tiles[i]; these_no_border[i] = last_scan.selected[i] && !last_scan.border_tiles[i];
} }
boolean [] dbg_last_selected = last_scan.selected.clone();
boolean [] dbg_last_border = last_scan.border_tiles.clone();
boolean [] dbg_no_border = these_no_border.clone();
boolean [] known_tiles = these_no_border.clone(); boolean [] known_tiles = these_no_border.clone();
// known are background or these tiles // known are background or these tiles
for (int i = 0; i < known_tiles.length; i++) { for (int i = 0; i < known_tiles.length; i++) {
...@@ -1436,7 +1884,67 @@ public class TileProcessor { ...@@ -1436,7 +1884,67 @@ public class TileProcessor {
clt_parameters, clt_parameters,
threadsMax, // maximal number of threads to launch threadsMax, // maximal number of threads to launch
debugLevel); debugLevel);
// increase disparity if it
boolean [] tried_before = new boolean [tlen];
int num_tried_before = 0;
int num_extended = 0;
for (int num_scan = 0; num_scan < clt_3d_passes.size(); num_scan++){
CLTPass3d pass = clt_3d_passes.get(num_scan);
// if (pass != scan) { // not the same reference
if (pass.isMeasured()) { // measured with pass.disparity[ty][tx]
for (int ty = 0; ty < tilesY; ty++) for (int tx = 0; tx < tilesX; tx++){
int nt = ty * tilesX + tx;
if ((debugLevel >- 1) && (nt == dbg_tile)){
System.out.println("setupExtendDisparity(): nt = "+nt);
}
if (border[nt]) {
num_extended++;
if ( (pass.tile_op[ty][tx] != 0) &&
(Math.abs(pass.disparity[ty][tx] - disparity[nt]) < tried_margin)) {
if (!tried_before[nt]) num_tried_before ++;
tried_before[nt] = true;
}
}
}
}
}
if (debugLevel > -1) {
System.out.println("Number of extended tiles: "+num_extended+", tiles already tried (within +/-"+tried_margin+") :"+num_tried_before);
}
if (num_extended == 0){
if (debugLevel > -1) {
System.out.println("No new tiles wanted");
}
return 0;
}
int num_replaced = 0;
if (num_tried_before > 0){
for (int ty = 0; ty < tilesY; ty++) for (int tx = 0; tx < tilesX; tx++){
int nt = ty * tilesX + tx;
if (tried_before[nt]){
double new_disp = scan.max_tried_disparity[ty][tx] + grow_disp_step;
if (new_disp > grow_disp_max){
// border[nt] = false; // let it repeat, will be filtered out if too close anyway. And removing border needs to remove selected too
} else {
num_replaced ++;
disparity[nt] = new_disp;
// TODO: Make it smarter to give up looking at differences between images
}
}
}
}
if (debugLevel > -1) {
System.out.println("Replaced "+num_replaced+" already tried tiles (of "+num_tried_before+"), abandoned "+(num_tried_before -num_replaced));
}
num_extended += num_replaced - num_tried_before;
if (num_extended == 0){
if (debugLevel > -1) {
System.out.println("No new tiles wanted");
}
return 0;
}
scan.selected = grown; scan.selected = grown;
scan.border_tiles = border; scan.border_tiles = border;
scan.disparity = new double [tilesY][tilesX]; scan.disparity = new double [tilesY][tilesX];
...@@ -1458,7 +1966,7 @@ public class TileProcessor { ...@@ -1458,7 +1966,7 @@ public class TileProcessor {
if (show_debug){ if (show_debug){
String [] dbg_titles0 = {"tried","disparity","bgnd","these","known_in", "known"}; String [] dbg_titles0 = {"tried","disparity","bgnd","these","known_in", "known","last_sel_border", "no_border","tried_before"};
dbg_titles = dbg_titles0; dbg_titles = dbg_titles0;
dbg_img = new double[dbg_titles.length][]; dbg_img = new double[dbg_titles.length][];
dbg_img[0] = new double[tilesY * tilesX]; dbg_img[0] = new double[tilesY * tilesX];
...@@ -1469,6 +1977,11 @@ public class TileProcessor { ...@@ -1469,6 +1977,11 @@ public class TileProcessor {
dbg_img[3] = new double[tilesY * tilesX]; dbg_img[3] = new double[tilesY * tilesX];
dbg_img[4] = new double[tilesY * tilesX]; dbg_img[4] = new double[tilesY * tilesX];
dbg_img[5] = new double[tilesY * tilesX]; dbg_img[5] = new double[tilesY * tilesX];
dbg_img[6] = new double[tilesY * tilesX];
dbg_img[7] = new double[tilesY * tilesX];
dbg_img[8] = new double[tilesY * tilesX];
for (int i = 0; i <tlen; i++){ for (int i = 0; i <tlen; i++){
int ty = i / tilesX; int ty = i / tilesX;
int tx = i % tilesX; int tx = i % tilesX;
...@@ -1479,29 +1992,47 @@ public class TileProcessor { ...@@ -1479,29 +1992,47 @@ public class TileProcessor {
dbg_img[3][i] = ((last_scan.selected != null) && (last_scan.selected[i]))? 1.0:0.0 ; dbg_img[3][i] = ((last_scan.selected != null) && (last_scan.selected[i]))? 1.0:0.0 ;
dbg_img[4][i] = dbg_img[2][i] + dbg_img[3][i]; dbg_img[4][i] = dbg_img[2][i] + dbg_img[3][i];
dbg_img[5][i] = (scan.selected[i]?1:0)+ (scan.border_tiles[i]?2:0); dbg_img[5][i] = (scan.selected[i]?1:0)+ (scan.border_tiles[i]?2:0);
dbg_img[6][i] = (dbg_last_selected[i]?1:0)+ (dbg_last_border[i]?2:0);
dbg_img[7][i] = dbg_no_border[i]?1:0;
dbg_img[8][i] = tried_before[i]?1:0;
} }
sdfa_instance = new showDoubleFloatArrays(); // just for debugging? sdfa_instance = new showDoubleFloatArrays(); // just for debugging?
sdfa_instance.showArrays(dbg_img, tilesX, tilesY, true, "extend_disparity",dbg_titles); sdfa_instance.showArrays(dbg_img, tilesX, tilesY, true, "extend_disparity",dbg_titles);
} }
/*
boolean [] dbg_last_selected = last_scan.selected.clone();
boolean [] dbg_last_border = last_scan.border_tiles.clone();
boolean [] dbg_no_border = these_no_border.clone();
*/
return num_extended;
} }
public void showScan(
CLTPass3d scan,
public CLTPass3d prepareExtendDisparityScan ( String title)
final CLTPass3d base_scan, // should be a combo, including non-null max_tried_disparity
CLTPass3d new_scan, // either semi-prepared scan (i.e. refined disparities) or null
final int grow_sweep, // double number of extra rows/columns to add
final double grow_disp_max, // = 50.0; // Maximal disparity to try
final double grow_disp_trust, // = 4.0; // Trust measured disparity within +/- this value
final double grow_disp_step, // = 6.0; // Increase disparity (from maximal tried) if nothing found in that tile // TODO: handle enclosed dips?
final double grow_min_diff, // = 0.5; // Grow more only if at least one channel has higher variance from others for the tile
final int debugLevel)
{ {
boolean is_new_scan = new_scan == null; showDoubleFloatArrays sdfa_instance = null;
final CLTPass3d scan = is_new_scan ? new CLTPass3d() : new_scan; sdfa_instance = new showDoubleFloatArrays(); // just for debugging?
String [] titles = {"tile_op","disparity","disp_cm","strength","selection", "border_tiles","max_tried"};
int tlen = tilesX*tilesY;
double [][] dbg_img = new double[titles.length][tlen];
for (int ty = 0; ty < tilesY; ty++) for (int tx = 0; tx < tilesX; tx++){
int nt = ty*tilesX + tx;
dbg_img[0][nt] = scan.tile_op[ty][tx];
if (scan.disparity != null) dbg_img[1][nt] = scan.disparity[ty][tx];
if ((scan.disparity_map != null) && (scan.disparity_map[ImageDtt.DISPARITY_INDEX_CM] != null)) dbg_img[2][nt] = scan.disparity_map[ImageDtt.DISPARITY_INDEX_CM][nt];
if ((scan.disparity_map != null) && (scan.disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX] != null)) dbg_img[3][nt] = scan.disparity_map[ImageDtt.DISPARITY_STRENGTH_INDEX][nt];
if (scan.selected != null) dbg_img[4][nt] = scan.selected[nt]? 1.0:0.0;
if (scan.border_tiles != null) dbg_img[5][nt] = scan.border_tiles[nt]? 1.0:0.0;
if (scan.max_tried_disparity != null) {
dbg_img[6][nt] = scan.max_tried_disparity[ty][tx];
}
}
sdfa_instance.showArrays(dbg_img, tilesX, tilesY, true, title,titles);
System.out.println("showScan("+title+"): isMeasured()="+scan.isMeasured()+", isProcessed()="+scan.isProcessed()+", isCombo()="+scan.isCombo());
return scan;
} }
//sure_smth //sure_smth
...@@ -1652,6 +2183,7 @@ public class TileProcessor { ...@@ -1652,6 +2183,7 @@ public class TileProcessor {
} }
/** /**
* Create tasks for individual clusters (with flaps). Border_fixed will have alpha = 0 and provided disparity, border float - adjusted disparity from neighbors * Create tasks for individual clusters (with flaps). Border_fixed will have alpha = 0 and provided disparity, border float - adjusted disparity from neighbors
* No ordering here, just filtering * No ordering here, just filtering
...@@ -3239,8 +3771,14 @@ public class TileProcessor { ...@@ -3239,8 +3771,14 @@ public class TileProcessor {
dbg_orig_disparity = scan_prev.getDisparity().clone(); dbg_orig_disparity = scan_prev.getDisparity().clone();
// combine weak with supertiles // combine weak with supertiles
dbg_with_super_disp = scan_prev.combineSuper(clt_parameters.stUseDisp); dbg_with_super_disp = scan_prev.combineSuper(
true, //boolean updateStrength, // use ST strength if true, keep original (update disparity only) if false
clt_parameters.stStrengthScale, // Multiply st strength if used instead of regular strength (only if updateStrength)
clt_parameters.stUseDisp); //.15; // Use background disparity from supertiles if tile strength is less
if (dbg_with_super_disp != null) dbg_with_super_disp = dbg_with_super_disp.clone(); // else no super disparity available if (dbg_with_super_disp != null) dbg_with_super_disp = dbg_with_super_disp.clone(); // else no super disparity available
} }
// replace weak outlaye tiles with weighted averages (modifies disparity) // replace weak outlaye tiles with weighted averages (modifies disparity)
...@@ -3251,7 +3789,8 @@ public class TileProcessor { ...@@ -3251,7 +3789,8 @@ public class TileProcessor {
clt_parameters.outlayerDiffPos, // final double maxDiff) clt_parameters.outlayerDiffPos, // final double maxDiff)
clt_parameters.outlayerDiffNeg, // final double maxDiff) clt_parameters.outlayerDiffNeg, // final double maxDiff)
0.5 * disparity_far, 0.5 * disparity_far,
2.0 * disparity_near); 2.0 * disparity_near,
debugLevel);
dbg_outlayers = new double[outlayers.length]; dbg_outlayers = new double[outlayers.length];
...@@ -3334,14 +3873,14 @@ public class TileProcessor { ...@@ -3334,14 +3873,14 @@ public class TileProcessor {
String [] dbg_disp_tiltes={"masked", "filtered", "disp_combo", "disparity","st_disparity", "strength", String [] dbg_disp_tiltes={"masked", "filtered", "disp_combo", "disparity","st_disparity", "strength",
"st_strength","outlayers","these","border","border_tiles"}; "st_strength","outlayers","these","border","border_tiles"};
double [][] dbg_disp = new double [dbg_disp_tiltes.length][]; double [][] dbg_disp = new double [dbg_disp_tiltes.length][];
dbg_disp[0] = masked_filtered; dbg_disp[0] = masked_filtered; // +
dbg_disp[1] = scan_prev.getDisparity(); dbg_disp[1] = scan_prev.getDisparity(); // +
dbg_disp[2] = dbg_with_super_disp; dbg_disp[2] = dbg_with_super_disp; // -
dbg_disp[3] = dbg_orig_disparity; dbg_disp[3] = dbg_orig_disparity; // -
dbg_disp[4] = scan_prev.getBgDisparity(); dbg_disp[4] = scan_prev.getBgDisparity(); // -
dbg_disp[5] = scan_prev.getStrength(); dbg_disp[5] = scan_prev.getStrength(); // +
dbg_disp[6] = scan_prev.getBgStrength(); dbg_disp[6] = scan_prev.getBgStrength(); // -
dbg_disp[7] = dbg_outlayers; dbg_disp[7] = dbg_outlayers; // +
dbg_disp[8] = new double [masked_filtered.length]; dbg_disp[8] = new double [masked_filtered.length];
dbg_disp[9] = new double [masked_filtered.length]; dbg_disp[9] = new double [masked_filtered.length];
dbg_disp[10] = new double [masked_filtered.length]; dbg_disp[10] = new double [masked_filtered.length];
...@@ -3457,8 +3996,13 @@ public class TileProcessor { ...@@ -3457,8 +3996,13 @@ public class TileProcessor {
grown, // boolean [] tiles, grown, // boolean [] tiles,
null); // boolean [] prohibit) null); // boolean [] prohibit)
dbg_orig_disparity = scan_prev.getDisparity().clone(); dbg_orig_disparity = scan_prev.getDisparity().clone();
// combine weak with supertiles // combine weak with supertiles
dbg_with_super_disp = scan_prev.combineSuper(clt_parameters.stUseDisp); dbg_with_super_disp = scan_prev.combineSuper(
true, //boolean updateStrength, // use ST strength if true, keep original (update disparity only) if false
clt_parameters.stStrengthScale, // Multiply st strength if used instead of regular strength (only if updateStrength)
clt_parameters.stUseDisp);
if (dbg_with_super_disp != null) dbg_with_super_disp = dbg_with_super_disp.clone(); // else no super disparity available if (dbg_with_super_disp != null) dbg_with_super_disp = dbg_with_super_disp.clone(); // else no super disparity available
} else { } else {
growTiles( growTiles(
...@@ -3475,7 +4019,8 @@ public class TileProcessor { ...@@ -3475,7 +4019,8 @@ public class TileProcessor {
clt_parameters.outlayerDiffPos, // final double maxDiff) clt_parameters.outlayerDiffPos, // final double maxDiff)
clt_parameters.outlayerDiffNeg, // final double maxDiff) clt_parameters.outlayerDiffNeg, // final double maxDiff)
0.5 * disparity_far, 0.5 * disparity_far,
2.0 * disparity_near); 2.0 * disparity_near,
debugLevel);
dbg_outlayers = new double[outlayers.length]; dbg_outlayers = new double[outlayers.length];
......
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