ConsoleProgress.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __CONSOLE_PROGRESS_HH__
#define __CONSOLE_PROGRESS_HH__

// std
#include <iostream>

// BIAS
#include <Base/Debug/Error.hh>

namespace BIAS
{
  /**
   * @brief Visualises the progress of some computation in the console.
   *
   * This class is intended to show the progress of an iteration over a large
   * number of elements. It only prints itegral percentage values and so doesn't
   * spam the console.
   *
   * If you only iterate over a small number of elements (e.g. 100), performance
   * may be hit drastically because output is flushed after each integral
   * percentage (i.e. an I/O operation is performed).
   *
   * @author rwulff
   * @date   03/2011
   */
  class BIASUtils_EXPORT ConsoleProgress
  {

  public:

    /**
     * @brief Constructor.
     *
     * @param maxValue
     *        the maximum value to reach, equivalent to 100%
     */
    explicit inline
    ConsoleProgress(unsigned int maxValue = 0) :
      percentageShown_(0), maxValue_(0)
    {
      Reset(maxValue);
    }

    /**
     * @brief Resets the internal counter and sets the maximum value to reach.
     *
     * @param maxValue
     *        the maximum value to reach, equivalent to 100%. if set to 0, the
     *        current maxValue will not be changed.
     */
    inline
    void Reset(unsigned int maxValue = 0)
    {
      percentageShown_ = 0;
      if (maxValue > 0) {
        maxValue_ = maxValue;
      }
    }

    /**
     * @brief Prints the current percentage if it is equal or greater than all
     *        integral percentage values that have been printed before.
     *
     * @note No endl is appended. You may want to print it on your own after the
     *       iteration is finished.
     *
     * @param curValue
     *        the current value within interval [0, maxValue]
     */
    inline
    void PrintPercentage(unsigned int curValue)
    {
      BIASASSERT(curValue <= maxValue_)

      const float curPercentage =
        (maxValue_ > 0 ? float(curValue) / float(maxValue_) * 100.0f : 0.0f);
      const unsigned int curPercRounded = (unsigned int)(curPercentage + 0.5f);

      if (curPercentage >= percentageShown_) {
        std::cout << "\r";
        if (curPercRounded < 10) {
          std::cout << " ";
        }
        if (curPercRounded < 100) {
          std::cout << " ";
        }
        std::cout << curPercRounded << "% " << std::flush;

        percentageShown_ = curPercRounded + 1;
      }
    }

    /**
     * @brief Prints progress bar showing the current percentage.
     * @note No end line is appended.
     * @param curValue The current value within interval [0, maxValue].
     * @param size The length of the progress bar in characters.
     */
    inline
    void PrintProgressBar(unsigned int curValue, unsigned int size = 25)
    {
      BIASASSERT(curValue <= maxValue_);
      
      const float curPercentage =
        (maxValue_ > 0 ? float(curValue) / float(maxValue_) * 100.0f : 0.0f);
      const unsigned int curPercRounded = (unsigned int)(curPercentage + 0.5f);

      if (curPercentage >= percentageShown_) {
        std::cout << "\r[";
        const float step = 100.0f / (float) size;
        float perc = 0.0f;
        for (unsigned int i = 0; i < size; i++, perc += step) {
          std::cout << (perc < curPercentage ? "=" : " ");
        }
        std::cout << "] " << curPercRounded << "% " << std::flush;

        percentageShown_ = curPercRounded + 1;
      }
    }

  private:

    /// @brief counter to ensure that only integral values are printed
    unsigned int percentageShown_;

    /// @brief the maximum value, equivalent to 100%
    unsigned int maxValue_;
  };
}

#endif // __CONSOLE_PROGRESS_HH__