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

25
opencv/cvaux.go
View file

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

86
opencv/cxcore.go
View file

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

1
opencv/cxcore_test.go
View file

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

125
opencv/cxtype.go
View file

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

1
opencv/doc.go
View file

@ -4,4 +4,3 @@
// Bindings for Intel's OpenCV computer vision library.
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++
import "C"
import (
_ "fmt"
"runtime"
"unsafe"
_ "fmt"
)
func init() {
@ -44,29 +44,28 @@ func WaitKey(delay int) int {
return int(key)
}
//-----------------------------------------------------------------------------
// Window wrapper for go
//-----------------------------------------------------------------------------
// mouse callback
type MouseFunc interface{}
type MouseFunc interface{}
type MouseFuncA func(event, x, y, flags int)
type MouseFuncB func(event, x, y, flags int, param ...interface{})
// trackbar callback
type TrackbarFunc interface{}
type TrackbarFunc interface{}
type TrackbarFuncA func(pos int)
type TrackbarFuncB func(pos int, param ...interface{})
// named window
type Window struct {
name string
name_c *C.char
flags C.int
name string
name_c *C.char
flags C.int
mouseHandle MouseFunc
param []interface{}
mouseHandle MouseFunc
param []interface{}
trackbarHandle map[string]TrackbarFunc
trackbarMax map[string]int
@ -74,8 +73,8 @@ type Window struct {
trackbarName map[string](*C.char)
trackbarParam map[string]([]interface{})
image *IplImage
refCount int
image *IplImage
refCount int
}
// window list
@ -97,15 +96,15 @@ func NewWindow(name string, flags ...int) *Window {
}
win := &Window{
name:name,
name_c:C.CString(name),
flags:win_flags,
name: name,
name_c: C.CString(name),
flags: win_flags,
trackbarHandle:make(map[string]TrackbarFunc, 50),
trackbarMax:make(map[string]int, 50),
trackbarVal:make(map[string]int, 50),
trackbarName:make(map[string](*C.char), 50),
trackbarParam:make(map[string]([]interface{}), 50),
trackbarHandle: make(map[string]TrackbarFunc, 50),
trackbarMax: make(map[string]int, 50),
trackbarVal: make(map[string]int, 50),
trackbarName: make(map[string](*C.char), 50),
trackbarParam: make(map[string]([]interface{}), 50),
}
C.cvNamedWindow(win.name_c, win.flags)
C.GoOpenCV_SetMouseCallback(win.name_c)
@ -121,49 +120,49 @@ const (
CV_WINDOW_NORMAL = int(C.CV_WINDOW_NORMAL)
CV_WINDOW_FULLSCREEN = int(C.CV_WINDOW_FULLSCREEN)
)
/* Set and Get Property of the window */
func (win *Window)SetProperty(prop_id int, value float64) {
func (win *Window) SetProperty(prop_id int, value float64) {
C.cvSetWindowProperty(win.name_c, C.int(prop_id), C.double(value))
}
func (win *Window)GetProperty(prop_id int) float64 {
func (win *Window) GetProperty(prop_id int) float64 {
rv := C.cvGetWindowProperty(win.name_c, C.int(prop_id))
return float64(rv)
}
/* display image within window (highgui windows remember their content) */
func (win *Window)ShowImage(image *IplImage) {
func (win *Window) ShowImage(image *IplImage) {
win.image = image
C.cvShowImage(win.name_c, unsafe.Pointer(image))
}
/* resize/move window */
func (win *Window)Resize(width, height int) {
func (win *Window) Resize(width, height int) {
C.cvResizeWindow(win.name_c, C.int(width), C.int(height))
}
func (win *Window)Move(x, y int) {
func (win *Window) Move(x, y int) {
C.cvMoveWindow(win.name_c, C.int(x), C.int(y))
}
/* get native window handle (HWND in case of Win32 and Widget in case of X Window) */
func (win *Window)GetHandle() unsafe.Pointer {
func (win *Window) GetHandle() unsafe.Pointer {
p := C.cvGetWindowHandle(win.name_c)
return unsafe.Pointer(p)
}
/* get name of highgui window given its native handle */
func (win *Window)GetWindowName() string {
func (win *Window) GetWindowName() string {
return win.name
}
//-----------------------------------------------------------------------------
// window: track bar
//-----------------------------------------------------------------------------
/* create trackbar and display it on top of given window, set callback */
func (win *Window)CreateTrackbar(name string,
func (win *Window) CreateTrackbar(name string,
value, count int,
on_changed TrackbarFunc, param ...interface{}) bool {
on_changed TrackbarFunc, param ...interface{}) bool {
bar_name := C.CString(name)
@ -196,7 +195,7 @@ func (win *Window)CreateTrackbar(name string,
return bool(rv != 0)
}
func destroyTrackbar(barName_, winName_ *C.char) {
C.GoOpenCV_DestroyTrackbar(barName_, winName_);
C.GoOpenCV_DestroyTrackbar(barName_, winName_)
}
//export goTrackbarCallback
@ -208,11 +207,17 @@ func goTrackbarCallback(barName_, winName_ *C.char, pos C.int) {
barName := C.GoString(barName_)
win, ok := allWindows[winName]
if !ok { return }
if !ok {
return
}
trackbarHandle, ok := win.trackbarHandle[barName]
if !ok { return }
if trackbarHandle == nil { return }
if !ok {
return
}
if trackbarHandle == nil {
return
}
if fa, ok := trackbarHandle.(func(pos int)); ok {
fa(int(pos))
@ -227,41 +232,40 @@ func goTrackbarCallback(barName_, winName_ *C.char, pos C.int) {
}
/* retrieve or set trackbar position */
func (win *Window)GetTrackbarPos(name string) (value, max int) {
func (win *Window) GetTrackbarPos(name string) (value, max int) {
rv := C.cvGetTrackbarPos(win.trackbarName[name], win.name_c)
return int(rv), win.trackbarMax[name]
}
func (win *Window)SetTrackbarPos(name string, pos int) {
func (win *Window) SetTrackbarPos(name string, pos int) {
C.cvSetTrackbarPos(win.trackbarName[name], win.name_c, C.int(pos))
}
//-----------------------------------------------------------------------------
// window: mouse callback
//-----------------------------------------------------------------------------
const (
CV_EVENT_MOUSEMOVE = int(C.CV_EVENT_MOUSEMOVE )
CV_EVENT_LBUTTONDOWN = int(C.CV_EVENT_LBUTTONDOWN )
CV_EVENT_RBUTTONDOWN = int(C.CV_EVENT_RBUTTONDOWN )
CV_EVENT_MBUTTONDOWN = int(C.CV_EVENT_MBUTTONDOWN )
CV_EVENT_LBUTTONUP = int(C.CV_EVENT_LBUTTONUP )
CV_EVENT_RBUTTONUP = int(C.CV_EVENT_RBUTTONUP )
CV_EVENT_MBUTTONUP = int(C.CV_EVENT_MBUTTONUP )
CV_EVENT_MOUSEMOVE = int(C.CV_EVENT_MOUSEMOVE)
CV_EVENT_LBUTTONDOWN = int(C.CV_EVENT_LBUTTONDOWN)
CV_EVENT_RBUTTONDOWN = int(C.CV_EVENT_RBUTTONDOWN)
CV_EVENT_MBUTTONDOWN = int(C.CV_EVENT_MBUTTONDOWN)
CV_EVENT_LBUTTONUP = int(C.CV_EVENT_LBUTTONUP)
CV_EVENT_RBUTTONUP = int(C.CV_EVENT_RBUTTONUP)
CV_EVENT_MBUTTONUP = int(C.CV_EVENT_MBUTTONUP)
CV_EVENT_LBUTTONDBLCLK = int(C.CV_EVENT_LBUTTONDBLCLK)
CV_EVENT_RBUTTONDBLCLK = int(C.CV_EVENT_RBUTTONDBLCLK)
CV_EVENT_MBUTTONDBLCLK = int(C.CV_EVENT_MBUTTONDBLCLK)
CV_EVENT_FLAG_LBUTTON = int(C.CV_EVENT_FLAG_LBUTTON )
CV_EVENT_FLAG_RBUTTON = int(C.CV_EVENT_FLAG_RBUTTON )
CV_EVENT_FLAG_MBUTTON = int(C.CV_EVENT_FLAG_MBUTTON )
CV_EVENT_FLAG_CTRLKEY = int(C.CV_EVENT_FLAG_CTRLKEY )
CV_EVENT_FLAG_LBUTTON = int(C.CV_EVENT_FLAG_LBUTTON)
CV_EVENT_FLAG_RBUTTON = int(C.CV_EVENT_FLAG_RBUTTON)
CV_EVENT_FLAG_MBUTTON = int(C.CV_EVENT_FLAG_MBUTTON)
CV_EVENT_FLAG_CTRLKEY = int(C.CV_EVENT_FLAG_CTRLKEY)
CV_EVENT_FLAG_SHIFTKEY = int(C.CV_EVENT_FLAG_SHIFTKEY)
CV_EVENT_FLAG_ALTKEY = int(C.CV_EVENT_FLAG_ALTKEY )
CV_EVENT_FLAG_ALTKEY = int(C.CV_EVENT_FLAG_ALTKEY)
)
/* assign callback for mouse events */
func (win *Window)SetMouseCallback(on_mouse MouseFunc, param ...interface{}) {
func (win *Window) SetMouseCallback(on_mouse MouseFunc, param ...interface{}) {
switch f := on_mouse.(type) {
case MouseFuncA:
@ -282,6 +286,7 @@ func (win *Window)SetMouseCallback(on_mouse MouseFunc, param ...interface{}) {
win.param = nil
}
}
//export goMouseCallback
func goMouseCallback(name *C.char, event, x, y, flags C.int) {
runtime.LockOSThread()
@ -290,8 +295,12 @@ func goMouseCallback(name *C.char, event, x, y, flags C.int) {
winName := C.GoString(name)
win, ok := allWindows[winName]
if !ok { return }
if win.mouseHandle == nil { return }
if !ok {
return
}
if win.mouseHandle == nil {
return
}
if fa, ok := win.mouseHandle.(func(event, x, y, flags int)); ok {
fa(int(event), int(x), int(y), int(flags))
@ -308,13 +317,12 @@ func goMouseCallback(name *C.char, event, x, y, flags C.int) {
}
}
//-----------------------------------------------------------------------------
// window: destroy
//-----------------------------------------------------------------------------
/* destroy window and all the trackers associated with it */
func (win *Window)Destroy() {
func (win *Window) Destroy() {
C.cvDestroyWindow(win.name_c)
delete(allWindows, win.name)
@ -343,17 +351,18 @@ const (
/* 8bit, gray */
CV_LOAD_IMAGE_GRAYSCALE = int(C.CV_LOAD_IMAGE_GRAYSCALE)
/* ?, color */
CV_LOAD_IMAGE_COLOR = int(C.CV_LOAD_IMAGE_COLOR)
CV_LOAD_IMAGE_COLOR = int(C.CV_LOAD_IMAGE_COLOR)
/* any depth, ? */
CV_LOAD_IMAGE_ANYDEPTH = int(C.CV_LOAD_IMAGE_ANYDEPTH)
CV_LOAD_IMAGE_ANYDEPTH = int(C.CV_LOAD_IMAGE_ANYDEPTH)
/* ?, 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
iscolor can be a combination of above flags where CV_LOAD_IMAGE_UNCHANGED
overrides the other flags
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
iscolor can be a combination of above flags where CV_LOAD_IMAGE_UNCHANGED
overrides the other flags
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
*/
func LoadImage(filename string, iscolor_ ...int) *IplImage {
iscolor := CV_LOAD_IMAGE_COLOR
@ -435,34 +444,34 @@ func NewFileCapture(filename string) *Capture {
}
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_V4L = int(C.CV_CAP_V4L)
CV_CAP_V4L2 = int(C.CV_CAP_V4L2)
CV_CAP_VFW = int(C.CV_CAP_VFW) // platform native
CV_CAP_V4L = int(C.CV_CAP_V4L)
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_IEEE1394 = int(C.CV_CAP_IEEE1394)
CV_CAP_DC1394 = int(C.CV_CAP_DC1394)
CV_CAP_CMU1394 = int(C.CV_CAP_CMU1394)
CV_CAP_STEREO = int(C.CV_CAP_STEREO) // TYZX proprietary drivers
CV_CAP_TYZX = int(C.CV_CAP_TYZX)
CV_TYZX_LEFT = int(C.CV_TYZX_LEFT)
CV_TYZX_RIGHT = int(C.CV_TYZX_RIGHT)
CV_TYZX_COLOR = int(C.CV_TYZX_COLOR)
CV_TYZX_Z = int(C.CV_TYZX_Z)
CV_CAP_STEREO = int(C.CV_CAP_STEREO) // TYZX proprietary drivers
CV_CAP_TYZX = int(C.CV_CAP_TYZX)
CV_TYZX_LEFT = int(C.CV_TYZX_LEFT)
CV_TYZX_RIGHT = int(C.CV_TYZX_RIGHT)
CV_TYZX_COLOR = int(C.CV_TYZX_COLOR)
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_*) */
@ -472,64 +481,64 @@ func NewCameraCapture(index int) *Capture {
}
/* grab a frame, return 1 on success, 0 on fail.
this function is thought to be fast */
func (capture *Capture)GrabFrame() bool {
this function is thought to be fast */
func (capture *Capture) GrabFrame() bool {
rv := C.cvGrabFrame((*C.CvCapture)(capture))
return (rv != C.int(0))
}
/* get the frame grabbed with cvGrabFrame(..)
This function may apply some frame processing like
frame decompression, flipping etc.
!!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
func (capture *Capture)RetrieveFrame(streamIdx int) *IplImage {
This function may apply some frame processing like
frame decompression, flipping etc.
!!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
func (capture *Capture) RetrieveFrame(streamIdx int) *IplImage {
rv := C.cvRetrieveFrame((*C.CvCapture)(capture), C.int(streamIdx))
return (*IplImage)(rv)
}
/* Just a combination of cvGrabFrame and cvRetrieveFrame
!!!DO NOT RELEASE or MODIFY the retrieved frame!!! */
func (capture *Capture)QueryFrame() *IplImage {
func (capture *Capture) QueryFrame() *IplImage {
rv := C.cvQueryFrame((*C.CvCapture)(capture))
return (*IplImage)(rv)
}
/* stop capturing/reading and free resources */
func (capture *Capture)Release() {
func (capture *Capture) Release() {
cap_c := (*C.CvCapture)(capture)
C.cvReleaseCapture(&cap_c)
}
const (
CV_CAP_PROP_POS_MSEC = int(C.CV_CAP_PROP_POS_MSEC )
CV_CAP_PROP_POS_FRAMES = int(C.CV_CAP_PROP_POS_FRAMES )
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_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_HEIGHT = int(C.CV_CAP_PROP_FRAME_HEIGHT )
CV_CAP_PROP_FPS = int(C.CV_CAP_PROP_FPS )
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_FORMAT = int(C.CV_CAP_PROP_FORMAT )
CV_CAP_PROP_MODE = int(C.CV_CAP_PROP_MODE )
CV_CAP_PROP_BRIGHTNESS = int(C.CV_CAP_PROP_BRIGHTNESS )
CV_CAP_PROP_CONTRAST = int(C.CV_CAP_PROP_CONTRAST )
CV_CAP_PROP_SATURATION = int(C.CV_CAP_PROP_SATURATION )
CV_CAP_PROP_HUE = int(C.CV_CAP_PROP_HUE )
CV_CAP_PROP_GAIN = int(C.CV_CAP_PROP_GAIN )
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_FRAME_WIDTH = int(C.CV_CAP_PROP_FRAME_WIDTH)
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_FOURCC = int(C.CV_CAP_PROP_FOURCC)
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_MODE = int(C.CV_CAP_PROP_MODE)
CV_CAP_PROP_BRIGHTNESS = int(C.CV_CAP_PROP_BRIGHTNESS)
CV_CAP_PROP_CONTRAST = int(C.CV_CAP_PROP_CONTRAST)
CV_CAP_PROP_SATURATION = int(C.CV_CAP_PROP_SATURATION)
CV_CAP_PROP_HUE = int(C.CV_CAP_PROP_HUE)
CV_CAP_PROP_GAIN = int(C.CV_CAP_PROP_GAIN)
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_WHITE_BALANCE = int(C.CV_CAP_PROP_WHITE_BALANCE)
CV_CAP_PROP_RECTIFICATION = int(C.CV_CAP_PROP_RECTIFICATION)
)
/* retrieve or set capture properties */
func (capture *Capture)GetProperty(property_id int) float64 {
func (capture *Capture) GetProperty(property_id int) float64 {
rv := C.cvGetCaptureProperty((*C.CvCapture)(capture),
C.int(property_id),
)
return float64(rv)
}
func (capture *Capture)SetProperty(property_id int, value float64) int {
func (capture *Capture) SetProperty(property_id int, value float64) int {
rv := C.cvSetCaptureProperty((*C.CvCapture)(capture),
C.int(property_id), C.double(value),
)
@ -538,7 +547,7 @@ func (capture *Capture)SetProperty(property_id int, value float64) int {
// Return the type of the capturer (eg, CV_CAP_V4W, CV_CAP_UNICAP),
// which is unknown if created with CV_CAP_ANY
func (capture *Capture)GetDomain() int {
func (capture *Capture) GetDomain() int {
rv := C.cvGetCaptureDomain((*C.CvCapture)(capture))
return int(rv)
}
@ -552,12 +561,13 @@ type VideoWriter C.CvVideoWriter
// Prototype for CV_FOURCC so that swig can generate wrapper without mixing up the define
func FOURCC(c1, c2, c3, c4 int8) uint32 {
rv := C.GoOpenCV_FOURCC_(C.int(c1),C.int(c2),C.int(c3),C.int(c4))
rv := C.GoOpenCV_FOURCC_(C.int(c1), C.int(c2), C.int(c3), C.int(c4))
return uint32(rv)
}
const (
/* Open Codec Selection Dialog (Windows only) */
CV_FOURCC_PROMPT = int(C.CV_FOURCC_PROMPT)
CV_FOURCC_PROMPT = int(C.CV_FOURCC_PROMPT)
/* Use default codec for specified filename (Linux only) */
// CV_FOURCC_DEFAULT = int(C.CV_FOURCC_DEFAULT)
)
@ -585,7 +595,7 @@ func (writer *VideoWriter) WriteFrame(image *IplImage) int {
}
/* close video file writer */
func (writer *VideoWriter)Release() {
func (writer *VideoWriter) Release() {
writer_c := (*C.CvVideoWriter)(writer)
C.cvReleaseVideoWriter(&writer_c)
}
@ -593,5 +603,3 @@ func (writer *VideoWriter)Release() {
/*****************************************************************************\
* --- END --- *
\*****************************************************************************/

3
opencv/opencv.go
View file

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

4
samples/edge.go
View file

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

4
samples/hellocv.go
View file

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

4
samples/inpaint.go
View file

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

4
samples/player.go
View file

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

4
samples/webcam.go
View file

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