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

Wrap basic types.

Browse source
This commit is contained in:
Chih-Wei Chang 2015-02-15 16:11:09 +08:00
parent 165a4b1f4f
commit a2e19543f7
7 changed files with 244 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
opencv2/gcv_calib3d/gcv_calib3d.cpp
View file

@ -19,7 +19,7 @@ cv::Mat GcvInitCameraMatrix2D(VecPoint3f objPts, VecPoint2f imgPts) {
}
double GcvCalibrateCamera(VecPoint3f objPts, VecPoint2f imgPts,
std::vector<int> imgSize, cv::Mat cameraMatrix) {
cv::Size imgSize, cv::Mat cameraMatrix) {
std::vector<VecPoint3f> objPtsArr;
std::vector<VecPoint2f> imgPtsArr;
std::vector<cv::Mat> rvecs, tvecs;
@ -32,8 +32,7 @@ double GcvCalibrateCamera(VecPoint3f objPts, VecPoint2f imgPts,
std::cout << "init Camera" << cameraMatrix << std::endl;
rtn = cv::calibrateCamera(objPtsArr, imgPtsArr,
cv::Size2i(imgSize[0], imgSize[1]),
rtn = cv::calibrateCamera(objPtsArr, imgPtsArr, imgSize,
cameraMatrix, distCoeffs, rvecs, tvecs);
std::cout << "final Camera" << cameraMatrix << std::endl;

2
opencv2/gcv_calib3d/gcv_calib3d.hpp
View file

@ -8,4 +8,4 @@ typedef std::vector<cv::Point2f> VecPoint2f;
cv::Mat GcvInitCameraMatrix2D(VecPoint3f objPts, VecPoint2f imgPts);
double GcvCalibrateCamera(VecPoint3f objPts, VecPoint2f imgPts,
std::vector<int> imgSize, cv::Mat cameraMatrix);
cv::Size2i imgSize, cv::Mat cameraMatrix);

62
opencv2/gcv_calib3d/gcv_calib3d_test.go
View file

@ -2,7 +2,7 @@ package gcv_calib3d
import "testing"
import "github.com/lazywei/go-opencv/opencv2/gcv_utils"
import "github.com/lazywei/go-opencv/opencv2/gcv_core"
// [[[ 0. 25. 0.]
// [ 0. -25. 0.]
@ -18,37 +18,51 @@ import "github.com/lazywei/go-opencv/opencv2/gcv_utils"
// [ 0.00000000e+00 0.00000000e+00 1.00000000e+00]]
func TestGcvInitCameraMatrix2D(t *testing.T) {
objPts := gcv_utils.NewGcvPoint3fVector(int64(4))
objPts.Set(0, gcv_utils.GetPoint3f(0, 25, 0))
objPts.Set(1, gcv_utils.GetPoint3f(0, -25, 0))
objPts.Set(2, gcv_utils.GetPoint3f(-47, 25, 0))
objPts.Set(3, gcv_utils.GetPoint3f(-47, -25, 0))
objPts := gcv_core.NewGcvPoint3fVector(int64(4))
objPts.Set(0, gcv_core.NewGcvPoint3f(
float32(0), float32(25), float32(0)))
objPts.Set(1, gcv_core.NewGcvPoint3f(
float32(0), float32(-25), float32(0)))
objPts.Set(2, gcv_core.NewGcvPoint3f(
float32(-47), float32(25), float32(0)))
objPts.Set(3, gcv_core.NewGcvPoint3f(
float32(-47), float32(-25), float32(0)))
imgPts := gcv_utils.NewGcvPoint2fVector(int64(4))
imgPts.Set(0, gcv_utils.GetPoint2f(1136.4140625, 1041.89208984))
imgPts.Set(1, gcv_utils.GetPoint2f(1845.33190918, 671.39581299))
imgPts.Set(2, gcv_utils.GetPoint2f(302.73373413, 634.79998779))
imgPts.Set(3, gcv_utils.GetPoint2f(1051.46154785, 352.76107788))
imgPts := gcv_core.NewGcvPoint2fVector(int64(4))
imgPts.Set(0, gcv_core.NewGcvPoint2f(
float32(1136.4140625), float32(1041.89208984)))
imgPts.Set(1, gcv_core.NewGcvPoint2f(
float32(1845.33190918), float32(671.39581299)))
imgPts.Set(2, gcv_core.NewGcvPoint2f(
float32(302.73373413), float32(634.79998779)))
imgPts.Set(3, gcv_core.NewGcvPoint2f(
float32(1051.46154785), float32(352.76107788)))
GcvInitCameraMatrix2D(objPts, imgPts)
}
func TestGcvCalibrateCamera(t *testing.T) {
objPts := gcv_utils.NewGcvPoint3fVector(int64(4))
objPts.Set(0, gcv_utils.GetPoint3f(0, 25, 0))
objPts.Set(1, gcv_utils.GetPoint3f(0, -25, 0))
objPts.Set(2, gcv_utils.GetPoint3f(-47, 25, 0))
objPts.Set(3, gcv_utils.GetPoint3f(-47, -25, 0))
objPts := gcv_core.NewGcvPoint3fVector(int64(4))
objPts.Set(0, gcv_core.NewGcvPoint3f(
float32(0), float32(25), float32(0)))
objPts.Set(1, gcv_core.NewGcvPoint3f(
float32(0), float32(-25), float32(0)))
objPts.Set(2, gcv_core.NewGcvPoint3f(
float32(-47), float32(25), float32(0)))
objPts.Set(3, gcv_core.NewGcvPoint3f(
float32(-47), float32(-25), float32(0)))
imgPts := gcv_utils.NewGcvPoint2fVector(int64(4))
imgPts.Set(0, gcv_utils.GetPoint2f(1136.4140625, 1041.89208984))
imgPts.Set(1, gcv_utils.GetPoint2f(1845.33190918, 671.39581299))
imgPts.Set(2, gcv_utils.GetPoint2f(302.73373413, 634.79998779))
imgPts.Set(3, gcv_utils.GetPoint2f(1051.46154785, 352.76107788))
imgPts := gcv_core.NewGcvPoint2fVector(int64(4))
imgPts.Set(0, gcv_core.NewGcvPoint2f(
float32(1136.4140625), float32(1041.89208984)))
imgPts.Set(1, gcv_core.NewGcvPoint2f(
float32(1845.33190918), float32(671.39581299)))
imgPts.Set(2, gcv_core.NewGcvPoint2f(
float32(302.73373413), float32(634.79998779)))
imgPts.Set(3, gcv_core.NewGcvPoint2f(
float32(1051.46154785), float32(352.76107788)))
imgSize := gcv_utils.NewGcvIntVector(int64(2))
imgSize.Set(0, 1920)
imgSize.Set(1, 1080)
imgSize := gcv_core.NewGcvSize2i(1920, 1080)
camMat := GcvInitCameraMatrix2D(objPts, imgPts)

2
opencv2/gcv_utils/gcv_utils.go → opencv2/gcv_core/gcv_core.go
View file

@ -1,4 +1,4 @@
package gcv_utils
package gcv_core
// #cgo CXXFLAGS: -std=c++11
// #cgo darwin pkg-config: opencv

202
opencv2/gcv_core/gcv_core.swigcxx Normal file
View file

@ -0,0 +1,202 @@
%module gcv_core
%include "std_vector.i"
%{
#include "opencv2/core/types_c.h"
#include "opencv2/core/version.hpp"
#include "opencv2/core/core.hpp"
%}
/* Classes defined in core.hpp */
namespace cv {
template<typename _Tp> class Size_;
template<typename _Tp> class Point_;
template<typename _Tp> class Rect_;
template<typename _Tp, int cn> class Vec;
//////////////////////////////// Point_ ////////////////////////////////
/*!
template 2D point class.
The class defines a point in 2D space. Data type of the point coordinates is specified
as a template parameter. There are a few shorter aliases available for user convenience.
See cv::Point, cv::Point2i, cv::Point2f and cv::Point2d.
*/
template<typename _Tp> class Point_
{
public:
typedef _Tp value_type;
// various constructors
Point_();
Point_(_Tp _x, _Tp _y);
Point_(const Point_& pt);
Point_(const CvPoint& pt);
Point_(const CvPoint2D32f& pt);
Point_(const Size_<_Tp>& sz);
Point_(const Vec<_Tp, 2>& v);
Point_& operator = (const Point_& pt);
//! conversion to another data type
template<typename _Tp2> operator Point_<_Tp2>() const;
//! conversion to the old-style C structures
operator CvPoint() const;
operator CvPoint2D32f() const;
operator Vec<_Tp, 2>() const;
//! dot product
_Tp dot(const Point_& pt) const;
//! dot product computed in double-precision arithmetics
double ddot(const Point_& pt) const;
//! cross-product
double cross(const Point_& pt) const;
//! checks whether the point is inside the specified rectangle
bool inside(const Rect_<_Tp>& r) const;
_Tp x, y; //< the point coordinates
};
/*!
template 3D point class.
The class defines a point in 3D space. Data type of the point coordinates is specified
as a template parameter.
\see cv::Point3i, cv::Point3f and cv::Point3d
*/
template<typename _Tp> class Point3_
{
public:
typedef _Tp value_type;
// various constructors
Point3_();
Point3_(_Tp _x, _Tp _y, _Tp _z);
Point3_(const Point3_& pt);
explicit Point3_(const Point_<_Tp>& pt);
Point3_(const CvPoint3D32f& pt);
Point3_(const Vec<_Tp, 3>& v);
Point3_& operator = (const Point3_& pt);
//! conversion to another data type
template<typename _Tp2> operator Point3_<_Tp2>() const;
//! conversion to the old-style CvPoint...
operator CvPoint3D32f() const;
//! conversion to cv::Vec<>
operator Vec<_Tp, 3>() const;
//! dot product
_Tp dot(const Point3_& pt) const;
//! dot product computed in double-precision arithmetics
double ddot(const Point3_& pt) const;
//! cross product of the 2 3D points
Point3_ cross(const Point3_& pt) const;
_Tp x, y, z; //< the point coordinates
};
//////////////////////////////// Size_ ////////////////////////////////
/*!
The 2D size class
The class represents the size of a 2D rectangle, image size, matrix size etc.
Normally, cv::Size ~ cv::Size_<int> is used.
*/
template<typename _Tp> class Size_
{
public:
typedef _Tp value_type;
//! various constructors
Size_();
Size_(_Tp _width, _Tp _height);
Size_(const Size_& sz);
Size_(const CvSize& sz);
Size_(const CvSize2D32f& sz);
Size_(const Point_<_Tp>& pt);
Size_& operator = (const Size_& sz);
//! the area (width*height)
_Tp area() const;
//! conversion of another data type.
template<typename _Tp2> operator Size_<_Tp2>() const;
//! conversion to the old-style OpenCV types
operator CvSize() const;
operator CvSize2D32f() const;
_Tp width, height; // the width and the height
};
//////////////////////////////// Rect_ ////////////////////////////////
/*!
The 2D up-right rectangle class
The class represents a 2D rectangle with coordinates of the specified data type.
Normally, cv::Rect ~ cv::Rect_<int> is used.
*/
template<typename _Tp> class Rect_
{
public:
typedef _Tp value_type;
//! various constructors
Rect_();
Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);
Rect_(const Rect_& r);
Rect_(const CvRect& r);
Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);
Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);
Rect_& operator = ( const Rect_& r );
//! the top-left corner
Point_<_Tp> tl() const;
//! the bottom-right corner
Point_<_Tp> br() const;
//! size (width, height) of the rectangle
Size_<_Tp> size() const;
//! area (width*height) of the rectangle
_Tp area() const;
//! conversion to another data type
template<typename _Tp2> operator Rect_<_Tp2>() const;
//! conversion to the old-style CvRect
operator CvRect() const;
//! checks whether the rectangle contains the point
bool contains(const Point_<_Tp>& pt) const;
_Tp x, y, width, height; //< the top-left corner, as well as width and height of the rectangle
};
%template(GcvSize2i) Size_<int>;
%template(GcvSize2d) Size_<double>;
%template(GcvSize2f) Size_<float>;
%template(GcvRect) Rect_<int>;
%template(GcvPoint2i) Point_<int>;
%template(GcvPoint2f) Point_<float>;
%template(GcvPoint2d) Point_<double>;
%template(GcvPoint3i) Point3_<int>;
%template(GcvPoint3f) Point3_<float>;
%template(GcvPoint3d) Point3_<double>;
}
/* Additional STL types */
namespace std {
%template(GcvPoint3fVector) vector<cv::Point3f>;
%template(GcvPoint2fVector) vector<cv::Point2f>;
%template(GcvIntVector) vector<int>;
%template(GcvFloatVector) vector<float>;
};

12
opencv2/gcv_utils/gcv_utils.hpp
View file

@ -1,12 +0,0 @@
#include <opencv2/opencv.hpp>
#include <vector>
using namespace std;
cv::Point3f GetPoint3f(float x, float y, float z) {
return cv::Point3f(x, y, z);
}
cv::Point2f GetPoint2f(float x, float y) {
return cv::Point2f(x, y);
}

16
opencv2/gcv_utils/gcv_utils.swigcxx
View file

@ -1,16 +0,0 @@
%module gcv_utils
%include "std_vector.i"
%{
#include "gcv_utils.hpp"
%}
%include "gcv_utils.hpp"
namespace std {
%template(GcvPoint3fVector) vector<cv::Point3f>;
%template(GcvPoint2fVector) vector<cv::Point2f>;
%template(GcvIntVector) vector<int>;
%template(GcvFloatVector) vector<float>;
};