ImageCalc.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 __IMAGE_CALC_HH__
#define __IMAGE_CALC_HH__

#include <Utils/Param.hh>
#include <Base/Image/ImageBase.hh>
#include <Base/Image/ImageIO.hh>

namespace BIAS
{
  /**
   * @class ImageCalc
   *
   * @brief Performs pixelwise arithmetic and boolean operations on images.
   *
   * @note Over- and underflows are not prevented. You may want to convert
   *       your 1-byte images (like char or unsigned char) to float.
   * @note The output image is always initialised.
   *
   * Possible improvements:
   * - avoid over- and underflows by clipping to maximum or minimum value
   * - generalise for n input images
   *
   *  @ingroup g_image_other
   *  @author Robert Wulff
   *  @date 03/2010
   */
  template<class StorageType>
  class BIASImageUtilsBase_EXPORT ImageCalc
  {

  public:

    ////////////////////////////////////////////////////////////////////////////
    // calculations between two images                                        //
    ////////////////////////////////////////////////////////////////////////////

    /**
     * @brief Computes the pixelwise sum of the input images.
     */
    static void Add(const Image<StorageType> &in1,
                    const Image<StorageType> &in2,
                    Image<StorageType> &out);

    /**
     * @brief Computes the pixelwise difference of the input images. The second
     *        image is subtracted from the first one.
     */
    static void Subtract(const Image<StorageType> &in1,
                         const Image<StorageType> &in2,
                         Image<StorageType> &out);

    /**
     * @brief Computes the pixelwise product of the input images.
     */
    static void Multiply(const Image<StorageType> &in1,
                         const Image<StorageType> &in2,
                         Image<StorageType> &out);

    /**
     * @brief Computes the pixelwise quotient of the input images. The first
     *        image is divided by the second one.
     *
     * @note In case of division by zero the output image's pixel will be set
     *       to 0 and a BIASWARN will be printed to stdout
     */
    static void Divide(const Image<StorageType> &in1,
                       const Image<StorageType> &in2,
                       Image<StorageType> &out);

    /**
     * @brief Performs a pixelwise AND on the input images.
     *
     * The input images are interpreted binary: input pixel values == 0 are
     * treated as FALSE and all values != 0 are interpreted as TRUE. Output
     * image will be of same storage type as input images, but will contain only
     * binary values, i.e. only 0 and 1.
     *
     * Each image channel is treated individually.
     */
    static void And(const Image<StorageType> &in1,
                    const Image<StorageType> &in2,
                    Image<StorageType> &out);

    /**
     * @brief Performs a pixelwise NAND on the input images.
     *
     * The input images are interpreted binary: input pixel values == 0 are
     * treated as FALSE and all values != 0 are interpreted as TRUE. Output
     * image will be of same storage type as input images, but will contain only
     * binary values, i.e. only 0 and 1.
     *
     * Each image channel is treated individually.
     */
    static void Nand(const Image<StorageType> &in1,
                     const Image<StorageType> &in2,
                     Image<StorageType> &out);

    /**
     * @brief Performs a pixelwise OR on the input images.
     *
     * The input images are interpreted binary: input pixel values == 0 are
     * treated as FALSE and all values != 0 are interpreted as TRUE. Output
     * image will be of same storage type as input images, but will contain only
     * binary values, i.e. only 0 and 1.
     *
     * Each image channel is treated individually.
     */
    static void Or(const Image<StorageType> &in1,
                   const Image<StorageType> &in2,
                   Image<StorageType> &out);

    /**
     * @brief Performs a pixelwise NOR on the input images.
     *
     * The input images are interpreted binary: input pixel values == 0 are
     * treated as FALSE and all values != 0 are interpreted as TRUE. Output
     * image will be of same storage type as input images, but will contain only
     * binary values, i.e. only 0 and 1.
     *
     * Each image channel is treated individually.
     */
    static void Nor(const Image<StorageType> &in1,
                    const Image<StorageType> &in2,
                    Image<StorageType> &out);

    /**
     * @brief Performs a pixelwise XOR on the input images.
     *
     * The input images are interpreted binary: input pixel values == 0 are
     * treated as FALSE and all values != 0 are interpreted as TRUE. Output
     * image will be of same storage type as input images, but will contain only
     * binary values, i.e. only 0 and 1.
     *
     * Each image channel is treated individually.
     */
    static void Xor(const Image<StorageType> &in1,
                    const Image<StorageType> &in2,
                    Image<StorageType> &out);

    ////////////////////////////////////////////////////////////////////////////
    // calculations between one image and a scalar                            //
    ////////////////////////////////////////////////////////////////////////////

    /**
     * @brief Adds the scalar value to each pixel of the input image.
     */
    static void AddScalar(const Image<StorageType> &in, StorageType scalar,
                          Image<StorageType> &out);

    /**
     * @brief Subtracts the scalar value from each pixel of the input image.
     */
    static void SubtractScalar(const Image<StorageType> &in, StorageType scalar,
                               Image<StorageType> &out);

    /**
     * @brief Multiplies the scalar value to each pixel of the input image.
     */
    static void MultiplyScalar(const Image<StorageType> &in, StorageType scalar,
                               Image<StorageType> &out);

    /**
     * @brief Divides each pixel from the input image by the scalar.
     *
     * @note The scalar must not be 0!
     */
    static void DivideScalar(const Image<StorageType> &in, StorageType scalar,
                             Image<StorageType> &out);

    ////////////////////////////////////////////////////////////////////////////
    // calculations on a single image                                         //
    ////////////////////////////////////////////////////////////////////////////

    /**
     * @brief Computes the natural logarithm (base e) for each pixel.
     *
     * @note Each pixel's value will be cast to double for the computation and
     *       then back to it's original storage type.
     */
    static void Log(const Image<StorageType> &in, Image<StorageType> &out);

    /**
     * @brief Computes the common logarithm (base 10) for each pixel.
     *
     * @note Each pixel's value will be cast to double for the computation and
     *       then back to it's original storage type.
     */
    static void Log10(const Image<StorageType> &in, Image<StorageType> &out);

    /**
     * @brief Computes the absolute value for each pixel.
     *
     * Obiously only makes sense for signed storage types...
     */
    static void Abs(const Image<StorageType> &in, Image<StorageType> &out);
  };
}

#endif // __IMAGE_CALC_HH__