/* * 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.
* Create a new Image if \c dst == NULL.
* 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.
* Create a new ColorImage if \c dst == NULL.
* 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.
* Create a new Image if \c dst == NULL.
* 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.
* Create a new Image if \c dst == NULL.
* 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 ImageT

* addConstBorder(const ImageT

&src, uint width, uint height, P value=0, ImageT

* 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 ImageT

* copyBorder(const ImageT

&src, uint width, uint height, ImageT

* 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.
* Create a new Image if \c dst == NULL.
* 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.
* Create a new Image if \c dst == NULL.
* 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.
* Create a new Image if \c dst == NULL.
* 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 void autoCropRect(const ImageT

&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 void normalizeToRange(const ImageT

&src, ImageT

&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 void normalizeToRange(ImageT

&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 void findLocalMinima(const ImageT

&src, P thresh, int dist, std::vector &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 void findLocalMaxima(const ImageT

&src, P thresh, int dist, std::vector &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.
* create a new IppiConnectedComp if \c compBuffer == NULL.
* @return pointer to IppiConnectedComp */ template IppiConnectedComp* floodFill4Connected(ImageT

& 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.
* create a new IppiConnectedComp if \c compBuffer == NULL.
* @return pointer to IppiConnectedComp */ template IppiConnectedComp* floodFill8Connected(ImageT

& 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 void Floodfill(ImageT

& 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 void Floodfill(ColorImageT

& 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 void FloodfillRGB(ColorImageT

& 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 //#endif #endif //LIMUN_IMAGETOOLS_H