rgbprocess.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2010 Nicolas Limare <nicolas.limare@cmla.ens-cachan.fr>
 *                         Jose-Luis Lisani <joseluis.lisani@uib.es>
 * All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "io_png/io_png.h"
#include "rgbprocess_lib.h"

#define VERSION "0.20110518"

int main(int argc, char *const *argv)
{
    unsigned char *img, *img2, *img3, *imgOut1=NULL, *imgOut2=NULL,
                  *imgOut3=NULL;
    int wOut, hOut;
    size_t nx = 0, ny = 0, nc = 0;

    /* "-v" option : version info */
    if (2 <= argc && 0 == strcmp("-v", argv[1]))
    {
        fprintf(stdout, "%s version " VERSION
                ", compiled " __DATE__ "\n", argv[0]);
        return EXIT_SUCCESS;
    }
    /* wrong number of parameters : simple help info */
    if (argc < 2)
    {
        fprintf(stderr, 
                "usage  : %s [filter in.png out.png]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [rmisolated in.png out.png]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [pcaviews in1.png in2.png out1.png out2.png \
out3.png wOut hOut]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [pcaviewsB in1.png in2.png out123.png \
wOut hOut]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [densityimage in1.png density.png\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [densityviews in1.png in2.png out123.png \
wOut hOut [optional: density.png]]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [mergeimages in1.png in2.png out.png]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [RGBviewsparams nameparams.txt]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [RGBviews in1.png nameparams.txt nameviews \
wOut hOut displaydensity=0/1 [optional: density.png]]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [combineviews nameparams.txt nameviews1 \
nameview2 nameview3 nameviewsOut]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [computeRMSE in1.png in2.png]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [countcolors in1.png]\n", 
                argv[0]);
        fprintf(stderr, 
                "usage  : %s [RGB2VRML2 in1.png out.wrl displaydensity=0/1 \
[optional: density.png]]\n", 
                argv[0]);
        return EXIT_FAILURE;
    }

    if (!strcmp(argv[1], "filter")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);

      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* process input image */
      rgbprocess(img, NULL, NULL, nx, ny, img, NULL, NULL, nx, ny, "filter");

      /* write the PNG output image */
      nc=3; /*color image*/
      io_png_write_u8(argv[3], img, nx, ny, nc);

      /* free the memory */
      free(img);

    }

    if (!strcmp(argv[1], "rmisolated")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);

      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* process input image */
      rgbprocess(img, NULL, NULL, nx, ny, img, NULL, NULL, 
                 nx, ny, "rmisolated");

      /* write the PNG output image */
      nc=3; /*color image*/
      io_png_write_u8(argv[3], img, nx, ny, nc);

      /* free the memory */
      free(img);

    }


    if (!strcmp(argv[1], "pcaviews")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);
      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* read the PNG input image */
      img2 = io_png_read_u8_rgb(argv[3], &nx, &ny);
      if (!img2)
      {
        fprintf(stderr, 
                "Error reading reference input image or not a color image!\n");
        free(img);
        return EXIT_FAILURE;
      }
        
      wOut = atoi(argv[7]);
      hOut = atoi(argv[8]);

      imgOut1=(unsigned char *) malloc(3*wOut*hOut);
      imgOut2=(unsigned char *) malloc(3*wOut*hOut);
      imgOut3=(unsigned char *) malloc(3*wOut*hOut);

      /* process input image */
      rgbprocess(img, img2, NULL, nx, ny, 
                 imgOut1, imgOut2, imgOut3, wOut, hOut, "pcaviews");

      /* write the PNG output image */
      nc=3; /*color image*/
      io_png_write_u8(argv[4], imgOut1, wOut, hOut, nc);
      io_png_write_u8(argv[5], imgOut2, wOut, hOut, nc);
      io_png_write_u8(argv[6], imgOut3, wOut, hOut, nc);

      /* free the memory */
      free(img);
      free(img2);
      free(imgOut1);
      free(imgOut2);
      free(imgOut3);
    }

    if (!strcmp(argv[1], "pcaviewsB")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);
      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* read the PNG input image */
      img2 = io_png_read_u8_rgb(argv[3], &nx, &ny);
      if (!img2)
      {
        fprintf(stderr, 
                "Error reading reference input image or not a color image!\n");
        free(img);
        return EXIT_FAILURE;
      }
        
      wOut = atoi(argv[5]);
      hOut = atoi(argv[6]);

      imgOut1=(unsigned char *) malloc(3*3*wOut*hOut);

      /* process input image */
      rgbprocess(img, img2, NULL, nx, ny, 
                 imgOut1, NULL, NULL, wOut, hOut, "pcaviewsB");

      /* write the PNG output image */
      nc=3; /*color image*/
      io_png_write_u8(argv[4], imgOut1, 3*wOut, hOut, nc);
 
      /* free the memory */
      free(img);
      free(img2);
      free(imgOut1);
    }

    if (!strcmp(argv[1], "densityimage")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);

      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      imgOut1=(unsigned char *) malloc(nx*ny);

      /* process input image */
      rgbprocess(img, NULL, NULL, nx, ny, 
                 imgOut1, NULL, NULL, nx, ny, "densityImage");

      /* write the PNG output image */
      nc=1; /*grey-scale image*/
      io_png_write_u8(argv[3], imgOut1, nx, ny, nc);

      /* free the memory */
      free(img);
      free(imgOut1);
    }


    if (!strcmp(argv[1], "densityviews")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);
      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* read the PNG input image */
      img2 = io_png_read_u8_rgb(argv[3], &nx, &ny);
      if (!img2)
      {
        fprintf(stderr, 
                "Error reading reference input image or not a color image!\n");
        free(img);
        return EXIT_FAILURE;
      }
        
      wOut = atoi(argv[5]);
      hOut = atoi(argv[6]);

      img3=NULL;
      if (argc > 7) {
        /* read the PNG density image */
        img3 = io_png_read_u8_gray(argv[7], &nx, &ny);
        if (!img3)
        {
          fprintf(stderr, "Error reading density input image!\n");
          free(img);
          free(img2);
          return EXIT_FAILURE;
        }
      }

      imgOut1=(unsigned char *) malloc(3*3*wOut*hOut);

      /* process input image */
      rgbprocess(img, img2, img3, nx, ny, 
                         imgOut1, NULL, NULL, wOut, hOut, "densityviews");

      /* write the PNG output image */
      nc=3; /*color image*/
      io_png_write_u8(argv[4], imgOut1, 3*wOut, hOut, nc);
 
      /* free the memory */
      free(img);
      free(img2);
      if (img3) free(img3);
      free(imgOut1);
    }

    if (!strcmp(argv[1], "mergeimages")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);
      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* read the PNG input image */
      img2 = io_png_read_u8_rgb(argv[3], &nx, &ny);
      if (!img2)
      {
        fprintf(stderr, 
                "Error reading reference input image or not a color image!\n");
        free(img);
        return EXIT_FAILURE;
      }
        
      imgOut1=(unsigned char *) malloc(3*nx*ny);

      /* process input image */
      rgbprocess(img, img2, NULL, nx, ny, 
                 imgOut1, NULL, NULL, nx, ny, "mergeimages");

      /* write the PNG output image */
      nc=3; /*color image*/
      io_png_write_u8(argv[4], imgOut1, nx, ny, nc);
 
      /* free the memory */
      free(img);
      free(img2);
      free(imgOut1);
    }

    if (!strcmp(argv[1], "RGBviewsparams")) {
      RGBviewsparams(argv[2]);
    }

    if (!strcmp(argv[1], "RGBviews")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);
      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* views size */
      int wview, hview; 
      sscanf(argv[5], "%i", &wview); 
      sscanf(argv[6], "%i", &hview); 

      imgOut1=(unsigned char *) malloc(3*wview*hview);

      /* Compute densities, if necessary */
      unsigned char *Idsty=NULL;
      int displayDensity;
      sscanf(argv[7], "%i", &displayDensity); 
      if (displayDensity == 1) {
        if (argc > 8) {
          /* read the PNG density image */
          Idsty = io_png_read_u8_gray(argv[8], &nx, &ny); 
          if (!Idsty) {
            fprintf(stderr, "Error reading density input image!\n");
            free(img);
            free(imgOut1);
            return EXIT_FAILURE;
          }
        } else {
          printf("compute density\n");
          Idsty=(unsigned char *) malloc(nx*ny);
          rgbprocess(img, NULL, NULL, nx, ny, 
                     Idsty, NULL, NULL, 0, 0, "densityImage");
        }
      }

      const char *nameviews=argv[4];
      char nameview[128];

      /* Read info from params file */
      FILE *params;
      int nviews;
      float P[3], u[3], v[3];
      params=fopen(argv[3], "r");
      int nread;
      nread=fscanf(params, "%i", &nviews);
      for (int n=0; n < nviews; n++) {
        nread=fscanf(params, "%f %f %f %f %f %f %f %f %f", 
                     &P[0], &P[1], &P[2], &u[0], &u[1], &u[2], 
                     &v[0], &v[1], &v[2]);
        getRGBview(img, nx, ny, Idsty, imgOut1, wview, hview, P, u, v);
        /* write the PNG output image */
        nc=3; /*color image*/
        sprintf(nameview, "%s_%i.png", nameviews, 100+n);
        io_png_write_u8(nameview, imgOut1, wview, hview, nc);
      }
 
      fclose(params);
      /* free the memory */
      free(img);
      free(imgOut1);
      if (Idsty) free(Idsty);
    }

    if (!strcmp(argv[1], "combineviews")) {

      int nviews;
      FILE *params=fopen(argv[2], "r");
      int nread;
      nread=fscanf(params, "%i", &nviews);
      fclose(params);

      int wview, hview;
      unsigned char *img1, *img2, *img3, *imgOut1;
      imgOut1=NULL;

      const char *nameviews1=argv[3];
      const char *nameviews2=argv[4];
      const char *nameviews3=argv[5];
      const char *nameviewsOut=argv[6];
      char nameview1[128], nameview2[128], nameview3[128], nameviewOut[128];
      for (int n=0; n < nviews; n++) {
        sprintf(nameview1, "%s_%i.png", nameviews1, 100+n);
        sprintf(nameview2, "%s_%i.png", nameviews2, 100+n);
        sprintf(nameview3, "%s_%i.png", nameviews3, 100+n);
        sprintf(nameviewOut, "%s_%i.png", nameviewsOut, 100+n);

        /* read the PNG input images */ 
        img1 = io_png_read_u8_rgb(nameview1, &nx, &ny);
        if (!img1) {
          fprintf(stderr, "Error reading input image or not a color image!\n");
          return EXIT_FAILURE;
        }
        img2 = io_png_read_u8_rgb(nameview2, &nx, &ny);
        if (!img2)
        {
          fprintf(stderr, "Error reading input image or not a color image!\n");
          free(img1);
          return EXIT_FAILURE;
        }
        img3 = io_png_read_u8_rgb(nameview3, &nx, &ny);
        if (!img3)
        {
          fprintf(stderr, "Error reading input image or not a color image!\n");
          free(img1);
          free(img2);
          return EXIT_FAILURE;
        }
        wview=(int) nx;
        hview=(int) ny;


        if (!imgOut1) imgOut1=(unsigned char *) malloc(3*(2*wview)*(2*hview));

        // process input image 
        rgbprocess(img1, img2, img3, nx, ny, 
                   imgOut1, NULL, NULL, 0, 0, "combineviewsB");


        // write the PNG output image 
        nc=3; //color image
        io_png_write_u8(nameviewOut, imgOut1, 2*nx, 2*ny, nc);


        /* free the memory */
        free(img1);
        free(img2);
        free(img3);

      }
      free(imgOut1);

    }

    if (!strcmp(argv[1], "computeRMSE")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);
      if (!img) {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* read the PNG input image */
      img2 = io_png_read_u8_rgb(argv[3], &nx, &ny);
      if (!img2) {
        fprintf(stderr, 
                "Error reading reference input image or not a color image!\n");
        free(img);
        return EXIT_FAILURE;
      }
        
      float rmse, dmean;
      rmse=computeRMSE(img, img2, nx, ny, dmean);

      printf("The Root Mean Square Error (RMSE) between the original and \
filtered color clouds is: %2.2f\n", rmse);
      printf("The Average Distance (dmean) between the original and filtered \
color clouds is: %2.2f\n", dmean);

      /* free the memory */
      free(img);
      free(img2);
    }

    if (!strcmp(argv[1], "countcolors")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);
      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

        
      int nRGB;
      nRGB=countcolors(img, nx, ny);

      printf("Number of colors of filtered image: %i\n", nRGB);

      /* free the memory */
      free(img);
    }

    if (!strcmp(argv[1], "RGB2VRML2")) {


      /* read the PNG input image */
      img = io_png_read_u8_rgb(argv[2], &nx, &ny);
      if (!img)
      {
        fprintf(stderr, "Error reading input image or not a color image!\n");
        return EXIT_FAILURE;
      }

      /* Compute densities, if necessary */
      unsigned char *Idsty=NULL;
      int displayDensity;
      sscanf(argv[4], "%i", &displayDensity); 
      if (displayDensity == 1) {
        if (argc > 5) {
          /* read the PNG density image */
          Idsty = io_png_read_u8_gray(argv[5], &nx, &ny);
          if (!Idsty) {
            fprintf(stderr, "Error reading density input image!\n");
            free(img);
            return EXIT_FAILURE;
          }
        } else {
          printf("compute density\n");
          Idsty=(unsigned char *) malloc(nx*ny);
          rgbprocess(img, NULL, NULL, nx, ny, 
                     Idsty, NULL, NULL, 0, 0, "densityImage");
        }
      }

      RGB2VRML2(img, nx, ny, Idsty, argv[3]);

      /* free the memory */
      free(img);
      if (Idsty) free(Idsty);
    }

    return EXIT_SUCCESS;
}

---