go fmt

opencv/cv.go

@@ -23,7 +23,6 @@ const (
 	CV_BLUR = C.CV_BLUR
 )
 
-
 /* Smoothes array (removes noise) */
 func Smooth(src, dst *IplImage, smoothtype,
 	param1, param2 int, param3, param4 float64) {
@@ -31,6 +30,7 @@ func Smooth(src, dst *IplImage, smoothtype,
 		C.int(param1), C.int(param2), C.double(param3), C.double(param4),
 	)
 }
+
 //CVAPI(void) cvSmooth( const CvArr* src, CvArr* dst,
 //                      int smoothtype CV_DEFAULT(CV_GAUSSIAN),
 //                      int param1 CV_DEFAULT(3),
@@ -42,15 +42,9 @@ func Smooth(src, dst *IplImage, smoothtype,
 func CvtColor(src, dst *IplImage, code int) {
 	C.cvCvtColor(unsafe.Pointer(src), unsafe.Pointer(dst), C.int(code))
 }
+
 //CVAPI(void)  cvCvtColor( const CvArr* src, CvArr* dst, int code );
 
-
-
-
-
-
-
-
 /* Runs canny edge detector */
 func Canny(image, edges *IplImage, threshold1, threshold2 float64, aperture_size int) {
 	C.cvCanny(unsafe.Pointer(image), unsafe.Pointer(edges),
@@ -58,10 +52,10 @@ func Canny(image, edges *IplImage, threshold1, threshold2 float64, aperture_size
 		C.int(aperture_size),
 	)
 }
+
 //CVAPI(void)  cvCanny( const CvArr* image, CvArr* edges, double threshold1,
 //                      double threshold2, int  aperture_size CV_DEFAULT(3) );
 
-
 const (
 	CV_INPAINT_NS    = C.CV_INPAINT_NS
 	CV_INPAINT_TELEA = C.CV_INPAINT_TELEA
@@ -77,8 +71,6 @@ func Inpaint(src, inpaint_mask, dst *IplImage, inpaintRange float64, flags int)
 		C.int(flags),
 	)
 }
+
 //CVAPI(void) cvInpaint( const CvArr* src, const CvArr* inpaint_mask,
 //                       CvArr* dst, double inpaintRange, int flags );
-
-
-

opencv/cvaux.go

@@ -10,86 +10,61 @@ package opencv
 //#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++
 import "C"
 
-
 /****************************************************************************************\
 *                                  Eigen objects                                         *
 \****************************************************************************************/
 
-
-
 /****************************************************************************************\
 *                                       1D/2D HMM                                        *
 \****************************************************************************************/
 
-
 /*********************************** Embedded HMMs *************************************/
 
-
 /****************************************************************************************\
 *               A few functions from old stereo gesture recognition demosions            *
 \****************************************************************************************/
 
-
 /****************************************************************************************\
 *                           Additional operations on Subdivisions                        *
 \****************************************************************************************/
 
-
-
 /****************************************************************************************\
 *                           More operations on sequences                                 *
 \****************************************************************************************/
 
-
 /*******************************Stereo correspondence*************************************/
 
-
 /*****************************************************************************************/
 /************ Epiline functions *******************/
 
-
 /****************************************************************************************\
 *                                   Contour Morphing                                     *
 \****************************************************************************************/
 
-
 /****************************************************************************************\
 *                                    Texture Descriptors                                 *
 \****************************************************************************************/
 
-
-
 /****************************************************************************************\
 *                                  Face eyes&mouth tracking                              *
 \****************************************************************************************/
 
-
-
 /****************************************************************************************\
 *                                         3D Tracker                                     *
 \****************************************************************************************/
 
-
-
-
 /****************************************************************************************\
 *                           Skeletons and Linear-Contour Models                          *
 \****************************************************************************************/
 
-
 /****************************************************************************************\
 *                           Background/foreground segmentation                           *
 \****************************************************************************************/
 
-
 /****************************************************************************************\
 *                                   Calibration engine                                   *
 \****************************************************************************************/
 
-
-
 /*****************************************************************************\
 *                                 --- END ---                                 *
 \*****************************************************************************/
-
-

opencv/cxcore.go

@@ -31,7 +31,7 @@ func Free(p unsafe.Pointer) {
 /* Allocates and initializes IplImage header */
 func CreateImageHeader(w, h, depth, channels int) *IplImage {
 	hdr := C.cvCreateImageHeader(
-		C.cvSize(C.int(w),C.int(h)),
+		C.cvSize(C.int(w), C.int(h)),
 		C.int(depth),
 		C.int(channels),
 	)
@@ -39,10 +39,10 @@ func CreateImageHeader(w, h, depth, channels int) *IplImage {
 }
 
 /* Inializes IplImage header */
-func (img *IplImage)InitHeader(w, h, depth, channels, origin, align int) {
+func (img *IplImage) InitHeader(w, h, depth, channels, origin, align int) {
 	C.cvInitImageHeader(
 		(*C.IplImage)(img),
-		C.cvSize(C.int(w),C.int(h)),
+		C.cvSize(C.int(w), C.int(h)),
 		C.int(depth),
 		C.int(channels),
 		C.int(origin),
@@ -58,44 +58,47 @@ func CreateImage(w, h, depth, channels int) *IplImage {
 }
 
 /* Releases (i.e. deallocates) IPL image header */
-func (img *IplImage)ReleaseHeader() {
+func (img *IplImage) ReleaseHeader() {
 	img_c := (*C.IplImage)(img)
 	C.cvReleaseImageHeader(&img_c)
 }
 
 /* Releases IPL image header and data */
-func (img *IplImage)Release() {
+func (img *IplImage) Release() {
 	img_c := (*C.IplImage)(img)
 	C.cvReleaseImage(&img_c)
 }
 
 /* Creates a copy of IPL image (widthStep may differ) */
-func (img *IplImage)Clone() *IplImage {
+func (img *IplImage) Clone() *IplImage {
 	p := C.cvCloneImage((*C.IplImage)(img))
-	return (*IplImage)(p);
+	return (*IplImage)(p)
 }
 
 /* Sets a Channel Of Interest (only a few functions support COI) -
    use cvCopy to extract the selected channel and/or put it back */
-func (img *IplImage)SetCOI(coi int) {
+func (img *IplImage) SetCOI(coi int) {
 	C.cvSetImageCOI((*C.IplImage)(img), C.int(coi))
 }
+
 /* Retrieves image Channel Of Interest */
-func (img *IplImage)GetCOI() int {
+func (img *IplImage) GetCOI() int {
 	coi := C.cvGetImageCOI((*C.IplImage)(img))
 	return int(coi)
 }
 
 /* Sets image ROI (region of interest) (COI is not changed) */
-func (img *IplImage)SetROI(rect Rect) {
+func (img *IplImage) SetROI(rect Rect) {
 	C.cvSetImageROI((*C.IplImage)(img), C.CvRect(rect))
 }
+
 /* Resets image ROI and COI */
-func (img *IplImage)ResetROI() {
+func (img *IplImage) ResetROI() {
 	C.cvResetImageROI((*C.IplImage)(img))
 }
+
 /* Retrieves image ROI */
-func (img *IplImage)GetROI() Rect {
+func (img *IplImage) GetROI() Rect {
 	r := C.cvGetImageROI((*C.IplImage)(img))
 	return Rect(r)
 }
@@ -112,6 +115,7 @@ func CreateMatHeader(rows, cols, type_ int) *Mat {
 	)
 	return (*Mat)(mat)
 }
+
 /* Allocates and initializes CvMat header and allocates data */
 func CreateMat(rows, cols, type_ int) *Mat {
 	mat := C.cvCreateMat(
@@ -121,7 +125,7 @@ func CreateMat(rows, cols, type_ int) *Mat {
 }
 
 /* Initializes CvMat header */
-func (mat *Mat)InitHeader(rows, cols, type_ int, data unsafe.Pointer, step int) {
+func (mat *Mat) InitHeader(rows, cols, type_ int, data unsafe.Pointer, step int) {
 	C.cvInitMatHeader(
 		(*C.CvMat)(mat),
 		C.int(rows),
@@ -134,7 +138,7 @@ func (mat *Mat)InitHeader(rows, cols, type_ int, data unsafe.Pointer, step int)
 
 /* Releases CvMat header and deallocates matrix data
    (reference counting is used for data) */
-func (mat *Mat)Release() {
+func (mat *Mat) Release() {
 	mat_c := (*C.CvMat)(mat)
 	C.cvReleaseMat(&mat_c)
 }
@@ -144,13 +148,14 @@ func (mat *Mat)Release() {
 func DecRefData(arr Arr) {
 	C.cvDecRefData(unsafe.Pointer(arr))
 }
+
 /* Increments CvMat data reference counter */
 func IncRefData(arr Arr) {
 	C.cvIncRefData(unsafe.Pointer(arr))
 }
 
 /* Creates an exact copy of the input matrix (except, may be, step value) */
-func (mat *Mat)Clone() *Mat {
+func (mat *Mat) Clone() *Mat {
 	mat_new := C.cvCloneMat((*C.CvMat)(mat))
 	return (*Mat)(mat_new)
 }
@@ -165,6 +170,7 @@ func GetSubRect(arr Arr, submat *Mat, rect Rect) *Mat {
 	)
 	return (*Mat)(mat_new)
 }
+
 //#define cvGetSubArr cvGetSubRect
 
 /* Selects row span of the input array: arr(start_row:delta_row:end_row,:)
@@ -230,7 +236,7 @@ func ScalarToRawData(scalar *Scalar, data unsafe.Pointer, type_, extend_to_12 in
 		C.int(extend_to_12),
 	)
 }
-func RawDataToScalar(data unsafe.Pointer, type_ int , scalar *Scalar) {
+func RawDataToScalar(data unsafe.Pointer, type_ int, scalar *Scalar) {
 	C.cvRawDataToScalar(
 		data,
 		C.int(type_),
@@ -249,7 +255,7 @@ func CreateMatNDHeader(sizes []int, type_ int) *MatND {
 	mat := C.cvCreateMatNDHeader(
 		dims, (*C.int)(&sizes_c[0]), C.int(type_),
 	)
-	return (*MatND)(mat);
+	return (*MatND)(mat)
 }
 
 /* Allocates and initializes CvMatND header and allocates data */
@@ -263,11 +269,11 @@ func CreateMatND(sizes []int, type_ int) *MatND {
 	mat := C.cvCreateMatND(
 		dims, (*C.int)(&sizes_c[0]), C.int(type_),
 	)
-	return (*MatND)(mat);
+	return (*MatND)(mat)
 }
 
 /* Initializes preallocated CvMatND header */
-func (mat *MatND)InitMatNDHeader(sizes []int, type_ int, data unsafe.Pointer) {
+func (mat *MatND) InitMatNDHeader(sizes []int, type_ int, data unsafe.Pointer) {
 	dims := C.int(len(sizes))
 	sizes_c := make([]C.int, len(sizes))
 	for i := 0; i < len(sizes); i++ {
@@ -282,13 +288,13 @@ func (mat *MatND)InitMatNDHeader(sizes []int, type_ int, data unsafe.Pointer) {
 }
 
 /* Releases CvMatND */
-func (mat *MatND)Release() {
+func (mat *MatND) Release() {
 	mat_c := (*C.CvMatND)(mat)
 	C.cvReleaseMatND(&mat_c)
 }
 
 /* Creates a copy of CvMatND (except, may be, steps) */
-func (mat *MatND)Clone() *MatND {
+func (mat *MatND) Clone() *MatND {
 	mat_c := (*C.CvMatND)(mat)
 	mat_ret := C.cvCloneMatND(mat_c)
 	return (*MatND)(mat_ret)
@@ -305,17 +311,17 @@ func CreateSparseMat(sizes []int, type_ int) *SparseMat {
 	mat := C.cvCreateSparseMat(
 		dims, (*C.int)(&sizes_c[0]), C.int(type_),
 	)
-	return (*SparseMat)(mat);
+	return (*SparseMat)(mat)
 }
 
 /* Releases CvSparseMat */
-func (mat *SparseMat)Release() {
+func (mat *SparseMat) Release() {
 	mat_c := (*C.CvSparseMat)(mat)
 	C.cvReleaseSparseMat(&mat_c)
 }
 
 /* Creates a copy of CvSparseMat (except, may be, zero items) */
-func (mat *SparseMat)Clone() *SparseMat {
+func (mat *SparseMat) Clone() *SparseMat {
 	mat_c := (*C.CvSparseMat)(mat)
 	mat_ret := C.cvCloneSparseMat(mat_c)
 	return (*SparseMat)(mat_ret)
@@ -323,14 +329,14 @@ func (mat *SparseMat)Clone() *SparseMat {
 
 /* Initializes sparse array iterator
    (returns the first node or NULL if the array is empty) */
-func (mat *SparseMat)InitSparseMatIterator(iter *SparseMatIterator) *SparseNode {
+func (mat *SparseMat) InitSparseMatIterator(iter *SparseMatIterator) *SparseNode {
 	mat_c := (*C.CvSparseMat)(mat)
 	node := C.cvInitSparseMatIterator(mat_c, (*C.CvSparseMatIterator)(iter))
 	return (*SparseNode)(node)
 }
 
 // returns next sparse array node (or NULL if there is no more nodes)
-func (iter *SparseMatIterator)Next() *SparseNode {
+func (iter *SparseMatIterator) Next() *SparseNode {
 	node := C.cvGetNextSparseNode((*C.CvSparseMatIterator)(iter))
 	return (*SparseNode)(node)
 }
@@ -352,7 +358,7 @@ func GetSizeHeight(img *IplImage) int {
 }
 func GetSize(img *IplImage) Size {
 	sz := C.cvGetSize(unsafe.Pointer(img))
-	return Size{ int(sz.width), int(sz.height) }
+	return Size{int(sz.width), int(sz.height)}
 
 }
 
@@ -360,6 +366,7 @@ func GetSize(img *IplImage) Size {
 func Copy(src, dst, mask *IplImage) {
 	C.cvCopy(unsafe.Pointer(src), unsafe.Pointer(dst), unsafe.Pointer(mask))
 }
+
 //CVAPI(void)  cvCopy( const CvArr* src, CvArr* dst,
 //                     const CvArr* mask CV_DEFAULT(NULL) );
 
@@ -367,51 +374,41 @@ func Copy(src, dst, mask *IplImage) {
 func Zero(img *IplImage) {
 	C.cvSetZero(unsafe.Pointer(img))
 }
+
 //CVAPI(void)  cvSetZero( CvArr* arr );
 //#define cvZero  cvSetZero
 
-
 /****************************************************************************************\
 *                   Arithmetic, logic and comparison operations               *
 \****************************************************************************************/
 
-
 /* dst(idx) = ~src(idx) */
 func Not(src, dst *IplImage) {
 	C.cvNot(unsafe.Pointer(src), unsafe.Pointer(dst))
 }
+
 //CVAPI(void) cvNot( const CvArr* src, CvArr* dst );
 
 /****************************************************************************************\
 *                                Math operations                              *
 \****************************************************************************************/
 
-
 /****************************************************************************************\
 *                                Matrix operations                            *
 \****************************************************************************************/
 
-
-
 /****************************************************************************************\
 *                                    Array Statistics                         *
 \****************************************************************************************/
 
-
-
 /****************************************************************************************\
 *                      Discrete Linear Transforms and Related Functions       *
 \****************************************************************************************/
 
-
-
-
 /****************************************************************************************\
 *                              Dynamic data structures                        *
 \****************************************************************************************/
 
-
-
 /****************************************************************************************\
 *                                     Drawing                                 *
 \****************************************************************************************/
@@ -433,19 +430,10 @@ func Line(image *IplImage, pt1, pt2 Point, color Scalar, thickness, line_type, s
 //                     CvScalar color, int thickness CV_DEFAULT(1),
 //                     int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
 
-
 /****************************************************************************************\
 *                                    System functions                         *
 \****************************************************************************************/
 
-
 /****************************************************************************************\
 *                                    Data Persistence                         *
 \****************************************************************************************/
-
-
-
-
-
-
-

opencv/cxcore_test.go

@@ -7,4 +7,3 @@ import (
 func TestLoadImage2(t *testing.T) {
 	// t.Errorf("aaa")
 }
-

opencv/cxtype.go

@@ -59,7 +59,6 @@ import (
 
 //-----------------------------------------------------------------------------
 
-
 // cvver.h
 
 //-----------------------------------------------------------------------------
@@ -71,7 +70,7 @@ const (
 )
 
 var (
-	//CV_VERSION = C.GoString(C.CV_VERSION_)
+//CV_VERSION = C.GoString(C.CV_VERSION_)
 )
 
 //-----------------------------------------------------------------------------
@@ -229,34 +228,34 @@ const (
 type IplImage C.IplImage
 
 // normal fields
-func (img *IplImage)Channels() int {
+func (img *IplImage) Channels() int {
 	return int(img.nChannels)
 }
-func (img *IplImage)Depth() int {
+func (img *IplImage) Depth() int {
 	return int(img.depth)
 }
-func (img *IplImage)Origin() int {
+func (img *IplImage) Origin() int {
 	return int(img.origin)
 }
-func (img *IplImage)Width() int {
+func (img *IplImage) Width() int {
 	return int(img.width)
 }
-func (img *IplImage)Height() int {
+func (img *IplImage) Height() int {
 	return int(img.height)
 }
-func (img *IplImage)WidthStep() int {
+func (img *IplImage) WidthStep() int {
 	return int(img.widthStep)
 }
-func (img *IplImage)ImageSize() int {
+func (img *IplImage) ImageSize() int {
 	return int(img.imageSize)
 }
-func (img *IplImage)ImageData() unsafe.Pointer {
+func (img *IplImage) ImageData() unsafe.Pointer {
 	return unsafe.Pointer(img.imageData)
 }
 
 type IplROI C.IplROI
 
-func (roi *IplROI)Init(coi, xOffset, yOffset, width, height int) {
+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)
@@ -264,23 +263,23 @@ func (roi *IplROI)Init(coi, xOffset, yOffset, width, height int) {
 	roi_c.width = C.int(width)
 	roi_c.height = C.int(height)
 }
-func (roi *IplROI)Coi() int {
+func (roi *IplROI) Coi() int {
 	roi_c := (*C.IplROI)(roi)
 	return int(roi_c.coi)
 }
-func (roi *IplROI)XOffset() int {
+func (roi *IplROI) XOffset() int {
 	roi_c := (*C.IplROI)(roi)
 	return int(roi_c.xOffset)
 }
-func (roi *IplROI)YOffset() int {
+func (roi *IplROI) YOffset() int {
 	roi_c := (*C.IplROI)(roi)
 	return int(roi_c.yOffset)
 }
-func (roi *IplROI)Width() int {
+func (roi *IplROI) Width() int {
 	roi_c := (*C.IplROI)(roi)
 	return int(roi_c.width)
 }
-func (roi *IplROI)Height() int {
+func (roi *IplROI) Height() int {
 	roi_c := (*C.IplROI)(roi)
 	return int(roi_c.height)
 }
@@ -319,17 +318,17 @@ const (
 
 type Mat C.CvMat
 
-func (mat *Mat)Type() int {
+func (mat *Mat) Type() int {
 	return int(C.myGetMatType((*C.CvMat)(mat)))
 }
-func (mat *Mat)Step() int {
+func (mat *Mat) Step() int {
 	return int(mat.step)
 }
 
-func (mat *Mat)Rows() int {
+func (mat *Mat) Rows() int {
 	return int(mat.rows)
 }
-func (mat *Mat)Cols() int {
+func (mat *Mat) Cols() int {
 	return int(mat.cols)
 }
 
@@ -346,14 +345,14 @@ func CV_ARE_TYPE_EQ() bool {
 	return false
 }
 
-func (m *Mat)Init(rows, cols int, type_ int, data unsafe.Pointer) {
+func (m *Mat) Init(rows, cols int, type_ int, data unsafe.Pointer) {
 	return
 }
-func (m *Mat)Get(row, col int) float64 {
+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) {
+func (m *Mat) Set(row, col int, value float64) {
 	C.cvmSet((*C.CvMat)(m), C.int(row), C.int(col), C.double(value))
 }
 
@@ -376,11 +375,11 @@ const (
 
 type MatND C.CvMatND
 
-func (m *MatND)Type() int {
+func (m *MatND) Type() int {
 	rv := C.myGetMatNDType((*C.CvMatND)(m))
 	return int(rv)
 }
-func (m *MatND)Dims() int {
+func (m *MatND) Dims() int {
 	rv := m.dims
 	return int(rv)
 }
@@ -396,11 +395,11 @@ const (
 
 type SparseMat C.CvSparseMat
 
-func (m *SparseMat)Type() int {
+func (m *SparseMat) Type() int {
 	rv := C.myGetSparseMatType((*C.CvSparseMat)(m))
 	return int(rv)
 }
-func (m *SparseMat)Dims() int {
+func (m *SparseMat) Dims() int {
 	rv := m.dims
 	return int(rv)
 }
@@ -409,26 +408,26 @@ func (m *SparseMat)Dims() int {
 
 type SparseNode C.CvSparseNode
 
-func (node *SparseNode)HashVal() uint32 {
+func (node *SparseNode) HashVal() uint32 {
 	rv := node.hashval
 	return uint32(rv)
 }
-func (node *SparseNode)Next() *SparseNode {
+func (node *SparseNode) Next() *SparseNode {
 	rv := node.next
 	return (*SparseNode)(rv)
 }
 
 type SparseMatIterator C.CvSparseMatIterator
 
-func (node *SparseMatIterator)Mat() *SparseMat {
+func (node *SparseMatIterator) Mat() *SparseMat {
 	rv := node.mat
 	return (*SparseMat)(rv)
 }
-func (node *SparseMatIterator)Node() *SparseNode {
+func (node *SparseMatIterator) Node() *SparseNode {
 	rv := node.node
 	return (*SparseNode)(rv)
 }
-func (node *SparseMatIterator)CurIdx() int {
+func (node *SparseMatIterator) CurIdx() int {
 	rv := node.curidx
 	return (int)(rv)
 }
@@ -478,35 +477,35 @@ func CV_HIST_HAS_RANGES() bool {
 
 type Rect C.CvRect
 
-func (r *Rect)Init(x, y, w, h int) {
+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 {
+func (r *Rect) X() int {
 	r_c := (*C.CvRect)(r)
 	return int(r_c.x)
 }
-func (r *Rect)Y() int {
+func (r *Rect) Y() int {
 	r_c := (*C.CvRect)(r)
 	return int(r_c.y)
 }
-func (r *Rect)Width() int {
+func (r *Rect) Width() int {
 	r_c := (*C.CvRect)(r)
 	return int(r_c.width)
 }
-func (r *Rect)Height() int {
+func (r *Rect) Height() int {
 	r_c := (*C.CvRect)(r)
 	return int(r_c.height)
 }
 
-func (r *Rect)ToROI(coi int) IplROI {
+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 {
+func (roi *IplROI) ToRect() Rect {
 	r := C.cvRect(
 		C.int(roi.XOffset()),
 		C.int(roi.YOffset()),
@@ -526,20 +525,20 @@ const (
 
 type TermCriteria C.CvTermCriteria
 
-func (x *TermCriteria)Init(type_, max_iter int, epsilon float64) {
+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 {
+func (x *TermCriteria) Type() int {
 	rv := C.myGetTermCriteriaType((*C.CvTermCriteria)(x))
 	return int(rv)
 }
-func (x *TermCriteria)MaxIter() int {
+func (x *TermCriteria) MaxIter() int {
 	rv := x.max_iter
 	return int(rv)
 }
-func (x *TermCriteria)Epsilon() float64 {
+func (x *TermCriteria) Epsilon() float64 {
 	rv := x.epsilon
 	return float64(rv)
 }
@@ -561,7 +560,6 @@ type Point3D32f struct {
 	Z float32
 }
 
-
 type Point2D64f struct {
 	X float64
 	Y float64
@@ -677,4 +675,3 @@ type AttrList C.CvAttrList
 /*****************************************************************************\
 *                                 --- END ---                                 *
 \*****************************************************************************/
-

opencv/doc.go

@@ -4,4 +4,3 @@
 
 // Bindings for Intel's OpenCV computer vision library.
 package opencv
-

opencv/highgui.go

@@ -10,9 +10,9 @@ package opencv
 //#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++
 import "C"
 import (
+	_ "fmt"
 	"runtime"
 	"unsafe"
-	_ "fmt"
 )
 
 func init() {
@@ -44,7 +44,6 @@ func WaitKey(delay int) int {
 	return int(key)
 }
 
-
 //-----------------------------------------------------------------------------
 // Window wrapper for go
 //-----------------------------------------------------------------------------
@@ -97,15 +96,15 @@ func NewWindow(name string, flags ...int) *Window {
 	}
 
 	win := &Window{
-		name:name,
+		name:   name,
-		name_c:C.CString(name),
+		name_c: C.CString(name),
-		flags:win_flags,
+		flags:  win_flags,
 
-		trackbarHandle:make(map[string]TrackbarFunc, 50),
+		trackbarHandle: make(map[string]TrackbarFunc, 50),
-		trackbarMax:make(map[string]int, 50),
+		trackbarMax:    make(map[string]int, 50),
-		trackbarVal:make(map[string]int, 50),
+		trackbarVal:    make(map[string]int, 50),
-		trackbarName:make(map[string](*C.char), 50),
+		trackbarName:   make(map[string](*C.char), 50),
-		trackbarParam:make(map[string]([]interface{}), 50),
+		trackbarParam:  make(map[string]([]interface{}), 50),
 	}
 	C.cvNamedWindow(win.name_c, win.flags)
 	C.GoOpenCV_SetMouseCallback(win.name_c)
@@ -121,47 +120,47 @@ const (
 	CV_WINDOW_NORMAL       = int(C.CV_WINDOW_NORMAL)
 	CV_WINDOW_FULLSCREEN   = int(C.CV_WINDOW_FULLSCREEN)
 )
+
 /* Set and Get Property of the window */
-func (win *Window)SetProperty(prop_id int, value float64)  {
+func (win *Window) SetProperty(prop_id int, value float64) {
 	C.cvSetWindowProperty(win.name_c, C.int(prop_id), C.double(value))
 }
-func (win *Window)GetProperty(prop_id int) float64 {
+func (win *Window) GetProperty(prop_id int) float64 {
 	rv := C.cvGetWindowProperty(win.name_c, C.int(prop_id))
 	return float64(rv)
 }
 
 /* display image within window (highgui windows remember their content) */
-func (win *Window)ShowImage(image *IplImage)  {
+func (win *Window) ShowImage(image *IplImage) {
 	win.image = image
 	C.cvShowImage(win.name_c, unsafe.Pointer(image))
 }
 
 /* resize/move window */
-func (win *Window)Resize(width, height int)  {
+func (win *Window) Resize(width, height int) {
 	C.cvResizeWindow(win.name_c, C.int(width), C.int(height))
 }
-func (win *Window)Move(x, y int)  {
+func (win *Window) Move(x, y int) {
 	C.cvMoveWindow(win.name_c, C.int(x), C.int(y))
 }
 
 /* get native window handle (HWND in case of Win32 and Widget in case of X Window) */
-func (win *Window)GetHandle() unsafe.Pointer {
+func (win *Window) GetHandle() unsafe.Pointer {
 	p := C.cvGetWindowHandle(win.name_c)
 	return unsafe.Pointer(p)
 }
 
 /* get name of highgui window given its native handle */
-func (win *Window)GetWindowName() string {
+func (win *Window) GetWindowName() string {
 	return win.name
 }
 
-
 //-----------------------------------------------------------------------------
 // window: track bar
 //-----------------------------------------------------------------------------
 
 /* create trackbar and display it on top of given window, set callback */
-func (win *Window)CreateTrackbar(name string,
+func (win *Window) CreateTrackbar(name string,
 	value, count int,
 	on_changed TrackbarFunc, param ...interface{}) bool {
 
@@ -196,7 +195,7 @@ func (win *Window)CreateTrackbar(name string,
 	return bool(rv != 0)
 }
 func destroyTrackbar(barName_, winName_ *C.char) {
-	C.GoOpenCV_DestroyTrackbar(barName_, winName_);
+	C.GoOpenCV_DestroyTrackbar(barName_, winName_)
 }
 
 //export goTrackbarCallback
@@ -208,11 +207,17 @@ func goTrackbarCallback(barName_, winName_ *C.char, pos C.int) {
 	barName := C.GoString(barName_)
 
 	win, ok := allWindows[winName]
-	if !ok { return }
+	if !ok {
+		return
+	}
 
 	trackbarHandle, ok := win.trackbarHandle[barName]
-	if !ok { return }
+	if !ok {
-	if trackbarHandle == nil { return }
+		return
+	}
+	if trackbarHandle == nil {
+		return
+	}
 
 	if fa, ok := trackbarHandle.(func(pos int)); ok {
 		fa(int(pos))
@@ -227,41 +232,40 @@ func goTrackbarCallback(barName_, winName_ *C.char, pos C.int) {
 }
 
 /* retrieve or set trackbar position */
-func (win *Window)GetTrackbarPos(name string) (value, max int) {
+func (win *Window) GetTrackbarPos(name string) (value, max int) {
 	rv := C.cvGetTrackbarPos(win.trackbarName[name], win.name_c)
 	return int(rv), win.trackbarMax[name]
 }
-func (win *Window)SetTrackbarPos(name string, pos int) {
+func (win *Window) SetTrackbarPos(name string, pos int) {
 	C.cvSetTrackbarPos(win.trackbarName[name], win.name_c, C.int(pos))
 }
 
-
 //-----------------------------------------------------------------------------
 // window: mouse callback
 //-----------------------------------------------------------------------------
 
 const (
-	CV_EVENT_MOUSEMOVE     = int(C.CV_EVENT_MOUSEMOVE    )
+	CV_EVENT_MOUSEMOVE     = int(C.CV_EVENT_MOUSEMOVE)
-	CV_EVENT_LBUTTONDOWN   = int(C.CV_EVENT_LBUTTONDOWN  )
+	CV_EVENT_LBUTTONDOWN   = int(C.CV_EVENT_LBUTTONDOWN)
-	CV_EVENT_RBUTTONDOWN   = int(C.CV_EVENT_RBUTTONDOWN  )
+	CV_EVENT_RBUTTONDOWN   = int(C.CV_EVENT_RBUTTONDOWN)
-	CV_EVENT_MBUTTONDOWN   = int(C.CV_EVENT_MBUTTONDOWN  )
+	CV_EVENT_MBUTTONDOWN   = int(C.CV_EVENT_MBUTTONDOWN)
-	CV_EVENT_LBUTTONUP     = int(C.CV_EVENT_LBUTTONUP    )
+	CV_EVENT_LBUTTONUP     = int(C.CV_EVENT_LBUTTONUP)
-	CV_EVENT_RBUTTONUP     = int(C.CV_EVENT_RBUTTONUP    )
+	CV_EVENT_RBUTTONUP     = int(C.CV_EVENT_RBUTTONUP)
-	CV_EVENT_MBUTTONUP     = int(C.CV_EVENT_MBUTTONUP    )
+	CV_EVENT_MBUTTONUP     = int(C.CV_EVENT_MBUTTONUP)
 	CV_EVENT_LBUTTONDBLCLK = int(C.CV_EVENT_LBUTTONDBLCLK)
 	CV_EVENT_RBUTTONDBLCLK = int(C.CV_EVENT_RBUTTONDBLCLK)
 	CV_EVENT_MBUTTONDBLCLK = int(C.CV_EVENT_MBUTTONDBLCLK)
 
-	CV_EVENT_FLAG_LBUTTON  = int(C.CV_EVENT_FLAG_LBUTTON )
+	CV_EVENT_FLAG_LBUTTON  = int(C.CV_EVENT_FLAG_LBUTTON)
-	CV_EVENT_FLAG_RBUTTON  = int(C.CV_EVENT_FLAG_RBUTTON )
+	CV_EVENT_FLAG_RBUTTON  = int(C.CV_EVENT_FLAG_RBUTTON)
-	CV_EVENT_FLAG_MBUTTON  = int(C.CV_EVENT_FLAG_MBUTTON )
+	CV_EVENT_FLAG_MBUTTON  = int(C.CV_EVENT_FLAG_MBUTTON)
-	CV_EVENT_FLAG_CTRLKEY  = int(C.CV_EVENT_FLAG_CTRLKEY )
+	CV_EVENT_FLAG_CTRLKEY  = int(C.CV_EVENT_FLAG_CTRLKEY)
 	CV_EVENT_FLAG_SHIFTKEY = int(C.CV_EVENT_FLAG_SHIFTKEY)
-	CV_EVENT_FLAG_ALTKEY   = int(C.CV_EVENT_FLAG_ALTKEY  )
+	CV_EVENT_FLAG_ALTKEY   = int(C.CV_EVENT_FLAG_ALTKEY)
 )
 
 /* assign callback for mouse events */
-func (win *Window)SetMouseCallback(on_mouse MouseFunc, param ...interface{})  {
+func (win *Window) SetMouseCallback(on_mouse MouseFunc, param ...interface{}) {
 
 	switch f := on_mouse.(type) {
 	case MouseFuncA:
@@ -282,6 +286,7 @@ func (win *Window)SetMouseCallback(on_mouse MouseFunc, param ...interface{})  {
 		win.param = nil
 	}
 }
+
 //export goMouseCallback
 func goMouseCallback(name *C.char, event, x, y, flags C.int) {
 	runtime.LockOSThread()
@@ -290,8 +295,12 @@ func goMouseCallback(name *C.char, event, x, y, flags C.int) {
 	winName := C.GoString(name)
 	win, ok := allWindows[winName]
 
-	if !ok { return }
+	if !ok {
-	if win.mouseHandle == nil { return }
+		return
+	}
+	if win.mouseHandle == nil {
+		return
+	}
 
 	if fa, ok := win.mouseHandle.(func(event, x, y, flags int)); ok {
 		fa(int(event), int(x), int(y), int(flags))
@@ -308,13 +317,12 @@ func goMouseCallback(name *C.char, event, x, y, flags C.int) {
 	}
 }
 
-
 //-----------------------------------------------------------------------------
 // window: destroy
 //-----------------------------------------------------------------------------
 
 /* destroy window and all the trackers associated with it */
-func (win *Window)Destroy()  {
+func (win *Window) Destroy() {
 	C.cvDestroyWindow(win.name_c)
 	delete(allWindows, win.name)
 
@@ -349,11 +357,12 @@ const (
 	/* ?, any color */
 	CV_LOAD_IMAGE_ANYCOLOR = int(C.CV_LOAD_IMAGE_ANYCOLOR)
 )
+
 /* load image from file
-  iscolor can be a combination of above flags where CV_LOAD_IMAGE_UNCHANGED
+iscolor can be a combination of above flags where CV_LOAD_IMAGE_UNCHANGED
-  overrides the other flags
+overrides the other flags
-  using CV_LOAD_IMAGE_ANYCOLOR alone is equivalent to CV_LOAD_IMAGE_UNCHANGED
+using CV_LOAD_IMAGE_ANYCOLOR alone is equivalent to CV_LOAD_IMAGE_UNCHANGED
-  unless CV_LOAD_IMAGE_ANYDEPTH is specified images are converted to 8bit
+unless CV_LOAD_IMAGE_ANYDEPTH is specified images are converted to 8bit
 */
 func LoadImage(filename string, iscolor_ ...int) *IplImage {
 	iscolor := CV_LOAD_IMAGE_COLOR
@@ -472,64 +481,64 @@ func NewCameraCapture(index int) *Capture {
 }
 
 /* grab a frame, return 1 on success, 0 on fail.
-  this function is thought to be fast               */
+this function is thought to be fast               */
-func (capture *Capture)GrabFrame() bool {
+func (capture *Capture) GrabFrame() bool {
 	rv := C.cvGrabFrame((*C.CvCapture)(capture))
 	return (rv != C.int(0))
 }
 
 /* get the frame grabbed with cvGrabFrame(..)
-  This function may apply some frame processing like
+This function may apply some frame processing like
-  frame decompression, flipping etc.
+frame decompression, flipping etc.
-  !!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
+!!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
-func (capture *Capture)RetrieveFrame(streamIdx int) *IplImage {
+func (capture *Capture) RetrieveFrame(streamIdx int) *IplImage {
 	rv := C.cvRetrieveFrame((*C.CvCapture)(capture), C.int(streamIdx))
 	return (*IplImage)(rv)
 }
 
 /* Just a combination of cvGrabFrame and cvRetrieveFrame
    !!!DO NOT RELEASE or MODIFY the retrieved frame!!!      */
-func (capture *Capture)QueryFrame() *IplImage {
+func (capture *Capture) QueryFrame() *IplImage {
 	rv := C.cvQueryFrame((*C.CvCapture)(capture))
 	return (*IplImage)(rv)
 }
 
 /* stop capturing/reading and free resources */
-func (capture *Capture)Release() {
+func (capture *Capture) Release() {
 	cap_c := (*C.CvCapture)(capture)
 	C.cvReleaseCapture(&cap_c)
 }
 
 const (
-	CV_CAP_PROP_POS_MSEC      = int(C.CV_CAP_PROP_POS_MSEC     )
+	CV_CAP_PROP_POS_MSEC      = int(C.CV_CAP_PROP_POS_MSEC)
-	CV_CAP_PROP_POS_FRAMES    = int(C.CV_CAP_PROP_POS_FRAMES   )
+	CV_CAP_PROP_POS_FRAMES    = int(C.CV_CAP_PROP_POS_FRAMES)
 	CV_CAP_PROP_POS_AVI_RATIO = int(C.CV_CAP_PROP_POS_AVI_RATIO)
-	CV_CAP_PROP_FRAME_WIDTH   = int(C.CV_CAP_PROP_FRAME_WIDTH  )
+	CV_CAP_PROP_FRAME_WIDTH   = int(C.CV_CAP_PROP_FRAME_WIDTH)
-	CV_CAP_PROP_FRAME_HEIGHT  = int(C.CV_CAP_PROP_FRAME_HEIGHT )
+	CV_CAP_PROP_FRAME_HEIGHT  = int(C.CV_CAP_PROP_FRAME_HEIGHT)
-	CV_CAP_PROP_FPS           = int(C.CV_CAP_PROP_FPS          )
+	CV_CAP_PROP_FPS           = int(C.CV_CAP_PROP_FPS)
-	CV_CAP_PROP_FOURCC        = int(C.CV_CAP_PROP_FOURCC       )
+	CV_CAP_PROP_FOURCC        = int(C.CV_CAP_PROP_FOURCC)
-	CV_CAP_PROP_FRAME_COUNT   = int(C.CV_CAP_PROP_FRAME_COUNT  )
+	CV_CAP_PROP_FRAME_COUNT   = int(C.CV_CAP_PROP_FRAME_COUNT)
-	CV_CAP_PROP_FORMAT        = int(C.CV_CAP_PROP_FORMAT       )
+	CV_CAP_PROP_FORMAT        = int(C.CV_CAP_PROP_FORMAT)
-	CV_CAP_PROP_MODE          = int(C.CV_CAP_PROP_MODE         )
+	CV_CAP_PROP_MODE          = int(C.CV_CAP_PROP_MODE)
-	CV_CAP_PROP_BRIGHTNESS    = int(C.CV_CAP_PROP_BRIGHTNESS   )
+	CV_CAP_PROP_BRIGHTNESS    = int(C.CV_CAP_PROP_BRIGHTNESS)
-	CV_CAP_PROP_CONTRAST      = int(C.CV_CAP_PROP_CONTRAST     )
+	CV_CAP_PROP_CONTRAST      = int(C.CV_CAP_PROP_CONTRAST)
-	CV_CAP_PROP_SATURATION    = int(C.CV_CAP_PROP_SATURATION   )
+	CV_CAP_PROP_SATURATION    = int(C.CV_CAP_PROP_SATURATION)
-	CV_CAP_PROP_HUE           = int(C.CV_CAP_PROP_HUE          )
+	CV_CAP_PROP_HUE           = int(C.CV_CAP_PROP_HUE)
-	CV_CAP_PROP_GAIN          = int(C.CV_CAP_PROP_GAIN         )
+	CV_CAP_PROP_GAIN          = int(C.CV_CAP_PROP_GAIN)
-	CV_CAP_PROP_EXPOSURE      = int(C.CV_CAP_PROP_EXPOSURE     )
+	CV_CAP_PROP_EXPOSURE      = int(C.CV_CAP_PROP_EXPOSURE)
-	CV_CAP_PROP_CONVERT_RGB   = int(C.CV_CAP_PROP_CONVERT_RGB  )
+	CV_CAP_PROP_CONVERT_RGB   = int(C.CV_CAP_PROP_CONVERT_RGB)
 	// CV_CAP_PROP_WHITE_BALANCE = int(C.CV_CAP_PROP_WHITE_BALANCE)
 	CV_CAP_PROP_RECTIFICATION = int(C.CV_CAP_PROP_RECTIFICATION)
 )
 
 /* retrieve or set capture properties */
-func (capture *Capture)GetProperty(property_id int) float64 {
+func (capture *Capture) GetProperty(property_id int) float64 {
 	rv := C.cvGetCaptureProperty((*C.CvCapture)(capture),
 		C.int(property_id),
 	)
 	return float64(rv)
 }
-func (capture *Capture)SetProperty(property_id int, value float64) int {
+func (capture *Capture) SetProperty(property_id int, value float64) int {
 	rv := C.cvSetCaptureProperty((*C.CvCapture)(capture),
 		C.int(property_id), C.double(value),
 	)
@@ -538,7 +547,7 @@ func (capture *Capture)SetProperty(property_id int, value float64) int {
 
 // Return the type of the capturer (eg, CV_CAP_V4W, CV_CAP_UNICAP),
 // which is unknown if created with CV_CAP_ANY
-func (capture *Capture)GetDomain() int {
+func (capture *Capture) GetDomain() int {
 	rv := C.cvGetCaptureDomain((*C.CvCapture)(capture))
 	return int(rv)
 }
@@ -552,9 +561,10 @@ type VideoWriter C.CvVideoWriter
 
 // Prototype for CV_FOURCC so that swig can generate wrapper without mixing up the define
 func FOURCC(c1, c2, c3, c4 int8) uint32 {
-	rv := C.GoOpenCV_FOURCC_(C.int(c1),C.int(c2),C.int(c3),C.int(c4))
+	rv := C.GoOpenCV_FOURCC_(C.int(c1), C.int(c2), C.int(c3), C.int(c4))
 	return uint32(rv)
 }
+
 const (
 	/* Open Codec Selection Dialog (Windows only) */
 	CV_FOURCC_PROMPT = int(C.CV_FOURCC_PROMPT)
@@ -585,7 +595,7 @@ func (writer *VideoWriter) WriteFrame(image *IplImage) int {
 }
 
 /* close video file writer */
-func (writer *VideoWriter)Release() {
+func (writer *VideoWriter) Release() {
 	writer_c := (*C.CvVideoWriter)(writer)
 	C.cvReleaseVideoWriter(&writer_c)
 }
@@ -593,5 +603,3 @@ func (writer *VideoWriter)Release() {
 /*****************************************************************************\
 *                                 --- END ---                                 *
 \*****************************************************************************/
-
-

opencv/opencv.go

@@ -4,11 +4,10 @@
 
 package opencv
 
-import(
+import (
 //	"image"
 )
 
 //-----------------------------------------------------------------------------
 // End
 //-----------------------------------------------------------------------------
-

samples/edge.go

@@ -10,8 +10,8 @@ import (
 	"path"
 	"runtime"
 
-	//"github.com/lazywei/go-opencv/opencv"
+	"github.com/hybridgroup/go-opencv/opencv"
-	"../opencv" // can be used in forks, comment in real application
+	//"../opencv" // can be used in forks, comment in real application
 )
 
 func main() {

samples/hellocv.go

@@ -10,8 +10,8 @@ import (
 	"path"
 	"runtime"
 
-	//"github.com/lazywei/go-opencv/opencv"
+	"github.com/hybridgroup/go-opencv/opencv"
-	"../opencv" // can be used in forks, comment in real application
+	//"../opencv" // can be used in forks, comment in real application
 )
 
 func main() {

samples/inpaint.go

@@ -10,8 +10,8 @@ import (
 	"path"
 	"runtime"
 
-	//"github.com/lazywei/go-opencv/opencv"
+	"github.com/hybridgroup/go-opencv/opencv"
-	"../opencv" // can be used in forks, comment in real application
+	//"../opencv" // can be used in forks, comment in real application
 )
 
 func main() {

samples/player.go

@@ -8,8 +8,8 @@ import (
 	"fmt"
 	"os"
 
-	//"github.com/lazywei/go-opencv/opencv"
+	"github.com/hybridgroup/go-opencv/opencv"
-	"../opencv" // can be used in forks, comment in real application
+	//"../opencv" // can be used in forks, comment in real application
 )
 
 func main() {

samples/webcam.go

@@ -6,8 +6,8 @@ import (
 	//"path"
 	//"runtime"
 
-	//"github.com/lazywei/go-opencv/opencv"
+	"github.com/hybridgroup/go-opencv/opencv"
-	"../opencv" // can be used in forks, comment in real application
+	//"../opencv" // can be used in forks, comment in real application
 )
 
 func main() {