Delphi-OpenCV/include/imgproc/imgproc.pas

// --------------------------------- OpenCV license.txt ---------------------------
(* //    IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
  //
  //    By downloading, copying, installing or using the software you agree to this license.
  //    If you do not agree to this license, do not download, install,
  //    copy or use the software.
  //
  //
  //                             License Agreement
  //                  For Open Source Computer Vision Library
  //
  //   Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
  //   Copyright (C) 2009, Willow Garage Inc., all rights reserved.
  //   Third party copyrights are property of their respective owners.
  //
  //   Redistribution and use in source and binary forms, with or without modification,
  //   are permitted provided that the following conditions are met:
  //
  //     * Redistribution's of source code must retain the above copyright notice,
  //       this list of conditions and the following disclaimer.
  //
  //     * Redistribution's 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.
  //
  //     * The name of the copyright holders may not be used to endorse or promote products
  //       derived from this software without specific prior written permission.
  //
  //   This software is provided by the copyright holders 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 Intel Corporation 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. *)

(* /  **************************************************************************************************
  //                                 Project Delphi-OpenCV
  //  **************************************************************************************************
  //  Contributor:
  //  laentir Valetov
  //  email:laex@bk.ru
  //  **************************************************************************************************
  //  You may retrieve the latest version of this file at the GitHub,
  //  located at git://github.com/Laex/Delphi-OpenCV.git
  //  **************************************************************************************************
  //  License:
  //  The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License");
  //  you may not use this file except in compliance with the License. You may obtain a copy of the
  //  License at http://www.mozilla.org/MPL/
  //
  //  Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
  //  ANY KIND, either express or implied. See the License for the specific language governing rights
  //  and limitations under the License.
  //
  //  Alternatively, the contents of this file may be used under the terms of the
  //  GNU Lesser General Public License (the  "LGPL License"), in which case the
  //  provisions of the LGPL License are applicable instead of those above.
  //  If you wish to allow use of your version of this file only under the terms
  //  of the LGPL License and not to allow others to use your version of this file
  //  under the MPL, indicate your decision by deleting  the provisions above and
  //  replace  them with the notice and other provisions required by the LGPL
  //  License.  If you do not delete the provisions above, a recipient may use
  //  your version of this file under either the MPL or the LGPL License.
  //
  //  For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html
  //  **************************************************************************************************
  //  Warning: Using Delphi XE3 syntax!
  //  **************************************************************************************************
  //  The Initial Developer of the Original Code:
  //  OpenCV: open source computer vision library
  //  Homepage:    http://opencv.org
  //  Online docs: http://docs.opencv.org
  //  Q&A forum:   http://answers.opencv.org
  //  Dev zone:    http://code.opencv.org
  //  **************************************************************************************************
  //  Original file:
  //  opencv\modules\imgproc\include\opencv2\imgproc.hpp
  //  ************************************************************************************************* *)

{$IFDEF DEBUG}
{$A8,B-,C+,D+,E-,F-,G+,H+,I+,J-,K-,L+,M-,N+,O-,P+,Q+,R+,S-,T-,U-,V+,W+,X+,Y+,Z1}
{$ELSE}
{$A8,B-,C-,D-,E-,F-,G+,H+,I+,J-,K-,L-,M-,N+,O+,P+,Q-,R-,S-,T-,U-,V+,W-,X+,Y-,Z1}
{$ENDIF}
{$WARN SYMBOL_DEPRECATED OFF}
{$WARN SYMBOL_PLATFORM OFF}
{$WARN UNIT_PLATFORM OFF}
{$WARN UNSAFE_TYPE OFF}
{$WARN UNSAFE_CODE OFF}
{$WARN UNSAFE_CAST OFF}
{$POINTERMATH ON}
unit imgproc;

interface

Uses core_c, Core.types_c, imgproc.types_c;

// {
//
/// /! various border interpolation methods
const
  BORDER_REPLICATE = IPL_BORDER_REPLICATE;
  BORDER_CONSTANT = IPL_BORDER_CONSTANT;
  BORDER_REFLECT = IPL_BORDER_REFLECT;
  BORDER_WRAP = IPL_BORDER_WRAP;
  BORDER_REFLECT_101 = IPL_BORDER_REFLECT_101;
  BORDER_REFLECT101 = BORDER_REFLECT_101;
  BORDER_TRANSPARENT = IPL_BORDER_TRANSPARENT;
  BORDER_DEFAULT = BORDER_REFLECT_101;
  BORDER_ISOLATED = 16;
  //
  /// /! 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
  // CV_EXPORTS_W int borderInterpolate( int p, int len, int borderType );

  /// *!
  // The Base Class for 1D or Row-wise Filters
  //
  // This is the base class for linear or non-linear filters that process 1D data.
  // In particular, such filters are used for the "horizontal" filtering parts in separable filters.
  //
  // Several functions in OpenCV return Ptr<BaseRowFilter> for the specific types of filters,
  // and those pointers can be used directly or within cv::FilterEngine.
  // */
  // class CV_EXPORTS BaseRowFilter
  // {
  // public:
  // //! the default constructor
  // BaseRowFilter();
  // //! the destructor
  // virtual ~BaseRowFilter();
  // //! the filtering operator. Must be overrided in the derived classes. The horizontal border interpolation is done outside of the class.
  // virtual void operator()(const uchar* src, uchar* dst,
  // int width, int cn) = 0;
  // int ksize, anchor;
  // };

Type
  TBaseRowFilter = class
  private
    Fanchor: Integer;
    Fksize: Integer;
  public
    // ! the default constructor
    constructor Create;
    // ! the destructor
    destructor Destroy; override;
    // ! the filtering operator. Must be overrided in the derived classes. The horizontal border interpolation is done outside of the class.
    // virtual void operator()(const uchar* src, uchar* dst, int width, int cn) = 0;
    // int ksize, anchor;
    property ksize: Integer read Fksize write Fksize;
    property anchor: Integer read Fanchor write Fanchor;
  end;


  //
  /// *!
  // The Base Class for Column-wise Filters
  //
  // This is the base class for linear or non-linear filters that process columns of 2D arrays.
  // Such filters are used for the "vertical" filtering parts in separable filters.
  //
  // Several functions in OpenCV return Ptr<BaseColumnFilter> for the specific types of filters,
  // and those pointers can be used directly or within cv::FilterEngine.
  //
  // Unlike cv::BaseRowFilter, cv::BaseColumnFilter may have some context information,
  // i.e. box filter keeps the sliding sum of elements. To reset the state BaseColumnFilter::reset()
  // must be called (e.g. the method is called by cv::FilterEngine)
  // */
  // class CV_EXPORTS BaseColumnFilter
  // {
  // public:
  // //! the default constructor
  // BaseColumnFilter();
  // //! the destructor
  // virtual ~BaseColumnFilter();
  // //! the filtering operator. Must be overrided in the derived classes. The vertical border interpolation is done outside of the class.
  // virtual void operator()(const uchar** src, uchar* dst, int dststep,
  // int dstcount, int width) = 0;
  // //! resets the internal buffers, if any
  // virtual void reset();
  // int ksize, anchor;
  // };

type
  TBaseColumnFilter = class
  private
    Fanchor: Integer;
    Fksize: Integer;
  public
    // //! the default constructor
    // BaseColumnFilter();
    constructor Create;
    // //! the destructor
    // virtual ~BaseColumnFilter();
    destructor Destroy; override;
    // //! the filtering operator. Must be overrided in the derived classes. The vertical border interpolation is done outside of the class.
    // virtual void operator()(const uchar** src, uchar* dst, int dststep, int dstcount, int width) = 0;
    // //! resets the internal buffers, if any
    // virtual void reset();
    procedure reset; virtual;
    // int ksize, anchor;
    property ksize: Integer Read Fksize write Fksize;
    property anchor: Integer Read Fanchor write Fanchor;
  end;


  // *!
  // The Base Class for Non-Separable 2D Filters.
  //
  // This is the base class for linear or non-linear 2D filters.
  //
  // Several functions in OpenCV return Ptr<BaseFilter> for the specific types of filters,
  // and those pointers can be used directly or within cv::FilterEngine.
  //
  // Similar to cv::BaseColumnFilter, the class may have some context information,
  // that should be reset using BaseFilter::reset() method before processing the new array.
  //

  // class CV_EXPORTS BaseFilter
  // {
  // public:
  // //! the default constructor
  // BaseFilter();
  // //! the destructor
  // virtual ~BaseFilter();
  // //! the filtering operator. The horizontal and the vertical border interpolation is done outside of the class.
  // virtual void operator()(const uchar** src, uchar* dst, int dststep,
  // int dstcount, int width, int cn) = 0;
  // //! resets the internal buffers, if any
  // virtual void reset();
  // Size ksize;
  // Point anchor;
  // };

Type
  TBaseFilter = class
  private
    Fksize: TcvSize;
    Fanchor: TcvPoint;
  public
    // {
    // public:
    // ! the default constructor
    // BaseFilter();
    constructor Create;
    // ! the destructor
    // virtual ~BaseFilter();
    destructor Destroy; override;
    // //! the filtering operator. The horizontal and the vertical border interpolation is done outside of the class.
    // virtual void operator()(const uchar** src, uchar* dst, int dststep, int dstcount, int width, int cn) = 0;
    // //! resets the internal buffers, if any
    // virtual void reset();
    procedure reset; virtual;
    // Size ksize;
    property ksize: TcvSize read Fksize write Fksize;
    // Point anchor;
    property anchor: TcvPoint read Fanchor write Fanchor;
  end;

  /// *!
  // The Main Class for Image Filtering.
  //
  // The class can be used to apply an arbitrary filtering operation to an image.
  // It contains all the necessary intermediate buffers, it computes extrapolated values
  // of the "virtual" pixels outside of the image etc.
  // Pointers to the initialized cv::FilterEngine instances
  // are returned by various OpenCV functions, such as cv::createSeparableLinearFilter(),
  // cv::createLinearFilter(), cv::createGaussianFilter(), cv::createDerivFilter(),
  // cv::createBoxFilter() and cv::createMorphologyFilter().
  //
  // Using the class you can process large images by parts and build complex pipelines
  // that include filtering as some of the stages. If all you need is to apply some pre-defined
  // filtering operation, you may use cv::filter2D(), cv::erode(), cv::dilate() etc.
  // functions that create FilterEngine internally.
  //
  // Here is the example on how to use the class to implement Laplacian operator, which is the sum of
  // second-order derivatives. More complex variant for different types is implemented in cv::Laplacian().
  //
  // \code
  // void laplace_f(const Mat& src, Mat& dst)
  // {
  // CV_Assert( src.type() == CV_32F );
  // // make sure the destination array has the proper size and type
  // dst.create(src.size(), src.type());
  //
  // // get the derivative and smooth kernels for d2I/dx2.
  // // for d2I/dy2 we could use the same kernels, just swapped
  // Mat kd, ks;
  // getSobelKernels( kd, ks, 2, 0, ksize, false, ktype );
  //
  // // let's process 10 source rows at once
  // int DELTA = std::min(10, src.rows);
  // Ptr<FilterEngine> Fxx = createSeparableLinearFilter(src.type(),
  // dst.type(), kd, ks, Point(-1,-1), 0, borderType, borderType, Scalar() );
  // Ptr<FilterEngine> Fyy = createSeparableLinearFilter(src.type(),
  // dst.type(), ks, kd, Point(-1,-1), 0, borderType, borderType, Scalar() );
  //
  // int y = Fxx->start(src), dsty = 0, dy = 0;
  // Fyy->start(src);
  // const uchar* sptr = src.data + y*src.step;
  //
  // // allocate the buffers for the spatial image derivatives;
  // // the buffers need to have more than DELTA rows, because at the
  // // last iteration the output may take max(kd.rows-1,ks.rows-1)
  // // rows more than the input.
  // Mat Ixx( DELTA + kd.rows - 1, src.cols, dst.type() );
  // Mat Iyy( DELTA + kd.rows - 1, src.cols, dst.type() );
  //
  // // inside the loop we always pass DELTA rows to the filter
  // // (note that the "proceed" method takes care of possibe overflow, since
  // // it was given the actual image height in the "start" method)
  // // on output we can get:
  // //  * < DELTA rows (the initial buffer accumulation stage)
  // //  * = DELTA rows (settled state in the middle)
  // //  * > DELTA rows (then the input image is over, but we generate
  // //                  "virtual" rows using the border mode and filter them)
  // // this variable number of output rows is dy.
  // // dsty is the current output row.
  // // sptr is the pointer to the first input row in the portion to process
  // for( ; dsty < dst.rows; sptr += DELTA*src.step, dsty += dy )
  // {
  // Fxx->proceed( sptr, (int)src.step, DELTA, Ixx.data, (int)Ixx.step );
  // dy = Fyy->proceed( sptr, (int)src.step, DELTA, d2y.data, (int)Iyy.step );
  // if( dy > 0 )
  // {
  // Mat dstripe = dst.rowRange(dsty, dsty + dy);
  // add(Ixx.rowRange(0, dy), Iyy.rowRange(0, dy), dstripe);
  // }
  // }
  // }
  // \endcode
  // */


  // class CV_EXPORTS FilterEngine
  // {
  // public:
  // //! the default constructor
  // FilterEngine();
  // //! the full constructor. Either _filter2D or both _rowFilter and _columnFilter must be non-empty.
  // FilterEngine(const Ptr<BaseFilter>& _filter2D,
  // const Ptr<BaseRowFilter>& _rowFilter,
  // const Ptr<BaseColumnFilter>& _columnFilter,
  // int srcType, int dstType, int bufType,
  // int _rowBorderType=BORDER_REPLICATE,
  // int _columnBorderType=-1,
  // const Scalar& _borderValue=Scalar());
  // //! the destructor
  // virtual ~FilterEngine();
  // //! reinitializes the engine. The previously assigned filters are released.
  // void init(const Ptr<BaseFilter>& _filter2D,
  // const Ptr<BaseRowFilter>& _rowFilter,
  // const Ptr<BaseColumnFilter>& _columnFilter,
  // int srcType, int dstType, int bufType,
  // int _rowBorderType=BORDER_REPLICATE, int _columnBorderType=-1,
  // const Scalar& _borderValue=Scalar());
  // //! starts filtering of the specified ROI of an image of size wholeSize.
  // virtual int start(Size wholeSize, Rect roi, int maxBufRows=-1);
  // //! starts filtering of the specified ROI of the specified image.
  // virtual int start(const Mat& src, const Rect& srcRoi=Rect(0,0,-1,-1),
  // bool isolated=false, int maxBufRows=-1);
  // //! processes the next srcCount rows of the image.
  // virtual int proceed(const uchar* src, int srcStep, int srcCount,
  // uchar* dst, int dstStep);
  // //! applies filter to the specified ROI of the image. if srcRoi=(0,0,-1,-1), the whole image is filtered.
  // virtual void apply( const Mat& src, Mat& dst,
  // const Rect& srcRoi=Rect(0,0,-1,-1),
  // Point dstOfs=Point(0,0),
  // bool isolated=false);
  // //! returns true if the filter is separable
  // bool isSeparable() const { return (const BaseFilter*)filter2D == 0; }
  // //! returns the number
  // int remainingInputRows() const;
  // int remainingOutputRows() const;
  //
  // int srcType, dstType, bufType;
  // Size ksize;
  // Point anchor;
  // int maxWidth;
  // Size wholeSize;
  // Rect roi;
  // int dx1, dx2;
  // int rowBorderType, columnBorderType;
  // std::vector<int> borderTab;
  // int borderElemSize;
  // std::vector<uchar> ringBuf;
  // std::vector<uchar> srcRow;
  // std::vector<uchar> constBorderValue;
  // std::vector<uchar> constBorderRow;
  // int bufStep, startY, startY0, endY, rowCount, dstY;
  // std::vector<uchar*> rows;
  //
  // Ptr<BaseFilter> filter2D;
  // Ptr<BaseRowFilter> rowFilter;
  // Ptr<BaseColumnFilter> columnFilter;
  // };

  TFilterEngine = class
  private
    // int srcType, dstType, bufType;
    srcType, dstType, bufType: Integer;
    // Size ksize;
    ksize: TcvSize;
    // Point anchor;
    anchor: TcvPoint;
    // int maxWidth;
    maxWidth: Integer;
    // Size wholeSize;
    wholeSize: TcvSize;
    // Rect roi;
    roi: TCvRect;
    // int dx1, dx2;
    dx1, dx2: Integer;
    // int rowBorderType, columnBorderType;
    rowBorderType, columnBorderType: Integer;
    // std::vector<int> borderTab;
    borderTab: TArray<Integer>;
    // int borderElemSize;
    borderElemSize: Integer;
    // std::vector<uchar> ringBuf;
    ringBuf: TArray<byte>;
    // std::vector<uchar> srcRow;
    srcRow: TArray<byte>;
    // std::vector<uchar> constBorderValue;
    constBorderValue: TArray<byte>;
    // std::vector<uchar> constBorderRow;
    constBorderRow: TArray<byte>;
    // int bufStep, startY, startY0, endY, rowCount, dstY;
    bufStep, startY, startY0, endY, rowCount, dstY: Integer;
    // std::vector<uchar*> rows;
    rows: TArray<pByte>;
  public
    // ! the default constructor
    // FilterEngine();
    constructor Create; overload;
    // ! the full constructor. Either _filter2D or both _rowFilter and _columnFilter must be non-empty.
    // FilterEngine(const Ptr<BaseFilter>& _filter2D,
    constructor Create(const _filter2D: TBaseFilter; const _rowFilter: TBaseRowFilter;
      const _columnFilter: TBaseColumnFilter; srcType: Integer; dstType: Integer; bufType: Integer;
      _rowBorderType: Integer { =BORDER_REPLICATE }; _columnBorderType: Integer { =-1 };
      const _borderValue: TcvScalar { =TScalar.Create } ); overload;
    // //! the destructor
    // virtual ~FilterEngine();
    destructor Destroy; override;
    // //! reinitializes the engine. The previously assigned filters are released.
    // void init(const Ptr<BaseFilter>& _filter2D,
    procedure Init(const _filter2D: TBaseFilter; const _rowFilter: TBaseRowFilter;
      const _columnFilter: TBaseColumnFilter; srcType: Integer; dstType: Integer; bufType: Integer;
      _rowBorderType: Integer { =BORDER_REPLICATE }; _columnBorderType: Integer { =-1 };
      const _borderValue: TcvScalar { =TScalar.Create } );
    // //! starts filtering of the specified ROI of an image of size wholeSize.
    // virtual int start(Size wholeSize, Rect roi, int maxBufRows=-1);
    function start(wholeSize: TcvSize; roi: TCvRect; maxBufRows: Integer = -1): Integer; overload; virtual;
    // //! starts filtering of the specified ROI of the specified image.
    // virtual int start(const Mat& src, const Rect& srcRoi=Rect(0,0,-1,-1),bool isolated=false, int maxBufRows=-1);
    function start(const src: pIplImage; const srcRoi: TCvRect { =Rect(0,0,-1,-1) }; isolated: boolean = false;
      maxBufRows: Integer = -1): Integer; overload; virtual;
    // //! processes the next srcCount rows of the image.
    // virtual int proceed(const uchar* src, int srcStep, int srcCount,uchar* dst, int dstStep);
    function proceed(const src: pByte; srcStep: Integer; srcCount: Integer; dst: pByte; dstStep: Integer)
      : Integer; virtual;
    // //! applies filter to the specified ROI of the image. if srcRoi=(0,0,-1,-1), the whole image is filtered.
    // virtual void apply( const Mat& src, Mat& dst, const Rect& srcRoi=Rect(0,0,-1,-1), Point dstOfs=Point(0,0), bool isolated=false);
    procedure apply(const src: pIplImage; dst: pIplImage; const srcRoi: TCvRect { =Rect(0,0,-1,-1) };
      dstOfs: TcvPoint { =Point(0,0) }; isolated: boolean = false); virtual;
    // //! returns true if the filter is separable
    // bool isSeparable() const { return (const BaseFilter*)filter2D == 0; }
    // //! returns the number
    // int remainingInputRows() const;
    // int remainingOutputRows() const;
    // Ptr<BaseFilter> filter2D;
    // Ptr<BaseRowFilter> rowFilter;
    // Ptr<BaseColumnFilter> columnFilter;
    // };
  end;

  /// /! type of the kernel
  // enum { KERNEL_GENERAL=0, KERNEL_SYMMETRICAL=1, KERNEL_ASYMMETRICAL=2,
  // KERNEL_SMOOTH=4, KERNEL_INTEGER=8 };
  //
  /// /! returns type (one of KERNEL_*) of 1D or 2D kernel specified by its coefficients.
  // CV_EXPORTS int getKernelType(InputArray kernel, Point anchor);
  //
  /// /! returns the primitive row filter with the specified kernel
  // CV_EXPORTS Ptr<BaseRowFilter> getLinearRowFilter(int srcType, int bufType,
  // InputArray kernel, int anchor,
  // int symmetryType);
  //
  /// /! returns the primitive column filter with the specified kernel
  // CV_EXPORTS Ptr<BaseColumnFilter> getLinearColumnFilter(int bufType, int dstType,
  // InputArray kernel, int anchor,
  // int symmetryType, double delta=0,
  // int bits=0);
  //
  /// /! returns 2D filter with the specified kernel
  // CV_EXPORTS Ptr<BaseFilter> getLinearFilter(int srcType, int dstType,
  // InputArray kernel,
  // Point anchor=Point(-1,-1),
  // double delta=0, int bits=0);

  // ! returns the separable linear filter engine
  // CV_EXPORTS Ptr<FilterEngine> createSeparableLinearFilter(int srcType, int dstType,
  // InputArray rowKernel, InputArray columnKernel,
  // Point anchor=Point(-1,-1), double delta=0,
  // int rowBorderType=BORDER_DEFAULT,
  // int columnBorderType=-1,
  // const Scalar& borderValue=Scalar());

function createSeparableLinearFilter(srcType: Integer; dstType: Integer; rowKernel: TCvMat; columnKernel: TCvMat;
  anchor: TcvPoint { =Point(-1,-1) }; delta: double { =0 }; rowBorderType: Integer { =BORDER_DEFAULT };
  columnBorderType: Integer { =-1 }; const borderValue: TcvScalar { =Scalar() } ): TFilterEngine;

/// /! returns the non-separable linear filter engine
// CV_EXPORTS Ptr<FilterEngine> createLinearFilter(int srcType, int dstType,
// InputArray kernel, Point _anchor=Point(-1,-1),
// double delta=0, int rowBorderType=BORDER_DEFAULT,
// int columnBorderType=-1, const Scalar& borderValue=Scalar());
//
/// /! returns the Gaussian kernel with the specified parameters
// CV_EXPORTS_W Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F );
function getGaussianKernel(n: Integer; sigma: double; ktype: Integer): TCvMat;

// ! returns the Gaussian filter engine
// CV_EXPORTS Ptr<FilterEngine> createGaussianFilter( int type, Size ksize,
// double sigma1, double sigma2=0,
// int borderType=BORDER_DEFAULT);
function createGaussianFilter(_type: Integer; ksize: TcvSize; sigma1: double; sigma2: double = 0;
  borderType: Integer = BORDER_DEFAULT): TFilterEngine;

/// /! initializes kernels of the generalized Sobel operator
// CV_EXPORTS_W void getDerivKernels( OutputArray kx, OutputArray ky,
// int dx, int dy, int ksize,
// bool normalize=false, int ktype=CV_32F );
/// /! returns filter engine for the generalized Sobel operator
// CV_EXPORTS Ptr<FilterEngine> createDerivFilter( int srcType, int dstType,
// int dx, int dy, int ksize,
// int borderType=BORDER_DEFAULT );
/// /! returns horizontal 1D box filter
// CV_EXPORTS Ptr<BaseRowFilter> getRowSumFilter(int srcType, int sumType,
// int ksize, int anchor=-1);
/// /! returns vertical 1D box filter
// CV_EXPORTS Ptr<BaseColumnFilter> getColumnSumFilter( int sumType, int dstType,
// int ksize, int anchor=-1,
// double scale=1);
/// /! returns box filter engine
// CV_EXPORTS Ptr<FilterEngine> createBoxFilter( int srcType, int dstType, Size ksize,
// Point anchor=Point(-1,-1),
// bool normalize=true,
// int borderType=BORDER_DEFAULT);
//
/// /! returns the Gabor kernel with the specified parameters
// CV_EXPORTS_W Mat getGaborKernel( Size ksize, double sigma, double theta, double lambd,
// double gamma, double psi=CV_PI*0.5, int ktype=CV_64F );
//
/// /! type of morphological operation
// enum { MORPH_ERODE=CV_MOP_ERODE, MORPH_DILATE=CV_MOP_DILATE,
// MORPH_OPEN=CV_MOP_OPEN, MORPH_CLOSE=CV_MOP_CLOSE,
// MORPH_GRADIENT=CV_MOP_GRADIENT, MORPH_TOPHAT=CV_MOP_TOPHAT,
// MORPH_BLACKHAT=CV_MOP_BLACKHAT };
//
/// /! returns horizontal 1D morphological filter
// CV_EXPORTS Ptr<BaseRowFilter> getMorphologyRowFilter(int op, int type, int ksize, int anchor=-1);
/// /! returns vertical 1D morphological filter
// CV_EXPORTS Ptr<BaseColumnFilter> getMorphologyColumnFilter(int op, int type, int ksize, int anchor=-1);
/// /! returns 2D morphological filter
// CV_EXPORTS Ptr<BaseFilter> getMorphologyFilter(int op, int type, InputArray kernel,
// Point anchor=Point(-1,-1));
//
/// /! returns "magic" border value for erosion and dilation. It is automatically transformed to Scalar::all(-DBL_MAX) for dilation.
// static inline Scalar morphologyDefaultBorderValue() { return Scalar::all(DBL_MAX); }
//
/// /! returns morphological filter engine. Only MORPH_ERODE and MORPH_DILATE are supported.
// CV_EXPORTS Ptr<FilterEngine> createMorphologyFilter(int op, int type, InputArray kernel,
// Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT,
// int columnBorderType=-1,
// const Scalar& borderValue=morphologyDefaultBorderValue());
//
/// /! shape of the structuring element
// enum { MORPH_RECT=0, MORPH_CROSS=1, MORPH_ELLIPSE=2 };
/// /! returns structuring element of the specified shape and size
// CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor=Point(-1,-1));
//
// template<> CV_EXPORTS void Ptr<IplConvKernel>::delete_obj();
//
/// /! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode
// CV_EXPORTS_W void copyMakeBorder( InputArray src, OutputArray dst,
// int top, int bottom, int left, int right,
// int borderType, const Scalar& value=Scalar() );
//
/// /! smooths the image using median filter.
// CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize );

// ! smooths the image using Gaussian filter.
// CV_EXPORTS_W void GaussianBlur( InputArray src,
// OutputArray dst, Size ksize,
// double sigmaX, double sigmaY=0,
// int borderType=BORDER_DEFAULT );
procedure GaussianBlur(src: pIplImage; dst: pIplImage; ksize: TcvSize; sigmaX: double; sigmaY: double = 0;
  borderType: Integer = BORDER_DEFAULT);

/// /! smooths the image using bilateral filter
// CV_EXPORTS_W void bilateralFilter( InputArray src, OutputArray dst, int d,
// double sigmaColor, double sigmaSpace,
// int borderType=BORDER_DEFAULT );
/// /! smooths the image using the box filter. Each pixel is processed in O(1) time
// CV_EXPORTS_W void boxFilter( InputArray src, OutputArray dst, int ddepth,
// Size ksize, Point anchor=Point(-1,-1),
// bool normalize=true,
// int borderType=BORDER_DEFAULT );
/// /! a synonym for normalized box filter
// CV_EXPORTS_W void blur( InputArray src, OutputArray dst,
// Size ksize, Point anchor=Point(-1,-1),
// int borderType=BORDER_DEFAULT );
//
/// /! applies non-separable 2D linear filter to the image
// CV_EXPORTS_W void filter2D( InputArray src, OutputArray dst, int ddepth,
// InputArray kernel, Point anchor=Point(-1,-1),
// double delta=0, int borderType=BORDER_DEFAULT );
//
/// /! applies separable 2D linear filter to the image
// CV_EXPORTS_W void sepFilter2D( InputArray src, OutputArray dst, int ddepth,
// InputArray kernelX, InputArray kernelY,
// Point anchor=Point(-1,-1),
// double delta=0, int borderType=BORDER_DEFAULT );
//
/// /! applies generalized Sobel operator to the image
// CV_EXPORTS_W void Sobel( InputArray src, OutputArray dst, int ddepth,
// int dx, int dy, int ksize=3,
// double scale=1, double delta=0,
// int borderType=BORDER_DEFAULT );
//
/// /! applies the vertical or horizontal Scharr operator to the image
// CV_EXPORTS_W void Scharr( InputArray src, OutputArray dst, int ddepth,
// int dx, int dy, double scale=1, double delta=0,
// int borderType=BORDER_DEFAULT );
//
/// /! applies Laplacian operator to the image
// CV_EXPORTS_W void Laplacian( InputArray src, OutputArray dst, int ddepth,
// int ksize=1, double scale=1, double delta=0,
// int borderType=BORDER_DEFAULT );
//
/// /! applies Canny edge detector and produces the edge map.
// CV_EXPORTS_W void Canny( InputArray image, OutputArray edges,
// double threshold1, double threshold2,
// int apertureSize=3, bool L2gradient=false );
//
/// /! computes minimum eigen value of 2x2 derivative covariation matrix at each pixel - the cornerness criteria
// CV_EXPORTS_W void cornerMinEigenVal( InputArray src, OutputArray dst,
// int blockSize, int ksize=3,
// int borderType=BORDER_DEFAULT );
//
/// /! computes Harris cornerness criteria at each image pixel
// CV_EXPORTS_W void cornerHarris( InputArray src, OutputArray dst, int blockSize,
// int ksize, double k,
// int borderType=BORDER_DEFAULT );
//
/// / low-level function for computing eigenvalues and eigenvectors of 2x2 matrices
// CV_EXPORTS void eigen2x2( const float* a, float* e, int n );
//
/// /! computes both eigenvalues and the eigenvectors of 2x2 derivative covariation matrix  at each pixel. The output is stored as 6-channel matrix.
// CV_EXPORTS_W void cornerEigenValsAndVecs( InputArray src, OutputArray dst,
// int blockSize, int ksize,
// int borderType=BORDER_DEFAULT );
//
/// /! computes another complex cornerness criteria at each pixel
// CV_EXPORTS_W void preCornerDetect( InputArray src, OutputArray dst, int ksize,
// int borderType=BORDER_DEFAULT );
//
/// /! adjusts the corner locations with sub-pixel accuracy to maximize the certain cornerness criteria
// CV_EXPORTS_W void cornerSubPix( InputArray image, InputOutputArray corners,
// Size winSize, Size zeroZone,
// TermCriteria criteria );
//
/// /! finds the strong enough corners where the cornerMinEigenVal() or cornerHarris() report the local maxima
// CV_EXPORTS_W void goodFeaturesToTrack( InputArray image, OutputArray corners,
// int maxCorners, double qualityLevel, double minDistance,
// InputArray mask=noArray(), int blockSize=3,
// bool useHarrisDetector=false, double k=0.04 );
//
/// /! finds lines in the black-n-white image using the standard or pyramid Hough transform
// CV_EXPORTS_W void HoughLines( InputArray image, OutputArray lines,
// double rho, double theta, int threshold,
// double srn=0, double stn=0 );
//
/// /! finds line segments in the black-n-white image using probabalistic Hough transform
// CV_EXPORTS_W void HoughLinesP( InputArray image, OutputArray lines,
// double rho, double theta, int threshold,
// double minLineLength=0, double maxLineGap=0 );
//
/// /! finds circles in the grayscale image using 2+1 gradient Hough transform
// CV_EXPORTS_W void HoughCircles( InputArray image, OutputArray circles,
// int method, double dp, double minDist,
// double param1=100, double param2=100,
// int minRadius=0, int maxRadius=0 );
//
// enum
// {
// GHT_POSITION = 0,
// GHT_SCALE = 1,
// GHT_ROTATION = 2
// };
//
/// /! finds arbitrary template in the grayscale image using Generalized Hough Transform
/// /! Ballard, D.H. (1981). Generalizing the Hough transform to detect arbitrary shapes. Pattern Recognition 13 (2): 111-122.
/// /! Guil, N., González-Linares, J.M. and Zapata, E.L. (1999). Bidimensional shape detection using an invariant approach. Pattern Recognition 32 (6): 1025-1038.
// class CV_EXPORTS GeneralizedHough : public Algorithm
// {
// public:
// static Ptr<GeneralizedHough> create(int method);
//
// virtual ~GeneralizedHough();
//
// //! set template to search
// void setTemplate(InputArray templ, int cannyThreshold = 100, Point templCenter = Point(-1, -1));
// void setTemplate(InputArray edges, InputArray dx, InputArray dy, Point templCenter = Point(-1, -1));
//
// //! find template on image
// void detect(InputArray image, OutputArray positions, OutputArray votes = cv::noArray(), int cannyThreshold = 100);
// void detect(InputArray edges, InputArray dx, InputArray dy, OutputArray positions, OutputArray votes = cv::noArray());
//
// void release();
//
// protected:
// virtual void setTemplateImpl(const Mat& edges, const Mat& dx, const Mat& dy, Point templCenter) = 0;
// virtual void detectImpl(const Mat& edges, const Mat& dx, const Mat& dy, OutputArray positions, OutputArray votes) = 0;
// virtual void releaseImpl() = 0;
//
// private:
// Mat edges_, dx_, dy_;
// };
//
/// /! erodes the image (applies the local minimum operator)
// CV_EXPORTS_W void erode( InputArray src, OutputArray dst, InputArray kernel,
// Point anchor=Point(-1,-1), int iterations=1,
// int borderType=BORDER_CONSTANT,
// const Scalar& borderValue=morphologyDefaultBorderValue() );
//
/// /! dilates the image (applies the local maximum operator)
// CV_EXPORTS_W void dilate( InputArray src, OutputArray dst, InputArray kernel,
// Point anchor=Point(-1,-1), int iterations=1,
// int borderType=BORDER_CONSTANT,
// const Scalar& borderValue=morphologyDefaultBorderValue() );
//
/// /! applies an advanced morphological operation to the image
// CV_EXPORTS_W void morphologyEx( InputArray src, OutputArray dst,
// int op, InputArray kernel,
// Point anchor=Point(-1,-1), int iterations=1,
// int borderType=BORDER_CONSTANT,
// const Scalar& borderValue=morphologyDefaultBorderValue() );
//
/// /! interpolation algorithm
// enum
// {
// INTER_NEAREST=CV_INTER_NN, //!< nearest neighbor interpolation
// INTER_LINEAR=CV_INTER_LINEAR, //!< bilinear interpolation
// INTER_CUBIC=CV_INTER_CUBIC, //!< bicubic interpolation
// INTER_AREA=CV_INTER_AREA, //!< area-based (or super) interpolation
// INTER_LANCZOS4=CV_INTER_LANCZOS4, //!< Lanczos interpolation over 8x8 neighborhood
// INTER_MAX=7,
// WARP_INVERSE_MAP=CV_WARP_INVERSE_MAP
// };
//
/// /! resizes the image
// CV_EXPORTS_W void resize( InputArray src, OutputArray dst,
// Size dsize, double fx=0, double fy=0,
// int interpolation=INTER_LINEAR );
//
/// /! warps the image using affine transformation
// CV_EXPORTS_W void warpAffine( InputArray src, OutputArray dst,
// InputArray M, Size dsize,
// int flags=INTER_LINEAR,
// int borderMode=BORDER_CONSTANT,
// const Scalar& borderValue=Scalar());
//
/// /! warps the image using perspective transformation
// CV_EXPORTS_W void warpPerspective( InputArray src, OutputArray dst,
// InputArray M, Size dsize,
// int flags=INTER_LINEAR,
// int borderMode=BORDER_CONSTANT,
// const Scalar& borderValue=Scalar());
//
// enum
// {
// INTER_BITS=5, INTER_BITS2=INTER_BITS*2,
// INTER_TAB_SIZE=(1<<INTER_BITS),
// INTER_TAB_SIZE2=INTER_TAB_SIZE*INTER_TAB_SIZE
// };
//
/// /! warps the image using the precomputed maps. The maps are stored in either floating-point or integer fixed-point format
// CV_EXPORTS_W void remap( InputArray src, OutputArray dst,
// InputArray map1, InputArray map2,
// int interpolation, int borderMode=BORDER_CONSTANT,
// const Scalar& borderValue=Scalar());
//
/// /! converts maps for remap from floating-point to fixed-point format or backwards
// CV_EXPORTS_W void convertMaps( InputArray map1, InputArray map2,
// OutputArray dstmap1, OutputArray dstmap2,
// int dstmap1type, bool nninterpolation=false );
//
/// /! returns 2x3 affine transformation matrix for the planar rotation.
// CV_EXPORTS_W Mat getRotationMatrix2D( Point2f center, double angle, double scale );
/// /! returns 3x3 perspective transformation for the corresponding 4 point pairs.
// CV_EXPORTS Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] );
/// /! returns 2x3 affine transformation for the corresponding 3 point pairs.
// CV_EXPORTS Mat getAffineTransform( const Point2f src[], const Point2f dst[] );
/// /! computes 2x3 affine transformation matrix that is inverse to the specified 2x3 affine transformation.
// CV_EXPORTS_W void invertAffineTransform( InputArray M, OutputArray iM );
//
// CV_EXPORTS_W Mat getPerspectiveTransform( InputArray src, InputArray dst );
// CV_EXPORTS_W Mat getAffineTransform( InputArray src, InputArray dst );
//
/// /! extracts rectangle from the image at sub-pixel location
// CV_EXPORTS_W void getRectSubPix( InputArray image, Size patchSize,
// Point2f center, OutputArray patch, int patchType=-1 );
//
/// /! computes the integral image
// CV_EXPORTS_W void integral( InputArray src, OutputArray sum, int sdepth=-1 );
//
/// /! computes the integral image and integral for the squared image
// CV_EXPORTS_AS(integral2) void integral( InputArray src, OutputArray sum,
// OutputArray sqsum, int sdepth=-1 );
/// /! computes the integral image, integral for the squared image and the tilted integral image
// CV_EXPORTS_AS(integral3) void integral( InputArray src, OutputArray sum,
// OutputArray sqsum, OutputArray tilted,
// int sdepth=-1 );
//
/// /! adds image to the accumulator (dst += src). Unlike cv::add, dst and src can have different types.
// CV_EXPORTS_W void accumulate( InputArray src, InputOutputArray dst,
// InputArray mask=noArray() );
/// /! adds squared src image to the accumulator (dst += src*src).
// CV_EXPORTS_W void accumulateSquare( InputArray src, InputOutputArray dst,
// InputArray mask=noArray() );
/// /! adds product of the 2 images to the accumulator (dst += src1*src2).
// CV_EXPORTS_W void accumulateProduct( InputArray src1, InputArray src2,
// InputOutputArray dst, InputArray mask=noArray() );
/// /! updates the running average (dst = dst*(1-alpha) + src*alpha)
// CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
// double alpha, InputArray mask=noArray() );
//
/// /! computes PSNR image/video quality metric
// CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2);
//
// CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2,
// InputArray window = noArray(), CV_OUT double* response=0);
// CV_EXPORTS_W void createHanningWindow(OutputArray dst, Size winSize, int type);
//
/// /! type of the threshold operation
const
THRESH_BINARY=CV_THRESH_BINARY;
THRESH_BINARY_INV=CV_THRESH_BINARY_INV;
 THRESH_TRUNC=CV_THRESH_TRUNC; THRESH_TOZERO=CV_THRESH_TOZERO;
 THRESH_TOZERO_INV=CV_THRESH_TOZERO_INV; THRESH_MASK=CV_THRESH_MASK;
 THRESH_OTSU=CV_THRESH_OTSU;
//
/// /! applies fixed threshold to the image
// CV_EXPORTS_W double threshold( InputArray src, OutputArray dst,
// double thresh, double maxval, int type );
//
/// /! adaptive threshold algorithm
// enum { ADAPTIVE_THRESH_MEAN_C=0, ADAPTIVE_THRESH_GAUSSIAN_C=1 };
//
/// /! applies variable (adaptive) threshold to the image
// CV_EXPORTS_W void adaptiveThreshold( InputArray src, OutputArray dst,
// double maxValue, int adaptiveMethod,
// int thresholdType, int blockSize, double C );
//
/// /! smooths and downsamples the image
// CV_EXPORTS_W void pyrDown( InputArray src, OutputArray dst,
// const Size& dstsize=Size(), int borderType=BORDER_DEFAULT );
/// /! upsamples and smoothes the image
// CV_EXPORTS_W void pyrUp( InputArray src, OutputArray dst,
// const Size& dstsize=Size(), int borderType=BORDER_DEFAULT );
//
/// /! builds the gaussian pyramid using pyrDown() as a basic operation
// CV_EXPORTS void buildPyramid( InputArray src, OutputArrayOfArrays dst,
// int maxlevel, int borderType=BORDER_DEFAULT );
//
/// /! corrects lens distortion for the given camera matrix and distortion coefficients
// CV_EXPORTS_W void undistort( InputArray src, OutputArray dst,
// InputArray cameraMatrix,
// InputArray distCoeffs,
// InputArray newCameraMatrix=noArray() );
//
/// /! initializes maps for cv::remap() to correct lens distortion and optionally rectify the image
// CV_EXPORTS_W void initUndistortRectifyMap( InputArray cameraMatrix, InputArray distCoeffs,
// InputArray R, InputArray newCameraMatrix,
// Size size, int m1type, OutputArray map1, OutputArray map2 );
//
// enum
// {
// PROJ_SPHERICAL_ORTHO = 0,
// PROJ_SPHERICAL_EQRECT = 1
// };
//
/// /! initializes maps for cv::remap() for wide-angle
// CV_EXPORTS_W float initWideAngleProjMap( InputArray cameraMatrix, InputArray distCoeffs,
// Size imageSize, int destImageWidth,
// int m1type, OutputArray map1, OutputArray map2,
// int projType=PROJ_SPHERICAL_EQRECT, double alpha=0);
//
/// /! returns the default new camera matrix (by default it is the same as cameraMatrix unless centerPricipalPoint=true)
// CV_EXPORTS_W Mat getDefaultNewCameraMatrix( InputArray cameraMatrix, Size imgsize=Size(),
// bool centerPrincipalPoint=false );
//
/// /! returns points' coordinates after lens distortion correction
// CV_EXPORTS_W void undistortPoints( InputArray src, OutputArray dst,
// InputArray cameraMatrix, InputArray distCoeffs,
// InputArray R=noArray(), InputArray P=noArray());
//
// template<> CV_EXPORTS void Ptr<CvHistogram>::delete_obj();
//
/// /! computes the joint dense histogram for a set of images.
// CV_EXPORTS void calcHist( const Mat* images, int nimages,
// const int* channels, InputArray mask,
// OutputArray hist, int dims, const int* histSize,
// const float** ranges, bool uniform=true, bool accumulate=false );
//
/// /! computes the joint sparse histogram for a set of images.
// CV_EXPORTS void calcHist( const Mat* images, int nimages,
// const int* channels, InputArray mask,
// SparseMat& hist, int dims,
// const int* histSize, const float** ranges,
// bool uniform=true, bool accumulate=false );
//
// CV_EXPORTS_W void calcHist( InputArrayOfArrays images,
// const std::vector<int>& channels,
// InputArray mask, OutputArray hist,
// const std::vector<int>& histSize,
// const std::vector<float>& ranges,
// bool accumulate=false );
//
/// /! computes back projection for the set of images
// CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
// const int* channels, InputArray hist,
// OutputArray backProject, const float** ranges,
// double scale=1, bool uniform=true );
//
/// /! computes back projection for the set of images
// CV_EXPORTS void calcBackProject( const Mat* images, int nimages,
// const int* channels, const SparseMat& hist,
// OutputArray backProject, const float** ranges,
// double scale=1, bool uniform=true );
//
// CV_EXPORTS_W void calcBackProject( InputArrayOfArrays images, const std::vector<int>& channels,
// InputArray hist, OutputArray dst,
// const std::vector<float>& ranges,
// double scale );
//
/// *CV_EXPORTS void calcBackProjectPatch( const Mat* images, int nimages, const int* channels,
// InputArray hist, OutputArray dst, Size patchSize,
// int method, double factor=1 );
//
// CV_EXPORTS_W void calcBackProjectPatch( InputArrayOfArrays images, const std::vector<int>& channels,
// InputArray hist, OutputArray dst, Size patchSize,
// int method, double factor=1 );*/
//
/// /! compares two histograms stored in dense arrays
// CV_EXPORTS_W double compareHist( InputArray H1, InputArray H2, int method );
//
/// /! compares two histograms stored in sparse arrays
// CV_EXPORTS double compareHist( const SparseMat& H1, const SparseMat& H2, int method );
//
/// /! normalizes the grayscale image brightness and contrast by normalizing its histogram
// CV_EXPORTS_W void equalizeHist( InputArray src, OutputArray dst );
//
// class CV_EXPORTS CLAHE : public Algorithm
// {
// public:
// virtual void apply(InputArray src, OutputArray dst) = 0;
//
// virtual void setClipLimit(double clipLimit) = 0;
// virtual double getClipLimit() const = 0;
//
// virtual void setTilesGridSize(Size tileGridSize) = 0;
// virtual Size getTilesGridSize() const = 0;
//
// virtual void collectGarbage() = 0;
// };
// CV_EXPORTS Ptr<CLAHE> createCLAHE(double clipLimit = 40.0, Size tileGridSize = Size(8, 8));
//
// CV_EXPORTS float EMD( InputArray signature1, InputArray signature2,
// int distType, InputArray cost=noArray(),
// float* lowerBound=0, OutputArray flow=noArray() );
//
/// /! segments the image using watershed algorithm
// CV_EXPORTS_W void watershed( InputArray image, InputOutputArray markers );
//
/// /! filters image using meanshift algorithm
// CV_EXPORTS_W void pyrMeanShiftFiltering( InputArray src, OutputArray dst,
// double sp, double sr, int maxLevel=1,
// TermCriteria termcrit=TermCriteria(
// TermCriteria::MAX_ITER+TermCriteria::EPS,5,1) );
//
/// /! class of the pixel in GrabCut algorithm
// enum
// {
// GC_BGD    = 0,  //!< background
// GC_FGD    = 1,  //!< foreground
// GC_PR_BGD = 2,  //!< most probably background
// GC_PR_FGD = 3   //!< most probably foreground
// };
//
/// /! GrabCut algorithm flags
// enum
// {
// GC_INIT_WITH_RECT  = 0,
// GC_INIT_WITH_MASK  = 1,
// GC_EVAL            = 2
// };
//
/// /! segments the image using GrabCut algorithm
// CV_EXPORTS_W void grabCut( InputArray img, InputOutputArray mask, Rect rect,
// InputOutputArray bgdModel, InputOutputArray fgdModel,
// int iterCount, int mode = GC_EVAL );
//
// enum
// {
// DIST_LABEL_CCOMP = 0,
// DIST_LABEL_PIXEL = 1
// };
//
/// /! builds the discrete Voronoi diagram
// CV_EXPORTS_AS(distanceTransformWithLabels) void distanceTransform( InputArray src, OutputArray dst,
// OutputArray labels, int distanceType, int maskSize,
// int labelType=DIST_LABEL_CCOMP );
//
/// /! computes the distance transform map
// CV_EXPORTS_W void distanceTransform( InputArray src, OutputArray dst,
// int distanceType, int maskSize );
//
// enum { FLOODFILL_FIXED_RANGE = 1 << 16, FLOODFILL_MASK_ONLY = 1 << 17 };
//
/// /! fills the semi-uniform image region starting from the specified seed point
// CV_EXPORTS int floodFill( InputOutputArray image,
// Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0,
// Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
// int flags=4 );
//
/// /! fills the semi-uniform image region and/or the mask starting from the specified seed point
// CV_EXPORTS_W int floodFill( InputOutputArray image, InputOutputArray mask,
// Point seedPoint, Scalar newVal, CV_OUT Rect* rect=0,
// Scalar loDiff=Scalar(), Scalar upDiff=Scalar(),
// int flags=4 );
//
//
// enum
// {
// COLOR_BGR2BGRA    =0,
// COLOR_RGB2RGBA    =COLOR_BGR2BGRA,
//
// COLOR_BGRA2BGR    =1,
// COLOR_RGBA2RGB    =COLOR_BGRA2BGR,
//
// COLOR_BGR2RGBA    =2,
// COLOR_RGB2BGRA    =COLOR_BGR2RGBA,
//
// COLOR_RGBA2BGR    =3,
// COLOR_BGRA2RGB    =COLOR_RGBA2BGR,
//
// COLOR_BGR2RGB     =4,
// COLOR_RGB2BGR     =COLOR_BGR2RGB,
//
// COLOR_BGRA2RGBA   =5,
// COLOR_RGBA2BGRA   =COLOR_BGRA2RGBA,
//
// COLOR_BGR2GRAY    =6,
// COLOR_RGB2GRAY    =7,
// COLOR_GRAY2BGR    =8,
// COLOR_GRAY2RGB    =COLOR_GRAY2BGR,
// COLOR_GRAY2BGRA   =9,
// COLOR_GRAY2RGBA   =COLOR_GRAY2BGRA,
// COLOR_BGRA2GRAY   =10,
// COLOR_RGBA2GRAY   =11,
//
// COLOR_BGR2BGR565  =12,
// COLOR_RGB2BGR565  =13,
// COLOR_BGR5652BGR  =14,
// COLOR_BGR5652RGB  =15,
// COLOR_BGRA2BGR565 =16,
// COLOR_RGBA2BGR565 =17,
// COLOR_BGR5652BGRA =18,
// COLOR_BGR5652RGBA =19,
//
// COLOR_GRAY2BGR565 =20,
// COLOR_BGR5652GRAY =21,
//
// COLOR_BGR2BGR555  =22,
// COLOR_RGB2BGR555  =23,
// COLOR_BGR5552BGR  =24,
// COLOR_BGR5552RGB  =25,
// COLOR_BGRA2BGR555 =26,
// COLOR_RGBA2BGR555 =27,
// COLOR_BGR5552BGRA =28,
// COLOR_BGR5552RGBA =29,
//
// COLOR_GRAY2BGR555 =30,
// COLOR_BGR5552GRAY =31,
//
// COLOR_BGR2XYZ     =32,
// COLOR_RGB2XYZ     =33,
// COLOR_XYZ2BGR     =34,
// COLOR_XYZ2RGB     =35,
//
// COLOR_BGR2YCrCb   =36,
// COLOR_RGB2YCrCb   =37,
// COLOR_YCrCb2BGR   =38,
// COLOR_YCrCb2RGB   =39,
//
// COLOR_BGR2HSV     =40,
// COLOR_RGB2HSV     =41,
//
// COLOR_BGR2Lab     =44,
// COLOR_RGB2Lab     =45,
//
// COLOR_BayerBG2BGR =46,
// COLOR_BayerGB2BGR =47,
// COLOR_BayerRG2BGR =48,
// COLOR_BayerGR2BGR =49,
//
// COLOR_BayerBG2RGB =COLOR_BayerRG2BGR,
// COLOR_BayerGB2RGB =COLOR_BayerGR2BGR,
// COLOR_BayerRG2RGB =COLOR_BayerBG2BGR,
// COLOR_BayerGR2RGB =COLOR_BayerGB2BGR,
//
// COLOR_BGR2Luv     =50,
// COLOR_RGB2Luv     =51,
// COLOR_BGR2HLS     =52,
// COLOR_RGB2HLS     =53,
//
// COLOR_HSV2BGR     =54,
// COLOR_HSV2RGB     =55,
//
// COLOR_Lab2BGR     =56,
// COLOR_Lab2RGB     =57,
// COLOR_Luv2BGR     =58,
// COLOR_Luv2RGB     =59,
// COLOR_HLS2BGR     =60,
// COLOR_HLS2RGB     =61,
//
// COLOR_BayerBG2BGR_VNG =62,
// COLOR_BayerGB2BGR_VNG =63,
// COLOR_BayerRG2BGR_VNG =64,
// COLOR_BayerGR2BGR_VNG =65,
//
// COLOR_BayerBG2RGB_VNG =COLOR_BayerRG2BGR_VNG,
// COLOR_BayerGB2RGB_VNG =COLOR_BayerGR2BGR_VNG,
// COLOR_BayerRG2RGB_VNG =COLOR_BayerBG2BGR_VNG,
// COLOR_BayerGR2RGB_VNG =COLOR_BayerGB2BGR_VNG,
//
// COLOR_BGR2HSV_FULL = 66,
// COLOR_RGB2HSV_FULL = 67,
// COLOR_BGR2HLS_FULL = 68,
// COLOR_RGB2HLS_FULL = 69,
//
// COLOR_HSV2BGR_FULL = 70,
// COLOR_HSV2RGB_FULL = 71,
// COLOR_HLS2BGR_FULL = 72,
// COLOR_HLS2RGB_FULL = 73,
//
// COLOR_LBGR2Lab     = 74,
// COLOR_LRGB2Lab     = 75,
// COLOR_LBGR2Luv     = 76,
// COLOR_LRGB2Luv     = 77,
//
// COLOR_Lab2LBGR     = 78,
// COLOR_Lab2LRGB     = 79,
// COLOR_Luv2LBGR     = 80,
// COLOR_Luv2LRGB     = 81,
//
// COLOR_BGR2YUV      = 82,
// COLOR_RGB2YUV      = 83,
// COLOR_YUV2BGR      = 84,
// COLOR_YUV2RGB      = 85,
//
// COLOR_BayerBG2GRAY = 86,
// COLOR_BayerGB2GRAY = 87,
// COLOR_BayerRG2GRAY = 88,
// COLOR_BayerGR2GRAY = 89,
//
// //YUV 4:2:0 formats family
// COLOR_YUV2RGB_NV12 = 90,
// COLOR_YUV2BGR_NV12 = 91,
// COLOR_YUV2RGB_NV21 = 92,
// COLOR_YUV2BGR_NV21 = 93,
// COLOR_YUV420sp2RGB = COLOR_YUV2RGB_NV21,
// COLOR_YUV420sp2BGR = COLOR_YUV2BGR_NV21,
//
// COLOR_YUV2RGBA_NV12 = 94,
// COLOR_YUV2BGRA_NV12 = 95,
// COLOR_YUV2RGBA_NV21 = 96,
// COLOR_YUV2BGRA_NV21 = 97,
// COLOR_YUV420sp2RGBA = COLOR_YUV2RGBA_NV21,
// COLOR_YUV420sp2BGRA = COLOR_YUV2BGRA_NV21,
//
// COLOR_YUV2RGB_YV12 = 98,
// COLOR_YUV2BGR_YV12 = 99,
// COLOR_YUV2RGB_IYUV = 100,
// COLOR_YUV2BGR_IYUV = 101,
// COLOR_YUV2RGB_I420 = COLOR_YUV2RGB_IYUV,
// COLOR_YUV2BGR_I420 = COLOR_YUV2BGR_IYUV,
// COLOR_YUV420p2RGB = COLOR_YUV2RGB_YV12,
// COLOR_YUV420p2BGR = COLOR_YUV2BGR_YV12,
//
// COLOR_YUV2RGBA_YV12 = 102,
// COLOR_YUV2BGRA_YV12 = 103,
// COLOR_YUV2RGBA_IYUV = 104,
// COLOR_YUV2BGRA_IYUV = 105,
// COLOR_YUV2RGBA_I420 = COLOR_YUV2RGBA_IYUV,
// COLOR_YUV2BGRA_I420 = COLOR_YUV2BGRA_IYUV,
// COLOR_YUV420p2RGBA = COLOR_YUV2RGBA_YV12,
// COLOR_YUV420p2BGRA = COLOR_YUV2BGRA_YV12,
//
// COLOR_YUV2GRAY_420 = 106,
// COLOR_YUV2GRAY_NV21 = COLOR_YUV2GRAY_420,
// COLOR_YUV2GRAY_NV12 = COLOR_YUV2GRAY_420,
// COLOR_YUV2GRAY_YV12 = COLOR_YUV2GRAY_420,
// COLOR_YUV2GRAY_IYUV = COLOR_YUV2GRAY_420,
// COLOR_YUV2GRAY_I420 = COLOR_YUV2GRAY_420,
// COLOR_YUV420sp2GRAY = COLOR_YUV2GRAY_420,
// COLOR_YUV420p2GRAY = COLOR_YUV2GRAY_420,
//
// //YUV 4:2:2 formats family
// COLOR_YUV2RGB_UYVY = 107,
// COLOR_YUV2BGR_UYVY = 108,
// //COLOR_YUV2RGB_VYUY = 109,
// //COLOR_YUV2BGR_VYUY = 110,
// COLOR_YUV2RGB_Y422 = COLOR_YUV2RGB_UYVY,
// COLOR_YUV2BGR_Y422 = COLOR_YUV2BGR_UYVY,
// COLOR_YUV2RGB_UYNV = COLOR_YUV2RGB_UYVY,
// COLOR_YUV2BGR_UYNV = COLOR_YUV2BGR_UYVY,
//
// COLOR_YUV2RGBA_UYVY = 111,
// COLOR_YUV2BGRA_UYVY = 112,
// //COLOR_YUV2RGBA_VYUY = 113,
// //COLOR_YUV2BGRA_VYUY = 114,
// COLOR_YUV2RGBA_Y422 = COLOR_YUV2RGBA_UYVY,
// COLOR_YUV2BGRA_Y422 = COLOR_YUV2BGRA_UYVY,
// COLOR_YUV2RGBA_UYNV = COLOR_YUV2RGBA_UYVY,
// COLOR_YUV2BGRA_UYNV = COLOR_YUV2BGRA_UYVY,
//
// COLOR_YUV2RGB_YUY2 = 115,
// COLOR_YUV2BGR_YUY2 = 116,
// COLOR_YUV2RGB_YVYU = 117,
// COLOR_YUV2BGR_YVYU = 118,
// COLOR_YUV2RGB_YUYV = COLOR_YUV2RGB_YUY2,
// COLOR_YUV2BGR_YUYV = COLOR_YUV2BGR_YUY2,
// COLOR_YUV2RGB_YUNV = COLOR_YUV2RGB_YUY2,
// COLOR_YUV2BGR_YUNV = COLOR_YUV2BGR_YUY2,
//
// COLOR_YUV2RGBA_YUY2 = 119,
// COLOR_YUV2BGRA_YUY2 = 120,
// COLOR_YUV2RGBA_YVYU = 121,
// COLOR_YUV2BGRA_YVYU = 122,
// COLOR_YUV2RGBA_YUYV = COLOR_YUV2RGBA_YUY2,
// COLOR_YUV2BGRA_YUYV = COLOR_YUV2BGRA_YUY2,
// COLOR_YUV2RGBA_YUNV = COLOR_YUV2RGBA_YUY2,
// COLOR_YUV2BGRA_YUNV = COLOR_YUV2BGRA_YUY2,
//
// COLOR_YUV2GRAY_UYVY = 123,
// COLOR_YUV2GRAY_YUY2 = 124,
// //COLOR_YUV2GRAY_VYUY = COLOR_YUV2GRAY_UYVY,
// COLOR_YUV2GRAY_Y422 = COLOR_YUV2GRAY_UYVY,
// COLOR_YUV2GRAY_UYNV = COLOR_YUV2GRAY_UYVY,
// COLOR_YUV2GRAY_YVYU = COLOR_YUV2GRAY_YUY2,
// COLOR_YUV2GRAY_YUYV = COLOR_YUV2GRAY_YUY2,
// COLOR_YUV2GRAY_YUNV = COLOR_YUV2GRAY_YUY2,
//
// // alpha premultiplication
// COLOR_RGBA2mRGBA = 125,
// COLOR_mRGBA2RGBA = 126,
//
// COLOR_RGB2YUV_I420 = 127,
// COLOR_BGR2YUV_I420 = 128,
// COLOR_RGB2YUV_IYUV = COLOR_RGB2YUV_I420,
// COLOR_BGR2YUV_IYUV = COLOR_BGR2YUV_I420,
//
// COLOR_RGBA2YUV_I420 = 129,
// COLOR_BGRA2YUV_I420 = 130,
// COLOR_RGBA2YUV_IYUV = COLOR_RGBA2YUV_I420,
// COLOR_BGRA2YUV_IYUV = COLOR_BGRA2YUV_I420,
// COLOR_RGB2YUV_YV12  = 131,
// COLOR_BGR2YUV_YV12  = 132,
// COLOR_RGBA2YUV_YV12 = 133,
// COLOR_BGRA2YUV_YV12 = 134,
//
// // Edge-Aware Demosaicing
// COLOR_BayerBG2BGR_EA = 135,
// COLOR_BayerGB2BGR_EA = 136,
// COLOR_BayerRG2BGR_EA = 137,
// COLOR_BayerGR2BGR_EA = 138,
//
// COLOR_BayerBG2RGB_EA = COLOR_BayerRG2BGR_EA,
// COLOR_BayerGB2RGB_EA = COLOR_BayerGR2BGR_EA,
// COLOR_BayerRG2RGB_EA = COLOR_BayerBG2BGR_EA,
// COLOR_BayerGR2RGB_EA = COLOR_BayerGB2BGR_EA,
//
// COLOR_COLORCVT_MAX  = 139
// };
//
//
/// /! converts image from one color space to another
// CV_EXPORTS_W void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 );
//
/// /! raster image moments
// class CV_EXPORTS_W_MAP Moments
// {
// public:
// //! the default constructor
// Moments();
// //! the full constructor
// Moments(double m00, double m10, double m01, double m20, double m11,
// double m02, double m30, double m21, double m12, double m03 );
// //! the conversion from CvMoments
// Moments( const CvMoments& moments );
// //! the conversion to CvMoments
// operator CvMoments() const;
//
// //! spatial moments
// CV_PROP_RW double  m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
// //! central moments
// CV_PROP_RW double  mu20, mu11, mu02, mu30, mu21, mu12, mu03;
// //! central normalized moments
// CV_PROP_RW double  nu20, nu11, nu02, nu30, nu21, nu12, nu03;
// };
//
/// /! computes moments of the rasterized shape or a vector of points
// CV_EXPORTS_W Moments moments( InputArray array, bool binaryImage=false );
//
/// /! computes 7 Hu invariants from the moments
// CV_EXPORTS void HuMoments( const Moments& moments, double hu[7] );
// CV_EXPORTS_W void HuMoments( const Moments& m, OutputArray hu );
//
/// /! type of the template matching operation
// enum { TM_SQDIFF=0, TM_SQDIFF_NORMED=1, TM_CCORR=2, TM_CCORR_NORMED=3, TM_CCOEFF=4, TM_CCOEFF_NORMED=5 };
//
/// /! computes the proximity map for the raster template and the image where the template is searched for
// CV_EXPORTS_W void matchTemplate( InputArray image, InputArray templ,
// OutputArray result, int method );
//
// enum { CC_STAT_LEFT=0, CC_STAT_TOP=1, CC_STAT_WIDTH=2, CC_STAT_HEIGHT=3, CC_STAT_AREA=4, CC_STAT_MAX = 5};
//
/// / computes the connected components labeled image of boolean image ``image``
/// / with 4 or 8 way connectivity - returns N, the total
/// / number of labels [0, N-1] where 0 represents the background label.
/// / ltype specifies the output label image type, an important
/// / consideration based on the total number of labels or
/// / alternatively the total number of pixels in the source image.
// CV_EXPORTS_W int connectedComponents(InputArray image, OutputArray labels,
// int connectivity = 8, int ltype=CV_32S);
// CV_EXPORTS_W int connectedComponentsWithStats(InputArray image, OutputArray labels,
// OutputArray stats, OutputArray centroids,
// int connectivity = 8, int ltype=CV_32S);
//
/// /! mode of the contour retrieval algorithm
// enum
// {
// RETR_EXTERNAL=CV_RETR_EXTERNAL, //!< retrieve only the most external (top-level) contours
// RETR_LIST=CV_RETR_LIST, //!< retrieve all the contours without any hierarchical information
// RETR_CCOMP=CV_RETR_CCOMP, //!< retrieve the connected components (that can possibly be nested)
// RETR_TREE=CV_RETR_TREE, //!< retrieve all the contours and the whole hierarchy
// RETR_FLOODFILL=CV_RETR_FLOODFILL
// };
//
/// /! the contour approximation algorithm
// enum
// {
// CHAIN_APPROX_NONE=CV_CHAIN_APPROX_NONE,
// CHAIN_APPROX_SIMPLE=CV_CHAIN_APPROX_SIMPLE,
// CHAIN_APPROX_TC89_L1=CV_CHAIN_APPROX_TC89_L1,
// CHAIN_APPROX_TC89_KCOS=CV_CHAIN_APPROX_TC89_KCOS
// };
//
/// /! retrieves contours and the hierarchical information from black-n-white image.
// CV_EXPORTS_W void findContours( InputOutputArray image, OutputArrayOfArrays contours,
// OutputArray hierarchy, int mode,
// int method, Point offset=Point());
//
/// /! retrieves contours from black-n-white image.
// CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours,
// int mode, int method, Point offset=Point());
//
/// /! approximates contour or a curve using Douglas-Peucker algorithm
// CV_EXPORTS_W void approxPolyDP( InputArray curve,
// OutputArray approxCurve,
// double epsilon, bool closed );
//
/// /! computes the contour perimeter (closed=true) or a curve length
// CV_EXPORTS_W double arcLength( InputArray curve, bool closed );
/// /! computes the bounding rectangle for a contour
// CV_EXPORTS_W Rect boundingRect( InputArray points );
/// /! computes the contour area
// CV_EXPORTS_W double contourArea( InputArray contour, bool oriented=false );
/// /! computes the minimal rotated rectangle for a set of points
// CV_EXPORTS_W RotatedRect minAreaRect( InputArray points );
/// /! computes the minimal enclosing circle for a set of points
// CV_EXPORTS_W void minEnclosingCircle( InputArray points,
// CV_OUT Point2f& center, CV_OUT float& radius );
/// /! matches two contours using one of the available algorithms
// CV_EXPORTS_W double matchShapes( InputArray contour1, InputArray contour2,
// int method, double parameter );
/// /! computes convex hull for a set of 2D points.
// CV_EXPORTS_W void convexHull( InputArray points, OutputArray hull,
// bool clockwise=false, bool returnPoints=true );
/// /! computes the contour convexity defects
// CV_EXPORTS_W void convexityDefects( InputArray contour, InputArray convexhull, OutputArray convexityDefects );
//
/// /! returns true if the contour is convex. Does not support contours with self-intersection
// CV_EXPORTS_W bool isContourConvex( InputArray contour );
//
/// /! finds intersection of two convex polygons
// CV_EXPORTS_W float intersectConvexConvex( InputArray _p1, InputArray _p2,
// OutputArray _p12, bool handleNested=true );
//
/// /! fits ellipse to the set of 2D points
// CV_EXPORTS_W RotatedRect fitEllipse( InputArray points );
//
/// /! fits line to the set of 2D points using M-estimator algorithm
// CV_EXPORTS_W void fitLine( InputArray points, OutputArray line, int distType,
// double param, double reps, double aeps );
/// /! checks if the point is inside the contour. Optionally computes the signed distance from the point to the contour boundary
// CV_EXPORTS_W double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist );
//
//
// class CV_EXPORTS_W Subdiv2D
// {
// public:
// enum
// {
// PTLOC_ERROR = -2,
// PTLOC_OUTSIDE_RECT = -1,
// PTLOC_INSIDE = 0,
// PTLOC_VERTEX = 1,
// PTLOC_ON_EDGE = 2
// };
//
// enum
// {
// NEXT_AROUND_ORG   = 0x00,
// NEXT_AROUND_DST   = 0x22,
// PREV_AROUND_ORG   = 0x11,
// PREV_AROUND_DST   = 0x33,
// NEXT_AROUND_LEFT  = 0x13,
// NEXT_AROUND_RIGHT = 0x31,
// PREV_AROUND_LEFT  = 0x20,
// PREV_AROUND_RIGHT = 0x02
// };
//
// CV_WRAP Subdiv2D();
// CV_WRAP Subdiv2D(Rect rect);
// CV_WRAP void initDelaunay(Rect rect);
//
// CV_WRAP int insert(Point2f pt);
// CV_WRAP void insert(const std::vector<Point2f>& ptvec);
// CV_WRAP int locate(Point2f pt, CV_OUT int& edge, CV_OUT int& vertex);
//
// CV_WRAP int findNearest(Point2f pt, CV_OUT Point2f* nearestPt=0);
// CV_WRAP void getEdgeList(CV_OUT std::vector<Vec4f>& edgeList) const;
// CV_WRAP void getTriangleList(CV_OUT std::vector<Vec6f>& triangleList) const;
// CV_WRAP void getVoronoiFacetList(const std::vector<int>& idx, CV_OUT std::vector<std::vector<Point2f> >& facetList,
// CV_OUT std::vector<Point2f>& facetCenters);
//
// CV_WRAP Point2f getVertex(int vertex, CV_OUT int* firstEdge=0) const;
//
// CV_WRAP int getEdge( int edge, int nextEdgeType ) const;
// CV_WRAP int nextEdge(int edge) const;
// CV_WRAP int rotateEdge(int edge, int rotate) const;
// CV_WRAP int symEdge(int edge) const;
// CV_WRAP int edgeOrg(int edge, CV_OUT Point2f* orgpt=0) const;
// CV_WRAP int edgeDst(int edge, CV_OUT Point2f* dstpt=0) const;
//
// protected:
// int newEdge();
// void deleteEdge(int edge);
// int newPoint(Point2f pt, bool isvirtual, int firstEdge=0);
// void deletePoint(int vtx);
// void setEdgePoints( int edge, int orgPt, int dstPt );
// void splice( int edgeA, int edgeB );
// int connectEdges( int edgeA, int edgeB );
// void swapEdges( int edge );
// int isRightOf(Point2f pt, int edge) const;
// void calcVoronoi();
// void clearVoronoi();
// void checkSubdiv() const;
//
// struct CV_EXPORTS Vertex
// {
// Vertex();
// Vertex(Point2f pt, bool _isvirtual, int _firstEdge=0);
// bool isvirtual() const;
// bool isfree() const;
// int firstEdge;
// int type;
// Point2f pt;
// };
// struct CV_EXPORTS QuadEdge
// {
// QuadEdge();
// QuadEdge(int edgeidx);
// bool isfree() const;
// int next[4];
// int pt[4];
// };
//
// std::vector<Vertex> vtx;
// std::vector<QuadEdge> qedges;
// int freeQEdge;
// int freePoint;
// bool validGeometry;
//
// int recentEdge;
// Point2f topLeft;
// Point2f bottomRight;
// };
//
/// / main function for all demosaicing procceses
// CV_EXPORTS_W void demosaicing(InputArray _src, OutputArray _dst, int code, int dcn = 0);
//
// }
//
// #endif /* __cplusplus */
//
// #endif
//
/// * End of file. */

implementation

Uses Math;

// ****************************************************************************
// *               \modules\imgproc\src\filter.cpp                            *
// ****************************************************************************

{ TBaseFilter }

constructor TBaseFilter.Create;
begin

end;

destructor TBaseFilter.Destroy;
begin

  inherited;
end;

procedure TBaseFilter.reset;
begin

end;

{ TBaseRowFilter }

constructor TBaseRowFilter.Create;
begin

end;

destructor TBaseRowFilter.Destroy;
begin

  inherited;
end;

{ TFilterEngine }

constructor TFilterEngine.Create;
begin
  srcType := -1;
  dstType := -1;
  bufType := -1;
  rowBorderType := BORDER_REPLICATE;
  columnBorderType := BORDER_REPLICATE;
  bufStep := 0;
  startY := 0;
  startY0 := 0;
  endY := 0;
  rowCount := 0;
  dstY := 0;
  maxWidth := 0;

  wholeSize := cvSize(-1, -1);
end;

procedure TFilterEngine.apply(const src: pIplImage; dst: pIplImage; const srcRoi: TCvRect; dstOfs: TcvPoint;
  isolated: boolean);
begin

end;

constructor TFilterEngine.Create(const _filter2D: TBaseFilter; const _rowFilter: TBaseRowFilter;
  const _columnFilter: TBaseColumnFilter; srcType, dstType, bufType, _rowBorderType, _columnBorderType: Integer;
  const _borderValue: TcvScalar);
begin

end;

destructor TFilterEngine.Destroy;
begin

  inherited;
end;

procedure TFilterEngine.Init(const _filter2D: TBaseFilter; const _rowFilter: TBaseRowFilter;
  const _columnFilter: TBaseColumnFilter; srcType, dstType, bufType, _rowBorderType, _columnBorderType: Integer;
  const _borderValue: TcvScalar);
begin

end;

function TFilterEngine.proceed(const src: pByte; srcStep, srcCount: Integer; dst: pByte; dstStep: Integer): Integer;
begin

end;

function TFilterEngine.start(wholeSize: TcvSize; roi: TCvRect; maxBufRows: Integer): Integer;
begin

end;

function TFilterEngine.start(const src: pIplImage; const srcRoi: TCvRect; isolated: boolean;
  maxBufRows: Integer): Integer;
begin

end;

{ TBaseColumnFilter }

constructor TBaseColumnFilter.Create;
begin

end;

destructor TBaseColumnFilter.Destroy;
begin

  inherited;
end;

procedure TBaseColumnFilter.reset;
begin

end;

// ****************************************************************************
// *               \modules\imgproc\src\smooth.cpp                            *
// ****************************************************************************
procedure GaussianBlur(src: pIplImage; dst: pIplImage; ksize: TcvSize; sigmaX: double; sigmaY: double = 0;
  borderType: Integer = BORDER_DEFAULT);
var
  f: TFilterEngine;
begin
  if (borderType <> BORDER_CONSTANT) then
  begin
    if (src^.height = 1) then
      ksize.height := 1;
    if (src^.width = 1) then
      ksize.width := 1;
  end;

  if (ksize.width = 1) and (ksize.height = 1) then
  begin
    cvCopy(src, dst);
    Exit;
  end;

{$IFDEF HAVE_TEGRA_OPTIMIZATION}
  if (sigmaX = 0) and (sigmaY = 0) and tegra_gaussian(src, dst, ksize, borderType) then
    Exit;
{$ENDIF}
  f := createGaussianFilter(src^.depth, ksize, sigmaX, sigmaY, borderType);
  f.apply(src, dst, cvRect(0, 0, -1, -1), cvPoint(0, 0));
  f.Free;
end;

function createGaussianFilter(_type: Integer; ksize: TcvSize; sigma1: double; sigma2: double; borderType: Integer)
  : TFilterEngine;
Var
  depth: Integer;
  kx, ky: TCvMat;
begin
  depth := CV_MAT_DEPTH(_type);
  if (sigma2 <= 0) then
    sigma2 := sigma1;

  // automatic detection of kernel size from sigma
  if (ksize.width <= 0) and (sigma1 > 0) then
    ksize.width := cvRound(sigma1 * iif(depth = CV_8U, 3, 4) * 2 + 1) or 1;
  if (ksize.height <= 0) and (sigma2 > 0) then
    ksize.height := cvRound(sigma2 * iif(depth = CV_8U, 3, 4) * 2 + 1) or 1;

  Assert((ksize.width > 0) and (ksize.width mod 2 = 1) and (ksize.height > 0) and (ksize.height mod 2 = 1));

  sigma1 := max(sigma1, 0);
  sigma2 := max(sigma2, 0);

  kx := getGaussianKernel(ksize.width, sigma1, max(depth, CV_32F));
  if (ksize.height = ksize.width) and (abs(sigma1 - sigma2) < DBL_EPSILON) then
    ky := kx
  else
    ky := getGaussianKernel(ksize.height, sigma2, max(depth, CV_32F));

  Result := createSeparableLinearFilter(_type, _type, kx, ky, cvPoint(-1, -1), 0, borderType, -1, cvScalar(0));
end;

function getGaussianKernel(n: Integer; sigma: double; ktype: Integer): TCvMat;
Type
  TArrayOfSingle = TArray<Single>;
  TGaussianArray = TArray<TArrayOfSingle>;

const
  SMALL_GAUSSIAN_SIZE = 7;
  // small_gaussian_tab[0..3][0..SMALL_GAUSSIAN_SIZE-1] of Single =
  // (
  // (1,0,0,0,0,0,0),
  // (0.25, 0.5, 0.25,0,0,0,0),
  // (0.0625, 0.25, 0.375, 0.25, 0.0625,0,0),
  // (0.03125, 0.109375, 0.21875, 0.28125, 0.21875, 0.109375, 0.03125)
  // );
Var
  small_gaussian_tab: TGaussianArray;
  fixed_kernel: TArrayOfSingle;
  cf: PSingle;
  cd: pdouble;
  sigmaX, scale2X, sum: double;
  i: Integer;
  x, t: double;
begin
  small_gaussian_tab := TGaussianArray.Create(TArrayOfSingle.Create(1), TArrayOfSingle.Create(0.25, 0.5, 0.25),
    TArrayOfSingle.Create(0.0625, 0.25, 0.375, 0.25, 0.0625), TArrayOfSingle.Create(0.03125, 0.109375, 0.21875, 0.28125,
    0.21875, 0.109375, 0.03125));

  fixed_kernel := iif(((n mod 2) = 1) and (n <= SMALL_GAUSSIAN_SIZE) and (sigma <= 0), small_gaussian_tab[n shr 1], 0);

  Assert((ktype = CV_32F) or (ktype = CV_64F));
  Result := cvCreateMat(n, 1, ktype)^;
  cf := PSingle(Result.data);
  cd := pdouble(Result.data);

  sigmaX := iif(sigma > 0, sigma, ((n - 1) * 0.5 - 1) * 0.3 + 0.8);
  scale2X := -0.5 / (sigmaX * sigmaX);
  sum := 0;

  for i := 0 to n - 1 do
  begin
    x := i - (n - 1) * 0.5;
    t := iif(Assigned(fixed_kernel), fixed_kernel[i], exp(scale2X * x * x));
    if (ktype = CV_32F) then
    begin
      cf[i] := t;
      sum := sum + cf[i];
    end
    else
    begin
      cd[i] := t;
      sum := sum + cd[i];
    end;
  end;

  sum := 1 / sum;
  for i := 0 to n - 1 do
  begin
    if (ktype = CV_32F) then
      cf[i] := cf[i] * sum
    else
      cd[i] := cd[i] * sum;
  end;
end;

function createSeparableLinearFilter(srcType: Integer; dstType: Integer; rowKernel: TCvMat; columnKernel: TCvMat;
  anchor: TcvPoint { =Point(-1,-1) }; delta: double { =0 }; rowBorderType: Integer { =BORDER_DEFAULT };
  columnBorderType: Integer { =-1 }; const borderValue: TcvScalar { =Scalar() } ): TFilterEngine;
begin
  // Mat _rowKernel = __rowKernel.getMat(), _columnKernel = __columnKernel.getMat();
  // _srcType = CV_MAT_TYPE(_srcType);
  // _dstType = CV_MAT_TYPE(_dstType);
  // int sdepth = CV_MAT_DEPTH(_srcType), ddepth = CV_MAT_DEPTH(_dstType);
  // int cn = CV_MAT_CN(_srcType);
  // CV_Assert( cn == CV_MAT_CN(_dstType) );
  // int rsize = _rowKernel.rows + _rowKernel.cols - 1;
  // int csize = _columnKernel.rows + _columnKernel.cols - 1;
  // if( _anchor.x < 0 )
  // _anchor.x = rsize/2;
  // if( _anchor.y < 0 )
  // _anchor.y = csize/2;
  // int rtype = getKernelType(_rowKernel,
  // _rowKernel.rows == 1 ? Point(_anchor.x, 0) : Point(0, _anchor.x));
  // int ctype = getKernelType(_columnKernel,
  // _columnKernel.rows == 1 ? Point(_anchor.y, 0) : Point(0, _anchor.y));
  // Mat rowKernel, columnKernel;
  //
  // int bdepth = std::max(CV_32F,std::max(sdepth, ddepth));
  // int bits = 0;
  //
  // if( sdepth == CV_8U &&
  // ((rtype == KERNEL_SMOOTH+KERNEL_SYMMETRICAL &&
  // ctype == KERNEL_SMOOTH+KERNEL_SYMMETRICAL &&
  // ddepth == CV_8U) ||
  // ((rtype & (KERNEL_SYMMETRICAL+KERNEL_ASYMMETRICAL)) &&
  // (ctype & (KERNEL_SYMMETRICAL+KERNEL_ASYMMETRICAL)) &&
  // (rtype & ctype & KERNEL_INTEGER) &&
  // ddepth == CV_16S)) )
  // {
  // bdepth = CV_32S;
  // bits = ddepth == CV_8U ? 8 : 0;
  // _rowKernel.convertTo( rowKernel, CV_32S, 1 << bits );
  // _columnKernel.convertTo( columnKernel, CV_32S, 1 << bits );
  // bits *= 2;
  // _delta *= (1 << bits);
  // }
  // else
  // {
  // if( _rowKernel.type() != bdepth )
  // _rowKernel.convertTo( rowKernel, bdepth );
  // else
  // rowKernel = _rowKernel;
  // if( _columnKernel.type() != bdepth )
  // _columnKernel.convertTo( columnKernel, bdepth );
  // else
  // columnKernel = _columnKernel;
  // }
  //
  // int _bufType = CV_MAKETYPE(bdepth, cn);
  // Ptr<BaseRowFilter> _rowFilter = getLinearRowFilter(
  // _srcType, _bufType, rowKernel, _anchor.x, rtype);
  // Ptr<BaseColumnFilter> _columnFilter = getLinearColumnFilter(
  // _bufType, _dstType, columnKernel, _anchor.y, ctype, _delta, bits );
  //
  // return Ptr<FilterEngine>( new FilterEngine(Ptr<BaseFilter>(0), _rowFilter, _columnFilter,
  // _srcType, _dstType, _bufType, _rowBorderType, _columnBorderType, _borderValue ));
end;

end.