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

Compare commits

base: sander:master
Branches Tags
sander:master
sander:feature/threshold
sander:develop
sander:cv2
..
compare: sander:cv2
Branches Tags
sander:master
sander:feature/threshold
sander:develop
sander:cv2

No commits in common. "master" and "cv2" have entirely different histories.
master ... cv2

15 changed files with 86 additions and 433 deletions
Show stats Expand all files Collapse all files

1
gocv/gocv.go
View file

@ -2,5 +2,4 @@ package gocv
// #cgo CXXFLAGS: -std=c++11
// #cgo darwin pkg-config: opencv
// #cgo linux pkg-config: opencv
import "C"

11
gocv/gocv_calib3d.cpp
View file

@ -5,7 +5,7 @@
#include "gocv_calib3d.hpp"
cv::Mat GcvInitCameraMatrix2D_(VecPoint3f objPts, VecPoint2f imgPts, cv::Size imgSize, double aspectRatio) {
cv::Mat GcvInitCameraMatrix2D_(VecPoint3f objPts, VecPoint2f imgPts) {
cv::Mat cameraMatrix;
std::vector<VecPoint3f> objPtsArr;
@ -14,16 +14,17 @@ cv::Mat GcvInitCameraMatrix2D_(VecPoint3f objPts, VecPoint2f imgPts, cv::Size im
objPtsArr.push_back(objPts);
imgPtsArr.push_back(imgPts);
cameraMatrix = cv::initCameraMatrix2D(objPtsArr, imgPtsArr, imgSize, aspectRatio);
cameraMatrix = cv::initCameraMatrix2D(objPtsArr, imgPtsArr, cv::Size(1920, 1080), 1);
return cameraMatrix;
}
double GcvCalibrateCamera_(VecPoint3f objPts, VecPoint2f imgPts,
cv::Size imgSize, cv::Mat& cameraMatrix, cv::Mat distCoeffs,
cv::Mat& rvec, cv::Mat& tvec, int flags) {
cv::Size imgSize, cv::Mat& cameraMatrix,
cv::Mat& rvec, cv::Mat& tvec) {
std::vector<VecPoint3f> objPtsArr;
std::vector<VecPoint2f> imgPtsArr;
std::vector<cv::Mat> rvecs, tvecs;
cv::Mat distCoeffs;
double rtn;
objPtsArr.push_back(objPts);
@ -36,7 +37,7 @@ double GcvCalibrateCamera_(VecPoint3f objPts, VecPoint2f imgPts,
rtn = cv::calibrateCamera(objPtsArr, imgPtsArr, imgSize,
cameraMatrix, distCoeffs,
rvecs, tvecs, flags);
rvecs, tvecs, 14575);
rvec = rvecs[0];
tvec = tvecs[0];

91
gocv/gocv_calib3d.go
View file

@ -2,73 +2,64 @@ package gocv
// #cgo CXXFLAGS: -std=c++11
// #cgo darwin pkg-config: opencv
// #cgo linux pkg-config: opencv
import "C"
import "github.com/gonum/matrix/mat64"
// GcvInitCameraMatrix2D takes one 3-by-N matrix and one 2-by-N Matrix as input.
// Each column in the input matrix represents a point in real world (objPts) or
// in image (imgPts).
// GcvInitCameraMatrix2D takes one N-by-3 matrix and one
// N-by-2 Matrix as input.
// Each row in the input matrix represents a point in real
// world (objPts) or in image (imgPts).
// Return: the camera matrix.
func GcvInitCameraMatrix2D(objPts, imgPts *mat64.Dense, dims [2]int,
aspectRatio float64) (camMat *mat64.Dense) {
func GcvInitCameraMatrix2D(objPts, imgPts *mat64.Dense) (camMat *mat64.Dense) {
nObjPts, objCol := objPts.Dims()
nImgPts, imgCol := imgPts.Dims()
objDim, nObjPts := objPts.Dims()
imgDim, nImgPts := imgPts.Dims()
if objDim != 3 || imgDim != 2 || nObjPts != nImgPts {
if objCol != 3 || imgCol != 2 || nObjPts != nImgPts {
panic("Invalid dimensions for objPts and imgPts")
}
objPtsVec := NewGcvPoint3f32Vector(int64(nObjPts))
imgPtsVec := NewGcvPoint2f32Vector(int64(nObjPts))
for j := 0; j < nObjPts; j++ {
objPtsVec.Set(j, NewGcvPoint3f32(mat64.Col(nil, j, objPts)...))
for i := 0; i < nObjPts; i++ {
objPtsVec.Set(i, NewGcvPoint3f32(objPts.Row(nil, i)...))
}
for j := 0; j < nObjPts; j++ {
imgPtsVec.Set(j, NewGcvPoint2f32(mat64.Col(nil, j, imgPts)...))
for i := 0; i < nObjPts; i++ {
imgPtsVec.Set(i, NewGcvPoint2f32(imgPts.Row(nil, i)...))
}
_imgSize := NewGcvSize2i(dims[0], dims[1])
camMat = GcvMatToMat64(GcvInitCameraMatrix2D_(
objPtsVec, imgPtsVec, _imgSize, aspectRatio))
camMat = GcvMatToMat64(GcvInitCameraMatrix2D_(objPtsVec, imgPtsVec))
return camMat
}
func GcvCalibrateCamera(objPts, imgPts, camMat, distCoeffs *mat64.Dense,
dims [2]int, flags int) (calCamMat, rvec, tvec *mat64.Dense) {
func GcvCalibrateCamera(objPts, imgPts, camMat *mat64.Dense) (calCamMat, rvec, tvec *mat64.Dense) {
nObjPts, objCol := objPts.Dims()
nImgPts, imgCol := imgPts.Dims()
objDim, nObjPts := objPts.Dims()
imgDim, nImgPts := imgPts.Dims()
if objDim != 3 || imgDim != 2 || nObjPts != nImgPts {
if objCol != 3 || imgCol != 2 || nObjPts != nImgPts {
panic("Invalid dimensions for objPts and imgPts")
}
objPtsVec := NewGcvPoint3f32Vector(int64(nObjPts))
imgPtsVec := NewGcvPoint2f32Vector(int64(nObjPts))
for j := 0; j < nObjPts; j++ {
objPtsVec.Set(j, NewGcvPoint3f32(mat64.Col(nil, j, objPts)...))
for i := 0; i < nObjPts; i++ {
objPtsVec.Set(i, NewGcvPoint3f32(objPts.Row(nil, i)...))
}
for j := 0; j < nObjPts; j++ {
imgPtsVec.Set(j, NewGcvPoint2f32(mat64.Col(nil, j, imgPts)...))
for i := 0; i < nObjPts; i++ {
imgPtsVec.Set(i, NewGcvPoint2f32(imgPts.Row(nil, i)...))
}
_camMat := Mat64ToGcvMat(camMat)
_distCoeffs := Mat64ToGcvMat(distCoeffs)
_rvec := NewGcvMat()
_tvec := NewGcvMat()
_imgSize := NewGcvSize2i(dims[0], dims[1])
_imgSize := NewGcvSize2i(1920, 1080)
GcvCalibrateCamera_(
objPtsVec, imgPtsVec,
_imgSize, _camMat, _distCoeffs,
_rvec, _tvec, flags)
_imgSize, _camMat, _rvec, _tvec)
calCamMat = GcvMatToMat64(_camMat)
rvec = GcvMatToMat64(_rvec)
@ -77,7 +68,7 @@ func GcvCalibrateCamera(objPts, imgPts, camMat, distCoeffs *mat64.Dense,
return calCamMat, rvec, tvec
}
// GcvRodrigues takes a 3D column vector, and apply cv::Rodrigues to it.
// Same as cv::Rodrigues
func GcvRodrigues(src *mat64.Dense) (dst *mat64.Dense) {
gcvSrc := Mat64ToGcvMat(src)
gcvDst := NewGcvMat()
@ -86,3 +77,37 @@ func GcvRodrigues(src *mat64.Dense) (dst *mat64.Dense) {
return dst
}
// func mat64ToGcvPoint3f32Vector(mat *mat64.Dense) NewGcvPoint3f32Vector {
// }
// func TestGcvCalibrateCamera(t *testing.T) {
// objPts := NewGcvPoint3fVector(int64(4))
// objPts.Set(0, NewGcvPoint3f(0, 25, 0))
// objPts.Set(1, NewGcvPoint3f(0, -25, 0))
// objPts.Set(2, NewGcvPoint3f(-47, 25, 0))
// objPts.Set(3, NewGcvPoint3f(-47, -25, 0))
// imgPts := NewGcvPoint2fVector(int64(4))
// imgPts.Set(0, NewGcvPoint2f(1136.4140625, 1041.89208984))
// imgPts.Set(1, NewGcvPoint2f(1845.33190918, 671.39581299))
// imgPts.Set(2, NewGcvPoint2f(302.73373413, 634.79998779))
// imgPts.Set(3, NewGcvPoint2f(1051.46154785, 352.76107788))
// imgSize := NewGcvSize2i(1920, 1080)
// camMat := GcvInitCameraMatrix2D(objPts, imgPts)
// spew.Dump(camMat.GcvAtd(NewGcvSize2i(0, 0)))
// spew.Dump(camMat.GcvAtd(NewGcvSize2i(0, 1)))
// spew.Dump(camMat.GcvAtd(NewGcvSize2i(1, 1)))
// spew.Dump(camMat.GcvAtd(NewGcvSize2i(1, 2)))
// spew.Dump(camMat.GcvAtd(NewGcvSize2i(2, 2)))
// rvec := NewMat()
// tvec := NewMat()
// GcvCalibrateCamera(objPts, imgPts, imgSize, camMat, rvec, tvec)
// MatToMat64(camMat)
// }

7
gocv/gocv_calib3d.hpp
View file

@ -5,11 +5,10 @@
typedef std::vector<cv::Point3f> VecPoint3f;
typedef std::vector<cv::Point2f> VecPoint2f;
cv::Mat GcvInitCameraMatrix2D_(VecPoint3f objPts, VecPoint2f imgPts,
cv::Size imgSize, double aspectRatio);
cv::Mat GcvInitCameraMatrix2D_(VecPoint3f objPts, VecPoint2f imgPts);
double GcvCalibrateCamera_(VecPoint3f objPts, VecPoint2f imgPts,
cv::Size imgSize, cv::Mat& cameraMatrix, cv::Mat distCoeffs,
cv::Mat& rvec, cv::Mat& tvec, int flags);
cv::Size2i imgSize, cv::Mat& cameraMatrix,
cv::Mat& rvec, cv::Mat& tvec);
void GcvRodrigues_(cv::Mat src, cv::Mat& dst);

38
gocv/gocv_calib3d_test.go
View file

@ -24,7 +24,6 @@ func TestGcvInitCameraMatrix2D(t *testing.T) {
-0.226950, 0.942377, -0.899869,
-1.148912, 0.093725, 0.634745,
})
objPts.Clone(objPts.T())
imgPts := mat64.NewDense(10, 2, []float64{
-0.384281, -0.299055,
@ -38,15 +37,14 @@ func TestGcvInitCameraMatrix2D(t *testing.T) {
0.631444, -0.340257,
-0.647580, 0.502113,
})
imgPts.Clone(imgPts.T())
camMat := GcvInitCameraMatrix2D(objPts, imgPts, [2]int{1920, 1080}, 1)
camMat := GcvInitCameraMatrix2D(objPts, imgPts)
assert.InDeltaSlice(t, []float64{1.47219772e+03, 0.00000000e+00, 9.59500000e+02},
mat64.Row(nil, 0, camMat), DELTA)
camMat.Row(nil, 0), DELTA)
assert.InDeltaSlice(t, []float64{0.00000000e+00, 1.47219772e+03, 5.39500000e+02},
mat64.Row(nil, 1, camMat), DELTA)
camMat.Row(nil, 1), DELTA)
assert.InDeltaSlice(t, []float64{0.00000000e+00, 0.00000000e+00, 1.00000000e+00},
mat64.Row(nil, 2, camMat), DELTA)
camMat.Row(nil, 2), DELTA)
}
func TestGcvCalibrateCamera(t *testing.T) {
@ -62,7 +60,6 @@ func TestGcvCalibrateCamera(t *testing.T) {
-0.226950, 0.942377, -0.899869,
-1.148912, 0.093725, 0.634745,
})
objPts.Clone(objPts.T())
imgPts := mat64.NewDense(10, 2, []float64{
-0.384281, -0.299055,
@ -76,21 +73,22 @@ func TestGcvCalibrateCamera(t *testing.T) {
0.631444, -0.340257,
-0.647580, 0.502113,
})
imgPts.Clone(imgPts.T())
camMat := GcvInitCameraMatrix2D(objPts, imgPts, [2]int{1920, 1080}, 1)
camMat := GcvInitCameraMatrix2D(objPts, imgPts)
distCoeffs := mat64.NewDense(5, 1, []float64{0, 0, 0, 0, 0})
camMat, rvec, tvec := GcvCalibrateCamera(objPts, imgPts, camMat)
camMat, rvec, tvec := GcvCalibrateCamera(
objPts, imgPts, camMat, distCoeffs, [2]int{1920, 1080}, 14575)
// stackedMat := *mat64.NewDense(0, 0, nil)
// stackedMat.Augment(GcvRodrigues(rvec), tvec)
assert.InDeltaSlice(t, []float64{-46.15296606, 0., 959.5}, mat64.Row(nil, 0, camMat), DELTA)
assert.InDeltaSlice(t, []float64{0., -46.15296606, 539.5}, mat64.Row(nil, 1, camMat), DELTA)
assert.InDeltaSlice(t, []float64{0., 0., 1.}, mat64.Row(nil, 2, camMat), DELTA)
// camMat.Mul(camMat, &stackedMat)
assert.InDeltaSlice(t, []float64{-0.98405029, -0.93443411, -0.26304667}, mat64.Col(nil, 0, rvec), DELTA)
assert.InDeltaSlice(t, []float64{0.6804739, 0.47530207, -0.04833094}, mat64.Col(nil, 0, tvec), DELTA)
assert.InDeltaSlice(t, []float64{-46.15296606, 0., 959.5}, camMat.Row(nil, 0), DELTA)
assert.InDeltaSlice(t, []float64{0., -46.15296606, 539.5}, camMat.Row(nil, 1), DELTA)
assert.InDeltaSlice(t, []float64{0., 0., 1.}, camMat.Row(nil, 2), DELTA)
assert.InDeltaSlice(t, []float64{-0.98405029, -0.93443411, -0.26304667}, rvec.Col(nil, 0), DELTA)
assert.InDeltaSlice(t, []float64{0.6804739, 0.47530207, -0.04833094}, tvec.Col(nil, 0), DELTA)
}
func TestGcvRodrigues(t *testing.T) {
@ -101,7 +99,7 @@ func TestGcvRodrigues(t *testing.T) {
})
rmat := GcvRodrigues(rvec)
assert.InDeltaSlice(t, []float64{0.59922526, 0.57799222, -0.55394411}, mat64.Row(nil, 0, rmat), DELTA)
assert.InDeltaSlice(t, []float64{0.20413818, 0.558743, 0.80382452}, mat64.Row(nil, 1, rmat), DELTA)
assert.InDeltaSlice(t, []float64{0.77411672, -0.5947531, 0.21682264}, mat64.Row(nil, 2, rmat), DELTA)
assert.InDeltaSlice(t, []float64{0.59922526, 0.57799222, -0.55394411}, rmat.Row(nil, 0), DELTA)
assert.InDeltaSlice(t, []float64{0.20413818, 0.558743, 0.80382452}, rmat.Row(nil, 1), DELTA)
assert.InDeltaSlice(t, []float64{0.77411672, -0.5947531, 0.21682264}, rmat.Row(nil, 2), DELTA)
}

1
gocv/gocv_core.go
View file

@ -2,7 +2,6 @@ package gocv
// #cgo CXXFLAGS: -std=c++11
// #cgo darwin pkg-config: opencv
// #cgo linux pkg-config: opencv
import "C"
import "github.com/gonum/matrix/mat64"

BIN
images/lena_with_text.jpg
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 105 KiB

BIN
images/pic5_contours.png
View file

Binary file not shown.
Side by side

Before

Width:  |  Height:  |  Size: 5.1 KiB

4
opencv/cv.go
View file

@ -23,11 +23,7 @@ const (
CV_BGR2BGRA = C.CV_BGR2BGRA
CV_RGBA2BGRA = C.CV_RGBA2BGRA
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
CV_8U = C.CV_8U
CV_8S = C.CV_8S

75
opencv/cxcore.go
View file

@ -142,11 +142,6 @@ func (img *IplImage) Get3D(x, y, z int) Scalar {
return Scalar(ret)
}
/* Sets every element of an array to a given value. */
func (img *IplImage) Set(value Scalar) {
C.cvSet(unsafe.Pointer(img), (C.CvScalar)(value), nil)
}
/* 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))
@ -528,15 +523,6 @@ func Not(src, dst *IplImage) {
/****************************************************************************************\
* Array Statistics *
\****************************************************************************************/
// CvScalar cvAvg(const CvArr* arr, const CvArr* mask=NULL )
func (src *IplImage) Avg(mask *IplImage) Scalar {
return (Scalar)(C.cvAvg(unsafe.Pointer(src), unsafe.Pointer(mask)))
}
// cvEqualizeHist(const CvArr* src, CvArr* dst)
func (src *IplImage) EqualizeHist(dst *IplImage) {
C.cvEqualizeHist(unsafe.Pointer(src), unsafe.Pointer(dst))
}
/****************************************************************************************\
* Discrete Linear Transforms and Related Functions *
@ -545,25 +531,6 @@ func (src *IplImage) EqualizeHist(dst *IplImage) {
/****************************************************************************************\
* Dynamic data structures *
\****************************************************************************************/
func (seq *Seq) Release() {
C.cvReleaseMemStorage(&seq.storage)
}
func (seq *Seq) Total() int {
return (int)(seq.total)
}
func (seq *Seq) HNext() *Seq {
return (*Seq)(seq.h_next)
}
func (seq *Seq) VNext() *Seq {
return (*Seq)(seq.v_next)
}
func (seq *Seq) Storage() *MemStorage {
return (*MemStorage)(seq.storage)
}
/****************************************************************************************\
* Drawing *
@ -599,48 +566,6 @@ func Circle(image *IplImage, pt1 Point, radius int, color Scalar, thickness, lin
)
}
const (
CV_FONT_HERSHEY_SIMPLEX = int(C.CV_FONT_HERSHEY_SIMPLEX)
CV_FONT_HERSHEY_PLAIN = int(C.CV_FONT_HERSHEY_PLAIN)
CV_FONT_HERSHEY_DUPLEX = int(C.CV_FONT_HERSHEY_DUPLEX)
CV_FONT_HERSHEY_COMPLEX = int(C.CV_FONT_HERSHEY_COMPLEX)
CV_FONT_HERSHEY_TRIPLEX = int(C.CV_FONT_HERSHEY_TRIPLEX)
CV_FONT_HERSHEY_COMPLEX_SMALL = int(C.CV_FONT_HERSHEY_COMPLEX_SMALL)
CV_FONT_HERSHEY_SCRIPT_SIMPLEX = int(C.CV_FONT_HERSHEY_SCRIPT_SIMPLEX)
CV_FONT_HERSHEY_SCRIPT_COMPLEX = int(C.CV_FONT_HERSHEY_SCRIPT_COMPLEX)
CV_FONT_ITALIC = int(C.CV_FONT_ITALIC)
)
type Font struct {
font C.CvFont
}
//void cvInitFont(CvFont* font, int font_face, double hscale, double vscale, double shear=0, int thickness=1, int line_type=8 )
func InitFont(fontFace int, hscale, vscale, shear float32, thickness, lineType int) *Font {
font := new(Font)
C.cvInitFont(
&font.font,
C.int(fontFace),
C.double(hscale),
C.double(vscale),
C.double(shear),
C.int(thickness),
C.int(lineType),
)
return font
}
// void cvPutText(CvArr* img, const char* text, CvPoint org, const CvFont* font, CvScalar color)
func (this *Font) PutText(image *IplImage, text string, pt1 Point, color Scalar) {
C.cvPutText(
unsafe.Pointer(image),
C.CString(text),
C.cvPoint(C.int(pt1.X), C.int(pt1.Y)),
&this.font,
(C.CvScalar)(color),
)
}
//CVAPI(void) cvLine( CvArr* img, CvPoint pt1, CvPoint pt2,
// CvScalar color, int thickness CV_DEFAULT(1),
// int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );

66
opencv/cxcore_test.go
View file

@ -1,75 +1,9 @@
package opencv
import (
"bytes"
"io/ioutil"
"os"
"path"
"runtime"
"syscall"
"testing"
)
func TestLoadImage2(t *testing.T) {
// t.Errorf("aaa")
}
func TestInitFont(t *testing.T) {
// Will assert at the C layer on error
InitFont(CV_FONT_HERSHEY_DUPLEX, 1, 1, 0, 1, 8)
}
func TestPutText(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()
// Write 'Hello' on the image
font := InitFont(CV_FONT_HERSHEY_DUPLEX, 1, 1, 0, 1, 8)
color := NewScalar(255, 255, 255, 0)
pos := Point{image.Width() / 2, image.Height() / 2}
font.PutText(image, "Hello", pos, color)
filename = path.Join(path.Dir(currentfile), "../images/lena_with_text.jpg")
// Uncomment this code to create the test image "../images/lena_with_text.jpg"
// It is part of the repo, and what this test compares against
//
// SaveImage(filename, image, 0)
// println("Saved file", filename)
tempfilename := path.Join(os.TempDir(), "lena_with_text.jpg")
defer syscall.Unlink(tempfilename)
SaveImage(tempfilename, image, 0)
// Compare actual image with expected image
same, err := BinaryCompare(filename, tempfilename)
if err != nil {
t.Fatal(err)
}
if !same {
t.Error("Actual file differs from expected file with text")
}
}
// Compare two files, return true if exactly the same
func BinaryCompare(file1, file2 string) (bool, error) {
f1, err := ioutil.ReadFile(file1)
if err != nil {
return false, err
}
f2, err := ioutil.ReadFile(file2)
if err != nil {
return false, err
}
return bytes.Equal(f1, f2), nil
}

39
opencv/cxtype.go
View file

@ -595,18 +595,6 @@ type Box2D struct {
angle float32
}
func (box *Box2D) Size() Size2D32f {
return box.size
}
func (box *Box2D) Center() Point2D32f {
return box.center
}
func (box *Box2D) Angle() float32 {
return box.angle
}
type LineIterator C.CvLineIterator
/************************************* CvSlice ******************************************/
@ -617,12 +605,6 @@ const (
CV_WHOLE_SEQ_END_INDEX = C.CV_WHOLE_SEQ_END_INDEX
)
/* Equivalent to the C constant CV_WHOLE_SEQ */
func WholeSeq() Slice {
slice := C.cvSlice(C.int(0), C.CV_WHOLE_SEQ_END_INDEX)
return (Slice)(slice)
}
/************************************* CvScalar *****************************************/
type Scalar C.CvScalar
@ -679,18 +661,6 @@ type Graph C.CvGraph
type Chain C.CvChain
type Contour C.CvContour
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_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
)
/****************************************************************************************\
* Sequence types *
\****************************************************************************************/
@ -724,15 +694,6 @@ const (
type AttrList C.CvAttrList
/****************************************************************************************/
/* Structural Analysis and Shape Descriptors */
/****************************************************************************************/
/* For use in ApproxPoly */
const (
CV_POLY_APPROX_DP = C.CV_POLY_APPROX_DP
)
/*****************************************************************************\
* --- END --- *
\*****************************************************************************/

75
opencv/imgproc.go
View file

@ -52,78 +52,3 @@ func Crop(src *IplImage, x, y, width, height int) *IplImage {
return dest
}
/* Returns a Seq of countours in an image, detected according to the parameters.
Caller must Release() the Seq returned */
func (image *IplImage) FindContours(mode, method int, offset Point) *Seq {
storage := C.cvCreateMemStorage(0)
header_size := (C.size_t)(unsafe.Sizeof(C.CvContour{}))
var seq *C.CvSeq
C.cvFindContours(
unsafe.Pointer(image),
storage,
&seq,
C.int(header_size),
C.int(mode),
C.int(method),
C.cvPoint(C.int(offset.X), C.int(offset.Y)))
return (*Seq)(seq)
}
//cvDrawContours(CvArr* img, CvSeq* contour, CvScalar externalColor, CvScalar holeColor, int maxLevel, int thickness=1, int lineType=8
func DrawContours(image *IplImage, contours *Seq, externalColor, holeColor Scalar, maxLevel, thickness, lineType int, offset Point) {
C.cvDrawContours(
unsafe.Pointer(image),
(*C.CvSeq)(contours),
(C.CvScalar)(externalColor),
(C.CvScalar)(holeColor),
C.int(maxLevel),
C.int(thickness),
C.int(lineType),
C.cvPoint(C.int(offset.X), C.int(offset.Y)))
}
// CvSeq* cvApproxPoly(const void* src_seq, int header_size, CvMemStorage* storage, int method, double eps, int recursive=0 )
func ApproxPoly(src *Seq, header_size int, storage *MemStorage, method int, eps float64, recursive int) *Seq {
seq := C.cvApproxPoly(
unsafe.Pointer(src),
C.int(header_size),
(*C.CvMemStorage)(storage),
C.int(method),
C.double(eps),
C.int(recursive))
return (*Seq)(seq)
}
// cvArcLength(const void* curve, CvSlice slice=CV_WHOLE_SEQ, int is_closed=-1 )
func ArcLength(curve *Seq, slice Slice, is_closed bool) float64 {
is_closed_int := 0
if is_closed {
is_closed_int = 1
}
return float64(C.cvArcLength(unsafe.Pointer(curve),
(C.CvSlice)(slice),
C.int(is_closed_int)))
}
func ContourPerimeter(curve *Seq) float64 {
return ArcLength(curve, WholeSeq(), true)
}
// double cvContourArea(const CvArr* contour, CvSlice slice=CV_WHOLE_SEQ, int oriented=0 )
func ContourArea(contour *Seq, slice Slice, oriented int) float64 {
return float64(C.cvContourArea(
unsafe.Pointer(contour),
(C.CvSlice)(slice),
C.int(oriented)))
}
/* points can be either CvSeq* or CvMat* */
func FitEllipse2(points unsafe.Pointer) Box2D {
box := C.cvFitEllipse2(points)
center := Point2D32f{float32(box.center.x), float32(box.center.y)}
size := Size2D32f{float32(box.size.width), float32(box.size.height)}
angle := float32(box.angle)
return Box2D{center, size, angle}
}

55
opencv/imgproc_test.go
View file

@ -1,10 +1,8 @@
package opencv
import (
"os"
"path"
"runtime"
"syscall"
"testing"
)
@ -57,56 +55,3 @@ func TestCrop(t *testing.T) {
t.Fatalf("excepted width is 200, returned %d\n", crop.Height())
}
}
func TestFindContours(t *testing.T) {
_, currentfile, _, _ := runtime.Caller(0)
filename := path.Join(path.Dir(currentfile), "../images/pic5.png")
image := LoadImage(filename)
if image == nil {
t.Fatal("LoadImage fail")
}
defer image.Release()
grayscale := CreateImage(image.Width(), image.Height(), IPL_DEPTH_8U, 1)
CvtColor(image, grayscale, CV_BGR2GRAY)
defer grayscale.Release()
edges := CreateImage(grayscale.Width(), grayscale.Height(), grayscale.Depth(), grayscale.Channels())
defer edges.Release()
Canny(grayscale, edges, 50, 200, 3)
seq := edges.FindContours(CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE, Point{0, 0})
defer seq.Release()
contours := CreateImage(grayscale.Width(), grayscale.Height(), grayscale.Depth(), grayscale.Channels())
white := NewScalar(255, 255, 255, 0)
contours.Set(white)
black := NewScalar(0, 0, 0, 0)
red := NewScalar(0, 255, 0, 0)
for ; seq != nil; seq = seq.HNext() {
DrawContours(contours, seq, red, black, 0, 2, 8, Point{0, 0})
}
filename = path.Join(path.Dir(currentfile), "../images/pic5_contours.png")
// Uncomment this code to create the test image "../images/shapes_contours.png"
// It is part of the repo, and what this test compares against
//
//SaveImage(filename), contours, 0)
tempfilename := path.Join(os.TempDir(), "pic5_contours.png")
defer syscall.Unlink(tempfilename)
SaveImage(tempfilename, contours, 0)
// Compare actual image with expected image
same, err := BinaryCompare(filename, tempfilename)
if err != nil {
t.Fatal(err)
}
if !same {
t.Error("Expected contour file != actual contour file")
}
}

54
samples/webcam_facedetect.go
View file

@ -1,54 +0,0 @@
package main
import (
"fmt"
"os"
"path"
"github.com/lazywei/go-opencv/opencv"
)
func main() {
win := opencv.NewWindow("Go-OpenCV Webcam Face Detection")
defer win.Destroy()
cap := opencv.NewCameraCapture(0)
if cap == nil {
panic("cannot open camera")
}
defer cap.Release()
cwd, err := os.Getwd()
if err != nil {
panic(err)
}
cascade := opencv.LoadHaarClassifierCascade(path.Join(cwd, "haarcascade_frontalface_alt.xml"))
fmt.Println("Press ESC to quit")
for {
if cap.GrabFrame() {
img := cap.RetrieveFrame(1)
if img != nil {
faces := cascade.DetectObjects(img)
for _, value := range faces {
opencv.Circle(img,
opencv.Point{
value.X() + (value.Width() / 2),
value.Y() + (value.Height() / 2),
},
value.Width()/2,
opencv.ScalarAll(255.0), 1, 1, 0)
}
win.ShowImage(img)
} else {
fmt.Println("nil image")
}
}
key := opencv.WaitKey(1)
if key == 27 {
os.Exit(0)
}
}
}