/*
 * NICE-Core - efficient algebra and computer vision methods
 *  - libimage - An image library
 * See file License for license information.
 */
#ifndef LIMUN_IMAGETOOLS_H
#define LIMUN_IMAGETOOLS_H


#include "core/image/ippwrapper.h"

#include "core/vector/VectorT.h"
#include "core/vector/MatrixT.h"

#include "core/image/ImageT.h"
#include "core/image/ColorImageT.h"

#include "core/image/Convert.h"
#include "core/image/FilterT.h"

namespace NICE {

    /**
    * @name Arithmetic and Logical Operations
    * \{
    */

    /**
    * Calculates the absolute difference between Image \c src0 and Image \c src1 into the Image \c dst .
    * @param src0 source gray image
    * @param src1 source gray image
    * @param dst  optional buffer to be used as target.<br>
    *             Create a new Image if \c dst == NULL.<br>
    *             If \c dst != NULL then size must be equal to \c src 's size!
    * @throw ImageException will be thrown if \c dst != NULL and the size of \c src0 / \c scr1 and \c dst or
    *                       the size of \c src0 and \c src1 is not equal.
    * @return Image
    */
    Image* absDiff(const Image& src0, const Image& src1, Image* dst=NULL);

    /**
    * Calculates the absolute difference between ColorImage \c src0 and ColorImage \c src1 into the ColorImage \c dst .
    * @param src0 source color image
    * @param src1 source color image
    * @param dst  optional buffer to be used as target.<br>
    *             Create a new ColorImage if \c dst == NULL.<br>
    *             If \c dst != NULL then size must be equal to \c src' s size!
    * @throw ImageException will be thrown if \c dst != NULL and the size of \c src0 / \c scr1 and \c dst or
    *                       the size of \c src0 and \c src1 is not equal.
    * @return ColorImage
    */
    ColorImage* absDiff(const ColorImage& src0, const ColorImage& src1, ColorImage* dst=NULL);

    /**
    * Calculates bitwise and between the corresponding pixels of the Image \c src0 and Image
    * \c src1 into the Image \c dst.
    * @param src0 source gray image
    * @param src1 source gray image
    * @param dst  optional buffer to be used as target.<br>
    *             Create a new Image if \c dst == NULL.<br>
    *             If \c dst != NULL then size must be equal to \c src 's size!
    * @throw ImageException will be thrown if \c dst != NULL and the size of \c src0 / \c scr1 and \c dst or
    *                       the size of \c src0 and \c src1 is not equal.
    * @return Image
    */
    Image* And(const Image& src0, const Image& src1, Image* dst=NULL);

    /**
    * Calculates bitwise and between the corresponding pixels of the ColorImage \c src0 and
    * ColorImage \c src1 into the ColorImage \c dst.
    * @param src0 source color image
    * @param src1 source color image
    * @param dst  optional buffer to be used as target.<br>
    *             Create a new Image if \c dst == NULL.<br>
    *             If \c dst != NULL then size must be equal to \c src size!
    * @throw ImageException will be thrown if \c dst != NULL and the size of \c src0 / \c scr1 and \c dst or
    *                       the size of \c src0 and \c src1 is not equal.
    * @return ColorImage
    */
    ColorImage* And(const ColorImage& src0, const ColorImage& src1, ColorImage* dst=NULL);

    /**
    * \}
    * @name Border Functions
    * \{
    */

    /** Add Border with a constant value.
     * @param src    source gray image
     * @param width  width of the left and right border
     * @param height height of the top and bottom border
     * @param value  border color
     * @param dst    destination image
     */
    template<class P>
    ImageT<P>* addConstBorder(const ImageT<P> &src, uint width, uint height,
                                  P value=0, ImageT<P>* dst = NULL);


    /** Copy the border of an image.
     * @param src source gray image
     * @param width width of the left and right border
     * @param height height of the top and bottom border
     * @param dst destination image
    */
    template<class P>
    ImageT<P>* copyBorder(const ImageT<P> &src, uint width, uint height, ImageT<P>* dst);

    /**
    * \}
    * @name Threshold Functions
    * \{
    */

    /**
    * Generate a binarized image from Image \c src .
    * @param src       source gray image
    * @param threshold threshold
    * @param dst       optional buffer to be used as target.<br>
    *                  Create a new Image if \c dst == NULL.<br>
    *                  If \c dst != NULL then size must be equal to \c src 's size!
    * @return Image
    * @throw ImageException will be thrown if \c dst != NULL and the size of \c src and \c dst is not equal.
    */
    Image* threshold(const Image& src, const int threshold, Image* dst=NULL);

    /**
    * Generate a threshold image from Image \c src .
    * @param src       source Image
    * @param threshold threshold
    * @param dst       optional buffer to be used as target.<br>
    *                  Create a new Image if \c dst == NULL.<br>
    *                  If \c dst != NULL then size must be equal to \c src 's size!
    * @param value     set pixel less or equal to \c threshold to this value
    * @return Image
    * @throw ImageException will be thrown if \c dst != NULL and the size of \c src and \c dst is not equal.
    */
    Image* lowerThreshold(const Image& src, const int threshold,
                              Image* dst=NULL, const int value=0);

    /**
    * Generate a threshold image from Image \c src .
    * @param src       source Image
    * @param threshold threshold
    * @param dst       optional buffer to be used as target.<br>
    *                  Create a new Image if \c dst == NULL.<br>
    *                  If \c dst != NULL then size must be equal to \c src 's size!
    * @param value     set pixel greater than threshold to this value
    * @return Image
    * @throw ImageException will be thrown if \c dst != NULL and the size of \c src and \c dst is not equal.
    */
    Image* upperThreshold(Image& src, const int threshold,
                              Image* dst=NULL, const int value=255);

	/**
	* Generate a binarized image from Image \c src .
	* @param src       source gray image
	* @param threshold threshold
	*/
	void thresholdIP(Image& src, const int threshold);
	
	/**
	* Generate a threshold image from Image \c src .
	* @param src       source gray image
	* @param threshold threshold
	* @param value     set pixel less or equal to \c threshold to this value
	*/
	void lowerThresholdIP(Image& src, const int threshold, const int value=0);
	
	/**
	* Generate a threshold image from Image \c src .
	* @param src       source gray image
	* @param threshold threshold
	* @param value     set pixel greater than \c threshold to this value
	*/
    void upperThresholdIP(Image& src, const int threshold, const int value=255);

    /**
    * \}
    * @name Minimum / Maximum Functions
    * \{
    */

    /**
     * autoCropRect determine the rectangular area \c Rect within the pixels have larger values than a given value.
     * @param src source image
     * @param color color value
     * @param rect returned \c Rect of the area which has larger values than the color value
     **/
    template<class P>
    void autoCropRect(const ImageT<P> &src, P color, Rect &rect);
    
    
     /**
     * scale and shift image values as a new image with a destined range [min,max] 
     * @param src input image
     * @param dst output image
     * @param min target range minimum
     * @param max target range maximum
      */
    template<class P>
    void normalizeToRange(const ImageT<P> &src, ImageT<P> &dst , P min, P max);
    
    /**
     * scale and shift image values to destined range [min,max] (inplace)
     * @param src image to modify
     * @param min target range minimum
     * @param max target range maximum
     */
    template<class P>
    void normalizeToRange(ImageT<P> &src, P min, P max);
    
    
    /**
     * findLocalMinima find minima in images.
     * @param src source image
     * @param thresh minima must be below this threshold
     * @param dist  local minima have a displacement of rectangular distance to other minima
     * @param minima vector of coordiantes of minima
     **/
    template<class P>
    void findLocalMinima(const ImageT<P> &src, P thresh, int dist, std::vector<Coord> &minima);

    /**
     * findLocalMaxima find maxima in images.
     * @param src    source image
     * @param thresh maxima must be below this threshold
     * @param dist   local maxima have a displacement of rectangular distance to other minima
     * @param maxima vector of coordiantes of maxima
     **/
    template<class P>
    void findLocalMaxima(const ImageT<P> &src, P thresh, int dist, std::vector<Coord> &maxima);

    /**
    * \}
    * @name Line Segmentation
    * \{
    */

    /**
    * Create a lookup table to speed up the Hough Transformation
    * @return Pointer to gray image
    */
    FloatImage* houghTransformLUT();

    /**
    * Hough Transformation for a given gradient strength and degree image
    * @param gradStr    gradient strength image
    * @param gradDir    gradient direction image
    * @param noLines    return the \c noLines strongest Lines as result
    * @param gradThresh pixels with gradient strenth lower \c gradThresh will be ignored 
    * @param soAreaDeg  degree area which will be cleared while getting best \c nolines lines
    * @param soAreaDist distance area which will be cleared while getting best \c nolines lines
    * @param soBorder   ignore a border of size \c soBorder
    * @param lut        optional lookup table, create with \b houghTransformLUT() to speed up the ht
    * @param diffAngle  only angles from \c -diffAngle to \c +diffAngle will be accumulated
    * @throw ImageException will be thrown if the size of \c gradStr and \c gradDir is not equal.
    * @return IntMatrix of size (\c noLines x 3) or
    *         (lines found x 3) if lesser lines than \c noLines can be found.
    *   - 1.col: distance
    *   - 2.col: angle in degree
    *   - 3.col: accumulator value
    */
    IntMatrix* houghTransform(const Image& gradStr,
                              const Image& gradDir,
                              const uint& noLines,
                              const uint& gradThresh,
                              const uint& soAreaDeg,
                              const uint& soAreaDist,
                              const uint& soBorder = 0,
                              const FloatImage* lut=NULL,
                              const int diffAngle = 22);

    /**
    * Hough Transformation for a given gradient strength image
    * @param gradStr    gradient strength image
    * @param noLines    return the \c noLines strongest Lines as result
    * @param gradThresh pixels with gradient strenth lower \c gradThresh will be ignored
    * @param soAreaDeg  degree area which will be cleared while getting the stronges \c nolines lines
    * @param soAreaDist distance area which will be cleared while getting the strongest \c nolines lines
    * @param soBorder   ignore a border of size \c soBorder
    * @param lut        optional lookup table, create with \b houghTransformLUT() to speed up the ht
    * @throw ImageException will be thrown if the size of \c gradStr and \c gradDir is not equal.
    * @return IntMatrix of size (\c noLines x 3) or
    *         (lines found x 3) if lesser lines than \c noLines can be found.
    *   - 1.col: distance
    *   - 2.col: angle in degree
    *   - 3.col: accumulator value
    */
    IntMatrix* houghTransform(const Image& gradStr,
                              const uint& noLines,
                              const uint& gradThresh,
                              const uint& soAreaDeg,
                              const uint& soAreaDist,
                              const uint& soBorder = 0,
                              const FloatImage* lut=NULL);

    /**
    * \}
    * @name Corner Detection
    * \{
    */

    /**
    * Kanade-Lucas-Tomasi corner detection
    * @param src            source gray image
    * @param noCorner       return the \c noCorner strongest corners as result
    * @param EVThresh       only corners where the smaller eigenvalue is bigger than \c EVThresh will be processed
    * @param soNeighborhood only neighbors of a pixel with distance lower or equal to
                            \c soNeighborhood are taken into account during the calculation of the structure matrix
    * @param soArea         all pixels around a detected corner with distance smaller or equal to
    *                       \c soArea will be deleted
    * @param gradX          optional horizontal gradient image
    * @param gradY          optional vertical gradient image
    * @throw ImageException will be thrown, if \c gradX != NULL or \c GradY != NULL and the
    *                       size of \c gradX and \c gradY or \c gradX / \c gradY and \c src is not equal.
    * @return Matrix
    */
    Matrix* KLTCornerDetector(const Image& src,
                                 const uint& noCorner,
                                 const double& EVThresh,
                                 const uint& soNeighborhood,
                                 const uint& soArea,
                                 const GrayImage16s* gradX=NULL,
                                 const GrayImage16s* gradY=NULL);

    /**
    * \}
    * @name Floodfill Functions
    * \{
    */

    /**
    * Floodfill algorithm for GrayImages
    * fill area with the color \c newVal beginning with the starting point \c seed
    * using a 4-neighborhood
    * @param src        source gray image
    * @param seed       start point
    * @param newVal     value to fill component with
    * @param compBuffer optional buffer to be used as target.<br>
    *                   create a new IppiConnectedComp if \c compBuffer == NULL.<br>
    * @return pointer to IppiConnectedComp
    */
    template<class P>
    IppiConnectedComp* floodFill4Connected(ImageT<P>&  src,
                                           const IppiPoint&      seed,
                                           const P&              newVal,
                                           IppiConnectedComp*    compBuffer = NULL);

    /**
    * Floodfill algorithm for GrayImages
    * fill area with the color \c newVal beginning with the starting point \c seed
    * using a 4-neighborhood 
    * @param src        source gray image
    * @param seed       start point
    * @param newVal     value to fill component with
    * @param compBuffer optional buffer to be used as target.<br>
    *                   create a new IppiConnectedComp if \c compBuffer == NULL.<br>
    * @return pointer to IppiConnectedComp
    */
    template<class P>
    IppiConnectedComp* floodFill8Connected(ImageT<P>&  src,
                                           const IppiPoint&      seed,
                                           const P&              newVal,
                                           IppiConnectedComp*    compBuffer = NULL);

    /**
     * Floodfill algorithm for GrayImages
     * @param src       source image
     * @param startx    start x coordinate for floodfill
     * @param starty    start y coordinate for floodfill
     * @param newVal    new value in filled area
     * @param minDelta  minimum Delta for neighbourpixel from actual pixelvalue
     * @param maxDelta  maximum Delta for neighbourpixel from actual pixelvalue
     */
    template<class P>
    void Floodfill(ImageT<P>& src, int startx=0, int starty=0,
                   uint newVal=0, uint minDelta=50, uint maxDelta=50);

    /**
     * Floodfill algorithm for ColorImages treating all channels the same
     * @param src       source image
     * @param startx    start x coordinate for floodfill
     * @param starty    start y coordinate for floodfill
     * @param newVal    new value in filled area
     * @param minDelta      minimum Delta for neighbourpixel from actual pixelvalue
     * @param maxDelta      maximum Delta for neighbourpixel from actual pixelvalue
     */
    template<class P>
    void Floodfill(ColorImageT<P>& src, int startx=0, int starty=0,
                   uint newVal=0, uint minDelta=50, uint maxDelta=50);

    /**
     * Floodfill algorithm for ColorImages
     * @param src       source image
     * @param startx    start x coordinate for floodfill
     * @param starty    start y coordinate for floodfill
     * @param newValR   new value in filled area for R channel
     * @param newValG   new value in filled area for G channel
     * @param newValB   new value in filled area for B channel
     * @param minDeltaR     minimum Delta for neighbourpixel from actual pixelvalue for R channel
     * @param minDeltaG     minimum Delta for neighbourpixel from actual pixelvalue for G channel
     * @param minDeltaB     minimum Delta for neighbourpixel from actual pixelvalue for B channel
     * @param maxDeltaR     maximum Delta for neighbourpixel from actual pixelvalue for R channel
     * @param maxDeltaG     maximum Delta for neighbourpixel from actual pixelvalue for G channel
     * @param maxDeltaB     maximum Delta for neighbourpixel from actual pixelvalue for B channel
     */
    template<class P>
    void FloodfillRGB(ColorImageT<P>& src, int startx=0, int starty=0,
                      uint newValR=0,    uint newValG=0,    uint newValB=0,
                      uint minDeltaR=50, uint minDeltaG=50, uint minDeltaB=50,
                      uint maxDeltaR=50, uint maxDeltaG=50, uint maxDeltaB=50);
	
} // namespace

#include "core/image/ImageT.h"
#include "core/image/ImageT.h"
#include "core/image/ColorImageT.h"
#include "core/image/Buffer.h"

//#ifdef __GNUC__
	#include <core/image/ImageTools.tcc>
//#endif

#endif //LIMUN_IMAGETOOLS_H
