+sci2c_CVImgproclib = lib(pathmacros + "ImageProcessing\imgproc" + filesep());

+#include "cvimgproc.h"

+#include "int_cvimgproc.h"

+ PrintStringInfo('LDFLAGS = -llapack -lrefblas -lgfortran -lwiringPi',FileInfo.MakefileFilename,'file','y','y');

+ if(SharedInfo.OpenCVUsed == %T)

+ PrintStringInfo('LDFLAGS += -lopencv_calib3d -lopencv_contrib -lopencv_core -lopencv_features2d -lopencv_flann',FileInfo.MakefileFilename,'file','y','y');

+ PrintStringInfo('LDFLAGS += -lopencv_gpu -lopencv_highgui -lopencv_imgproc -lopencv_legacy -lopencv_ml',FileInfo.MakefileFilename,'file','y','y');

+ PrintStringInfo('LDFLAGS += -lopencv_nonfree -lopencv_objdetect -lopencv_ocl -lopencv_photo -lopencv_stitching',FileInfo.MakefileFilename,'file','y','y');

+ PrintStringInfo('LDFLAGS += -lopencv_superres -lopencv_ts -lopencv_video -lopencv_videostab -lrt -lpthread -lm -ldl', FileInfo.MakefileFilename,'file','y','y');

+ end

+ if(SharedInfo.OpenCVUsed == %T)

+ PrintStringInfo('LDFLAGS += `pkg-config --libs opencv`',FileInfo.MakefileFilename,'file','y','y');

+ PrintStringInfo('CFLAGS += `pkg-config --cflags opencv`',FileInfo.MakefileFilename,'file','y','y');

+ end

+OpencvDirs = [ "core", ...

+ "highgui", ...

+ "imgproc"];

+// CV_CreateImage([320 240], "IPL_DEPTH_8U", 1) //to create image of the size 320*240

+// Copyright (C) 2016 - IIT Bombay - FOSSEE

+//

+// This file must be used under the terms of the CeCILL.

+// This source file is licensed as described in the file COPYING, which

+// you should have received as part of this distribution. The terms

+// are also available at

+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt

+// Author: Siddhesh Wani

+// Organization: FOSSEE, IIT Bombay

+// Email: toolbox@scilab.in

+

+function imgsize = CV_GetImgSize(img)

+// function to get size of the image (width*height)

+//

+// Calling Sequence

+// CV_GetImgSize(img)

+//

+// Parameters

+// img: image whose size is to be returned

+//

+// Description

+// This function can be used for retriving size information of the image.

+// It returs an array with first image element as width and second as height

+// Examples

+// img = CV_LoadImage('~/test.jpg',0)

+// size = CV_GetImgSize(img)

+//

+// See also

+// CV_LoadImage CV_CreateImage

+//

+// Authors

+// Siddhesh Wani

+//

+imgsize = [0 0];

+// This is curretly dummy function. It provides no functionality but is required

+// for providing support for generating C code for OpenCV

+

+endfunction

+CV_GetImgSize

+// Copyright (C) 2016 - IIT Bombay - FOSSEE

+//

+// This file must be used under the terms of the CeCILL.

+// This source file is licensed as described in the file COPYING, which

+// you should have received as part of this distribution. The terms

+// are also available at

+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt

+// Author: Siddhesh Wani

+// Organization: FOSSEE, IIT Bombay

+// Email: toolbox@scilab.in

+

+function status = CV_CvtColor(srcimg,dstimg,code)

+// function to convert image from one colorspace to other colorspace

+//

+// Calling Sequence

+// CV_CvtColor(srcimg,dstimg,code,dstCn)

+//

+// Parameters

+// srcimg: source image to be converted

+// dstimg: destination image in which to store converted image

+// code: String specifying conversion type. Same as defined in OpenCV

+// for eg. 'CV_RGB2GRAY' for conversion from RGB image to grayscale image

+// dstCn: no of channels in destination image (0 by default)

+//

+// Description

+// This function can be used for converting an image to other colorspace.

+// Refer OpenCV documentation for list of available conversions

+// Examples

+// img = CV_LoadImage('~/test.jpg',0)

+// dst = CV_CreateImage(320,240,"IPL_DEPTH_8U",1)

+// CV_CvtColor(img,dst,'CV_RGB2GRAY')

+//

+// See also

+// CV_LoadImage CV_CreateImage

+//

+// Authors

+// Siddhesh Wani

+//

+status = 0;

+// This is curretly dummy function. It provides no functionality but is required

+// for providing support for generating C code for OpenCV

+

+endfunction

+//

+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab

+// Copyright (C) 2009-2009 - DIGITEO - Bruno JOFRET

+//

+// This file must be used under the terms of the CeCILL.

+// This source file is licensed as described in the file COPYING, which

+// you should have received as part of this distribution. The terms

+// are also available at

+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt

+//

+//

+

+tbx_build_macros(TOOLBOX_NAME, get_absolute_file_path('buildmacros.sce'));

+

+clear tbx_build_macros;

+CV_CvtColor

+//------------------------------------

+//---- Class CV_CvtColor -------------

+//------------------------------------

+ClassName = 'CV_CvtColor';

+

+// --- Class Annotation. ---

+PrintStringInfo(' Adding Class: '+ClassName+'.',GeneralReport,'file','y');

+ClassFileName = fullfile(SCI2CLibCAnnClsDir,ClassName+ExtensionCAnnCls);

+

+PrintStringInfo('NIN= 3',ClassFileName,'file','y');

+PrintStringInfo('NOUT= 1',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).TP= ''u8''',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).SZ(1)= ''1''',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).SZ(2)= ''1''',ClassFileName,'file','y');

+

+ClassFileName = fullfile(SCI2CLibCFLClsDir,ClassName+ExtensionCFuncListCls);

+PrintStringInfo('im0im0g2'+ArgSeparator+'u80',ClassFileName,'file','y');

+

+// --- Annotation Function And Function List Function. ---

+FunctionName = 'CV_CvtColor';

+PrintStringInfo(' Adding Function: '+FunctionName+'.',GeneralReport,'file','y');

+INIT_GenAnnFLFunctions(FunctionName,SCI2CLibCAnnFunDir,ClassName,GeneralReport,ExtensionCAnnFun);

+INIT_GenAnnFLFunctions(FunctionName,SCI2CLibCFLFunDir,ClassName,GeneralReport,ExtensionCFuncListFun);

+

+//------------------------------------

+//---- Class CV_GetImgSize -----------

+//------------------------------------

+ClassName = 'CV_GetImgSize';

+

+// --- Class Annotation. ---

+PrintStringInfo(' Adding Class: '+ClassName+'.',GeneralReport,'file','y');

+ClassFileName = fullfile(SCI2CLibCAnnClsDir,ClassName+ExtensionCAnnCls);

+

+PrintStringInfo('NIN= 1',ClassFileName,'file','y');

+PrintStringInfo('NOUT= 1',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).TP= ''d''',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).SZ(1)= ''1''',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).SZ(2)= ''2''',ClassFileName,'file','y');

+

+ClassFileName = fullfile(SCI2CLibCFLClsDir,ClassName+ExtensionCFuncListCls);

+PrintStringInfo('im0'+ArgSeparator+'d2',ClassFileName,'file','y');

+

+// --- Annotation Function And Function List Function. ---

+FunctionName = 'CV_GetImgSize';

+PrintStringInfo(' Adding Function: '+FunctionName+'.',GeneralReport,'file','y');

+INIT_GenAnnFLFunctions(FunctionName,SCI2CLibCAnnFunDir,ClassName,GeneralReport,ExtensionCAnnFun);

+INIT_GenAnnFLFunctions(FunctionName,SCI2CLibCFLFunDir,ClassName,GeneralReport,ExtensionCFuncListFun);

+

+ "src/c/imageProcessing/includes/cvhighgui.h"

+ "src/c/imageProcessing/includes/cvimgproc.h"];

+ "src/c/imageProcessing/interfaces/int_cvhighgui.h"

+ "src/c/imageProcessing/interfaces/int_cvimgproc.h"];

+ RPi_cvlibs = [

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_calib3d.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_contrib.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_core.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_features2d.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_flann.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_gpu.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_highgui.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_imgproc.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_legacy.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_ml.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_nonfree.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_objdetect.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_ocl.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_photo.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_stitching.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_superres.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_video.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_videostab.so"

+ "src/c/hardware/rasberrypi/libraries/opencv/libopencv_ts.a"

+];

+

+ allLibraries = RPi_libs;

+ if (SharedInfo.OpenCVUsed == %T)

+ allLibraries = cat(1,allLibraries,RPi_cvlibs)

+ end

+

+ "src/c/imageProcessing/cvcore/imcvGetImgSizes.c"

+ "src/c/imageProcessing/cvhighgui/imcvShowImages.c"

+ "src/c/imageProcessing/cvimgproc/imcvCvtColors.c"];

+ //disp("Copying "+allLibraries(i)+" in "+SCI2COutputPath+"/libraries/");

+

+//Copy folder containing opencv include files in Includes folder

+if((Target == 'RPi') & (SharedInfo.OpenCVUsed == %T))

+ copyfile(SCI2CHOME + "/" +'src/c/hardware/rasberrypi/libraries/opencv/opencv2/',SCI2COutputPath+"/includes/opencv2")

+end

+

+

+/*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.

+//

+//

+// 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.

+//

+//M*/

+

+#include "opencv2/calib3d/calib3d.hpp"

+/*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.

+//

+//

+// 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.

+//

+//M*/

+

+#ifndef __OPENCV_CALIB3D_HPP__

+#define __OPENCV_CALIB3D_HPP__

+

+#include "opencv2/core/core.hpp"

+#include "opencv2/features2d/features2d.hpp"

+#include "opencv2/core/affine.hpp"

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/****************************************************************************************\

+* Camera Calibration, Pose Estimation and Stereo *

+\****************************************************************************************/

+

+typedef struct CvPOSITObject CvPOSITObject;

+

+/* Allocates and initializes CvPOSITObject structure before doing cvPOSIT */

+CVAPI(CvPOSITObject*) cvCreatePOSITObject( CvPoint3D32f* points, int point_count );

+

+

+/* Runs POSIT (POSe from ITeration) algorithm for determining 3d position of

+ an object given its model and projection in a weak-perspective case */

+CVAPI(void) cvPOSIT( CvPOSITObject* posit_object, CvPoint2D32f* image_points,

+ double focal_length, CvTermCriteria criteria,

+ float* rotation_matrix, float* translation_vector);

+

+/* Releases CvPOSITObject structure */

+CVAPI(void) cvReleasePOSITObject( CvPOSITObject** posit_object );

+

+/* updates the number of RANSAC iterations */

+CVAPI(int) cvRANSACUpdateNumIters( double p, double err_prob,

+ int model_points, int max_iters );

+

+CVAPI(void) cvConvertPointsHomogeneous( const CvMat* src, CvMat* dst );

+

+/* Calculates fundamental matrix given a set of corresponding points */

+#define CV_FM_7POINT 1

+#define CV_FM_8POINT 2

+

+#define CV_LMEDS 4

+#define CV_RANSAC 8

+

+#define CV_FM_LMEDS_ONLY CV_LMEDS

+#define CV_FM_RANSAC_ONLY CV_RANSAC

+#define CV_FM_LMEDS CV_LMEDS

+#define CV_FM_RANSAC CV_RANSAC

+

+enum

+{

+ CV_ITERATIVE = 0,

+ CV_EPNP = 1, // F.Moreno-Noguer, V.Lepetit and P.Fua "EPnP: Efficient Perspective-n-Point Camera Pose Estimation"

+ CV_P3P = 2 // X.S. Gao, X.-R. Hou, J. Tang, H.-F. Chang; "Complete Solution Classification for the Perspective-Three-Point Problem"

+};

+

+CVAPI(int) cvFindFundamentalMat( const CvMat* points1, const CvMat* points2,

+ CvMat* fundamental_matrix,

+ int method CV_DEFAULT(CV_FM_RANSAC),

+ double param1 CV_DEFAULT(3.), double param2 CV_DEFAULT(0.99),

+ CvMat* status CV_DEFAULT(NULL) );

+

+/* For each input point on one of images

+ computes parameters of the corresponding

+ epipolar line on the other image */

+CVAPI(void) cvComputeCorrespondEpilines( const CvMat* points,

+ int which_image,

+ const CvMat* fundamental_matrix,

+ CvMat* correspondent_lines );

+

+/* Triangulation functions */

+

+CVAPI(void) cvTriangulatePoints(CvMat* projMatr1, CvMat* projMatr2,

+ CvMat* projPoints1, CvMat* projPoints2,

+ CvMat* points4D);

+

+CVAPI(void) cvCorrectMatches(CvMat* F, CvMat* points1, CvMat* points2,

+ CvMat* new_points1, CvMat* new_points2);

+

+

+/* Computes the optimal new camera matrix according to the free scaling parameter alpha:

+ alpha=0 - only valid pixels will be retained in the undistorted image

+ alpha=1 - all the source image pixels will be retained in the undistorted image

+*/

+CVAPI(void) cvGetOptimalNewCameraMatrix( const CvMat* camera_matrix,

+ const CvMat* dist_coeffs,

+ CvSize image_size, double alpha,

+ CvMat* new_camera_matrix,

+ CvSize new_imag_size CV_DEFAULT(cvSize(0,0)),

+ CvRect* valid_pixel_ROI CV_DEFAULT(0),

+ int center_principal_point CV_DEFAULT(0));

+

+/* Converts rotation vector to rotation matrix or vice versa */

+CVAPI(int) cvRodrigues2( const CvMat* src, CvMat* dst,

+ CvMat* jacobian CV_DEFAULT(0) );

+

+/* Finds perspective transformation between the object plane and image (view) plane */

+CVAPI(int) cvFindHomography( const CvMat* src_points,

+ const CvMat* dst_points,

+ CvMat* homography,

+ int method CV_DEFAULT(0),

+ double ransacReprojThreshold CV_DEFAULT(3),

+ CvMat* mask CV_DEFAULT(0));

+

+/* Computes RQ decomposition for 3x3 matrices */

+CVAPI(void) cvRQDecomp3x3( const CvMat *matrixM, CvMat *matrixR, CvMat *matrixQ,

+ CvMat *matrixQx CV_DEFAULT(NULL),

+ CvMat *matrixQy CV_DEFAULT(NULL),

+ CvMat *matrixQz CV_DEFAULT(NULL),

+ CvPoint3D64f *eulerAngles CV_DEFAULT(NULL));

+

+/* Computes projection matrix decomposition */

+CVAPI(void) cvDecomposeProjectionMatrix( const CvMat *projMatr, CvMat *calibMatr,

+ CvMat *rotMatr, CvMat *posVect,

+ CvMat *rotMatrX CV_DEFAULT(NULL),

+ CvMat *rotMatrY CV_DEFAULT(NULL),

+ CvMat *rotMatrZ CV_DEFAULT(NULL),

+ CvPoint3D64f *eulerAngles CV_DEFAULT(NULL));

+

+/* Computes d(AB)/dA and d(AB)/dB */

+CVAPI(void) cvCalcMatMulDeriv( const CvMat* A, const CvMat* B, CvMat* dABdA, CvMat* dABdB );

+

+/* Computes r3 = rodrigues(rodrigues(r2)*rodrigues(r1)),

+ t3 = rodrigues(r2)*t1 + t2 and the respective derivatives */

+CVAPI(void) cvComposeRT( const CvMat* _rvec1, const CvMat* _tvec1,

+ const CvMat* _rvec2, const CvMat* _tvec2,

+ CvMat* _rvec3, CvMat* _tvec3,

+ CvMat* dr3dr1 CV_DEFAULT(0), CvMat* dr3dt1 CV_DEFAULT(0),

+ CvMat* dr3dr2 CV_DEFAULT(0), CvMat* dr3dt2 CV_DEFAULT(0),

+ CvMat* dt3dr1 CV_DEFAULT(0), CvMat* dt3dt1 CV_DEFAULT(0),

+ CvMat* dt3dr2 CV_DEFAULT(0), CvMat* dt3dt2 CV_DEFAULT(0) );

+

+/* Projects object points to the view plane using

+ the specified extrinsic and intrinsic camera parameters */

+CVAPI(void) cvProjectPoints2( const CvMat* object_points, const CvMat* rotation_vector,

+ const CvMat* translation_vector, const CvMat* camera_matrix,

+ const CvMat* distortion_coeffs, CvMat* image_points,

+ CvMat* dpdrot CV_DEFAULT(NULL), CvMat* dpdt CV_DEFAULT(NULL),

+ CvMat* dpdf CV_DEFAULT(NULL), CvMat* dpdc CV_DEFAULT(NULL),

+ CvMat* dpddist CV_DEFAULT(NULL),

+ double aspect_ratio CV_DEFAULT(0));

+

+/* Finds extrinsic camera parameters from

+ a few known corresponding point pairs and intrinsic parameters */

+CVAPI(void) cvFindExtrinsicCameraParams2( const CvMat* object_points,

+ const CvMat* image_points,

+ const CvMat* camera_matrix,

+ const CvMat* distortion_coeffs,

+ CvMat* rotation_vector,

+ CvMat* translation_vector,

+ int use_extrinsic_guess CV_DEFAULT(0) );

+

+/* Computes initial estimate of the intrinsic camera parameters

+ in case of planar calibration target (e.g. chessboard) */

+CVAPI(void) cvInitIntrinsicParams2D( const CvMat* object_points,

+ const CvMat* image_points,

+ const CvMat* npoints, CvSize image_size,

+ CvMat* camera_matrix,

+ double aspect_ratio CV_DEFAULT(1.) );

+

+#define CV_CALIB_CB_ADAPTIVE_THRESH 1

+#define CV_CALIB_CB_NORMALIZE_IMAGE 2

+#define CV_CALIB_CB_FILTER_QUADS 4

+#define CV_CALIB_CB_FAST_CHECK 8

+

+// Performs a fast check if a chessboard is in the input image. This is a workaround to

+// a problem of cvFindChessboardCorners being slow on images with no chessboard

+// - src: input image

+// - size: chessboard size

+// Returns 1 if a chessboard can be in this image and findChessboardCorners should be called,

+// 0 if there is no chessboard, -1 in case of error

+CVAPI(int) cvCheckChessboard(IplImage* src, CvSize size);

+

+ /* Detects corners on a chessboard calibration pattern */

+CVAPI(int) cvFindChessboardCorners( const void* image, CvSize pattern_size,

+ CvPoint2D32f* corners,

+ int* corner_count CV_DEFAULT(NULL),

+ int flags CV_DEFAULT(CV_CALIB_CB_ADAPTIVE_THRESH+CV_CALIB_CB_NORMALIZE_IMAGE) );

+

+/* Draws individual chessboard corners or the whole chessboard detected */

+CVAPI(void) cvDrawChessboardCorners( CvArr* image, CvSize pattern_size,

+ CvPoint2D32f* corners,

+ int count, int pattern_was_found );

+

+#define CV_CALIB_USE_INTRINSIC_GUESS 1

+#define CV_CALIB_FIX_ASPECT_RATIO 2

+#define CV_CALIB_FIX_PRINCIPAL_POINT 4

+#define CV_CALIB_ZERO_TANGENT_DIST 8

+#define CV_CALIB_FIX_FOCAL_LENGTH 16

+#define CV_CALIB_FIX_K1 32

+#define CV_CALIB_FIX_K2 64

+#define CV_CALIB_FIX_K3 128

+#define CV_CALIB_FIX_K4 2048

+#define CV_CALIB_FIX_K5 4096

+#define CV_CALIB_FIX_K6 8192

+#define CV_CALIB_RATIONAL_MODEL 16384

+

+/* Finds intrinsic and extrinsic camera parameters

+ from a few views of known calibration pattern */

+CVAPI(double) cvCalibrateCamera2( const CvMat* object_points,

+ const CvMat* image_points,

+ const CvMat* point_counts,

+ CvSize image_size,

+ CvMat* camera_matrix,

+ CvMat* distortion_coeffs,

+ CvMat* rotation_vectors CV_DEFAULT(NULL),

+ CvMat* translation_vectors CV_DEFAULT(NULL),

+ int flags CV_DEFAULT(0),

+ CvTermCriteria term_crit CV_DEFAULT(cvTermCriteria(

+ CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,DBL_EPSILON)) );

+

+/* Computes various useful characteristics of the camera from the data computed by

+ cvCalibrateCamera2 */

+CVAPI(void) cvCalibrationMatrixValues( const CvMat *camera_matrix,

+ CvSize image_size,

+ double aperture_width CV_DEFAULT(0),

+ double aperture_height CV_DEFAULT(0),

+ double *fovx CV_DEFAULT(NULL),

+ double *fovy CV_DEFAULT(NULL),

+ double *focal_length CV_DEFAULT(NULL),

+ CvPoint2D64f *principal_point CV_DEFAULT(NULL),

+ double *pixel_aspect_ratio CV_DEFAULT(NULL));

+

+#define CV_CALIB_FIX_INTRINSIC 256

+#define CV_CALIB_SAME_FOCAL_LENGTH 512

+

+/* Computes the transformation from one camera coordinate system to another one

+ from a few correspondent views of the same calibration target. Optionally, calibrates

+ both cameras */

+CVAPI(double) cvStereoCalibrate( const CvMat* object_points, const CvMat* image_points1,

+ const CvMat* image_points2, const CvMat* npoints,

+ CvMat* camera_matrix1, CvMat* dist_coeffs1,

+ CvMat* camera_matrix2, CvMat* dist_coeffs2,

+ CvSize image_size, CvMat* R, CvMat* T,

+ CvMat* E CV_DEFAULT(0), CvMat* F CV_DEFAULT(0),

+ CvTermCriteria term_crit CV_DEFAULT(cvTermCriteria(

+ CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,1e-6)),

+ int flags CV_DEFAULT(CV_CALIB_FIX_INTRINSIC));

+

+#define CV_CALIB_ZERO_DISPARITY 1024

+

+/* Computes 3D rotations (+ optional shift) for each camera coordinate system to make both

+ views parallel (=> to make all the epipolar lines horizontal or vertical) */

+CVAPI(void) cvStereoRectify( const CvMat* camera_matrix1, const CvMat* camera_matrix2,

+ const CvMat* dist_coeffs1, const CvMat* dist_coeffs2,

+ CvSize image_size, const CvMat* R, const CvMat* T,

+ CvMat* R1, CvMat* R2, CvMat* P1, CvMat* P2,

+ CvMat* Q CV_DEFAULT(0),

+ int flags CV_DEFAULT(CV_CALIB_ZERO_DISPARITY),

+ double alpha CV_DEFAULT(-1),

+ CvSize new_image_size CV_DEFAULT(cvSize(0,0)),

+ CvRect* valid_pix_ROI1 CV_DEFAULT(0),

+ CvRect* valid_pix_ROI2 CV_DEFAULT(0));

+

+/* Computes rectification transformations for uncalibrated pair of images using a set

+ of point correspondences */

+CVAPI(int) cvStereoRectifyUncalibrated( const CvMat* points1, const CvMat* points2,

+ const CvMat* F, CvSize img_size,

+ CvMat* H1, CvMat* H2,

+ double threshold CV_DEFAULT(5));

+

+

+

+/* stereo correspondence parameters and functions */

+

+#define CV_STEREO_BM_NORMALIZED_RESPONSE 0

+#define CV_STEREO_BM_XSOBEL 1

+

+/* Block matching algorithm structure */

+typedef struct CvStereoBMState

+{

+ // pre-filtering (normalization of input images)

+ int preFilterType; // =CV_STEREO_BM_NORMALIZED_RESPONSE now

+ int preFilterSize; // averaging window size: ~5x5..21x21

+ int preFilterCap; // the output of pre-filtering is clipped by [-preFilterCap,preFilterCap]

+

+ // correspondence using Sum of Absolute Difference (SAD)

+ int SADWindowSize; // ~5x5..21x21

+ int minDisparity; // minimum disparity (can be negative)

+ int numberOfDisparities; // maximum disparity - minimum disparity (> 0)

+

+ // post-filtering

+ int textureThreshold; // the disparity is only computed for pixels

+ // with textured enough neighborhood

+ int uniquenessRatio; // accept the computed disparity d* only if

+ // SAD(d) >= SAD(d*)*(1 + uniquenessRatio/100.)

+ // for any d != d*+/-1 within the search range.

+ int speckleWindowSize; // disparity variation window

+ int speckleRange; // acceptable range of variation in window

+

+ int trySmallerWindows; // if 1, the results may be more accurate,

+ // at the expense of slower processing

+ CvRect roi1, roi2;

+ int disp12MaxDiff;

+

+ // temporary buffers

+ CvMat* preFilteredImg0;

+ CvMat* preFilteredImg1;

+ CvMat* slidingSumBuf;

+ CvMat* cost;

+ CvMat* disp;

+} CvStereoBMState;

+

+#define CV_STEREO_BM_BASIC 0

+#define CV_STEREO_BM_FISH_EYE 1

+#define CV_STEREO_BM_NARROW 2

+

+CVAPI(CvStereoBMState*) cvCreateStereoBMState(int preset CV_DEFAULT(CV_STEREO_BM_BASIC),

+ int numberOfDisparities CV_DEFAULT(0));

+

+CVAPI(void) cvReleaseStereoBMState( CvStereoBMState** state );

+

+CVAPI(void) cvFindStereoCorrespondenceBM( const CvArr* left, const CvArr* right,

+ CvArr* disparity, CvStereoBMState* state );

+

+CVAPI(CvRect) cvGetValidDisparityROI( CvRect roi1, CvRect roi2, int minDisparity,

+ int numberOfDisparities, int SADWindowSize );

+

+CVAPI(void) cvValidateDisparity( CvArr* disparity, const CvArr* cost,

+ int minDisparity, int numberOfDisparities,

+ int disp12MaxDiff CV_DEFAULT(1) );

+

+/* Reprojects the computed disparity image to the 3D space using the specified 4x4 matrix */

+CVAPI(void) cvReprojectImageTo3D( const CvArr* disparityImage,

+ CvArr* _3dImage, const CvMat* Q,

+ int handleMissingValues CV_DEFAULT(0) );

+

+

+#ifdef __cplusplus

+}

+

+//////////////////////////////////////////////////////////////////////////////////////////

+class CV_EXPORTS CvLevMarq

+{

+public:

+ 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 };

+

+ cv::Ptr<CvMat> mask;

+ cv::Ptr<CvMat> prevParam;

+ cv::Ptr<CvMat> param;

+ cv::Ptr<CvMat> J;

+ cv::Ptr<CvMat> err;

+ cv::Ptr<CvMat> JtJ;

+ cv::Ptr<CvMat> JtJN;

+ cv::Ptr<CvMat> JtErr;

+ cv::Ptr<CvMat> JtJV;

+ cv::Ptr<CvMat> JtJW;

+ double prevErrNorm, errNorm;

+ int lambdaLg10;

+ CvTermCriteria criteria;

+ int state;

+ int iters;

+ bool completeSymmFlag;

+};

+

+namespace cv

+{

+//! converts rotation vector to rotation matrix or vice versa using Rodrigues transformation

+CV_EXPORTS_W void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=noArray());

+

+//! type of the robust estimation algorithm

+enum

+{

+ LMEDS=CV_LMEDS, //!< least-median algorithm

+ RANSAC=CV_RANSAC //!< RANSAC algorithm

+};

+

+//! computes the best-fit perspective transformation mapping srcPoints to dstPoints.

+CV_EXPORTS_W Mat findHomography( InputArray srcPoints, InputArray dstPoints,

+ int method=0, double ransacReprojThreshold=3,

+ OutputArray mask=noArray());

+

+//! variant of findHomography for backward compatibility

+CV_EXPORTS Mat findHomography( InputArray srcPoints, InputArray dstPoints,

+ OutputArray mask, int method=0, double ransacReprojThreshold=3);

+

+//! Computes RQ decomposition of 3x3 matrix

+CV_EXPORTS_W Vec3d RQDecomp3x3( InputArray src, OutputArray mtxR, OutputArray mtxQ,

+ OutputArray Qx=noArray(),

+ OutputArray Qy=noArray(),

+ OutputArray Qz=noArray());

+

+//! Decomposes the projection matrix into camera matrix and the rotation martix and the translation vector

+CV_EXPORTS_W void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix,

+ OutputArray rotMatrix, OutputArray transVect,

+ OutputArray rotMatrixX=noArray(),

+ OutputArray rotMatrixY=noArray(),

+ OutputArray rotMatrixZ=noArray(),

+ OutputArray eulerAngles=noArray() );

+

+//! computes derivatives of the matrix product w.r.t each of the multiplied matrix coefficients

+CV_EXPORTS_W void matMulDeriv( InputArray A, InputArray B,

+ OutputArray dABdA,

+ OutputArray dABdB );

+

+//! composes 2 [R|t] transformations together. Also computes the derivatives of the result w.r.t the arguments

+CV_EXPORTS_W void composeRT( InputArray rvec1, InputArray tvec1,

+ InputArray rvec2, InputArray tvec2,

+ OutputArray rvec3, OutputArray tvec3,

+ OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(),

+ OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(),

+ OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(),

+ OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray() );

+

+//! projects points from the model coordinate space to the image coordinates. Also computes derivatives of the image coordinates w.r.t the intrinsic and extrinsic camera parameters

+CV_EXPORTS_W void projectPoints( InputArray objectPoints,

+ InputArray rvec, InputArray tvec,

+ InputArray cameraMatrix, InputArray distCoeffs,

+ OutputArray imagePoints,

+ OutputArray jacobian=noArray(),

+ double aspectRatio=0 );

+

+//! computes the camera pose from a few 3D points and the corresponding projections. The outliers are not handled.

+enum

+{

+ ITERATIVE=CV_ITERATIVE,

+ EPNP=CV_EPNP,

+ P3P=CV_P3P

+};

+CV_EXPORTS_W bool solvePnP( InputArray objectPoints, InputArray imagePoints,

+ InputArray cameraMatrix, InputArray distCoeffs,

+ OutputArray rvec, OutputArray tvec,

+ bool useExtrinsicGuess=false, int flags=ITERATIVE);

+

+//! computes the camera pose from a few 3D points and the corresponding projections. The outliers are possible.

+CV_EXPORTS_W void solvePnPRansac( InputArray objectPoints,

+ InputArray imagePoints,

+ InputArray cameraMatrix,

+ InputArray distCoeffs,

+ OutputArray rvec,

+ OutputArray tvec,

+ bool useExtrinsicGuess = false,

+ int iterationsCount = 100,

+ float reprojectionError = 8.0,

+ int minInliersCount = 100,

+ OutputArray inliers = noArray(),

+ int flags = ITERATIVE);

+

+//! initializes camera matrix from a few 3D points and the corresponding projections.

+CV_EXPORTS_W Mat initCameraMatrix2D( InputArrayOfArrays objectPoints,

+ InputArrayOfArrays imagePoints,

+ Size imageSize, double aspectRatio=1. );

+

+enum { CALIB_CB_ADAPTIVE_THRESH = 1, CALIB_CB_NORMALIZE_IMAGE = 2,

+ CALIB_CB_FILTER_QUADS = 4, CALIB_CB_FAST_CHECK = 8 };

+

+//! finds checkerboard pattern of the specified size in the image

+CV_EXPORTS_W bool findChessboardCorners( InputArray image, Size patternSize,

+ OutputArray corners,

+ int flags=CALIB_CB_ADAPTIVE_THRESH+CALIB_CB_NORMALIZE_IMAGE );

+

+//! finds subpixel-accurate positions of the chessboard corners

+CV_EXPORTS bool find4QuadCornerSubpix(InputArray img, InputOutputArray corners, Size region_size);

+

+//! draws the checkerboard pattern (found or partly found) in the image

+CV_EXPORTS_W void drawChessboardCorners( InputOutputArray image, Size patternSize,

+ InputArray corners, bool patternWasFound );

+

+enum { CALIB_CB_SYMMETRIC_GRID = 1, CALIB_CB_ASYMMETRIC_GRID = 2,

+ CALIB_CB_CLUSTERING = 4 };

+

+//! finds circles' grid pattern of the specified size in the image

+CV_EXPORTS_W bool findCirclesGrid( InputArray image, Size patternSize,

+ OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID,

+ const Ptr<FeatureDetector> &blobDetector = new SimpleBlobDetector());

+

+//! the deprecated function. Use findCirclesGrid() instead of it.

+CV_EXPORTS_W bool findCirclesGridDefault( InputArray image, Size patternSize,

+ OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID );

+enum

+{

+ CALIB_USE_INTRINSIC_GUESS = CV_CALIB_USE_INTRINSIC_GUESS,

+ CALIB_FIX_ASPECT_RATIO = CV_CALIB_FIX_ASPECT_RATIO,

+ CALIB_FIX_PRINCIPAL_POINT = CV_CALIB_FIX_PRINCIPAL_POINT,

+ CALIB_ZERO_TANGENT_DIST = CV_CALIB_ZERO_TANGENT_DIST,

+ CALIB_FIX_FOCAL_LENGTH = CV_CALIB_FIX_FOCAL_LENGTH,

+ CALIB_FIX_K1 = CV_CALIB_FIX_K1,

+ CALIB_FIX_K2 = CV_CALIB_FIX_K2,

+ CALIB_FIX_K3 = CV_CALIB_FIX_K3,

+ CALIB_FIX_K4 = CV_CALIB_FIX_K4,

+ CALIB_FIX_K5 = CV_CALIB_FIX_K5,

+ CALIB_FIX_K6 = CV_CALIB_FIX_K6,

+ CALIB_RATIONAL_MODEL = CV_CALIB_RATIONAL_MODEL,

+ // only for stereo

+ CALIB_FIX_INTRINSIC = CV_CALIB_FIX_INTRINSIC,

+ CALIB_SAME_FOCAL_LENGTH = CV_CALIB_SAME_FOCAL_LENGTH,

+ // for stereo rectification

+ CALIB_ZERO_DISPARITY = CV_CALIB_ZERO_DISPARITY

+};

+

+//! finds intrinsic and extrinsic camera parameters from several fews of a known calibration pattern.

+CV_EXPORTS_W double calibrateCamera( InputArrayOfArrays objectPoints,

+ InputArrayOfArrays imagePoints,

+ Size imageSize,

+ CV_OUT InputOutputArray cameraMatrix,

+ CV_OUT InputOutputArray distCoeffs,

+ OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,

+ int flags=0, TermCriteria criteria = TermCriteria(

+ TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON) );

+

+//! computes several useful camera characteristics from the camera matrix, camera frame resolution and the physical sensor size.

+CV_EXPORTS_W void calibrationMatrixValues( InputArray cameraMatrix,

+ Size imageSize,

+ double apertureWidth,

+ double apertureHeight,

+ CV_OUT double& fovx,

+ CV_OUT double& fovy,

+ CV_OUT double& focalLength,

+ CV_OUT Point2d& principalPoint,

+ CV_OUT double& aspectRatio );

+

+//! finds intrinsic and extrinsic parameters of a stereo camera

+CV_EXPORTS_W double stereoCalibrate( InputArrayOfArrays objectPoints,

+ InputArrayOfArrays imagePoints1,

+ InputArrayOfArrays imagePoints2,

+ CV_OUT InputOutputArray cameraMatrix1,

+ CV_OUT InputOutputArray distCoeffs1,

+ CV_OUT InputOutputArray cameraMatrix2,

+ CV_OUT InputOutputArray distCoeffs2,

+ Size imageSize, OutputArray R,

+ OutputArray T, OutputArray E, OutputArray F,

+ TermCriteria criteria = TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6),

+ int flags=CALIB_FIX_INTRINSIC );

+

+

+//! computes the rectification transformation for a stereo camera from its intrinsic and extrinsic parameters

+CV_EXPORTS_W void stereoRectify( InputArray cameraMatrix1, InputArray distCoeffs1,

+ InputArray cameraMatrix2, InputArray distCoeffs2,

+ Size imageSize, InputArray R, InputArray T,

+ OutputArray R1, OutputArray R2,

+ OutputArray P1, OutputArray P2,

+ OutputArray Q, int flags=CALIB_ZERO_DISPARITY,

+ double alpha=-1, Size newImageSize=Size(),

+ CV_OUT Rect* validPixROI1=0, CV_OUT Rect* validPixROI2=0 );

+

+//! computes the rectification transformation for an uncalibrated stereo camera (zero distortion is assumed)

+CV_EXPORTS_W bool stereoRectifyUncalibrated( InputArray points1, InputArray points2,

+ InputArray F, Size imgSize,

+ OutputArray H1, OutputArray H2,

+ double threshold=5 );

+

+//! computes the rectification transformations for 3-head camera, where all the heads are on the same line.

+CV_EXPORTS_W float rectify3Collinear( InputArray cameraMatrix1, InputArray distCoeffs1,

+ InputArray cameraMatrix2, InputArray distCoeffs2,

+ InputArray cameraMatrix3, InputArray distCoeffs3,

+ InputArrayOfArrays imgpt1, InputArrayOfArrays imgpt3,

+ Size imageSize, InputArray R12, InputArray T12,

+ InputArray R13, InputArray T13,

+ OutputArray R1, OutputArray R2, OutputArray R3,

+ OutputArray P1, OutputArray P2, OutputArray P3,

+ OutputArray Q, double alpha, Size newImgSize,

+ CV_OUT Rect* roi1, CV_OUT Rect* roi2, int flags );

+

+//! returns the optimal new camera matrix

+CV_EXPORTS_W Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs,

+ Size imageSize, double alpha, Size newImgSize=Size(),

+ CV_OUT Rect* validPixROI=0, bool centerPrincipalPoint=false);

+

+//! converts point coordinates from normal pixel coordinates to homogeneous coordinates ((x,y)->(x,y,1))

+CV_EXPORTS_W void convertPointsToHomogeneous( InputArray src, OutputArray dst );

+

+//! converts point coordinates from homogeneous to normal pixel coordinates ((x,y,z)->(x/z, y/z))

+CV_EXPORTS_W void convertPointsFromHomogeneous( InputArray src, OutputArray dst );

+

+//! for backward compatibility

+CV_EXPORTS void convertPointsHomogeneous( InputArray src, OutputArray dst );

+

+//! the algorithm for finding fundamental matrix

+enum

+{

+ FM_7POINT = CV_FM_7POINT, //!< 7-point algorithm

+ FM_8POINT = CV_FM_8POINT, //!< 8-point algorithm

+ FM_LMEDS = CV_FM_LMEDS, //!< least-median algorithm

+ FM_RANSAC = CV_FM_RANSAC //!< RANSAC algorithm

+};

+

+//! finds fundamental matrix from a set of corresponding 2D points

+CV_EXPORTS_W Mat findFundamentalMat( InputArray points1, InputArray points2,

+ int method=FM_RANSAC,

+ double param1=3., double param2=0.99,

+ OutputArray mask=noArray());

+

+//! variant of findFundamentalMat for backward compatibility

+CV_EXPORTS Mat findFundamentalMat( InputArray points1, InputArray points2,

+ OutputArray mask, int method=FM_RANSAC,

+ double param1=3., double param2=0.99);

+

+//! finds coordinates of epipolar lines corresponding the specified points

+CV_EXPORTS_W void computeCorrespondEpilines( InputArray points,

+ int whichImage, InputArray F,

+ OutputArray lines );

+

+CV_EXPORTS_W void triangulatePoints( InputArray projMatr1, InputArray projMatr2,

+ InputArray projPoints1, InputArray projPoints2,

+ OutputArray points4D );

+

+CV_EXPORTS_W void correctMatches( InputArray F, InputArray points1, InputArray points2,

+ OutputArray newPoints1, OutputArray newPoints2 );

+

+template<> CV_EXPORTS void Ptr<CvStereoBMState>::delete_obj();

+

+/*!

+ Block Matching Stereo Correspondence Algorithm

+

+ The class implements BM stereo correspondence algorithm by K. Konolige.

+*/

+class CV_EXPORTS_W StereoBM

+{

+public:

+ enum { PREFILTER_NORMALIZED_RESPONSE = 0, PREFILTER_XSOBEL = 1,

+ BASIC_PRESET=0, FISH_EYE_PRESET=1, NARROW_PRESET=2 };

+

+ //! the default constructor

+ CV_WRAP StereoBM();

+ //! the full constructor taking the camera-specific preset, number of disparities and the SAD window size

+ CV_WRAP StereoBM(int preset, int ndisparities=0, int SADWindowSize=21);

+ //! the method that reinitializes the state. The previous content is destroyed

+ void init(int preset, int ndisparities=0, int SADWindowSize=21);

+ //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair

+ CV_WRAP_AS(compute) void operator()( InputArray left, InputArray right,

+ OutputArray disparity, int disptype=CV_16S );

+

+ //! pointer to the underlying CvStereoBMState

+ Ptr<CvStereoBMState> state;

+};

+

+

+/*!

+ Semi-Global Block Matching Stereo Correspondence Algorithm

+

+ The class implements the original SGBM stereo correspondence algorithm by H. Hirschmuller and some its modification.

+ */

+class CV_EXPORTS_W StereoSGBM

+{

+public:

+ enum { DISP_SHIFT=4, DISP_SCALE = (1<<DISP_SHIFT) };

+

+ //! the default constructor

+ CV_WRAP StereoSGBM();

+

+ //! the full constructor taking all the necessary algorithm parameters

+ CV_WRAP StereoSGBM(int minDisparity, int numDisparities, int SADWindowSize,

+ int P1=0, int P2=0, int disp12MaxDiff=0,

+ int preFilterCap=0, int uniquenessRatio=0,

+ int speckleWindowSize=0, int speckleRange=0,

+ bool fullDP=false);

+ //! the destructor

+ virtual ~StereoSGBM();

+

+ //! the stereo correspondence operator that computes disparity map for the specified rectified stereo pair

+ CV_WRAP_AS(compute) virtual void operator()(InputArray left, InputArray right,

+ OutputArray disp);

+

+ CV_PROP_RW int minDisparity;

+ CV_PROP_RW int numberOfDisparities;

+ CV_PROP_RW int SADWindowSize;

+ CV_PROP_RW int preFilterCap;

+ CV_PROP_RW int uniquenessRatio;

+ CV_PROP_RW int P1;

+ CV_PROP_RW int P2;

+ CV_PROP_RW int speckleWindowSize;

+ CV_PROP_RW int speckleRange;

+ CV_PROP_RW int disp12MaxDiff;

+ CV_PROP_RW bool fullDP;

+

+protected:

+ Mat buffer;

+};

+

+//! filters off speckles (small regions of incorrectly computed disparity)

+CV_EXPORTS_W void filterSpeckles( InputOutputArray img, double newVal, int maxSpeckleSize, double maxDiff,

+ InputOutputArray buf=noArray() );

+

+//! computes valid disparity ROI from the valid ROIs of the rectified images (that are returned by cv::stereoRectify())

+CV_EXPORTS_W Rect getValidDisparityROI( Rect roi1, Rect roi2,

+ int minDisparity, int numberOfDisparities,

+ int SADWindowSize );

+

+//! validates disparity using the left-right check. The matrix "cost" should be computed by the stereo correspondence algorithm

+CV_EXPORTS_W void validateDisparity( InputOutputArray disparity, InputArray cost,

+ int minDisparity, int numberOfDisparities,

+ int disp12MaxDisp=1 );

+

+//! reprojects disparity image to 3D: (x,y,d)->(X,Y,Z) using the matrix Q returned by cv::stereoRectify

+CV_EXPORTS_W void reprojectImageTo3D( InputArray disparity,

+ OutputArray _3dImage, InputArray Q,

+ bool handleMissingValues=false,

+ int ddepth=-1 );

+

+CV_EXPORTS_W int estimateAffine3D(InputArray src, InputArray dst,

+ OutputArray out, OutputArray inliers,

+ double ransacThreshold=3, double confidence=0.99);

+

+namespace fisheye

+{

+ enum{

+ CALIB_USE_INTRINSIC_GUESS = 1,

+ CALIB_RECOMPUTE_EXTRINSIC = 2,

+ CALIB_CHECK_COND = 4,

+ CALIB_FIX_SKEW = 8,

+ CALIB_FIX_K1 = 16,

+ CALIB_FIX_K2 = 32,

+ CALIB_FIX_K3 = 64,

+ CALIB_FIX_K4 = 128,

+ CALIB_FIX_INTRINSIC = 256

+ };

+

+ //! projects 3D points using fisheye model

+ CV_EXPORTS void projectPoints(InputArray objectPoints, OutputArray imagePoints, const Affine3d& affine,

+ InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());

+

+ //! projects points using fisheye model

+ CV_EXPORTS void projectPoints(InputArray objectPoints, OutputArray imagePoints, InputArray rvec, InputArray tvec,

+ InputArray K, InputArray D, double alpha = 0, OutputArray jacobian = noArray());

+

+ //! distorts 2D points using fisheye model

+ CV_EXPORTS void distortPoints(InputArray undistorted, OutputArray distorted, InputArray K, InputArray D, double alpha = 0);

+

+ //! undistorts 2D points using fisheye model

+ CV_EXPORTS void undistortPoints(InputArray distorted, OutputArray undistorted,

+ InputArray K, InputArray D, InputArray R = noArray(), InputArray P = noArray());

+

+ //! computing undistortion and rectification maps for image transform by cv::remap()

+ //! If D is empty zero distortion is used, if R or P is empty identity matrixes are used

+ CV_EXPORTS void initUndistortRectifyMap(InputArray K, InputArray D, InputArray R, InputArray P,

+ const cv::Size& size, int m1type, OutputArray map1, OutputArray map2);

+

+ //! undistorts image, optionally changes resolution and camera matrix. If Knew zero identity matrix is used

+ CV_EXPORTS void undistortImage(InputArray distorted, OutputArray undistorted,

+ InputArray K, InputArray D, InputArray Knew = cv::noArray(), const Size& new_size = Size());

+

+ //! estimates new camera matrix for undistortion or rectification

+ CV_EXPORTS void estimateNewCameraMatrixForUndistortRectify(InputArray K, InputArray D, const Size &image_size, InputArray R,

+ OutputArray P, double balance = 0.0, const Size& new_size = Size(), double fov_scale = 1.0);

+

+ //! performs camera calibaration

+ CV_EXPORTS double calibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, const Size& image_size,

+ InputOutputArray K, InputOutputArray D, OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs, int flags = 0,

+ TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));

+

+ //! stereo rectification estimation

+ CV_EXPORTS void stereoRectify(InputArray K1, InputArray D1, InputArray K2, InputArray D2, const Size &imageSize, InputArray R, InputArray tvec,

+ OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags, const Size &newImageSize = Size(),

+ double balance = 0.0, double fov_scale = 1.0);

+

+ //! performs stereo calibaration

+ CV_EXPORTS double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2,

+ InputOutputArray K1, InputOutputArray D1, InputOutputArray K2, InputOutputArray D2, Size imageSize,

+ OutputArray R, OutputArray T, int flags = CALIB_FIX_INTRINSIC,

+ TermCriteria criteria = TermCriteria(TermCriteria::COUNT + TermCriteria::EPS, 100, DBL_EPSILON));

+

+}

+

+}

+

+#endif

+#endif

+/*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.

+//

+//

+// 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.

+//

+//M*/

+

+#ifndef __OPENCV_CONTRIB_HPP__

+#define __OPENCV_CONTRIB_HPP__

+

+#include "opencv2/core/core.hpp"

+#include "opencv2/imgproc/imgproc.hpp"

+#include "opencv2/features2d/features2d.hpp"

+#include "opencv2/objdetect/objdetect.hpp"

+

+#ifdef __cplusplus

+

+/****************************************************************************************\

+* Adaptive Skin Detector *

+\****************************************************************************************/

+

+class CV_EXPORTS CvAdaptiveSkinDetector

+{

+private:

+ enum {

+ GSD_HUE_LT = 3,

+ GSD_HUE_UT = 33,

+ GSD_INTENSITY_LT = 15,

+ GSD_INTENSITY_UT = 250

+ };

+

+ class CV_EXPORTS Histogram

+ {

+ private:

+ enum {

+ HistogramSize = (GSD_HUE_UT - GSD_HUE_LT + 1)

+ };

+

+ protected:

+ int findCoverageIndex(double surfaceToCover, int defaultValue = 0);

+

+ public:

+ CvHistogram *fHistogram;

+ Histogram();

+ virtual ~Histogram();

+

+ void findCurveThresholds(int &x1, int &x2, double percent = 0.05);

+ void mergeWith(Histogram *source, double weight);

+ };

+

+ int nStartCounter, nFrameCount, nSkinHueLowerBound, nSkinHueUpperBound, nMorphingMethod, nSamplingDivider;

+ double fHistogramMergeFactor, fHuePercentCovered;

+ Histogram histogramHueMotion, skinHueHistogram;

+ IplImage *imgHueFrame, *imgSaturationFrame, *imgLastGrayFrame, *imgMotionFrame, *imgFilteredFrame;

+ IplImage *imgShrinked, *imgTemp, *imgGrayFrame, *imgHSVFrame;

+

+protected:

+ void initData(IplImage *src, int widthDivider, int heightDivider);

+ void adaptiveFilter();

+

+public:

+

+ enum {

+ MORPHING_METHOD_NONE = 0,

+ MORPHING_METHOD_ERODE = 1,

+ MORPHING_METHOD_ERODE_ERODE = 2,

+ MORPHING_METHOD_ERODE_DILATE = 3

+ };

+

+ CvAdaptiveSkinDetector(int samplingDivider = 1, int morphingMethod = MORPHING_METHOD_NONE);

+ virtual ~CvAdaptiveSkinDetector();

+

+ virtual void process(IplImage *inputBGRImage, IplImage *outputHueMask);

+};

+

+

+/****************************************************************************************\

+ * Fuzzy MeanShift Tracker *

+ \****************************************************************************************/

+

+class CV_EXPORTS CvFuzzyPoint {

+public:

+ double x, y, value;

+

+ CvFuzzyPoint(double _x, double _y);

+};

+

+class CV_EXPORTS CvFuzzyCurve {

+private:

+ std::vector<CvFuzzyPoint> points;

+ double value, centre;

+

+ bool between(double x, double x1, double x2);

+

+public:

+ CvFuzzyCurve();

+ ~CvFuzzyCurve();

+

+ void setCentre(double _centre);

+ double getCentre();

+ void clear();

+ void addPoint(double x, double y);

+ double calcValue(double param);

+ double getValue();

+ void setValue(double _value);

+};

+

+class CV_EXPORTS CvFuzzyFunction {

+public:

+ std::vector<CvFuzzyCurve> curves;

+

+ CvFuzzyFunction();

+ ~CvFuzzyFunction();

+ void addCurve(CvFuzzyCurve *curve, double value = 0);

+ void resetValues();

+ double calcValue();

+ CvFuzzyCurve *newCurve();

+};

+

+class CV_EXPORTS CvFuzzyRule {

+private:

+ CvFuzzyCurve *fuzzyInput1, *fuzzyInput2;

+ CvFuzzyCurve *fuzzyOutput;

+public:

+ CvFuzzyRule();

+ ~CvFuzzyRule();

+ void setRule(CvFuzzyCurve *c1, CvFuzzyCurve *c2, CvFuzzyCurve *o1);

+ double calcValue(double param1, double param2);

+ CvFuzzyCurve *getOutputCurve();

+};

+

+class CV_EXPORTS CvFuzzyController {

+private:

+ std::vector<CvFuzzyRule*> rules;

+public:

+ CvFuzzyController();

+ ~CvFuzzyController();

+ void addRule(CvFuzzyCurve *c1, CvFuzzyCurve *c2, CvFuzzyCurve *o1);

+ double calcOutput(double param1, double param2);

+};

+

+class CV_EXPORTS CvFuzzyMeanShiftTracker

+{

+private:

+ class FuzzyResizer

+ {

+ private:

+ CvFuzzyFunction iInput, iOutput;

+ CvFuzzyController fuzzyController;

+ public:

+ FuzzyResizer();

+ int calcOutput(double edgeDensity, double density);

+ };

+

+ class SearchWindow

+ {

+ public:

+ FuzzyResizer *fuzzyResizer;

+ int x, y;

+ int width, height, maxWidth, maxHeight, ellipseHeight, ellipseWidth;

+ int ldx, ldy, ldw, ldh, numShifts, numIters;

+ int xGc, yGc;

+ long m00, m01, m10, m11, m02, m20;

+ double ellipseAngle;

+ double density;

+ unsigned int depthLow, depthHigh;

+ int verticalEdgeLeft, verticalEdgeRight, horizontalEdgeTop, horizontalEdgeBottom;

+

+ SearchWindow();

+ ~SearchWindow();

+ void setSize(int _x, int _y, int _width, int _height);

+ void initDepthValues(IplImage *maskImage, IplImage *depthMap);

+ bool shift();

+ void extractInfo(IplImage *maskImage, IplImage *depthMap, bool initDepth);

+ void getResizeAttribsEdgeDensityLinear(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh);

+ void getResizeAttribsInnerDensity(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh);

+ void getResizeAttribsEdgeDensityFuzzy(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh);

+ bool meanShift(IplImage *maskImage, IplImage *depthMap, int maxIteration, bool initDepth);

+ };

+

+public:

+ enum TrackingState

+ {

+ tsNone = 0,

+ tsSearching = 1,

+ tsTracking = 2,

+ tsSetWindow = 3,

+ tsDisabled = 10

+ };

+

+ enum ResizeMethod {

+ rmEdgeDensityLinear = 0,

+ rmEdgeDensityFuzzy = 1,

+ rmInnerDensity = 2

+ };

+

+ enum {

+ MinKernelMass = 1000

+ };

+

+ SearchWindow kernel;

+ int searchMode;

+

+private:

+ enum

+ {

+ MaxMeanShiftIteration = 5,

+ MaxSetSizeIteration = 5

+ };

+

+ void findOptimumSearchWindow(SearchWindow &searchWindow, IplImage *maskImage, IplImage *depthMap, int maxIteration, int resizeMethod, bool initDepth);

+

+public:

+ CvFuzzyMeanShiftTracker();

+ ~CvFuzzyMeanShiftTracker();

+

+ void track(IplImage *maskImage, IplImage *depthMap, int resizeMethod, bool resetSearch, int minKernelMass = MinKernelMass);

+};

+

+

+namespace cv

+{

+

+ class CV_EXPORTS Octree

+ {

+ public:

+ struct Node

+ {

+ Node() {}

+ int begin, end;

+ float x_min, x_max, y_min, y_max, z_min, z_max;

+ int maxLevels;

+ bool isLeaf;

+ int children[8];

+ };

+

+ Octree();

+ Octree( const vector<Point3f>& points, int maxLevels = 10, int minPoints = 20 );

+ virtual ~Octree();

+

+ virtual void buildTree( const vector<Point3f>& points, int maxLevels = 10, int minPoints = 20 );

+ virtual void getPointsWithinSphere( const Point3f& center, float radius,

+ vector<Point3f>& points ) const;

+ const vector<Node>& getNodes() const { return nodes; }

+ private:

+ int minPoints;

+ vector<Point3f> points;

+ vector<Node> nodes;

+

+ virtual void buildNext(size_t node_ind);

+ };

+

+

+ class CV_EXPORTS Mesh3D

+ {

+ public:

+ struct EmptyMeshException {};

+

+ Mesh3D();

+ Mesh3D(const vector<Point3f>& vtx);

+ ~Mesh3D();

+

+ void buildOctree();

+ void clearOctree();

+ float estimateResolution(float tryRatio = 0.1f);

+ void computeNormals(float normalRadius, int minNeighbors = 20);

+ void computeNormals(const vector<int>& subset, float normalRadius, int minNeighbors = 20);

+

+ void writeAsVrml(const String& file, const vector<Scalar>& colors = vector<Scalar>()) const;

+

+ vector<Point3f> vtx;

+ vector<Point3f> normals;

+ float resolution;

+ Octree octree;

+

+ const static Point3f allzero;

+ };

+

+ class CV_EXPORTS SpinImageModel

+ {

+ public:

+

+ /* model parameters, leave unset for default or auto estimate */

+ float normalRadius;

+ int minNeighbors;

+

+ float binSize;

+ int imageWidth;

+

+ float lambda;

+ float gamma;

+

+ float T_GeometriccConsistency;

+ float T_GroupingCorespondances;

+

+ /* public interface */

+ SpinImageModel();

+ explicit SpinImageModel(const Mesh3D& mesh);

+ ~SpinImageModel();

+

+ void setLogger(std::ostream* log);

+ void selectRandomSubset(float ratio);

+ void setSubset(const vector<int>& subset);

+ void compute();

+

+ void match(const SpinImageModel& scene, vector< vector<Vec2i> >& result);

+

+ Mat packRandomScaledSpins(bool separateScale = false, size_t xCount = 10, size_t yCount = 10) const;

+

+ size_t getSpinCount() const { return spinImages.rows; }

+ Mat getSpinImage(size_t index) const { return spinImages.row((int)index); }

+ const Point3f& getSpinVertex(size_t index) const { return mesh.vtx[subset[index]]; }

+ const Point3f& getSpinNormal(size_t index) const { return mesh.normals[subset[index]]; }

+

+ const Mesh3D& getMesh() const { return mesh; }

+ Mesh3D& getMesh() { return mesh; }

+

+ /* static utility functions */

+ static bool spinCorrelation(const Mat& spin1, const Mat& spin2, float lambda, float& result);

+

+ static Point2f calcSpinMapCoo(const Point3f& point, const Point3f& vertex, const Point3f& normal);

+

+ static float geometricConsistency(const Point3f& pointScene1, const Point3f& normalScene1,

+ const Point3f& pointModel1, const Point3f& normalModel1,

+ const Point3f& pointScene2, const Point3f& normalScene2,

+ const Point3f& pointModel2, const Point3f& normalModel2);

+

+ static float groupingCreteria(const Point3f& pointScene1, const Point3f& normalScene1,

+ const Point3f& pointModel1, const Point3f& normalModel1,

+ const Point3f& pointScene2, const Point3f& normalScene2,

+ const Point3f& pointModel2, const Point3f& normalModel2,

+ float gamma);

+ protected:

+ void defaultParams();

+

+ void matchSpinToModel(const Mat& spin, vector<int>& indeces,

+ vector<float>& corrCoeffs, bool useExtremeOutliers = true) const;

+

+ void repackSpinImages(const vector<uchar>& mask, Mat& spinImages, bool reAlloc = true) const;

+

+ vector<int> subset;

+ Mesh3D mesh;

+ Mat spinImages;

+ std::ostream* out;

+ };

+

+ class CV_EXPORTS TickMeter

+ {

+ public:

+ TickMeter();

+ void start();

+ void stop();

+

+ int64 getTimeTicks() const;

+ double getTimeMicro() const;

+ double getTimeMilli() const;

+ double getTimeSec() const;

+ int64 getCounter() const;

+

+ void reset();

+ private:

+ int64 counter;

+ int64 sumTime;

+ int64 startTime;

+ };

+

+ CV_EXPORTS std::ostream& operator<<(std::ostream& out, const TickMeter& tm);

+

+ class CV_EXPORTS SelfSimDescriptor

+ {

+ public:

+ SelfSimDescriptor();

+ SelfSimDescriptor(int _ssize, int _lsize,

+ int _startDistanceBucket=DEFAULT_START_DISTANCE_BUCKET,

+ int _numberOfDistanceBuckets=DEFAULT_NUM_DISTANCE_BUCKETS,

+ int _nangles=DEFAULT_NUM_ANGLES);

+ SelfSimDescriptor(const SelfSimDescriptor& ss);

+ virtual ~SelfSimDescriptor();

+ SelfSimDescriptor& operator = (const SelfSimDescriptor& ss);

+

+ size_t getDescriptorSize() const;

+ Size getGridSize( Size imgsize, Size winStride ) const;

+

+ virtual void compute(const Mat& img, vector<float>& descriptors, Size winStride=Size(),

+ const vector<Point>& locations=vector<Point>()) const;

+ virtual void computeLogPolarMapping(Mat& mappingMask) const;

+ virtual void SSD(const Mat& img, Point pt, Mat& ssd) const;

+

+ int smallSize;

+ int largeSize;

+ int startDistanceBucket;

+ int numberOfDistanceBuckets;

+ int numberOfAngles;

+

+ enum { DEFAULT_SMALL_SIZE = 5, DEFAULT_LARGE_SIZE = 41,

+ DEFAULT_NUM_ANGLES = 20, DEFAULT_START_DISTANCE_BUCKET = 3,

+ DEFAULT_NUM_DISTANCE_BUCKETS = 7 };

+ };

+

+

+ typedef bool (*BundleAdjustCallback)(int iteration, double norm_error, void* user_data);

+

+ class CV_EXPORTS LevMarqSparse {

+ public:

+ LevMarqSparse();

+ LevMarqSparse(int npoints, // number of points

+ int ncameras, // number of cameras

+ int nPointParams, // number of params per one point (3 in case of 3D points)

+ int nCameraParams, // number of parameters per one camera

+ int nErrParams, // number of parameters in measurement vector

+ // for 1 point at one camera (2 in case of 2D projections)

+ Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras

+ // 1 - point is visible for the camera, 0 - invisible

+ Mat& P0, // starting vector of parameters, first cameras then points

+ Mat& X, // measurements, in order of visibility. non visible cases are skipped

+ TermCriteria criteria, // termination criteria

+

+ // callback for estimation of Jacobian matrices

+ void (CV_CDECL * fjac)(int i, int j, Mat& point_params,

+ Mat& cam_params, Mat& A, Mat& B, void* data),

+ // callback for estimation of backprojection errors

+ void (CV_CDECL * func)(int i, int j, Mat& point_params,

+ Mat& cam_params, Mat& estim, void* data),

+ void* data, // user-specific data passed to the callbacks

+ BundleAdjustCallback cb, void* user_data

+ );

+

+ virtual ~LevMarqSparse();

+

+ virtual void run( int npoints, // number of points

+ int ncameras, // number of cameras

+ int nPointParams, // number of params per one point (3 in case of 3D points)

+ int nCameraParams, // number of parameters per one camera

+ int nErrParams, // number of parameters in measurement vector

+ // for 1 point at one camera (2 in case of 2D projections)

+ Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras

+ // 1 - point is visible for the camera, 0 - invisible

+ Mat& P0, // starting vector of parameters, first cameras then points

+ Mat& X, // measurements, in order of visibility. non visible cases are skipped

+ TermCriteria criteria, // termination criteria

+

+ // callback for estimation of Jacobian matrices

+ void (CV_CDECL * fjac)(int i, int j, Mat& point_params,

+ Mat& cam_params, Mat& A, Mat& B, void* data),

+ // callback for estimation of backprojection errors

+ void (CV_CDECL * func)(int i, int j, Mat& point_params,

+ Mat& cam_params, Mat& estim, void* data),

+ void* data // user-specific data passed to the callbacks

+ );

+

+ virtual void clear();

+

+ // useful function to do simple bundle adjustment tasks

+ static void bundleAdjust(vector<Point3d>& points, // positions of points in global coordinate system (input and output)

+ const vector<vector<Point2d> >& imagePoints, // projections of 3d points for every camera

+ const vector<vector<int> >& visibility, // visibility of 3d points for every camera

+ vector<Mat>& cameraMatrix, // intrinsic matrices of all cameras (input and output)

+ vector<Mat>& R, // rotation matrices of all cameras (input and output)

+ vector<Mat>& T, // translation vector of all cameras (input and output)

+ vector<Mat>& distCoeffs, // distortion coefficients of all cameras (input and output)

+ const TermCriteria& criteria=

+ TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON),

+ BundleAdjustCallback cb = 0, void* user_data = 0);

+

+ public:

+ virtual void optimize(CvMat &_vis); //main function that runs minimization

+

+ //iteratively asks for measurement for visible camera-point pairs

+ void ask_for_proj(CvMat &_vis,bool once=false);

+ //iteratively asks for Jacobians for every camera_point pair

+ void ask_for_projac(CvMat &_vis);

+

+ CvMat* err; //error X-hX

+ double prevErrNorm, errNorm;

+ double lambda;

+ CvTermCriteria criteria;

+ int iters;

+

+ CvMat** U; //size of array is equal to number of cameras

+ CvMat** V; //size of array is equal to number of points

+ CvMat** inv_V_star; //inverse of V*

+

+ CvMat** A;

+ CvMat** B;

+ CvMat** W;

+

+ CvMat* X; //measurement

+ CvMat* hX; //current measurement extimation given new parameter vector

+

+ CvMat* prevP; //current already accepted parameter.

+ CvMat* P; // parameters used to evaluate function with new params

+ // this parameters may be rejected

+

+ CvMat* deltaP; //computed increase of parameters (result of normal system solution )

+

+ CvMat** ea; // sum_i AijT * e_ij , used as right part of normal equation

+ // length of array is j = number of cameras

+ CvMat** eb; // sum_j BijT * e_ij , used as right part of normal equation

+ // length of array is i = number of points

+

+ CvMat** Yj; //length of array is i = num_points

+

+ CvMat* S; //big matrix of block Sjk , each block has size num_cam_params x num_cam_params

+

+ CvMat* JtJ_diag; //diagonal of JtJ, used to backup diagonal elements before augmentation

+

+ CvMat* Vis_index; // matrix which element is index of measurement for point i and camera j

+

+ int num_cams;

+ int num_points;

+ int num_err_param;

+ int num_cam_param;

+ int num_point_param;

+

+ //target function and jacobian pointers, which needs to be initialized

+ void (*fjac)(int i, int j, Mat& point_params, Mat& cam_params, Mat& A, Mat& B, void* data);

+ void (*func)(int i, int j, Mat& point_params, Mat& cam_params, Mat& estim, void* data);

+

+ void* data;

+

+ BundleAdjustCallback cb;

+ void* user_data;

+ };

+

+ CV_EXPORTS_W int chamerMatching( Mat& img, Mat& templ,

+ CV_OUT vector<vector<Point> >& results, CV_OUT vector<float>& cost,

+ double templScale=1, int maxMatches = 20,

+ double minMatchDistance = 1.0, int padX = 3,

+ int padY = 3, int scales = 5, double minScale = 0.6, double maxScale = 1.6,

+ double orientationWeight = 0.5, double truncate = 20);

+

+

+ class CV_EXPORTS_W StereoVar

+ {

+ public:

+ // Flags

+ enum {USE_INITIAL_DISPARITY = 1, USE_EQUALIZE_HIST = 2, USE_SMART_ID = 4, USE_AUTO_PARAMS = 8, USE_MEDIAN_FILTERING = 16};

+ enum {CYCLE_O, CYCLE_V};

+ enum {PENALIZATION_TICHONOV, PENALIZATION_CHARBONNIER, PENALIZATION_PERONA_MALIK};

+

+ //! the default constructor

+ CV_WRAP StereoVar();

+

+ //! the full constructor taking all the necessary algorithm parameters

+ CV_WRAP StereoVar(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags);

+

+ //! the destructor

+ virtual ~StereoVar();

+

+ //! the stereo correspondence operator that computes disparity map for the specified rectified stereo pair

+ CV_WRAP_AS(compute) virtual void operator()(const Mat& left, const Mat& right, CV_OUT Mat& disp);

+

+ CV_PROP_RW int levels;

+ CV_PROP_RW double pyrScale;

+ CV_PROP_RW int nIt;

+ CV_PROP_RW int minDisp;

+ CV_PROP_RW int maxDisp;

+ CV_PROP_RW int poly_n;

+ CV_PROP_RW double poly_sigma;

+ CV_PROP_RW float fi;

+ CV_PROP_RW float lambda;

+ CV_PROP_RW int penalization;

+ CV_PROP_RW int cycle;

+ CV_PROP_RW int flags;

+

+ private:

+ void autoParams();

+ void FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level);

+ void VCycle_MyFAS(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level);

+ void VariationalSolver(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level);

+ };

+

+ CV_EXPORTS void polyfit(const Mat& srcx, const Mat& srcy, Mat& dst, int order);

+

+ class CV_EXPORTS Directory

+ {

+ public:

+ static std::vector<std::string> GetListFiles ( const std::string& path, const std::string & exten = "*", bool addPath = true );

+ static std::vector<std::string> GetListFilesR ( const std::string& path, const std::string & exten = "*", bool addPath = true );

+ static std::vector<std::string> GetListFolders( const std::string& path, const std::string & exten = "*", bool addPath = true );

+ };

+

+ /*

+ * Generation of a set of different colors by the following way:

+ * 1) generate more then need colors (in "factor" times) in RGB,

+ * 2) convert them to Lab,

+ * 3) choose the needed count of colors from the set that are more different from

+ * each other,

+ * 4) convert the colors back to RGB

+ */

+ CV_EXPORTS void generateColors( std::vector<Scalar>& colors, size_t count, size_t factor=100 );

+

+

+ /*

+ * Estimate the rigid body motion from frame0 to frame1. The method is based on the paper

+ * "Real-Time Visual Odometry from Dense RGB-D Images", F. Steinbucker, J. Strum, D. Cremers, ICCV, 2011.

+ */

+ enum { ROTATION = 1,

+ TRANSLATION = 2,

+ RIGID_BODY_MOTION = 4

+ };

+ CV_EXPORTS bool RGBDOdometry( Mat& Rt, const Mat& initRt,

+ const Mat& image0, const Mat& depth0, const Mat& mask0,

+ const Mat& image1, const Mat& depth1, const Mat& mask1,

+ const Mat& cameraMatrix, float minDepth=0.f, float maxDepth=4.f, float maxDepthDiff=0.07f,

+ const std::vector<int>& iterCounts=std::vector<int>(),

+ const std::vector<float>& minGradientMagnitudes=std::vector<float>(),

+ int transformType=RIGID_BODY_MOTION );

+

+ /**

+ *Bilinear interpolation technique.

+ *

+ *The value of a desired cortical pixel is obtained through a bilinear interpolation of the values

+ *of the four nearest neighbouring Cartesian pixels to the center of the RF.

+ *The same principle is applied to the inverse transformation.

+ *

+ *More details can be found in http://dx.doi.org/10.1007/978-3-642-23968-7_5

+ */

+ class CV_EXPORTS LogPolar_Interp

+ {

+ public:

+

+ LogPolar_Interp() {}

+

+ /**

+ *Constructor

+ *\param w the width of the input image

+ *\param h the height of the input image

+ *\param center the transformation center: where the output precision is maximal

+ *\param R the number of rings of the cortical image (default value 70 pixel)

+ *\param ro0 the radius of the blind spot (default value 3 pixel)

+ *\param interp interpolation algorithm

+ *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.

+ * \a 0 means that the retinal image is computed within the inscribed circle.

+ *\param S the number of sectors of the cortical image (default value 70 pixel).

+ * Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.

+ *\param sp \a 1 (default value) means that the parameter \a S is internally computed.

+ * \a 0 means that the parameter \a S is provided by the user.

+ */

+ LogPolar_Interp(int w, int h, Point2i center, int R=70, double ro0=3.0,

+ int interp=INTER_LINEAR, int full=1, int S=117, int sp=1);

+ /**

+ *Transformation from Cartesian image to cortical (log-polar) image.

+ *\param source the Cartesian image

+ *\return the transformed image (cortical image)

+ */

+ const Mat to_cortical(const Mat &source);

+ /**

+ *Transformation from cortical image to retinal (inverse log-polar) image.

+ *\param source the cortical image

+ *\return the transformed image (retinal image)

+ */

+ const Mat to_cartesian(const Mat &source);

+ /**

+ *Destructor

+ */

+ ~LogPolar_Interp();

+

+ protected:

+

+ Mat Rsri;

+ Mat Csri;

+

+ int S, R, M, N;

+ int top, bottom,left,right;

+ double ro0, romax, a, q;

+ int interp;

+

+ Mat ETAyx;

+ Mat CSIyx;

+

+ void create_map(int M, int N, int R, int S, double ro0);

+ };

+

+ /**

+ *Overlapping circular receptive fields technique

+ *

+ *The Cartesian plane is divided in two regions: the fovea and the periphery.

+ *The fovea (oversampling) is handled by using the bilinear interpolation technique described above, whereas in

+ *the periphery we use the overlapping Gaussian circular RFs.

+ *

+ *More details can be found in http://dx.doi.org/10.1007/978-3-642-23968-7_5

+ */

+ class CV_EXPORTS LogPolar_Overlapping

+ {

+ public:

+ LogPolar_Overlapping() {}

+

+ /**

+ *Constructor

+ *\param w the width of the input image

+ *\param h the height of the input image

+ *\param center the transformation center: where the output precision is maximal

+ *\param R the number of rings of the cortical image (default value 70 pixel)

+ *\param ro0 the radius of the blind spot (default value 3 pixel)

+ *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.

+ * \a 0 means that the retinal image is computed within the inscribed circle.

+ *\param S the number of sectors of the cortical image (default value 70 pixel).

+ * Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.

+ *\param sp \a 1 (default value) means that the parameter \a S is internally computed.

+ * \a 0 means that the parameter \a S is provided by the user.

+ */

+ LogPolar_Overlapping(int w, int h, Point2i center, int R=70,

+ double ro0=3.0, int full=1, int S=117, int sp=1);

+ /**

+ *Transformation from Cartesian image to cortical (log-polar) image.

+ *\param source the Cartesian image

+ *\return the transformed image (cortical image)

+ */

+ const Mat to_cortical(const Mat &source);

+ /**

+ *Transformation from cortical image to retinal (inverse log-polar) image.

+ *\param source the cortical image

+ *\return the transformed image (retinal image)

+ */

+ const Mat to_cartesian(const Mat &source);

+ /**

+ *Destructor

+ */

+ ~LogPolar_Overlapping();

+

+ protected:

+

+ Mat Rsri;

+ Mat Csri;

+ vector<int> Rsr;

+ vector<int> Csr;

+ vector<double> Wsr;

+

+ int S, R, M, N, ind1;

+ int top, bottom,left,right;

+ double ro0, romax, a, q;

+

+ struct kernel

+ {

+ kernel() { w = 0; }

+ vector<double> weights;

+ int w;

+ };

+

+ Mat ETAyx;

+ Mat CSIyx;

+ vector<kernel> w_ker_2D;

+

+ void create_map(int M, int N, int R, int S, double ro0);

+ };

+

+ /**

+ * Adjacent receptive fields technique

+ *

+ *All the Cartesian pixels, whose coordinates in the cortical domain share the same integer part, are assigned to the same RF.

+ *The precision of the boundaries of the RF can be improved by breaking each pixel into subpixels and assigning each of them to the correct RF.

+ *This technique is implemented from: Traver, V., Pla, F.: Log-polar mapping template design: From task-level requirements

+ *to geometry parameters. Image Vision Comput. 26(10) (2008) 1354-1370

+ *

+ *More details can be found in http://dx.doi.org/10.1007/978-3-642-23968-7_5

+ */

+ class CV_EXPORTS LogPolar_Adjacent

+ {

+ public:

+ LogPolar_Adjacent() {}

+

+ /**

+ *Constructor

+ *\param w the width of the input image

+ *\param h the height of the input image

+ *\param center the transformation center: where the output precision is maximal

+ *\param R the number of rings of the cortical image (default value 70 pixel)

+ *\param ro0 the radius of the blind spot (default value 3 pixel)

+ *\param smin the size of the subpixel (default value 0.25 pixel)

+ *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.

+ * \a 0 means that the retinal image is computed within the inscribed circle.

+ *\param S the number of sectors of the cortical image (default value 70 pixel).

+ * Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.

+ *\param sp \a 1 (default value) means that the parameter \a S is internally computed.

+ * \a 0 means that the parameter \a S is provided by the user.

+ */

+ LogPolar_Adjacent(int w, int h, Point2i center, int R=70, double ro0=3.0, double smin=0.25, int full=1, int S=117, int sp=1);

+ /**

+ *Transformation from Cartesian image to cortical (log-polar) image.

+ *\param source the Cartesian image

+ *\return the transformed image (cortical image)

+ */

+ const Mat to_cortical(const Mat &source);

+ /**

+ *Transformation from cortical image to retinal (inverse log-polar) image.

+ *\param source the cortical image

+ *\return the transformed image (retinal image)

+ */

+ const Mat to_cartesian(const Mat &source);

+ /**

+ *Destructor

+ */

+ ~LogPolar_Adjacent();

+

+ protected:

+ struct pixel

+ {

+ pixel() { u = v = 0; a = 0.; }

+ int u;

+ int v;

+ double a;

+ };

+ int S, R, M, N;

+ int top, bottom,left,right;

+ double ro0, romax, a, q;

+ vector<vector<pixel> > L;

+ vector<double> A;

+

+ void subdivide_recursively(double x, double y, int i, int j, double length, double smin);

+ bool get_uv(double x, double y, int&u, int&v);

+ void create_map(int M, int N, int R, int S, double ro0, double smin);

+ };

+

+ CV_EXPORTS Mat subspaceProject(InputArray W, InputArray mean, InputArray src);

+ CV_EXPORTS Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src);

+

+ class CV_EXPORTS LDA

+ {

+ public:

+ // Initializes a LDA with num_components (default 0).

+ LDA(int num_components = 0) :

+ _num_components(num_components) {};

+

+ // Initializes and performs a Discriminant Analysis with Fisher's

+ // Optimization Criterion on given data in src and corresponding labels

+ // in labels. If 0 (or less) number of components are given, they are

+ // automatically determined for given data in computation.

+ LDA(const Mat& src, vector<int> labels,

+ int num_components = 0) :

+ _num_components(num_components)

+ {

+ this->compute(src, labels); //! compute eigenvectors and eigenvalues

+ }

+

+ // Initializes and performs a Discriminant Analysis with Fisher's

+ // Optimization Criterion on given data in src and corresponding labels

+ // in labels. If 0 (or less) number of components are given, they are

+ // automatically determined for given data in computation.

+ LDA(InputArrayOfArrays src, InputArray labels,

+ int num_components = 0) :

+ _num_components(num_components)

+ {

+ this->compute(src, labels); //! compute eigenvectors and eigenvalues

+ }

+

+ // Serializes this object to a given filename.

+ void save(const string& filename) const;

+

+ // Deserializes this object from a given filename.

+ void load(const string& filename);

+

+ // Serializes this object to a given cv::FileStorage.

+ void save(FileStorage& fs) const;

+

+ // Deserializes this object from a given cv::FileStorage.

+ void load(const FileStorage& node);

+

+ // Destructor.

+ ~LDA() {}

+

+ /** Compute the discriminants for data in src (row aligned) and labels.

+ */

+ void compute(InputArrayOfArrays src, InputArray labels);

+

+ /** Projects samples into the LDA subspace.

+ src may be one or more row aligned samples.

+ */

+ Mat project(InputArray src);

+

+ /** Reconstructs projections from the LDA subspace.

+ src may be one or more row aligned projections.

+ */

+ Mat reconstruct(InputArray src);

+

+ // Returns the eigenvectors of this LDA.

+ Mat eigenvectors() const { return _eigenvectors; };

+

+ // Returns the eigenvalues of this LDA.

+ Mat eigenvalues() const { return _eigenvalues; }

+

+ protected:

+ bool _dataAsRow; // unused, but needed for ABI compatibility.

+ int _num_components;

+ Mat _eigenvectors;

+ Mat _eigenvalues;

+

+ void lda(InputArrayOfArrays src, InputArray labels);

+ };

+

+ class CV_EXPORTS_W FaceRecognizer : public Algorithm

+ {

+ public:

+ //! virtual destructor

+ virtual ~FaceRecognizer() {}

+

+ // Trains a FaceRecognizer.

+ CV_WRAP virtual void train(InputArrayOfArrays src, InputArray labels) = 0;

+

+ // Updates a FaceRecognizer.

+ CV_WRAP void update(InputArrayOfArrays src, InputArray labels);

+

+ // Gets a prediction from a FaceRecognizer.

+ virtual int predict(InputArray src) const = 0;

+

+ // Predicts the label and confidence for a given sample.

+ CV_WRAP virtual void predict(InputArray src, CV_OUT int &label, CV_OUT double &confidence) const = 0;

+

+ // Serializes this object to a given filename.

+ CV_WRAP virtual void save(const string& filename) const;

+

+ // Deserializes this object from a given filename.

+ CV_WRAP virtual void load(const string& filename);

+

+ // Serializes this object to a given cv::FileStorage.

+ virtual void save(FileStorage& fs) const = 0;

+

+ // Deserializes this object from a given cv::FileStorage.

+ virtual void load(const FileStorage& fs) = 0;

+

+ // Sets additional information as pairs label - info.

+ void setLabelsInfo(const std::map<int, string>& labelsInfo);

+

+ // Gets string information by label

+ string getLabelInfo(const int &label);

+

+ // Gets labels by string

+ vector<int> getLabelsByString(const string& str);

+ };

+

+ CV_EXPORTS_W Ptr<FaceRecognizer> createEigenFaceRecognizer(int num_components = 0, double threshold = DBL_MAX);

+ CV_EXPORTS_W Ptr<FaceRecognizer> createFisherFaceRecognizer(int num_components = 0, double threshold = DBL_MAX);

+ CV_EXPORTS_W Ptr<FaceRecognizer> createLBPHFaceRecognizer(int radius=1, int neighbors=8,

+ int grid_x=8, int grid_y=8, double threshold = DBL_MAX);

+

+ enum

+ {

+ COLORMAP_AUTUMN = 0,

+ COLORMAP_BONE = 1,

+ COLORMAP_JET = 2,

+ COLORMAP_WINTER = 3,

+ COLORMAP_RAINBOW = 4,

+ COLORMAP_OCEAN = 5,

+ COLORMAP_SUMMER = 6,

+ COLORMAP_SPRING = 7,

+ COLORMAP_COOL = 8,

+ COLORMAP_HSV = 9,

+ COLORMAP_PINK = 10,

+ COLORMAP_HOT = 11

+ };

+

+ CV_EXPORTS_W void applyColorMap(InputArray src, OutputArray dst, int colormap);

+

+ CV_EXPORTS bool initModule_contrib();

+}

+

+#include "opencv2/contrib/retina.hpp"

+

+#include "opencv2/contrib/openfabmap.hpp"

+

+#endif

+

+#endif

+#pragma once

+

+#if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(ANDROID)

+

+#include <opencv2/core/core.hpp>

+#include <opencv2/objdetect/objdetect.hpp>

+

+#include <vector>

+

+class DetectionBasedTracker

+{

+ public:

+ struct Parameters

+ {

+ int minObjectSize;

+ int maxObjectSize;

+ double scaleFactor;

+ int maxTrackLifetime;

+ int minNeighbors;

+ int minDetectionPeriod; //the minimal time between run of the big object detector (on the whole frame) in ms (1000 mean 1 sec), default=0

+

+ Parameters();

+ };

+

+ DetectionBasedTracker(const std::string& cascadeFilename, const Parameters& params);

+ virtual ~DetectionBasedTracker();

+

+ virtual bool run();

+ virtual void stop();

+ virtual void resetTracking();

+

+ virtual void process(const cv::Mat& imageGray);

+

+ bool setParameters(const Parameters& params);

+ const Parameters& getParameters();

+

+

+ typedef std::pair<cv::Rect, int> Object;

+ virtual void getObjects(std::vector<cv::Rect>& result) const;

+ virtual void getObjects(std::vector<Object>& result) const;

+

+ protected:

+ class SeparateDetectionWork;

+ cv::Ptr<SeparateDetectionWork> separateDetectionWork;

+ friend void* workcycleObjectDetectorFunction(void* p);

+

+

+ struct InnerParameters

+ {

+ int numLastPositionsToTrack;

+ int numStepsToWaitBeforeFirstShow;

+ int numStepsToTrackWithoutDetectingIfObjectHasNotBeenShown;

+ int numStepsToShowWithoutDetecting;

+

+ float coeffTrackingWindowSize;

+ float coeffObjectSizeToTrack;

+ float coeffObjectSpeedUsingInPrediction;

+

+ InnerParameters();

+ };

+ Parameters parameters;

+ InnerParameters innerParameters;

+

+ struct TrackedObject

+ {

+ typedef std::vector<cv::Rect> PositionsVector;

+

+ PositionsVector lastPositions;

+

+ int numDetectedFrames;

+ int numFramesNotDetected;

+ int id;

+

+ TrackedObject(const cv::Rect& rect):numDetectedFrames(1), numFramesNotDetected(0)

+ {

+ lastPositions.push_back(rect);

+ id=getNextId();

+ };

+

+ static int getNextId()

+ {

+ static int _id=0;

+ return _id++;

+ }

+ };

+

+ int numTrackedSteps;

+ std::vector<TrackedObject> trackedObjects;

+

+ std::vector<float> weightsPositionsSmoothing;

+ std::vector<float> weightsSizesSmoothing;

+

+ cv::CascadeClassifier cascadeForTracking;

+

+

+ void updateTrackedObjects(const std::vector<cv::Rect>& detectedObjects);

+ cv::Rect calcTrackedObjectPositionToShow(int i) const;

+ void detectInRegion(const cv::Mat& img, const cv::Rect& r, std::vector<cv::Rect>& detectedObjectsInRegions);

+};

+

+namespace cv

+{

+ using ::DetectionBasedTracker;

+} //end of cv namespace

+

+#endif

+//*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.

+//

+//

+// License Agreement

+// For Open Source Computer Vision Library

+//

+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.

+// Copyright (C) 2008-2011, 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 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 __OPENCV_HYBRIDTRACKER_H_

+#define __OPENCV_HYBRIDTRACKER_H_

+

+#include "opencv2/core/core.hpp"

+#include "opencv2/core/operations.hpp"

+#include "opencv2/imgproc/imgproc.hpp"

+#include "opencv2/features2d/features2d.hpp"

+#include "opencv2/video/tracking.hpp"

+#include "opencv2/ml/ml.hpp"

+

+#ifdef __cplusplus

+

+namespace cv

+{

+

+// Motion model for tracking algorithm. Currently supports objects that do not move much.

+// To add Kalman filter

+struct CV_EXPORTS CvMotionModel

+{

+ enum {LOW_PASS_FILTER = 0, KALMAN_FILTER = 1, EM = 2};

+

+ CvMotionModel()

+ {

+ }

+

+ float low_pass_gain; // low pass gain

+};

+

+// Mean Shift Tracker parameters for specifying use of HSV channel and CamShift parameters.

+struct CV_EXPORTS CvMeanShiftTrackerParams

+{

+ enum { H = 0, HS = 1, HSV = 2 };

+ CvMeanShiftTrackerParams(int tracking_type = CvMeanShiftTrackerParams::HS,

+ CvTermCriteria term_crit = CvTermCriteria());

+

+ int tracking_type;

+ vector<float> h_range;

+ vector<float> s_range;

+ vector<float> v_range;

+ CvTermCriteria term_crit;

+};

+

+// Feature tracking parameters

+struct CV_EXPORTS CvFeatureTrackerParams

+{

+ enum { SIFT = 0, SURF = 1, OPTICAL_FLOW = 2 };

+ CvFeatureTrackerParams(int featureType = 0, int windowSize = 0)

+ {

+ feature_type = featureType;

+ window_size = windowSize;

+ }

+

+ int feature_type; // Feature type to use

+ int window_size; // Window size in pixels around which to search for new window

+};

+

+// Hybrid Tracking parameters for specifying weights of individual trackers and motion model.

+struct CV_EXPORTS CvHybridTrackerParams

+{

+ CvHybridTrackerParams(float ft_tracker_weight = 0.5, float ms_tracker_weight = 0.5,

+ CvFeatureTrackerParams ft_params = CvFeatureTrackerParams(),

+ CvMeanShiftTrackerParams ms_params = CvMeanShiftTrackerParams(),

+ CvMotionModel model = CvMotionModel());

+

+ float ft_tracker_weight;

+ float ms_tracker_weight;

+ CvFeatureTrackerParams ft_params;

+ CvMeanShiftTrackerParams ms_params;

+ int motion_model;

+ float low_pass_gain;

+};

+

+// Performs Camshift using parameters from MeanShiftTrackerParams

+class CV_EXPORTS CvMeanShiftTracker

+{

+private:

+ Mat hsv, hue;

+ Mat backproj;

+ Mat mask, maskroi;

+ MatND hist;

+ Rect prev_trackwindow;

+ RotatedRect prev_trackbox;

+ Point2f prev_center;

+

+public:

+ CvMeanShiftTrackerParams params;

+

+ CvMeanShiftTracker();

+ explicit CvMeanShiftTracker(CvMeanShiftTrackerParams _params);

+ ~CvMeanShiftTracker();

+ void newTrackingWindow(Mat image, Rect selection);

+ RotatedRect updateTrackingWindow(Mat image);

+ Mat getHistogramProjection(int type);

+ void setTrackingWindow(Rect _window);

+ Rect getTrackingWindow();

+ RotatedRect getTrackingEllipse();

+ Point2f getTrackingCenter();

+};

+

+// Performs SIFT/SURF feature tracking using parameters from FeatureTrackerParams

+class CV_EXPORTS CvFeatureTracker

+{

+private:

+ Ptr<Feature2D> dd;

+ Ptr<DescriptorMatcher> matcher;

+ vector<DMatch> matches;

+

+ Mat prev_image;

+ Mat prev_image_bw;

+ Rect prev_trackwindow;

+ Point2d prev_center;

+

+ int ittr;

+ vector<Point2f> features[2];

+

+public:

+ Mat disp_matches;

+ CvFeatureTrackerParams params;

+

+ CvFeatureTracker();

+ explicit CvFeatureTracker(CvFeatureTrackerParams params);

+ ~CvFeatureTracker();

+ void newTrackingWindow(Mat image, Rect selection);

+ Rect updateTrackingWindow(Mat image);

+ Rect updateTrackingWindowWithSIFT(Mat image);

+ Rect updateTrackingWindowWithFlow(Mat image);

+ void setTrackingWindow(Rect _window);

+ Rect getTrackingWindow();

+ Point2f getTrackingCenter();

+};

+

+// Performs Hybrid Tracking and combines individual trackers using EM or filters

+class CV_EXPORTS CvHybridTracker

+{

+private:

+ CvMeanShiftTracker* mstracker;

+ CvFeatureTracker* fttracker;

+

+ CvMat* samples;

+ CvMat* labels;

+

+ Rect prev_window;

+ Point2f prev_center;

+ Mat prev_proj;

+ RotatedRect trackbox;

+

+ int ittr;

+ Point2f curr_center;

+

+ inline float getL2Norm(Point2f p1, Point2f p2);

+ Mat getDistanceProjection(Mat image, Point2f center);

+ Mat getGaussianProjection(Mat image, int ksize, double sigma, Point2f center);

+ void updateTrackerWithEM(Mat image);

+ void updateTrackerWithLowPassFilter(Mat image);

+

+public:

+ CvHybridTrackerParams params;

+ CvHybridTracker();

+ explicit CvHybridTracker(CvHybridTrackerParams params);

+ ~CvHybridTracker();

+

+ void newTracker(Mat image, Rect selection);

+ void updateTracker(Mat image);

+ Rect getTrackingWindow();

+};

+

+typedef CvMotionModel MotionModel;

+typedef CvMeanShiftTrackerParams MeanShiftTrackerParams;

+typedef CvFeatureTrackerParams FeatureTrackerParams;

+typedef CvHybridTrackerParams HybridTrackerParams;

+typedef CvMeanShiftTracker MeanShiftTracker;

+typedef CvFeatureTracker FeatureTracker;

+typedef CvHybridTracker HybridTracker;

+}

+

+#endif

+

+#endif

+/*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.

+//

+// This file originates from the openFABMAP project:

+// [http://code.google.com/p/openfabmap/]

+//

+// For published work which uses all or part of OpenFABMAP, please cite:

+// [http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=6224843]

+//

+// Original Algorithm by Mark Cummins and Paul Newman:

+// [http://ijr.sagepub.com/content/27/6/647.short]

+// [http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=5613942]

+// [http://ijr.sagepub.com/content/30/9/1100.abstract]

+//

+// License Agreement

+//

+// Copyright (C) 2012 Arren Glover [aj.glover@qut.edu.au] and

+// Will Maddern [w.maddern@qut.edu.au], all rights reserved.

+//

+//

+// 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.

+//

+//M*/

+

+#ifndef __OPENCV_OPENFABMAP_H_

+#define __OPENCV_OPENFABMAP_H_

+

+#include "opencv2/core/core.hpp"

+#include "opencv2/features2d/features2d.hpp"

+

+#include <vector>

+#include <list>

+#include <map>

+#include <set>

+#include <valarray>

+

+namespace cv {

+

+namespace of2 {

+

+using std::list;

+using std::map;

+using std::multiset;

+

+/*

+ Return data format of a FABMAP compare call

+*/

+struct CV_EXPORTS IMatch {

+

+ IMatch() :

+ queryIdx(-1), imgIdx(-1), likelihood(-DBL_MAX), match(-DBL_MAX) {

+ }

+ IMatch(int _queryIdx, int _imgIdx, double _likelihood, double _match) :

+ queryIdx(_queryIdx), imgIdx(_imgIdx), likelihood(_likelihood), match(

+ _match) {

+ }

+

+ int queryIdx; //query index

+ int imgIdx; //test index

+

+ double likelihood; //raw loglikelihood

+ double match; //normalised probability

+

+ bool operator<(const IMatch& m) const {

+ return match < m.match;

+ }

+

+};

+

+/*

+ Base FabMap class. Each FabMap method inherits from this class.

+*/

+class CV_EXPORTS FabMap {

+public:

+

+ //FabMap options

+ enum {

+ MEAN_FIELD = 1,

+ SAMPLED = 2,

+ NAIVE_BAYES = 4,

+ CHOW_LIU = 8,

+ MOTION_MODEL = 16

+ };

+

+ FabMap(const Mat& clTree, double PzGe, double PzGNe, int flags,

+ int numSamples = 0);

+ virtual ~FabMap();

+

+ //methods to add training data for sampling method

+ virtual void addTraining(const Mat& queryImgDescriptor);

+ virtual void addTraining(const vector<Mat>& queryImgDescriptors);

+

+ //methods to add to the test data

+ virtual void add(const Mat& queryImgDescriptor);

+ virtual void add(const vector<Mat>& queryImgDescriptors);

+

+ //accessors

+ const vector<Mat>& getTrainingImgDescriptors() const;

+ const vector<Mat>& getTestImgDescriptors() const;

+

+ //Main FabMap image comparison

+ void compare(const Mat& queryImgDescriptor,

+ vector<IMatch>& matches, bool addQuery = false,

+ const Mat& mask = Mat());

+ void compare(const Mat& queryImgDescriptor,

+ const Mat& testImgDescriptors, vector<IMatch>& matches,

+ const Mat& mask = Mat());

+ void compare(const Mat& queryImgDescriptor,

+ const vector<Mat>& testImgDescriptors,

+ vector<IMatch>& matches, const Mat& mask = Mat());

+ void compare(const vector<Mat>& queryImgDescriptors, vector<

+ IMatch>& matches, bool addQuery = false, const Mat& mask =

+ Mat());

+ void compare(const vector<Mat>& queryImgDescriptors,

+ const vector<Mat>& testImgDescriptors,

+ vector<IMatch>& matches, const Mat& mask = Mat());

+

+protected:

+

+ void compareImgDescriptor(const Mat& queryImgDescriptor,

+ int queryIndex, const vector<Mat>& testImgDescriptors,

+ vector<IMatch>& matches);

+

+ void addImgDescriptor(const Mat& queryImgDescriptor);

+

+ //the getLikelihoods method is overwritten for each different FabMap

+ //method.

+ virtual void getLikelihoods(const Mat& queryImgDescriptor,

+ const vector<Mat>& testImgDescriptors,

+ vector<IMatch>& matches);

+ virtual double getNewPlaceLikelihood(const Mat& queryImgDescriptor);

+

+ //turn likelihoods into probabilities (also add in motion model if used)

+ void normaliseDistribution(vector<IMatch>& matches);

+

+ //Chow-Liu Tree

+ int pq(int q);

+ double Pzq(int q, bool zq);

+ double PzqGzpq(int q, bool zq, bool zpq);

+

+ //FAB-MAP Core

+ double PzqGeq(bool zq, bool eq);

+ double PeqGL(int q, bool Lzq, bool eq);

+ double PzqGL(int q, bool zq, bool zpq, bool Lzq);

+ double PzqGzpqL(int q, bool zq, bool zpq, bool Lzq);

+ double (FabMap::*PzGL)(int q, bool zq, bool zpq, bool Lzq);

+

+ //data

+ Mat clTree;

+ vector<Mat> trainingImgDescriptors;

+ vector<Mat> testImgDescriptors;

+ vector<IMatch> priorMatches;

+

+ //parameters

+ double PzGe;

+ double PzGNe;

+ double Pnew;

+

+ double mBias;

+ double sFactor;

+

+ int flags;

+ int numSamples;

+

+};

+

+/*

+ The original FAB-MAP algorithm, developed based on:

+ http://ijr.sagepub.com/content/27/6/647.short

+*/

+class CV_EXPORTS FabMap1: public FabMap {

+public:

+ FabMap1(const Mat& clTree, double PzGe, double PzGNe, int flags,

+ int numSamples = 0);

+ virtual ~FabMap1();

+protected:

+

+ //FabMap1 implementation of likelihood comparison

+ void getLikelihoods(const Mat& queryImgDescriptor, const vector<

+ Mat>& testImgDescriptors, vector<IMatch>& matches);

+};

+

+/*

+ A computationally faster version of the original FAB-MAP algorithm. A look-

+ up-table is used to precompute many of the reoccuring calculations

+*/

+class CV_EXPORTS FabMapLUT: public FabMap {

+public:

+ FabMapLUT(const Mat& clTree, double PzGe, double PzGNe,

+ int flags, int numSamples = 0, int precision = 6);

+ virtual ~FabMapLUT();

+protected:

+

+ //FabMap look-up-table implementation of the likelihood comparison

+ void getLikelihoods(const Mat& queryImgDescriptor, const vector<

+ Mat>& testImgDescriptors, vector<IMatch>& matches);

+

+ //precomputed data

+ int (*table)[8];

+

+ //data precision

+ int precision;

+};

+

+/*

+ The Accelerated FAB-MAP algorithm, developed based on:

+ http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=5613942

+*/

+class CV_EXPORTS FabMapFBO: public FabMap {

+public:

+ FabMapFBO(const Mat& clTree, double PzGe, double PzGNe, int flags,

+ int numSamples = 0, double rejectionThreshold = 1e-8, double PsGd =

+ 1e-8, int bisectionStart = 512, int bisectionIts = 9);

+ virtual ~FabMapFBO();

+

+protected:

+

+ //FabMap Fast Bail-out implementation of the likelihood comparison

+ void getLikelihoods(const Mat& queryImgDescriptor, const vector<

+ Mat>& testImgDescriptors, vector<IMatch>& matches);

+

+ //stucture used to determine word comparison order

+ struct WordStats {

+ WordStats() :

+ q(0), info(0), V(0), M(0) {

+ }

+

+ WordStats(int _q, double _info) :

+ q(_q), info(_info), V(0), M(0) {

+ }

+

+ int q;

+ double info;

+ mutable double V;

+ mutable double M;

+

+ bool operator<(const WordStats& w) const {

+ return info < w.info;

+ }

+

+ };

+

+ //private fast bail-out necessary functions

+ void setWordStatistics(const Mat& queryImgDescriptor, multiset<WordStats>& wordData);

+ double limitbisection(double v, double m);

+ double bennettInequality(double v, double m, double delta);

+ static bool compInfo(const WordStats& first, const WordStats& second);

+

+ //parameters

+ double PsGd;

+ double rejectionThreshold;

+ int bisectionStart;

+ int bisectionIts;

+};

+

+/*

+ The FAB-MAP2.0 algorithm, developed based on:

+ http://ijr.sagepub.com/content/30/9/1100.abstract

+*/

+class CV_EXPORTS FabMap2: public FabMap {

+public:

+

+ FabMap2(const Mat& clTree, double PzGe, double PzGNe, int flags);

+ virtual ~FabMap2();

+

+ //FabMap2 builds the inverted index and requires an additional training/test

+ //add function

+ void addTraining(const Mat& queryImgDescriptors) {

+ FabMap::addTraining(queryImgDescriptors);

+ }

+ void addTraining(const vector<Mat>& queryImgDescriptors);

+

+ void add(const Mat& queryImgDescriptors) {

+ FabMap::add(queryImgDescriptors);

+ }

+ void add(const vector<Mat>& queryImgDescriptors);

+

+protected:

+

+ //FabMap2 implementation of the likelihood comparison

+ void getLikelihoods(const Mat& queryImgDescriptor, const vector<

+ Mat>& testImgDescriptors, vector<IMatch>& matches);

+ double getNewPlaceLikelihood(const Mat& queryImgDescriptor);

+

+ //the likelihood function using the inverted index

+ void getIndexLikelihoods(const Mat& queryImgDescriptor, vector<

+ double>& defaults, map<int, vector<int> >& invertedMap,

+ vector<IMatch>& matches);

+ void addToIndex(const Mat& queryImgDescriptor,

+ vector<double>& defaults,

+ map<int, vector<int> >& invertedMap);

+

+ //data

+ vector<double> d1, d2, d3, d4;

+ vector<vector<int> > children;

+

+ // TODO: inverted map a vector?

+

+ vector<double> trainingDefaults;

+ map<int, vector<int> > trainingInvertedMap;

+

+ vector<double> testDefaults;

+ map<int, vector<int> > testInvertedMap;

+

+};

+/*

+ A Chow-Liu tree is required by FAB-MAP. The Chow-Liu tree provides an

+ estimate of the full distribution of visual words using a minimum spanning

+ tree. The tree is generated through training data.

+*/

+class CV_EXPORTS ChowLiuTree {

+public:

+ ChowLiuTree();

+ virtual ~ChowLiuTree();

+

+ //add data to the chow-liu tree before calling make

+ void add(const Mat& imgDescriptor);

+ void add(const vector<Mat>& imgDescriptors);

+

+ const vector<Mat>& getImgDescriptors() const;

+

+ Mat make(double infoThreshold = 0.0);

+

+private:

+ vector<Mat> imgDescriptors;

+ Mat mergedImgDescriptors;

+

+ typedef struct info {

+ float score;

+ short word1;

+ short word2;

+ } info;

+

+ //probabilities extracted from mergedImgDescriptors

+ double P(int a, bool za);

+ double JP(int a, bool za, int b, bool zb); //a & b

+ double CP(int a, bool za, int b, bool zb); // a | b

+

+ //calculating mutual information of all edges

+ void createBaseEdges(list<info>& edges, double infoThreshold);

+ double calcMutInfo(int word1, int word2);

+ static bool sortInfoScores(const info& first, const info& second);

+

+ //selecting minimum spanning egdges with maximum information

+ bool reduceEdgesToMinSpan(list<info>& edges);

+

+ //building the tree sctructure

+ Mat buildTree(int root_word, list<info> &edges);

+ void recAddToTree(Mat &cltree, int q, int pq,

+ list<info> &remaining_edges);

+ vector<int> extractChildren(list<info> &remaining_edges, int q);

+

+};

+

+/*

+ A custom vocabulary training method based on:

+ http://www.springerlink.com/content/d1h6j8x552532003/

+*/

+class CV_EXPORTS BOWMSCTrainer: public BOWTrainer {

+public:

+ BOWMSCTrainer(double clusterSize = 0.4);

+ virtual ~BOWMSCTrainer();

+

+ // Returns trained vocabulary (i.e. cluster centers).

+ virtual Mat cluster() const;

+ virtual Mat cluster(const Mat& descriptors) const;

+

+protected:

+

+ double clusterSize;

+

+};

+

+}

+

+}

+

+#endif /* OPENFABMAP_H_ */

+/*#******************************************************************************

+ ** 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.

+ **

+ **

+ ** HVStools : interfaces allowing OpenCV users to integrate Human Vision System models. Presented models originate from Jeanny Herault's original research and have been reused and adapted by the author&collaborators for computed vision applications since his thesis with Alice Caplier at Gipsa-Lab.

+ ** Use: extract still images & image sequences features, from contours details to motion spatio-temporal features, etc. for high level visual scene analysis. Also contribute to image enhancement/compression such as tone mapping.

+ **

+ ** Maintainers : Listic lab (code author current affiliation & applications) and Gipsa Lab (original research origins & applications)

+ **

+ ** Creation - enhancement process 2007-2011

+ ** Author: Alexandre Benoit (benoit.alexandre.vision@gmail.com), LISTIC lab, Annecy le vieux, France

+ **

+ ** Theses algorithm have been developped by Alexandre BENOIT since his thesis with Alice Caplier at Gipsa-Lab (www.gipsa-lab.inpg.fr) and the research he pursues at LISTIC Lab (www.listic.univ-savoie.fr).

+ ** Refer to the following research paper for more information:

+ ** Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011

+ ** This work have been carried out thanks to Jeanny Herault who's research and great discussions are the basis of all this work, please take a look at his book:

+ ** Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.

+ **

+ ** The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :

+ ** _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:

+ ** ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007

+ ** _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.

+ ** ====> more informations in the above cited Jeanny Heraults's book.

+ **

+ ** License Agreement

+ ** For Open Source Computer Vision Library

+ **

+ ** Copyright (C) 2000-2008, Intel Corporation, all rights reserved.

+ ** Copyright (C) 2008-2011, Willow Garage Inc., all rights reserved.

+ **

+ ** For Human Visual System tools (hvstools)

+ ** Copyright (C) 2007-2011, LISTIC Lab, Annecy le Vieux and GIPSA Lab, Grenoble, France, 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:

+ **

+ ** * Redistributions of source code must retain the above copyright notice,

+ ** this list of conditions and the following disclaimer.

+ **

+ ** * 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.

+ **

+ ** * 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.

+ *******************************************************************************/

+

+#ifndef __OPENCV_CONTRIB_RETINA_HPP__

+#define __OPENCV_CONTRIB_RETINA_HPP__

+

+/*

+ * Retina.hpp

+ *

+ * Created on: Jul 19, 2011

+ * Author: Alexandre Benoit

+ */

+

+#include "opencv2/core/core.hpp" // for all OpenCV core functionalities access, including cv::Exception support

+#include <valarray>

+

+namespace cv

+{

+

+enum RETINA_COLORSAMPLINGMETHOD

+{

+ RETINA_COLOR_RANDOM, //!< each pixel position is either R, G or B in a random choice

+ RETINA_COLOR_DIAGONAL,//!< color sampling is RGBRGBRGB..., line 2 BRGBRGBRG..., line 3, GBRGBRGBR...

+ RETINA_COLOR_BAYER//!< standard bayer sampling

+};

+

+class RetinaFilter;

+

+/**

+ * a wrapper class which allows the Gipsa/Listic Labs model to be used.

+ * This retina model allows spatio-temporal image processing (applied on still images, video sequences).

+ * As a summary, these are the retina model properties:

+ * => It applies a spectral whithening (mid-frequency details enhancement)

+ * => high frequency spatio-temporal noise reduction

+ * => low frequency luminance to be reduced (luminance range compression)

+ * => local logarithmic luminance compression allows details to be enhanced in low light conditions

+ *

+ * USE : this model can be used basically for spatio-temporal video effects but also for :

+ * _using the getParvo method output matrix : texture analysiswith enhanced signal to noise ratio and enhanced details robust against input images luminance ranges

+ * _using the getMagno method output matrix : motion analysis also with the previously cited properties

+ *

+ * for more information, reer to the following papers :

+ * Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011

+ * Vision: Images, Signals and Neural Networks: Models of Neural Processing in Visual Perception (Progress in Neural Processing),By: Jeanny Herault, ISBN: 9814273686. WAPI (Tower ID): 113266891.

+ *

+ * The retina filter includes the research contributions of phd/research collegues from which code has been redrawn by the author :

+ * _take a look at the retinacolor.hpp module to discover Brice Chaix de Lavarene color mosaicing/demosaicing and the reference paper:

+ * ====> B. Chaix de Lavarene, D. Alleysson, B. Durette, J. Herault (2007). "Efficient demosaicing through recursive filtering", IEEE International Conference on Image Processing ICIP 2007

+ * _take a look at imagelogpolprojection.hpp to discover retina spatial log sampling which originates from Barthelemy Durette phd with Jeanny Herault. A Retina / V1 cortex projection is also proposed and originates from Jeanny's discussions.

+ * ====> more informations in the above cited Jeanny Heraults's book.

+ */

+class CV_EXPORTS Retina {

+

+public:

+

+ // parameters structure for better clarity, check explenations on the comments of methods : setupOPLandIPLParvoChannel and setupIPLMagnoChannel

+ struct RetinaParameters{

+ struct OPLandIplParvoParameters{ // Outer Plexiform Layer (OPL) and Inner Plexiform Layer Parvocellular (IplParvo) parameters

+ OPLandIplParvoParameters():colorMode(true),

+ normaliseOutput(true),

+ photoreceptorsLocalAdaptationSensitivity(0.7f),

+ photoreceptorsTemporalConstant(0.5f),

+ photoreceptorsSpatialConstant(0.53f),

+ horizontalCellsGain(0.0f),

+ hcellsTemporalConstant(1.f),

+ hcellsSpatialConstant(7.f),

+ ganglionCellsSensitivity(0.7f){};// default setup

+ bool colorMode, normaliseOutput;

+ float photoreceptorsLocalAdaptationSensitivity, photoreceptorsTemporalConstant, photoreceptorsSpatialConstant, horizontalCellsGain, hcellsTemporalConstant, hcellsSpatialConstant, ganglionCellsSensitivity;

+ };

+ struct IplMagnoParameters{ // Inner Plexiform Layer Magnocellular channel (IplMagno)

+ IplMagnoParameters():

+ normaliseOutput(true),

+ parasolCells_beta(0.f),

+ parasolCells_tau(0.f),

+ parasolCells_k(7.f),

+ amacrinCellsTemporalCutFrequency(1.2f),

+ V0CompressionParameter(0.95f),

+ localAdaptintegration_tau(0.f),

+ localAdaptintegration_k(7.f){};// default setup

+ bool normaliseOutput;

+ float parasolCells_beta, parasolCells_tau, parasolCells_k, amacrinCellsTemporalCutFrequency, V0CompressionParameter, localAdaptintegration_tau, localAdaptintegration_k;

+ };

+ struct OPLandIplParvoParameters OPLandIplParvo;

+ struct IplMagnoParameters IplMagno;

+ };

+

+ /**

+ * Main constructor with most commun use setup : create an instance of color ready retina model

+ * @param inputSize : the input frame size

+ */

+ Retina(Size inputSize);

+

+ /**

+ * Complete Retina filter constructor which allows all basic structural parameters definition

+ * @param inputSize : the input frame size

+ * @param colorMode : the chosen processing mode : with or without color processing

+ * @param colorSamplingMethod: specifies which kind of color sampling will be used

+ * @param useRetinaLogSampling: activate retina log sampling, if true, the 2 following parameters can be used

+ * @param reductionFactor: only usefull if param useRetinaLogSampling=true, specifies the reduction factor of the output frame (as the center (fovea) is high resolution and corners can be underscaled, then a reduction of the output is allowed without precision leak

+ * @param samplingStrenght: only usefull if param useRetinaLogSampling=true, specifies the strenght of the log scale that is applied

+ */

+ Retina(Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const double reductionFactor=1.0, const double samplingStrenght=10.0);

+

+ virtual ~Retina();

+

+ /**

+ * retreive retina input buffer size

+ */

+ Size inputSize();

+

+ /**

+ * retreive retina output buffer size

+ */

+ Size outputSize();

+

+ /**

+ * try to open an XML retina parameters file to adjust current retina instance setup

+ * => if the xml file does not exist, then default setup is applied

+ * => warning, Exceptions are thrown if read XML file is not valid

+ * @param retinaParameterFile : the parameters filename

+ * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error

+ */

+ void setup(std::string retinaParameterFile="", const bool applyDefaultSetupOnFailure=true);

+

+

+ /**

+ * try to open an XML retina parameters file to adjust current retina instance setup

+ * => if the xml file does not exist, then default setup is applied

+ * => warning, Exceptions are thrown if read XML file is not valid

+ * @param fs : the open Filestorage which contains retina parameters

+ * @param applyDefaultSetupOnFailure : set to true if an error must be thrown on error

+ */

+ void setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure=true);

+

+ /**

+ * try to open an XML retina parameters file to adjust current retina instance setup

+ * => if the xml file does not exist, then default setup is applied

+ * => warning, Exceptions are thrown if read XML file is not valid

+ * @param newParameters : a parameters structures updated with the new target configuration

+ */

+ void setup(RetinaParameters newParameters);

+

+ /**

+ * @return the current parameters setup

+ */

+ Retina::RetinaParameters getParameters();

+

+ /**

+ * parameters setup display method

+ * @return a string which contains formatted parameters information

+ */

+ const std::string printSetup();

+

+ /**

+ * write xml/yml formated parameters information

+ * @param fs : the filename of the xml file that will be open and writen with formatted parameters information

+ */

+ virtual void write( std::string fs ) const;

+

+

+ /**

+ * write xml/yml formated parameters information

+ * @param fs : a cv::Filestorage object ready to be filled

+ */

+ virtual void write( FileStorage& fs ) const;

+

+ /**

+ * setup the OPL and IPL parvo channels (see biologocal model)

+ * OPL is referred as Outer Plexiform Layer of the retina, it allows the spatio-temporal filtering which withens the spectrum and reduces spatio-temporal noise while attenuating global luminance (low frequency energy)

+ * IPL parvo is the OPL next processing stage, it refers to Inner Plexiform layer of the retina, it allows high contours sensitivity in foveal vision.

+ * for more informations, please have a look at the paper Benoit A., Caplier A., Durette B., Herault, J., "USING HUMAN VISUAL SYSTEM MODELING FOR BIO-INSPIRED LOW LEVEL IMAGE PROCESSING", Elsevier, Computer Vision and Image Understanding 114 (2010), pp. 758-773, DOI: http://dx.doi.org/10.1016/j.cviu.2010.01.011

+ * @param colorMode : specifies if (true) color is processed of not (false) to then processing gray level image

+ * @param normaliseOutput : specifies if (true) output is rescaled between 0 and 255 of not (false)

+ * @param photoreceptorsLocalAdaptationSensitivity: the photoreceptors sensitivity renage is 0-1 (more log compression effect when value increases)

+ * @param photoreceptorsTemporalConstant: the time constant of the first order low pass filter of the photoreceptors, use it to cut high temporal frequencies (noise or fast motion), unit is frames, typical value is 1 frame

+ * @param photoreceptorsSpatialConstant: the spatial constant of the first order low pass filter of the photoreceptors, use it to cut high spatial frequencies (noise or thick contours), unit is pixels, typical value is 1 pixel

+ * @param horizontalCellsGain: gain of the horizontal cells network, if 0, then the mean value of the output is zero, if the parameter is near 1, then, the luminance is not filtered and is still reachable at the output, typicall value is 0

+ * @param HcellsTemporalConstant: the time constant of the first order low pass filter of the horizontal cells, use it to cut low temporal frequencies (local luminance variations), unit is frames, typical value is 1 frame, as the photoreceptors

+ * @param HcellsSpatialConstant: the spatial constant of the first order low pass filter of the horizontal cells, use it to cut low spatial frequencies (local luminance), unit is pixels, typical value is 5 pixel, this value is also used for local contrast computing when computing the local contrast adaptation at the ganglion cells level (Inner Plexiform Layer parvocellular channel model)

+ * @param ganglionCellsSensitivity: the compression strengh of the ganglion cells local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 230

+ */

+ void setupOPLandIPLParvoChannel(const bool colorMode=true, const bool normaliseOutput = true, const float photoreceptorsLocalAdaptationSensitivity=0.7f, const float photoreceptorsTemporalConstant=0.5f, const float photoreceptorsSpatialConstant=0.53f, const float horizontalCellsGain=0, const float HcellsTemporalConstant=1, const float HcellsSpatialConstant=7, const float ganglionCellsSensitivity=0.7f);

+

+ /**

+ * set parameters values for the Inner Plexiform Layer (IPL) magnocellular channel

+ * this channel processes signals outpint from OPL processing stage in peripheral vision, it allows motion information enhancement. It is decorrelated from the details channel. See reference paper for more details.

+ * @param normaliseOutput : specifies if (true) output is rescaled between 0 and 255 of not (false)

+ * @param parasolCells_beta: the low pass filter gain used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), typical value is 0

+ * @param parasolCells_tau: the low pass filter time constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is frame, typical value is 0 (immediate response)

+ * @param parasolCells_k: the low pass filter spatial constant used for local contrast adaptation at the IPL level of the retina (for ganglion cells local adaptation), unit is pixels, typical value is 5

+ * @param amacrinCellsTemporalCutFrequency: the time constant of the first order high pass fiter of the magnocellular way (motion information channel), unit is frames, tipicall value is 5

+ * @param V0CompressionParameter: the compression strengh of the ganglion cells local adaptation output, set a value between 160 and 250 for best results, a high value increases more the low value sensitivity... and the output saturates faster, recommended value: 200

+ * @param localAdaptintegration_tau: specifies the temporal constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation

+ * @param localAdaptintegration_k: specifies the spatial constant of the low pas filter involved in the computation of the local "motion mean" for the local adaptation computation

+ */

+ void setupIPLMagnoChannel(const bool normaliseOutput = true, const float parasolCells_beta=0, const float parasolCells_tau=0, const float parasolCells_k=7, const float amacrinCellsTemporalCutFrequency=1.2f, const float V0CompressionParameter=0.95f, const float localAdaptintegration_tau=0, const float localAdaptintegration_k=7);

+

+ /**

+ * method which allows retina to be applied on an input image, after run, encapsulated retina module is ready to deliver its outputs using dedicated acccessors, see getParvo and getMagno methods

+ * @param inputImage : the input cv::Mat image to be processed, can be gray level or BGR coded in any format (from 8bit to 16bits)

+ */

+ void run(const Mat &inputImage);

+

+ /**

+ * accessor of the details channel of the retina (models foveal vision)

+ * @param retinaOutput_parvo : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV

+ */

+ void getParvo(Mat &retinaOutput_parvo);

+

+ /**

+ * accessor of the details channel of the retina (models foveal vision)

+ * @param retinaOutput_parvo : the output buffer (reallocated if necessary), this output is the original retina filter model output, without any quantification or rescaling

+ */

+ void getParvo(std::valarray<float> &retinaOutput_parvo);

+

+ /**

+ * accessor of the motion channel of the retina (models peripheral vision)

+ * @param retinaOutput_magno : the output buffer (reallocated if necessary), this output is rescaled for standard 8bits image processing use in OpenCV

+ */

+ void getMagno(Mat &retinaOutput_magno);

+

+ /**

+ * accessor of the motion channel of the retina (models peripheral vision)

+ * @param retinaOutput_magno : the output buffer (reallocated if necessary), this output is the original retina filter model output, without any quantification or rescaling

+ */

+ void getMagno(std::valarray<float> &retinaOutput_magno);

+

+ // original API level data accessors : get buffers addresses...

+ const std::valarray<float> & getMagno() const;

+ const std::valarray<float> & getParvo() const;

+

+ /**

+ * activate color saturation as the final step of the color demultiplexing process

+ * -> this saturation is a sigmoide function applied to each channel of the demultiplexed image.

+ * @param saturateColors: boolean that activates color saturation (if true) or desactivate (if false)

+ * @param colorSaturationValue: the saturation factor

+ */

+ void setColorSaturation(const bool saturateColors=true, const float colorSaturationValue=4.0);

+

+ /**

+ * clear all retina buffers (equivalent to opening the eyes after a long period of eye close ;o)

+ */

+ void clearBuffers();

+

+ /**

+ * Activate/desactivate the Magnocellular pathway processing (motion information extraction), by default, it is activated

+ * @param activate: true if Magnocellular output should be activated, false if not

+ */

+ void activateMovingContoursProcessing(const bool activate);

+

+ /**

+ * Activate/desactivate the Parvocellular pathway processing (contours information extraction), by default, it is activated

+ * @param activate: true if Parvocellular (contours information extraction) output should be activated, false if not

+ */

+ void activateContoursProcessing(const bool activate);

+

+protected:

+ // Parameteres setup members

+ RetinaParameters _retinaParameters; // structure of parameters

+

+ // Retina model related modules

+ std::valarray<float> _inputBuffer; //!< buffer used to convert input cv::Mat to internal retina buffers format (valarrays)

+

+ // pointer to retina model

+ RetinaFilter* _retinaFilter; //!< the pointer to the retina module, allocated with instance construction

+

+ /**

+ * exports a valarray buffer outing from HVStools objects to a cv::Mat in CV_8UC1 (gray level picture) or CV_8UC3 (color) format

+ * @param grayMatrixToConvert the valarray to export to OpenCV

+ * @param nbRows : the number of rows of the valarray flatten matrix

+ * @param nbColumns : the number of rows of the valarray flatten matrix

+ * @param colorMode : a flag which mentions if matrix is color (true) or graylevel (false)

+ * @param outBuffer : the output matrix which is reallocated to satisfy Retina output buffer dimensions

+ */

+ void _convertValarrayBuffer2cvMat(const std::valarray<float> &grayMatrixToConvert, const unsigned int nbRows, const unsigned int nbColumns, const bool colorMode, Mat &outBuffer);

+

+ /**

+ *

+ * @param inputMatToConvert : the OpenCV cv::Mat that has to be converted to gray or RGB valarray buffer that will be processed by the retina model

+ * @param outputValarrayMatrix : the output valarray

+ * @return the input image color mode (color=true, gray levels=false)

+ */

+ bool _convertCvMat2ValarrayBuffer(const cv::Mat inputMatToConvert, std::valarray<float> &outputValarrayMatrix);

+

+ //! private method called by constructors, gathers their parameters and use them in a unified way

+ void _init(const Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod=RETINA_COLOR_BAYER, const bool useRetinaLogSampling=false, const double reductionFactor=1.0, const double samplingStrenght=10.0);

+

+

+};

+

+}

+#endif /* __OPENCV_CONTRIB_RETINA_HPP__ */

+/*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.

+//

+//

+// License Agreement

+// For Open Source Computer Vision Library

+//

+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.

+// Copyright (C) 2009-2011, 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.

+//

+//M*/

+

+#include "opencv2/core/core.hpp"

+/*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.

+//

+//

+// 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.

+// Copyright (C) 2013, OpenCV Foundation, 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.

+//

+//M*/

+

+#ifndef __OPENCV_CORE_AFFINE3_HPP__

+#define __OPENCV_CORE_AFFINE3_HPP__

+

+#ifdef __cplusplus

+

+#include <opencv2/core/core.hpp>

+

+/*! @file */

+

+namespace cv

+{

+ template<typename T>

+ class Affine3

+ {

+ public:

+ typedef T float_type;

+ typedef Matx<float_type, 3, 3> Mat3;

+ typedef Matx<float_type, 4, 4> Mat4;

+ typedef Vec<float_type, 3> Vec3;

+

+ Affine3();

+

+ //Augmented affine matrix

+ Affine3(const Mat4& affine);

+

+ //Rotation matrix

+ Affine3(const Mat3& R, const Vec3& t = Vec3::all(0));

+

+ //Rodrigues vector

+ Affine3(const Vec3& rvec, const Vec3& t = Vec3::all(0));

+

+ //Combines all contructors above. Supports 4x4, 4x3, 3x3, 1x3, 3x1 sizes of data matrix

+ explicit Affine3(const Mat& data, const Vec3& t = Vec3::all(0));

+

+ //From 16th element array

+ explicit Affine3(const float_type* vals);

+

+ static Affine3 Identity();

+

+ //Rotation matrix

+ void rotation(const Mat3& R);

+

+ //Rodrigues vector

+ void rotation(const Vec3& rvec);

+

+ //Combines rotation methods above. Suports 3x3, 1x3, 3x1 sizes of data matrix;

+ void rotation(const Mat& data);

+

+ void linear(const Mat3& L);

+ void translation(const Vec3& t);

+

+ Mat3 rotation() const;

+ Mat3 linear() const;

+ Vec3 translation() const;

+

+ //Rodrigues vector

+ Vec3 rvec() const;

+

+ Affine3 inv(int method = cv::DECOMP_SVD) const;

+

+ // a.rotate(R) is equivalent to Affine(R, 0) * a;

+ Affine3 rotate(const Mat3& R) const;

+

+ // a.rotate(R) is equivalent to Affine(rvec, 0) * a;

+ Affine3 rotate(const Vec3& rvec) const;

+

+ // a.translate(t) is equivalent to Affine(E, t) * a;

+ Affine3 translate(const Vec3& t) const;

+

+ // a.concatenate(affine) is equivalent to affine * a;

+ Affine3 concatenate(const Affine3& affine) const;

+

+ template <typename Y> operator Affine3<Y>() const;

+

+ template <typename Y> Affine3<Y> cast() const;

+

+ Mat4 matrix;

+

+#if defined EIGEN_WORLD_VERSION && defined EIGEN_GEOMETRY_MODULE_H

+ Affine3(const Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)>& affine);

+ Affine3(const Eigen::Transform<T, 3, Eigen::Affine>& affine);

+ operator Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)>() const;

+ operator Eigen::Transform<T, 3, Eigen::Affine>() const;

+#endif

+ };

+

+ template<typename T> static

+ Affine3<T> operator*(const Affine3<T>& affine1, const Affine3<T>& affine2);

+

+ template<typename T, typename V> static

+ V operator*(const Affine3<T>& affine, const V& vector);

+

+ typedef Affine3<float> Affine3f;

+ typedef Affine3<double> Affine3d;

+

+ static Vec3f operator*(const Affine3f& affine, const Vec3f& vector);

+ static Vec3d operator*(const Affine3d& affine, const Vec3d& vector);

+

+ template<typename _Tp> class DataType< Affine3<_Tp> >

+ {

+ public:

+ typedef Affine3<_Tp> value_type;

+ typedef Affine3<typename DataType<_Tp>::work_type> work_type;

+ typedef _Tp channel_type;

+

+ enum { generic_type = 0,

+ depth = DataType<channel_type>::depth,

+ channels = 16,

+ fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),

+ type = CV_MAKETYPE(depth, channels)

+ };

+

+ typedef Vec<channel_type, channels> vec_type;

+ };

+}

+

+

+///////////////////////////////////////////////////////////////////////////////////

+/// Implementaiton

+

+template<typename T> inline

+cv::Affine3<T>::Affine3()

+ : matrix(Mat4::eye())

+{}

+

+template<typename T> inline

+cv::Affine3<T>::Affine3(const Mat4& affine)

+ : matrix(affine)

+{}

+

+template<typename T> inline

+cv::Affine3<T>::Affine3(const Mat3& R, const Vec3& t)

+{

+ rotation(R);

+ translation(t);

+ matrix.val[12] = matrix.val[13] = matrix.val[14] = 0;

+ matrix.val[15] = 1;

+}

+

+template<typename T> inline

+cv::Affine3<T>::Affine3(const Vec3& _rvec, const Vec3& t)

+{

+ rotation(_rvec);

+ translation(t);

+ matrix.val[12] = matrix.val[13] = matrix.val[14] = 0;

+ matrix.val[15] = 1;

+}

+

+template<typename T> inline

+cv::Affine3<T>::Affine3(const cv::Mat& data, const Vec3& t)

+{

+ CV_Assert(data.type() == cv::DataType<T>::type);

+

+ if (data.cols == 4 && data.rows == 4)

+ {

+ data.copyTo(matrix);

+ return;

+ }

+ else if (data.cols == 4 && data.rows == 3)

+ {

+ rotation(data(Rect(0, 0, 3, 3)));

+ translation(data(Rect(3, 0, 1, 3)));

+ return;

+ }

+

+ rotation(data);

+ translation(t);

+ matrix.val[12] = matrix.val[13] = matrix.val[14] = 0;

+ matrix.val[15] = 1;

+}

+

+template<typename T> inline

+cv::Affine3<T>::Affine3(const float_type* vals) : matrix(vals)

+{}

+

+template<typename T> inline

+cv::Affine3<T> cv::Affine3<T>::Identity()

+{

+ return Affine3<T>(cv::Affine3<T>::Mat4::eye());

+}

+

+template<typename T> inline

+void cv::Affine3<T>::rotation(const Mat3& R)

+{

+ linear(R);

+}

+

+template<typename T> inline

+void cv::Affine3<T>::rotation(const Vec3& _rvec)

+{

+ double rx = _rvec[0], ry = _rvec[1], rz = _rvec[2];

+ double theta = std::sqrt(rx*rx + ry*ry + rz*rz);

+

+ if (theta < DBL_EPSILON)

+ rotation(Mat3::eye());

+ else

+ {

+ const double I[] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };

+

+ double c = std::cos(theta);

+ double s = std::sin(theta);

+ double c1 = 1. - c;

+ double itheta = (theta != 0) ? 1./theta : 0.;

+

+ rx *= itheta; ry *= itheta; rz *= itheta;

+

+ double rrt[] = { rx*rx, rx*ry, rx*rz, rx*ry, ry*ry, ry*rz, rx*rz, ry*rz, rz*rz };

+ double _r_x_[] = { 0, -rz, ry, rz, 0, -rx, -ry, rx, 0 };

+ Mat3 R;

+

+ // R = cos(theta)*I + (1 - cos(theta))*r*rT + sin(theta)*[r_x]

+ // where [r_x] is [0 -rz ry; rz 0 -rx; -ry rx 0]

+ for(int k = 0; k < 9; ++k)

+ R.val[k] = static_cast<float_type>(c*I[k] + c1*rrt[k] + s*_r_x_[k]);

+

+ rotation(R);

+ }

+}

+

+//Combines rotation methods above. Suports 3x3, 1x3, 3x1 sizes of data matrix;

+template<typename T> inline

+void cv::Affine3<T>::rotation(const cv::Mat& data)

+{

+ CV_Assert(data.type() == cv::DataType<T>::type);

+

+ if (data.cols == 3 && data.rows == 3)

+ {

+ Mat3 R;

+ data.copyTo(R);

+ rotation(R);

+ }

+ else if ((data.cols == 3 && data.rows == 1) || (data.cols == 1 && data.rows == 3))

+ {

+ Vec3 _rvec;

+ data.reshape(1, 3).copyTo(_rvec);

+ rotation(_rvec);

+ }

+ else

+ CV_Assert(!"Input marix can be 3x3, 1x3 or 3x1");

+}

+

+template<typename T> inline

+void cv::Affine3<T>::linear(const Mat3& L)

+{

+ matrix.val[0] = L.val[0]; matrix.val[1] = L.val[1]; matrix.val[ 2] = L.val[2];

+ matrix.val[4] = L.val[3]; matrix.val[5] = L.val[4]; matrix.val[ 6] = L.val[5];

+ matrix.val[8] = L.val[6]; matrix.val[9] = L.val[7]; matrix.val[10] = L.val[8];

+}

+

+template<typename T> inline

+void cv::Affine3<T>::translation(const Vec3& t)

+{

+ matrix.val[3] = t[0]; matrix.val[7] = t[1]; matrix.val[11] = t[2];

+}

+

+template<typename T> inline

+typename cv::Affine3<T>::Mat3 cv::Affine3<T>::rotation() const

+{

+ return linear();

+}

+

+template<typename T> inline

+typename cv::Affine3<T>::Mat3 cv::Affine3<T>::linear() const

+{

+ typename cv::Affine3<T>::Mat3 R;

+ R.val[0] = matrix.val[0]; R.val[1] = matrix.val[1]; R.val[2] = matrix.val[ 2];

+ R.val[3] = matrix.val[4]; R.val[4] = matrix.val[5]; R.val[5] = matrix.val[ 6];

+ R.val[6] = matrix.val[8]; R.val[7] = matrix.val[9]; R.val[8] = matrix.val[10];

+ return R;

+}

+

+template<typename T> inline

+typename cv::Affine3<T>::Vec3 cv::Affine3<T>::translation() const

+{

+ return Vec3(matrix.val[3], matrix.val[7], matrix.val[11]);

+}

+

+template<typename T> inline

+typename cv::Affine3<T>::Vec3 cv::Affine3<T>::rvec() const

+{

+ cv::Vec3d w;

+ cv::Matx33d u, vt, R = rotation();

+ cv::SVD::compute(R, w, u, vt, cv::SVD::FULL_UV + cv::SVD::MODIFY_A);

+ R = u * vt;

+

+ double rx = R.val[7] - R.val[5];

+ double ry = R.val[2] - R.val[6];

+ double rz = R.val[3] - R.val[1];

+

+ double s = std::sqrt((rx*rx + ry*ry + rz*rz)*0.25);

+ double c = (R.val[0] + R.val[4] + R.val[8] - 1) * 0.5;

+ c = c > 1.0 ? 1.0 : c < -1.0 ? -1.0 : c;

+ double theta = acos(c);

+

+ if( s < 1e-5 )

+ {

+ if( c > 0 )

+ rx = ry = rz = 0;

+ else

+ {

+ double t;

+ t = (R.val[0] + 1) * 0.5;

+ rx = std::sqrt(std::max(t, 0.0));

+ t = (R.val[4] + 1) * 0.5;

+ ry = std::sqrt(std::max(t, 0.0)) * (R.val[1] < 0 ? -1.0 : 1.0);

+ t = (R.val[8] + 1) * 0.5;

+ rz = std::sqrt(std::max(t, 0.0)) * (R.val[2] < 0 ? -1.0 : 1.0);

+

+ if( fabs(rx) < fabs(ry) && fabs(rx) < fabs(rz) && (R.val[5] > 0) != (ry*rz > 0) )

+ rz = -rz;

+ theta /= std::sqrt(rx*rx + ry*ry + rz*rz);

+ rx *= theta;

+ ry *= theta;

+ rz *= theta;

+ }

+ }

+ else

+ {

+ double vth = 1/(2*s);

+ vth *= theta;

+ rx *= vth; ry *= vth; rz *= vth;

+ }

+

+ return cv::Vec3d(rx, ry, rz);

+}

+

+template<typename T> inline

+cv::Affine3<T> cv::Affine3<T>::inv(int method) const

+{

+ return matrix.inv(method);

+}

+

+template<typename T> inline

+cv::Affine3<T> cv::Affine3<T>::rotate(const Mat3& R) const

+{

+ Mat3 Lc = linear();

+ Vec3 tc = translation();

+ Mat4 result;

+ result.val[12] = result.val[13] = result.val[14] = 0;

+ result.val[15] = 1;

+

+ for(int j = 0; j < 3; ++j)

+ {

+ for(int i = 0; i < 3; ++i)

+ {

+ float_type value = 0;

+ for(int k = 0; k < 3; ++k)

+ value += R(j, k) * Lc(k, i);

+ result(j, i) = value;

+ }

+

+ result(j, 3) = R.row(j).dot(tc.t());

+ }

+ return result;

+}

+

+template<typename T> inline

+cv::Affine3<T> cv::Affine3<T>::rotate(const Vec3& _rvec) const

+{

+ return rotate(Affine3f(_rvec).rotation());

+}

+

+template<typename T> inline

+cv::Affine3<T> cv::Affine3<T>::translate(const Vec3& t) const

+{

+ Mat4 m = matrix;

+ m.val[ 3] += t[0];

+ m.val[ 7] += t[1];

+ m.val[11] += t[2];

+ return m;

+}

+

+template<typename T> inline

+cv::Affine3<T> cv::Affine3<T>::concatenate(const Affine3<T>& affine) const

+{

+ return (*this).rotate(affine.rotation()).translate(affine.translation());

+}

+

+template<typename T> template <typename Y> inline

+cv::Affine3<T>::operator Affine3<Y>() const

+{

+ return Affine3<Y>(matrix);

+}

+

+template<typename T> template <typename Y> inline

+cv::Affine3<Y> cv::Affine3<T>::cast() const

+{

+ return Affine3<Y>(matrix);

+}

+

+/** @cond IGNORED */

+template<typename T> inline

+cv::Affine3<T> cv::operator*(const cv::Affine3<T>& affine1, const cv::Affine3<T>& affine2)

+{

+ return affine2.concatenate(affine1);

+}

+

+template<typename T, typename V> inline

+V cv::operator*(const cv::Affine3<T>& affine, const V& v)

+{

+ const typename Affine3<T>::Mat4& m = affine.matrix;

+

+ V r;

+ r.x = m.val[0] * v.x + m.val[1] * v.y + m.val[ 2] * v.z + m.val[ 3];

+ r.y = m.val[4] * v.x + m.val[5] * v.y + m.val[ 6] * v.z + m.val[ 7];

+ r.z = m.val[8] * v.x + m.val[9] * v.y + m.val[10] * v.z + m.val[11];

+ return r;

+}

+/** @endcond */

+

+static inline

+cv::Vec3f cv::operator*(const cv::Affine3f& affine, const cv::Vec3f& v)

+{

+ const cv::Matx44f& m = affine.matrix;

+ cv::Vec3f r;

+ r.val[0] = m.val[0] * v[0] + m.val[1] * v[1] + m.val[ 2] * v[2] + m.val[ 3];

+ r.val[1] = m.val[4] * v[0] + m.val[5] * v[1] + m.val[ 6] * v[2] + m.val[ 7];

+ r.val[2] = m.val[8] * v[0] + m.val[9] * v[1] + m.val[10] * v[2] + m.val[11];

+ return r;

+}

+

+static inline

+cv::Vec3d cv::operator*(const cv::Affine3d& affine, const cv::Vec3d& v)

+{

+ const cv::Matx44d& m = affine.matrix;

+ cv::Vec3d r;

+ r.val[0] = m.val[0] * v[0] + m.val[1] * v[1] + m.val[ 2] * v[2] + m.val[ 3];

+ r.val[1] = m.val[4] * v[0] + m.val[5] * v[1] + m.val[ 6] * v[2] + m.val[ 7];

+ r.val[2] = m.val[8] * v[0] + m.val[9] * v[1] + m.val[10] * v[2] + m.val[11];

+ return r;

+}

+

+

+

+#if defined EIGEN_WORLD_VERSION && defined EIGEN_GEOMETRY_MODULE_H

+

+template<typename T> inline

+cv::Affine3<T>::Affine3(const Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)>& affine)

+{

+ cv::Mat(4, 4, cv::DataType<T>::type, affine.matrix().data()).copyTo(matrix);

+}

+

+template<typename T> inline

+cv::Affine3<T>::Affine3(const Eigen::Transform<T, 3, Eigen::Affine>& affine)

+{

+ Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)> a = affine;

+ cv::Mat(4, 4, cv::DataType<T>::type, a.matrix().data()).copyTo(matrix);

+}

+

+template<typename T> inline

+cv::Affine3<T>::operator Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)>() const

+{

+ Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)> r;

+ cv::Mat hdr(4, 4, cv::DataType<T>::type, r.matrix().data());

+ cv::Mat(matrix, false).copyTo(hdr);

+ return r;

+}

+

+template<typename T> inline

+cv::Affine3<T>::operator Eigen::Transform<T, 3, Eigen::Affine>() const

+{

+ return this->operator Eigen::Transform<T, 3, Eigen::Affine, (Eigen::RowMajor)>();

+}

+

+#endif /* defined EIGEN_WORLD_VERSION && defined EIGEN_GEOMETRY_MODULE_H */

+

+

+#endif /* __cplusplus */

+

+#endif /* __OPENCV_CORE_AFFINE3_HPP__ */

+/*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.

+//

+//

+// License Agreement

+// For Open Source Computer Vision Library

+//

+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.

+// Copyright (C) 2009-2011, 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.

+//

+//M*/

+

+#ifndef __OPENCV_CORE_HPP__

+#define __OPENCV_CORE_HPP__

+

+#include "opencv2/core/types_c.h"

+#include "opencv2/core/version.hpp"

+

+#ifdef __cplusplus

+

+#ifndef SKIP_INCLUDES

+#include <limits.h>

+#include <algorithm>

+#include <cmath>

+#include <cstddef>

+#include <complex>

+#include <map>

+#include <new>

+#include <string>

+#include <vector>

+#include <sstream>

+#endif // SKIP_INCLUDES

+

+/*! \namespace cv

+ Namespace where all the C++ OpenCV functionality resides

+*/

+namespace cv {

+

+#undef abs

+#undef min

+#undef max

+#undef Complex

+

+using std::vector;

+using std::string;

+using std::ptrdiff_t;

+

+template<typename _Tp> class Size_;

+template<typename _Tp> class Point_;

+template<typename _Tp> class Rect_;

+template<typename _Tp, int cn> class Vec;

+template<typename _Tp, int m, int n> class Matx;

+

+typedef std::string String;

+

+class Mat;

+class SparseMat;

+typedef Mat MatND;

+

+namespace ogl {

+ class Buffer;

+ class Texture2D;

+ class Arrays;

+}

+

+// < Deprecated

+class GlBuffer;

+class GlTexture;

+class GlArrays;

+class GlCamera;

+// >

+

+namespace gpu {

+ class GpuMat;

+}

+

+class CV_EXPORTS MatExpr;

+class CV_EXPORTS MatOp_Base;

+class CV_EXPORTS MatArg;

+class CV_EXPORTS MatConstIterator;

+

+template<typename _Tp> class Mat_;

+template<typename _Tp> class MatIterator_;

+template<typename _Tp> class MatConstIterator_;

+template<typename _Tp> class MatCommaInitializer_;

+

+#if !defined(ANDROID) || (defined(_GLIBCXX_USE_WCHAR_T) && _GLIBCXX_USE_WCHAR_T)

+typedef std::basic_string<wchar_t> WString;

+

+CV_EXPORTS string fromUtf16(const WString& str);

+CV_EXPORTS WString toUtf16(const string& str);

+#endif

+

+CV_EXPORTS string format( const char* fmt, ... );

+CV_EXPORTS string tempfile( const char* suffix CV_DEFAULT(0));

+

+// matrix decomposition types

+enum { DECOMP_LU=0, DECOMP_SVD=1, DECOMP_EIG=2, DECOMP_CHOLESKY=3, DECOMP_QR=4, DECOMP_NORMAL=16 };

+enum { NORM_INF=1, NORM_L1=2, NORM_L2=4, NORM_L2SQR=5, NORM_HAMMING=6, NORM_HAMMING2=7, NORM_TYPE_MASK=7, NORM_RELATIVE=8, NORM_MINMAX=32 };

+enum { CMP_EQ=0, CMP_GT=1, CMP_GE=2, CMP_LT=3, CMP_LE=4, CMP_NE=5 };

+enum { GEMM_1_T=1, GEMM_2_T=2, GEMM_3_T=4 };

+enum { DFT_INVERSE=1, DFT_SCALE=2, DFT_ROWS=4, DFT_COMPLEX_OUTPUT=16, DFT_REAL_OUTPUT=32,

+ DCT_INVERSE = DFT_INVERSE, DCT_ROWS=DFT_ROWS };

+

+

+/*!

+ The standard OpenCV exception class.

+ Instances of the class are thrown by various functions and methods in the case of critical errors.

+ */

+class CV_EXPORTS Exception : public std::exception

+{

+public:

+ /*!

+ Default constructor

+ */

+ Exception();

+ /*!

+ Full constructor. Normally the constuctor is not called explicitly.

+ Instead, the macros CV_Error(), CV_Error_() and CV_Assert() are used.

+ */

+ Exception(int _code, const string& _err, const string& _func, const string& _file, int _line);

+ virtual ~Exception() throw();

+

+ /*!

+ \return the error description and the context as a text string.

+ */

+ virtual const char *what() const throw();

+ void formatMessage();

+

+ string msg; ///< the formatted error message

+

+ int code; ///< error code @see CVStatus

+ string err; ///< error description

+ string func; ///< function name. Available only when the compiler supports getting it

+ string file; ///< source file name where the error has occured

+ int line; ///< line number in the source file where the error has occured

+};

+

+

+//! Signals an error and raises the exception.

+

+/*!

+ By default the function prints information about the error to stderr,

+ then it either stops if setBreakOnError() had been called before or raises the exception.

+ It is possible to alternate error processing by using redirectError().

+

+ \param exc the exception raisen.

+ */

+CV_EXPORTS void error( const Exception& exc );

+

+//! Sets/resets the break-on-error mode.

+

+/*!

+ When the break-on-error mode is set, the default error handler

+ issues a hardware exception, which can make debugging more convenient.

+

+ \return the previous state

+ */

+CV_EXPORTS bool setBreakOnError(bool flag);

+

+typedef int (CV_CDECL *ErrorCallback)( int status, const char* func_name,

+ const char* err_msg, const char* file_name,

+ int line, void* userdata );

+

+//! Sets the new error handler and the optional user data.

+

+/*!

+ The function sets the new error handler, called from cv::error().

+

+ \param errCallback the new error handler. If NULL, the default error handler is used.

+ \param userdata the optional user data pointer, passed to the callback.

+ \param prevUserdata the optional output parameter where the previous user data pointer is stored

+

+ \return the previous error handler

+*/

+CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback,

+ void* userdata=0, void** prevUserdata=0);

+

+

+#if defined __GNUC__

+#define CV_Func __func__

+#elif defined _MSC_VER

+#define CV_Func __FUNCTION__

+#else

+#define CV_Func ""

+#endif

+

+#define CV_Error( code, msg ) cv::error( cv::Exception(code, msg, CV_Func, __FILE__, __LINE__) )

+#define CV_Error_( code, args ) cv::error( cv::Exception(code, cv::format args, CV_Func, __FILE__, __LINE__) )

+#define CV_Assert( expr ) if(!!(expr)) ; else cv::error( cv::Exception(CV_StsAssert, #expr, CV_Func, __FILE__, __LINE__) )

+

+#ifdef _DEBUG

+#define CV_DbgAssert(expr) CV_Assert(expr)

+#else

+#define CV_DbgAssert(expr)

+#endif

+

+CV_EXPORTS void glob(String pattern, std::vector<String>& result, bool recursive = false);

+

+CV_EXPORTS_W void setNumThreads(int nthreads);

+CV_EXPORTS_W int getNumThreads();

+CV_EXPORTS_W int getThreadNum();

+

+CV_EXPORTS_W const string& getBuildInformation();

+

+//! Returns the number of ticks.

+

+/*!

+ The function returns the number of ticks since the certain event (e.g. when the machine was turned on).

+ It can be used to initialize cv::RNG or to measure a function execution time by reading the tick count

+ before and after the function call. The granularity of ticks depends on the hardware and OS used. Use

+ cv::getTickFrequency() to convert ticks to seconds.

+*/

+CV_EXPORTS_W int64 getTickCount();

+

+/*!

+ Returns the number of ticks per seconds.

+

+ The function returns the number of ticks (as returned by cv::getTickCount()) per second.

+ The following code computes the execution time in milliseconds:

+

+ \code

+ double exec_time = (double)getTickCount();

+ // do something ...

+ exec_time = ((double)getTickCount() - exec_time)*1000./getTickFrequency();

+ \endcode

+*/

+CV_EXPORTS_W double getTickFrequency();

+

+/*!

+ Returns the number of CPU ticks.

+

+ On platforms where the feature is available, the function returns the number of CPU ticks

+ since the certain event (normally, the system power-on moment). Using this function

+ one can accurately measure the execution time of very small code fragments,

+ for which cv::getTickCount() granularity is not enough.

+*/

+CV_EXPORTS_W int64 getCPUTickCount();

+

+/*!

+ Returns SSE etc. support status

+

+ The function returns true if certain hardware features are available.

+ Currently, the following features are recognized:

+ - CV_CPU_MMX - MMX

+ - CV_CPU_SSE - SSE

+ - CV_CPU_SSE2 - SSE 2

+ - CV_CPU_SSE3 - SSE 3

+ - CV_CPU_SSSE3 - SSSE 3

+ - CV_CPU_SSE4_1 - SSE 4.1

+ - CV_CPU_SSE4_2 - SSE 4.2

+ - CV_CPU_POPCNT - POPCOUNT

+ - CV_CPU_AVX - AVX

+ - CV_CPU_AVX2 - AVX2

+

+ \note {Note that the function output is not static. Once you called cv::useOptimized(false),

+ most of the hardware acceleration is disabled and thus the function will returns false,

+ until you call cv::useOptimized(true)}

+*/

+CV_EXPORTS_W bool checkHardwareSupport(int feature);

+

+//! returns the number of CPUs (including hyper-threading)

+CV_EXPORTS_W int getNumberOfCPUs();

+

+/*!

+ Allocates memory buffer

+

+ This is specialized OpenCV memory allocation function that returns properly aligned memory buffers.

+ The usage is identical to malloc(). The allocated buffers must be freed with cv::fastFree().

+ If there is not enough memory, the function calls cv::error(), which raises an exception.

+

+ \param bufSize buffer size in bytes

+ \return the allocated memory buffer.

+*/

+CV_EXPORTS void* fastMalloc(size_t bufSize);

+

+/*!

+ Frees the memory allocated with cv::fastMalloc

+

+ This is the corresponding deallocation function for cv::fastMalloc().

+ When ptr==NULL, the function has no effect.

+*/

+CV_EXPORTS void fastFree(void* ptr);

+

+template<typename _Tp> static inline _Tp* allocate(size_t n)

+{

+ return new _Tp[n];

+}

+

+template<typename _Tp> static inline void deallocate(_Tp* ptr, size_t)

+{

+ delete[] ptr;

+}

+

+/*!

+ Aligns pointer by the certain number of bytes

+

+ This small inline function aligns the pointer by the certian number of bytes by shifting

+ it forward by 0 or a positive offset.

+*/

+template<typename _Tp> static inline _Tp* alignPtr(_Tp* ptr, int n=(int)sizeof(_Tp))

+{

+ return (_Tp*)(((size_t)ptr + n-1) & -n);

+}

+

+/*!

+ Aligns buffer size by the certain number of bytes

+

+ This small inline function aligns a buffer size by the certian number of bytes by enlarging it.

+*/

+static inline size_t alignSize(size_t sz, int n)

+{

+ assert((n & (n - 1)) == 0); // n is a power of 2

+ return (sz + n-1) & -n;

+}

+

+/*!

+ Turns on/off available optimization

+

+ The function turns on or off the optimized code in OpenCV. Some optimization can not be enabled

+ or disabled, but, for example, most of SSE code in OpenCV can be temporarily turned on or off this way.

+

+ \note{Since optimization may imply using special data structures, it may be unsafe

+ to call this function anywhere in the code. Instead, call it somewhere at the top level.}

+*/

+CV_EXPORTS_W void setUseOptimized(bool onoff);

+

+/*!

+ Returns the current optimization status

+

+ The function returns the current optimization status, which is controlled by cv::setUseOptimized().

+*/

+CV_EXPORTS_W bool useOptimized();

+

+/*!

+ The STL-compilant memory Allocator based on cv::fastMalloc() and cv::fastFree()

+*/

+template<typename _Tp> class Allocator

+{

+public:

+ typedef _Tp value_type;

+ typedef value_type* pointer;

+ typedef const value_type* const_pointer;

+ typedef value_type& reference;

+ typedef const value_type& const_reference;

+ typedef size_t size_type;

+ typedef ptrdiff_t difference_type;

+ template<typename U> class rebind { typedef Allocator<U> other; };

+

+ explicit Allocator() {}

+ ~Allocator() {}

+ explicit Allocator(Allocator const&) {}

+ template<typename U>

+ explicit Allocator(Allocator<U> const&) {}

+

+ // address

+ pointer address(reference r) { return &r; }

+ const_pointer address(const_reference r) { return &r; }

+

+ pointer allocate(size_type count, const void* =0)

+ { return reinterpret_cast<pointer>(fastMalloc(count * sizeof (_Tp))); }

+

+ void deallocate(pointer p, size_type) {fastFree(p); }

+

+ size_type max_size() const

+ { return max(static_cast<_Tp>(-1)/sizeof(_Tp), 1); }

+

+ void construct(pointer p, const _Tp& v) { new(static_cast<void*>(p)) _Tp(v); }

+ void destroy(pointer p) { p->~_Tp(); }

+};

+

+/////////////////////// Vec (used as element of multi-channel images /////////////////////

+

+/*!

+ A helper class for cv::DataType

+

+ The class is specialized for each fundamental numerical data type supported by OpenCV.

+ It provides DataDepth<T>::value constant.

+*/

+template<typename _Tp> class DataDepth {};

+

+template<> class DataDepth<bool> { public: enum { value = CV_8U, fmt=(int)'u' }; };

+template<> class DataDepth<uchar> { public: enum { value = CV_8U, fmt=(int)'u' }; };

+template<> class DataDepth<schar> { public: enum { value = CV_8S, fmt=(int)'c' }; };

+template<> class DataDepth<char> { public: enum { value = CV_8S, fmt=(int)'c' }; };

+template<> class DataDepth<ushort> { public: enum { value = CV_16U, fmt=(int)'w' }; };

+template<> class DataDepth<short> { public: enum { value = CV_16S, fmt=(int)'s' }; };

+template<> class DataDepth<int> { public: enum { value = CV_32S, fmt=(int)'i' }; };

+// this is temporary solution to support 32-bit unsigned integers

+template<> class DataDepth<unsigned> { public: enum { value = CV_32S, fmt=(int)'i' }; };

+template<> class DataDepth<float> { public: enum { value = CV_32F, fmt=(int)'f' }; };

+template<> class DataDepth<double> { public: enum { value = CV_64F, fmt=(int)'d' }; };

+template<typename _Tp> class DataDepth<_Tp*> { public: enum { value = CV_USRTYPE1, fmt=(int)'r' }; };

+

+

+////////////////////////////// Small Matrix ///////////////////////////

+

+/*!

+ A short numerical vector.

+

+ This template class represents short numerical vectors (of 1, 2, 3, 4 ... elements)

+ on which you can perform basic arithmetical operations, access individual elements using [] operator etc.

+ The vectors are allocated on stack, as opposite to std::valarray, std::vector, cv::Mat etc.,

+ which elements are dynamically allocated in the heap.

+

+ The template takes 2 parameters:

+ -# _Tp element type

+ -# cn the number of elements

+

+ In addition to the universal notation like Vec<float, 3>, you can use shorter aliases

+ for the most popular specialized variants of Vec, e.g. Vec3f ~ Vec<float, 3>.

+ */

+

+struct CV_EXPORTS Matx_AddOp {};

+struct CV_EXPORTS Matx_SubOp {};

+struct CV_EXPORTS Matx_ScaleOp {};

+struct CV_EXPORTS Matx_MulOp {};

+struct CV_EXPORTS Matx_MatMulOp {};

+struct CV_EXPORTS Matx_TOp {};

+

+template<typename _Tp, int m, int n> class Matx

+{

+public:

+ typedef _Tp value_type;

+ typedef Matx<_Tp, (m < n ? m : n), 1> diag_type;

+ typedef Matx<_Tp, m, n> mat_type;

+ enum { depth = DataDepth<_Tp>::value, rows = m, cols = n, channels = rows*cols,

+ type = CV_MAKETYPE(depth, channels) };

+

+ //! default constructor

+ Matx();

+

+ Matx(_Tp v0); //!< 1x1 matrix

+ Matx(_Tp v0, _Tp v1); //!< 1x2 or 2x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2); //!< 1x3 or 3x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3); //!< 1x4, 2x2 or 4x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 1x5 or 5x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5); //!< 1x6, 2x3, 3x2 or 6x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6); //!< 1x7 or 7x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7); //!< 1x8, 2x4, 4x2 or 8x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8); //!< 1x9, 3x3 or 9x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9); //!< 1x10, 2x5 or 5x2 or 10x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,

+ _Tp v4, _Tp v5, _Tp v6, _Tp v7,

+ _Tp v8, _Tp v9, _Tp v10, _Tp v11); //!< 1x12, 2x6, 3x4, 4x3, 6x2 or 12x1 matrix

+ Matx(_Tp v0, _Tp v1, _Tp v2, _Tp v3,

+ _Tp v4, _Tp v5, _Tp v6, _Tp v7,

+ _Tp v8, _Tp v9, _Tp v10, _Tp v11,

+ _Tp v12, _Tp v13, _Tp v14, _Tp v15); //!< 1x16, 4x4 or 16x1 matrix

+ explicit Matx(const _Tp* vals); //!< initialize from a plain array

+

+ static Matx all(_Tp alpha);

+ static Matx zeros();

+ static Matx ones();

+ static Matx eye();

+ static Matx diag(const diag_type& d);

+ static Matx randu(_Tp a, _Tp b);

+ static Matx randn(_Tp a, _Tp b);

+

+ //! dot product computed with the default precision

+ _Tp dot(const Matx<_Tp, m, n>& v) const;

+

+ //! dot product computed in double-precision arithmetics

+ double ddot(const Matx<_Tp, m, n>& v) const;

+

+ //! conversion to another data type

+ template<typename T2> operator Matx<T2, m, n>() const;

+

+ //! change the matrix shape

+ template<int m1, int n1> Matx<_Tp, m1, n1> reshape() const;

+

+ //! extract part of the matrix

+ template<int m1, int n1> Matx<_Tp, m1, n1> get_minor(int i, int j) const;

+

+ //! extract the matrix row

+ Matx<_Tp, 1, n> row(int i) const;

+

+ //! extract the matrix column

+ Matx<_Tp, m, 1> col(int i) const;

+

+ //! extract the matrix diagonal

+ diag_type diag() const;

+

+ //! transpose the matrix

+ Matx<_Tp, n, m> t() const;

+

+ //! invert matrix the matrix

+ Matx<_Tp, n, m> inv(int method=DECOMP_LU) const;

+

+ //! solve linear system

+ template<int l> Matx<_Tp, n, l> solve(const Matx<_Tp, m, l>& rhs, int flags=DECOMP_LU) const;

+ Vec<_Tp, n> solve(const Vec<_Tp, m>& rhs, int method) const;

+

+ //! multiply two matrices element-wise

+ Matx<_Tp, m, n> mul(const Matx<_Tp, m, n>& a) const;

+

+ //! element access

+ const _Tp& operator ()(int i, int j) const;

+ _Tp& operator ()(int i, int j);

+

+ //! 1D element access

+ const _Tp& operator ()(int i) const;

+ _Tp& operator ()(int i);

+

+ Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_AddOp);

+ Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_SubOp);

+ template<typename _T2> Matx(const Matx<_Tp, m, n>& a, _T2 alpha, Matx_ScaleOp);

+ Matx(const Matx<_Tp, m, n>& a, const Matx<_Tp, m, n>& b, Matx_MulOp);

+ template<int l> Matx(const Matx<_Tp, m, l>& a, const Matx<_Tp, l, n>& b, Matx_MatMulOp);

+ Matx(const Matx<_Tp, n, m>& a, Matx_TOp);

+

+ _Tp val[m*n]; //< matrix elements

+};

+

+

+typedef Matx<float, 1, 2> Matx12f;

+typedef Matx<double, 1, 2> Matx12d;

+typedef Matx<float, 1, 3> Matx13f;

+typedef Matx<double, 1, 3> Matx13d;

+typedef Matx<float, 1, 4> Matx14f;

+typedef Matx<double, 1, 4> Matx14d;

+typedef Matx<float, 1, 6> Matx16f;

+typedef Matx<double, 1, 6> Matx16d;

+

+typedef Matx<float, 2, 1> Matx21f;

+typedef Matx<double, 2, 1> Matx21d;

+typedef Matx<float, 3, 1> Matx31f;

+typedef Matx<double, 3, 1> Matx31d;

+typedef Matx<float, 4, 1> Matx41f;

+typedef Matx<double, 4, 1> Matx41d;

+typedef Matx<float, 6, 1> Matx61f;

+typedef Matx<double, 6, 1> Matx61d;

+

+typedef Matx<float, 2, 2> Matx22f;

+typedef Matx<double, 2, 2> Matx22d;

+typedef Matx<float, 2, 3> Matx23f;

+typedef Matx<double, 2, 3> Matx23d;

+typedef Matx<float, 3, 2> Matx32f;

+typedef Matx<double, 3, 2> Matx32d;

+

+typedef Matx<float, 3, 3> Matx33f;

+typedef Matx<double, 3, 3> Matx33d;

+

+typedef Matx<float, 3, 4> Matx34f;

+typedef Matx<double, 3, 4> Matx34d;

+typedef Matx<float, 4, 3> Matx43f;

+typedef Matx<double, 4, 3> Matx43d;

+

+typedef Matx<float, 4, 4> Matx44f;

+typedef Matx<double, 4, 4> Matx44d;

+typedef Matx<float, 6, 6> Matx66f;

+typedef Matx<double, 6, 6> Matx66d;

+

+

+/*!

+ A short numerical vector.

+

+ This template class represents short numerical vectors (of 1, 2, 3, 4 ... elements)

+ on which you can perform basic arithmetical operations, access individual elements using [] operator etc.

+ The vectors are allocated on stack, as opposite to std::valarray, std::vector, cv::Mat etc.,

+ which elements are dynamically allocated in the heap.

+

+ The template takes 2 parameters:

+ -# _Tp element type

+ -# cn the number of elements

+

+ In addition to the universal notation like Vec<float, 3>, you can use shorter aliases

+ for the most popular specialized variants of Vec, e.g. Vec3f ~ Vec<float, 3>.

+*/

+template<typename _Tp, int cn> class Vec : public Matx<_Tp, cn, 1>

+{

+public:

+ typedef _Tp value_type;

+ enum { depth = DataDepth<_Tp>::value, channels = cn, type = CV_MAKETYPE(depth, channels) };

+

+ //! default constructor

+ Vec();

+

+ Vec(_Tp v0); //!< 1-element vector constructor

+ Vec(_Tp v0, _Tp v1); //!< 2-element vector constructor

+ Vec(_Tp v0, _Tp v1, _Tp v2); //!< 3-element vector constructor

+ Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3); //!< 4-element vector constructor

+ Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4); //!< 5-element vector constructor

+ Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5); //!< 6-element vector constructor

+ Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6); //!< 7-element vector constructor

+ Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7); //!< 8-element vector constructor

+ Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8); //!< 9-element vector constructor

+ Vec(_Tp v0, _Tp v1, _Tp v2, _Tp v3, _Tp v4, _Tp v5, _Tp v6, _Tp v7, _Tp v8, _Tp v9); //!< 10-element vector constructor

+ explicit Vec(const _Tp* values);

+

+ Vec(const Vec<_Tp, cn>& v);

+

+ static Vec all(_Tp alpha);

+

+ //! per-element multiplication

+ Vec mul(const Vec<_Tp, cn>& v) const;

+

+ //! conjugation (makes sense for complex numbers and quaternions)

+ Vec conj() const;

+

+ /*!

+ cross product of the two 3D vectors.

+

+ For other dimensionalities the exception is raised

+ */

+ Vec cross(const Vec& v) const;

+ //! conversion to another data type

+ template<typename T2> operator Vec<T2, cn>() const;

+ //! conversion to 4-element CvScalar.

+ operator CvScalar() const;

+

+ /*! element access */

+ const _Tp& operator [](int i) const;

+ _Tp& operator[](int i);

+ const _Tp& operator ()(int i) const;

+ _Tp& operator ()(int i);

+

+ Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_AddOp);

+ Vec(const Matx<_Tp, cn, 1>& a, const Matx<_Tp, cn, 1>& b, Matx_SubOp);

+ template<typename _T2> Vec(const Matx<_Tp, cn, 1>& a, _T2 alpha, Matx_ScaleOp);

+};

+

+

+/* \typedef

+

+ Shorter aliases for the most popular specializations of Vec<T,n>

+*/

+typedef Vec<uchar, 2> Vec2b;

+typedef Vec<uchar, 3> Vec3b;

+typedef Vec<uchar, 4> Vec4b;

+

+typedef Vec<short, 2> Vec2s;

+typedef Vec<short, 3> Vec3s;

+typedef Vec<short, 4> Vec4s;

+

+typedef Vec<ushort, 2> Vec2w;

+typedef Vec<ushort, 3> Vec3w;

+typedef Vec<ushort, 4> Vec4w;

+

+typedef Vec<int, 2> Vec2i;

+typedef Vec<int, 3> Vec3i;

+typedef Vec<int, 4> Vec4i;

+typedef Vec<int, 6> Vec6i;

+typedef Vec<int, 8> Vec8i;

+

+typedef Vec<float, 2> Vec2f;

+typedef Vec<float, 3> Vec3f;

+typedef Vec<float, 4> Vec4f;

+typedef Vec<float, 6> Vec6f;

+

+typedef Vec<double, 2> Vec2d;

+typedef Vec<double, 3> Vec3d;

+typedef Vec<double, 4> Vec4d;

+typedef Vec<double, 6> Vec6d;

+

+

+//////////////////////////////// Complex //////////////////////////////

+

+/*!

+ A complex number class.

+

+ The template class is similar and compatible with std::complex, however it provides slightly

+ more convenient access to the real and imaginary parts using through the simple field access, as opposite

+ to std::complex::real() and std::complex::imag().

+*/

+template<typename _Tp> class Complex

+{

+public:

+

+ //! constructors

+ Complex();

+ Complex( _Tp _re, _Tp _im=0 );

+ Complex( const std::complex<_Tp>& c );

+

+ //! conversion to another data type

+ template<typename T2> operator Complex<T2>() const;

+ //! conjugation

+ Complex conj() const;

+ //! conversion to std::complex

+ operator std::complex<_Tp>() const;

+

+ _Tp re, im; //< the real and the imaginary parts

+};

+

+

+typedef Complex<float> Complexf;

+typedef Complex<double> Complexd;

+

+

+//////////////////////////////// Point_ ////////////////////////////////

+

+/*!

+ template 2D point class.

+

+ The class defines a point in 2D space. Data type of the point coordinates is specified

+ as a template parameter. There are a few shorter aliases available for user convenience.

+ See cv::Point, cv::Point2i, cv::Point2f and cv::Point2d.

+*/

+template<typename _Tp> class Point_

+{

+public:

+ typedef _Tp value_type;

+

+ // various constructors

+ Point_();

+ Point_(_Tp _x, _Tp _y);

+ Point_(const Point_& pt);

+ Point_(const CvPoint& pt);

+ Point_(const CvPoint2D32f& pt);

+ Point_(const Size_<_Tp>& sz);

+ Point_(const Vec<_Tp, 2>& v);

+

+ Point_& operator = (const Point_& pt);

+ //! conversion to another data type

+ template<typename _Tp2> operator Point_<_Tp2>() const;

+

+ //! conversion to the old-style C structures

+ operator CvPoint() const;

+ operator CvPoint2D32f() const;

+ operator Vec<_Tp, 2>() const;

+

+ //! dot product

+ _Tp dot(const Point_& pt) const;

+ //! dot product computed in double-precision arithmetics

+ double ddot(const Point_& pt) const;

+ //! cross-product

+ double cross(const Point_& pt) const;

+ //! checks whether the point is inside the specified rectangle

+ bool inside(const Rect_<_Tp>& r) const;

+

+ _Tp x, y; //< the point coordinates

+};

+

+/*!

+ template 3D point class.

+

+ The class defines a point in 3D space. Data type of the point coordinates is specified

+ as a template parameter.

+

+ \see cv::Point3i, cv::Point3f and cv::Point3d

+*/

+template<typename _Tp> class Point3_

+{

+public:

+ typedef _Tp value_type;

+

+ // various constructors

+ Point3_();

+ Point3_(_Tp _x, _Tp _y, _Tp _z);

+ Point3_(const Point3_& pt);

+ explicit Point3_(const Point_<_Tp>& pt);

+ Point3_(const CvPoint3D32f& pt);

+ Point3_(const Vec<_Tp, 3>& v);

+

+ Point3_& operator = (const Point3_& pt);

+ //! conversion to another data type

+ template<typename _Tp2> operator Point3_<_Tp2>() const;

+ //! conversion to the old-style CvPoint...

+ operator CvPoint3D32f() const;

+ //! conversion to cv::Vec<>

+ operator Vec<_Tp, 3>() const;

+

+ //! dot product

+ _Tp dot(const Point3_& pt) const;

+ //! dot product computed in double-precision arithmetics

+ double ddot(const Point3_& pt) const;

+ //! cross product of the 2 3D points

+ Point3_ cross(const Point3_& pt) const;

+

+ _Tp x, y, z; //< the point coordinates

+};

+

+//////////////////////////////// Size_ ////////////////////////////////

+

+/*!

+ The 2D size class

+

+ The class represents the size of a 2D rectangle, image size, matrix size etc.

+ Normally, cv::Size ~ cv::Size_<int> is used.

+*/

+template<typename _Tp> class Size_

+{

+public:

+ typedef _Tp value_type;

+

+ //! various constructors

+ Size_();

+ Size_(_Tp _width, _Tp _height);

+ Size_(const Size_& sz);

+ Size_(const CvSize& sz);

+ Size_(const CvSize2D32f& sz);

+ Size_(const Point_<_Tp>& pt);

+

+ Size_& operator = (const Size_& sz);

+ //! the area (width*height)

+ _Tp area() const;

+

+ //! conversion of another data type.

+ template<typename _Tp2> operator Size_<_Tp2>() const;

+

+ //! conversion to the old-style OpenCV types

+ operator CvSize() const;

+ operator CvSize2D32f() const;

+

+ _Tp width, height; // the width and the height

+};

+

+//////////////////////////////// Rect_ ////////////////////////////////

+

+/*!

+ The 2D up-right rectangle class

+

+ The class represents a 2D rectangle with coordinates of the specified data type.

+ Normally, cv::Rect ~ cv::Rect_<int> is used.

+*/

+template<typename _Tp> class Rect_

+{

+public:

+ typedef _Tp value_type;

+

+ //! various constructors

+ Rect_();

+ Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);

+ Rect_(const Rect_& r);

+ Rect_(const CvRect& r);

+ Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);

+ Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);

+

+ Rect_& operator = ( const Rect_& r );

+ //! the top-left corner

+ Point_<_Tp> tl() const;

+ //! the bottom-right corner

+ Point_<_Tp> br() const;

+

+ //! size (width, height) of the rectangle

+ Size_<_Tp> size() const;

+ //! area (width*height) of the rectangle

+ _Tp area() const;

+

+ //! conversion to another data type

+ template<typename _Tp2> operator Rect_<_Tp2>() const;

+ //! conversion to the old-style CvRect

+ operator CvRect() const;

+

+ //! checks whether the rectangle contains the point

+ bool contains(const Point_<_Tp>& pt) const;

+

+ _Tp x, y, width, height; //< the top-left corner, as well as width and height of the rectangle

+};

+

+

+typedef Point_<int> Point2i;

+typedef Point2i Point;

+typedef Size_<int> Size2i;

+typedef Size_<double> Size2d;

+typedef Size2i Size;

+typedef Rect_<int> Rect;

+typedef Point_<float> Point2f;

+typedef Point_<double> Point2d;

+typedef Size_<float> Size2f;

+typedef Point3_<int> Point3i;

+typedef Point3_<float> Point3f;

+typedef Point3_<double> Point3d;

+

+

+/*!

+ The rotated 2D rectangle.

+

+ The class represents rotated (i.e. not up-right) rectangles on a plane.

+ Each rectangle is described by the center point (mass center), length of each side

+ (represented by cv::Size2f structure) and the rotation angle in degrees.

+*/

+class CV_EXPORTS RotatedRect

+{

+public:

+ //! various constructors

+ RotatedRect();

+ RotatedRect(const Point2f& center, const Size2f& size, float angle);

+ RotatedRect(const CvBox2D& box);

+

+ //! returns 4 vertices of the rectangle

+ void points(Point2f pts[]) const;

+ //! returns the minimal up-right rectangle containing the rotated rectangle

+ Rect boundingRect() const;

+ //! conversion to the old-style CvBox2D structure

+ operator CvBox2D() const;

+

+ Point2f center; //< the rectangle mass center

+ Size2f size; //< width and height of the rectangle

+ float angle; //< the rotation angle. When the angle is 0, 90, 180, 270 etc., the rectangle becomes an up-right rectangle.

+};

+

+//////////////////////////////// Scalar_ ///////////////////////////////

+

+/*!

+ The template scalar class.

+

+ This is partially specialized cv::Vec class with the number of elements = 4, i.e. a short vector of four elements.

+ Normally, cv::Scalar ~ cv::Scalar_<double> is used.

+*/

+template<typename _Tp> class Scalar_ : public Vec<_Tp, 4>

+{

+public:

+ //! various constructors

+ Scalar_();

+ Scalar_(_Tp v0, _Tp v1, _Tp v2=0, _Tp v3=0);

+ Scalar_(const CvScalar& s);

+ Scalar_(_Tp v0);

+

+ //! returns a scalar with all elements set to v0

+ static Scalar_<_Tp> all(_Tp v0);

+ //! conversion to the old-style CvScalar

+ operator CvScalar() const;

+

+ //! conversion to another data type

+ template<typename T2> operator Scalar_<T2>() const;

+

+ //! per-element product

+ Scalar_<_Tp> mul(const Scalar_<_Tp>& t, double scale=1 ) const;

+

+ // returns (v0, -v1, -v2, -v3)

+ Scalar_<_Tp> conj() const;

+

+ // returns true iff v1 == v2 == v3 == 0

+ bool isReal() const;

+};

+

+typedef Scalar_<double> Scalar;

+

+CV_EXPORTS void scalarToRawData(const Scalar& s, void* buf, int type, int unroll_to=0);

+

+//////////////////////////////// Range /////////////////////////////////

+

+/*!

+ The 2D range class

+

+ This is the class used to specify a continuous subsequence, i.e. part of a contour, or a column span in a matrix.

+*/

+class CV_EXPORTS Range

+{

+public:

+ Range();

+ Range(int _start, int _end);

+ Range(const CvSlice& slice);

+ int size() const;

+ bool empty() const;

+ static Range all();

+ operator CvSlice() const;

+

+ int start, end;

+};

+

+/////////////////////////////// DataType ////////////////////////////////

+

+/*!

+ Informative template class for OpenCV "scalars".

+

+ The class is specialized for each primitive numerical type supported by OpenCV (such as unsigned char or float),

+ as well as for more complex types, like cv::Complex<>, std::complex<>, cv::Vec<> etc.

+ The common property of all such types (called "scalars", do not confuse it with cv::Scalar_)

+ is that each of them is basically a tuple of numbers of the same type. Each "scalar" can be represented

+ by the depth id (CV_8U ... CV_64F) and the number of channels.

+ OpenCV matrices, 2D or nD, dense or sparse, can store "scalars",

+ as long as the number of channels does not exceed CV_CN_MAX.

+*/

+template<typename _Tp> class DataType

+{

+public:

+ typedef _Tp value_type;

+ typedef value_type work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 1, depth = -1, channels = 1, fmt=0,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<bool>

+{

+public:

+ typedef bool value_type;

+ typedef int work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<uchar>

+{

+public:

+ typedef uchar value_type;

+ typedef int work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<schar>

+{

+public:

+ typedef schar value_type;

+ typedef int work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<char>

+{

+public:

+ typedef schar value_type;

+ typedef int work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<ushort>

+{

+public:

+ typedef ushort value_type;

+ typedef int work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<short>

+{

+public:

+ typedef short value_type;

+ typedef int work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<int>

+{

+public:

+ typedef int value_type;

+ typedef value_type work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<float>

+{

+public:

+ typedef float value_type;

+ typedef value_type work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<> class DataType<double>

+{

+public:

+ typedef double value_type;

+ typedef value_type work_type;

+ typedef value_type channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 1,

+ fmt=DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<typename _Tp, int m, int n> class DataType<Matx<_Tp, m, n> >

+{

+public:

+ typedef Matx<_Tp, m, n> value_type;

+ typedef Matx<typename DataType<_Tp>::work_type, m, n> work_type;

+ typedef _Tp channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = m*n,

+ fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<typename _Tp, int cn> class DataType<Vec<_Tp, cn> >

+{

+public:

+ typedef Vec<_Tp, cn> value_type;

+ typedef Vec<typename DataType<_Tp>::work_type, cn> work_type;

+ typedef _Tp channel_type;

+ typedef value_type vec_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = cn,

+ fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+};

+

+template<typename _Tp> class DataType<std::complex<_Tp> >

+{

+public:

+ typedef std::complex<_Tp> value_type;

+ typedef value_type work_type;

+ typedef _Tp channel_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,

+ fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+ typedef Vec<channel_type, channels> vec_type;

+};

+

+template<typename _Tp> class DataType<Complex<_Tp> >

+{

+public:

+ typedef Complex<_Tp> value_type;

+ typedef value_type work_type;

+ typedef _Tp channel_type;

+ enum { generic_type = 0, depth = DataDepth<channel_type>::value, channels = 2,

+ fmt = ((channels-1)<<8) + DataDepth<channel_type>::fmt,

+ type = CV_MAKETYPE(depth, channels) };

+ typedef Vec<channel_type, channels> vec_type;

+};

+

+template<typename _Tp> class DataType<Point_<_Tp> >

+{

+public:

+ typedef Point_<_Tp> value_type;

+ typedef Point_<typename DataType<_Tp>::work_type> work_type;

+ typedef _Tp channel_type;