mirror of
https://github.com/hybridgroup/gocv
synced 2025-08-25 08:41:04 +08:00
1108 lines
24 KiB
Go
1108 lines
24 KiB
Go
//go:build !gocv_specific_modules || (gocv_specific_modules && gocv_cuda_arithm)
|
|
|
|
package cuda
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"gocv.io/x/gocv"
|
|
)
|
|
|
|
func TestAbs(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in Abs test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg.Upload(src)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Abs(cimg, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src.Rows() != dest.Rows() || src.Cols() != dest.Cols() {
|
|
t.Error("Invalid Abs test")
|
|
}
|
|
}
|
|
|
|
func TestAbsException(t *testing.T) {
|
|
src := gocv.NewMat()
|
|
defer src.Close()
|
|
|
|
var cimg, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg.Upload(src)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
err := Abs(cimg, &dimg)
|
|
if err == nil {
|
|
t.Error("Expected exception in test")
|
|
}
|
|
if len(err.Error()) == 0 {
|
|
t.Error("Expected exception message in test")
|
|
}
|
|
}
|
|
|
|
func TestAbsWithStream(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in Abs test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg, s = NewGpuMat(), NewGpuMat(), NewStream()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
cimg.UploadWithStream(src, s)
|
|
AbsWithStream(cimg, &dimg, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() || src.Rows() != dest.Rows() || src.Cols() != dest.Cols() {
|
|
t.Error("Invalid Abs test")
|
|
}
|
|
}
|
|
|
|
func TestAbsDiff(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in AbsDiff test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
AbsDiff(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid AbsDiff test")
|
|
}
|
|
}
|
|
|
|
func TestAdd(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in AbsDiff test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Add(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Add test")
|
|
}
|
|
}
|
|
|
|
func TestBitwiseAnd(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in AbsDiff test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
BitwiseAnd(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid BitwiseAnd test")
|
|
}
|
|
}
|
|
|
|
func TestBitwiseNot(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in AbsDiff test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
BitwiseNot(cimg, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid BitwiseNot test")
|
|
}
|
|
}
|
|
|
|
func TestBitwiseOr(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in BitwiseOr test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
BitwiseOr(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid BitwiseOr test")
|
|
}
|
|
}
|
|
|
|
func TestBitwiseXor(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in BitwiseXor test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
BitwiseXor(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid BitwiseXor test")
|
|
}
|
|
}
|
|
|
|
func TestDivide(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Divide test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Divide(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Divide test")
|
|
}
|
|
}
|
|
|
|
func TestDivideWithStream(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Divide test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
var s = NewStream()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
cimg1.UploadWithStream(src1, s)
|
|
cimg2.UploadWithStream(src1, s)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
DivideWithStream(cimg1, cimg2, &dimg, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Divide test")
|
|
}
|
|
}
|
|
|
|
func TestExp(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Exp test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Exp(cimg1, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Exp test")
|
|
}
|
|
}
|
|
|
|
func TestLog(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Log test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Log(cimg1, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Log test")
|
|
}
|
|
}
|
|
|
|
func TestMax(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Max test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Max(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Max test")
|
|
}
|
|
}
|
|
|
|
func TestMin(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Min test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Min(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Min test")
|
|
}
|
|
}
|
|
|
|
func TestMultiply(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Multiply test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src1)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Multiply(cimg1, cimg2, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Multiply test")
|
|
}
|
|
}
|
|
|
|
func TestMultiplyWithStream(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Multiply test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
var s = NewStream()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
cimg1.UploadWithStream(src1, s)
|
|
cimg2.UploadWithStream(src1, s)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
MultiplyWithStream(cimg1, cimg2, &dimg, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() || src1.Rows() != dest.Rows() || src1.Cols() != dest.Cols() {
|
|
t.Error("Invalid Multiply test")
|
|
}
|
|
|
|
}
|
|
|
|
func TestThreshold(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in Threshold test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg.Upload(src)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Threshold(cimg, &dimg, 25, 255, gocv.ThresholdBinary)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src.Rows() != dest.Rows() || src.Cols() != dest.Cols() {
|
|
t.Error("Invalid Threshold test")
|
|
}
|
|
}
|
|
|
|
func TestThresholdWithStream(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in Threshold test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg, s = NewGpuMat(), NewGpuMat(), NewStream()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
cimg.UploadWithStream(src, s)
|
|
ThresholdWithStream(cimg, &dimg, 25, 255, gocv.ThresholdBinary, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() || src.Rows() != dest.Rows() || src.Cols() != dest.Cols() {
|
|
t.Error("Invalid Threshold test")
|
|
}
|
|
}
|
|
|
|
func TestFlip(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in Flip test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg.Upload(src)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Flip(cimg, &dimg, 0)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src.Rows() != dest.Rows() || src.Cols() != dest.Cols() {
|
|
t.Error("Invalid Flip test")
|
|
}
|
|
}
|
|
|
|
func TestFlipWithStream(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadColor)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in Flip test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg, s = NewGpuMat(), NewGpuMat(), NewStream()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
cimg.UploadWithStream(src, s)
|
|
FlipWithStream(cimg, &dimg, 0, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() || src.Rows() != dest.Rows() || src.Cols() != dest.Cols() {
|
|
t.Error("Invalid Flip test")
|
|
}
|
|
}
|
|
|
|
func TestMerge(t *testing.T) {
|
|
src := NewGpuMatWithSize(101, 102, gocv.MatTypeCV8U)
|
|
defer src.Close()
|
|
src2 := NewGpuMatWithSize(101, 102, gocv.MatTypeCV8U)
|
|
defer src2.Close()
|
|
src3 := NewGpuMatWithSize(101, 102, gocv.MatTypeCV8U)
|
|
defer src3.Close()
|
|
|
|
dstGPU := NewGpuMat()
|
|
defer dstGPU.Close()
|
|
|
|
Merge([]GpuMat{src, src2, src3}, &dstGPU)
|
|
if dstGPU.Empty() {
|
|
t.Error("TestMerge dst should not be empty.")
|
|
}
|
|
}
|
|
|
|
func TestMergeWithStream(t *testing.T) {
|
|
src := NewGpuMatWithSize(101, 102, gocv.MatTypeCV8U)
|
|
defer src.Close()
|
|
src2 := NewGpuMatWithSize(101, 102, gocv.MatTypeCV8U)
|
|
defer src2.Close()
|
|
src3 := NewGpuMatWithSize(101, 102, gocv.MatTypeCV8U)
|
|
defer src3.Close()
|
|
s := NewStream()
|
|
defer s.Close()
|
|
|
|
dstGPU := NewGpuMat()
|
|
defer dstGPU.Close()
|
|
|
|
MergeWithStream([]GpuMat{src, src2, src3}, &dstGPU, s)
|
|
|
|
s.WaitForCompletion()
|
|
if dstGPU.Empty() {
|
|
t.Error("TestMergeWithStream dst should not be empty.")
|
|
}
|
|
}
|
|
|
|
func TestTranspose(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in Transpose test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg.Upload(src)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
Transpose(cimg, &dimg)
|
|
dimg.Download(&dest)
|
|
if dest.Empty() || src.Rows() != dest.Cols() || src.Cols() != dest.Rows() {
|
|
t.Error("Invalid Transpose test")
|
|
}
|
|
}
|
|
|
|
func TestTransposeWithStream(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in TransposeWithStream test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg, s = NewGpuMat(), NewGpuMat(), NewStream()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
cimg.Upload(src)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
TransposeWithStream(cimg, &dimg, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() || src.Rows() != dest.Cols() || src.Cols() != dest.Rows() {
|
|
t.Error("Invalid TransposeWithStream test")
|
|
}
|
|
}
|
|
|
|
func TestAddWeighted(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in AddWeighted test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
src2 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src2.Empty() {
|
|
t.Error("Invalid read of Mat in AddWeighted test")
|
|
}
|
|
defer src2.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src2)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
alpha, beta, gamma := 0.5, 0.5, 0.0
|
|
AddWeighted(cimg1, alpha, cimg2, beta, gamma, &dimg, -1)
|
|
dimg.Download(&dest)
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid AddWeighted test")
|
|
}
|
|
}
|
|
|
|
func TestAddWeightedWithStream(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in AddWeighted test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
src2 := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src2.Empty() {
|
|
t.Error("Invalid read of Mat in AddWeighted test")
|
|
}
|
|
defer src2.Close()
|
|
|
|
var cimg1, cimg2, dimg, s = NewGpuMat(), NewGpuMat(), NewGpuMat(), NewStream()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
cimg1.UploadWithStream(src1, s)
|
|
cimg2.UploadWithStream(src2, s)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
alpha, beta, gamma := 0.5, 0.5, 0.0
|
|
AddWeightedWithStream(cimg1, alpha, cimg2, beta, gamma, &dimg, -1, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid AddWeightedWithStream test")
|
|
}
|
|
}
|
|
|
|
func TestCopyMakeBorder(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in CopyMakeBorder test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
|
|
cimg.Upload(src)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
CopyMakeBorder(cimg, &dimg, 10, 10, 10, 10, gocv.BorderReflect, gocv.NewScalar(0, 0, 0, 0))
|
|
dimg.Download(&dest)
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid CopyMakeBorder test")
|
|
}
|
|
}
|
|
|
|
func TestCopyMakeBorderWithStream(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in CopyMakeBorder test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg, s = NewGpuMat(), NewGpuMat(), NewStream()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
cimg.UploadWithStream(src, s)
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
CopyMakeBorderWithStream(cimg, &dimg, 10, 10, 10, 10, gocv.BorderReflect, gocv.NewScalar(0, 0, 0, 0), s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid CopyMakeBorderWithStream test")
|
|
}
|
|
}
|
|
|
|
func TestNewLookUpTable(t *testing.T) {
|
|
|
|
m := NewGpuMatWithSize(1, 256, gocv.MatTypeCV8U)
|
|
defer m.Close()
|
|
|
|
lt := NewLookUpTable(m)
|
|
defer lt.Close()
|
|
|
|
}
|
|
|
|
func TestLookUpTableEmpty(t *testing.T) {
|
|
m := NewGpuMatWithSize(1, 256, gocv.MatTypeCV8U)
|
|
defer m.Close()
|
|
|
|
lt := NewLookUpTable(m)
|
|
defer lt.Close()
|
|
|
|
lt.Empty()
|
|
}
|
|
|
|
func TestTransform(t *testing.T) {
|
|
|
|
src := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC3)
|
|
defer src.Close()
|
|
|
|
dst := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC3)
|
|
defer dst.Close()
|
|
|
|
m := NewGpuMatWithSize(1, 256, gocv.MatTypeCV8U)
|
|
defer m.Close()
|
|
|
|
lt := NewLookUpTable(m)
|
|
defer lt.Close()
|
|
|
|
lt.Transform(src, &dst)
|
|
}
|
|
|
|
func TestTransformWithStream(t *testing.T) {
|
|
|
|
src := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC3)
|
|
defer src.Close()
|
|
|
|
dst := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC3)
|
|
defer dst.Close()
|
|
|
|
m := NewGpuMatWithSize(1, 256, gocv.MatTypeCV8U)
|
|
defer m.Close()
|
|
|
|
lt := NewLookUpTable(m)
|
|
defer lt.Close()
|
|
|
|
s := NewStream()
|
|
defer s.Close()
|
|
|
|
lt.TransformWithStream(src, &dst, s)
|
|
s.WaitForCompletion()
|
|
}
|
|
|
|
func TestSplit(t *testing.T) {
|
|
|
|
m := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC2)
|
|
defer m.Close()
|
|
|
|
m0 := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC1)
|
|
defer m0.Close()
|
|
|
|
m1 := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC1)
|
|
defer m1.Close()
|
|
|
|
mats := []GpuMat{m0, m1}
|
|
|
|
Split(m, mats)
|
|
}
|
|
|
|
func TestSplitWithStream(t *testing.T) {
|
|
|
|
m := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC2)
|
|
defer m.Close()
|
|
|
|
m0 := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC1)
|
|
defer m0.Close()
|
|
|
|
m1 := NewGpuMatWithSize(256, 256, gocv.MatTypeCV8UC1)
|
|
defer m1.Close()
|
|
|
|
mats := []GpuMat{m0, m1}
|
|
|
|
s := NewStream()
|
|
defer s.Close()
|
|
|
|
SplitWithStream(m, mats, s)
|
|
s.WaitForCompletion()
|
|
}
|
|
|
|
func TestCalcNorm(t *testing.T) {
|
|
src := gocv.IMRead("../images/chessboard_4x6_distort_correct.png", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in CalcNorm test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg = NewGpuMat(), NewGpuMat()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
cimg.Upload(src)
|
|
CalcNorm(cimg, dimg, gocv.NormL2)
|
|
dimg.Download(&dest)
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid CalcNorm test")
|
|
}
|
|
}
|
|
|
|
func TestCalcNormWithStream(t *testing.T) {
|
|
src := gocv.IMRead("../images/chessboard_4x6_distort_correct.png", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in CalcNorm test")
|
|
}
|
|
defer src.Close()
|
|
|
|
var cimg, dimg, s = NewGpuMat(), NewGpuMat(), NewStream()
|
|
defer cimg.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
cimg.UploadWithStream(src, s)
|
|
CalcNormWithStream(cimg, dimg, gocv.NormL2, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid CalcNormWithStream test")
|
|
}
|
|
}
|
|
|
|
func TestCalcNormDiff(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/chessboard_4x6_distort_correct.png", gocv.IMReadGrayScale)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in CalcNormDiff test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
src2 := gocv.IMRead("../images/chessboard_4x6_distort.png", gocv.IMReadGrayScale)
|
|
if src2.Empty() {
|
|
t.Error("Invalid read of Mat in CalcNormDiff test")
|
|
}
|
|
defer src2.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src2)
|
|
CalcNormDiff(cimg1, cimg2, dimg, gocv.NormL2)
|
|
dimg.Download(&dest)
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid CalcNormDiff test")
|
|
}
|
|
}
|
|
|
|
func TestCalcNormDiffWithStream(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/chessboard_4x6_distort_correct.png", gocv.IMReadGrayScale)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in CalcNormDiff test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
src2 := gocv.IMRead("../images/chessboard_4x6_distort.png", gocv.IMReadGrayScale)
|
|
if src2.Empty() {
|
|
t.Error("Invalid read of Mat in CalcNormDiff test")
|
|
}
|
|
defer src2.Close()
|
|
|
|
var cimg1, cimg2, dimg, s = NewGpuMat(), NewGpuMat(), NewGpuMat(), NewStream()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
defer s.Close()
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
cimg1.UploadWithStream(src1, s)
|
|
cimg2.UploadWithStream(src2, s)
|
|
CalcNormDiffWithStream(cimg1, cimg2, dimg, gocv.NormL2, s)
|
|
dimg.DownloadWithStream(&dest, s)
|
|
|
|
s.WaitForCompletion()
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid CalcNormWithStream test")
|
|
}
|
|
}
|
|
|
|
func TestNorm(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/chessboard_4x6_distort_correct.png", gocv.IMReadGrayScale)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Norm test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
src2 := gocv.IMRead("../images/chessboard_4x6_distort.png", gocv.IMReadGrayScale)
|
|
if src2.Empty() {
|
|
t.Error("Invalid read of Mat in Norm test")
|
|
}
|
|
defer src2.Close()
|
|
|
|
var cimg1, cimg2 = NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src2)
|
|
|
|
result := Norm(cimg1, cimg2, gocv.NormL2)
|
|
|
|
if result == 0 {
|
|
t.Error("Invalid Norm test")
|
|
}
|
|
}
|
|
|
|
func TestCompareDiff(t *testing.T) {
|
|
src1 := gocv.IMRead("../images/chessboard_4x6_distort_correct.png", gocv.IMReadGrayScale)
|
|
if src1.Empty() {
|
|
t.Error("Invalid read of Mat in Compare test")
|
|
}
|
|
defer src1.Close()
|
|
|
|
src2 := gocv.IMRead("../images/chessboard_4x6_distort.png", gocv.IMReadGrayScale)
|
|
if src2.Empty() {
|
|
t.Error("Invalid read of Mat in Compare test")
|
|
}
|
|
defer src2.Close()
|
|
|
|
var cimg1, cimg2, dimg = NewGpuMat(), NewGpuMat(), NewGpuMat()
|
|
defer cimg1.Close()
|
|
defer cimg2.Close()
|
|
defer dimg.Close()
|
|
|
|
dest := gocv.NewMat()
|
|
defer dest.Close()
|
|
|
|
cimg1.Upload(src1)
|
|
cimg2.Upload(src2)
|
|
Compare(cimg1, cimg2, dimg, gocv.CompareNE)
|
|
dimg.Download(&dest)
|
|
|
|
if dest.Empty() {
|
|
t.Error("Invalid CalcNormDiff test")
|
|
}
|
|
}
|
|
|
|
func TestLShift(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in LShift test")
|
|
}
|
|
defer src.Close()
|
|
|
|
cimg := NewGpuMat()
|
|
defer cimg.Close()
|
|
cimg.Upload(src)
|
|
|
|
dst := NewGpuMat()
|
|
defer dst.Close()
|
|
|
|
err := LShift(cimg, gocv.NewScalar(128, 128, 128, 128), &dst)
|
|
if err != nil {
|
|
t.Errorf("LShift error: %v", err)
|
|
}
|
|
if dst.Empty() {
|
|
t.Error("LShift result should not be empty")
|
|
}
|
|
}
|
|
|
|
func TestLShiftWithStream(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in LShiftWithStream test")
|
|
}
|
|
defer src.Close()
|
|
|
|
cimg := NewGpuMat()
|
|
defer cimg.Close()
|
|
cimg.Upload(src)
|
|
|
|
dst := NewGpuMat()
|
|
defer dst.Close()
|
|
|
|
s := NewStream()
|
|
defer s.Close()
|
|
|
|
err := LShiftWithStream(cimg, gocv.NewScalar(128, 128, 128, 128), &dst, s)
|
|
if err != nil {
|
|
t.Errorf("LShiftWithStream error: %v", err)
|
|
}
|
|
s.WaitForCompletion()
|
|
if dst.Empty() {
|
|
t.Error("LShiftWithStream result should not be empty")
|
|
}
|
|
}
|
|
|
|
func TestRShift(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in RShift test")
|
|
}
|
|
defer src.Close()
|
|
|
|
cimg := NewGpuMat()
|
|
defer cimg.Close()
|
|
cimg.Upload(src)
|
|
|
|
dst := NewGpuMat()
|
|
defer dst.Close()
|
|
|
|
err := RShift(cimg, gocv.NewScalar(2, 2, 2, 2), &dst)
|
|
if err != nil {
|
|
t.Errorf("RShift error: %v", err)
|
|
}
|
|
if dst.Empty() {
|
|
t.Error("RShift result should not be empty")
|
|
}
|
|
}
|
|
|
|
func TestRShiftWithStream(t *testing.T) {
|
|
src := gocv.IMRead("../images/gocvlogo.jpg", gocv.IMReadGrayScale)
|
|
if src.Empty() {
|
|
t.Error("Invalid read of Mat in RShiftWithStream test")
|
|
}
|
|
defer src.Close()
|
|
|
|
cimg := NewGpuMat()
|
|
defer cimg.Close()
|
|
cimg.Upload(src)
|
|
|
|
dst := NewGpuMat()
|
|
defer dst.Close()
|
|
|
|
s := NewStream()
|
|
defer s.Close()
|
|
|
|
err := RShiftWithStream(cimg, gocv.NewScalar(2, 2, 2, 2), &dst, s)
|
|
if err != nil {
|
|
t.Errorf("RShiftWithStream error: %v", err)
|
|
}
|
|
s.WaitForCompletion()
|
|
if dst.Empty() {
|
|
t.Error("RShiftWithStream result should not be empty")
|
|
}
|
|
}
|