edges.c

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <config.h>

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <math.h>

#ifdef EDGES_HAVE_DMALLOC
#include <dmalloc.h>
#endif

#include <jwsc/base/error.h>
#include <jwsc/base/option.h>
#include <jwsc/matrix/matrix.h>
#include <jwsc/image/image.h>
#include <jwsc/image/image_io.h>
#include <jwsc/image/edge.h>


#define DEFAULT_BEGIN_MAG_THRESH  0.05f
#define DEFAULT_END_MAG_THRESH    0.025f
#define DEFAULT_BREAK_DP_THRESH  -1.0f
#define DEFAULT_BREAK_DP_NUM_AVG  1
#define DEFAULT_SIGMA             1.0f
#define DEFAULT_SAMPLE_RATE       1.0f
#define DEFAULT_MIN_LEN           1
#define DEFAULT_SEED              289375
#define DEFAULT_RANDOM_COLOR      0

#define NUM_OPTS_NO_ARG   3
#define NUM_OPTS_WITH_ARG 12


static Option_no_arg opts_no_arg[NUM_OPTS_NO_ARG];

static Option_with_arg opts_with_arg[NUM_OPTS_WITH_ARG];


static const char* map_fname = NULL;

static const char* color_fname = NULL;

static const char* edges_in_fname = NULL;

static const char* edges_out_fname = NULL;

static float begin_mag_thresh = DEFAULT_BEGIN_MAG_THRESH;

static float end_mag_thresh = DEFAULT_END_MAG_THRESH;

static float break_dp_thresh = DEFAULT_BREAK_DP_THRESH;

static uint32_t break_dp_num_avg = DEFAULT_BREAK_DP_NUM_AVG;

static float sigma = DEFAULT_SIGMA;

static float sample_rate = DEFAULT_SAMPLE_RATE;

static uint32_t min_len = DEFAULT_MIN_LEN;

static uint32_t seed = DEFAULT_MIN_LEN;

static uint8_t random_color = DEFAULT_RANDOM_COLOR;


static void print_usage(void)
{
    fprintf(stderr, "usage: edges OPTIONS 'image'\n");
    fprintf(stderr, "where OPTIONS is one or more of the following:\n");
    print_options(stderr, 25, NUM_OPTS_NO_ARG, opts_no_arg, NUM_OPTS_WITH_ARG, 
            opts_with_arg);
}

static Error* process_help_opt(void)
{
    print_usage();
    exit(EXIT_SUCCESS);
    return NULL;
}

static Error* process_version_opt(void)
{
    fprintf(stderr, "%s\n", EDGES_PACKAGE_STRING);
    exit(EXIT_SUCCESS);
    return NULL;
}

static Error* process_random_color_opt(void)
{
    random_color = 1;
    return NULL;
}

static Error* process_color_out_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'color-out' requires an argument");
    }
    color_fname = arg;
    return NULL;
}

static Error* process_map_out_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'map-out' requires an argument");
    }
    map_fname = arg;
    return NULL;
}

static Error* process_edges_in_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'edges-in' requires an argument");
    }
    edges_in_fname = arg;
    return NULL;
}

static Error* process_edges_out_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'edges-out' requires an argument");
    }
    edges_out_fname = arg;
    return NULL;
}

static Error* process_begin_mag_thresh_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'begin-mag-thresh' requires an argument");
    }
    if (sscanf(arg, "%f", &begin_mag_thresh) != 1 || begin_mag_thresh < 0)
    {
        return JWSC_EARG("Option 'begin-mag-thresh' must be >= 0");
    }
    return NULL;
}

static Error* process_end_mag_thresh_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'end-mag-thresh' requires an argument");
    }
    if (sscanf(arg, "%f", &end_mag_thresh) != 1 || end_mag_thresh < 0)
    {
        return JWSC_EARG("Option 'end-mag-thresh' must be >= 0");
    }
    return NULL;
}

static Error* process_break_dp_thresh_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'break-dp-thresh' requires an argument");
    }
    if (sscanf(arg, "%f", &break_dp_thresh) != 1 || break_dp_thresh < -1 || 
            break_dp_thresh > 1)
    {
        return JWSC_EARG("Option 'break-dp-thresh' must be in [-1,1]");
    }
    return NULL;
}

static Error* process_break_dp_num_avg_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'break-dp-num-avg' requires an argument");
    }
    if (sscanf(arg, "%u", &break_dp_num_avg) != 1 || break_dp_num_avg < 1)
    {
        return JWSC_EARG("Option 'break-dp-num-avg' must be >= 1");
    }
    return NULL;
}

static Error* process_sigma_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'sigma' requires an argument");
    }
    if (sscanf(arg, "%f", &sigma) != 1 || sigma <= 0)
    {
        return JWSC_EARG("Option 'sigma' must be > 0");
    }
    return NULL;
}

static Error* process_sample_rate_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'sample-rate' requires an argument");
    }
    if (sscanf(arg, "%f", &sample_rate) != 1 || sample_rate <= 0 ||
            sample_rate > 1.0)
    {
        return JWSC_EARG("Option 'sample-rate' must be in (0,1]");
    }
    return NULL;
}

static Error* process_min_len_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'min-len' requires an argument");
    }
    if (sscanf(arg, "%u", &min_len) != 1)
    {
        return JWSC_EARG("Option 'min-len' requires an argument");
    }
    return NULL;
}

static Error* process_seed_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'seed' requires an argument");
    }
    if (sscanf(arg, "%u", &seed) != 1)
    {
        return JWSC_EARG("Option 'seed' requires an argument");
    }
    return NULL;
}




int main(int argc, const char** argv)
{
    uint32_t    num_rows, num_cols;
    uint32_t    i, j;
    int         argi;
    const char* input_fname;

    Pixel_f pxl;

    Image_f*      img_in  = NULL;
    Image_f*      img_out = NULL;
    Matrix_f*     m       = NULL;
    Error*        e       = NULL;
    Edge_set_f*   edges   = NULL;
    Edge_point_f* pt      = NULL;

    /* Init the options. */
    init_option_no_arg(&(opts_no_arg[0]), "help", 'h', 
            "Prints program usage.", process_help_opt);
    init_option_no_arg(&(opts_no_arg[1]), "version", 'v', 
            "Prints program version.", process_version_opt);
    init_option_no_arg(&(opts_no_arg[2]), "random-color", 0, 
            "Color edges with random selected different colors.", 
            process_random_color_opt);
    init_option_with_arg(&(opts_with_arg[0]), "color-out", 0, 
            "Original image with edges colored.", process_color_out_opt);
    init_option_with_arg(&(opts_with_arg[1]), "map-out", 0, 
            "Bi-level image edge map.", process_map_out_opt);
    init_option_with_arg(&(opts_with_arg[2]), "edges-in", 0, 
            "File to read ASCII formatted edge set from.", 
            process_edges_in_opt);
    init_option_with_arg(&(opts_with_arg[3]), "edges-out", 0, 
            "File to write ASCII formatted edge set to.", 
            process_edges_out_opt);
    init_option_with_arg(&(opts_with_arg[4]), "begin-mag-thresh", 0, 
            "Hysterisis starting gradient magnitude threshold.", 
            process_begin_mag_thresh_opt);
    init_option_with_arg(&(opts_with_arg[5]), "end-mag-thresh", 0, 
            "Hysterisis stopping gradient magnitude threshold.", 
            process_end_mag_thresh_opt);
    init_option_with_arg(&(opts_with_arg[6]), "break-dp-thresh", 0, 
            "Gradient vector dot product threshold for breaking edges.",
            process_break_dp_thresh_opt);
    init_option_with_arg(&(opts_with_arg[7]), "break-dp-num-avg", 0, 
            "Number of gradient vectors to average when computing the dot product threshold for breaking edges.",
            process_break_dp_num_avg_opt);
    init_option_with_arg(&(opts_with_arg[8]), "sigma", 0, 
            "Gaussian smoothing sigma.", process_sigma_opt);
    init_option_with_arg(&(opts_with_arg[9]), "sample-rate", 0, 
            "Edge point sampling rate.", process_sample_rate_opt);
    init_option_with_arg(&(opts_with_arg[10]), "min-len", 0, 
            "Minimum length of an edge.", process_min_len_opt);
    init_option_with_arg(&(opts_with_arg[11]), "seed", 0, 
            "Random seed.", process_seed_opt);

    /* Check for the help option first. */
    process_option_no_arg(argc, argv, &argi, &(opts_no_arg[0]));

    if ((e = process_options(argc, argv, &argi, NUM_OPTS_NO_ARG, opts_no_arg, 
                    NUM_OPTS_WITH_ARG, opts_with_arg)) != NULL)
    {
        print_error_msg_exit("edges", e->msg);
    }
    if ((argc - argi) < 1)
    {
        print_error_msg_exit("edges", "No input image");
    }
    input_fname = argv[ argi ];

    if ((e = read_image_f(&img_in, input_fname)) != NULL)
    {
        print_error_msg_exit("edges", e->msg);
    }

    srand(seed); rand(); rand();

    num_rows = img_in->num_rows;
    num_cols = img_in->num_cols;

    if (edges_in_fname)
    {
        if ((e = read_edge_set_f(&edges, edges_in_fname)) != NULL)
        {
            print_error_msg("edges", NULL);
            print_error_msg_exit(edges_in_fname, e->msg);
        }
    }
    else
    {
        /* Detect edges and sample them if requested. */
        create_matrix_from_image_f(&m, img_in, 0.3f, 0.59f, 0.11f);
        if ((e = detect_matrix_edge_set_f(&edges, m, sigma, begin_mag_thresh,
                        end_mag_thresh, 8)) != NULL)
        {
            print_error_msg_exit("edges", e->msg);
        }
    }

    break_edges_at_corners_f(edges, break_dp_thresh, break_dp_num_avg);
    remove_short_edges_f(edges, min_len);

    fprintf(stdout, "Number of detected edges: %d\n", edges->num_edges);
    fprintf(stdout, "Number of detected edge points: %d\n", 
            edges->total_num_pts);

    if (sample_rate < 1.0f)
    {
        sample_edge_set_f(&edges, edges, sample_rate);
        fprintf(stdout, "Number of sampled edge points: %d\n", 
                edges->total_num_pts);
    }

    /* Write an edge map image if requested. */
    if (map_fname)
    {
        create_zero_matrix_f(&m, num_rows, num_cols);

        for (i = 0; i < edges->num_edges; i++)
        {
            for (j = 0; j < edges->num_pts[ i ]; j++)
            {
                pt = &(edges->pts[ i ][ j ]);
                m->elts[ pt->row ][ pt->col ] = 1.0f;
            }
        }

        create_image_from_matrix_f(&img_out, m);

        if ((e = write_image_f(img_out, map_fname)) != NULL)
        {
            print_error_msg("edges", e->msg);
            free_error(e);
        }
    }

    /* Write the image data with the edges colored on it if requested. */
    if (color_fname)
    {
        if (random_color)
        {
            randomly_color_edge_set_f(&img_out, img_in, edges);
        }
        else
        {
            pxl.r = 1;
            pxl.g = 0;
            pxl.b = 0;

            color_edge_set_f(&img_out, img_in, edges, &pxl);
        }

        if ((e = write_image_f(img_out, color_fname)) != NULL)
        {
            print_error_msg("edges", e->msg);
            free_error(e);
        }
    }

    /* Write the edge points if requested. */
    if (edges_out_fname)
    {
        if ((e = write_edge_set_f(edges, edges_out_fname)) != NULL)
        {
            print_error_msg("edges", NULL);
            print_error_msg(edges_out_fname, e->msg);
            free_error(e);
        }
    }

    free_edge_set_f(edges);
    free_image_f(img_in);
    free_image_f(img_out);
    free_matrix_f(m);

    return EXIT_SUCCESS;
}