// Copyright 2011 <chaishushan@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// 22/11/2013 Updated by <mohamd.helala@gmail.com>.

package opencv

/*
#cgo linux  pkg-config: opencv
#cgo darwin pkg-config: opencv
#cgo freebsd pkg-config: opencv
#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++

#include "opencv.h"
#include <stdlib.h>
#include <string.h>

//-----------------------------------------------------------------------------

// version
// const char* CV_VERSION_ = CV_VERSION;

//-----------------------------------------------------------------------------

// IplImage
static int IPL_IMAGE_MAGIC_VAL_() {
	return IPL_IMAGE_MAGIC_VAL;
}
static const char* CV_TYPE_NAME_IMAGE_() {
	return CV_TYPE_NAME_IMAGE;
}
static int CV_IS_IMAGE_HDR_(void* img) {
	return CV_IS_IMAGE_HDR(img);
}
static int CV_IS_IMAGE_(void* img) {
	return CV_IS_IMAGE(img);
}

//-----------------------------------------------------------------------------

// type filed is go keyword
static int myGetMatType(const CvMat* mat) {
	return mat->type;
}
static char* myGetData(const CvMat* mat) {
	return  (char*)mat->data.ptr;
}
static int myGetMatNDType(const CvMatND* mat) {
	return mat->type;
}
static int myGetSparseMatType(const CvSparseMat* mat) {
	return mat->type;
}
static int myGetTermCriteriaType(const CvTermCriteria* x) {
	return x->type;
}

#define CV_CHAIN_SIZE sizeof(CvChain)
#define CV_CONTOUR_SIZE sizeof(CvContour)
#define CV_SEQ_SIZE sizeof(CvSeq)
#define CV_SEQBLOCK_SIZE sizeof(CvSeqBlock)
#define CV_POINT_SIZE sizeof(CvPoint)
//-----------------------------------------------------------------------------

*/
import "C"
import (
	"unsafe"
)

//-----------------------------------------------------------------------------

// cvver.h

//-----------------------------------------------------------------------------

const (
	CV_MAJOR_VERSION    = int(C.CV_MAJOR_VERSION)
	CV_MINOR_VERSION    = int(C.CV_MINOR_VERSION)
	CV_SUBMINOR_VERSION = int(C.CV_SUBMINOR_VERSION)
)

var (
//CV_VERSION = C.GoString(C.CV_VERSION_)
)

//-----------------------------------------------------------------------------
// cxerror.h
//-----------------------------------------------------------------------------

const (
	CV_StsOk                     = C.CV_StsOk
	CV_StsBackTrace              = C.CV_StsBackTrace
	CV_StsError                  = C.CV_StsError
	CV_StsInternal               = C.CV_StsInternal
	CV_StsNoMem                  = C.CV_StsNoMem
	CV_StsBadArg                 = C.CV_StsBadArg
	CV_StsBadFunc                = C.CV_StsBadFunc
	CV_StsNoConv                 = C.CV_StsNoConv
	CV_StsAutoTrace              = C.CV_StsAutoTrace
	CV_HeaderIsNull              = C.CV_HeaderIsNull
	CV_BadImageSize              = C.CV_BadImageSize
	CV_BadOffset                 = C.CV_BadOffset
	CV_BadDataPtr                = C.CV_BadDataPtr
	CV_BadStep                   = C.CV_BadStep
	CV_BadModelOrChSeq           = C.CV_BadModelOrChSeq
	CV_BadNumChannels            = C.CV_BadNumChannels
	CV_BadNumChannel1U           = C.CV_BadNumChannel1U
	CV_BadDepth                  = C.CV_BadDepth
	CV_BadAlphaChannel           = C.CV_BadAlphaChannel
	CV_BadOrder                  = C.CV_BadOrder
	CV_BadOrigin                 = C.CV_BadOrigin
	CV_BadAlign                  = C.CV_BadAlign
	CV_BadCallBack               = C.CV_BadCallBack
	CV_BadTileSize               = C.CV_BadTileSize
	CV_BadCOI                    = C.CV_BadCOI
	CV_BadROISize                = C.CV_BadROISize
	CV_MaskIsTiled               = C.CV_MaskIsTiled
	CV_StsNullPtr                = C.CV_StsNullPtr
	CV_StsVecLengthErr           = C.CV_StsVecLengthErr
	CV_StsFilterStructContentErr = C.CV_StsFilterStructContentErr
	CV_StsKernelStructContentErr = C.CV_StsKernelStructContentErr
	CV_StsFilterOffsetErr        = C.CV_StsFilterOffsetErr
	CV_StsBadSize                = C.CV_StsBadSize
	CV_StsDivByZero              = C.CV_StsDivByZero
	CV_StsInplaceNotSupported    = C.CV_StsInplaceNotSupported
	CV_StsObjectNotFound         = C.CV_StsObjectNotFound
	CV_StsUnmatchedFormats       = C.CV_StsUnmatchedFormats
	CV_StsBadFlag                = C.CV_StsBadFlag
	CV_StsBadPoint               = C.CV_StsBadPoint
	CV_StsBadMask                = C.CV_StsBadMask
	CV_StsUnmatchedSizes         = C.CV_StsUnmatchedSizes
	CV_StsUnsupportedFormat      = C.CV_StsUnsupportedFormat
	CV_StsOutOfRange             = C.CV_StsOutOfRange
	CV_StsParseError             = C.CV_StsParseError
	CV_StsNotImplemented         = C.CV_StsNotImplemented
	CV_StsBadMemBlock            = C.CV_StsBadMemBlock
	CV_StsAssert                 = C.CV_StsAssert
	//CV_GpuNotSupported=          C.CV_GpuNotSupported
	//CV_GpuApiCallError=          C.CV_GpuApiCallError
	//CV_GpuNppCallError=          C.CV_GpuNppCallError
)

//-----------------------------------------------------------------------------
// cxtypes.h
//-----------------------------------------------------------------------------
type Arr unsafe.Pointer

/*****************************************************************************\
*                      Common macros and inline functions                     *
\*****************************************************************************/

const (
	CV_PI   = 3.1415926535897932384626433832795
	CV_LOG2 = 0.69314718055994530941723212145818
)

func Round(value float64) int {
	rv := C.cvRound(C.double(value))
	return int(rv)
}
func Floor(value float64) int {
	rv := C.cvFloor(C.double(value))
	return int(rv)
}
func Ceil(value float64) int {
	rv := C.cvCeil(C.double(value))
	return int(rv)
}

func IsNaN(value float64) int {
	rv := C.cvIsNaN(C.double(value))
	return int(rv)
}
func IsInf(value float64) int {
	rv := C.cvIsInf(C.double(value))
	return int(rv)
}

/*************** Random number generation *******************/

type RNG C.CvRNG

func NewRNG(seed int64) RNG {
	rv := C.cvRNG(C.int64(seed))
	return RNG(rv)
}
func (rng *RNG) RandInt() uint32 {
	rv := C.cvRandInt((*C.CvRNG)(rng))
	return uint32(rv)
}
func (rng *RNG) RandReal() float64 {
	rv := C.cvRandReal((*C.CvRNG)(rng))
	return float64(rv)
}

/*****************************************************************************\
*                            Image type (IplImage)                            *
\*****************************************************************************/

/*
 * The following definitions (until #endif)
 * is an extract from IPL headers.
 * Copyright (c) 1995 Intel Corporation.
 */
const (
	IPL_DEPTH_SIGN = C.IPL_DEPTH_SIGN

	IPL_DEPTH_1U  = C.IPL_DEPTH_1U
	IPL_DEPTH_8U  = C.IPL_DEPTH_8U
	IPL_DEPTH_16U = C.IPL_DEPTH_16U
	IPL_DEPTH_32F = C.IPL_DEPTH_32F

	IPL_DEPTH_8S  = C.IPL_DEPTH_8S
	IPL_DEPTH_16S = C.IPL_DEPTH_16S
	IPL_DEPTH_32S = C.IPL_DEPTH_32S

	IPL_DATA_ORDER_PIXEL = C.IPL_DATA_ORDER_PIXEL
	IPL_DATA_ORDER_PLANE = C.IPL_DATA_ORDER_PLANE

	IPL_ORIGIN_TL = C.IPL_ORIGIN_TL
	IPL_ORIGIN_BL = C.IPL_ORIGIN_BL

	IPL_ALIGN_4BYTES  = C.IPL_ALIGN_4BYTES
	IPL_ALIGN_8BYTES  = C.IPL_ALIGN_8BYTES
	IPL_ALIGN_16BYTES = C.IPL_ALIGN_16BYTES
	IPL_ALIGN_32BYTES = C.IPL_ALIGN_32BYTES

	IPL_ALIGN_DWORD = C.IPL_ALIGN_DWORD
	IPL_ALIGN_QWORD = C.IPL_ALIGN_QWORD

	IPL_BORDER_CONSTANT  = C.IPL_BORDER_CONSTANT
	IPL_BORDER_REPLICATE = C.IPL_BORDER_REPLICATE
	IPL_BORDER_REFLECT   = C.IPL_BORDER_REFLECT
	IPL_BORDER_WRAP      = C.IPL_BORDER_WRAP
)

type IplImage C.IplImage

// normal fields
func (img *IplImage) Channels() int {
	return int(img.nChannels)
}
func (img *IplImage) Depth() int {
	return int(img.depth)
}
func (img *IplImage) Origin() int {
	return int(img.origin)
}
func (img *IplImage) Width() int {
	return int(img.width)
}
func (img *IplImage) Height() int {
	return int(img.height)
}
func (img *IplImage) WidthStep() int {
	return int(img.widthStep)
}
func (img *IplImage) ImageSize() int {
	return int(img.imageSize)
}
func (img *IplImage) ImageData() unsafe.Pointer {
	return unsafe.Pointer(img.imageData)
}
func (img *IplImage) Ptr() unsafe.Pointer {
	return unsafe.Pointer(img)
}

type IplROI C.IplROI

func (roi *IplROI) Init(coi, xOffset, yOffset, width, height int) {
	roi_c := (*C.IplROI)(roi)
	roi_c.coi = C.int(coi)
	roi_c.xOffset = C.int(xOffset)
	roi_c.yOffset = C.int(yOffset)
	roi_c.width = C.int(width)
	roi_c.height = C.int(height)
}
func (roi *IplROI) Coi() int {
	roi_c := (*C.IplROI)(roi)
	return int(roi_c.coi)
}
func (roi *IplROI) XOffset() int {
	roi_c := (*C.IplROI)(roi)
	return int(roi_c.xOffset)
}
func (roi *IplROI) YOffset() int {
	roi_c := (*C.IplROI)(roi)
	return int(roi_c.yOffset)
}
func (roi *IplROI) Width() int {
	roi_c := (*C.IplROI)(roi)
	return int(roi_c.width)
}
func (roi *IplROI) Height() int {
	roi_c := (*C.IplROI)(roi)
	return int(roi_c.height)
}

type IplConvKernel C.IplConvKernel
type IplConvKernelFP C.IplConvKernelFP

const (
	IPL_IMAGE_HEADER = C.IPL_IMAGE_HEADER
	IPL_IMAGE_DATA   = C.IPL_IMAGE_DATA
	IPL_IMAGE_ROI    = C.IPL_IMAGE_ROI
)

/* extra border mode */
var (
	IPL_IMAGE_MAGIC_VAL = C.IPL_IMAGE_MAGIC_VAL_()
	CV_TYPE_NAME_IMAGE  = C.CV_TYPE_NAME_IMAGE_()
)

func CV_IS_IMAGE_HDR(img unsafe.Pointer) bool {
	rv := C.CV_IS_IMAGE_HDR_(img)
	return (int(rv) != 0)
}
func CV_IS_IMAGE(img unsafe.Pointer) bool {
	rv := C.CV_IS_IMAGE_(img)
	return (int(rv) != 0)
}

const (
	IPL_DEPTH_64F = int(C.IPL_DEPTH_64F)
)

/****************************************************************************************\
*                                  Matrix type (CvMat)                                   *
\****************************************************************************************/

const(
CV_8U      				= C.CV_8U
CV_8S      				= C.CV_8S
CV_16U     				= C.CV_16U
CV_16S     				= C.CV_16S
CV_32S     				= C.CV_32S
CV_32F     				= C.CV_32F
CV_64F                  = C.CV_64F
CV_USRTYPE1             = C.CV_USRTYPE1

CV_MAT_DEPTH_MASK       = C.CV_MAT_DEPTH_MASK

CV_8UC1                 = C.CV_8UC1
CV_8UC2                 = C.CV_8UC2
CV_8UC3                 = C.CV_8UC3
CV_8UC4                 = C.CV_8UC4

CV_8SC1                 = C.CV_8SC1
CV_8SC2                 = C.CV_8SC2
CV_8SC3                 = C.CV_8SC3
CV_8SC4                 = C.CV_8SC4

CV_16UC1                = C.CV_16UC1
CV_16UC2                = C.CV_16UC2
CV_16UC3                = C.CV_16UC3
CV_16UC4                = C.CV_16UC4

CV_16SC1                = C.CV_16SC1
CV_16SC2                = C.CV_16SC2
CV_16SC3                = C.CV_16SC3
CV_16SC4                = C.CV_16SC4

CV_32SC1                = C.CV_32SC1
CV_32SC2                = C.CV_32SC2
CV_32SC3                = C.CV_32SC3
CV_32SC4                = C.CV_32SC4

CV_32FC1                = C.CV_32FC1
CV_32FC2                = C.CV_32FC2
CV_32FC3                = C.CV_32FC3
CV_32FC4                = C.CV_32FC4

CV_64FC1                = C.CV_64FC1
CV_64FC2                = C.CV_64FC2
CV_64FC3                = C.CV_64FC3
CV_64FC4                = C.CV_64FC4

)

type Mat C.CvMat

func (mat *Mat) Type() int {
	return int(C.myGetMatType((*C.CvMat)(mat)))
}
func (mat *Mat) GetData() []byte {
	return C.GoBytes(unsafe.Pointer(C.myGetData((*C.CvMat)(mat))), C.int(mat.step))
}
func (mat *Mat) Step() int {
	return int(mat.step)
}

func (mat *Mat) Rows() int {
	return int(mat.rows)
}
func (mat *Mat) Cols() int {
	return int(mat.cols)
}
func (mat *Mat) Ptr() unsafe.Pointer {
	return unsafe.Pointer(mat)
}

func CV_IS_MAT_HDR(mat interface{}) bool {
	return false
}
func CV_IS_MAT(mat interface{}) bool {
	return false
}
func CV_IS_MASK_ARR() bool {
	return false
}
func CV_ARE_TYPE_EQ() bool {
	return false
}

func (m *Mat) Init(rows, cols int, type_ int, data unsafe.Pointer) {
	return
}
func (m *Mat) Get(row, col int) float64 {
	rv := C.cvmGet((*C.CvMat)(m), C.int(row), C.int(col))
	return float64(rv)
}
func (m *Mat) Set(row, col int, value float64) {
	C.cvmSet((*C.CvMat)(m), C.int(row), C.int(col), C.double(value))
}

func IplDepth(type_ int) int {
	rv := C.cvIplDepth(C.int(type_))
	return int(rv)
}

/****************************************************************************************\
*                       Multi-dimensional dense array (CvMatND)                          *
\****************************************************************************************/

const (
	CV_MATND_MAGIC_VAL = C.CV_MATND_MAGIC_VAL
	CV_TYPE_NAME_MATND = C.CV_TYPE_NAME_MATND

	CV_MAX_DIM      = C.CV_MAX_DIM
	CV_MAX_DIM_HEAP = C.CV_MAX_DIM_HEAP
)

type MatND C.CvMatND

func (m *MatND) Type() int {
	rv := C.myGetMatNDType((*C.CvMatND)(m))
	return int(rv)
}
func (m *MatND) Dims() int {
	rv := m.dims
	return int(rv)
}

/****************************************************************************************\
*                      Multi-dimensional sparse array (CvSparseMat)                      *
\****************************************************************************************/

const (
	CV_SPARSE_MAT_MAGIC_VAL = C.CV_SPARSE_MAT_MAGIC_VAL
	CV_TYPE_NAME_SPARSE_MAT = C.CV_TYPE_NAME_SPARSE_MAT
)

type SparseMat C.CvSparseMat

func (m *SparseMat) Type() int {
	rv := C.myGetSparseMatType((*C.CvSparseMat)(m))
	return int(rv)
}
func (m *SparseMat) Dims() int {
	rv := m.dims
	return int(rv)
}

/**************** iteration through a sparse array *****************/

type SparseNode C.CvSparseNode

func (node *SparseNode) HashVal() uint32 {
	rv := node.hashval
	return uint32(rv)
}
func (node *SparseNode) Next() *SparseNode {
	rv := node.next
	return (*SparseNode)(rv)
}

type SparseMatIterator C.CvSparseMatIterator

func (node *SparseMatIterator) Mat() *SparseMat {
	rv := node.mat
	return (*SparseMat)(rv)
}
func (node *SparseMatIterator) Node() *SparseNode {
	rv := node.node
	return (*SparseNode)(rv)
}
func (node *SparseMatIterator) CurIdx() int {
	rv := node.curidx
	return (int)(rv)
}

/****************************************************************************************\
*                                         Histogram                                      *
\****************************************************************************************/

type HistType C.CvHistType

const (
	CV_HIST_MAGIC_VAL    = C.CV_HIST_MAGIC_VAL
	CV_HIST_UNIFORM_FLAG = C.CV_HIST_UNIFORM_FLAG

	/* indicates whether bin ranges are set already or not */
	CV_HIST_RANGES_FLAG = C.CV_HIST_RANGES_FLAG

	CV_HIST_ARRAY  = C.CV_HIST_ARRAY
	CV_HIST_SPARSE = C.CV_HIST_SPARSE
	CV_HIST_TREE   = C.CV_HIST_TREE

	/* should be used as a parameter only,
	   it turns to CV_HIST_UNIFORM_FLAG of hist->type */
	CV_HIST_UNIFORM = C.CV_HIST_UNIFORM
)

type Histogram C.CvHistogram

func CV_IS_HIST() bool {
	return false
}
func CV_IS_UNIFORM_HIST() bool {
	return false
}
func CV_IS_SPARSE_HIST() bool {
	return false
}
func CV_HIST_HAS_RANGES() bool {
	return false
}

/****************************************************************************************\
*                      Other supplementary data type definitions                         *
\****************************************************************************************/

/*************************************** CvRect *****************************************/

type Rect C.CvRect

func (r *Rect) Init(x, y, w, h int) {
	r.x = C.int(x)
	r.y = C.int(y)
	r.width = C.int(w)
	r.height = C.int(h)
}
func (r *Rect) X() int {
	r_c := (*C.CvRect)(r)
	return int(r_c.x)
}
func (r *Rect) Y() int {
	r_c := (*C.CvRect)(r)
	return int(r_c.y)
}
func (r *Rect) Width() int {
	r_c := (*C.CvRect)(r)
	return int(r_c.width)
}
func (r *Rect) Height() int {
	r_c := (*C.CvRect)(r)
	return int(r_c.height)
}

func (r *Rect) ToROI(coi int) IplROI {
	r_c := (*C.CvRect)(r)
	return (IplROI)(C.cvRectToROI(*r_c, C.int(coi)))
}

func (roi *IplROI) ToRect() Rect {
	r := C.cvRect(
		C.int(roi.XOffset()),
		C.int(roi.YOffset()),
		C.int(roi.Width()),
		C.int(roi.Height()),
	)
	return Rect(r)
}

/*********************************** CvTermCriteria *************************************/

const (
	CV_TERMCRIT_ITER   = C.CV_TERMCRIT_ITER
	CV_TERMCRIT_NUMBER = C.CV_TERMCRIT_NUMBER
	CV_TERMCRIT_EPS    = C.CV_TERMCRIT_EPS
)

type TermCriteria C.CvTermCriteria

func (x *TermCriteria) Init(type_, max_iter int, epsilon float64) {
	rv := C.cvTermCriteria(C.int(type_), C.int(max_iter), C.double(epsilon))
	(*x) = (TermCriteria)(rv)
}

func (x *TermCriteria) Type() int {
	rv := C.myGetTermCriteriaType((*C.CvTermCriteria)(x))
	return int(rv)
}
func (x *TermCriteria) MaxIter() int {
	rv := x.max_iter
	return int(rv)
}
func (x *TermCriteria) Epsilon() float64 {
	rv := x.epsilon
	return float64(rv)
}

/******************************* CvPoint and variants ***********************************/

const (
	CV_POINT_SIZE = C.CV_POINT_SIZE
)

type Point struct {
	X int
	Y int
}

type Point2D32f struct {
	X float32
	Y float32
}
type Point3D32f struct {
	X float32
	Y float32
	Z float32
}

type Point2D64f struct {
	X float64
	Y float64
}
type Point3D64f struct {
	X float64
	Y float64
	Z float64
}

func GetPoint(p unsafe.Pointer) Point {
	cvpt := (*C.CvPoint)(p)
	return Point{int(cvpt.x), int(cvpt.y)}
}

/******************************** CvSize's & CvBox **************************************/

type Size struct {
	Width  int
	Height int
}

type Size2D32f struct {
	Width  float32
	Height float32
}

type Box2D struct {
	center Point2D32f
	size   Size2D32f
	angle  float32
}

type LineIterator C.CvLineIterator

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

type Slice C.CvSlice

var (
	CV_WHOLE_SEQ Slice = (Slice)(C.cvSlice(0, CV_WHOLE_SEQ_END_INDEX))
)

const (
	CV_WHOLE_SEQ_END_INDEX = C.CV_WHOLE_SEQ_END_INDEX
)

/************************************* CvScalar *****************************************/

type Scalar C.CvScalar

func NewScalar(b, g, r, a float64) Scalar {
	rv := C.cvScalar(C.double(b), C.double(g), C.double(r), C.double(a))
	return (Scalar)(rv)
}

func ScalarAll(val0 float64) Scalar {
	rv := C.cvScalarAll(C.double(val0))
	return (Scalar)(rv)
}

/* Val returns an array with the scalars values. */
func (s Scalar) Val() [4]float64 {
	return [4]float64{
		float64(s.val[0]),
		float64(s.val[1]),
		float64(s.val[2]),
		float64(s.val[3]),
	}
}

// CV_INLINE  CvScalar  cvScalarAll( double val0123 );

func ScalarN(val0, val1, val2, val3 float64) Scalar {
	rv := C.cvScalar(C.double(val0), C.double(val1),
		C.double(val2), C.double(val3))
	return (Scalar)(rv)
}

// CV_INLINE  CvScalar  cvScalar( double val0, double val1 CV_DEFAULT(0),
//                                double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0));
func RealScalar(val0 float64) Scalar {
	rv := C.cvRealScalar(C.double(val0))
	return (Scalar)(rv)
}

// CV_INLINE  CvScalar  cvRealScalar( double val0 );

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

/******************************** Memory storage ****************************************/

type MemBlock C.CvMemBlock
type MemStorage C.CvMemStorage
type MemStoragePos C.CvMemStoragePos

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

type SeqBlock C.CvSeqBlock
type Seq C.CvSeq

const (
	CV_SEQ_SIZE      = C.CV_SEQ_SIZE
	CV_SEQBLOCK_SIZE = C.CV_SEQBLOCK_SIZE
)

func (seq *Seq) Count() int {
	return int(seq.total)
}

func (seq *Seq) Ptr() unsafe.Pointer {
	return unsafe.Pointer(seq)
}

func (seq *Seq) H_next() *Seq {
	return (*Seq)(seq.h_next)
}

func (seq *Seq) H_prev() *Seq {
	return (*Seq)(seq.h_prev)
}

/*
typedef struct CvSeq {
	int flags; // miscellaneous flags
	int header_size; // size of sequence header
	CvSeq* h_prev; // previous sequence
	CvSeq* h_next; // next sequence
	CvSeq* v_prev; // 2nd previous sequence
	CvSeq* v_next // 2nd next sequence
	int total; // total number of elements
	int elem_size; // size of sequence element in byte
	char* block_max; // maximal bound of the last block
	char* ptr; // current write pointer
	int delta_elems; // how many elements allocated
	// when the sequence grows
	CvMemStorage* storage; // where the sequence is stored
	CvSeqBlock* free_blocks; // free blocks list
	CvSeqBlock* first; // pointer to the first sequence block
}*/

type CmpFunc func(a unsafe.Pointer, b unsafe.Pointer, userdata unsafe.Pointer) int

const (
	CV_SEQ_ELTYPE_BITS = C.CV_SEQ_ELTYPE_BITS
	CV_SEQ_ELTYPE_MASK = C.CV_SEQ_ELTYPE_MASK

	CV_SEQ_ELTYPE_POINT          = C.CV_SEQ_ELTYPE_POINT
	CV_SEQ_ELTYPE_CODE           = C.CV_SEQ_ELTYPE_CODE
	CV_SEQ_ELTYPE_GENERIC        = C.CV_SEQ_ELTYPE_GENERIC
	CV_SEQ_ELTYPE_PTR            = C.CV_SEQ_ELTYPE_PTR
	CV_SEQ_ELTYPE_PPOINT         = C.CV_SEQ_ELTYPE_PPOINT
	CV_SEQ_ELTYPE_INDEX          = C.CV_SEQ_ELTYPE_INDEX
	CV_SEQ_ELTYPE_GRAPH_EDGE     = C.CV_SEQ_ELTYPE_GRAPH_EDGE
	CV_SEQ_ELTYPE_GRAPH_VERTEX   = C.CV_SEQ_ELTYPE_GRAPH_VERTEX
	CV_SEQ_ELTYPE_TRIAN_ATR      = C.CV_SEQ_ELTYPE_TRIAN_ATR
	CV_SEQ_ELTYPE_CONNECTED_COMP = C.CV_SEQ_ELTYPE_CONNECTED_COMP
	CV_SEQ_ELTYPE_POINT3D        = C.CV_SEQ_ELTYPE_POINT3D
	CV_SEQ_KIND_BITS             = C.CV_SEQ_KIND_BITS
	CV_SEQ_KIND_MASK             = C.CV_SEQ_KIND_MASK

	/* types of sequences */
	CV_SEQ_KIND_GENERIC  = C.CV_SEQ_KIND_GENERIC
	CV_SEQ_KIND_CURVE    = C.CV_SEQ_KIND_CURVE
	CV_SEQ_KIND_BIN_TREE = C.CV_SEQ_KIND_BIN_TREE

	/* types of sparse sequences (sets) */
	CV_SEQ_KIND_GRAPH    = C.CV_SEQ_KIND_GRAPH
	CV_SEQ_KIND_SUBDIV2D = C.CV_SEQ_KIND_SUBDIV2D

	CV_SEQ_FLAG_SHIFT = C.CV_SEQ_FLAG_SHIFT

	/* flags for curves */
	CV_SEQ_FLAG_CLOSED = C.CV_SEQ_FLAG_CLOSED
	CV_SEQ_FLAG_SIMPLE = C.CV_SEQ_FLAG_SIMPLE
	CV_SEQ_FLAG_CONVEX = C.CV_SEQ_FLAG_CONVEX
	CV_SEQ_FLAG_HOLE   = C.CV_SEQ_FLAG_HOLE
)

/*************************************** Set ********************************************/

type Set C.CvSet

/************************************* Graph ********************************************/

type GraphEdge C.CvGraphEdge
type GraphVtx C.CvGraphVtx

type GraphVtx2D C.CvGraphVtx2D
type Graph C.CvGraph

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

type Chain C.CvChain
type Contour C.CvContour

const (
	CV_CHAIN_SIZE   = C.CV_CHAIN_SIZE
	CV_CONTOUR_SIZE = C.CV_CONTOUR_SIZE
)

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

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

type SeqWriter C.CvSeqWriter
type SeqReader C.CvSeqReader

/****************************************************************************************/
/*                                Operations on sequences                               */
/****************************************************************************************/

/****************************************************************************************\
*             Data structures for persistence (a.k.a serialization) functionality        *
\****************************************************************************************/

/* "black box" file storage */
type FileStorage C.CvFileStorage

/* Storage flags: */
const (
	CV_STORAGE_READ         = C.CV_STORAGE_READ
	CV_STORAGE_WRITE        = C.CV_STORAGE_WRITE
	CV_STORAGE_WRITE_TEXT   = C.CV_STORAGE_WRITE_TEXT
	CV_STORAGE_WRITE_BINARY = C.CV_STORAGE_WRITE_BINARY
	CV_STORAGE_APPEND       = C.CV_STORAGE_APPEND
)

type AttrList C.CvAttrList

/*****************************************************************************\
*                                 --- END ---                                 *
\*****************************************************************************/