histogram.cpp

/****************************************************************************
 *
 * $Id: histogram.cpp 4323 2013-07-18 09:24:01Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2013 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Example of Histogram manipulation.
 *
 * Author:
 * Fabien Spindler
 *
 *****************************************************************************/

#include <visp/vpDebug.h>
#include <visp/vpImage.h>
#include <visp/vpImageIo.h>
#include <visp/vpHistogram.h>
#include <visp/vpParseArgv.h>
#include <visp/vpIoTools.h>

#include <stdio.h>
#include <stdlib.h>
#include <sstream>
#include <iomanip>

// List of allowed command line options
#define GETOPTARGS  "i:o:h"

void usage(const char *name, const char *badparam, std::string ipath,
       std::string opath, std::string user)
{
  fprintf(stdout, "\n\
Read an image on the disk, display it using X11, display some\n\
features (line, circle, caracters) in overlay and finaly write \n\
the image and the overlayed features in an image on the disk.\n\
\n\
SYNOPSIS\n\
  %s [-i <input image path>] [-o <output histogram path>]\n\
     [-h]\n\
", name);

  fprintf(stdout, "\n\
OPTIONS:                                               Default\n\
  -i <input image path>                                %s\n\
     Set image input path.\n\
     From this path read \"ViSP-images/Klimt/Klimt.pgm\"\n\
     image.\n\
     Setting the VISP_INPUT_IMAGE_PATH environment\n\
     variable produces the same behaviour than using\n\
     this option.\n\
\n\
  -o <output histogram path>                           %s\n\
     From this directory, creates the \"%s\"\n\
     subdirectory depending on the username, where \n\
     \"histogram.txt\" is saved.\n\
\n\
  -h\n\
     Print the help.\n\n",
      ipath.c_str(), opath.c_str(), user.c_str());

  if (badparam) {
    fprintf(stderr, "ERROR: \n" );
    fprintf(stderr, "\nBad parameter [%s]\n", badparam);
  }

}
bool getOptions(int argc, const char **argv,
                std::string &ipath, std::string &opath,
                std::string user)
{
  const char *optarg;
  int   c;
  while ((c = vpParseArgv::parse(argc, argv, GETOPTARGS, &optarg)) > 1) {

    switch (c) {
    case 'i': ipath = optarg; break;
    case 'o': opath = optarg; break;
    case 'h': usage(argv[0], NULL, ipath, opath, user); return false; break;

    default:
      usage(argv[0], optarg, ipath, opath, user); return false; break;
    }
  }

  if ((c == 1) || (c == -1)) {
    // standalone param or error
    usage(argv[0], NULL, ipath, opath, user);
    std::cerr << "ERROR: " << std::endl;
    std::cerr << "  Bad argument " << optarg << std::endl << std::endl;
    return false;
  }

  return true;
}

int
main(int argc, const char ** argv)
{
  std::string env_ipath;
  std::string opt_ipath;
  std::string opt_opath;
  std::string ipath;
  std::string opath;
  std::string filename;
  std::string username;

  // Get the VISP_IMAGE_PATH environment variable value
  char *ptenv = getenv("VISP_INPUT_IMAGE_PATH");
  if (ptenv != NULL)
    env_ipath = ptenv;
  //  std::cout << "env_ipath: " << env_ipath << std::endl;

  // Set the default input path
  if (! env_ipath.empty())
    ipath = env_ipath;

  // Set the default output path
#ifdef WIN32
  opt_opath = "C:/temp";
#else
  opt_opath = "/tmp";
#endif

  // Get the user login name
  vpIoTools::getUserName(username);

  // Read the command line options
  if (getOptions(argc, argv, opt_ipath, opt_opath, username) == false) {
    exit (-1);
  }

  // Get the option values
  if (!opt_ipath.empty())
    ipath = opt_ipath;
  if (!opt_opath.empty())
    opath = opt_opath;

  // Append to the output path string, the login name of the user
  std::string dirname = opath +  vpIoTools::path("/") + username;

  // Test if the output path exist. If no try to create it
  if (vpIoTools::checkDirectory(dirname) == false) {
    try {
      // Create the dirname
      vpIoTools::makeDirectory(dirname);
    }
    catch (...) {
      usage(argv[0], NULL, ipath, opath, username);
      std::cerr << std::endl
                << "ERROR:" << std::endl;
      std::cerr << "  Cannot create " << dirname << std::endl;
      std::cerr << "  Check your -o " << opath << " option " << std::endl;
      exit(-1);
    }
  }

  // Compare ipath and env_ipath. If they differ, we take into account
  // the input path comming from the command line option
  if (opt_ipath.empty()) {
    if (ipath != env_ipath) {
      std::cout << std::endl
                << "WARNING: " << std::endl;
      std::cout << "  Since -i <visp image path=" << ipath << "> "
                << "  is different from VISP_IMAGE_PATH=" << env_ipath << std::endl
                << "  we skip the environment variable." << std::endl;
    }
  }

  // Test if an input path is set
  if (opt_ipath.empty() && env_ipath.empty()){
    usage(argv[0], NULL, ipath, opath, username);
    std::cerr << std::endl
              << "ERROR:" << std::endl;
    std::cerr << "  Use -i <visp image path> option or set VISP_INPUT_IMAGE_PATH "
              << std::endl
              << "  environment variable to specify the location of the " << std::endl
              << "  image path where test images are located." << std::endl << std::endl;
    exit(-1);
  }

  // Create a grey level image
  vpImage<unsigned char> I ;

  // Load a grey image from the disk
  filename = ipath;
  if (opt_ipath.empty())
    filename +=  vpIoTools::path("/ViSP-images/Klimt/Klimt.pgm");

  std::cout << "Read: " << filename << std::endl;
  vpImageIo::read(I, filename) ;

  unsigned char distance = 60;
  vpHistogram h;

  // Computes the histogram from the image
  h.calculate(I);

  // Save the histogram
  filename = dirname +  vpIoTools::path("/histogram.txt");
  std::cout << "Save the histogram in: " << filename << std::endl;
  h.write(filename);

  // Smooth the histogram
  h.smooth();
  // Save the histogram
  filename = dirname +  vpIoTools::path("/histogram_smoothed.txt");
  std::cout << "Save the smoothed histogram in: " << filename << std::endl;
  h.write(filename);

  std::list<vpHistogramPeak> peaks;
  unsigned int nbpeaks = 0;

  // get all the histogram peaks
  nbpeaks = h.getPeaks(peaks);

  vpTRACE("List of peaks");
  vpTRACE("Nb peaks: %d", nbpeaks);
  if (nbpeaks) {
    for(std::list<vpHistogramPeak>::const_iterator it = peaks.begin(); it != peaks.end(); ++it)
    {
      vpHistogramPeak p = *it;
      vpTRACE("Peak: gray level: %d value: %d", p.getLevel(), p.getValue());
    }
  }

  // sort all the histogram peaks list to have the highest peak at the
  // beginning of the list, the smallest at the end.
  nbpeaks = h.sort(peaks);

  vpTRACE("Sorted list of peaks");
  vpTRACE("Nb peaks: %d", nbpeaks);
  if (nbpeaks) {
    for(std::list<vpHistogramPeak>::const_iterator it = peaks.begin(); it != peaks.end(); ++it)
    {
      vpHistogramPeak p = *it;
      vpTRACE("Peak: gray level: %d value: %d", p.getLevel(), p.getValue());
    }
  }

  // Get the two highest histogram peaks. peak1 is the highest
  vpHistogramPeak peak1, peak2;
  nbpeaks = h.getPeaks(distance, peak1, peak2);
  if (nbpeaks != 2) {
    std::cout << "Not a bimodal histogram..." << std::endl;
  }
  else {
    vpTRACE("Bimodal histogram: main peak1: %d-%d second peak2: %d-%d",
            peak1.getLevel(), peak1.getValue(),
            peak2.getLevel(), peak2.getValue());
  }

  // Get the valey between the two highest peaks
  vpHistogramValey valey;
  if (h.getValey(peak1, peak2, valey) == false) {
    vpTRACE("No valey found...");
  }
  else {
    vpTRACE("Valey: %d-%d", valey.getLevel(), valey.getValue());
  }


  vpHistogramValey valeyl, valeyr;

  {
    // Search the two valeys around peak1
    unsigned ret = h.getValey(distance, peak1, valeyl, valeyr);
    if (ret == 0x00) {
      vpTRACE("No left and right valey for peak %d-%d...",
              peak1.getLevel(), peak1.getValue());
    }
    else if (ret == 0x10) {
      vpTRACE("No right valey for peak %d-%d...",
              peak1.getLevel(), peak1.getValue());
      vpTRACE("Left valey: %d-%d", valeyl.getLevel(), valeyl.getValue());
    }
    else if (ret == 0x01) {
      vpTRACE("No left valey for peak %d-%d...",
              peak1.getLevel(), peak1.getValue());
      vpTRACE("Right valey: %d-%d", valeyr.getLevel(), valeyr.getValue());
    }
    else if (ret == 0x11) {
      vpTRACE("Left valey: %d-%d",  valeyl.getLevel(), valeyl.getValue());
      vpTRACE("Right valey: %d-%d", valeyr.getLevel(), valeyr.getValue());
    }
  }
  {
    // Search the two valeys around peak2
    unsigned ret = h.getValey(distance, peak2, valeyl, valeyr);
    if (ret == 0x00) {
      vpTRACE("No left and right valey for peak %d-%d...",
              peak2.getLevel(), peak2.getValue());
    }
    else if (ret == 0x10) {
      vpTRACE("No right valey for peak %d-%d...",
              peak2.getLevel(), peak2.getValue());
      vpTRACE("Left valey: %d-%d", valeyl.getLevel(), valeyl.getValue());
    }
    else if (ret == 0x01) {
      vpTRACE("No left valey for peak %d-%d...",
              peak2.getLevel(), peak2.getValue());
      vpTRACE("Right valey: %d-%d", valeyr.getLevel(), valeyr.getValue());
    }
    else if (ret == 0x11) {
      vpTRACE("Left valey: %d-%d",  valeyl.getLevel(), valeyl.getValue());
      vpTRACE("Right valey: %d-%d", valeyr.getLevel(), valeyr.getValue());
    }
  }

  // get the valey between the two highest peaks. Here we don't know
  // which of peakl or peakr is the highest.
  vpHistogramPeak peakl, peakr;
  if (h.getPeaks(distance, peakl, peakr, valey) == false) {
    std::cout << "Not a bimodal histogram..." << std::endl;
  }
  else {
    vpTRACE("Bimodal histogram: valey %d-%d for peakl: %d-%d peakr: %d-%d",
            valey.getLevel(), valey.getValue(),
            peakl.getLevel(), peakl.getValue(),
            peakr.getLevel(), peakr.getValue());
  }

}



/*
 * Local variables:
 * c-basic-offset: 2
 * End:
 */