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

Merge https://github.com/hybridgroup/go-opencv into hybridgroup-master

Browse source
This commit is contained in:
Bert Chang 2014-05-02 20:19:36 +08:00
commit 82af0cc56b
16 changed files with 27182 additions and 988 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 );

44
opencv/cvaux.go
View file

@ -9,87 +9,85 @@ package 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"
import (
"unsafe"
)
/****************************************************************************************\ /****************************************************************************************\
* Eigen objects * * Eigen objects *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* 1D/2D HMM * * 1D/2D HMM *
\****************************************************************************************/ \****************************************************************************************/
/*********************************** Embedded HMMs *************************************/ /*********************************** Embedded HMMs *************************************/
/****************************************************************************************\ /****************************************************************************************\
* A few functions from old stereo gesture recognition demosions * * A few functions from old stereo gesture recognition demosions *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* Additional operations on Subdivisions * * Additional operations on Subdivisions *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* More operations on sequences * * More operations on sequences *
\****************************************************************************************/ \****************************************************************************************/
/*******************************Stereo correspondence*************************************/ /*******************************Stereo correspondence*************************************/
/*****************************************************************************************/ /*****************************************************************************************/
/************ Epiline functions *******************/ /************ Epiline functions *******************/
/****************************************************************************************\ /****************************************************************************************\
* Contour Morphing * * Contour Morphing *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* Texture Descriptors * * Texture Descriptors *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* Face eyes&mouth tracking * * Face eyes&mouth tracking *
\****************************************************************************************/ \****************************************************************************************/
type HaarCascade struct {
cascade *C.CvHaarClassifierCascade
}
func LoadHaarClassifierCascade(haar string) *HaarCascade {
haarCascade := new(HaarCascade)
haarCascade.cascade = C.cvLoadHaarClassifierCascade(C.CString(haar), C.cvSize(1, 1))
return haarCascade
}
func (this *HaarCascade) DetectObjects(image *IplImage) []*Rect {
storage := C.cvCreateMemStorage(0)
seq := C.cvHaarDetectObjects(unsafe.Pointer(image), this.cascade, storage, 1.1, 3, C.CV_HAAR_DO_CANNY_PRUNING, C.cvSize(0, 0), C.cvSize(0, 0))
var faces []*Rect
for i := 0; i < (int)(seq.total); i++ {
rect := (*Rect)((*_Ctype_CvRect)(unsafe.Pointer(C.cvGetSeqElem(seq, C.int(i)))))
faces = append(faces, rect)
}
return faces
}
/****************************************************************************************\ /****************************************************************************************\
* 3D Tracker * * 3D Tracker *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* Skeletons and Linear-Contour Models * * Skeletons and Linear-Contour Models *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* Background/foreground segmentation * * Background/foreground segmentation *
\****************************************************************************************/ \****************************************************************************************/
/****************************************************************************************\ /****************************************************************************************\
* Calibration engine * * Calibration engine *
\****************************************************************************************/ \****************************************************************************************/
/*****************************************************************************\ /*****************************************************************************\
* --- END --- * * --- END --- *
\*****************************************************************************/ \*****************************************************************************/

105
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,51 +374,41 @@ 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 *
\****************************************************************************************/ \****************************************************************************************/
@ -426,26 +423,34 @@ func Line(image *IplImage, pt1, pt2 Point, color Scalar, thickness, line_type, s
(C.CvScalar)(color), (C.CvScalar)(color),
C.int(thickness), C.int(line_type), C.int(shift), C.int(thickness), C.int(line_type), C.int(shift),
) )
//Scalar }
func Rectangle(image *IplImage, pt1, pt2 Point, color Scalar, thickness, line_type, shift int) {
C.cvRectangle(
unsafe.Pointer(image),
C.cvPoint(C.int(pt1.X), C.int(pt1.Y)),
C.cvPoint(C.int(pt2.X), C.int(pt2.Y)),
(C.CvScalar)(color),
C.int(thickness), C.int(line_type), C.int(shift),
)
}
func Circle(image *IplImage, pt1 Point, radius int, color Scalar, thickness, line_type, shift int) {
C.cvCircle(
unsafe.Pointer(image),
C.cvPoint(C.int(pt1.X), C.int(pt1.Y)),
C.int(radius),
(C.CvScalar)(color),
C.int(thickness), C.int(line_type), C.int(shift),
)
} }
//CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2, //CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,
// 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")
} }

130
opencv/cxtype.go
View file

@ -59,7 +59,6 @@ import (
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// cvver.h // cvver.h
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -71,7 +70,7 @@ const (
) )
var ( var (
//CV_VERSION = C.GoString(C.CV_VERSION_) //CV_VERSION = C.GoString(C.CV_VERSION_)
) )
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -229,58 +228,58 @@ const (
type IplImage C.IplImage type IplImage C.IplImage
// normal fields // normal fields
func (img *IplImage)Channels() int { func (img *IplImage) Channels() int {
return int(img.nChannels) return int(img.nChannels)
} }
func (img *IplImage)Depth() int { func (img *IplImage) Depth() int {
return int(img.depth) return int(img.depth)
} }
func (img *IplImage)Origin() int { func (img *IplImage) Origin() int {
return int(img.origin) return int(img.origin)
} }
func (img *IplImage)Width() int { func (img *IplImage) Width() int {
return int(img.width) return int(img.width)
} }
func (img *IplImage)Height() int { func (img *IplImage) Height() int {
return int(img.height) return int(img.height)
} }
func (img *IplImage)WidthStep() int { func (img *IplImage) WidthStep() int {
return int(img.widthStep) return int(img.widthStep)
} }
func (img *IplImage)ImageSize() int { func (img *IplImage) ImageSize() int {
return int(img.imageSize) return int(img.imageSize)
} }
func (img *IplImage)ImageData() unsafe.Pointer { func (img *IplImage) ImageData() unsafe.Pointer {
return unsafe.Pointer(img.imageData) return unsafe.Pointer(img.imageData)
} }
type IplROI C.IplROI 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 := (*C.IplROI)(roi)
roi_c.coi = C.int(coi) roi_c.coi = C.int(coi)
roi_c.xOffset = C.int(xOffset) roi_c.xOffset = C.int(xOffset)
roi_c.yOffset = C.int(yOffset) roi_c.yOffset = C.int(yOffset)
roi_c.width = C.int(width) roi_c.width = C.int(width)
roi_c.height = C.int(height) roi_c.height = C.int(height)
} }
func (roi *IplROI)Coi() int { func (roi *IplROI) Coi() int {
roi_c := (*C.IplROI)(roi) roi_c := (*C.IplROI)(roi)
return int(roi_c.coi) return int(roi_c.coi)
} }
func (roi *IplROI)XOffset() int { func (roi *IplROI) XOffset() int {
roi_c := (*C.IplROI)(roi) roi_c := (*C.IplROI)(roi)
return int(roi_c.xOffset) return int(roi_c.xOffset)
} }
func (roi *IplROI)YOffset() int { func (roi *IplROI) YOffset() int {
roi_c := (*C.IplROI)(roi) roi_c := (*C.IplROI)(roi)
return int(roi_c.yOffset) return int(roi_c.yOffset)
} }
func (roi *IplROI)Width() int { func (roi *IplROI) Width() int {
roi_c := (*C.IplROI)(roi) roi_c := (*C.IplROI)(roi)
return int(roi_c.width) return int(roi_c.width)
} }
func (roi *IplROI)Height() int { func (roi *IplROI) Height() int {
roi_c := (*C.IplROI)(roi) roi_c := (*C.IplROI)(roi)
return int(roi_c.height) return int(roi_c.height)
} }
@ -319,17 +318,17 @@ const (
type Mat C.CvMat type Mat C.CvMat
func (mat *Mat)Type() int { func (mat *Mat) Type() int {
return int(C.myGetMatType((*C.CvMat)(mat))) return int(C.myGetMatType((*C.CvMat)(mat)))
} }
func (mat *Mat)Step() int { func (mat *Mat) Step() int {
return int(mat.step) return int(mat.step)
} }
func (mat *Mat)Rows() int { func (mat *Mat) Rows() int {
return int(mat.rows) return int(mat.rows)
} }
func (mat *Mat)Cols() int { func (mat *Mat) Cols() int {
return int(mat.cols) return int(mat.cols)
} }
@ -346,14 +345,14 @@ func CV_ARE_TYPE_EQ() bool {
return false 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 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)) rv := C.cvmGet((*C.CvMat)(m), C.int(row), C.int(col))
return float64(rv) 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)) C.cvmSet((*C.CvMat)(m), C.int(row), C.int(col), C.double(value))
} }
@ -370,17 +369,17 @@ const (
CV_MATND_MAGIC_VAL = C.CV_MATND_MAGIC_VAL CV_MATND_MAGIC_VAL = C.CV_MATND_MAGIC_VAL
CV_TYPE_NAME_MATND = C.CV_TYPE_NAME_MATND CV_TYPE_NAME_MATND = C.CV_TYPE_NAME_MATND
CV_MAX_DIM = C.CV_MAX_DIM CV_MAX_DIM = C.CV_MAX_DIM
CV_MAX_DIM_HEAP = C.CV_MAX_DIM_HEAP CV_MAX_DIM_HEAP = C.CV_MAX_DIM_HEAP
) )
type MatND C.CvMatND type MatND C.CvMatND
func (m *MatND)Type() int { func (m *MatND) Type() int {
rv := C.myGetMatNDType((*C.CvMatND)(m)) rv := C.myGetMatNDType((*C.CvMatND)(m))
return int(rv) return int(rv)
} }
func (m *MatND)Dims() int { func (m *MatND) Dims() int {
rv := m.dims rv := m.dims
return int(rv) return int(rv)
} }
@ -396,11 +395,11 @@ const (
type SparseMat C.CvSparseMat type SparseMat C.CvSparseMat
func (m *SparseMat)Type() int { func (m *SparseMat) Type() int {
rv := C.myGetSparseMatType((*C.CvSparseMat)(m)) rv := C.myGetSparseMatType((*C.CvSparseMat)(m))
return int(rv) return int(rv)
} }
func (m *SparseMat)Dims() int { func (m *SparseMat) Dims() int {
rv := m.dims rv := m.dims
return int(rv) return int(rv)
} }
@ -409,26 +408,26 @@ func (m *SparseMat)Dims() int {
type SparseNode C.CvSparseNode type SparseNode C.CvSparseNode
func (node *SparseNode)HashVal() uint32 { func (node *SparseNode) HashVal() uint32 {
rv := node.hashval rv := node.hashval
return uint32(rv) return uint32(rv)
} }
func (node *SparseNode)Next() *SparseNode { func (node *SparseNode) Next() *SparseNode {
rv := node.next rv := node.next
return (*SparseNode)(rv) return (*SparseNode)(rv)
} }
type SparseMatIterator C.CvSparseMatIterator type SparseMatIterator C.CvSparseMatIterator
func (node *SparseMatIterator)Mat() *SparseMat { func (node *SparseMatIterator) Mat() *SparseMat {
rv := node.mat rv := node.mat
return (*SparseMat)(rv) return (*SparseMat)(rv)
} }
func (node *SparseMatIterator)Node() *SparseNode { func (node *SparseMatIterator) Node() *SparseNode {
rv := node.node rv := node.node
return (*SparseNode)(rv) return (*SparseNode)(rv)
} }
func (node *SparseMatIterator)CurIdx() int { func (node *SparseMatIterator) CurIdx() int {
rv := node.curidx rv := node.curidx
return (int)(rv) return (int)(rv)
} }
@ -440,15 +439,15 @@ func (node *SparseMatIterator)CurIdx() int {
type HistType C.CvHistType type HistType C.CvHistType
const ( const (
CV_HIST_MAGIC_VAL = C.CV_HIST_MAGIC_VAL CV_HIST_MAGIC_VAL = C.CV_HIST_MAGIC_VAL
CV_HIST_UNIFORM_FLAG = C.CV_HIST_UNIFORM_FLAG CV_HIST_UNIFORM_FLAG = C.CV_HIST_UNIFORM_FLAG
/* indicates whether bin ranges are set already or not */ /* indicates whether bin ranges are set already or not */
CV_HIST_RANGES_FLAG = C.CV_HIST_RANGES_FLAG CV_HIST_RANGES_FLAG = C.CV_HIST_RANGES_FLAG
CV_HIST_ARRAY = C.CV_HIST_ARRAY CV_HIST_ARRAY = C.CV_HIST_ARRAY
CV_HIST_SPARSE = C.CV_HIST_SPARSE CV_HIST_SPARSE = C.CV_HIST_SPARSE
CV_HIST_TREE = C.CV_HIST_TREE CV_HIST_TREE = C.CV_HIST_TREE
/* should be used as a parameter only, /* should be used as a parameter only,
it turns to CV_HIST_UNIFORM_FLAG of hist->type */ it turns to CV_HIST_UNIFORM_FLAG of hist->type */
@ -478,35 +477,35 @@ func CV_HIST_HAS_RANGES() bool {
type Rect C.CvRect 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.x = C.int(x)
r.y = C.int(y) r.y = C.int(y)
r.width = C.int(w) r.width = C.int(w)
r.height = C.int(h) r.height = C.int(h)
} }
func (r *Rect)X() int { func (r *Rect) X() int {
r_c := (*C.CvRect)(r) r_c := (*C.CvRect)(r)
return int(r_c.x) return int(r_c.x)
} }
func (r *Rect)Y() int { func (r *Rect) Y() int {
r_c := (*C.CvRect)(r) r_c := (*C.CvRect)(r)
return int(r_c.y) return int(r_c.y)
} }
func (r *Rect)Width() int { func (r *Rect) Width() int {
r_c := (*C.CvRect)(r) r_c := (*C.CvRect)(r)
return int(r_c.width) return int(r_c.width)
} }
func (r *Rect)Height() int { func (r *Rect) Height() int {
r_c := (*C.CvRect)(r) r_c := (*C.CvRect)(r)
return int(r_c.height) return int(r_c.height)
} }
func (r *Rect)ToROI(coi int) IplROI { func (r *Rect) ToROI(coi int) IplROI {
r_c := (*C.CvRect)(r) r_c := (*C.CvRect)(r)
return (IplROI)(C.cvRectToROI(*r_c, C.int(coi))) return (IplROI)(C.cvRectToROI(*r_c, C.int(coi)))
} }
func (roi *IplROI)ToRect() Rect { func (roi *IplROI) ToRect() Rect {
r := C.cvRect( r := C.cvRect(
C.int(roi.XOffset()), C.int(roi.XOffset()),
C.int(roi.YOffset()), C.int(roi.YOffset()),
@ -519,27 +518,27 @@ func (roi *IplROI)ToRect() Rect {
/*********************************** CvTermCriteria *************************************/ /*********************************** CvTermCriteria *************************************/
const ( const (
CV_TERMCRIT_ITER = C.CV_TERMCRIT_ITER CV_TERMCRIT_ITER = C.CV_TERMCRIT_ITER
CV_TERMCRIT_NUMBER = C.CV_TERMCRIT_NUMBER CV_TERMCRIT_NUMBER = C.CV_TERMCRIT_NUMBER
CV_TERMCRIT_EPS = C.CV_TERMCRIT_EPS CV_TERMCRIT_EPS = C.CV_TERMCRIT_EPS
) )
type TermCriteria C.CvTermCriteria 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)) rv := C.cvTermCriteria(C.int(type_), C.int(max_iter), C.double(epsilon))
(*x) = (TermCriteria)(rv) (*x) = (TermCriteria)(rv)
} }
func (x *TermCriteria)Type() int { func (x *TermCriteria) Type() int {
rv := C.myGetTermCriteriaType((*C.CvTermCriteria)(x)) rv := C.myGetTermCriteriaType((*C.CvTermCriteria)(x))
return int(rv) return int(rv)
} }
func (x *TermCriteria)MaxIter() int { func (x *TermCriteria) MaxIter() int {
rv := x.max_iter rv := x.max_iter
return int(rv) return int(rv)
} }
func (x *TermCriteria)Epsilon() float64 { func (x *TermCriteria) Epsilon() float64 {
rv := x.epsilon rv := x.epsilon
return float64(rv) return float64(rv)
} }
@ -561,7 +560,6 @@ type Point3D32f struct {
Z float32 Z float32
} }
type Point2D64f struct { type Point2D64f struct {
X float64 X float64
Y float64 Y float64
@ -604,6 +602,11 @@ const (
type Scalar C.CvScalar type Scalar C.CvScalar
func NewScalar(b, g, r int) Scalar {
rv := C.cvScalar(C.double(b), C.double(g), C.double(r), C.double(0))
return (Scalar)(rv)
}
func ScalarAll(val0 float64) Scalar { func ScalarAll(val0 float64) Scalar {
rv := C.cvScalarAll(C.double(val0)) rv := C.cvScalarAll(C.double(val0))
return (Scalar)(rv) return (Scalar)(rv)
@ -615,14 +618,14 @@ func ScalarAll(val0 float64) Scalar {
/******************************** Memory storage ****************************************/ /******************************** Memory storage ****************************************/
type MemBlock C.CvMemBlock type MemBlock C.CvMemBlock
type MemStorage C.CvMemStorage type MemStorage C.CvMemStorage
type MemStoragePos C.CvMemStoragePos type MemStoragePos C.CvMemStoragePos
/*********************************** Sequence *******************************************/ /*********************************** Sequence *******************************************/
type SeqBlock C.CvSeqBlock type SeqBlock C.CvSeqBlock
type Seq C.CvSeq type Seq C.CvSeq
/*************************************** Set ********************************************/ /*************************************** Set ********************************************/
@ -630,15 +633,15 @@ type Set C.CvSet
/************************************* Graph ********************************************/ /************************************* Graph ********************************************/
type GraphEdge C.CvGraphEdge type GraphEdge C.CvGraphEdge
type GraphVtx C.CvGraphVtx type GraphVtx C.CvGraphVtx
type GraphVtx2D C.CvGraphVtx2D type GraphVtx2D C.CvGraphVtx2D
type Graph C.CvGraph type Graph C.CvGraph
/*********************************** Chain/Countour *************************************/ /*********************************** Chain/Countour *************************************/
type Chain C.CvChain type Chain C.CvChain
type Contour C.CvContour type Contour C.CvContour
/****************************************************************************************\ /****************************************************************************************\
@ -665,11 +668,11 @@ type FileStorage C.CvFileStorage
/* Storage flags: */ /* Storage flags: */
const ( const (
CV_STORAGE_READ = C.CV_STORAGE_READ CV_STORAGE_READ = C.CV_STORAGE_READ
CV_STORAGE_WRITE = C.CV_STORAGE_WRITE CV_STORAGE_WRITE = C.CV_STORAGE_WRITE
CV_STORAGE_WRITE_TEXT = C.CV_STORAGE_WRITE_TEXT CV_STORAGE_WRITE_TEXT = C.CV_STORAGE_WRITE_TEXT
CV_STORAGE_WRITE_BINARY = C.CV_STORAGE_WRITE_BINARY CV_STORAGE_WRITE_BINARY = C.CV_STORAGE_WRITE_BINARY
CV_STORAGE_APPEND = C.CV_STORAGE_APPEND CV_STORAGE_APPEND = C.CV_STORAGE_APPEND
) )
type AttrList C.CvAttrList type AttrList C.CvAttrList
@ -677,4 +680,3 @@ type AttrList C.CvAttrList
/*****************************************************************************\ /*****************************************************************************\
* --- END --- * * --- END --- *
\*****************************************************************************/ \*****************************************************************************/

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

224
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,11 +207,17 @@ 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))
@ -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,8 +295,12 @@ 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))
@ -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 --- *
\*****************************************************************************/ \*****************************************************************************/

3
opencv/opencv.go
View file

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

13
opencv/opencv.h
View file

@ -8,10 +8,15 @@
#define _GO_OPENCV_BINDING_H_ #define _GO_OPENCV_BINDING_H_
// OpenCV 2.4.x // OpenCV 2.4.x
# include <opencv/cv.h> #include <opencv/cv.h>
# include <opencv/highgui.h> #include <opencv/highgui.h>
# include <opencv2/photo/photo_c.h> #include <opencv2/photo/photo_c.h>
# include <opencv2/imgproc/imgproc_c.h> #include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/core/core_c.h>
#include <opencv2/core/core.hpp>
#include <opencv2/objdetect/objdetect.hpp>
#include <opencv2/legacy/compat.hpp>
#include <opencv2/legacy/legacy.hpp>
// Trackbar // Trackbar
int GoOpenCV_CreateTrackbar( int GoOpenCV_CreateTrackbar(

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() {

26
samples/face_detect.go Normal file
View file

@ -0,0 +1,26 @@
package main
import (
"github.com/hybridgroup/go-opencv/opencv"
"path"
"runtime"
)
func main() {
_, currentfile, _, _ := runtime.Caller(0)
image := opencv.LoadImage(path.Join(path.Dir(currentfile), "../images/lena.jpg"))
cascade := opencv.LoadHaarClassifierCascade(path.Join(path.Dir(currentfile), "haarcascade_frontalface_alt.xml"))
faces := cascade.DetectObjects(image)
for _, value := range faces {
opencv.Rectangle(image,
opencv.Point{value.X() + value.Width(), value.Y()},
opencv.Point{value.X(), value.Y() + value.Height()},
opencv.ScalarAll(255.0), 1, 1, 0)
}
win := opencv.NewWindow("Face Detection")
win.ShowImage(image)
opencv.WaitKey(0)
}

26161
samples/haarcascade_frontalface_alt.xml Normal file
View file

File diff suppressed because it is too large Load diff

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() {