Skip to content

Commit

Permalink
Remove code not currently in use
Browse files Browse the repository at this point in the history 
Signed-off-by: deadprogram <[email protected]>
  • Loading branch information
@deadprogram
deadprogram committed Sep 25, 2017
1 parent 3eb086e commit edc917a
Show file tree
Hide file tree
Showing 3 changed files with 0 additions and 285 deletions.
133 changes: 0 additions & 133 deletions core.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,139 +24,6 @@ void DrawRectsToImage(Mat img, struct Rects rects) {
}
}

// MatVec3b_New creates a new empty MatVec3b
MatVec3b MatVec3b_New() {
return new cv::Mat_<cv::Vec3b>();
}

// MatVec3b_Delete deletes an existing MatVec3b
void MatVec3b_Delete(MatVec3b m) {
delete m;
}

void MatVec3b_CopyTo(MatVec3b src, MatVec3b dst) {
src->copyTo(*dst);
}

// MatVec3b_Empty tests if a MatVec3b is empty
int MatVec3b_Empty(MatVec3b m) {
return m->empty();
}

struct ByteArray MatVec3b_ToJpegData(MatVec3b m, int quality){
std::vector<int> param(2);
param[0] = CV_IMWRITE_JPEG_QUALITY;
param[1] = quality;
std::vector<uchar> data;
cv::imencode(".jpg", *m, data, param);
return toByteArray(reinterpret_cast<const char*>(&data[0]), data.size());
}

struct RawData MatVec3b_ToRawData(MatVec3b m) {
int width = m->cols;
int height = m->rows;
int size = width * height * 3;
char* data = reinterpret_cast<char*>(m->data);
ByteArray byteData = {data, size};
RawData raw = {width, height, byteData};
return raw;
}

MatVec3b RawData_ToMatVec3b(struct RawData r) {
int rows = r.height;
int cols = r.width;
cv::Mat_<cv::Vec3b>* mat = new cv::Mat_<cv::Vec3b>(rows, cols);
unsigned char* data = reinterpret_cast<unsigned char*>(r.data.data);
mat->data = data;
return mat;
}

void MatVec4b_Delete(MatVec4b m) {
delete m;
}

struct RawData MatVec4b_ToRawData(MatVec4b m) {
int width = m->cols;
int height = m->rows;
int size = width * height * 4;
char* data = reinterpret_cast<char*>(m->data);
ByteArray byteData = {data, size};
RawData raw = {width, height, byteData};
return raw;
}

MatVec4b RawData_ToMatVec4b(struct RawData r) {
int rows = r.height;
int cols = r.width;
cv::Mat_<cv::Vec4b>* mat = new cv::Mat_<cv::Vec4b>(rows, cols);
unsigned char* data = reinterpret_cast<unsigned char*>(r.data.data);
mat->data = data;
return mat;
}

MatVec4b LoadAlphaImg(const char* name) {
cv::Mat_<cv::Vec4b> img = cv::imread(name, cv::IMREAD_UNCHANGED);
return new cv::Mat_<cv::Vec4b>(img);
}

void MountAlphaImage(MatVec4b img, MatVec3b back, struct Rects rects) {
cv::Mat_<cv::Vec4b> resized;
for (int i = 0; i < rects.length; ++i) {
Rect r = rects.rects[i];
int col, row;
if (r.width < r.height) {
col = img->cols * r.height / img->rows;
row = r.height;
} else {
col = r.width;
row = img->rows * r.width / img->cols;
}
int ltx = r.x + r.width * 0.5 - col * 0.5;
int lty = r.y + r.height * 0.5 - row * 0.5;
std::vector<cv::Point2f> tgtPt;
tgtPt.push_back(cv::Point2f(ltx, lty));
tgtPt.push_back(cv::Point2f(ltx+col, lty));
tgtPt.push_back(cv::Point2f(ltx+col, lty+row));
tgtPt.push_back(cv::Point2f(ltx, lty+row));

cv::Mat img_rgb, img_aaa, img_backa;
std::vector<cv::Mat> planes_rgba, planes_rgb, planes_aaa, planes_backa;
int maxVal = pow(2, 8 * back->elemSize1()) - 1;

std::vector<cv::Point2f> srcPt;
srcPt.push_back(cv::Point2f(0, 0));
srcPt.push_back(cv::Point2f(img->cols-1, 0));
srcPt.push_back(cv::Point2f(img->cols-1, img->rows-1));
srcPt.push_back(cv::Point2f(0, img->rows-1));
cv::Mat mat = cv::getPerspectiveTransform(srcPt, tgtPt);

cv::Mat alpha0(back->rows, back->cols, img->type());
alpha0 = cv::Scalar::all(0);
cv::warpPerspective(*img, alpha0, mat, alpha0.size(), cv::INTER_CUBIC,
cv::BORDER_TRANSPARENT);

cv::split(alpha0, planes_rgba);

planes_rgb.push_back(planes_rgba[0]);
planes_rgb.push_back(planes_rgba[1]);
planes_rgb.push_back(planes_rgba[2]);
merge(planes_rgb, img_rgb);

planes_aaa.push_back(planes_rgba[3]);
planes_aaa.push_back(planes_rgba[3]);
planes_aaa.push_back(planes_rgba[3]);
merge(planes_aaa, img_aaa);

planes_backa.push_back(maxVal - planes_rgba[3]);
planes_backa.push_back(maxVal - planes_rgba[3]);
planes_backa.push_back(maxVal - planes_rgba[3]);
merge(planes_backa, img_backa);

*back = img_rgb.mul(img_aaa, 1.0/(float)maxVal)
+ back->mul(img_backa, 1.0/(float)maxVal);
}
}

void ByteArray_Release(struct ByteArray buf) {
delete[] buf.data;
}
Expand Down
134 changes: 0 additions & 134 deletions core.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,9 +5,6 @@ package opencv3
#include "core.h"
*/
import "C"
import (
"unsafe"
)

const (
// CvCapPropFrameWidth is OpenCV parameter of Frame Width
Expand Down Expand Up @@ -69,134 +66,3 @@ func DrawRectsToImage(img Mat, rects []Rect) {
}
C.DrawRectsToImage(img.p, cRects)
}

// CMatVec3b is an alias for C pointer.
type CMatVec3b C.MatVec3b

// MatVec3b is a bind of `cv::Mat_<cv::Vec3b>`
type MatVec3b struct {
p C.MatVec3b
}

// GetCPointer returns C pointer of MatVec3b.
func (m *MatVec3b) GetCPointer() C.MatVec3b {
return m.p
}

// NewMatVec3b returns a new MatVec3b.
func NewMatVec3b() MatVec3b {
return MatVec3b{p: C.MatVec3b_New()}
}

// NewMatVec3bWithCPointer return a new MatVec3b with argument C pointer.
func NewMatVec3bWithCPointer(p CMatVec3b) MatVec3b {
return MatVec3b{p: C.MatVec3b(p)}
}

// ToJpegData convert to JPEG data.
func (m *MatVec3b) ToJpegData(quality int) []byte {
b := C.MatVec3b_ToJpegData(m.p, C.int(quality))
defer C.ByteArray_Release(b)
return toGoBytes(b)
}

// Delete object.
func (m *MatVec3b) Delete() {
C.MatVec3b_Delete(m.p)
m.p = nil
}

// CopyTo copies MatVec3b.
func (m *MatVec3b) CopyTo(dst *MatVec3b) {
C.MatVec3b_CopyTo(m.p, dst.p)
}

// Empty returns the MatVec3b is empty or not.
func (m *MatVec3b) Empty() bool {
isEmpty := C.MatVec3b_Empty(m.p)
return isEmpty != 0
}

// ToRawData converts MatVec3b to RawData.
func (m *MatVec3b) ToRawData() (int, int, []byte) {
r := C.MatVec3b_ToRawData(m.p)
return int(r.width), int(r.height), toGoBytes(r.data)
}

// ToMatVec3b converts RawData to MatVec3b. Returned MatVec3b is required to
// delete after using.
func ToMatVec3b(width int, height int, data []byte) MatVec3b {
cr := C.struct_RawData{
width: C.int(width),
height: C.int(height),
data: toByteArray(data),
}
return MatVec3b{p: C.RawData_ToMatVec3b(cr)}
}

// MatVec4b is a bind of `cv::Mat_<cv::Vec4b>`
type MatVec4b struct {
p C.MatVec4b
}

// Delete object.
func (m *MatVec4b) Delete() {
C.MatVec4b_Delete(m.p)
m.p = nil
}

// ToRawData converts MatVec4b to RawData.
func (m *MatVec4b) ToRawData() (int, int, []byte) {
r := C.MatVec4b_ToRawData(m.p)
return int(r.width), int(r.height), toGoBytes(r.data)
}

// ToMatVec4b converts RawData to MatVec4b. Returned MatVec4b is required to
// delete after using.
func ToMatVec4b(width int, height int, data []byte) MatVec4b {
cr := C.struct_RawData{
width: C.int(width),
height: C.int(height),
data: toByteArray(data),
}
return MatVec4b{p: C.RawData_ToMatVec4b(cr)}
}

// LoadAlphaImage loads RGBA type image.
func LoadAlphaImage(name string) MatVec4b {
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
return MatVec4b{p: C.LoadAlphaImg(cName)}
}

// MountAlphaImage draws img on back leading to rects. img is required RGBA,
// TODO should be check file type.
func MountAlphaImage(img MatVec4b, back MatVec3b, rects []Rect) {
cRectArray := make([]C.struct_Rect, len(rects))
for i, r := range rects {
cRect := C.struct_Rect{
x: C.int(r.X),
y: C.int(r.Y),
width: C.int(r.Width),
height: C.int(r.Height),
}
cRectArray[i] = cRect
}
cRects := C.struct_Rects{
rects: (*C.Rect)(&cRectArray[0]),
length: C.int(len(rects)),
}
C.MountAlphaImage(img.p, back.p, cRects)
}

func toByteArray(b []byte) C.struct_ByteArray {
return C.struct_ByteArray{
data: (*C.char)(unsafe.Pointer(&b[0])),
length: C.int(len(b)),
}
}

// toGoBytes returns binary data. Serializing is depends on C/C++ implementation.
func toGoBytes(b C.struct_ByteArray) []byte {
return C.GoBytes(unsafe.Pointer(b.data), b.length)
}
18 changes: 0 additions & 18 deletions core.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,12 +38,8 @@ extern "C" {

#ifdef __cplusplus
typedef cv::Mat* Mat;
typedef cv::Mat_<cv::Vec3b>* MatVec3b;
typedef cv::Mat_<cv::Vec4b>* MatVec4b;
#else
typedef void* Mat;
typedef void* MatVec3b;
typedef void* MatVec4b;
#endif

struct ByteArray toByteArray(const char* buf, int len);
Expand All @@ -56,20 +52,6 @@ extern "C" {
void Mat_Delete(Mat m);
int Mat_Empty(Mat m);

MatVec3b MatVec3b_New();
struct ByteArray MatVec3b_ToJpegData(MatVec3b m, int quality);
void MatVec3b_Delete(MatVec3b m);
void MatVec3b_CopyTo(MatVec3b src, MatVec3b dst);
int MatVec3b_Empty(MatVec3b m);
struct RawData MatVec3b_ToRawData(MatVec3b m);
MatVec3b RawData_ToMatVec3b(struct RawData r);

void MatVec4b_Delete(MatVec4b m);
struct RawData MatVec4b_ToRawData(MatVec4b m);
MatVec4b RawData_ToMatVec4b(struct RawData r);
MatVec4b LoadAlphaImg(const char* name);
void MountAlphaImage(MatVec4b img, MatVec3b back, struct Rects rects);

#ifdef __cplusplus
}
#endif
Expand Down

0 comments on commit edc917a

Please sign in to comment.