Removed some obsolete code/debug (4d7174ad) · Commits · Elphel / imagej-elphel

src/main/java/com/elphel/imagej/tileprocessor/TexturedModel.java

+18 −212

Original line number	Original line	Diff line number	Diff line
	@@ -4914,7 +4914,7 @@ public class TexturedModel {
	final AtomicInteger aminus = new AtomicInteger(0); // number of removed opaque pixels		final AtomicInteger aminus = new AtomicInteger(0); // number of removed opaque pixels
	final TileNeibs pn = new TileNeibs(width,height);		final TileNeibs pn = new TileNeibs(width,height);
	int num_modified_pixels = 0;		int num_modified_pixels = 0;
	final int dbg_pix = 168170;		final int dbg_pix = -168170;
	final boolean [][] new_alpha = new boolean[num_slices][img_size];		final boolean [][] new_alpha = new boolean[num_slices][img_size];
	for (int nslice = 0; nslice < num_slices; nslice++) {		for (int nslice = 0; nslice < num_slices; nslice++) {
	int fnslice = nslice;		int fnslice = nslice;
	@@ -5786,8 +5786,8 @@ public class TexturedModel {
	(combo_texture_in != null) ?		(combo_texture_in != null) ?
	combo_texture_in :		combo_texture_in :
	getComboTexture (sensor_texture);		getComboTexture (sensor_texture);
	double [][][] dbg_out = (dbg_prefix != null) ? new double [6][][] : null;		////// double [][][] dbg_out = (dbg_prefix != null) ? new double [6][][] : null;
	boolean [][][] dbg_bool = (dbg_prefix != null) ? new boolean [5][][] : null;		// boolean [][][] dbg_bool = (dbg_prefix != null) ? new boolean [5][][] : null;

	// New processing		// New processing

	@@ -6053,7 +6053,7 @@ public class TexturedModel {
	final boolean en_patch = true; // enable change FG pixel to opaque from transparent		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?)		final double fg_disp_diff = 1.0; // do not consider obscuring too close BG (1 pix or more?)
	final int min_sensors = 4; // minimal number of sensors visible from the FG pixel		final int min_sensors = 4; // minimal number of sensors visible from the FG pixel
	final double weight_neib = 2.0; // 1.0; // weight of same neighbors - add to cost multiplied by num_neib-4		final double weight_neib = 3.0; // 2.0; // 1.0; // weight of same neighbors - add to cost multiplied by num_neib-4
	final double weight_bg = 0.9; // 0.8; // 1.0; // 15.0/16; // 1.0; // weight of BG cost relative to the FG one		final double weight_bg = 0.9; // 0.8; // 1.0; // 15.0/16; // 1.0; // weight of BG cost relative to the FG one
	// final double weight_bg2 = 0.0; // fraction of BG variance cost (1-weight_bg2) - the BG true one		// final double weight_bg2 = 0.0; // fraction of BG variance cost (1-weight_bg2) - the BG true one
	final double best_dir_frac = 0.6; // for BG - use this fraction of all sensors in the best direction		final double best_dir_frac = 0.6; // for BG - use this fraction of all sensors in the best direction
	@@ -6200,169 +6200,19 @@ public class TexturedModel {
	}		}
	}		}

			double [][] alphas = new double[num_slices][];
	// Old processing
	// maybe mask unbound_alpha with selected (TILE_KEEP) tiles for debug?

	final boolean [][][] fg_has_bg = get_fg_has_bg_any(
	slice_disparities, // final double [][] slice_disparities,
	slice_border_int, // final int [][] slice_border_int,
	// border_int_max, // final int border_int_max,
	max_disparity_lim, // final double max_disparity_lim,
	min_trim_disparity, // final double min_trim_disparity,
	transform_size, // final int transform_size,
	tilesX); // final int tilesX)
	showDebugBordersInt (
	slice_border_int, // final int [][] border_int,
	tilesX, // final int tilesX,
	dbg_prefix); // String prefix);

	showDebugDisparities( // nop if dbg_prefix== null
	slice_disparities, // final double [][] slice_disparities,
	tilesX, // final int tilesX,
	dbg_prefix); // String prefix);
	showDebugFgBg( // nop if dbg_prefix== null
	fg_has_bg, // boolean [][][] fg_has_bg,
	tilesX, // final int tilesX,
	dbg_prefix); // String prefix);
	final boolean [][] texture_on = getAllTexturePixels (
	gcombo_texture, // final double [][] combo_texture,
	fg_has_bg[2], // final boolean [][] tile_on,
	width, // final int width,
	transform_size); // final int transform_size)
	if (dbg_bool != null) dbg_bool[0] = copyTexture(texture_on); // all texture
	// Get vars_same, vars_inter and in debug mode - also
	// final double[][][] vars = getVariances (
	// sensor_texture, // final double [][][] sensor_texture,
	// gcombo_texture, // final double [][] combo_texture,
	// var_radius, // final double var_radius,
	// width); // final int width,
	// get edge pixels
	final boolean [][] texture_edge = getEdgeTexturePixels(
	texture_on, // final boolean [][] texture_on,
	width, // final int width,
	trim_edge); // final int trim_edge)

	final boolean [][] texture_fg_filt = filterFgByVariances( // OK if fg_has_bg[0,1] is for non-existing tile
	gcombo_texture, // final double [][] combo_texture,
	texture_on, // final boolean [][] texture_on, // if null will rely on NaN in combo_texture
	vars[0], // final double [][] vars_same,
	vars[1], // final double [][] vars_inter,
	fg_has_bg[0], // final boolean [][] is_fg_tile,
	fg_has_bg[1], // final boolean [][] has_bg_tile,
	fg_max_inter, // final double fg_max_inter,
	fg_max_rel, // final double fg_max_rel,
	width, // final int width,
	transform_size); // final int transform_size);
	if (dbg_bool != null) dbg_bool[1] = copyTexture(texture_fg_filt); // filter FG by variances

	trimFgEdgeVariancePixels(
	texture_fg_filt, // final boolean [][] texture_en,
	texture_edge, // final boolean [][] texture_edge,
	fg_has_bg[0], // final boolean [][] is_fg_tile,
	fg_has_bg[1], // final boolean [][] has_bg_tile,
	vars[0], // final double [][] variance,
	min_edge_variance, // final int min_variance,
	width, // final int width,
	transform_size); // final int transform_size); // final int transform_size)

	if (dbg_bool != null) dbg_bool[2] = copyTexture(texture_fg_filt); // filter FG by edge variances

	// debug-copy texture_fg_filt as it will be modified in the next step

	trimFgEdgePixels(
	texture_fg_filt, // final boolean [][] texture_filt, //** Will be modified
	texture_edge, // final boolean [][] texture_edge,
	fg_has_bg[0], // final boolean [][] is_fg_tile,
	fg_has_bg[1], // final boolean [][] has_bg_tile,
	trim_edge_center,// final int trim_edge_center,
	width, // final int width,
	transform_size); // final int transform_size)

	// debug-copy texture_fg_filt as it will be modified in the next step
	// dbg_texture_fg_pre_filt[nslice] = texture_fg_filt[nslice].clone();
	if (dbg_bool != null) dbg_bool[3] = copyTexture(texture_fg_filt); // filter by edges
	filterSelections(
	texture_fg_filt, // final boolean [][] selections, // ** will be modified
	min_neibs, // final int min_neibs,
	trim_grow, // final int grow,
	trim_shrink, // final int shrink,
	width); // final int width)
	if (dbg_bool != null) dbg_bool[4] = copyTexture(texture_fg_filt); // filter by size

	// TODO: Create BG generation using FG textures and predicting occlusions

	double [][] out_textures = processBgOcclusions(
	sensor_texture, // final double [][][] sensor_texture,
	gcombo_texture, // final double [][] combo_texture,
	texture_fg_filt, // final boolean [][] selections,
	fg_has_bg[0], // final boolean [][] is_fg_tile,
	fg_has_bg[1], // final boolean [][] has_bg_tile,
	vars[1], // final double [][] vars_inter,
	dir_radius, // double dir_radius,
	width, // final int width,
	transform_size, // final int transform_size,
	try_dir_var, // final double try_dir_var, // 20.0; // try directional if the intersensor variance exceeds this value
	dir_num_start, // final int dir_num_start, // 7; // start with this number of consecutive sensors
	dir_num_restart, // final int dir_num_restart, // 5; // restart (from best direction) with this number of consecutive sensors
	dir_var_max, // final double dir_var_max, // 15.0; // do not add more sensors if the variance would exceed this
	dir_worsen_rel, // final double dir_worsen_rel, // 0.15;// add more sensors until variance grows by this relative
	dbg_out); // final double [][][] dbg_out); // [5][][]
	// No - need to preserve un-trimmed textures (for UM filter) and generate a separate alpha
	/*
	applyTextureSelection(
	texture_fg_filt, // final boolean [][] selections,
	out_textures); // final double [][] combo_texture // will be modified - NaN where not selected
	*/

	double [][] alphas = generateTileAlphas(
	fg_has_bg[2], // boolean [][] texture_tiles,
	width, // int width,
	transform_size); // int transform_size)

	if (dbg_out != null) dbg_out[5] = copyTexture(alphas); // alpha after tile borders

	generateFgAlphas(
	texture_fg_filt, // final boolean [][] texture_en, // non-transparent texture pixels
	alphas, // final double [][] alphas, // or null will be updated
	edge_transparent, // final int edge, // now should be 2 or 1
	edge_weight, // final double border_alpha, // alpha along the border
	width, // final int width,
	transform_size); // final int transform_size)


	if (dbg_prefix != null) {
	final double [][] gtext_fg_filt = dbgBooleanTexture (texture_fg_filt, -1000, 1000); // texture filtered by fg trim
	final double [][] dbg_text_edge = dbgBooleanTexture (texture_edge, -1000, 1000);
	final double [][] dbg_text_en = dbgBooleanTexture (dbg_bool[0], -1000, 1000);
	final double [][] dbg_fg_prefiltered = dbgBooleanTexture (dbg_bool[1], -1000, 1000);
	final double [][] dbg_text_edge_var = dbgBooleanTexture (dbg_bool[2], -1000, 1000);
	final double [][] dbg_fg_prefiltered_neibs = dbgBooleanTexture (dbg_bool[3], -1000, 1000);

	final double [][] tdbg_is_fg = dbgBooleanTexture (fg_has_bg[1], fg_has_bg[0], 0,1,2,3);
	final double [][] gdbg_is_fg = new double [tdbg_is_fg.length][width*height];
	for (int nslice = 0; nslice < num_slices; nslice++) {		for (int nslice = 0; nslice < num_slices; nslice++) {
	for (int i = 0; i < gdbg_is_fg[0].length; i++) {		// replace old alpha with the new binary one
	int tileX = (i % width)/transform_size;		alphas[nslice] = new double [unbound_alpha[nslice].length];
	int tileY = (i / width)/transform_size;		for (int i = 0; i < unbound_alpha[nslice].length; i++) {
	int tile = tileX + tilesX * tileY;		alphas[nslice][i] = unbound_alpha[nslice][i] ? 1.0 : 0.0;
	gdbg_is_fg[nslice][i] = tdbg_is_fg[nslice][tile];
	}		}
	}		}

			if (dbg_prefix != null) {
	final double [][] dbg_out_textures = new double [num_slices][];
	for (int nslice = 0; nslice < num_slices; nslice++) {
	dbg_out_textures[nslice] = out_textures[nslice].clone();
	}
	applyTextureSelection(
	texture_fg_filt, // final boolean [][] selections,
	dbg_out_textures); // final double [][] combo_texture // will be modified - NaN where not selected

	for (int nslice = 0; nslice < num_slices; nslice++) {		for (int nslice = 0; nslice < num_slices; nslice++) {
	final double [] vars_ratio = new double [img_size];		final double [] vars_ratio = new double [img_size];
	final double [] vars_fom = new double [img_size]; // inter/sqrt(same)		final double [] vars_fom = new double [img_size]; // inter/sqrt(same)
	final double [] vars_dir_ratio = new double [img_size];
	final double [] half_pix = new double [img_size];		final double [] half_pix = new double [img_size];
	final double [] stitch_trim_pix = new double [img_size];		final double [] stitch_trim_pix = new double [img_size];
	final double [] trim_seed_pix = new double [img_size];		final double [] trim_seed_pix = new double [img_size];
	@@ -6405,15 +6255,11 @@ public class TexturedModel {
	for (int i = 0; i <img_size; i++) {		for (int i = 0; i <img_size; i++) {
	vars_ratio[i] = vars[0][nslice][i]/(vars[1][nslice][i]+trim_inter_fz);		vars_ratio[i] = vars[0][nslice][i]/(vars[1][nslice][i]+trim_inter_fz);
	vars_fom[i] = vars[1][nslice][i]/(vars[0][nslice][i]+seed_same_fz);		vars_fom[i] = vars[1][nslice][i]/(vars[0][nslice][i]+seed_same_fz);
	//vars[0][nslice]
	if (Double.isNaN(vars_ratio[i])) vars_ratio[i] = 0;		if (Double.isNaN(vars_ratio[i])) vars_ratio[i] = 0;
	if (Double.isNaN(vars_fom[i])) vars_fom[i] = 0;		if (Double.isNaN(vars_fom[i])) vars_fom[i] = 0;
	for (int k = 0; k < vars.length; k++) {		for (int k = 0; k < vars.length; k++) {
	if (Double.isNaN(vars[k][nslice][i])) vars[k][nslice][i] = 0;		if (Double.isNaN(vars[k][nslice][i])) vars[k][nslice][i] = 0;
	}		}

	vars_dir_ratio[i] = vars[0][nslice][i]/dbg_out[1][nslice][i]; //vars_dir_final;
	// grad_abs_over_same[i] = vars[4][nslice][i] / (vars[0][nslice][i]+seed_same_fz);
	ridges_pix[i] =		ridges_pix[i] =
	(trim_pixels [nslice][i]? 1.0:0.0) +		(trim_pixels [nslice][i]? 1.0:0.0) +
	(ridges [i]? 2.0:0.0);		(ridges [i]? 2.0:0.0);
	@@ -6475,12 +6321,6 @@ public class TexturedModel {
	fom_dbg[2][nslice],		fom_dbg[2][nslice],
	fom_dbg[3][nslice],		fom_dbg[3][nslice],
	vars_fom,		vars_fom,
	dbg_out[0][nslice], // gdbg_vars_dir_initial[nslice],
	dbg_out[1][nslice], // gdbg_vars_dir_final[nslice],
	dbg_out[2][nslice], // gdbg_dirs_initial[nslice],
	dbg_out[3][nslice], // gdbg_dirs_final[nslice],
	dbg_out[4][nslice], // gdbg_dirs_len[nslice],
	vars_dir_ratio,
	half_pix,		half_pix,
	stitch_trim_pix,		stitch_trim_pix,
	trim_seed_pix,		trim_seed_pix,
	@@ -6496,18 +6336,6 @@ public class TexturedModel {
	gcombo_texture[nslice],		gcombo_texture[nslice],
	occluded_filled_textures[nslice], // put before occluded_textures to compare with gcombo_texture		occluded_filled_textures[nslice], // put before occluded_textures to compare with gcombo_texture
	occluded_textures[nslice],		occluded_textures[nslice],
	dbg_text_edge[nslice], // dbg_text_edge,
	dbg_text_en[nslice],
	dbg_fg_prefiltered[nslice], //
	dbg_text_edge_var[nslice], //
	dbg_fg_prefiltered_neibs[nslice],
	gtext_fg_filt[nslice], //dbg_fg_filtered[nslice],
	gdbg_is_fg[nslice],
	// gcombo_texture[nslice],
	out_textures [nslice], // dirs_avg,
	dbg_out_textures[nslice],
	dbg_out[5][nslice],
	alphas[nslice],
	sensor_texture[nslice][ 0],		sensor_texture[nslice][ 0],
	sensor_texture[nslice][ 1],		sensor_texture[nslice][ 1],
	sensor_texture[nslice][ 2],		sensor_texture[nslice][ 2],
	@@ -6543,12 +6371,6 @@ public class TexturedModel {
	"TRIM_FOM_THRESH", // var_same_thresholded		"TRIM_FOM_THRESH", // var_same_thresholded
	"TRIM_FOM_THRESH_BLUR", // var_same_thresholded_blured		"TRIM_FOM_THRESH_BLUR", // var_same_thresholded_blured
	"SEED_FOM", // inter/(same+seed_same_fz)		"SEED_FOM", // inter/(same+seed_same_fz)
	"VAR_DIR_INITIAL",
	"VAR_DIR_FINAL",
	"DIR_INITIAL",
	"DIR_FINAL",
	"LEN",
	"DIR_RATIO",
	"HALF_BG_FG",		"HALF_BG_FG",
	"STITCH_TRIM",		"STITCH_TRIM",
	"TRIM_SEED",		"TRIM_SEED",
	@@ -6564,19 +6386,6 @@ public class TexturedModel {
	"COMBO_TEXTURE",		"COMBO_TEXTURE",
	"OCCLUDED_FILLED_TEXTURES",		"OCCLUDED_FILLED_TEXTURES",
	"OCCLUDED_TEXTURES",		"OCCLUDED_TEXTURES",

	"TEXTURE_EDGE",
	"TEXTURE_ON",
	"TEXTURE_TRIMMED",
	"TEXTURE_TRIMMED_EDGE_VAR",
	"TEXTURE_TRIMMED_EDGED",
	"TEXTURE_FG_FILTERED",
	"IS_FG",
	// "COMBO_TEXTURE",
	"OUT_TEXTURE_BG",
	"OUT_TEXTURE_FG",
	"TILE_ALPHA",
	"TEXTURE_ALPHA",
	"T00",		"T00",
	"T01",		"T01",
	"T02",		"T02",
	@@ -6603,8 +6412,9 @@ public class TexturedModel {
	dbg_titles);		dbg_titles);
	assert true;		assert true;
	}		}

	ShowDoubleFloatArrays.showArrays(		ShowDoubleFloatArrays.showArrays(
	out_textures,		occluded_filled_textures, // out_textures,
	width,		width,
	height,		height,
	true,		true,
	@@ -6618,26 +6428,22 @@ public class TexturedModel {

	double [][] masked_textures = combineTextureAlpha(		double [][] masked_textures = combineTextureAlpha(
	0.5, // final double alpha_threshold,		0.5, // final double alpha_threshold,
	out_textures, // final double [][] textures,		occluded_filled_textures, // out_textures, // final double [][] textures,
	alphas); // final double [][] alphas		alphas); // final double [][] alphas

	ShowDoubleFloatArrays.showArrays(		ShowDoubleFloatArrays.showArrays(
	masked_textures,		masked_textures,
	width,		width,
	height,		height,
	true,		true,
	dbg_prefix+"-masked_textures");		dbg_prefix+"-masked_textures");

	}		}

	double [][][] textures_alphas = new double [num_slices][][];		double [][][] textures_alphas = new double [num_slices][][];
	//unbound_alpha
	for (int nslice = 0; nslice < num_slices; nslice++) {		for (int nslice = 0; nslice < num_slices; nslice++) {
	// replace old alpha with the new binary one		alphas[nslice] = new double [unbound_alpha[nslice].length];
	for (int i = 0; i < unbound_alpha[nslice].length; i++) {		for (int i = 0; i < unbound_alpha[nslice].length; i++) {
	alphas[nslice][i] = unbound_alpha[nslice][i] ? 1.0 : 0.0;		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 [][] {occluded_filled_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		// set slice_disparities to NaN for unselected tiles - it will update tileClusters

Admin message