void horizontalruns()
{
unsigned x, y;
unsigned r, b, i, m;
// horizontal runs
for (y = 0; y < h; y++) {
b = 0, r = 0, i = 0;
runs[i] = 0;
for (x = 0; x < w; x++) {
if ((1 & f[y][x]) == b) {
r++;
continue;
}
b = 1 & f[y][x];
runs[i++] = r;
runs[i] = 0;
r = 1;
}
runs[i++] = r; // last
runs[i++] = 1; // edge
if (i < 6)
continue;
#if 0
i = despeckle(i);
if (i < 6)
continue;
#endif
r = 0;
for (x = 1; x < i - 4; x += 2) {
r += runs[x] + runs[x - 1];
if (!isfinder(x))
continue;
m = runs[x + 2];
for (b = 0; b < m; b++)
f[y][r + runs[x + 1] + b] |= 2;
}
}
}
void verticalruns()
{
unsigned x, y;
unsigned r, b, i, m;
// vertical runs
for (y = 0; y < w; y++) {
b = 0, r = 0, i = 0;
runs[i] = 0;
for (x = 0; x < h; x++) {
if ((1 & f[x][y]) == b) {
r++;
continue;
}
b = 1 & f[x][y];
runs[i++] = r;
runs[i] = 0;
r = 1;
}
runs[i++] = r;
runs[i++] = 1;
if (i < 6)
continue;
#if 0
i = despeckle(i);
if (i < 6)
continue;
#endif
r = 0;
for (x = 1; x < i - 4; x += 2) {
r += runs[x] + runs[x - 1];
if (!isfinder(x))
continue;
m = runs[x + 2];
for (b = 0; b < m; b++)
f[r + runs[x + 1] + b][y] |= 4;
}
}
}
int compose_result (Image *in, char* eval_name, char* regdes_name, char *outimg_name)
{
float class_level_weight[CLASSES + 1][MAX_LEVEL + 1];
int sx = in[0].sizeX(), sy = in[0].sizeY();
// read evaluation matrix
FILE *fp_eval= fopen(eval_name, "r");
for (int l = 0; l < MAX_LEVEL; l ++){
for (int i = 1; i < CLASSES + 1; i ++){
fscanf(fp_eval, "%f ", &(class_level_weight[i][l]));
cout<<class_level_weight[i][l];
}
fscanf(fp_eval, "\n");
cout<<endl;
}
fclose(fp_eval);
// auf volle Groesse resamplen
for (int l = 1; l < MAX_LEVEL; l ++)
in[l] = in[l].resampleNNplus(sx, sy);
// merge output image
Image out(typeid(unsigned char), sx, sy);
printf("analyzing images,\n");
float classes_f[CLASSES + 1];
float max; int imax;
for (int y = 0; y < sy; y ++)
{
for (int x = 0; x < sx; x ++)
{
memset(classes_f, 0, sizeof(float) * (CLASSES + 1));
for (int l = 0; l < MAX_LEVEL; l ++)
classes_f[in[l].getInt(x, y, 0)] += class_level_weight[in[l].getInt(x, y, 0)][l];
// classes_f[in[l].getInt(x, y, 0)] += 1.0;
max = 0;
imax = 0;
for (int i = 1; i < (CLASSES + 1); i ++)
{
if (classes_f[i] > max)
{
max = classes_f[i];
imax = i;
}
else if (classes_f[i] == max)
imax = 0;
}
out.set(x, y, imax);
}
printf("line: %05d of %05d\r", y, sy - 1);
}
printf("\n");
ImageT<unsigned char> label(out.sizeX(), out.sizeY(), 1);
for (int y = 0; y < out.sizeY(); y ++)
for (int x = 0; x < out.sizeX(); x ++)
{
label.set(x, y, out.getInt(x, y, 0));
}
cout << "despeckle, " << endl;
for (int i = 1; i < CLASSES + 1; i ++)
despeckle(label, 100, (unsigned char)i, (unsigned char)0);
ImageT<float> labelf(label.sizeX(), label.sizeY(), 1);
float valf;
for (int y = 0; y < label.sizeY(); y ++)
for (int x = 0; x < label.sizeX(); x ++)
{
valf = label.getFloat(x, y, 0);
if (valf)
labelf.set(x, y, valf);
else
labelf.set(x, y, NAN);
}
for (int l=0; l<MAX_LEVEL; l++)
in[l]= Image();
free;
#ifdef DEBUG_MSG
printf("writing output image.\n");
FILE *fp = fopen(outimg_name, "w");
labelf.write(fp);
fclose(fp);
#else
printf("relabel output image\n");
// relabel output image and write label description
ImageT<int> *labelimage;
labelimage= relabelOutput (out, outimg_name, regdes_name);
printf("writing output image\n");
FILE *fp = fopen(outimg_name, "w");
// labelf.write(fp);
labelimage->write(fp);
fclose(fp);
#endif
return (1);
}
int combine (Image *in, Image &mask, char* eval_name, char* path)
{
int classes[CLASSES + 1], c;
int refclasses[CLASSES + 1];
int falseclasses[CLASSES + 1];
float class_level_weight[CLASSES + 1][MAX_LEVEL + 1];
int sx = in[0].sizeX(), sy = in[0].sizeY();
// auf volle Groesse resamplen
for (int l = 0; l < MAX_LEVEL; l ++)
in[l] = in[l].resampleNNplus(sx, sy);
printf("calculating segmentation reliability,\n");
memset(class_level_weight, 0, sizeof(float) * (CLASSES + 1) * (MAX_LEVEL + 1));
for (int l = 0; l < MAX_LEVEL; l ++)
{
memset(classes, 0, sizeof(int) * (CLASSES + 1));
memset(refclasses, 0, sizeof(int) * (CLASSES + 1));
memset(falseclasses, 0, sizeof(int) * (CLASSES + 1));
for (int y = 0; y < sy; y ++)
{
for (int x = 0; x < sx; x ++)
{
c = mask.getInt(x, y, 0);
if (c)
{
refclasses[c] ++;
if (in[l].getInt(x, y, 0) == c)
classes[c] ++;
else
falseclasses[in[l].getInt(x, y, 0)] ++;
}
}
}
for (int j = 1; j < CLASSES + 1; j ++)
refclasses[0] += refclasses[j];
for (int j = 1; j < CLASSES + 1; j ++)
{
printf("level %d, class %d: %7d of %7d (%3d\%), false: %7d (%3d\%)\n", l, j, classes[j], refclasses[j], refclasses[j] ? classes[j] * 100 / refclasses[j] : 0, falseclasses[j], falseclasses[j] * 100 / (refclasses[0] - refclasses[j]));
// calculate the weight: hit percentage - false classification percentage
class_level_weight[j][l] = (float)classes[j] / (float)refclasses[j] - (float)falseclasses[j] / (float)(refclasses[0] - refclasses[j]);
class_level_weight[j][MAX_LEVEL] += class_level_weight[j][l];
}
}
// output of evaluation matrix
FILE *fp_eval= fopen(eval_name, "w");
printf("level c1 c2 c3 c4\n");
for (int l = 0; l < MAX_LEVEL; l ++)
{
printf("%5d: ", l);
for (int i = 1; i < CLASSES + 1; i ++)
{
class_level_weight[i][l] /= class_level_weight[i][MAX_LEVEL];
printf("%.3f ", class_level_weight[i][l]);
fprintf(fp_eval, "%.3f ", class_level_weight[i][l]);
}
printf("\n");
fprintf(fp_eval, "\n");
}
fclose(fp_eval);
// merge output image
Image out(typeid(unsigned char), sx, sy);
printf("analyzing images,\n");
float classes_f[CLASSES + 1];
float max; int imax;
for (int y = 0; y < sy; y ++)
{
for (int x = 0; x < sx; x ++)
{
memset(classes_f, 0, sizeof(float) * (CLASSES + 1));
for (int l = 0; l < MAX_LEVEL; l ++)
classes_f[in[l].getInt(x, y, 0)] += class_level_weight[in[l].getInt(x, y, 0)][l];
// classes_f[in[l].getInt(x, y, 0)] += 1.0;
max = 0;
imax = 0;
for (int i = 1; i < (CLASSES + 1); i ++)
{
if (classes_f[i] > max)
{
max = classes_f[i];
imax = i;
}
else if (classes_f[i] == max)
imax = 0;
}
out.set(x, y, imax);
}
printf("line: %05d of %05d\r", y, sy - 1);
}
printf("\n");
ImageT<unsigned char> label(out.sizeX(), out.sizeY(), 1);
for (int y = 0; y < out.sizeY(); y ++)
for (int x = 0; x < out.sizeX(); x ++)
{
label.set(x, y, out.getInt(x, y, 0));
}
cout << "despeckle, " << endl;
for (int i = 1; i < CLASSES + 1; i ++)
despeckle(label, 100, (unsigned char)i, (unsigned char)0);
ImageT<float> labelf(label.sizeX(), label.sizeY(), 1);
char name[255];
float valf;
sprintf (name, "%s/out.pfm", path);
printf("writing output image:%s\n", name);
for (int y = 0; y < label.sizeY(); y ++)
for (int x = 0; x < label.sizeX(); x ++)
{
valf= label.getFloat(x, y, 0);
if (valf)
labelf.set(x, y, valf);
else
labelf.set(x, y, NAN);
}
FILE *fp = fopen(name, "w");
labelf.write(fp);
fclose(fp);
return (1);
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpRunMode run_mode;
GimpPDBStatusType status;
static GimpParam values[1];
INIT_I18N ();
/*
* Initialize parameter data...
*/
status = GIMP_PDB_SUCCESS;
run_mode = param[0].data.d_int32;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
/*
* Get drawable information...
*/
drawable = gimp_drawable_get (param[2].data.d_drawable);
/*
* See how we will run
*/
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE :
/*
* Possibly retrieve data...
*/
gimp_get_data (PLUG_IN_PROC, &despeckle_radius);
/*
* Get information from the dialog...
*/
if (gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id))
{
if (! despeckle_dialog ())
return;
}
break;
case GIMP_RUN_NONINTERACTIVE:
/*
* Make sure all the arguments are present...
*/
if (nparams < 4 || nparams > 9)
status = GIMP_PDB_CALLING_ERROR;
else if (nparams == 4)
{
despeckle_radius = param[3].data.d_int32;
filter_type = FILTER_ADAPTIVE;
black_level = 7;
white_level = 248;
}
else if (nparams == 5)
{
despeckle_radius = param[3].data.d_int32;
filter_type = param[4].data.d_int32;
black_level = 7;
white_level = 248;
}
else if (nparams == 6)
{
despeckle_radius = param[3].data.d_int32;
filter_type = param[4].data.d_int32;
black_level = param[5].data.d_int32;
white_level = 248;
}
else
{
despeckle_radius = param[3].data.d_int32;
filter_type = param[4].data.d_int32;
black_level = param[5].data.d_int32;
white_level = param[6].data.d_int32;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/*
* Possibly retrieve data...
*/
INIT_I18N();
gimp_get_data (PLUG_IN_PROC, despeckle_vals);
break;
default:
status = GIMP_PDB_CALLING_ERROR;
break;
}
/*
* Despeckle the image...
*/
if (status == GIMP_PDB_SUCCESS)
{
if (gimp_drawable_is_rgb(drawable->drawable_id) ||
gimp_drawable_is_gray(drawable->drawable_id))
{
/*
* Run!
*/
despeckle ();
/*
* If run prevmode is interactive, flush displays...
*/
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush ();
/*
* Store data...
*/
if (run_mode == GIMP_RUN_INTERACTIVE)
gimp_set_data (PLUG_IN_PROC,
despeckle_vals, sizeof (despeckle_vals));
}
else
status = GIMP_PDB_EXECUTION_ERROR;
}
/*
* Reset the current run status...
*/
values[0].data.d_status = status;
/*
* Detach from the drawable...
*/
gimp_drawable_detach (drawable);
}
/* at_splines_new_full modify its argument: BITMAP
when despeckle, quantize and/or thin_image are invoked. */
at_splines_type *
at_splines_new_full (at_bitmap * bitmap,
at_fitting_opts_type * opts,
at_msg_func msg_func,
gpointer msg_data,
at_progress_func notify_progress,
gpointer progress_data,
at_testcancel_func test_cancel,
gpointer testcancel_data)
{
image_header_type image_header;
at_splines_type * splines = NULL;
pixel_outline_list_type pixels;
QuantizeObj *myQuant = NULL; /* curently not used */
at_exception_type exp = at_exception_new(msg_func, msg_data);
at_distance_map dist_map, *dist = NULL;
#define CANCELP (test_cancel && test_cancel(testcancel_data))
#define FATALP (at_exception_got_fatal(&exp))
#define FREE_SPLINE() do {if (splines) {at_splines_free(splines); splines = NULL;}} while(0)
#define CANCEL_THEN_CLEANUP_DIST() if (CANCELP) goto cleanup_dist;
#define CANCEL_THEN_CLEANUP_PIXELS() if (CANCELP) {FREE_SPLINE(); goto cleanup_pixels;}
#define FATAL_THEN_RETURN() if (FATALP) return splines;
#define FATAL_THEN_CLEANUP_DIST() if (FATALP) goto cleanup_dist;
#define FATAL_THEN_CLEANUP_PIXELS() if (FATALP) {FREE_SPLINE(); goto cleanup_pixels;}
if (opts->despeckle_level > 0)
{
despeckle (bitmap,
opts->despeckle_level,
opts->despeckle_tightness,
opts->noise_removal,
&exp);
FATAL_THEN_RETURN();
}
image_header.width = at_bitmap_get_width(bitmap);
image_header.height = at_bitmap_get_height(bitmap);
if (opts->color_count > 0)
{
quantize (bitmap, opts->color_count, opts->background_color, &myQuant, &exp);
if (myQuant)
quantize_object_free(myQuant); /* curently not used */
FATAL_THEN_RETURN();
}
if (opts->centerline)
{
if (opts->preserve_width)
{
/* Preserve line width prior to thinning. */
dist_map = new_distance_map(bitmap, 255, /*padded=*/TRUE, &exp);
dist = &dist_map;
FATAL_THEN_RETURN();
}
/* Hereafter, dist is allocated. dist must be freed if
the execution is canceled or exception is raised;
use FATAL_THEN_CLEANUP_DIST. */
thin_image (bitmap, opts->background_color, &exp);
FATAL_THEN_CLEANUP_DIST()
}
/* Hereafter, pixels is allocated. pixels must be freed if
the execution is canceled; use CANCEL_THEN_CLEANUP_PIXELS. */
if (opts->centerline)
{
at_color background_color = { 0xff, 0xff, 0xff };
if (opts->background_color)
background_color = *opts->background_color;
pixels = find_centerline_pixels(bitmap, background_color,
notify_progress, progress_data,
test_cancel, testcancel_data, &exp);
}
else
pixels = find_outline_pixels(bitmap, opts->background_color,
notify_progress, progress_data,
test_cancel, testcancel_data, &exp);
FATAL_THEN_CLEANUP_DIST();
CANCEL_THEN_CLEANUP_DIST();
XMALLOC(splines, sizeof(at_splines_type));
*splines = fitted_splines (pixels, opts, dist,
image_header.width,
image_header.height,
&exp,
notify_progress, progress_data,
test_cancel, testcancel_data);
FATAL_THEN_CLEANUP_PIXELS();
CANCEL_THEN_CLEANUP_PIXELS();
if (notify_progress)
notify_progress(1.0, progress_data);
cleanup_pixels:
free_pixel_outline_list (&pixels);
cleanup_dist:
if (dist)
free_distance_map (dist);
return splines;
#undef CANCELP
#undef FATALP
#undef FREE_SPLINE
#undef CANCEL_THEN_CLEANUP_DIST
#undef CANCEL_THEN_CLEANUP_PIXELS
#undef FATAL_THEN_RETURN
#undef FATAL_THEN_CLEANUP_DIST
#undef FATAL_THEN_CLEANUP_PIXELS
}
