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

Merge branch 'mohamed-helala-extension'

Browse source
This commit is contained in:
Chih-Wei Chang 2015-02-05 18:36:23 +08:00 • committed by Chih-Wei Chang
commit 60392006c9
14 changed files with 1570 additions and 173 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
AUTHORS
View file

@ -4,3 +4,15 @@
# Initial version authors: # Initial version authors:
ChaiShushan <chaishushan@gmail.com> ChaiShushan <chaishushan@gmail.com>
# Forked version authors:
Chih-Wei Chang <me@cwchang.me>
MohamedHelala <mohamed.helala@gmail.com>
Adrian Zankich <>
vanillahsu <>
Alexander Kirillov <>
Aditya Bhargava <>
Bradley Griffiths <>
Ashkan Kiani <>
Peter Bui <>
satojkovic <>
TEE JIA HEN <>

1
opencv/cluster.go
View file

@ -7,6 +7,7 @@ package opencv
//#include "opencv.h" //#include "opencv.h"
//#cgo linux pkg-config: opencv //#cgo linux pkg-config: opencv
//#cgo darwin pkg-config: opencv //#cgo darwin pkg-config: opencv
//#cgo freebsd 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" import "unsafe"

28
opencv/cv.go
View file

@ -7,6 +7,7 @@ package opencv
//#include "opencv.h" //#include "opencv.h"
//#cgo linux pkg-config: opencv //#cgo linux pkg-config: opencv
//#cgo darwin pkg-config: opencv //#cgo darwin pkg-config: opencv
//#cgo freebsd 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 ( import (
@ -17,22 +18,6 @@ import (
func init() { func init() {
} }
const (
CV_BGR2GRAY = C.CV_BGR2GRAY
CV_BGR2BGRA = C.CV_BGR2BGRA
CV_RGBA2BGRA = C.CV_RGBA2BGRA
CV_BLUR = C.CV_BLUR
CV_8U = C.CV_8U
CV_8S = C.CV_8S
CV_16U = C.CV_16U
CV_16S = C.CV_16S
CV_32S = C.CV_32S
CV_32F = C.CV_32F
CV_64F = C.CV_64F
)
/* 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) {
@ -78,6 +63,17 @@ func Canny(image, edges *IplImage, threshold1, threshold2 float64, 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) );
/* Calculates the first, second, third, or mixed image derivatives using an
* extended Sobel operator. */
func Sobel(src, dst *IplImage, xorder, yorder, aperture_size int) {
C.cvSobel(unsafe.Pointer(src), unsafe.Pointer(dst),
C.int(xorder), C.int(yorder),
C.int(aperture_size),
)
}
// C: void cvSobel(const CvArr* src, CvArr* dst, int xorder, int yorder, int aperture_size=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

1
opencv/cvaux.go
View file

@ -7,6 +7,7 @@ package opencv
//#include "opencv.h" //#include "opencv.h"
//#cgo linux pkg-config: opencv //#cgo linux pkg-config: opencv
//#cgo darwin pkg-config: opencv //#cgo darwin pkg-config: opencv
//#cgo freebsd 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 ( import (

560
opencv/cxcore.go
View file

@ -1,12 +1,14 @@
// Copyright 2011 <chaishushan@gmail.com>. All rights reserved. // Copyright 2011 <chaishushan@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// 22/11/2013 Updated by <mohamd.helala@gmail.com>.
package opencv package opencv
//#include "opencv.h" //#include "opencv.h"
//#cgo linux pkg-config: opencv //#cgo linux pkg-config: opencv
//#cgo darwin pkg-config: opencv //#cgo darwin pkg-config: opencv
//#cgo freebsd 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 ( import (
@ -57,11 +59,6 @@ func CreateImage(w, h, depth, channels int) *IplImage {
return (*IplImage)(img) return (*IplImage)(img)
} }
/* SetData assigns user data to the image header */
func (img *IplImage) SetData(data unsafe.Pointer, step int) {
C.cvSetData(unsafe.Pointer(img), data, C.int(step))
}
/* 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)
@ -74,10 +71,6 @@ func (img *IplImage) Release() {
C.cvReleaseImage(&img_c) C.cvReleaseImage(&img_c)
} }
func (img *IplImage) Zero() {
C.cvSetZero(unsafe.Pointer(img))
}
/* 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))
@ -112,58 +105,6 @@ func (img *IplImage) GetROI() Rect {
return Rect(r) return Rect(r)
} }
/*
Reshape changes shape of the image without copying data. A value of `0` means
that channels or rows remain unchanged.
*/
func (img *IplImage) Reshape(channels, rows, _type int) *Mat {
total := img.Width() * img.Height()
header := CreateMat(rows, total/rows, _type)
n := C.cvReshape(unsafe.Pointer(img), (*C.CvMat)(header), C.int(channels), C.int(rows))
return (*Mat)(n)
}
/* Get1D return a specific element from a 1-dimensional matrix. */
func (img *IplImage) Get1D(x int) Scalar {
ret := C.cvGet1D(unsafe.Pointer(img), C.int(x))
return Scalar(ret)
}
/* Get2D return a specific element from a 2-dimensional matrix. */
func (img *IplImage) Get2D(x, y int) Scalar {
ret := C.cvGet2D(unsafe.Pointer(img), C.int(y), C.int(x))
return Scalar(ret)
}
/* Get3D return a specific element from a 3-dimensional matrix. */
func (img *IplImage) Get3D(x, y, z int) Scalar {
ret := C.cvGet3D(unsafe.Pointer(img), C.int(z), C.int(y), C.int(x))
return Scalar(ret)
}
/* Set1D sets a particular element in the image */
func (img *IplImage) Set1D(x int, value Scalar) {
C.cvSet1D(unsafe.Pointer(img), C.int(x), (C.CvScalar)(value))
}
/* Set2D sets a particular element in the image */
func (img *IplImage) Set2D(x, y int, value Scalar) {
C.cvSet2D(unsafe.Pointer(img), C.int(y), C.int(x), (C.CvScalar)(value))
}
/* Set3D sets a particular element in the image */
func (img *IplImage) Set3D(x, y, z int, value Scalar) {
C.cvSet3D(unsafe.Pointer(img), C.int(z), C.int(y), C.int(x), (C.CvScalar)(value))
}
/* GetMat returns the matrix header for an image.*/
func (img *IplImage) GetMat() *Mat {
var null C.int
tmp := CreateMat(img.Height(), img.Width(), CV_32S)
m := C.cvGetMat(unsafe.Pointer(img), (*C.CvMat)(tmp), &null, C.int(0))
return (*Mat)(m)
}
// mat step // mat step
const ( const (
CV_AUTOSTEP = C.CV_AUTOSTEP CV_AUTOSTEP = C.CV_AUTOSTEP
@ -197,11 +138,6 @@ func (mat *Mat) InitHeader(rows, cols, type_ int, data unsafe.Pointer, step int)
) )
} }
/* SetData assigns user data to the matrix header. */
func (mat *Mat) SetData(data unsafe.Pointer, step int) {
C.cvSetData(unsafe.Pointer(mat), data, C.int(step))
}
/* 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() {
@ -226,21 +162,6 @@ func (mat *Mat) Clone() *Mat {
return (*Mat)(mat_new) return (*Mat)(mat_new)
} }
func (mat *Mat) Zero() {
C.cvSetZero(unsafe.Pointer(mat))
}
/*
Reshape changes shape of the matrix without copying data. A value of `0` means
that channels or rows remain unchanged.
*/
func (m *Mat) Reshape(channels, rows int) *Mat {
total := m.Cols() * m.Rows()
n := CreateMat(rows, total/rows, m.Type())
C.cvReshape(unsafe.Pointer(m), (*C.CvMat)(n), C.int(channels), C.int(rows))
return n
}
/* Makes a new matrix from <rect> subrectangle of input array. /* Makes a new matrix from <rect> subrectangle of input array.
No data is copied */ No data is copied */
func GetSubRect(arr Arr, submat *Mat, rect Rect) *Mat { func GetSubRect(arr Arr, submat *Mat, rect Rect) *Mat {
@ -308,47 +229,6 @@ func GetDiag(arr Arr, submat *Mat, diag int) *Mat {
return (*Mat)(mat_new) return (*Mat)(mat_new)
} }
/* Get1D return a specific element from a 1-dimensional matrix. */
func (m *Mat) Get1D(x int) Scalar {
ret := C.cvGet1D(unsafe.Pointer(m), C.int(x))
return Scalar(ret)
}
/* Get2D return a specific element from a 2-dimensional matrix. */
func (m *Mat) Get2D(x, y int) Scalar {
ret := C.cvGet2D(unsafe.Pointer(m), C.int(x), C.int(y))
return Scalar(ret)
}
/* Get3D return a specific element from a 3-dimensional matrix. */
func (m *Mat) Get3D(x, y, z int) Scalar {
ret := C.cvGet3D(unsafe.Pointer(m), C.int(x), C.int(y), C.int(z))
return Scalar(ret)
}
/* Set1D sets a particular element in them matrix */
func (m *Mat) Set1D(x int, value Scalar) {
C.cvSet1D(unsafe.Pointer(m), C.int(x), (C.CvScalar)(value))
}
/* Set2D sets a particular element in them matrix */
func (m *Mat) Set2D(x, y int, value Scalar) {
C.cvSet2D(unsafe.Pointer(m), C.int(x), C.int(y), (C.CvScalar)(value))
}
/* Set3D sets a particular element in them matrix */
func (m *Mat) Set3D(x, y, z int, value Scalar) {
C.cvSet3D(unsafe.Pointer(m), C.int(x), C.int(y), C.int(z), (C.CvScalar)(value))
}
/* GetImage returns the image header for the matrix. */
func (m *Mat) GetImage(channels int) *IplImage {
tmp := CreateImage(m.Cols(), m.Rows(), m.Type(), channels)
img := C.cvGetImage(unsafe.Pointer(m), (*C.IplImage)(tmp))
return (*IplImage)(img)
}
/* low-level scalar <-> raw data conversion functions */ /* low-level scalar <-> raw data conversion functions */
func ScalarToRawData(scalar *Scalar, data unsafe.Pointer, type_, extend_to_12 int) { func ScalarToRawData(scalar *Scalar, data unsafe.Pointer, type_, extend_to_12 int) {
C.cvScalarToRawData( C.cvScalarToRawData(
@ -467,6 +347,73 @@ func (iter *SparseMatIterator) Next() *SparseNode {
// P290 // P290
/*
Reshape changes shape of the image without copying data. A value of `0` means
that channels or rows remain unchanged.
*/
func Reshape(img unsafe.Pointer, header *Mat, channels, rows int) *Mat {
n := C.cvReshape(img, (*C.CvMat)(header), C.int(channels), C.int(rows))
return (*Mat)(n)
}
/* Get1D return a specific element from a 1-dimensional matrix. */
func Get1D(img unsafe.Pointer, x int) Scalar {
ret := C.cvGet1D(img, C.int(x))
return Scalar(ret)
}
/* Get2D return a specific element from a 2-dimensional matrix. */
func Get2D(img unsafe.Pointer,x, y int) Scalar {
ret := C.cvGet2D(img, C.int(y), C.int(x))
return Scalar(ret)
}
/* Get3D return a specific element from a 3-dimensional matrix. */
func Get3D(img unsafe.Pointer,x, y, z int) Scalar {
ret := C.cvGet3D(img, C.int(z), C.int(y), C.int(x))
return Scalar(ret)
}
/* Set1D sets a particular element in the image */
func Set1D(img unsafe.Pointer, x int, value Scalar) {
C.cvSet1D(img, C.int(x), (C.CvScalar)(value))
}
/* Set2D sets a particular element in the image */
func Set2D(img unsafe.Pointer, x, y int, value Scalar) {
C.cvSet2D(img, C.int(y), C.int(x), (C.CvScalar)(value))
}
/* Set3D sets a particular element in the image */
func Set3D(img unsafe.Pointer, x, y, z int, value Scalar) {
C.cvSet3D(img, C.int(z), C.int(y), C.int(x), (C.CvScalar)(value))
}
//
//
//
/* Converts CvArr (IplImage or CvMat,...) to CvMat.
If the last parameter is non-zero, function can
convert multi(>2)-dimensional array to CvMat as long as
the last array's dimension is continous. The resultant
matrix will be have appropriate (a huge) number of rows
CVAPI(CvMat*) cvGetMat( const CvArr* arr, CvMat* header,
int* coi CV_DEFAULT(NULL),int allowND CV_DEFAULT(0));*/
func GetMat(arr unsafe.Pointer, header *Mat, coi *int32, allowND int) *Mat{
m := C.cvGetMat(arr, (*C.CvMat)(header), (*C.int)(coi), C.int(allowND))
return (*Mat)(m)
}
/* Converts CvArr (IplImage or CvMat) to IplImage
CVAPI(IplImage*) cvGetImage( const CvArr* arr,
IplImage* image_header );*/
func GetImage(arr unsafe.Pointer, header *IplImage) *IplImage{
m := C.cvGetImage(arr, (*C.IplImage)(header))
return (*IplImage)(m)
}
/* Returns width and height of array in elements */ /* Returns width and height of array in elements */
func GetSizeWidth(img *IplImage) int { func GetSizeWidth(img *IplImage) int {
size := C.cvGetSize(unsafe.Pointer(img)) size := C.cvGetSize(unsafe.Pointer(img))
@ -485,16 +432,16 @@ func GetSize(img *IplImage) Size {
} }
/* Copies source array to destination array */ /* Copies source array to destination array */
func Copy(src, dst, mask *IplImage) { func Copy(src, dst, mask unsafe.Pointer) {
C.cvCopy(unsafe.Pointer(src), unsafe.Pointer(dst), unsafe.Pointer(mask)) C.cvCopy(src, dst, 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) );
/* Clears all the array elements (sets them to 0) */ /* Clears all the array elements (sets them to 0) */
func Zero(img *IplImage) { func Zero(img unsafe.Pointer) {
C.cvSetZero(unsafe.Pointer(img)) C.cvSetZero(img)
} }
//CVAPI(void) cvSetZero( CvArr* arr ); //CVAPI(void) cvSetZero( CvArr* arr );
@ -531,44 +478,356 @@ func Not(src, dst *IplImage) {
* Dynamic data structures * * Dynamic data structures *
\****************************************************************************************/ \****************************************************************************************/
/* Calculates length of sequence slice (with support of negative indices). */
func SliceLength(slice Slice, seq *Seq) {
C.cvSliceLength(C.CvSlice(slice), (*C.CvSeq)(seq))
}
// CVAPI(int) cvSliceLength( CvSlice slice, const CvSeq* seq );
/* Creates new memory storage.
block_size == 0 means that default,
somewhat optimal size, is used (currently, it is 64K) */
func CreateMemStorage(block_size int) *MemStorage {
block := C.cvCreateMemStorage(C.int(block_size))
return (*MemStorage)(block)
}
// CVAPI() cvCreateMemStorage( int block_size CV_DEFAULT(0));
/* Creates a memory storage that will borrow memory blocks from parent storage */
func CreateChildMemStorage(parent *MemStorage) *MemStorage {
block := C.cvCreateChildMemStorage((*C.CvMemStorage)(parent))
return (*MemStorage)(block)
}
// CVAPI(CvMemStorage*) cvCreateChildMemStorage( CvMemStorage* parent );
/* Releases memory storage. All the children of a parent must be released before
the parent. A child storage returns all the blocks to parent when it is released */
func ReleaseMemStorage(storage *MemStorage) {
block := (*C.CvMemStorage)(storage)
C.cvReleaseMemStorage(&block)
}
// CVAPI(void) cvReleaseMemStorage( CvMemStorage** storage );
/* Clears memory storage. This is the only way(!!!) (besides cvRestoreMemStoragePos)
to reuse memory allocated for the storage - cvClearSeq,cvClearSet ...
do not free any memory.
A child storage returns all the blocks to the parent when it is cleared */
func ClearMemStorage(storage *MemStorage) {
C.cvClearMemStorage((*C.CvMemStorage)(storage))
}
// CVAPI(void) cvClearMemStorage( CvMemStorage* storage );
/* Remember a storage "free memory" position */
func SaveMemStoragePos(storage *MemStorage, pos *MemStoragePos) {
C.cvSaveMemStoragePos((*C.CvMemStorage)(storage), (*C.CvMemStoragePos)(pos))
}
// CVAPI(void) cvSaveMemStoragePos( const CvMemStorage* storage, CvMemStoragePos* pos );
/* Restore a storage "free memory" position */
func RestoreMemStoragePos(storage *MemStorage, pos *MemStoragePos) {
C.cvRestoreMemStoragePos((*C.CvMemStorage)(storage), (*C.CvMemStoragePos)(pos))
}
// CVAPI(void) cvRestoreMemStoragePos( CvMemStorage* storage, CvMemStoragePos* pos );
/* Allocates continuous buffer of the specified size in the storage */
func MemStorageAlloc(storage *MemStorage, size int) {
C.cvMemStorageAlloc((*C.CvMemStorage)(storage), C.size_t(size))
}
// CVAPI(void*) cvMemStorageAlloc( CvMemStorage* storage, size_t size );
/* Allocates string in memory storage */
func MemStorageAllocString(storage *MemStorage, name string, _len int) {
C.cvMemStorageAllocString((*C.CvMemStorage)(storage), C.CString(name), C.int(_len))
}
// CVAPI(CvString) cvMemStorageAllocString( CvMemStorage* storage, const char* ptr,
// int len CV_DEFAULT(-1) );
/* Creates new empty sequence that will reside in the specified storage */
func CreateSeq(seq_flags, header_size, elem_size int, storage *MemStorage) {
C.cvCreateSeq(C.int(seq_flags), C.size_t(header_size), C.size_t(elem_size), (*C.CvMemStorage)(storage))
}
//CVAPI(CvSeq*) cvCreateSeq( int seq_flags, size_t header_size,
// size_t elem_size, CvMemStorage* storage );
/* Removes all the elements from the sequence. The freed memory
can be reused later only by the same sequence unless cvClearMemStorage
or cvRestoreMemStoragePos is called */
func ClearSeq(seq *Seq) {
C.cvClearSeq((*C.CvSeq)(seq))
}
// CVAPI(void) cvClearSeq( CvSeq* seq );
/* Retrieves pointer to specified sequence element.
Negative indices are supported and mean counting from the end
(e.g -1 means the last sequence element) */
func GetSeqElem(seq *Seq, index int) *int8 {
el := C.cvGetSeqElem((*C.CvSeq)(seq), C.int(index))
return (*int8)(el)
}
// CVAPI(schar*) cvGetSeqElem( const CvSeq* seq, int index );
/* Calculates index of the specified sequence element.
Returns -1 if element does not belong to the sequence */
func SeqElemIdx(seq *Seq, el unsafe.Pointer, seqblock *SeqBlock) int {
cvseqblock := (*C.CvSeqBlock)(seqblock)
r := C.cvSeqElemIdx((*C.CvSeq)(seq), el, &cvseqblock)
return (int)(r)
}
// CVAPI(int) cvSeqElemIdx( const CvSeq* seq, const void* element,
// CvSeqBlock** block CV_DEFAULT(NULL) );
/* Extracts sequence slice (with or without copying sequence elements) */
func SeqSlice(seq *Seq, slice Slice, storage *MemStorage, copy_data int) *Seq {
r := C.cvSeqSlice((*C.CvSeq)(seq), C.CvSlice(slice), (*C.CvMemStorage)(storage), C.int(copy_data))
return (*Seq)(r)
}
// CVAPI(CvSeq*) cvSeqSlice( const CvSeq* seq, CvSlice slice,
// CvMemStorage* storage CV_DEFAULT(NULL),
// int copy_data CV_DEFAULT(0));
/* A wrapper for the somewhat more general routine cvSeqSlice() whuch
creates a deep copy of a sequence and creates another entirely separate
sequence structure.*/
func CloneSeq(seq *Seq, storage *MemStorage) *Seq {
r := C.cvSeqSlice((*C.CvSeq)(seq), (C.CvSlice)(CV_WHOLE_SEQ), (*C.CvMemStorage)(storage), C.int(1))
return (*Seq)(r)
}
// CV_INLINE CvSeq* cvCloneSeq( const CvSeq* seq, CvMemStorage* storage CV_DEFAULT(NULL))
// {
// return cvSeqSlice( seq, CV_WHOLE_SEQ, storage, 1 );
// }
/* Removes sequence slice */
func SeqRemoveSlice(seq *Seq, slice Slice) {
C.cvSeqRemoveSlice((*C.CvSeq)(seq), C.CvSlice(slice))
}
// CVAPI(void) cvSeqRemoveSlice( CvSeq* seq, CvSlice slice );
/* Inserts a sequence or array into another sequence */
func SeqInsertSlice(seq *Seq, before_index int, from_arr Arr) {
C.cvSeqInsertSlice((*C.CvSeq)(seq), C.int(before_index), unsafe.Pointer(from_arr))
}
// CVAPI(void) cvSeqInsertSlice( CvSeq* seq, int before_index, const CvArr* from_arr );
/* Sorts sequence in-place given element comparison function */
func SeqSort(seq *Seq, f CmpFunc, userdata unsafe.Pointer) {
fc := func(a C.CVoid, b C.CVoid, data unsafe.Pointer) int {
return f(unsafe.Pointer(a), unsafe.Pointer(b), data)
}
cmpFunc := C.GoOpenCV_CmpFunc(unsafe.Pointer(&fc))
C.cvSeqSort((*C.CvSeq)(seq), cmpFunc, unsafe.Pointer(userdata))
}
// CVAPI(void) cvSeqSort( CvSeq* seq, CvCmpFunc func, void* userdata CV_DEFAULT(NULL) );
/* Finds element in a [sorted] sequence */
func SeqSearch(seq *Seq, elem unsafe.Pointer, f CmpFunc, is_sorted int,
lem_idx *int32, userdata unsafe.Pointer) {
fc := func(a C.CVoid, b C.CVoid, userdata Arr) int {
return f(unsafe.Pointer(a), unsafe.Pointer(b), unsafe.Pointer(userdata))
}
cmpFunc := C.GoOpenCV_CmpFunc(unsafe.Pointer(&fc))
C.cvSeqSearch((*C.CvSeq)(seq), elem, cmpFunc,
C.int(is_sorted), (*C.int)(lem_idx), userdata)
}
// CVAPI(schar*) cvSeqSearch( CvSeq* seq, const void* elem, CvCmpFunc func,
// int is_sorted, int* elem_idx,
// void* userdata CV_DEFAULT(NULL) );
/* Reverses order of sequence elements in-place */
func SeqInvert(seq *Seq) {
C.cvSeqInvert((*C.CvSeq)(seq))
}
// CVAPI(void) cvSeqInvert( CvSeq* seq );
/* Splits sequence into one or more equivalence classes using the specified criteria */
func SeqPartition(seq *Seq, storage *MemStorage, labels **Seq,
f CmpFunc, userdata unsafe.Pointer) {
fc := func(a C.CVoid, b C.CVoid, userdata Arr) int {
return f(unsafe.Pointer(a), unsafe.Pointer(b), unsafe.Pointer(userdata))
}
cmpFunc := C.GoOpenCV_CmpFunc(unsafe.Pointer(&fc))
cvSeq := (*C.CvSeq)(*labels)
C.cvSeqPartition((*C.CvSeq)(seq), (*C.CvMemStorage)(storage), &cvSeq,
cmpFunc, userdata)
}
// CVAPI(int) cvSeqPartition( const CvSeq* seq, CvMemStorage* storage,
// CvSeq** labels, CvCmpFunc is_equal, void* );
/* Inserts a new element in the middle of sequence.
cvSeqInsert(seq,0,elem) == cvSeqPushFront(seq,elem) */
func SeqInsert(seq *Seq, before_index int, element unsafe.Pointer) *int8 {
r := C.cvSeqInsert((*C.CvSeq)(seq), C.int(before_index), element)
return (*int8)(r)
}
// CVAPI(schar*) cvSeqInsert( CvSeq* seq, int before_index,
// const void* element CV_DEFAULT(NULL));
/* Removes specified sequence element */
func SeqRemove(seq *Seq, index int) {
C.cvSeqRemove((*C.CvSeq)(seq), C.int(index))
}
// CVAPI(void) cvSeqRemove( CvSeq* seq, int index );
/* Changes default size (granularity) of sequence blocks.
The default size is ~1Kbyte */
func SetSeqBlockSize(seq *Seq, delta_elems int) {
C.cvSetSeqBlockSize((*C.CvSeq)(seq), C.int(delta_elems))
}
// CVAPI(void) cvSetSeqBlockSize( CvSeq* seq, int delta_elems );
/* Copies sequence content to a continuous piece of memory */
func CvtSeqToArray(seq *Seq, delta_elems unsafe.Pointer, slice Slice) {
C.cvCvtSeqToArray((*C.CvSeq)(seq), delta_elems, (C.CvSlice)(slice))
}
// CVAPI(void*) cvCvtSeqToArray( const CvSeq* seq, void* elements,
// CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ) );
/* Creates sequence header for array.
After that all the operations on sequences that do not alter the content
can be applied to the resultant sequence */
func MakeSeqHeaderForArray(seq_type, header_size, elem_size int,
elems unsafe.Pointer, total int, seq *Seq, block *SeqBlock) *Seq {
r := C.cvMakeSeqHeaderForArray(C.int(seq_type), C.int(header_size),
C.int(elem_size), elems, C.int(total), (*C.CvSeq)(seq),
(*C.CvSeqBlock)(block))
return (*Seq)(r)
}
// CVAPI(CvSeq*) cvMakeSeqHeaderForArray( int seq_type, int header_size,
// int elem_size, void* elements, int total,
// CvSeq* seq, CvSeqBlock* block );
/****************************************************************************************\ /****************************************************************************************\
* Drawing * * Drawing *
\****************************************************************************************/ \****************************************************************************************/
const CV_FILLED = C.CV_FILLED
/* Draws 4-connected, 8-connected or antialiased line segment connecting two points */ /* Draws 4-connected, 8-connected or antialiased line segment connecting two points */
//color Scalar, //color Scalar,
func Line(image *IplImage, pt1, pt2 Point, color Scalar, thickness, line_type, shift int) { func Line(image unsafe.Pointer, pt1, pt2 Point, color Scalar, thickness, line_type, shift int) {
C.cvLine( C.cvLine(image,
unsafe.Pointer(image),
C.cvPoint(C.int(pt1.X), C.int(pt1.Y)), C.cvPoint(C.int(pt1.X), C.int(pt1.Y)),
C.cvPoint(C.int(pt2.X), C.int(pt2.Y)), C.cvPoint(C.int(pt2.X), C.int(pt2.Y)),
(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),
) )
} }
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) );
/* Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2),
if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn */
func Rectangle(image unsafe.Pointer, pt1, pt2 Point, color Scalar, thickness, line_type, shift int) {
C.cvRectangle(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),
)
}
// CVAPI(void) cvRectangle( CvArr* img, CvPoint pt1, CvPoint pt2,
// CvScalar color, int thickness CV_DEFAULT(1),
// int line_type CV_DEFAULT(8),
// int shift CV_DEFAULT(0));
func Circle(image unsafe.Pointer, pt1 Point, r int, color Scalar, thickness, line_type, shift int) {
C.cvCircle(image,
C.cvPoint(C.int(pt1.X), C.int(pt1.Y)),
C.int(r),
(C.CvScalar)(color),
C.int(thickness), C.int(line_type), C.int(shift),
)
}
/* Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector,
depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure
is rotated by <angle>. All the angles are in degrees */
// CVAPI(void) cvEllipse( CvArr* img, CvPoint center, CvSize axes,
// double angle, double start_angle, double end_angle,
// CvScalar color, int thickness CV_DEFAULT(1),
// int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
func Ellipse(image unsafe.Pointer, center Point, axes Size, angle, start_angle, end_angle float64,
color Scalar, thickness, line_type, shift int) {
C.cvEllipse(image,
C.cvPoint(C.int(center.X), C.int(center.Y)),
C.cvSize(C.int(axes.Width), C.int(axes.Height)), C.double(angle),
C.double(start_angle), C.double(end_angle) ,(C.CvScalar)(color),
C.int(thickness), C.int(line_type), C.int(shift),
)
}
// CVAPI(void) cvDrawContours( CvArr *img, CvSeq* contour,
// CvScalar external_color, CvScalar hole_color,
// int max_level, int thickness CV_DEFAULT(1),
// int line_type CV_DEFAULT(8),
// CvPoint offset CV_DEFAULT(cvPoint(0,0)));
/* Draws contour outlines or filled interiors on the image */
func DrawContours(image unsafe.Pointer, contour *Seq, external_color Scalar,
hole_color Scalar, max_level, thickness, line_type int, offset Point) {
C.cvDrawContours(image,
(*C.CvSeq)(contour),
(C.CvScalar)(external_color),
(C.CvScalar)(hole_color),
C.int(max_level), C.int(thickness), C.int(line_type),
C.cvPoint(C.int(offset.X), C.int(offset.Y)),
)
}
const (
CV_FONT_HERSHEY_SIMPLEX = C.CV_FONT_HERSHEY_SIMPLEX
CV_FONT_HERSHEY_PLAIN = C.CV_FONT_HERSHEY_PLAIN
CV_FONT_HERSHEY_DUPLEX = C.CV_FONT_HERSHEY_DUPLEX
CV_FONT_HERSHEY_COMPLEX = C.CV_FONT_HERSHEY_COMPLEX
CV_FONT_HERSHEY_TRIPLEX = C.CV_FONT_HERSHEY_TRIPLEX
CV_FONT_HERSHEY_COMPLEX_SMALL = C.CV_FONT_HERSHEY_COMPLEX_SMALL
CV_FONT_HERSHEY_SCRIPT_SIMPLEX = C.CV_FONT_HERSHEY_SCRIPT_SIMPLEX
CV_FONT_HERSHEY_SCRIPT_COMPLEX = C.CV_FONT_HERSHEY_SCRIPT_COMPLEX
)
/* Renders text stroke with specified font and color at specified location.
CvFont should be initialized with cvInitFont */
// CVAPI(void) cvPutText( CvArr* img, const char* text, CvPoint org,
// const CvFont* font, CvScalar color );
func PutText(image unsafe.Pointer, text string, org Point, font_face int,
hscale, vscale, shear float64, thickness, line_type int, color Scalar){
// create CvFont sturucture
f := &C.CvFont{}
C.cvInitFont(f, C.int(font_face), C.double(hscale), C.double(vscale),
C.double(shear), C.int(thickness), C.int(line_type))
C.cvPutText(image, C.CString(text), C.cvPoint(C.int(org.X), C.int(org.Y)),
f, (C.CvScalar)(color))
}
/****************************************************************************************\ /****************************************************************************************\
* System functions * * System functions *
\****************************************************************************************/ \****************************************************************************************/
@ -576,3 +835,10 @@ func Circle(image *IplImage, pt1 Point, radius int, color Scalar, thickness, lin
/****************************************************************************************\ /****************************************************************************************\
* Data Persistence * * Data Persistence *
\****************************************************************************************/ \****************************************************************************************/
/*********************************** Adding own types ***********************************/
/* universal functions */
func Release(ptr unsafe.Pointer) { C.cvRelease(&ptr) }
// CVAPI(void) cvRelease( void** struct_ptr );

177
opencv/cxtype.go
View file

@ -1,12 +1,14 @@
// Copyright 2011 <chaishushan@gmail.com>. All rights reserved. // Copyright 2011 <chaishushan@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// 22/11/2013 Updated by <mohamd.helala@gmail.com>.
package opencv package opencv
/* /*
#cgo linux pkg-config: opencv #cgo linux pkg-config: opencv
#cgo darwin pkg-config: opencv #cgo darwin pkg-config: opencv
#cgo freebsd pkg-config: opencv
#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++ #cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++
#include "opencv.h" #include "opencv.h"
@ -53,7 +55,13 @@ static int myGetTermCriteriaType(const CvTermCriteria* x) {
return x->type; return x->type;
} }
#define CV_CHAIN_SIZE sizeof(CvChain)
#define CV_CONTOUR_SIZE sizeof(CvContour)
#define CV_SEQ_SIZE sizeof(CvSeq)
#define CV_SEQBLOCK_SIZE sizeof(CvSeqBlock)
#define CV_POINT_SIZE sizeof(CvPoint)
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
*/ */
import "C" import "C"
import ( import (
@ -136,7 +144,6 @@ const (
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// cxtypes.h // cxtypes.h
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
type Arr unsafe.Pointer type Arr unsafe.Pointer
/*****************************************************************************\ /*****************************************************************************\
@ -255,6 +262,9 @@ func (img *IplImage) ImageSize() int {
func (img *IplImage) ImageData() unsafe.Pointer { func (img *IplImage) ImageData() unsafe.Pointer {
return unsafe.Pointer(img.imageData) return unsafe.Pointer(img.imageData)
} }
func (img *IplImage) Ptr() unsafe.Pointer {
return unsafe.Pointer(img)
}
type IplROI C.IplROI type IplROI C.IplROI
@ -319,6 +329,55 @@ const (
* Matrix type (CvMat) * * Matrix type (CvMat) *
\****************************************************************************************/ \****************************************************************************************/
const(
CV_8U = C.CV_8U
CV_8S = C.CV_8S
CV_16U = C.CV_16U
CV_16S = C.CV_16S
CV_32S = C.CV_32S
CV_32F = C.CV_32F
CV_64F = C.CV_64F
CV_USRTYPE1 = C.CV_USRTYPE1
CV_MAT_DEPTH_MASK = C.CV_MAT_DEPTH_MASK
CV_8UC1 = C.CV_8UC1
CV_8UC2 = C.CV_8UC2
CV_8UC3 = C.CV_8UC3
CV_8UC4 = C.CV_8UC4
CV_8SC1 = C.CV_8SC1
CV_8SC2 = C.CV_8SC2
CV_8SC3 = C.CV_8SC3
CV_8SC4 = C.CV_8SC4
CV_16UC1 = C.CV_16UC1
CV_16UC2 = C.CV_16UC2
CV_16UC3 = C.CV_16UC3
CV_16UC4 = C.CV_16UC4
CV_16SC1 = C.CV_16SC1
CV_16SC2 = C.CV_16SC2
CV_16SC3 = C.CV_16SC3
CV_16SC4 = C.CV_16SC4
CV_32SC1 = C.CV_32SC1
CV_32SC2 = C.CV_32SC2
CV_32SC3 = C.CV_32SC3
CV_32SC4 = C.CV_32SC4
CV_32FC1 = C.CV_32FC1
CV_32FC2 = C.CV_32FC2
CV_32FC3 = C.CV_32FC3
CV_32FC4 = C.CV_32FC4
CV_64FC1 = C.CV_64FC1
CV_64FC2 = C.CV_64FC2
CV_64FC3 = C.CV_64FC3
CV_64FC4 = C.CV_64FC4
)
type Mat C.CvMat type Mat C.CvMat
func (mat *Mat) Type() int { func (mat *Mat) Type() int {
@ -337,6 +396,9 @@ func (mat *Mat) Rows() int {
func (mat *Mat) Cols() int { func (mat *Mat) Cols() int {
return int(mat.cols) return int(mat.cols)
} }
func (mat *Mat) Ptr() unsafe.Pointer {
return unsafe.Pointer(mat)
}
func CV_IS_MAT_HDR(mat interface{}) bool { func CV_IS_MAT_HDR(mat interface{}) bool {
return false return false
@ -551,6 +613,10 @@ func (x *TermCriteria) Epsilon() float64 {
/******************************* CvPoint and variants ***********************************/ /******************************* CvPoint and variants ***********************************/
const (
CV_POINT_SIZE = C.CV_POINT_SIZE
)
type Point struct { type Point struct {
X int X int
Y int Y int
@ -576,6 +642,11 @@ type Point3D64f struct {
Z float64 Z float64
} }
func GetPoint(p unsafe.Pointer) Point {
cvpt := (*C.CvPoint)(p)
return Point{int(cvpt.x), int(cvpt.y)}
}
/******************************** CvSize's & CvBox **************************************/ /******************************** CvSize's & CvBox **************************************/
type Size struct { type Size struct {
@ -600,6 +671,10 @@ type LineIterator C.CvLineIterator
type Slice C.CvSlice type Slice C.CvSlice
var (
CV_WHOLE_SEQ Slice = (Slice)(C.cvSlice(0, CV_WHOLE_SEQ_END_INDEX))
)
const ( const (
CV_WHOLE_SEQ_END_INDEX = C.CV_WHOLE_SEQ_END_INDEX CV_WHOLE_SEQ_END_INDEX = C.CV_WHOLE_SEQ_END_INDEX
) )
@ -628,6 +703,23 @@ func (s Scalar) Val() [4]float64 {
} }
} }
// CV_INLINE CvScalar cvScalarAll( double val0123 );
func ScalarN(val0, val1, val2, val3 float64) Scalar {
rv := C.cvScalar(C.double(val0), C.double(val1),
C.double(val2), C.double(val3))
return (Scalar)(rv)
}
// CV_INLINE CvScalar cvScalar( double val0, double val1 CV_DEFAULT(0),
// double val2 CV_DEFAULT(0), double val3 CV_DEFAULT(0));
func RealScalar(val0 float64) Scalar {
rv := C.cvRealScalar(C.double(val0))
return (Scalar)(rv)
}
// CV_INLINE CvScalar cvRealScalar( double val0 );
/****************************************************************************************\ /****************************************************************************************\
* Dynamic Data structures * * Dynamic Data structures *
\****************************************************************************************/ \****************************************************************************************/
@ -643,6 +735,84 @@ type MemStoragePos C.CvMemStoragePos
type SeqBlock C.CvSeqBlock type SeqBlock C.CvSeqBlock
type Seq C.CvSeq type Seq C.CvSeq
const (
CV_SEQ_SIZE = C.CV_SEQ_SIZE
CV_SEQBLOCK_SIZE = C.CV_SEQBLOCK_SIZE
)
func (seq *Seq) Count() int {
return int(seq.total)
}
func (seq *Seq) Ptr() unsafe.Pointer {
return unsafe.Pointer(seq)
}
func (seq *Seq) H_next() *Seq {
return (*Seq)(seq.h_next)
}
func (seq *Seq) H_prev() *Seq {
return (*Seq)(seq.h_prev)
}
/*
typedef struct CvSeq {
int flags; // miscellaneous flags
int header_size; // size of sequence header
CvSeq* h_prev; // previous sequence
CvSeq* h_next; // next sequence
CvSeq* v_prev; // 2nd previous sequence
CvSeq* v_next // 2nd next sequence
int total; // total number of elements
int elem_size; // size of sequence element in byte
char* block_max; // maximal bound of the last block
char* ptr; // current write pointer
int delta_elems; // how many elements allocated
// when the sequence grows
CvMemStorage* storage; // where the sequence is stored
CvSeqBlock* free_blocks; // free blocks list
CvSeqBlock* first; // pointer to the first sequence block
}*/
type CmpFunc func(a unsafe.Pointer, b unsafe.Pointer, userdata unsafe.Pointer) int
const (
CV_SEQ_ELTYPE_BITS = C.CV_SEQ_ELTYPE_BITS
CV_SEQ_ELTYPE_MASK = C.CV_SEQ_ELTYPE_MASK
CV_SEQ_ELTYPE_POINT = C.CV_SEQ_ELTYPE_POINT
CV_SEQ_ELTYPE_CODE = C.CV_SEQ_ELTYPE_CODE
CV_SEQ_ELTYPE_GENERIC = C.CV_SEQ_ELTYPE_GENERIC
CV_SEQ_ELTYPE_PTR = C.CV_SEQ_ELTYPE_PTR
CV_SEQ_ELTYPE_PPOINT = C.CV_SEQ_ELTYPE_PPOINT
CV_SEQ_ELTYPE_INDEX = C.CV_SEQ_ELTYPE_INDEX
CV_SEQ_ELTYPE_GRAPH_EDGE = C.CV_SEQ_ELTYPE_GRAPH_EDGE
CV_SEQ_ELTYPE_GRAPH_VERTEX = C.CV_SEQ_ELTYPE_GRAPH_VERTEX
CV_SEQ_ELTYPE_TRIAN_ATR = C.CV_SEQ_ELTYPE_TRIAN_ATR
CV_SEQ_ELTYPE_CONNECTED_COMP = C.CV_SEQ_ELTYPE_CONNECTED_COMP
CV_SEQ_ELTYPE_POINT3D = C.CV_SEQ_ELTYPE_POINT3D
CV_SEQ_KIND_BITS = C.CV_SEQ_KIND_BITS
CV_SEQ_KIND_MASK = C.CV_SEQ_KIND_MASK
/* types of sequences */
CV_SEQ_KIND_GENERIC = C.CV_SEQ_KIND_GENERIC
CV_SEQ_KIND_CURVE = C.CV_SEQ_KIND_CURVE
CV_SEQ_KIND_BIN_TREE = C.CV_SEQ_KIND_BIN_TREE
/* types of sparse sequences (sets) */
CV_SEQ_KIND_GRAPH = C.CV_SEQ_KIND_GRAPH
CV_SEQ_KIND_SUBDIV2D = C.CV_SEQ_KIND_SUBDIV2D
CV_SEQ_FLAG_SHIFT = C.CV_SEQ_FLAG_SHIFT
/* flags for curves */
CV_SEQ_FLAG_CLOSED = C.CV_SEQ_FLAG_CLOSED
CV_SEQ_FLAG_SIMPLE = C.CV_SEQ_FLAG_SIMPLE
CV_SEQ_FLAG_CONVEX = C.CV_SEQ_FLAG_CONVEX
CV_SEQ_FLAG_HOLE = C.CV_SEQ_FLAG_HOLE
)
/*************************************** Set ********************************************/ /*************************************** Set ********************************************/
type Set C.CvSet type Set C.CvSet
@ -660,6 +830,11 @@ type Graph C.CvGraph
type Chain C.CvChain type Chain C.CvChain
type Contour C.CvContour type Contour C.CvContour
const (
CV_CHAIN_SIZE = C.CV_CHAIN_SIZE
CV_CONTOUR_SIZE = C.CV_CONTOUR_SIZE
)
/****************************************************************************************\ /****************************************************************************************\
* Sequence types * * Sequence types *
\****************************************************************************************/ \****************************************************************************************/

5
opencv/goimage.go
View file

@ -67,9 +67,10 @@ func (img *IplImage) ToImage() image.Image {
for y := 0; y < img.Height(); y++ { for y := 0; y < img.Height(); y++ {
for x := 0; x < img.Width(); x++ { for x := 0; x < img.Width(); x++ {
s := img.Get2D(x, y).Val() s := img.Get2D(x, y).Val()
b, g, r, a := s[2], s[1], s[0], s[3]
c := color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(a)} b, g, r := s[0], s[1], s[2]
c := color.NRGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: uint8(255)}
out.Set(x, y, c) out.Set(x, y, c)
} }
} }

1
opencv/highgui.go
View file

@ -7,6 +7,7 @@ package opencv
//#include "opencv.h" //#include "opencv.h"
//#cgo linux pkg-config: opencv //#cgo linux pkg-config: opencv
//#cgo darwin pkg-config: opencv //#cgo darwin pkg-config: opencv
//#cgo freebsd 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 ( import (

269
opencv/imgproc.go
View file

@ -1,20 +1,119 @@
// Copyright 2013 jrweizhang AT gmail.com. All rights reserved. // Copyright 2014 <mohamed.helala@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// Merged with contributions by jrweizhang AT gmail.com.
// Bindings for Intel's OpenCV computer vision library.
package opencv package opencv
//#include "opencv.h" //#include "opencv.h"
//#cgo linux pkg-config: opencv //#cgo linux pkg-config: opencv
//#cgo darwin pkg-config: opencv //#cgo darwin pkg-config: opencv
//#cgo freebsd 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 ( import (
//"errors" //"errors"
//"log"
"unsafe" "unsafe"
) )
/*********************** Background statistics accumulation *****************************/
/****************************************************************************************\
* Image Processing *
\****************************************************************************************/
/* creates structuring element used for morphological operations
CVAPI(IplConvKernel*) cvCreateStructuringElementEx(
int cols, int rows, int anchor_x, int anchor_y,
int shape, int* values CV_DEFAULT(NULL) );*/
func CreateStructuringElementEx(cols, rows, anchor_x, anchor_y,
shape int, values *int32) *IplConvKernel{
kernel := C.cvCreateStructuringElementEx(C.int(cols), C.int(rows),
C.int(anchor_x), C.int(anchor_y), C.int(shape),
(*C.int)(values))
return (*IplConvKernel)(kernel)
}
/* releases structuring element
CVAPI(void) cvReleaseStructuringElement( IplConvKernel** element );*/
func ReleaseStructuringElement(kernel *IplConvKernel){
k := (*C.IplConvKernel)(kernel)
C.cvReleaseStructuringElement(&k)
}
/* erodes input image (applies minimum filter) one or more times.
If element pointer is NULL, 3x3 rectangular element is used
CVAPI(void) cvErode( const CvArr* src, CvArr* dst,
IplConvKernel* element CV_DEFAULT(NULL),
int iterations CV_DEFAULT(1) );*/
func Erode(src, dst unsafe.Pointer, kernel *IplConvKernel,
iterations int){
C.cvErode(src, dst, (*C.IplConvKernel)(kernel), C.int(iterations))
}
/* dilates input image (applies maximum filter) one or more times.
If element pointer is NULL, 3x3 rectangular element is used
CVAPI(void) cvDilate( const CvArr* src, CvArr* dst,
IplConvKernel* element CV_DEFAULT(NULL),
int iterations CV_DEFAULT(1) );*/
func Dilate(src, dst unsafe.Pointer, kernel *IplConvKernel,
iterations int){
C.cvDilate(src, dst, (*C.IplConvKernel)(kernel), C.int(iterations))
}
/* Performs complex morphological transformation
CVAPI(void) cvMorphologyEx( const CvArr* src, CvArr* dst,
CvArr* temp, IplConvKernel* element,
int operation, int iterations CV_DEFAULT(1) );*/
func MorphologyEx(src, dst, temp unsafe.Pointer, kernel *IplConvKernel,
operation, iterations int){
C.cvMorphologyEx(src, dst, temp, (*C.IplConvKernel)(kernel),
C.int(operation), C.int(iterations))
}
/* Calculates all spatial and central moments up to the 3rd order
CVAPI(void) cvMoments( const CvArr* arr, CvMoments* moments, int binary CV_DEFAULT(0));*/
func GetMoments(arr unsafe.Pointer, moms *Moments, binary int){
C.cvMoments(arr, (*C.CvMoments)(moms), C.int(binary))
}
/* Retrieve particular spatial, central or normalized central moments */
/*CVAPI(double) cvGetSpatialMoment( CvMoments* moments, int x_order, int y_order );*/
func GetSpatialMoment(moms *Moments, x_order, y_order int) float64{
value := C.cvGetSpatialMoment((*C.CvMoments)(moms),
C.int(x_order), C.int(y_order))
return float64(value)
}
/*CVAPI(double) cvGetCentralMoment( CvMoments* moments, int x_order, int y_order );*/
func GetCentralMoment(moms *Moments, x_order, y_order int) float64{
value := C.cvGetCentralMoment((*C.CvMoments)(moms),
C.int(x_order), C.int(y_order))
return float64(value)
}
/*CVAPI(double) cvGetNormalizedCentralMoment( CvMoments* moments,
int x_order, int y_order );*/
func GetNormalizedCentralMoment(moms *Moments, x_order, y_order int) float64{
value := C.cvGetNormalizedCentralMoment((*C.CvMoments)(moms),
C.int(x_order), C.int(y_order))
return float64(value)
}
/* Calculates 7 Hu's invariants from precalculated spatial and central moments*/
/*CVAPI(void) cvGetHuMoments( CvMoments* moments, CvHuMoments* hu_moments );*/
func GetHuMoments(moms *Moments, hu_moms *HuMoments){
C.cvGetHuMoments((*C.CvMoments)(moms),
(*C.CvHuMoments)(hu_moms))
}
/* CVAPI(void) cvResize( const CvArr* src, CvArr* dst,
int interpolation CV_DEFAULT( CV_INTER_LINEAR ));*/
func Resize(src *IplImage, width, height, interpolation int) *IplImage { func Resize(src *IplImage, width, height, interpolation int) *IplImage {
if width == 0 && height == 0 { if width == 0 && height == 0 {
panic("Width and Height cannot be 0 at the same time") panic("Width and Height cannot be 0 at the same time")
@ -31,3 +130,169 @@ func Resize(src *IplImage, width, height, interpolation int) *IplImage {
C.cvResize(unsafe.Pointer(src), unsafe.Pointer(dst), C.int(interpolation)) C.cvResize(unsafe.Pointer(src), unsafe.Pointer(dst), C.int(interpolation))
return dst return dst
} }
func Crop(src *IplImage, x, y, width, height int) *IplImage {
r := C.cvRect(C.int(x), C.int(y), C.int(width), C.int(height))
rect := Rect(r)
src.SetROI(rect)
dest := CreateImage(width, height, src.Depth(), src.Channels())
Copy(src.Ptr(), dest.Ptr(), nil)
src.ResetROI()
return dest
}
/*********************************** data sampling **************************************/
/****************************************************************************************\
* Contours retrieving *
\****************************************************************************************/
/* Retrieves outer and optionally inner boundaries of white (non-zero) connected
components in the black (zero) background
Default Value: header_size = sizeof(CvContour),
mode = CV_RETR_LIST,
method = CV_CHAIN_APPROX_SIMPLE,
offset = cvPoint(0,0))*/
func FindContours(image unsafe.Pointer, storage *MemStorage, first_contour **Seq,
header_size int, mode int, method int, offset Point) int {
cvSeq := (*C.CvSeq)(*first_contour)
r := C.cvFindContours(image, (*C.CvMemStorage)(storage),
&cvSeq, C.int(header_size), C.int(mode), C.int(method),
C.cvPoint(C.int(offset.X), C.int(offset.Y)))
(*first_contour) = (*Seq)(cvSeq)
return int(r)
}
// CVAPI(int) cvFindContours( CvArr* image, CvMemStorage* storage, CvSeq** first_contour,
// int header_size CV_DEFAULT(sizeof(CvContour)),
// int mode CV_DEFAULT(CV_RETR_LIST),
// int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
// CvPoint offset CV_DEFAULT(cvPoint(0,0)));
/* Initalizes contour retrieving process.
Calls cvStartFindContours.
Calls cvFindNextContour until null pointer is returned
or some other condition becomes true.
Calls cvEndFindContours at the end. */
func StartFindContours(image unsafe.Pointer, storage *MemStorage,
header_size int, mode int, method int, offset Point) *ContourScanner {
scanner := C.cvStartFindContours(image, (*C.CvMemStorage)(storage),
C.int(header_size), C.int(mode), C.int(method),
C.cvPoint(C.int(offset.X), C.int(offset.Y)))
return (*ContourScanner)(&scanner)
}
// CVAPI(CvContourScanner) cvStartFindContours( CvArr* image, CvMemStorage* storage,
// int header_size CV_DEFAULT(sizeof(CvContour)),
// int mode CV_DEFAULT(CV_RETR_LIST),
// int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
// CvPoint offset CV_DEFAULT(cvPoint(0,0)));
/* Retrieves next contour */
func FindNextContour(scanner *ContourScanner) *Seq {
r := C.cvFindNextContour(C.CvContourScanner(*scanner))
return (*Seq)(r)
}
// CVAPI(CvSeq*) cvFindNextContour( CvContourScanner scanner );
/* Substitutes the last retrieved contour with the new one
(if the substitutor is null, the last retrieved contour is removed from the tree) */
func SubstituteContour(scanner *ContourScanner, new_contour *Seq) {
C.cvSubstituteContour(C.CvContourScanner(*scanner), (*C.CvSeq)(new_contour))
}
// CVAPI(void) cvSubstituteContour( CvContourScanner scanner, CvSeq* new_contour );
/* Releases contour scanner and returns pointer to the first outer contour */
func EndFindContours(scanner *ContourScanner) *Seq {
r := C.cvEndFindContours((*C.CvContourScanner)(scanner))
return (*Seq)(r)
}
// CVAPI(CvSeq*) cvEndFindContours( CvContourScanner* scanner );
/* Approximates a single Freeman chain or a tree of chains to polygonal curves */
func ApproxChains(src_seq *Seq, storage *MemStorage, method int, parameter float64,
minimal_perimeter int, recursive int) *Seq {
r := C.cvApproxChains((*C.CvSeq)(src_seq), (*C.CvMemStorage)(storage), C.int(method),
C.double(parameter), C.int(minimal_perimeter), C.int(recursive))
return (*Seq)(r)
}
// CVAPI(CvSeq*) cvApproxChains( CvSeq* src_seq, CvMemStorage* storage,
// int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
// double parameter CV_DEFAULT(0),
// int minimal_perimeter CV_DEFAULT(0),
// int recursive CV_DEFAULT(0));
/* Initalizes Freeman chain reader.
The reader is used to iteratively get coordinates of all the chain points.
If the Freeman codes should be read as is, a simple sequence reader should be used */
func StartReadChainPoints(chain *Chain, reader *ChainPtReader) {
C.cvStartReadChainPoints((*C.CvChain)(chain), (*C.CvChainPtReader)(reader))
}
// CVAPI(void) cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
/* Retrieves the next chain point */
func ReadChainPoint(reader *ChainPtReader) *Point {
r := C.cvReadChainPoint((*C.CvChainPtReader)(reader))
p := &Point{int(r.x), int(r.y)}
return p
}
// CVAPI(CvPoint) cvReadChainPoint( CvChainPtReader* reader );
/****************************************************************************************\
* Contour Processing and Shape Analysis *
\****************************************************************************************/
/* Calculates perimeter of a contour*/
func ContourPerimeter(seq unsafe.Pointer) float64 {
r := C.cvContourPerimeter(seq)
return (float64)(r)
}
// CV_INLINE double cvContourPerimeter( const void* contour )
// {
// return cvArcLength( contour, CV_WHOLE_SEQ, 1 );
// }
/* Approximates a single polygonal curve (contour) or
a tree of polygonal curves (contours)
Default Values: recursive = 0*/
func ApproxPoly(src_seq unsafe.Pointer, header_size int, storage *MemStorage,
method int, eps float64, recursive int) *Seq {
r := C.cvApproxPoly(src_seq, C.int(header_size), (*C.CvMemStorage)(storage),
C.int(method), C.double(eps), C.int(recursive))
return (*Seq)(r)
}
// CVAPI(CvSeq*) cvApproxPoly( const void* src_seq,
// int header_size, CvMemStorage* storage,
// int method, double eps,
// int recursive CV_DEFAULT(0));
/****************************************************************************************\
* Histogram functions *
\****************************************************************************************/
/* Applies fixed-level threshold to grayscale image.
This is a basic operation applied before retrieving contours */
func Threshold(src unsafe.Pointer, dst unsafe.Pointer,
threshold, max_value float64, threshold_type int) float64 {
r := C.cvThreshold(src, dst, C.double(threshold),
C.double(max_value), C.int(threshold_type))
return float64(r)
}
// CVAPI(double) cvThreshold( const CvArr* src, CvArr* dst,
// double threshold, double max_value,
// int threshold_type );
/****************************************************************************************\
* Feature detection *
\****************************************************************************************/

57
opencv/imgproc_test.go Normal file
View file

@ -0,0 +1,57 @@
package opencv
import (
"path"
"runtime"
"testing"
)
func TestResize(t *testing.T) {
_, currentfile, _, _ := runtime.Caller(0)
filename := path.Join(path.Dir(currentfile), "../images/lena.jpg")
image := LoadImage(filename)
if image == nil {
t.Fatal("LoadImage fail")
}
defer image.Release()
rimage := Resize(image, 10, 10, CV_INTER_LINEAR)
if rimage == nil {
t.Fatal("Resize fail")
}
defer rimage.Release()
if rimage.Width() != 10 {
t.Fatalf("excepted width is 10, returned %d\n", rimage.Width())
}
if rimage.Height() != 10 {
t.Fatalf("excepted width is 10, returned %d\n", rimage.Height())
}
}
func TestCrop(t *testing.T) {
_, currentfile, _, _ := runtime.Caller(0)
filename := path.Join(path.Dir(currentfile), "../images/lena.jpg")
image := LoadImage(filename)
if image == nil {
t.Fatal("LoadImage fail")
}
defer image.Release()
crop := Crop(image, 0, 0, 200, 200)
if crop == nil {
t.Fatal("Crop fail")
}
defer crop.Release()
if crop.Width() != 200 {
t.Fatalf("excepted width is 200, returned %d\n", crop.Width())
}
if crop.Height() != 200 {
t.Fatalf("excepted width is 200, returned %d\n", crop.Height())
}
}

574
opencv/imgptype.go Normal file
View file

@ -0,0 +1,574 @@
// Copyright 2014 <mohamed.helala@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Bindings for Intel's OpenCV computer vision library.
package opencv
//#include "opencv.h"
//#cgo linux pkg-config: opencv
//#cgo darwin pkg-config: opencv
//#cgo freebsd pkg-config: opencv
//#cgo windows LDFLAGS: -lopencv_core242.dll -lopencv_imgproc242.dll -lopencv_photo242.dll -lopencv_highgui242.dll -lstdc++
import "C"
/* Connected component structure */
type ConnectedComp C.CvConnectedComp
/*
// {
// double area; area of the connected component
// CvScalar value; average color of the connected component
// CvRect rect; ROI of the component
// CvSeq* contour; optional component boundary
// (the contour might have child contours corresponding to the holes)
// }
*/
// /* Image smooth methods */
const (
CV_BLUR_NO_SCALE = C.CV_BLUR_NO_SCALE
CV_BLUR = C.CV_BLUR
CV_GAUSSIAN = C.CV_GAUSSIAN
CV_MEDIAN = C.CV_MEDIAN
CV_BILATERAL = C.CV_BILATERAL
)
// /* Filters used in pyramid decomposition */
const (
CV_GAUSSIAN_5x5 = C.CV_GAUSSIAN_5x5
)
// /* Special filters */
const (
CV_SCHARR = C.CV_SCHARR
CV_MAX_SOBEL_KSIZE = C.CV_MAX_SOBEL_KSIZE
)
// /* Constants for color conversion */
const (
CV_BGR2BGRA = C.CV_BGR2BGRA
CV_RGB2RGBA = C.CV_RGB2RGBA
CV_BGRA2BGR = C.CV_BGRA2BGR
CV_RGBA2RGB = C.CV_RGBA2RGB
CV_BGR2RGBA = C.CV_BGR2RGBA
CV_RGB2BGRA = C.CV_RGB2BGRA
CV_RGBA2BGR = C.CV_RGBA2BGR
CV_BGRA2RGB = C.CV_BGRA2RGB
CV_BGR2RGB = C.CV_BGR2RGB
CV_RGB2BGR = C.CV_RGB2BGR
CV_BGRA2RGBA = C.CV_BGRA2RGBA
CV_RGBA2BGRA = C.CV_RGBA2BGRA
CV_BGR2GRAY = C.CV_BGR2GRAY
CV_RGB2GRAY = C.CV_RGB2GRAY
CV_GRAY2BGR = C.CV_GRAY2BGR
CV_GRAY2RGB = C.CV_GRAY2RGB
CV_GRAY2BGRA = C.CV_GRAY2BGRA
CV_GRAY2RGBA = C.CV_GRAY2RGBA
CV_BGRA2GRAY = C.CV_BGRA2GRAY
CV_RGBA2GRAY = C.CV_RGBA2GRAY
CV_BGR2BGR565 = C.CV_BGR2BGR565
CV_RGB2BGR565 = C.CV_RGB2BGR565
CV_BGR5652BGR = C.CV_BGR5652BGR
CV_BGR5652RGB = C.CV_BGR5652RGB
CV_BGRA2BGR565 = C.CV_BGRA2BGR565
CV_RGBA2BGR565 = C.CV_RGBA2BGR565
CV_BGR5652BGRA = C.CV_BGR5652BGRA
CV_BGR5652RGBA = C.CV_BGR5652RGBA
CV_GRAY2BGR565 = C.CV_GRAY2BGR565
CV_BGR5652GRAY = C.CV_BGR5652GRAY
CV_BGR2BGR555 = C.CV_BGR2BGR555
CV_RGB2BGR555 = C.CV_RGB2BGR555
CV_BGR5552BGR = C.CV_BGR5552BGR
CV_BGR5552RGB = C.CV_BGR5552RGB
CV_BGRA2BGR555 = C.CV_BGRA2BGR555
CV_RGBA2BGR555 = C.CV_RGBA2BGR555
CV_BGR5552BGRA = C.CV_BGR5552BGRA
CV_BGR5552RGBA = C.CV_BGR5552RGBA
CV_GRAY2BGR555 = C.CV_GRAY2BGR555
CV_BGR5552GRAY = C.CV_BGR5552GRAY
CV_BGR2XYZ = C.CV_BGR2XYZ
CV_RGB2XYZ = C.CV_RGB2XYZ
CV_XYZ2BGR = C.CV_XYZ2BGR
CV_XYZ2RGB = C.CV_XYZ2RGB
CV_BGR2YCrCb = C.CV_BGR2YCrCb
CV_RGB2YCrCb = C.CV_RGB2YCrCb
CV_YCrCb2BGR = C.CV_YCrCb2BGR
CV_YCrCb2RGB = C.CV_YCrCb2RGB
CV_BGR2HSV = C.CV_BGR2HSV
CV_RGB2HSV = C.CV_RGB2HSV
CV_BGR2Lab = C.CV_BGR2Lab
CV_RGB2Lab = C.CV_RGB2Lab
CV_BayerBG2BGR = C.CV_BayerBG2BGR
CV_BayerGB2BGR = C.CV_BayerGB2BGR
CV_BayerRG2BGR = C.CV_BayerRG2BGR
CV_BayerGR2BGR = C.CV_BayerGR2BGR
CV_BayerBG2RGB = C.CV_BayerBG2RGB
CV_BayerGB2RGB = C.CV_BayerGB2RGB
CV_BayerRG2RGB = C.CV_BayerRG2RGB
CV_BayerGR2RGB = C.CV_BayerGR2RGB
CV_BGR2Luv = C.CV_BGR2Luv
CV_RGB2Luv = C.CV_RGB2Luv
CV_BGR2HLS = C.CV_BGR2HLS
CV_RGB2HLS = C.CV_RGB2HLS
CV_HSV2BGR = C.CV_HSV2BGR
CV_HSV2RGB = C.CV_HSV2RGB
CV_Lab2BGR = C.CV_Lab2BGR
CV_Lab2RGB = C.CV_Lab2RGB
CV_Luv2BGR = C.CV_Luv2BGR
CV_Luv2RGB = C.CV_Luv2RGB
CV_HLS2BGR = C.CV_HLS2BGR
CV_HLS2RGB = C.CV_HLS2RGB
CV_BayerBG2BGR_VNG = C.CV_BayerBG2BGR_VNG
CV_BayerGB2BGR_VNG = C.CV_BayerGB2BGR_VNG
CV_BayerRG2BGR_VNG = C.CV_BayerRG2BGR_VNG
// CV_BayerGR2BGR_VNG =65,
// CV_BayerBG2RGB_VNG =CV_BayerRG2BGR_VNG,
// CV_BayerGB2RGB_VNG =CV_BayerGR2BGR_VNG,
// CV_BayerRG2RGB_VNG =CV_BayerBG2BGR_VNG,
// CV_BayerGR2RGB_VNG =CV_BayerGB2BGR_VNG,
// CV_BGR2HSV_FULL = 66,
// CV_RGB2HSV_FULL = 67,
// CV_BGR2HLS_FULL = 68,
// CV_RGB2HLS_FULL = 69,
// CV_HSV2BGR_FULL = 70,
// CV_HSV2RGB_FULL = 71,
// CV_HLS2BGR_FULL = 72,
// CV_HLS2RGB_FULL = 73,
// CV_LBGR2Lab = 74,
// CV_LRGB2Lab = 75,
// CV_LBGR2Luv = 76,
// CV_LRGB2Luv = 77,
// CV_Lab2LBGR = 78,
// CV_Lab2LRGB = 79,
// CV_Luv2LBGR = 80,
// CV_Luv2LRGB = 81,
// CV_BGR2YUV = 82,
// CV_RGB2YUV = 83,
// CV_YUV2BGR = 84,
// CV_YUV2RGB = 85,
// CV_BayerBG2GRAY = 86,
// CV_BayerGB2GRAY = 87,
// CV_BayerRG2GRAY = 88,
// CV_BayerGR2GRAY = 89,
// //YUV 4:2:0 formats family
// CV_YUV2RGB_NV12 = 90,
// CV_YUV2BGR_NV12 = 91,
// CV_YUV2RGB_NV21 = 92,
// CV_YUV2BGR_NV21 = 93,
// CV_YUV420sp2RGB = CV_YUV2RGB_NV21,
// CV_YUV420sp2BGR = CV_YUV2BGR_NV21,
// CV_YUV2RGBA_NV12 = 94,
// CV_YUV2BGRA_NV12 = 95,
// CV_YUV2RGBA_NV21 = 96,
// CV_YUV2BGRA_NV21 = 97,
// CV_YUV420sp2RGBA = CV_YUV2RGBA_NV21,
// CV_YUV420sp2BGRA = CV_YUV2BGRA_NV21,
// CV_YUV2RGB_YV12 = 98,
// CV_YUV2BGR_YV12 = 99,
// CV_YUV2RGB_IYUV = 100,
// CV_YUV2BGR_IYUV = 101,
// CV_YUV2RGB_I420 = CV_YUV2RGB_IYUV,
// CV_YUV2BGR_I420 = CV_YUV2BGR_IYUV,
// CV_YUV420p2RGB = CV_YUV2RGB_YV12,
// CV_YUV420p2BGR = CV_YUV2BGR_YV12,
// CV_YUV2RGBA_YV12 = 102,
// CV_YUV2BGRA_YV12 = 103,
// CV_YUV2RGBA_IYUV = 104,
// CV_YUV2BGRA_IYUV = 105,
// CV_YUV2RGBA_I420 = CV_YUV2RGBA_IYUV,
// CV_YUV2BGRA_I420 = CV_YUV2BGRA_IYUV,
// CV_YUV420p2RGBA = CV_YUV2RGBA_YV12,
// CV_YUV420p2BGRA = CV_YUV2BGRA_YV12,
// CV_YUV2GRAY_420 = 106,
// CV_YUV2GRAY_NV21 = CV_YUV2GRAY_420,
// CV_YUV2GRAY_NV12 = CV_YUV2GRAY_420,
// CV_YUV2GRAY_YV12 = CV_YUV2GRAY_420,
// CV_YUV2GRAY_IYUV = CV_YUV2GRAY_420,
// CV_YUV2GRAY_I420 = CV_YUV2GRAY_420,
// CV_YUV420sp2GRAY = CV_YUV2GRAY_420,
// CV_YUV420p2GRAY = CV_YUV2GRAY_420,
// //YUV 4:2:2 formats family
// CV_YUV2RGB_UYVY = 107,
// CV_YUV2BGR_UYVY = 108,
// //CV_YUV2RGB_VYUY = 109,
// //CV_YUV2BGR_VYUY = 110,
// CV_YUV2RGB_Y422 = CV_YUV2RGB_UYVY,
// CV_YUV2BGR_Y422 = CV_YUV2BGR_UYVY,
// CV_YUV2RGB_UYNV = CV_YUV2RGB_UYVY,
// CV_YUV2BGR_UYNV = CV_YUV2BGR_UYVY,
// CV_YUV2RGBA_UYVY = 111,
// CV_YUV2BGRA_UYVY = 112,
// //CV_YUV2RGBA_VYUY = 113,
// //CV_YUV2BGRA_VYUY = 114,
// CV_YUV2RGBA_Y422 = CV_YUV2RGBA_UYVY,
// CV_YUV2BGRA_Y422 = CV_YUV2BGRA_UYVY,
// CV_YUV2RGBA_UYNV = CV_YUV2RGBA_UYVY,
// CV_YUV2BGRA_UYNV = CV_YUV2BGRA_UYVY,
// CV_YUV2RGB_YUY2 = 115,
// CV_YUV2BGR_YUY2 = 116,
// CV_YUV2RGB_YVYU = 117,
// CV_YUV2BGR_YVYU = 118,
// CV_YUV2RGB_YUYV = CV_YUV2RGB_YUY2,
// CV_YUV2BGR_YUYV = CV_YUV2BGR_YUY2,
// CV_YUV2RGB_YUNV = CV_YUV2RGB_YUY2,
// CV_YUV2BGR_YUNV = CV_YUV2BGR_YUY2,
// CV_YUV2RGBA_YUY2 = 119,
// CV_YUV2BGRA_YUY2 = 120,
// CV_YUV2RGBA_YVYU = 121,
// CV_YUV2BGRA_YVYU = 122,
// CV_YUV2RGBA_YUYV = CV_YUV2RGBA_YUY2,
// CV_YUV2BGRA_YUYV = CV_YUV2BGRA_YUY2,
// CV_YUV2RGBA_YUNV = CV_YUV2RGBA_YUY2,
// CV_YUV2BGRA_YUNV = CV_YUV2BGRA_YUY2,
// CV_YUV2GRAY_UYVY = 123,
// CV_YUV2GRAY_YUY2 = 124,
// //CV_YUV2GRAY_VYUY = CV_YUV2GRAY_UYVY,
// CV_YUV2GRAY_Y422 = CV_YUV2GRAY_UYVY,
// CV_YUV2GRAY_UYNV = CV_YUV2GRAY_UYVY,
// CV_YUV2GRAY_YVYU = CV_YUV2GRAY_YUY2,
// CV_YUV2GRAY_YUYV = CV_YUV2GRAY_YUY2,
// CV_YUV2GRAY_YUNV = CV_YUV2GRAY_YUY2,
// // alpha premultiplication
// CV_RGBA2mRGBA = 125,
// CV_mRGBA2RGBA = 126,
// CV_COLORCVT_MAX = 127
)
// /* Sub-pixel interpolation methods */
const (
CV_INTER_NN = C.CV_INTER_NN
CV_INTER_LINEAR = C.CV_INTER_LINEAR
CV_INTER_CUBIC = C.CV_INTER_CUBIC
CV_INTER_AREA = C.CV_INTER_AREA
CV_INTER_LANCZOS4 = C.CV_INTER_LANCZOS4
)
// /* ... and other image warping flags */
const (
CV_WARP_FILL_OUTLIERS = C.CV_WARP_FILL_OUTLIERS
CV_WARP_INVERSE_MAP = C.CV_WARP_INVERSE_MAP
)
// /* Shapes of a structuring element for morphological operations */
const (
CV_SHAPE_RECT = C.CV_SHAPE_RECT
CV_SHAPE_CROSS = C.CV_SHAPE_CROSS
CV_SHAPE_ELLIPSE = C.CV_SHAPE_ELLIPSE
CV_SHAPE_CUSTOM = C.CV_SHAPE_CUSTOM
)
// /* Morphological operations */
const (
CV_MOP_ERODE = C.CV_MOP_ERODE
CV_MOP_DILATE = C.CV_MOP_DILATE
CV_MOP_OPEN = C.CV_MOP_OPEN
CV_MOP_CLOSE = C.CV_MOP_CLOSE
CV_MOP_GRADIENT = C.CV_MOP_GRADIENT
CV_MOP_TOPHAT = C.CV_MOP_TOPHAT
CV_MOP_BLACKHAT = C.CV_MOP_BLACKHAT
)
// /* Spatial and central moments */
type Moments C.CvMoments
// typedef struct CvMoments
// {
// double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03; /* spatial moments */
// double mu20, mu11, mu02, mu30, mu21, mu12, mu03; /* central moments */
// double inv_sqrt_m00; /* m00 != 0 ? 1/sqrt(m00) : 0 */
// }
// /* Hu invariants */
type HuMoments C.CvHuMoments
// typedef struct CvHuMoments
// {
// double hu1, hu2, hu3, hu4, hu5, hu6, hu7; /* Hu invariants */
// }
// /* Template matching methods */
const (
CV_TM_SQDIFF = C.CV_TM_SQDIFF
CV_TM_SQDIFF_NORMED = C.CV_TM_SQDIFF_NORMED
CV_TM_CCORR = C.CV_TM_CCORR
CV_TM_CCORR_NORMED = C.CV_TM_CCORR_NORMED
CV_TM_CCOEFF = C.CV_TM_CCOEFF
CV_TM_CCOEFF_NORMED = C.CV_TM_CCOEFF_NORMED
)
// typedef float (CV_CDECL * CvDistanceFunction)( const float* a, const float* b, void* user_param );
/* Contour retrieval modes */
const (
CV_RETR_EXTERNAL = C.CV_RETR_EXTERNAL
CV_RETR_LIST = C.CV_RETR_LIST
CV_RETR_CCOMP = C.CV_RETR_CCOMP
CV_RETR_TREE = C.CV_RETR_TREE
CV_RETR_FLOODFILL = C.CV_RETR_FLOODFILL
)
// /* Contour approximation methods */
const (
CV_CHAIN_CODE = C.CV_CHAIN_CODE
CV_CHAIN_APPROX_NONE = C.CV_CHAIN_APPROX_NONE
CV_CHAIN_APPROX_SIMPLE = C.CV_CHAIN_APPROX_SIMPLE
CV_CHAIN_APPROX_TC89_L1 = C.CV_CHAIN_APPROX_TC89_L1
CV_CHAIN_APPROX_TC89_KCOS = C.CV_CHAIN_APPROX_TC89_KCOS
CV_LINK_RUNS = C.CV_LINK_RUNS
)
// /*
// Internal structure that is used for sequental retrieving contours from the image.
// It supports both hierarchical and plane variants of Suzuki algorithm.
// */
type ContourScanner C.CvContourScanner
// typedef struct _CvContourScanner* CvContourScanner;
// /* Freeman chain reader state */
type ChainPtReader C.CvChainPtReader
// typedef struct CvChainPtReader
// {
// CV_SEQ_READER_FIELDS()
// char code;
// CvPoint pt;
// schar deltas[8][2];
// }
// CvChainPtReader;
// /* initializes 8-element array for fast access to 3x3 neighborhood of a pixel */
// #define CV_INIT_3X3_DELTAS( deltas, step, nch ) \
// ((deltas)[0] = (nch), (deltas)[1] = -(step) + (nch), \
// (deltas)[2] = -(step), (deltas)[3] = -(step) - (nch), \
// (deltas)[4] = -(nch), (deltas)[5] = (step) - (nch), \
// (deltas)[6] = (step), (deltas)[7] = (step) + (nch))
// /****************************************************************************************\
// * Planar subdivisions *
// \****************************************************************************************/
// typedef size_t CvSubdiv2DEdge;
// #define CV_QUADEDGE2D_FIELDS() \
// int flags; \
// struct CvSubdiv2DPoint* pt[4]; \
// CvSubdiv2DEdge next[4];
// #define CV_SUBDIV2D_POINT_FIELDS()\
// int flags; \
// CvSubdiv2DEdge first; \
// CvPoint2D32f pt; \
// int id;
// #define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30)
type QuadEdge2D C.CvQuadEdge2D
// typedef struct CvQuadEdge2D
// {
// CV_QUADEDGE2D_FIELDS()
// }
// CvQuadEdge2D;
type Subdiv2DPoint C.CvSubdiv2DPoint
// typedef struct CvSubdiv2DPoint
// {
// CV_SUBDIV2D_POINT_FIELDS()
// }
// CvSubdiv2DPoint;
// #define CV_SUBDIV2D_FIELDS() \
// CV_GRAPH_FIELDS() \
// int quad_edges; \
// int is_geometry_valid; \
// CvSubdiv2DEdge recent_edge; \
// CvPoint2D32f topleft; \
// CvPoint2D32f bottomright;
// typedef struct CvSubdiv2D
// {
// CV_SUBDIV2D_FIELDS()
// }
// CvSubdiv2D;
// typedef enum CvSubdiv2DPointLocation
// {
// CV_PTLOC_ERROR = -2,
// CV_PTLOC_OUTSIDE_RECT = -1,
// CV_PTLOC_INSIDE = 0,
// CV_PTLOC_VERTEX = 1,
// CV_PTLOC_ON_EDGE = 2
// }
// CvSubdiv2DPointLocation;
// typedef enum CvNextEdgeType
// {
// CV_NEXT_AROUND_ORG = 0x00,
// CV_NEXT_AROUND_DST = 0x22,
// CV_PREV_AROUND_ORG = 0x11,
// CV_PREV_AROUND_DST = 0x33,
// CV_NEXT_AROUND_LEFT = 0x13,
// CV_NEXT_AROUND_RIGHT = 0x31,
// CV_PREV_AROUND_LEFT = 0x20,
// CV_PREV_AROUND_RIGHT = 0x02
// }
// CvNextEdgeType;
// /* get the next edge with the same origin point (counterwise) */
// #define CV_SUBDIV2D_NEXT_EDGE( edge ) (((CvQuadEdge2D*)((edge) & ~3))->next[(edge)&3])
// /* Contour approximation algorithms */
const (
CV_POLY_APPROX_DP = C.CV_POLY_APPROX_DP
)
// /* Shape matching methods */
const (
CV_CONTOURS_MATCH_I1 = C.CV_CONTOURS_MATCH_I1
CV_CONTOURS_MATCH_I2 = C.CV_CONTOURS_MATCH_I2
CV_CONTOURS_MATCH_I3 = C.CV_CONTOURS_MATCH_I3
)
// /* Shape orientation */
const (
CV_CLOCKWISE = C.CV_CLOCKWISE
CV_COUNTER_CLOCKWISE = C.CV_COUNTER_CLOCKWISE
)
// /* Convexity defect */
// typedef struct CvConvexityDefect
// {
// CvPoint* start; /* point of the contour where the defect begins */
// CvPoint* end; /* point of the contour where the defect ends */
// CvPoint* depth_point; /* the farthest from the convex hull point within the defect */
// float depth; /* distance between the farthest point and the convex hull */
// } CvConvexityDefect;
// /* Histogram comparison methods */
const (
CV_COMP_CORREL = C.CV_COMP_CORREL
CV_COMP_CHISQR = C.CV_COMP_CHISQR
CV_COMP_INTERSECT = C.CV_COMP_INTERSECT
CV_COMP_BHATTACHARYYA = C.CV_COMP_BHATTACHARYYA
CV_COMP_HELLINGER = C.CV_COMP_HELLINGER
)
// /* Mask size for distance transform */
// enum
// {
// CV_DIST_MASK_3 =3,
// CV_DIST_MASK_5 =5,
// CV_DIST_MASK_PRECISE =0
// };
// /* Content of output label array: connected components or pixels */
// enum
// {
// CV_DIST_LABEL_CCOMP = 0,
// CV_DIST_LABEL_PIXEL = 1
// };
// /* Distance types for Distance Transform and M-estimators */
// enum
// {
// CV_DIST_USER =-1, /* User defined distance */
// CV_DIST_L1 =1, /* distance = |x1-x2| + |y1-y2| */
// CV_DIST_L2 =2, /* the simple euclidean distance */
// CV_DIST_C =3, /* distance = max(|x1-x2|,|y1-y2|) */
// CV_DIST_L12 =4, /* L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1)) */
// CV_DIST_FAIR =5, /* distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998 */
// CV_DIST_WELSCH =6, /* distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846 */
// CV_DIST_HUBER =7 /* distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345 */
// };
// /* Threshold types */
const (
CV_THRESH_BINARY = C.CV_THRESH_BINARY /* value = value > threshold ? max_value : 0 */
CV_THRESH_BINARY_INV = C.CV_THRESH_BINARY_INV /* value = value > threshold ? 0 : max_value */
CV_THRESH_TRUNC = C.CV_THRESH_TRUNC /* value = value > threshold ? threshold : value */
CV_THRESH_TOZERO = C.CV_THRESH_TOZERO /* value = value > threshold ? value : 0 */
CV_THRESH_TOZERO_INV = C.CV_THRESH_TOZERO_INV /* value = value > threshold ? 0 : value */
CV_THRESH_MASK = C.CV_THRESH_MASK
CV_THRESH_OTSU = C.CV_THRESH_OTSU /* use Otsu algorithm to choose the optimal threshold value;
combine the flag with one of the above CV_THRESH_* values */
)
// /* Adaptive threshold methods */
// enum
// {
// CV_ADAPTIVE_THRESH_MEAN_C =0,
// CV_ADAPTIVE_THRESH_GAUSSIAN_C =1
// };
// /* FloodFill flags */
// enum
// {
// CV_FLOODFILL_FIXED_RANGE =(1 << 16),
// CV_FLOODFILL_MASK_ONLY =(1 << 17)
// };
// /* Canny edge detector flags */
// enum
// {
// CV_CANNY_L2_GRADIENT =(1 << 31)
// };
// /* Variants of a Hough transform */
const (
CV_HOUGH_STANDARD = C.CV_HOUGH_STANDARD
CV_HOUGH_PROBABILISTIC = C.CV_HOUGH_PROBABILISTIC
CV_HOUGH_MULTI_SCALE = C.CV_HOUGH_MULTI_SCALE
CV_HOUGH_GRADIENT = C.CV_HOUGH_GRADIENT
)
// /* Fast search data structures */
// struct CvFeatureTree;
// struct CvLSH;
// struct CvLSHOperations;
// #ifdef __cplusplus
// }
// #endif
// #endif

19
opencv/opencv.c
View file

@ -1,6 +1,7 @@
// Copyright 2011 <chaishushan@gmail.com>. All rights reserved. // Copyright 2011 <chaishushan@gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// Updated by <mohamed.helala@gmail.com>
#include "opencv.h" #include "opencv.h"
#include "_cgo_export.h" #include "_cgo_export.h"
@ -14,8 +15,8 @@
// trackbar data // trackbar data
struct TrackbarUserdata { struct TrackbarUserdata {
char* win_name; schar* win_name;
char* bar_name; schar* bar_name;
int value; int value;
}; };
static struct TrackbarUserdata *trackbar_list[1000]; static struct TrackbarUserdata *trackbar_list[1000];
@ -32,8 +33,8 @@ int GoOpenCV_CreateTrackbar(
struct TrackbarUserdata *userdata = malloc(sizeof(*userdata)); struct TrackbarUserdata *userdata = malloc(sizeof(*userdata));
trackbar_list[trackbar_list_len++] = userdata; trackbar_list[trackbar_list_len++] = userdata;
userdata->win_name = (char*)window_name; userdata->win_name = (schar*)window_name;
userdata->bar_name = (char*)trackbar_name; userdata->bar_name = (schar*)trackbar_name;
userdata->value = value; userdata->value = value;
return cvCreateTrackbar2(trackbar_name, window_name, return cvCreateTrackbar2(trackbar_name, window_name,
@ -58,7 +59,7 @@ void GoOpenCV_DestroyTrackbar(char* trackbar_name, char* window_name) {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static void mouseCallback(int event, int x, int y, int flags, void* param) { static void mouseCallback(int event, int x, int y, int flags, void* param) {
char* name = (char*)param; schar* name = (schar*)param;
goMouseCallback(name, event, x, y, flags); goMouseCallback(name, event, x, y, flags);
} }
void GoOpenCV_SetMouseCallback(const char* window_name) { void GoOpenCV_SetMouseCallback(const char* window_name) {
@ -74,3 +75,11 @@ unsigned GoOpenCV_FOURCC_(int c1, int c2, int c3, int c4) {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// A wrapper to the CvCmpFunc
CvCmpFunc GoOpenCV_CmpFunc(void* gofunc)
{
int (*f)( const void*, const void*, void*) = gofunc;
return f;
}
//-----------------------------------------------------------------------------

10
opencv/opencv.h
View file

@ -3,6 +3,7 @@
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// //
// OpenCV Homepage: http://code.opencv.org // OpenCV Homepage: http://code.opencv.org
// Updated by <mohamed.helala@gmail.com>
#ifndef _GO_OPENCV_BINDING_H_ #ifndef _GO_OPENCV_BINDING_H_
#define _GO_OPENCV_BINDING_H_ #define _GO_OPENCV_BINDING_H_
@ -33,4 +34,13 @@ unsigned GoOpenCV_FOURCC_(
int c1, int c2, int c3, int c4 int c1, int c2, int c3, int c4
); );
//-----------------------------------------------------------------------------
typedef const void* CVoid;
// A wrapper to the CvCmpFunc
CvCmpFunc GoOpenCV_CmpFunc(void* gofunc);
//-----------------------------------------------------------------------------
#endif // _GO_OPENCV_BINDING_H_ #endif // _GO_OPENCV_BINDING_H_

29
samples/crop.go Normal file
View file

@ -0,0 +1,29 @@
package main
import (
"os"
"path"
"runtime"
opencv "github.com/lazywei/go-opencv/opencv"
)
func main() {
_, currentfile, _, _ := runtime.Caller(0)
filename := path.Join(path.Dir(currentfile), "../images/lena.jpg")
if len(os.Args) == 2 {
filename = os.Args[1]
}
image := opencv.LoadImage(filename)
if image == nil {
panic("LoadImage fail")
}
defer image.Release()
crop := opencv.Crop(image, 0, 0, 50, 50)
opencv.SaveImage("/tmp/crop.jpg", crop, 0)
crop.Release()
os.Exit(0)
}