random_phase_noise.c

Go to the documentation of this file.

/*
 * Copyright (c) 2010, Bruno Galerne <bruno.galerne@cmla.ens-cachan.fr>
 * All rights reserved.
 *
 * This program is free software: you can use, modify and/or
 * redistribute it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, either
 * version 3 of the License, or (at your option) any later
 * version. You should have received a copy of this license along
 * this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <getopt.h>
#include <fftw3.h>

#include "mt.h"
#include "io_png.h"
#include "random_phase_noise_lib.h"

#define FATAL(MSG)                      \
do {                            \
        fprintf(stderr, MSG "\n");      \
        abort();                        \
        } while (0);

/*
* Main function section
*/

static int display_usage()
{
    printf("\nrandom_phase_noise -r ratio -x nxout -y nyout "
           "-a alpha -s seed image_in.png image_out.png\n\n");
    printf("Required parameters:\n");
    printf("   image_in.png   :   name of the input PNG image\n");
    printf("   image_out.png  :   name of the output PNG image\n\n");
    printf("Optionnal parameters:\n");
    printf("   ratio           :   float > 1 that specifies the increase "
           "of size of image_out.png relatively to the size "
           "of image_in.png\n");
    printf("   nxout           :   int to specify the width "
           "of image_out.png. Must be greater than the width "
           "of image_in.png\n");
    printf("   nyout           :   int to specify the height "
           "of image_out.png. Must be greater than the height "
           "of image_in.png\n");
    printf("   alpha           :   float in (0,0.5) that specifies "
           "the proportion of the smoothing zone for "
           "the spot extension (alpha = 0.1 by default)\n");
    printf("   seed            :   unsigned int to specify the seed "
           "for the random number generator "
           "(seed = time(NULL) by default)\n");

    return (1);
}

int main(int argc, char **argv)
{
    char *fname_in, *fname_out; /* input/output file names */
    float *data_in;             /*input data */
    float *data_in_rgb[3];
    float *data_out;            /* output data */
    float *data_out_rgb[3];
    size_t nxin, nyin;          /* input size */
    size_t nxout, nyout;        /* output size */
    float alpha;
    int r_flag = 0;
    float ratio;                /* increase ratio for the
                                 * output size (must be >1) */
    unsigned long seed = 0;     /* seed for the random number
                                 * generator */
    int x_flag = 0;
    int y_flag = 0;
    int a_flag = 0;
    int s_flag = 0;
    int c;                      /* getopt flag */

    /* "default" value initialization */
    alpha = 0.1;
    nxout = 0;
    nyout = 0;
    ratio = 1.;

    /* process the options and parameters */

    while ((c = getopt(argc, argv, "r:x:y:a:s:hv")) != -1) {
        switch (c) {
        case 'r':
            /* increase ratio specified */
            r_flag = 1;
            ratio = atof(optarg);
            if (ratio <= 1)
                FATAL("Option usage: The ratio "
                      "specified by -r must be " "greater than 1.")
                    break;
        case 'x':
            /* output width specified */
            x_flag = 1;
            nxout = atoi(optarg);
            break;
        case 'y':
            /* output height specified */
            y_flag = 1;
            nyout = atoi(optarg);
            break;
        case 'a':
            /* alpha parameter specified */
            a_flag = 1;
            alpha = atof(optarg);
            break;
        case 's':
            /* seed specified */
            s_flag = 1;
            seed = (unsigned long) atol(optarg);
            break;
        case 'h':
            /* display usage */
            display_usage();
            return (-1);
        case 'v':
            /* display version */
            fprintf(stdout, "%s version " __DATE__ "\n", argv[0]);
            return (-1);
        default:
            abort();
        }
    }

    /* process the non-option parameters */
    if (2 > (argc - optind)) {
        printf("The image file names are missing\n\n");
        display_usage();
        return (-1);
    }
    fname_in = argv[optind++];
    fname_out = argv[optind++];

    /* initilization of the random number generator */
    if (s_flag == 0) {
        mt_init((unsigned long) time(NULL));
    }
    else {
        mt_init(seed);
    }

    /* read the PNG image and set pointers for data_in */
    if (NULL == (data_in = io_png_read_f32_rgb(fname_in, &nxin, &nyin)))
        FATAL("error while reading the PNG image");
    data_in_rgb[0] = data_in;
    data_in_rgb[1] = data_in + nxin * nyin;
    data_in_rgb[2] = data_in + 2 * nxin * nyin;

    /* deal with options conflict/inconsistance and set the output size */
    if ((r_flag == 1) && ((x_flag == 1) || (y_flag == 1))) {
        printf("Option usage: Conflicting options to specify "
               "the output size: Use either the -r option "
               "or both -x and -y options\n\n");
        display_usage();
        return (-1);
    }
    if (x_flag == 0) {
        nxout = (int) (ratio * ((float) nxin));
    }
    else if (nxin > nxout) {
        printf("Option usage: the width specified by "
               "the -x option must be greater than the one "
               "of the input image\n\n");
        display_usage();
        return (-1);
    }
    if (y_flag == 0) {
        nyout = (int) (ratio * ((float) nyin));
    }
    else if (nyin > nyout) {
        printf("Option usage: the height specified by "
               "the -y option must be greater than the one "
               "of the input image\n\n");
        display_usage();
        return (-1);
    }

    if ((a_flag == 1) && (nxin == nxout) && (nyin == nyout)) {
        printf("INFO: The -a option was ignored "
               "since the output size is the same as " "the input size.\n");
    }

    /* Two modes depending whether the input size and the output
     * size are the same */
    if ((nxin == nxout) && (nyin == nyout)) {   /* Same size */
        /* RPN computation */
        if (NULL == rpn_color_same_size(data_in_rgb, nxin, nyin))
            FATAL("error while running rpn_color_same_size");

        /* Write result in PNG file */
        if (0 != io_png_write_f32(fname_out, data_in, nxin, nyin, 3))
            FATAL("error while writing output PNG file");

        /* Free memory */
        free(data_in);
    }
    else {                      /* Different sizes */

        /* Memory allocation for data_out */
        if (NULL == (data_out = (float *)
                     malloc(3 * nxout * nyout * sizeof(float))))
            FATAL("allocation error");
        data_out_rgb[0] = data_out;
        data_out_rgb[1] = data_out + nxout * nyout;
        data_out_rgb[2] = data_out + 2 * nxout * nyout;

        /* RPN computation */
        if (NULL == rpn_color_different_size(data_out_rgb, data_in_rgb,
                                             nxout, nyout, nxin, nyin, alpha))
            FATAL("error while running rpn_color_different_size");

        /* Write result in PNG file */
        if (0 != io_png_write_f32(fname_out, data_out, nxout, nyout, 3))
            FATAL("error while writing output PNG file");

        /* Free memory */
        free(data_in);
        free(data_out);
    }

    return (0);
}