ImageProcessor.h

Go to the documentation of this file.

// ****************************************************************************
// This file is part of the Integrating Vision Toolkit (IVT).
//
// The IVT is maintained by the Karlsruhe Institute of Technology (KIT)
// (www.kit.edu) in cooperation with the company Keyetech (www.keyetech.de).
//
// Copyright (C) 2014 Karlsruhe Institute of Technology (KIT).
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the KIT nor the names of its contributors may be
//    used to endorse or promote products derived from this software
//    without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE KIT AND CONTRIBUTORS “AS IS” AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE KIT OR CONTRIBUTORS BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ****************************************************************************
// ****************************************************************************
// Filename:  ImageProcessor.h
// Author:    Pedram Azad
// Date:      2004
// ****************************************************************************
// Changes:   28.09.2011, Jan Issac
//            * Added methods ConvertImage for conversion from CFloatImage
//              to CByteImage and vice versa
// ****************************************************************************

#ifndef _IMAGE_PROCESSOR_H_
#define _IMAGE_PROCESSOR_H_


// ****************************************************************************
// Necessary includes
// ****************************************************************************

#include "Math/Math2d.h"
#include "Math/Math3d.h"
#include "Structs/Structs.h"
#include "Structs/ObjectDefinitions.h"


// ****************************************************************************
// Forward declarations
// ****************************************************************************

class CFloatMatrix;
class CDoubleMatrix;
class CRGBColorModel;
class CByteImage;
class CShortImage;
class CIntImage;
class CFloatImage;
class CColorParameterSet;
struct Mat3d;



// ****************************************************************************
// ImageProcessor
// ****************************************************************************

namespace ImageProcessor
{
        bool ConvertImage(const CByteImage *pInputImage, CByteImage *pOutputImage, bool bFast = false, const MyRegion *pROI = 0);

    bool ConvertImage(const CFloatImage *pInputImage, CByteImage *pOutputImage, bool equalize = false);

    bool ConvertImage(const CByteImage *pInputImage, CFloatImage *pOutputImage);

    bool ConvertImage(const CFloatMatrix *pInputImage, CByteImage *pOutputImage);

        bool ConvertImage(const CByteImage *pInputImage, CFloatMatrix *pOutputImage);
        
        bool ConvertImage(const CShortImage *pInputImage, CByteImage *pOutputImage);

        bool ConvertImage(const CByteImage *pInputImage, CShortImage *pOutputImage);
        
        bool ConvertImage(const CIntImage *pInputImage, CByteImage *pOutputImage);
        
        bool ConvertImage(const CByteImage *pInputImage, CIntImage *pOutputImage);
        
        bool ConvertMatrix(const CFloatMatrix *pInputImage, CDoubleMatrix *pOutputImage);
        
        bool ConvertMatrix(const CDoubleMatrix *pInputImage, CFloatMatrix *pOutputImage);

        bool CopyImage(const CByteImage *pInputImage, CByteImage *pOutputImage, const MyRegion *pROI = 0, bool bUseSameSize = false);

        bool CopyImage(const CShortImage *pInputImage, CShortImage *pOutputImage, const MyRegion *pROI = 0, bool bUseSameSize = false);

        bool CopyMatrix(const CFloatMatrix *pInputImage, CFloatMatrix *pOutputImage);
        
        bool CopyMatrix(const CDoubleMatrix *pInputImage, CDoubleMatrix *pOutputImage);

        void Zero(CByteImage *pImage, const MyRegion *pROI = 0);
        
        void Zero(CShortImage *pImage);
        
        void Zero(CIntImage *pImage);
        
        void Zero(CFloatMatrix *pImage);

        void Zero(CDoubleMatrix *pImage);


        bool FlipY(const CByteImage *pInputImage, CByteImage *pOutputImage);

                
        bool AverageFilter(const CByteImage *pInputImage, CByteImage *pOutputImage, int nMaskSize = 3);

        bool GaussianSmooth(const CByteImage *pInputImage, CFloatMatrix *pOutputImage, float fVariance, int nKernelSize);
        
        bool GaussianSmooth(const CFloatMatrix *pInputImage, CFloatMatrix *pOutputImage, float fVariance, int nKernelSize);

        bool GaussianSmooth(const CByteImage *pInputImage, CByteImage *pOutputImage, float fVariance, int nKernelSize);

        bool GaussianSmooth5x5(const CFloatMatrix *pInputImage, CFloatMatrix *pOutputImage, float fVariance);

        bool GaussianSmooth3x3(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool GaussianSmooth5x5(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool HighPassX3(const CFloatMatrix *pInputImage, CFloatMatrix *pOutputImage);

        bool HighPassY3(const CFloatMatrix *pInputImage, CFloatMatrix *pOutputImage);

        bool SobelX(const CByteImage *pInputImage, CShortImage *pOutputImage, bool bAbsoluteValue = true);

        bool SobelX(const CByteImage *pInputImage, CByteImage *pOutputImage, bool bAbsoluteValue = true);

        bool SobelY(const CByteImage *pInputImage, CShortImage *pOutputImage, bool bAbsoluteValue = true);

        bool SobelY(const CByteImage *pInputImage, CByteImage *pOutputImage, bool bAbsoluteValue = true);

        bool PrewittX(const CByteImage *pInputImage, CShortImage *pOutputImage, bool bAbsoluteValue = true);
        
        bool PrewittX(const CByteImage *pInputImage, CByteImage *pOutputImage, bool bAbsoluteValue = true);

        bool PrewittY(const CByteImage *pInputImage, CShortImage *pOutputImage, bool bAbsoluteValue = true);

        bool PrewittY(const CByteImage *pInputImage, CByteImage *pOutputImage, bool bAbsoluteValue = true);

        bool Laplace1(const CByteImage *pInputImage, CShortImage *pOutputImage, bool bAbsoluteValue = true);

        bool Laplace1(const CByteImage *pInputImage, CByteImage *pOutputImage, bool bAbsoluteValue = true);

        bool Laplace2(const CByteImage *pInputImage, CShortImage *pOutputImage, bool bAbsoluteValue = true);

        bool Laplace2(const CByteImage *pInputImage, CByteImage *pOutputImage, bool bAbsoluteValue = true);

        bool GeneralFilter(const CByteImage *pInputImage, CByteImage *pOutputImage, const int *pKernel, int nMaskSize, int nDivider = 1, bool bAbsoluteValue = false);

        bool GeneralFilter(const CByteImage *pInputImage, CShortImage *pOutputImage, const int *pKernel, int nMaskSize, int nDivider = 1, bool bAbsoluteValue = false);

        bool GeneralFilter(const CByteImage *pInputImage, CFloatMatrix *pOutputImage, const int *pKernel, int nMaskSize, int nDivider = 1, bool bAbsoluteValue = false);

        bool CalculateGradientImagePrewitt(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool CalculateGradientImageSobel(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool CalculateGradientImage(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool CalculateGradientImageBinary(const CByteImage *pInputImage, CByteImage *pOutputImage);


        bool ApplyAffinePointOperation(const CByteImage *pInputImage, CByteImage *pOutputImage, float a, float b);
        
        bool NormalizeColor(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool HistogramEqualization(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool HistogramStretching(const CByteImage *pInputImage, CByteImage *pOutputImage, float p1 = 0.1f, float p2 = 0.9f);

        bool Spread(const CByteImage *pInputImage, CByteImage *pOutputImage);
                
        
        bool ApplyHomography(const CByteImage *pInputImage, CByteImage *pOutputImage, const Mat3d& A, bool bInterpolation = true);

        bool ApplyHomography(const CByteImage *pInputImage, CByteImage *pOutputImage, float a1, float a2, float a3, float a4, float a5, float a6, float a7, float a8, bool bInterpolation = true);

        bool Resize(const CByteImage *pInputImage, CByteImage *pOutputImage, const MyRegion *pROI = 0, bool bInterpolation = true);

        bool Rotate(const CByteImage *pInputImage, CByteImage *pOutputImage, float mx, float my, float theta, bool bInterpolation = true);
        
        bool DetermineHomography(const Vec2d *pSourcePoints, const Vec2d *pTargetPoints, int nPoints, float &a1, float &a2, float &a3, float &a4, float &a5, float &a6, float &a7, float &a8);

        bool DetermineAffineTransformation(const Vec2d *pSourcePoints, const Vec2d *pTargetPoints, int nPoints, float &a1, float &a2, float &a3, float &a4, float &a5, float &a6);

        bool CalculateSaturationImage(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool FilterRGB(const CByteImage *pInputImage, CByteImage *pOutputImage, CRGBColorModel *pColorModel, float fThreshold);

        bool CalculateHSVImage(const CByteImage *pInputImage, CByteImage *pOutputImage, const MyRegion *pROI = 0);
        
        bool FilterHSV(const CByteImage *pInputImage, CByteImage *pOutputImage, unsigned char hue, unsigned char tol_hue, unsigned char min_sat, unsigned char max_sat, unsigned char min_v, unsigned char max_v, const MyRegion *pROI = 0);

        bool FilterHSV2(const CByteImage *pInputImage, CByteImage *pOutputImage, unsigned char min_hue, unsigned char max_hue, unsigned char min_sat, unsigned char max_sat, unsigned char min_v, unsigned char max_v, const MyRegion *pROI = 0);

    bool FilterColor(const CByteImage *pInputImage, CByteImage *pOutputImage, ObjectColor cColor, CColorParameterSet* pColorParameterSet, bool bImageIsHSV=true);


        void ZeroFrame(CByteImage *pImage);

        void ZeroFrame(CShortImage *pImage);
        
        void ZeroFrame(CIntImage *pImage);      

        bool CopyFrame(const CByteImage *pInputImage, CByteImage *pOutputImage);
        
        bool AdaptFrame(const CByteImage *pInputImage, CByteImage *pOutputImage);
        
        bool Invert(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool Amplify(const CByteImage *pInputImage, CByteImage *pOutputImage, float fFactor);
        
        bool Rotate180Degrees(const CByteImage *pInputImage, CByteImage *pOutputImage);

        bool Canny(const CByteImage *pInputImage, CByteImage *pOutputImage, int nLowThreshold, int nHighThreshold);

        bool Canny(const CByteImage *pInputImage, CVec2dArray &resultPoints, CVec2dArray &resultDirections, int nLowThreshold, int nHighThreshold);

        bool ThresholdBinarize(const CByteImage *pInputImage, CByteImage *pOutputImage, unsigned char nThreshold);

        bool ThresholdBinarizeInverse(const CByteImage *pInputImage, CByteImage *pOutputImage, unsigned char nThreshold);

        bool ThresholdBinarize(const CByteImage *pInputImage, CByteImage *pOutputImage, unsigned char nMinThreshold, unsigned char nMaxThreshold);

        bool ThresholdFilter(const CByteImage *pInputImage, CByteImage *pOutputImage, unsigned char nThreshold);

        bool ThresholdFilterInverse(const CByteImage *pInputImage, CByteImage *pOutputImage, unsigned char nThreshold);

        bool CalculateHarrisMap(const CByteImage *pInputImage, CIntImage *pOutputImage);

        int CalculateHarrisInterestPoints(const CByteImage *pInputImage, Vec2d *pInterestPoints, int nMaxPoints, float fQualityLevel = 0.01f, float fMinDistance = 5.0f);
        

        bool And(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);

        bool Xor(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);

        bool Or(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);


        bool Dilate(const CByteImage *pInputImage, CByteImage *pOutputImage, int nMaskSize = 3, const MyRegion *pROI = 0);

        bool Erode(const CByteImage *pInputImage, CByteImage *pOutputImage, int nMaskSize = 3, const MyRegion *pROI = 0);

        int RegionGrowing(const CByteImage *pInputImage, MyRegion &resultRegion, int x, int y, int nMinimumPointsPerRegion = 0, int nMaximumPointsPerRegion = 0, bool bCalculateBoundingBox = true, bool bStorePixels = false);

        bool FindRegions(const CByteImage *pImage, RegionList &regionList, int nMinimumPointsPerRegion = 0, int nMaximumPointsPerRegion = 0, bool bCalculateBoundingBox = true, bool bStorePixels = false);

        bool FindRegions(const CByteImage *pImage, CRegionArray &regionList, int nMinimumPointsPerRegion = 0, int nMaximumPointsPerRegion = 0, bool bCalculateBoundingBox = true, bool bStorePixels = false);

        bool HoughTransformLines(const CByteImage *pImage, CByteImage *pVisualizationImage, Vec2dList &resultLines, int nLinesToExtract, int nMinHits = 1);

        bool HoughTransformCircles(const CByteImage *pImage, CByteImage *pVisualizationImage, Vec3dList &resultCircles, int rmin, int rmax, int nCirclesToExtract, int nMinHits = 1);
        
        void HoughTransformLines(const CVec2dArray &edgePoints, const CVec2dArray &edgeDirections, int width, int height, int nLinesToExtract, int nMinHits, CVec2dArray &resultLines, CIntArray &resultHits, CByteImage *pVisualizationImage = 0);
        
        void HoughTransformLines(const CVec2dArray &edgePoints, const CVec2dArray &edgeDirections, int width, int height, int nLinesToExtract, int nMinHits, CStraightLine2dArray &resultLines, CIntArray &resultHits, CByteImage *pVisualizationImage = 0);
        
        bool HoughTransformCircles(const CVec2dArray &edgePoints, const CVec2dArray &edgeDirections, int width, int height, int rmin, int rmax, int nCirclesToExtract, int nMinHits, CVec3dArray &resultCircles, CIntArray &resultHits, CByteImage *pVisualizationImage = 0);

        bool HoughTransformCircles(const CVec2dArray &edgePoints, const CVec2dArray &edgeDirections, int width, int height, int rmin, int rmax, int nCirclesToExtract, int nMinHits, CCircle2dArray &resultCircles, CIntArray &resultHits, CByteImage *pVisualizationImage = 0);


        bool ThresholdBinarize(const CFloatMatrix *pInputImage, CFloatMatrix *pOutputImage, float fThreshold);
        
        bool CalculateIntegralImage(const CByteImage *pInputImage, CIntImage *pIntegralImage);
        
        bool CalculateSummedAreaTable(const CByteImage *pInputImage, CIntImage *pSummedAreaTable);
        
        int GetAreaSum(const CIntImage *pIntegralImage, int min_x, int min_y, int max_x, int max_y);
        
        inline int GetAreaSumNoChecks(const CIntImage *pIntegralImage, int min_x, int min_y, int max_x, int max_y);
        
        int GetAreaSum(const CIntImage *pIntegralImage, const MyRegion *pRegion);
        
        bool CalculateBinarizedSummedAreaTable(const CByteImage *pInputImage, CIntImage *pSummedAreaTable);
        
        bool CalculateReverseSummedAreaTable(const CIntImage *pSummedAreaTable, CByteImage *pOutputImage);


        enum BayerPatternType
        {
                eBayerRG,
                eBayerGR,
                eBayerBG,
                eBayerGB
        };

        bool ConvertBayerPattern(const CByteImage *pInputImage, CByteImage *pOutputImage, BayerPatternType type);


        bool Add(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);
        
        bool AddWithSaturation(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);

        bool Subtract(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);        
        
        bool SubtractWithSaturation(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);
        
        bool AbsoluteDifference(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);
        
        bool Average(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);

        bool Min(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);

        bool Max(const CByteImage *pInputImage1, const CByteImage *pInputImage2, CByteImage *pOutputImage);
        
        
        unsigned char MaxValue(const CByteImage *pImage);

        short MaxValue(const CShortImage *pImage);

        int MaxValue(const CIntImage *pImage);
        
        unsigned char MinValue(const CByteImage *pImage);
        
        short MinValue(const CShortImage *pImage);
        
        int MinValue(const CIntImage *pImage);
        
        bool MinMaxValue(const CByteImage *pImage, unsigned char &min, unsigned char &max);
        
        void MinMaxValue(const CShortImage *pImage, short &min, short &max);
        
        void MinMaxValue(const CIntImage *pImage, int &min, int &max);

        unsigned int PixelSum(const CByteImage *pImage);
}



#endif /* _IMAGE_PROCESSOR_H_ */