Skip to content

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

Started updateFgAlpha() to iteratively update FG alpha

parent c944c0f6
Hide whitespace changes
Inline Side-by-side
Showing with 449 additions and 60 deletions
src/main/java/com/elphel/imagej/tileprocessor/TexturedModel.java
View file @ f810a996
......@@ -3266,15 +3266,16 @@ public class TexturedModel {
public static boolean [][] getTrimSeeds(
final boolean [][] trim_pix, // pixels that may be trimmed
final boolean [][] seed_pix, // FG edge, just outside of trim_pix. Will be modified
final boolean [][] seed_pix_in, // FG edge, just outside of trim_pix. Will be modified. Or null
final double [][] vars_same,
final double [][] vars_inter,
final double seed_same_fz, // add to var_same in denominator
final double seed_fom, // minimal value of vars_inter/sqrt(vars_same)
final double seed_inter, // = 150;
final double seed_inter, // = 150; works for high-contrast over sky
final int width) {
final int num_slices = trim_pix.length;
final int num_pix = trim_pix[0].length;
final boolean [][] seed_pix = (seed_pix_in != null) ? seed_pix_in : new boolean [num_slices][num_pix];
final Thread[] threads = ImageDtt.newThreadArray(THREADS_MAX);
final AtomicInteger ai = new AtomicInteger(0);
for (int nslice = 0; nslice < num_slices; nslice++) {
......@@ -3302,6 +3303,8 @@ public class TexturedModel {
}
public static double [][] getTrimFom(
final boolean [][] trim_pix, // pixels that may be trimmed
final double [][] vars_same,
......@@ -3380,6 +3383,47 @@ public class TexturedModel {
return trim_foms;
}
public static boolean [][] thresholdAnalog(
final double [][] data,
final double threshold,
final boolean greater) {
final int num_slices = data.length;
final int num_pix = data[0].length;
final Thread[] threads = ImageDtt.newThreadArray(THREADS_MAX);
final AtomicInteger ai = new AtomicInteger(0);
final boolean [][] binaries = new boolean [num_slices][num_pix];
for (int nslice = 0; nslice < num_slices; nslice++) {
final int fnslice = nslice;
ai.set(0);
if (greater) {
for (int ithread = 0; ithread < threads.length; ithread++) {
threads[ithread] = new Thread() {
public void run() {
for (int pix = ai.getAndIncrement(); pix < num_pix; pix = ai.getAndIncrement()) {
binaries[fnslice][pix] = data[fnslice][pix] >= threshold;
}
}
};
}
ImageDtt.startAndJoin(threads);
} else {
for (int ithread = 0; ithread < threads.length; ithread++) {
threads[ithread] = new Thread() {
public void run() {
for (int pix = ai.getAndIncrement(); pix < num_pix; pix = ai.getAndIncrement()) {
binaries[fnslice][pix] = data[fnslice][pix] <= threshold;
}
}
};
}
ImageDtt.startAndJoin(threads);
}
}
return binaries;
}
public static void getTrimAlpha(
final double [][] fom_pix, // should be NaN outside of trim_pix
final boolean [][] trim_pix, // pixels that may be trimmed
......@@ -3972,7 +4016,7 @@ public class TexturedModel {
final boolean [][] texture_edge = new boolean[num_slices][];
final TileNeibs pn = new TileNeibs(width, img_size/width);
final Thread[] threads = ImageDtt.newThreadArray(THREADS_MAX);
final AtomicInteger ai = new AtomicInteger(0);
final AtomicInteger ai = new AtomicInteger(0); // may remove multithreaded
for (int ithread = 0; ithread < threads.length; ithread++) {
threads[ithread] = new Thread() {
public void run() {
......@@ -4361,19 +4405,23 @@ public class TexturedModel {
// now fill gaps in disparity and pixels
double []sky_disparity_filled = TileProcessor.fillNaNs( // multithreaded
sky_disparity, // final double [] data,
null, // final boolean [] prohibit,
sky_tiles_bounds.width, // int width,
2 * Math.max(sky_tiles_bounds.width, sky_tiles_bounds.height), // 16, // final int grow,
0.7, // double diagonal_weight, // relative to ortho
100, // int num_passes,
0.01, // final double max_rchange, // = 0.01
THREADS_MAX); // final int threadsMax) // maximal number of threads to launch
tileClusters[sky_slice].setSubDisparity(sky_subindex,sky_disparity_filled);
double[] sky_pixels_filled = TileProcessor.fillNaNs( // multithreaded
sky_pixels, // final double [] data,
null, // final boolean [] prohibit,
sky_pixels_bounds.width, // int width,
3 * Math.min(sky_pixels_bounds.width,sky_pixels_bounds.height) / 2, // 16, // final int grow,
0.7, // double diagonal_weight, // relative to ortho
100, // int num_passes,
0.01, // final double max_rchange, // = 0.01
THREADS_MAX); // final int threadsMax) // maximal number of threads to launch
TileNeibs.setDoubleWindow(
......@@ -4628,6 +4676,7 @@ public class TexturedModel {
* @param tile_stitch boolean map of stitch tiles (tile_booleans[TILE_STITCH]) - they have duplicates
* @param occlusion_frac thershold for interpolating occlusion - fraction of BG tile being occluded
* to actually occlude
* @param occlusion_min_disp minimal FG BG separation to calculate occlusions on BG
* @param width image width in pixels
* @param transform_size CLT conversion size. Always 8
* @return [nslice][pix] bit map of occluded sensors to be removed from sources of the
......@@ -4640,7 +4689,8 @@ public class TexturedModel {
final boolean [][] tile_keep, // do not check occluded strong foreground
final boolean [][] tile_fg_strong, // do not check occluded strong foreground
final boolean [][] tile_stitch, // do not process these - there are duplicates
final double occlusion_frac, // ratio of opaque pixel overlap to consider occlusion
final double occlusion_frac, // ratio of opaque pixel overlap to consider occlusion
final double occlusion_min_disp,
final int width,
final int transform_size){
final int num_slices = alpha_pix.length;
......@@ -4664,13 +4714,16 @@ public class TexturedModel {
if ((fnslice == dbg_slice) && (tile == dbg_tile )) {
System.out.println("getNonOccludedMap().1 nslice="+fnslice+", tile="+tile);
}
double [][] offs_bg = channel_pixel_offsets[fnslice][tile];
if (tile_keep[fnslice][tile] && !tile_fg_strong[fnslice][tile] && !tile_stitch[fnslice][tile]) {
if ( tile_keep[fnslice][tile] &&
!tile_fg_strong[fnslice][tile] &&
!tile_stitch[fnslice][tile]) { // ***
double [][] offs_bg = channel_pixel_offsets[fnslice][tile];
for (int ns = 0; ns < num_slices; ns++) {
if ((ns != fnslice) &&
tile_keep[ns][tile] &&
!tile_stitch[fnslice][tile] &&
(slice_disparities[ns][tile] > slice_disparities[fnslice][tile])) {
!tile_stitch[fnslice][tile] && // ***
(slice_disparities[ns][tile] > slice_disparities[fnslice][tile]) &&
((slice_disparities[ns][tile] - slice_disparities[fnslice][tile]) > occlusion_min_disp )) {
double [][] offs_fg = channel_pixel_offsets[ns][tile];
double [][] pixel_offs = new double [offs_bg.length][2];
for (int nsens = 0; nsens < pixel_offs.length; nsens++) {
......@@ -4752,6 +4805,7 @@ public class TexturedModel {
int tileY = tile / tilesX;
for (int dy = 0; dy < transform_size; dy++) {
int indx0 = (tileY * transform_size + dy) * width + tileX * transform_size;
// use or? both ways
System.arraycopy(
occluded[ns],
indx0,
......@@ -4772,6 +4826,173 @@ public class TexturedModel {
// for debug - display number of bits from bit_mask
}
public static boolean [][] getTrimTiles(
boolean [][] trim_pix,
final int width,
final int transform_size){
final int num_slices = trim_pix.length;
final int img_size = trim_pix[0].length;
final int tilesX = width/transform_size;
final int tilesY = img_size/width/transform_size;
final int tiles = tilesX * tilesY;
final boolean [][] trim_tiles = new boolean [num_slices][tiles];
final Thread[] threads = ImageDtt.newThreadArray(THREADS_MAX);
final AtomicInteger ai = new AtomicInteger(0);
for (int nslice = 0; nslice < num_slices; nslice++) {
int fnslice = nslice;
ai.set(0);
final boolean [] trim_this = trim_pix[nslice];
for (int ithread = 0; ithread < threads.length; ithread++) {
threads[ithread] = new Thread() {
public void run() {
for (int tile = ai.getAndIncrement(); tile < tiles; tile = ai.getAndIncrement()) {
int tileY = tile / tilesX;
int indx = tileY * transform_size * width;
search_pix:
for (int dy = 0; dy < transform_size; dy++) {
for (int dx = 0; dx < transform_size; dx++) {
if (trim_this[indx++]) {
trim_tiles[fnslice][tile] = true;
break search_pix;
}
}
indx += width - transform_size;
}
}
}
};
}
ImageDtt.startAndJoin(threads);
}
return trim_tiles;
}
public static int updateFgAlpha(
final double [][][][] channel_pixel_offsets,
final double [][] textures,
final boolean [][] alpha_pix, // will be updated
final double [][] combo_texture,
final double [][][] sensor_texture,
final double [][] slice_disparities,
final boolean [][] tile_keep, // tiles that have at least one pixel
final boolean [][] tile_stitch, // tiles that have at least one pixel
final boolean [][] trim_tiles, // tiles that have at least one pixel
final boolean [][] trim_pix, // pixels that may be trimmed
final boolean [][] transparent, // definitely transparent
final boolean [][] opaque, // definitely opaque
final boolean en_cut, // enable change FG pixel to transparent from opaque
final boolean en_patch, // enable change FG pixel to opaque from transparent
final double min_disp_diff, // do not consider obscuring too close BG (1 pix or more?)
// other parameters
final double [][] debug_cost, // if not null, should be double [nslices][] - will return costs/NaN
final int width,
final int transform_size){
final int num_slices = alpha_pix.length;
final int img_size = alpha_pix[0].length;
final int height = img_size/width;
final int tilesX = width/transform_size;
final int tilesY = img_size/width/transform_size;
final int tiles = tilesX * tilesY;
final int dbg_tile = -1; // 4123;
final int dbg_slice = 0;
final Thread[] threads = ImageDtt.newThreadArray(THREADS_MAX);
final AtomicInteger ai = new AtomicInteger(0);
final AtomicInteger aplus = new AtomicInteger(0); // number of added opaque pixels
final AtomicInteger aminus = new AtomicInteger(0); // number of removed opaque pixels
final boolean [] new_alpha = new boolean[img_size];
for (int nslice = 0; nslice < num_slices; nslice++) {
int fnslice = nslice;
System.arraycopy(alpha_pix[fnslice], 0, new_alpha, 0, img_size);
ai.set(0);
aplus.set(0);
aminus.set(0);
for (int ithread = 0; ithread < threads.length; ithread++) {
threads[ithread] = new Thread() {
public void run() {
for (int tile = ai.getAndIncrement(); tile < tiles; tile = ai.getAndIncrement()) {
if ((fnslice == dbg_slice) && (tile == dbg_tile )) {
System.out.println("updateFgAlpha().1 nslice="+fnslice+", tile="+tile);
}
if ( trim_tiles [fnslice][tile] &&
!tile_stitch[fnslice][tile]) {
double [][] offs_fg = channel_pixel_offsets[fnslice][tile];
for (int ns = 0; ns < num_slices; ns++) {
if ((ns != fnslice) &&
tile_keep[ns][tile] &&
!tile_stitch[fnslice][tile] && // ***
(slice_disparities[ns][tile] < slice_disparities[fnslice][tile]) &&
((slice_disparities[fnslice][tile] - slice_disparities[ns][tile]) > min_disp_diff )) {
double [][] offs_bg = channel_pixel_offsets[ns][tile];
double [][] pixel_offs = new double [offs_bg.length][2];
for (int nsens = 0; nsens < pixel_offs.length; nsens++) {
if (offs_bg[nsens] != null) { // to implement sensor mask later
pixel_offs[nsens][0] = offs_fg[nsens][0] - offs_bg[nsens][0];
pixel_offs[nsens][1] = offs_fg[nsens][1] - offs_bg[nsens][1];
}
}
int tileX = tile % tilesX;
int tileY = tile / tilesX;
int pix0 = (tileY * width + tileX) * transform_size;
for (int dy = 0; dy < transform_size; dy++) {
int py0 = tileY * transform_size + dy;
int pix1 = pix0 + dy * width;
for (int dx = 0; dx < transform_size; dx++) {
int px0 = tileX * transform_size + dx;
int pix = pix1 + dx;
if (trim_pix[fnslice][pix]) { // assign for all trim_pix
if (!transparent[fnslice][pix] && !opaque[fnslice][pix]) {
if ((alpha_pix[fnslice][pix] && en_patch) || (!alpha_pix[fnslice][pix] && en_cut)) {
// calculate costs
// maybe multiple backgrounds? Then combine them all
// each sensor - single BG - common array of 16?
// cost for FG - average w/o center, possibly tilt
// consider spread normalize to sigma?
// how to normalize BG error
// Or do not normalize at all - compare absolute values?
for (int nsens = 0; nsens < pixel_offs.length; nsens++) if (offs_bg[nsens] != null) {
// corresponding BG pixels
double px = px0 + pixel_offs[nsens][0];
double py = py0 + pixel_offs[nsens][1];
int ipx = (int) Math.round(px); // here just center
int ipy = (int) Math.round(py);
int pix_bg = ipx + ipy * width;
}
}
}
// process sure transparent/opaque pixels
} else { // if (!transparent[fnslice][indx] && !opaque[fnslice][indx]) {
if (transparent[fnslice][pix]) {
if (alpha_pix[fnslice][pix] && en_cut) {
new_alpha[pix] = false;
aminus.getAndIncrement();
}
} else if (opaque[fnslice][pix]) {
if (!alpha_pix[fnslice][pix] && en_patch) {
new_alpha[pix] = true;
aplus.getAndIncrement();
}
}
}
}
}
}
} // for (int ns = 0; ns < num_slices; ns++) {
}
}
}
};
}
ImageDtt.startAndJoin(threads);
}
return aplus.get() + aminus.get();
}
public static double [][] debugOccludedMap(
final int [][] occluded_map
){
......@@ -4839,6 +5060,46 @@ public class TexturedModel {
return occluded_texture;
}
public static double [][] fillOcclusionsNaN(
final double [][] combo_texture,
final double [][] combo_occluded_texture,
final int grow,
final int num_passes,
final double max_change,
final int width){
final int num_slices = combo_texture.length;
final int img_size = combo_texture[0].length;
final double diagonal_weight = 0.7;
final boolean [] prohibit = new boolean [img_size];
final double [][] filled_occluded = new double[num_slices][];
final Thread[] threads = ImageDtt.newThreadArray(THREADS_MAX);
final AtomicInteger ai = new AtomicInteger(0);
for (int nslice = 0; nslice < num_slices; nslice++) {
final int fnslice = nslice;
ai.set(0);
for (int ithread = 0; ithread < threads.length; ithread++) {
threads[ithread] = new Thread() {
public void run() {
for (int pix = ai.getAndIncrement(); pix < img_size; pix = ai.getAndIncrement()) {
prohibit[pix] = Double.isNaN(combo_texture[fnslice][pix]);
}
}
};
}
ImageDtt.startAndJoin(threads);
filled_occluded[fnslice] = TileProcessor.fillNaNs( // multithreaded
combo_occluded_texture[fnslice], // final double [] data,
prohibit, // final boolean [] prohibit,
width, // int width,
grow, // 16, // final int grow,
diagonal_weight, // double diagonal_weight, // relative to ortho
num_passes, // int num_passes,
max_change, // final double max_rchange, // = 0.01
THREADS_MAX); // final int threadsMax) // maximal number of threads to
}
return filled_occluded;
}
......@@ -5328,11 +5589,21 @@ public class TexturedModel {
final double seed_same_fz = 6.5; // 13; // seed_inter = 50.0;
final double seed_fom = 2.0; // 1.9; // 1.2;
final double trim_inter_fz = 5.0; // 13.0;
final double trim_fom = 0.5; // 0.8; // 1.3; // 1.8; // 1.2; // 0.8; // 0.4; // 0.7;
// scale down fom for pixels near high-variance VAR_SAME
final double trim_fom_threshold = 120.0; // count only pixels with VAR_SAME > this value
final double trim_fom_boost = 5; // boost high-varinace values that exceed threshold
final double trim_fom_blur = 10.0; // divide trim_fom array by blurred version to reduce over sky sharp edge
// Sure values to set unconditionally transparent and unconditionally opaque FG
final double seed_fom_sure = 5.0;
final double seed_inter_sure = 150.0; // 13.0;
final double trim_fom_sure = 2.0;
final double min_incr = 100; // temporary disable // 5; // 20.0; // 0.5; // only for sky?
// final double thr_same = 16; // 20; // minimal value of vars_same to block propagation
......@@ -5343,7 +5614,9 @@ public class TexturedModel {
final double alphaOverlapTolerance = 0.0; // exact match only
final int reduce_has_bg_grow = 2; // 0 - exactly half tile (between strong and weak)
// final int strong_bg_overlap = 1;
final double occlusion_frac = 0.9;
final double occlusion_min_disp = 0.3; // do not calculate occlusions for smaller disparity difference
boolean [][][] tile_booleans = getTileBooleans(
slice_disparities, // final double [][] slice_disparities,
......@@ -5568,27 +5841,97 @@ public class TexturedModel {
width, // final int width,
transform_size); // final int transform_size)
// Processing BG
final double occlusion_frac = 0.9;
int [][] occluded_map = getOccludedMap(
channel_pixel_offsets, // final double [][][][] channel_pixel_offsets,
unbound_alpha, // final boolean [][] alpha_pix,
slice_disparities, // final double [][] slice_disparities,
tile_booleans[TILE_KEEP], // final boolean [][] tile_keep, // do not check occluded strong foreground
tile_booleans[TILE_IS_FG_STRONG], // final boolean [][] tile_fg_strong, // do not check occluded strong foreground
tile_booleans[TILE_STITCH], // final boolean [][] tile_stitch, // do not process these - there are duplicates
occlusion_frac, // final double occlusion_frac, // ratio of opaque pixel overlap to consider occlusion
width, // final int width,
transform_size); // final int transform_size);
final double [][] dbg_occluded_map = (dbg_prefix == null)? null:debugOccludedMap(occluded_map);
final double [][] occluded_textures = combineTexturesWithOcclusions(
sensor_texture, // final double [][][] sensor_texture,
gcombo_texture, // final double [][] combo_texture,
occluded_map); // final int [][] occluded_map);
// Processing BG
// final double occlusion_frac = 0.9;
// final double occlusion_min_disp = 0.3; // do not calculate occlusions for smaller disparity difference
final boolean en_cut = true; // enable change FG pixel to transparent from opaque
final boolean en_patch = true; // enable change FG pixel to opaque from transparent
final double fg_disp_diff = 1.0; // do not consider obscuring too close BG (1 pix or more?)
int max_trim_iterations = 1;
int [][] occluded_map = null;
double [][] dbg_occluded_map = null;
double [][] occluded_textures = null;
double [][] occluded_filled_textures = null;
boolean [][] sure_transparent = null;
boolean [][] sure_opaque = null;
double [][] debug_cost = (dbg_prefix != null) ? new double [trim_pixels.length][] : null;
boolean [][] trim_tiles = getTrimTiles(
trim_pixels, // boolean [][] trim_pix,
width, // final int width,
transform_size); // final int transform_size);
for (int niter = 0; niter <max_trim_iterations; niter++) {
occluded_map = getOccludedMap(
channel_pixel_offsets, // final double [][][][] channel_pixel_offsets,
unbound_alpha, // final boolean [][] alpha_pix,
slice_disparities, // final double [][] slice_disparities,
tile_booleans[TILE_KEEP], // final boolean [][] tile_keep, // do not check occluded strong foreground
tile_booleans[TILE_IS_FG_STRONG], // final boolean [][] tile_fg_strong, // do not check occluded strong foreground
tile_booleans[TILE_STITCH], // final boolean [][] tile_stitch, // do not process these - there are duplicates
occlusion_frac, // final double occlusion_frac, // ratio of opaque pixel overlap to consider occlusion
occlusion_min_disp, // final double occlusion_min_disp,
width, // final int width,
transform_size); // final int transform_size);
dbg_occluded_map = (dbg_prefix == null)? null:debugOccludedMap(occluded_map);
occluded_textures = combineTexturesWithOcclusions(
sensor_texture, // final double [][][] sensor_texture,
gcombo_texture, // final double [][] combo_texture,
occluded_map); // final int [][] occluded_map);
occluded_filled_textures = fillOcclusionsNaN(
gcombo_texture, // final double [][] combo_texture,
occluded_textures, // final double [][] combo_occluded_texture,
6*transform_size, // final int grow,
100, // final int num_passes,
0.001, // final double max_change,
width); // final int width)
sure_transparent = getTrimSeeds(
trim_pixels, // final boolean [][] trim_pix, // pixels that may be trimmed
null, // final boolean [][] seed_pix_in, // FG edge, just outside of trim_pix. Will be modified. Or null
vars[0], // final double [][] vars_same,
vars[1], // final double [][] vars_inter,
seed_same_fz, // final double seed_same_fz, // add to var_same in denominator
seed_fom_sure, // final double seed_fom, // minimal value of vars_inter/sqrt(vars_same)
seed_inter_sure, // final double seed_inter, // = 150;
width); // final int width)
sure_opaque = thresholdAnalog(
trim_fom_pix, // final double [][] data,
trim_fom_sure, // final double threshold,
true); // final boolean greater)
int updated_tiles = updateFgAlpha(
channel_pixel_offsets, // final double [][][][] channel_pixel_offsets,
occluded_filled_textures, // final double [][] textures,
unbound_alpha, // final boolean [][] alpha_pix,
gcombo_texture, // final double [][] combo_texture,
sensor_texture, // final double [][][] sensor_texture,
slice_disparities, // final double [][] slice_disparities,
tile_booleans[TILE_KEEP], // final boolean [][] tile_keep, // tiles that have at least one pixel
tile_booleans[TILE_STITCH], // final boolean [][] tile_stitch, // tiles that have at least one pixel
trim_tiles, // final boolean [][] trim_tiles, // tiles that have at least one pixel
trim_pixels, // final boolean [][] trim_pix, // pixels that may be trimmed
sure_transparent, // final boolean [][] transparent, // definitely transparent
sure_opaque, // final boolean [][] opaque, // definitely opaque
en_cut, // final boolean en_cut, // enable change FG pixel to transparent from opaque
en_patch, // final boolean en_patch, // enable change FG pixel to opaque from transparent
fg_disp_diff, // final double min_disp_diff, // do not consider obscuring too close BG (1 pix or more?)
// other parameters
debug_cost, // final double [][] debug_cost, // if not null, should be double [nslices][] - will return costs/NaN
width, // final int width,
transform_size); // final int transform_size){
if (dbg_prefix != null) {
System.out.println("updateFgAlpha() -> "+updated_tiles);
}
}
// Old processing
// maybe mask unbound_alpha with selected (TILE_KEEP) tiles for debug?
......@@ -5883,8 +6226,8 @@ public class TexturedModel {
dbg_occluded_map[nslice],
gcombo_texture[nslice],
occluded_filled_textures[nslice], // put before occluded_textures to compare with gcombo_texture
occluded_textures[nslice],
dbg_text_edge[nslice], // dbg_text_edge,
dbg_text_en[nslice],
dbg_fg_prefiltered[nslice], //
......@@ -5951,7 +6294,9 @@ public class TexturedModel {
"OCCLUSIONS_MAP",
"COMBO_TEXTURE",
"OCCLUDED_FILLED_TEXTURES",
"OCCLUDED_TEXTURES",
"TEXTURE_EDGE",
"TEXTURE_ON",
"TEXTURE_TRIMMED",
......@@ -6024,9 +6369,9 @@ public class TexturedModel {
for (int i = 0; i < unbound_alpha[nslice].length; i++) {
alphas[nslice][i] = unbound_alpha[nslice][i] ? 1.0 : 0.0;
}
textures_alphas[nslice] = new double [][] {out_textures[nslice], alphas[nslice]};
// textures_alphas[nslice] = new double [][] {out_textures[nslice], alphas[nslice]};
textures_alphas[nslice] = new double [][] {occluded_filled_textures[nslice], alphas[nslice]};
}
// set slice_disparities to NaN for unselected tiles - it will update tileClusters
setMeshTileSelection(
slice_disparities, // final double [][] slice_disparities,
......@@ -6418,10 +6763,12 @@ public class TexturedModel {
for (int nslice = 0; nslice < faded_textures.length; nslice++) {
faded_textures[nslice][0] = TileProcessor.fillNaNs(
faded_textures[nslice][0], // final double [] data,
null, // final boolean [] prohibit,
width, // int width,
16, // final int grow,
0.7, // double diagonal_weight, // relative to ortho
100, // int num_passes,
0.01, // final double max_rchange, // = 0.01
THREADS_MAX); // final int threadsMax) // maximal number of threads to launch
}
......
src/main/java/com/elphel/imagej/tileprocessor/TileNeibs.java
View file @ f810a996
......@@ -53,7 +53,11 @@ public class TileNeibs{
}
int sizeX;
int sizeY;
int last_grown; // actual grown until died
public int dirs = DIRS;
public int getLastGrown() {
return last_grown;
}
public TileNeibs(int size){
this.sizeX = size;
this.sizeY = size;
......@@ -815,6 +819,7 @@ public class TileNeibs{
final int sizeXm1 = sizeX - 1;
final int sizeYm1 = sizeY - 1;
// grow
int grow0 = grow; // requested steps
boolean hor = true;
final int dbg_tile = -82228; // 71992; //312/112 or 61800 for 360/96
int num_prev = 1; // as if previous pass was successful
......@@ -915,6 +920,7 @@ public class TileNeibs{
}
num_prev = anew.get();
}
last_grown = grow0 - grow;
}
......@@ -940,6 +946,7 @@ public class TileNeibs{
}
boolean [] src_tiles = tiles.clone(); // just in case
// grow
int grow0 = grow; // requested steps
boolean hor = true;
int num_prev = 1; // as if previous pass was successful
for (; grow > 0; grow--){
......@@ -997,6 +1004,7 @@ public class TileNeibs{
}
num_prev = num_new;
}
last_grown = grow0 - grow;
}
public boolean [] boundShape(
......
src/main/java/com/elphel/imagej/tileprocessor/TileProcessor.java
View file @ f810a996
......@@ -5030,6 +5030,7 @@ ImageDtt.startAndJoin(threads);
}
}
}
@Deprecated
public void growTiles(
int grow, // grow tile selection by 1 over non-background tiles 1: 4 directions, 2 - 8 directions, 3 - 8 by 1, 4 by 1 more
boolean [] tiles,
......@@ -5043,7 +5044,8 @@ ImageDtt.startAndJoin(threads);
this.tilesY);
}
// Use TileNeibs
@Deprecated
public static void growTiles(
int grow, // grow tile selection by 1 over non-background tiles 1: 4 directions, 2 - 8 directions, 3 - 8 by 1, 4 by 1 more
boolean [] tiles,
......@@ -8637,45 +8639,60 @@ ImageDtt.startAndJoin(threads);
return -1;
}
public static double [] fillNaNs(
final double [] data,
int width,
final int grow,
double diagonal_weight, // relative to ortho
int num_passes,
final int threadsMax) // maximal number of threads to launch
final double [] data,
final boolean [] prohibit,
int width,
final int grow,
double diagonal_weight, // relative to ortho
int num_passes,
final double max_rchange, // = 0.01
final int threadsMax) // maximal number of threads to launch
{
final int scan0 = ( 3* grow) / 2;
int height = data.length/width;
double wdiag = 0.25 *diagonal_weight / (diagonal_weight + 1.0);
double wortho = 0.25 / (diagonal_weight + 1.0);
final double [] neibw = {wortho, wdiag, wortho, wdiag, wortho, wdiag, wortho, wdiag};
final int tiles = width * height;
final boolean [] fixed = new boolean [tiles];
final boolean [] fixed = new boolean [tiles]; // Original non-NaN, will not be modified
int num_fixed = 0;
double davg = 0.0;
double davg = 0.0; // average of all fixed samples
double davg2 = 0.0; // average of all fixed samples
for (int i = 0; i < tiles; i++) {
if (!Double.isNaN(data[i])) {
fixed[i] = true;
num_fixed ++;
davg+= data[i];
davg += data[i];
davg2 += data[i] * data[i];
}
}
if (num_fixed > 0) {
davg /= num_fixed;
davg2 = Math.sqrt(davg2/num_fixed - davg*davg);
} else {
return null;
}
final double fdavg = davg;
final double max_change = Math.abs(davg2 * max_rchange);
final boolean [] grown = fixed.clone();
final TileNeibs tn = new TileNeibs(width, height);
tn.growSelection(
grow, // int grow, // grow tile selection by 1 over non-background tiles 1: 4 directions, 2 - 8 directions, 3 - 8 by 1, 4 by 1 more
grown, // final boolean [] tiles,
prohibit); // null); // final boolean [] prohibit)
int last_grown = tn.getLastGrown(); // actual grown (0 <= last_grown <= grow)
final int scan0 = last_grown/2 + 2; // ( 3* grow) / 2;
/*
growTiles(
grow, // grow tile selection by 1 over non-background tiles 1: 4 directions, 2 - 8 directions, 3 - 8 by 1, 4 by 1 more
grown,
null,
width,
height);
*/
int num_active = 0;
for (int i = 0; i < tiles; i++) {
if (grown[i] && !fixed[i]) num_active++;
......@@ -8684,19 +8701,18 @@ ImageDtt.startAndJoin(threads);
return data.clone();
}
final int [] active = new int [num_active];
final double [] data_in = data.clone();
final double [] data_out = new double [tiles];
final double [][] data_io = new double[2][];
data_io[0] = data.clone();
num_active = 0;
for (int i = 0; i < tiles; i++) {
if (grown[i] && !fixed[i]) {
active [num_active++] = i;
data_in[i] = davg; // initial value
// data_io[0][i] = davg; // initial value - needed?
}
}
final Thread[] threads = ImageDtt.newThreadArray(threadsMax);
// final int numThreads = threads.length;
final AtomicInteger ai = new AtomicInteger(0);
final AtomicInteger ati = new AtomicInteger(0);
//Set initial values
for (int ithread = 0; ithread < threads.length; ithread++) {
threads[ithread] = new Thread() {
......@@ -8715,52 +8731,70 @@ ImageDtt.startAndJoin(threads);
}
}
if (n > 0) {
data_in[nt] = s/n;
data_io[0][nt] = s/n;
} else {
data_in[nt] = fdavg;
data_io[0][nt] = fdavg;
}
}
}
};
}
ImageDtt.startAndJoin(threads);
data_io[1] = data_io[0].clone();
final double [] last_change = new double [threads.length];
for (int pass = 0; pass < num_passes; pass ++) {
ai.set(0);
ati.set(0);
Arrays.fill(last_change, 0.0);
for (int ithread = 0; ithread < threads.length; ithread++) {
threads[ithread] = new Thread() {
public void run() {
int ti = ati.getAndIncrement();
for (int iTile = ai.getAndIncrement(); iTile < active.length; iTile = ai.getAndIncrement()) {
int nt = active[iTile];
double s = 0.0;
double sw = 0.0;
for (int dir = 0; dir < 8; dir++) {
int nt1 = tn.getNeibIndex(nt, dir);
if ((nt1 >=0) && grown[nt1]) {
if (fixed[nt1]) {
s += data_io[0][nt1] * neibw[dir];
/* if (fixed[nt1]) {
s += data[nt1] * neibw[dir];
} else {
s += data_in[nt1] * neibw[dir];
s += data_io[0][nt1] * neibw[dir];
}
*/
sw += neibw[dir];
}
}
// sw should never be 0;
s /= sw;
data_out[nt] = s;
data_io[1][nt] = s;
last_change[ti] = Math.max(last_change[ti], Math.abs(data_io[1][nt]-data_io[0][nt]));
}
}
};
}
ImageDtt.startAndJoin(threads);
if (pass < (num_passes - 1)) {
System.arraycopy(data_out,0,data_in,0,tiles);
double multi_change = 0;
for (int i = 0; i < last_change.length; i++) {
multi_change = Math.max(multi_change, last_change[i]);
}
boolean done = (pass >= (num_passes - 1)) || (multi_change < max_change);
// System.out.println("fillNaNs(): pass="+pass+" change="+multi_change+" done="+done);
if (done) {
break;
} else { // swap data_io[0] <--> data_io[1]
double [] data_tmp = data_io[0];
data_io[0] = data_io[1];
data_io[1] = data_tmp;
}
}
for (int i = 0; i < tiles; i++) if (fixed[i]) {
data_out[i] = data[i];
}
return data_out;
// System.out.println("fillNaNs(): done");;
return data_io[1];
}
......
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