409 lines
16 KiB
C++
409 lines
16 KiB
C++
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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.
|
|
//
|
|
//
|
|
// Intel License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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.
|
|
//
|
|
//M*/
|
|
|
|
#ifndef _CV_HPP_
|
|
#define _CV_HPP_
|
|
|
|
#ifdef __cplusplus
|
|
|
|
/****************************************************************************************\
|
|
* CvBaseImageFilter: Base class for filtering operations *
|
|
\****************************************************************************************/
|
|
|
|
#define CV_WHOLE 0
|
|
#define CV_START 1
|
|
#define CV_END 2
|
|
#define CV_MIDDLE 4
|
|
#define CV_ISOLATED_ROI 8
|
|
|
|
typedef void (*CvRowFilterFunc)( const uchar* src, uchar* dst, void* params );
|
|
typedef void (*CvColumnFilterFunc)( uchar** src, uchar* dst, int dst_step, int count, void* params );
|
|
|
|
class CV_EXPORTS CvBaseImageFilter
|
|
{
|
|
public:
|
|
CvBaseImageFilter();
|
|
/* calls init() */
|
|
CvBaseImageFilter( int _max_width, int _src_type, int _dst_type,
|
|
bool _is_separable, CvSize _ksize,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
virtual ~CvBaseImageFilter();
|
|
|
|
/* initializes the class for processing an image of maximal width _max_width,
|
|
input image has data type _src_type, the output will have _dst_type.
|
|
_is_separable != 0 if the filter is separable
|
|
(specific behaviour is defined in a derived class), 0 otherwise.
|
|
_ksize and _anchor specify the kernel size and the anchor point. _anchor=(-1,-1) means
|
|
that the anchor is at the center.
|
|
to get interpolate pixel values outside the image _border_mode=IPL_BORDER_*** is used,
|
|
_border_value specify the pixel value in case of IPL_BORDER_CONSTANT border mode.
|
|
before initialization clear() is called if necessary.
|
|
*/
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
bool _is_separable, CvSize _ksize,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
/* releases all the internal buffers.
|
|
for the further use of the object, init() needs to be called. */
|
|
virtual void clear();
|
|
/* processes input image or a part of it.
|
|
input is represented either as matrix (CvMat* src)
|
|
or a list of row pointers (uchar** src2).
|
|
in the later case width, _src_y1 and _src_y2 are used to specify the size.
|
|
_dst is the output image/matrix.
|
|
_src_roi specifies the roi inside the input image to process,
|
|
(0,0,-1,-1) denotes the whole image.
|
|
_dst_origin is the upper-left corner of the filtered roi within the output image.
|
|
_phase is either CV_START, or CV_END, or CV_MIDDLE, or CV_START|CV_END, or CV_WHOLE,
|
|
which is the same as CV_START|CV_END.
|
|
CV_START means that the input is the first (top) stripe of the processed image [roi],
|
|
CV_END - the input is the last (bottom) stripe of the processed image [roi],
|
|
CV_MIDDLE - the input is neither first nor last stripe.
|
|
CV_WHOLE - the input is the whole processed image [roi].
|
|
*/
|
|
virtual int process( const CvMat* _src, CvMat* _dst,
|
|
CvRect _src_roi=cvRect(0,0,-1,-1),
|
|
CvPoint _dst_origin=cvPoint(0,0), int _flags=0 );
|
|
/* retrieve various parameters of the filtering object */
|
|
int get_src_type() const { return src_type; }
|
|
int get_dst_type() const { return dst_type; }
|
|
int get_work_type() const { return work_type; }
|
|
CvSize get_kernel_size() const { return ksize; }
|
|
CvPoint get_anchor() const { return anchor; }
|
|
int get_width() const { return prev_x_range.end_index - prev_x_range.start_index; }
|
|
CvRowFilterFunc get_x_filter_func() const { return x_func; }
|
|
CvColumnFilterFunc get_y_filter_func() const { return y_func; }
|
|
|
|
protected:
|
|
/* initializes work_type, buf_size and max_rows */
|
|
virtual void get_work_params();
|
|
/* it is called (not always) from process when _phase=CV_START or CV_WHOLE.
|
|
the method initializes ring buffer (buf_end, buf_head, buf_tail, buf_count, rows),
|
|
prev_width, prev_x_range, const_row, border_tab, border_tab_sz* */
|
|
virtual void start_process( CvSlice x_range, int width );
|
|
/* forms pointers to "virtual rows" above or below the processed roi using the specified
|
|
border mode */
|
|
virtual void make_y_border( int row_count, int top_rows, int bottom_rows );
|
|
|
|
virtual int fill_cyclic_buffer( const uchar* src, int src_step,
|
|
int y, int y1, int y2 );
|
|
|
|
enum { ALIGN=32 };
|
|
|
|
int max_width;
|
|
/* currently, work_type must be the same as src_type in case of non-separable filters */
|
|
int min_depth, src_type, dst_type, work_type;
|
|
|
|
/* pointers to convolution functions, initialized by init method.
|
|
for non-separable filters only y_conv should be set */
|
|
CvRowFilterFunc x_func;
|
|
CvColumnFilterFunc y_func;
|
|
|
|
uchar* buffer;
|
|
uchar** rows;
|
|
int top_rows, bottom_rows, max_rows;
|
|
uchar *buf_start, *buf_end, *buf_head, *buf_tail;
|
|
int buf_size, buf_step, buf_count, buf_max_count;
|
|
|
|
bool is_separable;
|
|
CvSize ksize;
|
|
CvPoint anchor;
|
|
int max_ky, border_mode;
|
|
CvScalar border_value;
|
|
uchar* const_row;
|
|
int* border_tab;
|
|
int border_tab_sz1, border_tab_sz;
|
|
|
|
CvSlice prev_x_range;
|
|
int prev_width;
|
|
};
|
|
|
|
|
|
/* Derived class, for linear separable filtering. */
|
|
class CV_EXPORTS CvSepFilter : public CvBaseImageFilter
|
|
{
|
|
public:
|
|
CvSepFilter();
|
|
CvSepFilter( int _max_width, int _src_type, int _dst_type,
|
|
const CvMat* _kx, const CvMat* _ky,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
virtual ~CvSepFilter();
|
|
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
const CvMat* _kx, const CvMat* _ky,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
virtual void init_deriv( int _max_width, int _src_type, int _dst_type,
|
|
int dx, int dy, int aperture_size, int flags=0 );
|
|
virtual void init_gaussian( int _max_width, int _src_type, int _dst_type,
|
|
int gaussian_size, double sigma );
|
|
|
|
/* dummy method to avoid compiler warnings */
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
bool _is_separable, CvSize _ksize,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
virtual void clear();
|
|
const CvMat* get_x_kernel() const { return kx; }
|
|
const CvMat* get_y_kernel() const { return ky; }
|
|
int get_x_kernel_flags() const { return kx_flags; }
|
|
int get_y_kernel_flags() const { return ky_flags; }
|
|
|
|
enum { GENERIC=0, ASYMMETRICAL=1, SYMMETRICAL=2, POSITIVE=4, SUM_TO_1=8, INTEGER=16 };
|
|
enum { NORMALIZE_KERNEL=1, FLIP_KERNEL=2 };
|
|
|
|
static void init_gaussian_kernel( CvMat* kernel, double sigma=-1 );
|
|
static void init_sobel_kernel( CvMat* _kx, CvMat* _ky, int dx, int dy, int flags=0 );
|
|
static void init_scharr_kernel( CvMat* _kx, CvMat* _ky, int dx, int dy, int flags=0 );
|
|
|
|
protected:
|
|
CvMat *kx, *ky;
|
|
int kx_flags, ky_flags;
|
|
};
|
|
|
|
|
|
/* Derived class, for linear non-separable filtering. */
|
|
class CV_EXPORTS CvLinearFilter : public CvBaseImageFilter
|
|
{
|
|
public:
|
|
CvLinearFilter();
|
|
CvLinearFilter( int _max_width, int _src_type, int _dst_type,
|
|
const CvMat* _kernel,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
virtual ~CvLinearFilter();
|
|
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
const CvMat* _kernel,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
/* dummy method to avoid compiler warnings */
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
bool _is_separable, CvSize _ksize,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
virtual void clear();
|
|
const CvMat* get_kernel() const { return kernel; }
|
|
uchar* get_kernel_sparse_buf() { return k_sparse; }
|
|
int get_kernel_sparse_count() const { return k_sparse_count; }
|
|
|
|
protected:
|
|
CvMat *kernel;
|
|
uchar* k_sparse;
|
|
int k_sparse_count;
|
|
};
|
|
|
|
|
|
/* Box filter ("all 1's", optionally normalized) filter. */
|
|
class CV_EXPORTS CvBoxFilter : public CvBaseImageFilter
|
|
{
|
|
public:
|
|
CvBoxFilter();
|
|
CvBoxFilter( int _max_width, int _src_type, int _dst_type,
|
|
bool _normalized, CvSize _ksize,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
bool _normalized, CvSize _ksize,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
virtual ~CvBoxFilter();
|
|
bool is_normalized() const { return normalized; }
|
|
double get_scale() const { return scale; }
|
|
uchar* get_sum_buf() { return sum; }
|
|
int* get_sum_count_ptr() { return &sum_count; }
|
|
|
|
protected:
|
|
virtual void start_process( CvSlice x_range, int width );
|
|
|
|
uchar* sum;
|
|
int sum_count;
|
|
bool normalized;
|
|
double scale;
|
|
};
|
|
|
|
|
|
/* Laplacian operator: (d2/dx + d2/dy)I. */
|
|
class CV_EXPORTS CvLaplaceFilter : public CvSepFilter
|
|
{
|
|
public:
|
|
CvLaplaceFilter();
|
|
CvLaplaceFilter( int _max_width, int _src_type, int _dst_type,
|
|
bool _normalized, int _ksize,
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
virtual ~CvLaplaceFilter();
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
bool _normalized, int _ksize,
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
/* dummy methods to avoid compiler warnings */
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
bool _is_separable, CvSize _ksize,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
const CvMat* _kx, const CvMat* _ky,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
bool is_normalized() const { return normalized; }
|
|
bool is_basic_laplacian() const { return basic_laplacian; }
|
|
protected:
|
|
void get_work_params();
|
|
|
|
bool basic_laplacian;
|
|
bool normalized;
|
|
};
|
|
|
|
|
|
/* basic morphological operations: erosion & dilation */
|
|
class CV_EXPORTS CvMorphology : public CvBaseImageFilter
|
|
{
|
|
public:
|
|
CvMorphology();
|
|
CvMorphology( int _operation, int _max_width, int _src_dst_type,
|
|
int _element_shape, CvMat* _element,
|
|
CvSize _ksize=cvSize(0,0), CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
virtual ~CvMorphology();
|
|
virtual void init( int _operation, int _max_width, int _src_dst_type,
|
|
int _element_shape, CvMat* _element,
|
|
CvSize _ksize=cvSize(0,0), CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
/* dummy method to avoid compiler warnings */
|
|
virtual void init( int _max_width, int _src_type, int _dst_type,
|
|
bool _is_separable, CvSize _ksize,
|
|
CvPoint _anchor=cvPoint(-1,-1),
|
|
int _border_mode=IPL_BORDER_REPLICATE,
|
|
CvScalar _border_value=cvScalarAll(0) );
|
|
|
|
virtual void clear();
|
|
const CvMat* get_element() const { return element; }
|
|
int get_element_shape() const { return el_shape; }
|
|
int get_operation() const { return operation; }
|
|
uchar* get_element_sparse_buf() { return el_sparse; }
|
|
int get_element_sparse_count() const { return el_sparse_count; }
|
|
|
|
enum { RECT=0, CROSS=1, ELLIPSE=2, CUSTOM=100, BINARY = 0, GRAYSCALE=256 };
|
|
enum { ERODE=0, DILATE=1 };
|
|
|
|
static void init_binary_element( CvMat* _element, int _element_shape,
|
|
CvPoint _anchor=cvPoint(-1,-1) );
|
|
protected:
|
|
|
|
void start_process( CvSlice x_range, int width );
|
|
int fill_cyclic_buffer( const uchar* src, int src_step,
|
|
int y0, int y1, int y2 );
|
|
uchar* el_sparse;
|
|
int el_sparse_count;
|
|
|
|
CvMat *element;
|
|
int el_shape;
|
|
int operation;
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
struct CV_EXPORTS CvLevMarq
|
|
{
|
|
CvLevMarq();
|
|
CvLevMarq( int nparams, int nerrs, CvTermCriteria criteria=
|
|
cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
|
|
bool completeSymmFlag=false );
|
|
~CvLevMarq();
|
|
void init( int nparams, int nerrs, CvTermCriteria criteria=
|
|
cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER,30,DBL_EPSILON),
|
|
bool completeSymmFlag=false );
|
|
bool update( const CvMat*& param, CvMat*& J, CvMat*& err );
|
|
bool updateAlt( const CvMat*& param, CvMat*& JtJ, CvMat*& JtErr, double*& errNorm );
|
|
|
|
void clear();
|
|
void step();
|
|
enum { DONE=0, STARTED=1, CALC_J=2, CHECK_ERR=3 };
|
|
|
|
CvMat* mask;
|
|
CvMat* prevParam;
|
|
CvMat* param;
|
|
CvMat* J;
|
|
CvMat* err;
|
|
CvMat* JtJ;
|
|
CvMat* JtJN;
|
|
CvMat* JtErr;
|
|
CvMat* JtJV;
|
|
CvMat* JtJW;
|
|
double prevErrNorm, errNorm;
|
|
int lambdaLg10;
|
|
CvTermCriteria criteria;
|
|
int state;
|
|
int iters;
|
|
bool completeSymmFlag;
|
|
};
|
|
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* _CV_HPP_ */
|
|
|
|
/* End of file. */
|