sander/go-opencv
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

go fmt

Browse source
This commit is contained in:
Adrian Zankich 2014-02-07 12:27:16 -08:00
parent d24c14b7e6
commit 0087f832bc
13 changed files with 940 additions and 983 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
opencv/cv.go
View file

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

165
opencv/cvaux.go
View file

@ -1,95 +1,70 @@
// Copyright 2011 <chaishushan@gmail.com>. All rights reserved. // Copyright 2011 <chaishushan@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
package opencv package opencv
//#include "opencv.h" //#include "opencv.h"
//#cgo linux pkg-config: opencv //#cgo linux pkg-config: opencv
//#cgo darwin pkg-config: opencv //#cgo darwin pkg-config: opencv
//#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++ //#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++
import "C" import "C"
/****************************************************************************************\
/****************************************************************************************\ * Eigen objects *
* Eigen objects * \****************************************************************************************/
\****************************************************************************************/
/****************************************************************************************\
* 1D/2D HMM *
\****************************************************************************************/
/****************************************************************************************\
* 1D/2D HMM * /*********************************** Embedded HMMs *************************************/
\****************************************************************************************/
/****************************************************************************************\
* A few functions from old stereo gesture recognition demosions *
/*********************************** Embedded HMMs *************************************/ \****************************************************************************************/
/****************************************************************************************\
/****************************************************************************************\ * Additional operations on Subdivisions *
* A few functions from old stereo gesture recognition demosions * \****************************************************************************************/
\****************************************************************************************/
/****************************************************************************************\
* More operations on sequences *
/****************************************************************************************\ \****************************************************************************************/
* Additional operations on Subdivisions *
\****************************************************************************************/ /*******************************Stereo correspondence*************************************/
/*****************************************************************************************/
/************ Epiline functions *******************/
/****************************************************************************************\
* More operations on sequences * /****************************************************************************************\
\****************************************************************************************/ * Contour Morphing *
\****************************************************************************************/
/*******************************Stereo correspondence*************************************/ /****************************************************************************************\
* Texture Descriptors *
\****************************************************************************************/
/*****************************************************************************************/
/************ Epiline functions *******************/ /****************************************************************************************\
* Face eyes&mouth tracking *
\****************************************************************************************/
/****************************************************************************************\
* Contour Morphing * /****************************************************************************************\
\****************************************************************************************/ * 3D Tracker *
\****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* Texture Descriptors * * Skeletons and Linear-Contour Models *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\
* Background/foreground segmentation *
/****************************************************************************************\ \****************************************************************************************/
* Face eyes&mouth tracking *
\****************************************************************************************/ /****************************************************************************************\
* Calibration engine *
\****************************************************************************************/
/****************************************************************************************\ /*****************************************************************************\
* 3D Tracker * * --- END --- *
\****************************************************************************************/ \*****************************************************************************/
/****************************************************************************************\
* Skeletons and Linear-Contour Models *
\****************************************************************************************/
/****************************************************************************************\
* Background/foreground segmentation *
\****************************************************************************************/
/****************************************************************************************\
* Calibration engine *
\****************************************************************************************/
/*****************************************************************************\
* --- END --- *
\*****************************************************************************/

88
opencv/cxcore.go
View file

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

1
opencv/cxcore_test.go
View file

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

1357
opencv/cxtype.go
View file

File diff suppressed because it is too large Load diff

1
opencv/doc.go
View file

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

246
opencv/highgui.go
View file

@ -10,9 +10,9 @@ package opencv
//#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++ //#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++
import "C" import "C"
import ( import (
_ "fmt"
"runtime" "runtime"
"unsafe" "unsafe"
_ "fmt"
) )
func init() { func init() {
@ -44,29 +44,28 @@ func WaitKey(delay int) int {
return int(key) return int(key)
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Window wrapper for go // Window wrapper for go
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// mouse callback // mouse callback
type MouseFunc interface{} type MouseFunc interface{}
type MouseFuncA func(event, x, y, flags int) type MouseFuncA func(event, x, y, flags int)
type MouseFuncB func(event, x, y, flags int, param ...interface{}) type MouseFuncB func(event, x, y, flags int, param ...interface{})
// trackbar callback // trackbar callback
type TrackbarFunc interface{} type TrackbarFunc interface{}
type TrackbarFuncA func(pos int) type TrackbarFuncA func(pos int)
type TrackbarFuncB func(pos int, param ...interface{}) type TrackbarFuncB func(pos int, param ...interface{})
// named window // named window
type Window struct { type Window struct {
name string name string
name_c *C.char name_c *C.char
flags C.int flags C.int
mouseHandle MouseFunc mouseHandle MouseFunc
param []interface{} param []interface{}
trackbarHandle map[string]TrackbarFunc trackbarHandle map[string]TrackbarFunc
trackbarMax map[string]int trackbarMax map[string]int
@ -74,8 +73,8 @@ type Window struct {
trackbarName map[string](*C.char) trackbarName map[string](*C.char)
trackbarParam map[string]([]interface{}) trackbarParam map[string]([]interface{})
image *IplImage image *IplImage
refCount int refCount int
} }
// window list // window list
@ -97,15 +96,15 @@ func NewWindow(name string, flags ...int) *Window {
} }
win := &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.cvNamedWindow(win.name_c, win.flags)
C.GoOpenCV_SetMouseCallback(win.name_c) C.GoOpenCV_SetMouseCallback(win.name_c)
@ -121,49 +120,49 @@ const (
CV_WINDOW_NORMAL = int(C.CV_WINDOW_NORMAL) CV_WINDOW_NORMAL = int(C.CV_WINDOW_NORMAL)
CV_WINDOW_FULLSCREEN = int(C.CV_WINDOW_FULLSCREEN) CV_WINDOW_FULLSCREEN = int(C.CV_WINDOW_FULLSCREEN)
) )
/* Set and Get Property of the window */ /* 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)) 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)) rv := C.cvGetWindowProperty(win.name_c, C.int(prop_id))
return float64(rv) return float64(rv)
} }
/* display image within window (highgui windows remember their content) */ /* display image within window (highgui windows remember their content) */
func (win *Window)ShowImage(image *IplImage) { func (win *Window) ShowImage(image *IplImage) {
win.image = image win.image = image
C.cvShowImage(win.name_c, unsafe.Pointer(image)) C.cvShowImage(win.name_c, unsafe.Pointer(image))
} }
/* resize/move window */ /* 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)) 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)) 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) */ /* 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) p := C.cvGetWindowHandle(win.name_c)
return unsafe.Pointer(p) return unsafe.Pointer(p)
} }
/* get name of highgui window given its native handle */ /* get name of highgui window given its native handle */
func (win *Window)GetWindowName() string { func (win *Window) GetWindowName() string {
return win.name return win.name
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// window: track bar // window: track bar
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/* create trackbar and display it on top of given window, set callback */ /* 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, value, count int,
on_changed TrackbarFunc, param ...interface{}) bool { on_changed TrackbarFunc, param ...interface{}) bool {
bar_name := C.CString(name) bar_name := C.CString(name)
@ -196,7 +195,7 @@ func (win *Window)CreateTrackbar(name string,
return bool(rv != 0) return bool(rv != 0)
} }
func destroyTrackbar(barName_, winName_ *C.char) { func destroyTrackbar(barName_, winName_ *C.char) {
C.GoOpenCV_DestroyTrackbar(barName_, winName_); C.GoOpenCV_DestroyTrackbar(barName_, winName_)
} }
//export goTrackbarCallback //export goTrackbarCallback
@ -208,12 +207,18 @@ func goTrackbarCallback(barName_, winName_ *C.char, pos C.int) {
barName := C.GoString(barName_) barName := C.GoString(barName_)
win, ok := allWindows[winName] win, ok := allWindows[winName]
if !ok { return } if !ok {
return
}
trackbarHandle, ok := win.trackbarHandle[barName] 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 { if fa, ok := trackbarHandle.(func(pos int)); ok {
fa(int(pos)) fa(int(pos))
} else if fb, ok := trackbarHandle.(func(pos int, param ...interface{})); ok { } else if fb, ok := trackbarHandle.(func(pos int, param ...interface{})); ok {
@ -227,41 +232,40 @@ func goTrackbarCallback(barName_, winName_ *C.char, pos C.int) {
} }
/* retrieve or set trackbar position */ /* 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) rv := C.cvGetTrackbarPos(win.trackbarName[name], win.name_c)
return int(rv), win.trackbarMax[name] 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)) C.cvSetTrackbarPos(win.trackbarName[name], win.name_c, C.int(pos))
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// window: mouse callback // window: mouse callback
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
const ( 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_LBUTTONDBLCLK = int(C.CV_EVENT_LBUTTONDBLCLK)
CV_EVENT_RBUTTONDBLCLK = int(C.CV_EVENT_RBUTTONDBLCLK) CV_EVENT_RBUTTONDBLCLK = int(C.CV_EVENT_RBUTTONDBLCLK)
CV_EVENT_MBUTTONDBLCLK = int(C.CV_EVENT_MBUTTONDBLCLK) 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_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 */ /* 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) { switch f := on_mouse.(type) {
case MouseFuncA: case MouseFuncA:
@ -282,6 +286,7 @@ func (win *Window)SetMouseCallback(on_mouse MouseFunc, param ...interface{}) {
win.param = nil win.param = nil
} }
} }
//export goMouseCallback //export goMouseCallback
func goMouseCallback(name *C.char, event, x, y, flags C.int) { func goMouseCallback(name *C.char, event, x, y, flags C.int) {
runtime.LockOSThread() runtime.LockOSThread()
@ -290,9 +295,13 @@ func goMouseCallback(name *C.char, event, x, y, flags C.int) {
winName := C.GoString(name) winName := C.GoString(name)
win, ok := allWindows[winName] 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 { if fa, ok := win.mouseHandle.(func(event, x, y, flags int)); ok {
fa(int(event), int(x), int(y), int(flags)) fa(int(event), int(x), int(y), int(flags))
return return
@ -308,13 +317,12 @@ func goMouseCallback(name *C.char, event, x, y, flags C.int) {
} }
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// window: destroy // window: destroy
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/* destroy window and all the trackers associated with it */ /* destroy window and all the trackers associated with it */
func (win *Window)Destroy() { func (win *Window) Destroy() {
C.cvDestroyWindow(win.name_c) C.cvDestroyWindow(win.name_c)
delete(allWindows, win.name) delete(allWindows, win.name)
@ -343,17 +351,18 @@ const (
/* 8bit, gray */ /* 8bit, gray */
CV_LOAD_IMAGE_GRAYSCALE = int(C.CV_LOAD_IMAGE_GRAYSCALE) CV_LOAD_IMAGE_GRAYSCALE = int(C.CV_LOAD_IMAGE_GRAYSCALE)
/* ?, color */ /* ?, color */
CV_LOAD_IMAGE_COLOR = int(C.CV_LOAD_IMAGE_COLOR) CV_LOAD_IMAGE_COLOR = int(C.CV_LOAD_IMAGE_COLOR)
/* any depth, ? */ /* any depth, ? */
CV_LOAD_IMAGE_ANYDEPTH = int(C.CV_LOAD_IMAGE_ANYDEPTH) CV_LOAD_IMAGE_ANYDEPTH = int(C.CV_LOAD_IMAGE_ANYDEPTH)
/* ?, any color */ /* ?, any color */
CV_LOAD_IMAGE_ANYCOLOR = int(C.CV_LOAD_IMAGE_ANYCOLOR) CV_LOAD_IMAGE_ANYCOLOR = int(C.CV_LOAD_IMAGE_ANYCOLOR)
) )
/* load image from file /* 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 { func LoadImage(filename string, iscolor_ ...int) *IplImage {
iscolor := CV_LOAD_IMAGE_COLOR iscolor := CV_LOAD_IMAGE_COLOR
@ -435,34 +444,34 @@ func NewFileCapture(filename string) *Capture {
} }
const ( const (
CV_CAP_ANY = int(C.CV_CAP_ANY) // autodetect CV_CAP_ANY = int(C.CV_CAP_ANY) // autodetect
CV_CAP_MIL = int(C.CV_CAP_MIL) // MIL proprietary drivers CV_CAP_MIL = int(C.CV_CAP_MIL) // MIL proprietary drivers
CV_CAP_VFW = int(C.CV_CAP_VFW) // platform native CV_CAP_VFW = int(C.CV_CAP_VFW) // platform native
CV_CAP_V4L = int(C.CV_CAP_V4L) CV_CAP_V4L = int(C.CV_CAP_V4L)
CV_CAP_V4L2 = int(C.CV_CAP_V4L2) CV_CAP_V4L2 = int(C.CV_CAP_V4L2)
CV_CAP_FIREWARE = int(C.CV_CAP_FIREWARE) // IEEE 1394 drivers CV_CAP_FIREWARE = int(C.CV_CAP_FIREWARE) // IEEE 1394 drivers
CV_CAP_FIREWIRE = int(C.CV_CAP_FIREWIRE) CV_CAP_FIREWIRE = int(C.CV_CAP_FIREWIRE)
CV_CAP_IEEE1394 = int(C.CV_CAP_IEEE1394) CV_CAP_IEEE1394 = int(C.CV_CAP_IEEE1394)
CV_CAP_DC1394 = int(C.CV_CAP_DC1394) CV_CAP_DC1394 = int(C.CV_CAP_DC1394)
CV_CAP_CMU1394 = int(C.CV_CAP_CMU1394) CV_CAP_CMU1394 = int(C.CV_CAP_CMU1394)
CV_CAP_STEREO = int(C.CV_CAP_STEREO) // TYZX proprietary drivers CV_CAP_STEREO = int(C.CV_CAP_STEREO) // TYZX proprietary drivers
CV_CAP_TYZX = int(C.CV_CAP_TYZX) CV_CAP_TYZX = int(C.CV_CAP_TYZX)
CV_TYZX_LEFT = int(C.CV_TYZX_LEFT) CV_TYZX_LEFT = int(C.CV_TYZX_LEFT)
CV_TYZX_RIGHT = int(C.CV_TYZX_RIGHT) CV_TYZX_RIGHT = int(C.CV_TYZX_RIGHT)
CV_TYZX_COLOR = int(C.CV_TYZX_COLOR) CV_TYZX_COLOR = int(C.CV_TYZX_COLOR)
CV_TYZX_Z = int(C.CV_TYZX_Z) CV_TYZX_Z = int(C.CV_TYZX_Z)
CV_CAP_QT = int(C.CV_CAP_QT) // QuickTime CV_CAP_QT = int(C.CV_CAP_QT) // QuickTime
CV_CAP_UNICAP = int(C.CV_CAP_UNICAP) // Unicap drivers CV_CAP_UNICAP = int(C.CV_CAP_UNICAP) // Unicap drivers
CV_CAP_DSHOW = int(C.CV_CAP_DSHOW) // DirectShow (via videoInput) CV_CAP_DSHOW = int(C.CV_CAP_DSHOW) // DirectShow (via videoInput)
CV_CAP_PVAPI = int(C.CV_CAP_PVAPI) // PvAPI, Prosilica GigE SDK CV_CAP_PVAPI = int(C.CV_CAP_PVAPI) // PvAPI, Prosilica GigE SDK
) )
/* start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_*) */ /* start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_*) */
@ -472,64 +481,64 @@ func NewCameraCapture(index int) *Capture {
} }
/* grab a frame, return 1 on success, 0 on fail. /* 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)) rv := C.cvGrabFrame((*C.CvCapture)(capture))
return (rv != C.int(0)) return (rv != C.int(0))
} }
/* get the frame grabbed with cvGrabFrame(..) /* 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)) rv := C.cvRetrieveFrame((*C.CvCapture)(capture), C.int(streamIdx))
return (*IplImage)(rv) return (*IplImage)(rv)
} }
/* Just a combination of cvGrabFrame and cvRetrieveFrame /* Just a combination of cvGrabFrame and cvRetrieveFrame
!!!DO NOT RELEASE or MODIFY the retrieved frame!!! */ !!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
func (capture *Capture)QueryFrame() *IplImage { func (capture *Capture) QueryFrame() *IplImage {
rv := C.cvQueryFrame((*C.CvCapture)(capture)) rv := C.cvQueryFrame((*C.CvCapture)(capture))
return (*IplImage)(rv) return (*IplImage)(rv)
} }
/* stop capturing/reading and free resources */ /* stop capturing/reading and free resources */
func (capture *Capture)Release() { func (capture *Capture) Release() {
cap_c := (*C.CvCapture)(capture) cap_c := (*C.CvCapture)(capture)
C.cvReleaseCapture(&cap_c) C.cvReleaseCapture(&cap_c)
} }
const ( 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_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_WHITE_BALANCE = int(C.CV_CAP_PROP_WHITE_BALANCE)
CV_CAP_PROP_RECTIFICATION = int(C.CV_CAP_PROP_RECTIFICATION) CV_CAP_PROP_RECTIFICATION = int(C.CV_CAP_PROP_RECTIFICATION)
) )
/* retrieve or set capture properties */ /* 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), rv := C.cvGetCaptureProperty((*C.CvCapture)(capture),
C.int(property_id), C.int(property_id),
) )
return float64(rv) 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), rv := C.cvSetCaptureProperty((*C.CvCapture)(capture),
C.int(property_id), C.double(value), 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), // Return the type of the capturer (eg, CV_CAP_V4W, CV_CAP_UNICAP),
// which is unknown if created with CV_CAP_ANY // 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)) rv := C.cvGetCaptureDomain((*C.CvCapture)(capture))
return int(rv) return int(rv)
} }
@ -552,12 +561,13 @@ type VideoWriter C.CvVideoWriter
// Prototype for CV_FOURCC so that swig can generate wrapper without mixing up the define // Prototype for CV_FOURCC so that swig can generate wrapper without mixing up the define
func FOURCC(c1, c2, c3, c4 int8) uint32 { 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) return uint32(rv)
} }
const ( const (
/* Open Codec Selection Dialog (Windows only) */ /* Open Codec Selection Dialog (Windows only) */
CV_FOURCC_PROMPT = int(C.CV_FOURCC_PROMPT) CV_FOURCC_PROMPT = int(C.CV_FOURCC_PROMPT)
/* Use default codec for specified filename (Linux only) */ /* Use default codec for specified filename (Linux only) */
// CV_FOURCC_DEFAULT = int(C.CV_FOURCC_DEFAULT) // CV_FOURCC_DEFAULT = int(C.CV_FOURCC_DEFAULT)
) )
@ -585,7 +595,7 @@ func (writer *VideoWriter) WriteFrame(image *IplImage) int {
} }
/* close video file writer */ /* close video file writer */
func (writer *VideoWriter)Release() { func (writer *VideoWriter) Release() {
writer_c := (*C.CvVideoWriter)(writer) writer_c := (*C.CvVideoWriter)(writer)
C.cvReleaseVideoWriter(&writer_c) C.cvReleaseVideoWriter(&writer_c)
} }
@ -593,5 +603,3 @@ func (writer *VideoWriter)Release() {
/*****************************************************************************\ /*****************************************************************************\
* --- END --- * * --- END --- *
\*****************************************************************************/ \*****************************************************************************/

27
opencv/opencv.go
View file

@ -1,14 +1,13 @@
// Copyright 2011 <chaishushan@gmail.com>. All rights reserved. // Copyright 2011 <chaishushan@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
package opencv package opencv
import( import (
// "image" // "image"
) )
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// End // End
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------

4
samples/edge.go
View file

@ -10,8 +10,8 @@ import (
"path" "path"
"runtime" "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() { func main() {

4
samples/hellocv.go
View file

@ -10,8 +10,8 @@ import (
"path" "path"
"runtime" "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() { func main() {

4
samples/inpaint.go
View file

@ -10,8 +10,8 @@ import (
"path" "path"
"runtime" "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() { func main() {

4
samples/player.go
View file

@ -8,8 +8,8 @@ import (
"fmt" "fmt"
"os" "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() { func main() {

4
samples/webcam.go
View file

@ -6,8 +6,8 @@ import (
//"path" //"path"
//"runtime" //"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() { func main() {