/*
* This file provides some basic opencv structure and corner detection functions.
* Create by Shuo.Yan on 2016/5/13
*/

#ifndef __OPENCV_H_
#define __OPENCV_H_

//#include "math_common.h"
#include <math.h>
#include <vector>
//#include "dyn_memory.h"
#include <malloc.h>
#include <assert.h>
#include <iostream>
#include <stddef.h>
//#include "data_type.h"
using namespace std;



#define OPENCV 1

#if OPENCV
#include "opencv/cv.h"
#include "opencv/cxcore.h"
#include "opencv/highgui.h"
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
using namespace cv;

enum
{
	//CV_SHAPE_RECT = 0, // 0, 1, 2, 3, 4, 5, 6, 7, 8
	//CV_SHAPE_CROSS = 1, // 1, 3, 4, 5, 7
	CV_SHAPE_BAR_VERT_ALL = 2, // 1, 4, 7
	CV_SHAPE_BAR_VERT_UP = 3, // 1, 4
	CV_SHAPE_BAR_VERT_DOWN = 4, // 4, 7
	CV_SHAPE_BAR_HORI_ALL = 5, // 3, 4, 5
	CV_SHAPE_BAR_HORI_LEFT = 6, // 3, 4
	CV_SHAPE_BAR_HORI_RIGHT = 7, // 4, 5
	CV_SHAPE_BAR_INCL_048 = 8, // 0, 4, 8
	CV_SHAPE_BAR_INCL_04 = 9, // 0, 4
	CV_SHAPE_BAR_INCL_48 = 10,// 4, 8
	CV_SHAPE_BAR_INCL_246 = 11,// 2, 4, 6
	CV_SHAPE_BAR_INCL_24 = 12,// 2, 4
	CV_SHAPE_BAR_INCL_46 = 13,// 4, 6
};

void Dilate(const IplImage* src, IplImage* dst, int blockSize, int mode, int iterations);
void cvRgb2Gray(const IplImage* src, IplImage* dst);

#else

#define uchar unsigned char
#define CV_DEFAULT(val) = val
#define CV_CLOCKWISE         1
#define CV_COUNTER_CLOCKWISE 2
#define CV_RGB( r, g, b )  cvScalar( (b), (g), (r), 0 )
#define CV_WHOLE_SEQ_END_INDEX 0x3fffffff
#define CV_WHOLE_SEQ  cvSlice(0, CV_WHOLE_SEQ_END_INDEX)
#define CV_POLY_APPROX_DP 0
#define CV_MAGIC_MASK 0xFFFF0000 
#define CV_STRUCT_ALIGN sizeof(Float64_t)
#define CV_MAX_ALLOC_SIZE (((size_t)1 << (sizeof(size_t)*8-2)))
#define  CV_MALLOC_ALIGN 32
#define ICV_SHIFT_TAB_MAX 32
#define CV_STORAGE_BLOCK_SIZE ((1<<16) - 128)
#define cvFree(ptr) (cvFree_(*(ptr)), *(ptr)=0)
#define CV_TOGGLE_FLT(x) ((x)^((int)(x) < 0 ? 0x7fffffff : 0))

/****************************************************************************************\
*                                  Image type (IplImage)                                 *
\****************************************************************************************/
#define IPL_DEPTH_SIGN 0x80000000

#define IPL_DEPTH_1U     1
#define IPL_DEPTH_8U     8
#define IPL_DEPTH_16U   16
#define IPL_DEPTH_32F   32

#define IPL_DEPTH_8S  (IPL_DEPTH_SIGN| 8)
#define IPL_DEPTH_16S (IPL_DEPTH_SIGN|16)
#define IPL_DEPTH_32S (IPL_DEPTH_SIGN|32)

#define CV_IMAGE_ELEM( image, elemtype, row, col )       \
	(((elemtype*)((image)->imageData + (image)->widthStep*(row)))[(col)])

/* Types of filtering */
#define CV_BLUR_NO_SCALE 0
#define CV_BLUR  1
#define CV_GAUSSIAN  2
#define CV_MEDIAN 3
#define CV_BILATERAL 4

/* Types of thresholding */
#define CV_THRESH_BINARY      0  /* value = value > threshold ? max_value : 0       */
#define CV_THRESH_BINARY_INV  1  /* value = value > threshold ? 0 : max_value       */
#define CV_THRESH_TRUNC       2  /* value = value > threshold ? threshold : value   */
#define CV_THRESH_TOZERO      3  /* value = value > threshold ? value : 0           */
#define CV_THRESH_TOZERO_INV  4  /* value = value > threshold ? 0 : value           */
#define CV_THRESH_MASK        7

#define CV_THRESH_OTSU        8  /* use Otsu algorithm to choose the optimal threshold value;
								combine the flag with one of the above CV_THRESH_* values */

#define CV_STORAGE_MAGIC_VAL    0x42890000

#define CV_IS_STORAGE(storage)  \
	((storage) != NULL &&       \
	(((CvMemStorage*)(storage))->signature & CV_MAGIC_MASK) == CV_STORAGE_MAGIC_VAL)

#define CV_TYPE_NAME_SEQ             "opencv-sequence"
#define CV_TYPE_NAME_SEQ_TREE        "opencv-sequence-tree"

#define CV_SET_ELEM_IDX_MASK   ((1 << 26) - 1)
#define CV_SET_ELEM_FREE_FLAG  (1 << (sizeof(int)*8-1))

/** Checks whether the element pointed by ptr belongs to a set or not */
#define CV_IS_SET_ELEM( ptr )  (((CvSetElem*)(ptr))->flags >= 0)

/****************************************************************************************\
*                                    Sequence types                                      *
\****************************************************************************************/

#define CV_SEQ_MAGIC_VAL             0x42990000

#define CV_IS_SEQ(seq) \
	((seq) != NULL && (((CvSeq*)(seq))->flags & CV_MAGIC_MASK) == CV_SEQ_MAGIC_VAL)

#define CV_SET_MAGIC_VAL             0x42980000
#define CV_IS_SET(set) \
	((set) != NULL && (((CvSeq*)(set))->flags & CV_MAGIC_MASK) == CV_SET_MAGIC_VAL)

#define CV_SEQ_ELTYPE_BITS           12
#define CV_SEQ_ELTYPE_MASK           ((1 << CV_SEQ_ELTYPE_BITS) - 1)

#define CV_SEQ_ELTYPE_POINT          CV_32SC2  /**< (x,y) */
#define CV_SEQ_ELTYPE_CODE           CV_8UC1   /**< freeman code: 0..7 */
#define CV_SEQ_ELTYPE_GENERIC        0
#define CV_SEQ_ELTYPE_PTR            CV_USRTYPE1
#define CV_SEQ_ELTYPE_PPOINT         CV_SEQ_ELTYPE_PTR  /**< &(x,y) */
#define CV_SEQ_ELTYPE_INDEX          CV_32SC1  /**< #(x,y) */
#define CV_SEQ_ELTYPE_GRAPH_EDGE     0  /**< &next_o, &next_d, &vtx_o, &vtx_d */
#define CV_SEQ_ELTYPE_GRAPH_VERTEX   0  /**< first_edge, &(x,y) */
#define CV_SEQ_ELTYPE_TRIAN_ATR      0  /**< vertex of the binary tree   */
#define CV_SEQ_ELTYPE_CONNECTED_COMP 0  /**< connected component  */
#define CV_SEQ_ELTYPE_POINT3D        CV_32FC3  /**< (x,y,z)  */

#define CV_SEQ_KIND_BITS        2
#define CV_SEQ_KIND_MASK        (((1 << CV_SEQ_KIND_BITS) - 1)<<CV_SEQ_ELTYPE_BITS)

/** types of sequences */
#define CV_SEQ_KIND_GENERIC     (0 << CV_SEQ_ELTYPE_BITS)
#define CV_SEQ_KIND_CURVE       (1 << CV_SEQ_ELTYPE_BITS)
#define CV_SEQ_KIND_BIN_TREE    (2 << CV_SEQ_ELTYPE_BITS)

/** types of sparse sequences (sets) */
#define CV_SEQ_KIND_GRAPH       (1 << CV_SEQ_ELTYPE_BITS)
#define CV_SEQ_KIND_SUBDIV2D    (2 << CV_SEQ_ELTYPE_BITS)

#define CV_SEQ_FLAG_SHIFT       (CV_SEQ_KIND_BITS + CV_SEQ_ELTYPE_BITS)

/** flags for curves */
#define CV_SEQ_FLAG_CLOSED     (1 << CV_SEQ_FLAG_SHIFT)
#define CV_SEQ_FLAG_SIMPLE     (0 << CV_SEQ_FLAG_SHIFT)
#define CV_SEQ_FLAG_CONVEX     (0 << CV_SEQ_FLAG_SHIFT)
#define CV_SEQ_FLAG_HOLE       (2 << CV_SEQ_FLAG_SHIFT)

/** flags for graphs */
#define CV_GRAPH_FLAG_ORIENTED (1 << CV_SEQ_FLAG_SHIFT)

#define CV_GRAPH               CV_SEQ_KIND_GRAPH
#define CV_ORIENTED_GRAPH      (CV_SEQ_KIND_GRAPH|CV_GRAPH_FLAG_ORIENTED)

/** point sets */
#define CV_SEQ_POINT_SET       (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT)
#define CV_SEQ_POINT3D_SET     (CV_SEQ_KIND_GENERIC| CV_SEQ_ELTYPE_POINT3D)
#define CV_SEQ_POLYLINE        (CV_SEQ_KIND_CURVE  | CV_SEQ_ELTYPE_POINT)
#define CV_SEQ_POLYGON         (CV_SEQ_FLAG_CLOSED | CV_SEQ_POLYLINE )
#define CV_SEQ_CONTOUR         CV_SEQ_POLYGON
#define CV_SEQ_SIMPLE_POLYGON  (CV_SEQ_FLAG_SIMPLE | CV_SEQ_POLYGON  )

/** chain-coded curves */
#define CV_SEQ_CHAIN           (CV_SEQ_KIND_CURVE  | CV_SEQ_ELTYPE_CODE)
#define CV_SEQ_CHAIN_CONTOUR   (CV_SEQ_FLAG_CLOSED | CV_SEQ_CHAIN)

/** binary tree for the contour */
#define CV_SEQ_POLYGON_TREE    (CV_SEQ_KIND_BIN_TREE  | CV_SEQ_ELTYPE_TRIAN_ATR)

/** sequence of the connected components */
#define CV_SEQ_CONNECTED_COMP  (CV_SEQ_KIND_GENERIC  | CV_SEQ_ELTYPE_CONNECTED_COMP)

/** sequence of the integer numbers */
#define CV_SEQ_INDEX           (CV_SEQ_KIND_GENERIC  | CV_SEQ_ELTYPE_INDEX)

#define CV_SEQ_ELTYPE( seq )   ((seq)->flags & CV_SEQ_ELTYPE_MASK)
#define CV_SEQ_KIND( seq )     ((seq)->flags & CV_SEQ_KIND_MASK )

/** flag checking */
#define CV_IS_SEQ_INDEX( seq )      ((CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_INDEX) && \
	(CV_SEQ_KIND(seq) == CV_SEQ_KIND_GENERIC))

#define CV_IS_SEQ_CURVE( seq )      (CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE)
#define CV_IS_SEQ_CLOSED( seq )     (((seq)->flags & CV_SEQ_FLAG_CLOSED) != 0)
#define CV_IS_SEQ_CONVEX( seq )     0
#define CV_IS_SEQ_HOLE( seq )       (((seq)->flags & CV_SEQ_FLAG_HOLE) != 0)
#define CV_IS_SEQ_SIMPLE( seq )     1

/** type checking macros */
#define CV_IS_SEQ_POINT_SET( seq ) \
	((CV_SEQ_ELTYPE(seq) == CV_32SC2 || CV_SEQ_ELTYPE(seq) == CV_32FC2))

#define CV_IS_SEQ_POINT_SUBSET( seq ) \
	(CV_IS_SEQ_INDEX(seq) || CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_PPOINT)

#define CV_IS_SEQ_POLYLINE( seq )   \
	(CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && CV_IS_SEQ_POINT_SET(seq))

#define CV_IS_SEQ_POLYGON( seq )   \
	(CV_IS_SEQ_POLYLINE(seq) && CV_IS_SEQ_CLOSED(seq))

#define CV_IS_SEQ_CHAIN( seq )   \
	(CV_SEQ_KIND(seq) == CV_SEQ_KIND_CURVE && (seq)->elem_size == 1)

#define CV_IS_SEQ_CONTOUR( seq )   \
	(CV_IS_SEQ_CLOSED(seq) && (CV_IS_SEQ_POLYLINE(seq) || CV_IS_SEQ_CHAIN(seq)))

#define CV_IS_SEQ_CHAIN_CONTOUR( seq ) \
	(CV_IS_SEQ_CHAIN(seq) && CV_IS_SEQ_CLOSED(seq))

#define CV_IS_SEQ_POLYGON_TREE( seq ) \
	(CV_SEQ_ELTYPE(seq) == CV_SEQ_ELTYPE_TRIAN_ATR &&    \
	CV_SEQ_KIND(seq) == CV_SEQ_KIND_BIN_TREE)

#define CV_IS_GRAPH( seq )    \
	(CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_GRAPH)

#define CV_IS_GRAPH_ORIENTED( seq )   \
	(((seq)->flags & CV_GRAPH_FLAG_ORIENTED) != 0)

#define CV_IS_SUBDIV2D( seq )  \
	(CV_IS_SET(seq) && CV_SEQ_KIND((CvSet*)(seq)) == CV_SEQ_KIND_SUBDIV2D)

/**********************************load and save bmp image******************************************/

typedef struct
{
	char type1;
	char type2;
}BmpFileHead;
typedef struct
{
	unsigned int imageSize;
	unsigned int blank;
	unsigned int startPosition;
	unsigned int    length;
	unsigned int    width;
	unsigned int    height;
	unsigned short    colorPlane;
	unsigned short    bitColor;
	unsigned int    zipFormat;
	unsigned int    realSize;
	unsigned int    xPels;
	unsigned int    yPels;
	unsigned int    colorUse;
	unsigned int    colorImportant;
}BmpInfoHead;


typedef struct{
	unsigned char G;
	unsigned char B;
	unsigned char R;
	unsigned char A;
}RGBA;

enum { DECOMP_LU = 0, DECOMP_SVD = 1, DECOMP_EIG = 2, DECOMP_CHOLESKY = 3, DECOMP_QR = 4, DECOMP_NORMAL = 16 };

/********************************** End of load and save bmp image******************************************/

/****************************************************************************************\
*                                  Matrix type (Mat)                                     *
\****************************************************************************************/

#define CV_CN_MAX     512
#define CV_CN_SHIFT   3
#define CV_DEPTH_MAX  (1 << CV_CN_SHIFT)

#define CV_8U   0
#define CV_8S   1
#define CV_16U  2
#define CV_16S  3
#define CV_32S  4
#define CV_32F  5
#define CV_64F  6
#define CV_USRTYPE1 7

#define CV_MAT_DEPTH_MASK       (CV_DEPTH_MAX - 1)
#define CV_MAT_DEPTH(flags)     ((flags) & CV_MAT_DEPTH_MASK)

#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
#define CV_MAKE_TYPE CV_MAKETYPE

#define CV_8UC1 CV_MAKETYPE(CV_8U,1)
#define CV_8UC2 CV_MAKETYPE(CV_8U,2)
#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
#define CV_8UC4 CV_MAKETYPE(CV_8U,4)
#define CV_8UC(n) CV_MAKETYPE(CV_8U,(n))

#define CV_8SC1 CV_MAKETYPE(CV_8S,1)
#define CV_8SC2 CV_MAKETYPE(CV_8S,2)
#define CV_8SC3 CV_MAKETYPE(CV_8S,3)
#define CV_8SC4 CV_MAKETYPE(CV_8S,4)
#define CV_8SC(n) CV_MAKETYPE(CV_8S,(n))

#define CV_16UC1 CV_MAKETYPE(CV_16U,1)
#define CV_16UC2 CV_MAKETYPE(CV_16U,2)
#define CV_16UC3 CV_MAKETYPE(CV_16U,3)
#define CV_16UC4 CV_MAKETYPE(CV_16U,4)
#define CV_16UC(n) CV_MAKETYPE(CV_16U,(n))

#define CV_16SC1 CV_MAKETYPE(CV_16S,1)
#define CV_16SC2 CV_MAKETYPE(CV_16S,2)
#define CV_16SC3 CV_MAKETYPE(CV_16S,3)
#define CV_16SC4 CV_MAKETYPE(CV_16S,4)
#define CV_16SC(n) CV_MAKETYPE(CV_16S,(n))

#define CV_32SC1 CV_MAKETYPE(CV_32S,1)
#define CV_32SC2 CV_MAKETYPE(CV_32S,2)
#define CV_32SC3 CV_MAKETYPE(CV_32S,3)
#define CV_32SC4 CV_MAKETYPE(CV_32S,4)
#define CV_32SC(n) CV_MAKETYPE(CV_32S,(n))

#define CV_32FC1 CV_MAKETYPE(CV_32F,1)
#define CV_32FC2 CV_MAKETYPE(CV_32F,2)
#define CV_32FC3 CV_MAKETYPE(CV_32F,3)
#define CV_32FC4 CV_MAKETYPE(CV_32F,4)
#define CV_32FC(n) CV_MAKETYPE(CV_32F,(n))

#define CV_64FC1 CV_MAKETYPE(CV_64F,1)
#define CV_64FC2 CV_MAKETYPE(CV_64F,2)
#define CV_64FC3 CV_MAKETYPE(CV_64F,3)
#define CV_64FC4 CV_MAKETYPE(CV_64F,4)
#define CV_64FC(n) CV_MAKETYPE(CV_64F,(n))

#define CV_MAT_CN_MASK          ((CV_CN_MAX - 1) << CV_CN_SHIFT)
#define CV_MAT_CN(flags)        ((((flags) & CV_MAT_CN_MASK) >> CV_CN_SHIFT) + 1)
#define CV_MAT_TYPE_MASK        (CV_DEPTH_MAX*CV_CN_MAX - 1)
#define CV_MAT_TYPE(flags)      ((flags) & CV_MAT_TYPE_MASK)
#define CV_MAT_CONT_FLAG_SHIFT  14
#define CV_MAT_CONT_FLAG        (1 << CV_MAT_CONT_FLAG_SHIFT)
#define CV_IS_MAT_CONT(flags)   ((flags) & CV_MAT_CONT_FLAG)
#define CV_IS_CONT_MAT          CV_IS_MAT_CONT
#define CV_SUBMAT_FLAG_SHIFT    15
#define CV_SUBMAT_FLAG          (1 << CV_SUBMAT_FLAG_SHIFT)
#define CV_IS_SUBMAT(flags)     ((flags) & CV_MAT_SUBMAT_FLAG)

/* Size of each channel item,
   0x124489 = 1000 0100 0100 0010 0010 0001 0001 ~ array of sizeof(arr_type_elem) */
#define CV_ELEM_SIZE1(type) \
	((((sizeof(size_t) << 28) | 0x8442211) >> CV_MAT_DEPTH(type) * 4) & 15)

/* 0x3a50 = 11 10 10 01 01 00 00 ~ array of log2(sizeof(arr_type_elem)) */
#define CV_ELEM_SIZE(type) \
	(CV_MAT_CN(type) << ((((sizeof(size_t) / 4 + 1) * 16384 | 0x3a50) >> CV_MAT_DEPTH(type) * 2) & 3))

#define  CV_CMP(a,b)    (((a) > (b)) - ((a) < (b)))
#define  CV_SIGN(a)     CV_CMP((a),0)
#define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))

typedef struct CvPoint3D32f
{
	float x;
	float y;
	float z;
}
CvPoint3D32f;


inline  CvPoint3D32f  cvPoint3D32f(Float64_t x, Float64_t y, Float64_t z)
{
	CvPoint3D32f p;

	p.x = (float)x;
	p.y = (float)y;
	p.z = (float)z;

	return p;
}


typedef struct CvPoint2D64f
{
	Float64_t x;
	Float64_t y;
}
CvPoint2D64f;


inline  CvPoint2D64f  cvPoint2D64f(Float64_t x, Float64_t y)
{
	CvPoint2D64f p;

	p.x = x;
	p.y = y;

	return p;
}


typedef struct CvPoint3D64f
{
	Float64_t x;
	Float64_t y;
	Float64_t z;
}
CvPoint3D64f;


inline  CvPoint3D64f  cvPoint3D64f(Float64_t x, Float64_t y, Float64_t z)
{
	CvPoint3D64f p;

	p.x = x;
	p.y = y;
	p.z = z;

	return p;
}

/* IPP-compatible return codes */
typedef enum CvStatus
{
	CV_BADMEMBLOCK_ERR = -113,
	CV_INPLACE_NOT_SUPPORTED_ERR = -112,
	CV_UNMATCHED_ROI_ERR = -111,
	CV_NOTFOUND_ERR = -110,
	CV_BADCONVERGENCE_ERR = -109,

	CV_BADDEPTH_ERR = -107,
	CV_BADROI_ERR = -106,
	CV_BADHEADER_ERR = -105,
	CV_UNMATCHED_FORMATS_ERR = -104,
	CV_UNSUPPORTED_COI_ERR = -103,
	CV_UNSUPPORTED_CHANNELS_ERR = -102,
	CV_UNSUPPORTED_DEPTH_ERR = -101,
	CV_UNSUPPORTED_FORMAT_ERR = -100,

	CV_BADARG_ERR = -49,  //ipp comp
	CV_NOTDEFINED_ERR = -48,  //ipp comp

	CV_BADCHANNELS_ERR = -47,  //ipp comp
	CV_BADRANGE_ERR = -44,  //ipp comp
	CV_BADSTEP_ERR = -29,  //ipp comp

	CV_BADFLAG_ERR = -12,
	CV_DIV_BY_ZERO_ERR = -11, //ipp comp
	CV_BADCOEF_ERR = -10,

	CV_BADFACTOR_ERR = -7,
	CV_BADPOINT_ERR = -6,
	CV_BADSCALE_ERR = -4,
	CV_OUTOFMEM_ERR = -3,
	CV_NULLPTR_ERR = -2,
	CV_BADSIZE_ERR = -1,
	CV_NO_ERR = 0,
	CV_OK = CV_NO_ERR
}
CvStatus;

typedef struct CvMat
{
	int type;
	int step;

	/* for internal use only */
	int* refcount;
	int hdr_refcount;

	union
	{
		uchar* ptr;
		short* s;
		int* i;
		float* fl;
		Float64_t* db;
	} data;

#ifdef __cplusplus
	union
	{
		int rows;
		int height;
	};

	union
	{
		int cols;
		int width;
	};
#else
	int rows;
	int cols;
#endif

}
CvMat;

/************************************* CvSlice ******************************************/

typedef struct CvSlice
{
	int  start_index, end_index;
}
CvSlice;

class Scalar
{
public:
	Scalar(float a, float b, float c){};
	Scalar(){};
	~Scalar(){};

private:
	float val[4];
};
typedef struct Rect2f_
{
	Rect2f_(float x_in = 0.0f, float y_in = 0.0f, float width_in = 0.0f, float height_in = 0.0f)
	{
		x = x_in;
		y = y_in;
		width = width_in;
		height = height_in;
	}
	float x;
	float y;
	float width;
	float height;
}Rect2f;

typedef struct Rect_
{
	Rect_(int x_in = 0, int y_in = 0, int width_in = 0, int height_in = 0)
	{
		x = x_in;
		y = y_in;
		width = width_in;
		height = height_in;
	}
	int x;
	int y;
	int width;
	int height;
}Rect;

typedef struct Size_
{
	Size_(int width_in = 0, int height_in = 0)
	{
		width = width_in;
		height = height_in;
	}
	int width;
	int height;
}Size;

typedef struct Point2f_
{
	Point2f_(float x_in = 0.0f, float y_in = 0.0f)
	{
		x = x_in;
		y = y_in;
	}
	float x;
	float y;
}Point2f;

typedef struct Point3f_
{
	Point3f_(float x_in = 0.0f, float y_in = 0.0f, float z_in = 0.0f)
	{
		x = x_in;
		y = y_in;
		y = z_in;
	}
	float x;
	float y;
	float z;
}Point3f;

typedef struct CvPoint2D32f
{
	float x;
	float y;

}
CvPoint2D32f;

typedef struct CvPoint
{
	int x;
	int y;
}
CvPoint;

typedef union Cv32suf
{
	int i;
	unsigned u;
	float f;
}
Cv32suf;

typedef struct _IplImage
{
	int  nSize;             /**< sizeof(IplImage) */
	int  ID;                /**< version (=0)*/
	int  nChannels;         /**< Most of OpenCV functions support 1,2,3 or 4 channels */
	unsigned int  timeStamp;//int  alphaChannel;      /**< Ignored by OpenCV */
	int  depth;             /**< Pixel depth in bits: IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16S,
							   IPL_DEPTH_32S, IPL_DEPTH_32F and IPL_DEPTH_64F are supported.  */
	char colorModel[4];     /**< Ignored by OpenCV */
	char channelSeq[4];     /**< ditto */
	int  dataOrder;         /**< 0 - interleaved color channels, 1 - separate color channels.
							   cvCreateImage can only create interleaved images */
	int  origin;            /**< 0 - top-left origin,
							   1 - bottom-left origin (Windows bitmaps style).  */
	int  align;             /**< Alignment of image rows (4 or 8).
							   OpenCV ignores it and uses widthStep instead.    */
	int  width;             /**< Image width in pixels.                           */
	int  height;            /**< Image height in pixels.                          */
	struct _IplROI *roi;    /**< Image ROI. If NULL, the whole image is selected. */
	struct _IplImage *maskROI;      /**< Must be NULL. */
	void  *imageId;                 /**< "           " */
	struct _IplTileInfo *tileInfo;  /**< "           " */
	int  imageSize;         /**< Image data size in bytes
							   (==image->height*image->widthStep
							   in case of interleaved data)*/
	char *imageData;        /**< Pointer to aligned image data.         */
	int  widthStep;         /**< Size of aligned image row in bytes.    */
	int  BorderMode[4];     /**< Ignored by OpenCV.                     */
	int  BorderConst[4];    /**< Ditto.                                 */
	char *imageDataOrigin;  /**< Pointer to very origin of image data
							   (not necessarily aligned) -
							   needed for correct deallocation */
}
IplImage;


typedef struct CvScalar
{
	float val[4];
}CvScalar;

typedef struct CvRect
{
	int x;
	int y;
	int width;
	int height;
	void cvRect(int init_x, int init_y, int rect_width, int rect_height)
	{
		x = init_x;
		y = init_y;
		width = rect_width;
		height = rect_height;
	}
}
CvRect;

typedef struct CvSize
{
	int width;
	int height;
	CvSize(int w, int h)
	{
		width = w;
		height = h;

	}
	CvSize(){}
}CvSize;

//CvSlice  cvSlice( int start, int end );
//CvSize  cvSize( int width, int height );
//CvPoint  cvPoint( int x, int y );
//CvScalar  cvScalar( float32_t val0, float32_t val1 ,
//				   float32_t val2 , float32_t val3 );
//CvRect  cvRect( int x, int y, int width, int height );

// Let 0 - 9 to represents 3*3 matrix, the meaning of each kernel is illustrated as
enum
{
	CV_SHAPE_RECT = 0, // 0, 1, 2, 3, 4, 5, 6, 7, 8
	CV_SHAPE_CROSS = 1, // 1, 3, 4, 5, 7
	CV_SHAPE_BAR_VERT_ALL = 2, // 1, 4, 7
	CV_SHAPE_BAR_VERT_UP = 3, // 1, 4
	CV_SHAPE_BAR_VERT_DOWN = 4, // 4, 7
	CV_SHAPE_BAR_HORI_ALL = 5, // 3, 4, 5
	CV_SHAPE_BAR_HORI_LEFT = 6, // 3, 4
	CV_SHAPE_BAR_HORI_RIGHT = 7, // 4, 5
	CV_SHAPE_BAR_INCL_048 = 8, // 0, 4, 8
	CV_SHAPE_BAR_INCL_04 = 9, // 0, 4
	CV_SHAPE_BAR_INCL_48 = 10,// 4, 8
	CV_SHAPE_BAR_INCL_246 = 11,// 2, 4, 6
	CV_SHAPE_BAR_INCL_24 = 12,// 2, 4
	CV_SHAPE_BAR_INCL_46 = 13,// 4, 6
};

/****************************************************************************************\
*                                   Dynamic Data structures                              *
\****************************************************************************************/

/******************************** Memory storage ****************************************/
typedef signed char schar;
typedef struct CvMemBlock
{
	struct CvMemBlock*  prev;
	struct CvMemBlock*  next;
}
CvMemBlock;

typedef struct CvMemStorage
{
	int signature;
	CvMemBlock* bottom;           /**< First allocated block.                   */
	CvMemBlock* top;              /**< Current memory block - top of the stack. */
	struct  CvMemStorage* parent; /**< We get new blocks from parent as needed. */
	int block_size;               /**< Block size.                              */
	int free_space;               /**< Remaining free space in current block.   */
}
CvMemStorage;


typedef struct CvMemStoragePos
{
	CvMemBlock* top;
	int free_space;
}
CvMemStoragePos;


typedef struct CvTreeNode
{
	int       flags;         /* micsellaneous flags */
	int       header_size;   /* size of sequence header */
	struct    CvTreeNode* h_prev; /* previous sequence */
	struct    CvTreeNode* h_next; /* next sequence */
	struct    CvTreeNode* v_prev; /* 2nd previous sequence */
	struct    CvTreeNode* v_next; /* 2nd next sequence */
}
CvTreeNode;


/*********************************** Sequence *******************************************/

typedef struct CvSeqBlock
{
	struct  CvSeqBlock*  prev; /* previous sequence block */
	struct  CvSeqBlock*  next; /* next sequence block */
	int     start_index;       /* index of the first element in the block +
								  sequence->first->start_index */
	int     count;             /* number of elements in the block */
	schar*  data;              /* pointer to the first element of the block */
}
CvSeqBlock;


#define CV_TREE_NODE_FIELDS(node_type)                          \
	int       flags;         /* micsellaneous flags */          \
	int       header_size;   /* size of sequence header */      \
struct    node_type* h_prev; /* previous sequence */        \
struct    node_type* h_next; /* next sequence */            \
struct    node_type* v_prev; /* 2nd previous sequence */    \
struct    node_type* v_next  /* 2nd next sequence */

/*
   Read/Write sequence.
   Elements can be dynamically inserted to or deleted from the sequence.
   */
#define CV_SEQUENCE_FIELDS()                                            \
	CV_TREE_NODE_FIELDS(CvSeq);                                         \
	int        total;          /* total number of elements */            \
	int        elem_size;      /* size of sequence element in bytes */   \
	schar*     block_max;      /* maximal bound of the last block */     \
	schar*     ptr;            /* current write pointer */               \
	int        delta_elems;    /* how many elements allocated when the seq grows */  \
	CvMemStorage*  storage;    /* where the seq is stored */             \
	CvSeqBlock*  free_blocks;  /* free blocks list */                    \
	CvSeqBlock*  first; /* pointer to the first sequence block */

typedef struct CvSeq
{
	CV_SEQUENCE_FIELDS()
}
CvSeq;

/*************************************** Set ********************************************/
/** @brief Set
  Order is not preserved. There can be gaps between sequence elements.
  After the element has been inserted it stays in the same place all the time.
  The MSB(most-significant or sign bit) of the first field (flags) is 0 iff the element exists.
  */
#define CV_SET_ELEM_FIELDS(elem_type)   \
	int  flags;                         \
struct elem_type* next_free;

typedef struct CvSetElem
{
	CV_SET_ELEM_FIELDS(CvSetElem)
}
CvSetElem;

#define CV_SET_FIELDS()      \
	CV_SEQUENCE_FIELDS()     \
	CvSetElem* free_elems;   \
	int active_count;

typedef struct CvSet
{
	CV_SET_FIELDS()
}
CvSet;

/****************************************************************************************/
/*                            Sequence writer & reader                                  */
/****************************************************************************************/

#define CV_SEQ_WRITER_FIELDS()                                     \
	int          header_size;                                      \
	CvSeq*       seq;        /* the sequence written */            \
	CvSeqBlock*  block;      /* current block */                   \
	schar*       ptr;        /* pointer to free space */           \
	schar*       block_min;  /* pointer to the beginning of block*/\
	schar*       block_max;  /* pointer to the end of block */

typedef struct CvSeqWriter
{
	CV_SEQ_WRITER_FIELDS()
}
CvSeqWriter;


#define CV_SEQ_READER_FIELDS()                                      \
	int          header_size;                                       \
	CvSeq*       seq;        /* sequence, beign read */             \
	CvSeqBlock*  block;      /* current block */                    \
	schar*       ptr;        /* pointer to element be read next */  \
	schar*       block_min;  /* pointer to the beginning of block */\
	schar*       block_max;  /* pointer to the end of block */      \
	int          delta_index;/* = seq->first->start_index   */      \
	schar*       prev_elem;  /* pointer to previous element */


typedef struct CvSeqReader
{
	CV_SEQ_READER_FIELDS()
}
CvSeqReader;

/* Freeman chain reader state */
typedef struct CvChainPtReader
{
	CV_SEQ_READER_FIELDS()
	char      code;
	CvPoint   pt;
	char      deltas[8][2];
}
CvChainPtReader;

/****************************************************************************************\
*                         Raster->Chain Tree (Suzuki algorithms)                         *
\****************************************************************************************/

typedef struct _CvContourInfo
{
	int flags;
	struct _CvContourInfo *next;        /* next contour with the same mark value */
	struct _CvContourInfo *parent;      /* information about parent contour */
	CvSeq *contour;             /* corresponding contour (may be 0, if rejected) */
	CvRect rect;                /* bounding rectangle */
	CvPoint origin;             /* origin point (where the contour was traced from) */
	int is_hole;                /* hole flag */
}
_CvContourInfo;


/*
  Structure that is used for sequential retrieving contours from the image.
  It supports both hierarchical and plane variants of Suzuki algorithm.
  */
typedef struct _CvContourScanner
{
	CvMemStorage *storage1;     /* contains fetched contours */
	CvMemStorage *storage2;     /* contains approximated contours
								   (!=storage1 if approx_method2 != approx_method1) */
	CvMemStorage *cinfo_storage;        /* contains _CvContourInfo nodes */
	CvSet *cinfo_set;           /* set of _CvContourInfo nodes */
	CvMemStoragePos initial_pos;        /* starting storage pos */
	CvMemStoragePos backup_pos; /* beginning of the latest approx. contour */
	CvMemStoragePos backup_pos2;        /* ending of the latest approx. contour */
	schar *img0;                /* image origin */
	schar *img;                 /* current image row */
	int img_step;               /* image step */
	CvSize img_size;            /* ROI size */
	CvPoint offset;             /* ROI offset: coordinates, added to each contour point */
	CvPoint pt;                 /* current scanner position */
	CvPoint lnbd;               /* position of the last met contour */
	int nbd;                    /* current mark val */
	_CvContourInfo *l_cinfo;    /* information about latest approx. contour */
	_CvContourInfo cinfo_temp;  /* temporary var which is used in simple modes */
	_CvContourInfo frame_info;  /* information about frame */
	CvSeq frame;                /* frame itself */
	int approx_method1;         /* approx method when tracing */
	int approx_method2;         /* final approx method */
	int mode;                   /* contour scanning mode:
								   0 - external only
								   1 - all the contours w/o any hierarchy
								   2 - connected components (i.e. two-level structure -
								   external contours and holes),
								   3 - full hierarchy;
								   4 - connected components of a multi-level image
								   */
	int subst_flag;
	int seq_type1;              /* type of fetched contours */
	int header_size1;           /* hdr size of fetched contours */
	int elem_size1;             /* elem size of fetched contours */
	int seq_type2;              /*                                       */
	int header_size2;           /*        the same for approx. contours  */
	int elem_size2;             /*                                       */
	_CvContourInfo *cinfo_table[128];
}
_CvContourScanner;

#define _CV_FIND_CONTOURS_FLAGS_EXTERNAL_ONLY    1
#define _CV_FIND_CONTOURS_FLAGS_HIERARCHIC       2

enum
{
	CV_ADAPTIVE_THRESH_MEAN_C = 0,
	CV_ADAPTIVE_THRESH_GAUSSIAN_C = 1
};

/** Contour retrieval modes */
enum
{
	CV_RETR_EXTERNAL = 0,
	CV_RETR_LIST = 1,
	CV_RETR_CCOMP = 2,
	CV_RETR_TREE = 3,
	CV_RETR_FLOODFILL = 4
};

/** Contour approximation methods */
enum
{
	CV_CHAIN_CODE = 0,
	CV_CHAIN_APPROX_NONE = 1,
	CV_CHAIN_APPROX_SIMPLE = 2,
	CV_CHAIN_APPROX_TC89_L1 = 3,
	CV_CHAIN_APPROX_TC89_KCOS = 4,
	CV_LINK_RUNS = 5
};

/*
Internal structure that is used for sequential retrieving contours from the image.
It supports both hierarchical and plane variants of Suzuki algorithm.
*/
typedef struct _CvContourScanner* CvContourScanner;

/*********************************** Chain/Countour *************************************/

typedef struct CvChain
{
	CV_SEQUENCE_FIELDS()
	CvPoint  origin;
}
CvChain;

#define CV_CONTOUR_FIELDS()  \
	CV_SEQUENCE_FIELDS()     \
	CvRect rect;             \
	int color;               \
	int reserved[3];

typedef struct CvContour
{
	CV_CONTOUR_FIELDS()
}
CvContour;

// Definition Contour Struct
//typedef struct CvContourEx
//{
//    CV_CONTOUR_FIELDS()
//    int counter;
//}
//CvContourEx;

typedef CvContour CvPoint2DSeq;

typedef int(*sklansky_func)(CvPoint** points, int start, int end,
	int* stack, int sign, int sign2);

class Range
{
public:
	Range();
	Range(int _start, int _end);
	int size() const;
	bool empty() const;
	static Range all();

	int start, end;
};

template<typename _Tp, size_t fixed_size = 1024 / sizeof(_Tp)+8> class AutoBuffer
{
public:
	typedef _Tp value_type;

	//! the default constructor
	AutoBuffer();
	//! constructor taking the real buffer size
	AutoBuffer(size_t _size);

	//! the copy constructor
	AutoBuffer(const AutoBuffer<_Tp, fixed_size>& buf);
	//! the assignment operator
	AutoBuffer<_Tp, fixed_size>& operator = (const AutoBuffer<_Tp, fixed_size>& buf);

	//! destructor. calls deallocate()
	~AutoBuffer();

	//! allocates the new buffer of size _size. if the _size is small enough, stack-allocated buffer is used
	void allocate(size_t _size);
	//! deallocates the buffer if it was dynamically allocated
	void deallocate();
	//! resizes the buffer and preserves the content
	void resize(size_t _size);
	//! returns the current buffer size
	size_t size() const;
	//! returns pointer to the real buffer, stack-allocated or head-allocated
	operator _Tp* ();
	//! returns read-only pointer to the real buffer, stack-allocated or head-allocated
	operator const _Tp* () const;

protected:
	//! pointer to the real buffer, can point to buf if the buffer is small enough
	_Tp* ptr;
	//! size of the real buffer
	size_t sz;
	//! pre-allocated buffer. At least 1 element to confirm C++ standard reqirements
	_Tp buf[(fixed_size > 0) ? fixed_size : 1];
};

CvSlice cvSlice(int start, int end);
CvPoint cvPoint(int x, int y);
CvPoint2D32f cvPoint2D32f(float x, float y);
CvRect cvRect(int x, int y, int width, int height);
CvSize cvSize(int width, int height);

IplImage *cvCreateImage(CvSize size, int depth, int channels);
IplImage *cvCreateImage(Size size, int depth, int channels);
IplImage *cvCreateImageHeader(CvSize size, int depth, int channels);
void cvReleaseImageHeader(IplImage **image);
void cvReleaseImage(IplImage **image);

void cvSetZero(IplImage* dst);
void cvCopy(const IplImage* src, IplImage* dst);
void cvRgb2Gray(const IplImage* src, IplImage* dst);
void GenerateKernel(Float64_t *kernel, int ksize, Float64_t sigma);
void cvGaussianSmooth(const IplImage* src, IplImage* dst, int ksize, Float64_t sigma);
void adaptiveThreshold(const IplImage* src, IplImage* dst,
	Float64_t maxValue, int type, int blockSize, Float64_t delta);
void cvAdaptiveThreshold(const IplImage* srcIm, IplImage* dstIm, Float64_t maxValue, int adaptive_method,
	int type, int blockSize, Float64_t delta);
void Dilate(const IplImage* src, IplImage* dst, int blockSize, int mode, int iterations);
void cvErode(const IplImage* src, IplImage* dst, int blockSize, int mode, int iterations CV_DEFAULT(1));
void myDilateV4(const IplImage *src, IplImage *dst, int radius);

/****************************************************************************************\
*                               Sequence implementation                                  *
\****************************************************************************************/
CvSeq *cvCreateSeq(int seq_flags, size_t header_size, size_t elem_size, CvMemStorage* storage);
void cvSetSeqBlockSize(CvSeq *seq, int delta_elements);
schar* cvGetSeqElem(const CvSeq *seq, int index);
int cvSeqElemIdx(const CvSeq* seq, const void* element, CvSeqBlock** block CV_DEFAULT(NULL));
int cvSliceLength(CvSlice slice, const CvSeq* seq);
void* cvCvtSeqToArray(const CvSeq* seq, void* elements, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ));
static void icvGrowSeq(CvSeq *seq, int in_front_of);
static void icvFreeSeqBlock(CvSeq *seq, int in_front_of);

/****************************************************************************************\
*                             Sequence Writer implementation                             *
\****************************************************************************************/
void cvStartAppendToSeq(CvSeq *seq, CvSeqWriter * writer);
void cvStartWriteSeq(int seq_flags, int header_size, int elem_size, CvMemStorage * storage, CvSeqWriter * writer);
void cvFlushSeqWriter(CvSeqWriter * writer);
CvSeq *cvEndWriteSeq(CvSeqWriter * writer);
void cvCreateSeqBlock(CvSeqWriter * writer);

/****************************************************************************************\
*                               Sequence Reader implementation                           *
\****************************************************************************************/
void cvStartReadSeq(const CvSeq *seq, CvSeqReader * reader, int reverse CV_DEFAULT(0));
void cvChangeSeqBlock(void* reader, int direction);
int cvGetSeqReaderPos(CvSeqReader* reader);
void cvSetSeqReaderPos(CvSeqReader* reader, int index, int is_relative CV_DEFAULT(0));
schar* cvSeqPush(CvSeq* seq, const void* element CV_DEFAULT(NULL));
void cvSeqPop(CvSeq* seq, void* element CV_DEFAULT(NULL));
void cvSeqPushMulti(CvSeq* seq, const void* elements, int count, int in_front CV_DEFAULT(0));
void cvSeqPopMulti(CvSeq* seq, void* elements, int count, int in_front CV_DEFAULT(0));
void cvClearSeq(CvSeq *seq);

/****************************************************************************************\
*                                  Set implementation                                    *
\****************************************************************************************/
CvSet* cvCreateSet(int set_flags, int header_size, int elem_size, CvMemStorage* storage);
int cvSetAdd(CvSet* set_header, CvSetElem* elem CV_DEFAULT(NULL), CvSetElem** inserted_elem CV_DEFAULT(NULL));
void cvClearSet(CvSet* set_header);

/****************************************************************************************\
*                                   Contours Tracing                                     *
\****************************************************************************************/
CvContourScanner cvStartFindContours(IplImage* image, CvMemStorage* storage,
	int header_size CV_DEFAULT(sizeof(CvContour)),
	int mode CV_DEFAULT(CV_RETR_LIST),
	int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
	CvPoint offset CV_DEFAULT(cvPoint(0, 0)));
void icvEndProcessContour(CvContourScanner scanner);
void cvSubstituteContour(CvContourScanner scanner, CvSeq* new_contour);
void icvFetchContour(schar *ptr, int step, CvPoint pt, CvSeq* contour, int _method);
static int icvTraceContour(schar *ptr, int step, schar *stop_ptr, int is_hole);
static void icvFetchContourEx(schar* ptr, int step, CvPoint pt, CvSeq* contour, int _method, int nbd, CvRect* _rect);
static int icvTraceContour_32s(int *ptr, int step, int *stop_ptr, int is_hole);
static void icvFetchContourEx_32s(int* ptr, int step, CvPoint pt, CvSeq* contour, int _method, CvRect* _rect);
CvSeq* cvFindNextContour(CvContourScanner scanner);
CvSeq* cvEndFindContours(CvContourScanner * scanner);

/****************************************************************************************\
*                                  Chain Approximation                                   *
\****************************************************************************************/
void cvStartReadChainPoints(CvChain * chain, CvChainPtReader * reader);
CvSeq* icvApproximateChainTC89(CvChain* chain, int header_size, CvMemStorage* storage, int method);
int cvRound(Float64_t value);
int cvFloor(Float64_t value);
int cvCeil(Float64_t value);

/****************************************************************************************\
*                               Polygonal Approximation                                  *
\****************************************************************************************/
static int approxPolyDP_32s(const CvPoint* src_contour, int count0, CvPoint* dst_contour, bool is_closed0, Float64_t eps, AutoBuffer<Range>* _stack);
static int approxPolyDP_32f(const CvPoint2D32f* src_contour, int count0, CvPoint2D32f* dst_contour, bool is_closed0, Float64_t eps, AutoBuffer<Range>* _stack);
CvSeq* cvApproxPoly(const CvSeq* src_seq, int header_size, CvMemStorage* storage, int method, Float64_t eps, int recursive CV_DEFAULT(0));

/****************************************************************************************\
*                            Contour Processing and Shape Analysis                       *
\****************************************************************************************/
Float64_t cvArcLength(const CvSeq* curve, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ), int is_closed CV_DEFAULT(-1));
//Float64_t cvContourPerimeter( const void* contour )
//{
//	return cvArcLength( contour, CV_WHOLE_SEQ, 1 );
//}
CvRect cvBoundingRect(const CvSeq* ptseq, int update);
Float64_t contourArea(const CvSeq* contour, bool oriented);
static Float64_t icvContourSecArea(const CvSeq * contour, CvSlice slice);
Float64_t cvContourArea(const CvSeq* contour, CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ), int oriented CV_DEFAULT(0));
static int icvSklansky_32s(CvPoint** array, int start, int end, int* stack, int nsign, int sign2);
static int icvSklansky_32f(CvPoint2D32f** array, int start, int end, int* stack, int nsign, int sign2);
static void icvCalcAndWritePtIndices(CvPoint** pointer, int* stack, int start, int end, const CvSeq* ptseq, CvSeqWriter* writer);
CvSeq* cvConvexHull2(const CvSeq* input, void* hull_storage CV_DEFAULT(NULL), int orientation CV_DEFAULT(CV_CLOCKWISE), int return_points CV_DEFAULT(0));
bool isContourConvex(const CvSeq* contour);
int cvCheckContourConvexity(const CvSeq* contour);

/****************************************************************************************\
*            Functions for manipulating memory storage - list of memory blocks           *
\****************************************************************************************/
static void icvInitMemStorage(CvMemStorage* storage, int block_size);
CvMemStorage* cvCreateMemStorage(int block_size);
CvMemStorage* cvCreateChildMemStorage(CvMemStorage * parent);
static void icvDestroyMemStorage(CvMemStorage* storage);
void cvReleaseMemStorage(CvMemStorage** storage);
void cvClearMemStorage(CvMemStorage * storage);
static void icvGoNextMemBlock(CvMemStorage * storage);
void cvSaveMemStoragePos(const CvMemStorage * storage, CvMemStoragePos * pos);
void cvRestoreMemStoragePos(CvMemStorage * storage, CvMemStoragePos * pos);
void* cvMemStorageAlloc(CvMemStorage* storage, size_t size);
static void icvMemCopy(Float64_t **buf1, Float64_t **buf2, Float64_t **buf3, int *b_max);

/****************************************************************************************\
*                                 Working with sequence tree                             *
\****************************************************************************************/
void cvInsertNodeIntoTree(void* _node, void* _parent, void* _frame);

static inline void* cvAlignPtr(const void* ptr, int align = 32);
inline int cvAlignLeft(int size, int align);
static inline int cvAlign(int size, int align);

/****************************************************************************************\
 *          Array allocation, deallocation, initialization and access to elements         *
 \****************************************************************************************/
void* fastMalloc(size_t size);
void fastFree(void* ptr);
void* cvAlloc(size_t size);
void cvFree_(void* ptr);

//load and save images
extern "C" IplImage* cvLoadImage(const char* filename);
extern "C" int cvSaveImage(const char* filename, const IplImage * image);

// solve none homogeneous function group

/*!
Random Number Generator

The class implements RNG using Multiply-with-Carry algorithm
*/

#define CV_RNG_COEFF 4164903690U
struct RNG
{
	RNG();
	RNG(unsigned long long _state);
	unsigned next();

	unsigned long long state;
};
inline RNG::RNG() { state = 0xffffffff; }
inline RNG::RNG(unsigned long long _state) { state = _state ? _state : 0xffffffff; }
inline unsigned RNG::next()
{
	state = (unsigned long long)(unsigned)state*CV_RNG_COEFF + (unsigned)(state >> 32);
	return (unsigned)state;
}

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

void JacobiSVDImpl_(Float64_t* At, size_t astep, Float64_t* _W, Float64_t* Vt, size_t vstep,
	int m, int n, int n1, Float64_t minval, Float64_t eps);

static void MatrAXPY(int m, int n, const Float64_t* x, int dx, const Float64_t* a, int inca, Float64_t* y, int dy);

static void SVBkSbImpl_(int m, int n, const Float64_t* w, int incw,
	const Float64_t* u, int ldu, bool uT,
	const Float64_t* v, int ldv, bool vT,
	const Float64_t* b, int ldb, int nb,
	Float64_t* x, int ldx, Float64_t* buffer, Float64_t eps);

static void SVBkSb(int m, int n, const Float64_t* w, size_t wstep,
	const Float64_t* u, size_t ustep, bool uT,
	const Float64_t* v, size_t vstep, bool vT,
	const Float64_t* b, size_t bstep, int nb,
	Float64_t* x, size_t xstep, uchar* buffer);

static void JacobiSVD(Float64_t* At, size_t astep, Float64_t* W, Float64_t* Vt, size_t vstep, int m, int n, int n1 = -1);

#define CV_IMPLEMENT_QSORT_EX( func_name, T, LT, user_data_type )                   \
void func_name(T *array, size_t total, user_data_type aux)                          \
{                                                                                   \
    int isort_thresh = 7;                                                           \
    T t;                                                                            \
    int sp = 0;                                                                     \
    struct                                                                          \
    {                                                                               \
        T *lb;                                                                      \
        T *ub;                                                                      \
    }                                                                               \
	stack[48];                                                                      \
	                                                                                \
	aux = aux;                                                                      \
                                        	                                        \
    if (total <= 1)                                                                 \
        return;                                                                     \
	                                                                                \
    stack[0].lb = array;                                                            \
    stack[0].ub = array + (total - 1);                                              \
                                                                                    \
    while (sp >= 0)                                                                 \
    {                                                                               \
        T* left = stack[sp].lb;                                                     \
        T* right = stack[sp--].ub;                                                  \
                                                                                    \
        for (;;)                                                                    \
        {                                                                           \
            int i, n = (int)(right - left) + 1, m;                                  \
            T* ptr;                                                                 \
            T* ptr2;                                                                \
                                                                                    \
            if (n <= isort_thresh)                                                  \
            {                                                                       \
			    insert_sort:                                                        \
                for (ptr = left + 1; ptr <= right; ptr++)                           \
                {                                                                   \
                    for (ptr2 = ptr; ptr2 > left && LT(ptr2[0], ptr2[-1]); ptr2--)  \
				        CV_SWAP(ptr2[0], ptr2[-1], t);                              \
                }                                                                   \
                break;                                                              \
            }                                                                       \
            else                                                                    \
            {                                                                       \
                T* left0;                                                           \
                T* left1;                                                           \
                T* right0;                                                          \
                T* right1;                                                          \
                T* pivot;                                                           \
                T* a;                                                               \
                T* b;                                                               \
                T* c;                                                               \
                int swap_cnt = 0;                                                   \
                                                                                    \
                left0 = left;                                                       \
                right0 = right;                                                     \
                pivot = left + (n / 2);                                             \
                                                                                    \
                if (n > 40)                                                         \
                {                                                                   \
                    int d = n / 8;                                                  \
                    a = left, b = left + d, c = left + 2 * d;                       \
                    left = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))     \
                                      : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));    \
                                                                                    \
	                a = pivot - d, b = pivot, c = pivot + d;                        \
                    pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))    \
                                       : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));   \
                                                                                    \
                    a = right - 2 * d, b = right - d, c = right;                    \
                    right = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))    \
                                       : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));   \
                }                                                                   \
                                                                                    \
                a = left, b = pivot, c = right;                                     \
                pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a))        \
                                   : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c));       \
                if (pivot != left0)                                                 \
                {                                                                   \
                    CV_SWAP(*pivot, *left0, t);                                     \
                    pivot = left0;                                                  \
                }                                                                   \
                left = left1 = left0 + 1;                                           \
                right = right1 = right0;                                            \
                                                                                    \
                for (;;)                                                            \
                {                                                                   \
                    while (left <= right && !LT(*pivot, *left))                     \
                    {                                                               \
                        if (!LT(*left, *pivot))                                     \
                        {                                                           \
                            if (left > left1)                                       \
	                            CV_SWAP(*left1, *left, t);                          \
	                        swap_cnt = 1;                                           \
	                        left1++;                                                \
                        }                                                           \
	                    left++;                                                     \
                    }                                                               \
                                                                                    \
                    while (left <= right && !LT(*right, *pivot))                    \
                    {                                                               \
                        if (!LT(*pivot, *right))                                    \
                        {                                                           \
                            if (right < right1)                                     \
                                CV_SWAP(*right1, *right, t);                        \
                            swap_cnt = 1;                                           \
                            right1--;                                               \
                        }                                                           \
                        right--;                                                    \
                    }                                                               \
                                                                                    \
                    if (left > right)                                               \
                        break;                                                      \
                    CV_SWAP(*left, *right, t);                                      \
                    swap_cnt = 1;                                                   \
                    left++;                                                         \
                    right--;                                                        \
                }                                                                   \
                                                                                    \
                if (swap_cnt == 0)                                                  \
                {                                                                   \
                    left = left0, right = right0;                                   \
                    goto insert_sort;                                               \
                }                                                                   \
                                                                                    \
                n = MIN((int)(left1 - left0), (int)(left - left1));                 \
                for (i = 0; i < n; i++)                                             \
                    CV_SWAP(left0[i], left[i - n], t);                              \
                                                                                    \
                n = MIN((int)(right0 - right1), (int)(right1 - right));             \
                for (i = 0; i < n; i++)                                             \
                    CV_SWAP(left[i], right0[i - n + 1], t);                         \
                n = (int)(left - left1);                                            \
                m = (int)(right1 - right);                                          \
                if (n > 1)                                                          \
                {                                                                   \
                    if (m > 1)                                                      \
                    {                                                               \
                        if (n > m)                                                  \
                        {                                                           \
                            stack[++sp].lb = left0;                                 \
                            stack[sp].ub = left0 + n - 1;                           \
                            left = right0 - m + 1, right = right0;                  \
                        }                                                           \
                        else                                                        \
                        {                                                           \
                            stack[++sp].lb = right0 - m + 1;                        \
                            stack[sp].ub = right0;                                  \
                            left = left0, right = left0 + n - 1;                    \
                        }                                                           \
                    }                                                               \
                    else                                                            \
                        left = left0, right = left0 + n - 1;                        \
                }                                                                   \
                else if (m > 1)                                                     \
                    left = right0 - m + 1, right = right0;                          \
                else                                                                \
                    break;                                                          \
            }                                                                       \
        }                                                                           \
    }                                                                               \
}

#define CV_IMPLEMENT_QSORT( func_name, T, cmp )  \
	CV_IMPLEMENT_QSORT_EX(func_name, T, cmp, int)

#endif

#endif