Chiebot-Mirror
/
opencv
mirror of https://github.com/opencv/opencv.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
Open Source Computer Vision Library https://opencv.org/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7858 Commits
7 Branches
126 Tags
3.0 GiB
 
 
 
 
 
 
Tag: Branch: Tree: a6d558042c
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a6d558042c'
${ noResults }
opencv/modules/python/test/test.py

2237 lines
89 KiB
Raw Blame History

#!/usr/bin/env python
import unittest
import random
import time
import math
import sys
import array
import urllib
import tarfile
import hashlib
import os
import getopt
import operator
import functools
import cv2.cv as cv
from test2 import *
class OpenCVTests(unittest.TestCase):
depths = [ cv.IPL_DEPTH_8U, cv.IPL_DEPTH_8S, cv.IPL_DEPTH_16U, cv.IPL_DEPTH_16S, cv.IPL_DEPTH_32S, cv.IPL_DEPTH_32F, cv.IPL_DEPTH_64F ]
mat_types = [
cv.CV_8UC1,
cv.CV_8UC2,
cv.CV_8UC3,
cv.CV_8UC4,
cv.CV_8SC1,
cv.CV_8SC2,
cv.CV_8SC3,
cv.CV_8SC4,
cv.CV_16UC1,
cv.CV_16UC2,
cv.CV_16UC3,
cv.CV_16UC4,
cv.CV_16SC1,
cv.CV_16SC2,
cv.CV_16SC3,
cv.CV_16SC4,
cv.CV_32SC1,
cv.CV_32SC2,
cv.CV_32SC3,
cv.CV_32SC4,
cv.CV_32FC1,
cv.CV_32FC2,
cv.CV_32FC3,
cv.CV_32FC4,
cv.CV_64FC1,
cv.CV_64FC2,
cv.CV_64FC3,
cv.CV_64FC4,
]
mat_types_single = [
cv.CV_8UC1,
cv.CV_8SC1,
cv.CV_16UC1,
cv.CV_16SC1,
cv.CV_32SC1,
cv.CV_32FC1,
cv.CV_64FC1,
]
def depthsize(self, d):
return { cv.IPL_DEPTH_8U : 1,
cv.IPL_DEPTH_8S : 1,
cv.IPL_DEPTH_16U : 2,
cv.IPL_DEPTH_16S : 2,
cv.IPL_DEPTH_32S : 4,
cv.IPL_DEPTH_32F : 4,
cv.IPL_DEPTH_64F : 8 }[d]
def get_sample(self, filename, iscolor = cv.CV_LOAD_IMAGE_COLOR):
if not filename in self.image_cache:
filedata = urllib.urlopen("https://raw.github.com/Itseez/opencv/master/" + filename).read()
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1)
cv.SetData(imagefiledata, filedata, len(filedata))
self.image_cache[filename] = cv.DecodeImageM(imagefiledata, iscolor)
return self.image_cache[filename]
def setUp(self):
self.image_cache = {}
def snap(self, img):
self.snapL([img])
def snapL(self, L):
for i,img in enumerate(L):
cv.NamedWindow("snap-%d" % i, 1)
cv.ShowImage("snap-%d" % i, img)
cv.WaitKey()
cv.DestroyAllWindows()
def hashimg(self, im):
""" Compute a hash for an image, useful for image comparisons """
return hashlib.md5(im.tostring()).digest()
# Tests to run first; check the handful of basic operations that the later tests rely on
class PreliminaryTests(OpenCVTests):
def test_lena(self):
# Check that the lena jpg image has loaded correctly
# This test uses a 'golden' MD5 hash of the Lena image
# If the JPEG decompressor changes, it is possible that the MD5 hash will change,
# so the hash here will need to change.
im = self.get_sample("samples/c/lena.jpg")
# self.snap(im) # uncomment this line to view the image, when regilding
self.assertEqual(hashlib.md5(im.tostring()).hexdigest(), "9dcd9247f9811c6ce86675ba7b0297b6")
def test_LoadImage(self):
self.assertRaises(TypeError, lambda: cv.LoadImage())
self.assertRaises(TypeError, lambda: cv.LoadImage(4))
self.assertRaises(TypeError, lambda: cv.LoadImage('foo.jpg', 1, 1))
self.assertRaises(TypeError, lambda: cv.LoadImage('foo.jpg', xiscolor=cv.CV_LOAD_IMAGE_COLOR))
def test_types(self):
self.assert_(type(cv.CreateImage((7,5), cv.IPL_DEPTH_8U, 1)) == cv.iplimage)
self.assert_(type(cv.CreateMat(5, 7, cv.CV_32FC1)) == cv.cvmat)
for i,t in enumerate(self.mat_types):
basefunc = [
cv.CV_8UC,
cv.CV_8SC,
cv.CV_16UC,
cv.CV_16SC,
cv.CV_32SC,
cv.CV_32FC,
cv.CV_64FC,
][i / 4]
self.assertEqual(basefunc(1 + (i % 4)), t)
def test_tostring(self):
for w in [ 1, 4, 64, 512, 640]:
for h in [ 1, 4, 64, 480, 512]:
for c in [1, 2, 3, 4]:
for d in self.depths:
a = cv.CreateImage((w,h), d, c);
self.assert_(len(a.tostring()) == w * h * c * self.depthsize(d))
for w in [ 32, 96, 480 ]:
for h in [ 32, 96, 480 ]:
depth_size = {
cv.IPL_DEPTH_8U : 1,
cv.IPL_DEPTH_8S : 1,
cv.IPL_DEPTH_16U : 2,
cv.IPL_DEPTH_16S : 2,
cv.IPL_DEPTH_32S : 4,
cv.IPL_DEPTH_32F : 4,
cv.IPL_DEPTH_64F : 8
}
for f in self.depths:
for channels in (1,2,3,4):
img = cv.CreateImage((w, h), f, channels)
esize = (w * h * channels * depth_size[f])
self.assert_(len(img.tostring()) == esize)
cv.SetData(img, " " * esize, w * channels * depth_size[f])
self.assert_(len(img.tostring()) == esize)
mattype_size = {
cv.CV_8UC1 : 1,
cv.CV_8UC2 : 1,
cv.CV_8UC3 : 1,
cv.CV_8UC4 : 1,
cv.CV_8SC1 : 1,
cv.CV_8SC2 : 1,
cv.CV_8SC3 : 1,
cv.CV_8SC4 : 1,
cv.CV_16UC1 : 2,
cv.CV_16UC2 : 2,
cv.CV_16UC3 : 2,
cv.CV_16UC4 : 2,
cv.CV_16SC1 : 2,
cv.CV_16SC2 : 2,
cv.CV_16SC3 : 2,
cv.CV_16SC4 : 2,
cv.CV_32SC1 : 4,
cv.CV_32SC2 : 4,
cv.CV_32SC3 : 4,
cv.CV_32SC4 : 4,
cv.CV_32FC1 : 4,
cv.CV_32FC2 : 4,
cv.CV_32FC3 : 4,
cv.CV_32FC4 : 4,
cv.CV_64FC1 : 8,
cv.CV_64FC2 : 8,
cv.CV_64FC3 : 8,
cv.CV_64FC4 : 8
}
for t in self.mat_types:
for im in [cv.CreateMat(h, w, t), cv.CreateMatND([h, w], t)]:
elemsize = cv.CV_MAT_CN(cv.GetElemType(im)) * mattype_size[cv.GetElemType(im)]
cv.SetData(im, " " * (w * h * elemsize), (w * elemsize))
esize = (w * h * elemsize)
self.assert_(len(im.tostring()) == esize)
cv.SetData(im, " " * esize, w * elemsize)
self.assert_(len(im.tostring()) == esize)
# Tests for specific OpenCV functions
class FunctionTests(OpenCVTests):
def test_AvgSdv(self):
m = cv.CreateMat(1, 8, cv.CV_32FC1)
for i,v in enumerate([2, 4, 4, 4, 5, 5, 7, 9]):
m[0,i] = (v,)
self.assertAlmostEqual(cv.Avg(m)[0], 5.0, 3)
avg,sdv = cv.AvgSdv(m)
self.assertAlmostEqual(avg[0], 5.0, 3)
self.assertAlmostEqual(sdv[0], 2.0, 3)
def test_CalcEMD2(self):
cc = {}
for r in [ 5, 10, 37, 38 ]:
scratch = cv.CreateImage((100,100), 8, 1)
cv.SetZero(scratch)
cv.Circle(scratch, (50,50), r, 255, -1)
storage = cv.CreateMemStorage()
seq = cv.FindContours(scratch, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
arr = cv.CreateMat(len(seq), 3, cv.CV_32FC1)
for i,e in enumerate(seq):
arr[i,0] = 1
arr[i,1] = e[0]
arr[i,2] = e[1]
cc[r] = arr
def myL1(A, B, D):
return abs(A[0]-B[0]) + abs(A[1]-B[1])
def myL2(A, B, D):
return math.sqrt((A[0]-B[0])**2 + (A[1]-B[1])**2)
def myC(A, B, D):
return max(abs(A[0]-B[0]), abs(A[1]-B[1]))
contours = set(cc.values())
for c0 in contours:
for c1 in contours:
self.assert_(abs(cv.CalcEMD2(c0, c1, cv.CV_DIST_L1) - cv.CalcEMD2(c0, c1, cv.CV_DIST_USER, myL1)) < 1e-3)
self.assert_(abs(cv.CalcEMD2(c0, c1, cv.CV_DIST_L2) - cv.CalcEMD2(c0, c1, cv.CV_DIST_USER, myL2)) < 1e-3)
self.assert_(abs(cv.CalcEMD2(c0, c1, cv.CV_DIST_C) - cv.CalcEMD2(c0, c1, cv.CV_DIST_USER, myC)) < 1e-3)
def test_CalcOpticalFlowBM(self):
a = self.get_sample("samples/c/lena.jpg", 0)
b = self.get_sample("samples/c/lena.jpg", 0)
(w,h) = cv.GetSize(a)
vel_size = (w - 8 + 1, h - 8 + 1)
velx = cv.CreateImage(vel_size, cv.IPL_DEPTH_32F, 1)
vely = cv.CreateImage(vel_size, cv.IPL_DEPTH_32F, 1)
cv.CalcOpticalFlowBM(a, b, (8,8), (1,1), (8,8), 0, velx, vely)
def test_CalcOpticalFlowPyrLK(self):
a = self.get_sample("samples/c/lena.jpg", 0)
map = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetRotationMatrix2D((256, 256), 10, 1.0, map)
b = cv.CloneMat(a)
cv.WarpAffine(a, b, map)
eig_image = cv.CreateMat(a.rows, a.cols, cv.CV_32FC1)
temp_image = cv.CreateMat(a.rows, a.cols, cv.CV_32FC1)
prevPyr = cv.CreateMat(a.rows / 3, a.cols + 8, cv.CV_8UC1)
currPyr = cv.CreateMat(a.rows / 3, a.cols + 8, cv.CV_8UC1)
prevFeatures = cv.GoodFeaturesToTrack(a, eig_image, temp_image, 400, 0.01, 0.01)
(currFeatures, status, track_error) = cv.CalcOpticalFlowPyrLK(a,
b,
prevPyr,
currPyr,
prevFeatures,
(10, 10),
3,
(cv.CV_TERMCRIT_ITER|cv.CV_TERMCRIT_EPS,20, 0.03),
0)
if 0: # enable visualization
print
print sum(status), "Points found in curr image"
for prev,this in zip(prevFeatures, currFeatures):
iprev = tuple([int(c) for c in prev])
ithis = tuple([int(c) for c in this])
cv.Circle(a, iprev, 3, 255)
cv.Circle(a, ithis, 3, 0)
cv.Line(a, iprev, ithis, 128)
self.snapL([a, b])
def test_CartToPolar(self):
x = cv.CreateMat(5, 5, cv.CV_32F)
y = cv.CreateMat(5, 5, cv.CV_32F)
mag = cv.CreateMat(5, 5, cv.CV_32F)
angle = cv.CreateMat(5, 5, cv.CV_32F)
x2 = cv.CreateMat(5, 5, cv.CV_32F)
y2 = cv.CreateMat(5, 5, cv.CV_32F)
for i in range(5):
for j in range(5):
x[i, j] = i
y[i, j] = j
for in_degrees in [False, True]:
cv.CartToPolar(x, y, mag, angle, in_degrees)
cv.PolarToCart(mag, angle, x2, y2, in_degrees)
for i in range(5):
for j in range(5):
self.assertAlmostEqual(x[i, j], x2[i, j], 1)
self.assertAlmostEqual(y[i, j], y2[i, j], 1)
def test_Circle(self):
for w,h in [(2,77), (77,2), (256, 256), (640,480)]:
img = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 1)
cv.SetZero(img)
tricky = [ -8000, -2, -1, 0, 1, h/2, h-1, h, h+1, w/2, w-1, w, w+1, 8000]
for x0 in tricky:
for y0 in tricky:
for r in [ 0, 1, 2, 3, 4, 5, w/2, w-1, w, w+1, h/2, h-1, h, h+1, 8000 ]:
for thick in [1, 2, 10]:
for t in [0, 8, 4, cv.CV_AA]:
cv.Circle(img, (x0,y0), r, 255, thick, t)
# just check that something was drawn
self.assert_(cv.Sum(img)[0] > 0)
def test_ConvertImage(self):
i1 = cv.GetImage(self.get_sample("samples/c/lena.jpg", 1))
i2 = cv.CloneImage(i1)
i3 = cv.CloneImage(i1)
cv.ConvertImage(i1, i2, cv.CV_CVTIMG_FLIP + cv.CV_CVTIMG_SWAP_RB)
self.assertNotEqual(self.hashimg(i1), self.hashimg(i2))
cv.ConvertImage(i2, i3, cv.CV_CVTIMG_FLIP + cv.CV_CVTIMG_SWAP_RB)
self.assertEqual(self.hashimg(i1), self.hashimg(i3))
def test_ConvexHull2(self):
# Draw a series of N-pointed stars, find contours, assert the contour is not convex,
# assert the hull has N segments, assert that there are N convexity defects.
def polar2xy(th, r):
return (int(400 + r * math.cos(th)), int(400 + r * math.sin(th)))
storage = cv.CreateMemStorage(0)
for way in ['CvSeq', 'CvMat', 'list']:
for points in range(3,20):
scratch = cv.CreateImage((800,800), 8, 1)
cv.SetZero(scratch)
sides = 2 * points
cv.FillPoly(scratch, [ [ polar2xy(i * 2 * math.pi / sides, [100,350][i&1]) for i in range(sides) ] ], 255)
seq = cv.FindContours(scratch, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
if way == 'CvSeq':
# pts is a CvSeq
pts = seq
elif way == 'CvMat':
# pts is a CvMat
arr = cv.CreateMat(len(seq), 1, cv.CV_32SC2)
for i,e in enumerate(seq):
arr[i,0] = e
pts = arr
elif way == 'list':
# pts is a list of 2-tuples
pts = list(seq)
else:
assert False
self.assert_(cv.CheckContourConvexity(pts) == 0)
hull = cv.ConvexHull2(pts, storage, return_points = 1)
self.assert_(cv.CheckContourConvexity(hull) == 1)
self.assert_(len(hull) == points)
if way in [ 'CvSeq', 'CvMat' ]:
defects = cv.ConvexityDefects(pts, cv.ConvexHull2(pts, storage), storage)
self.assert_(len([depth for (_,_,_,depth) in defects if (depth > 5)]) == points)
def test_CreateImage(self):
for w in [ 1, 4, 64, 512, 640]:
for h in [ 1, 4, 64, 480, 512]:
for c in [1, 2, 3, 4]:
for d in self.depths:
a = cv.CreateImage((w,h), d, c);
self.assert_(a.width == w)
self.assert_(a.height == h)
self.assert_(a.nChannels == c)
self.assert_(a.depth == d)
self.assert_(cv.GetSize(a) == (w, h))
# self.assert_(cv.GetElemType(a) == d)
self.assertRaises(cv.error, lambda: cv.CreateImage((100, 100), 9, 1))
def test_CreateMat(self):
for rows in [1, 2, 4, 16, 64, 512, 640]:
for cols in [1, 2, 4, 16, 64, 512, 640]:
for t in self.mat_types:
m = cv.CreateMat(rows, cols, t)
self.assertEqual(cv.GetElemType(m), t)
self.assertEqual(m.type, t)
self.assertRaises(cv.error, lambda: cv.CreateMat(-1, 100, cv.CV_8SC4))
self.assertRaises(cv.error, lambda: cv.CreateMat(100, -1, cv.CV_8SC4))
self.assertRaises(cv.error, lambda: cv.cvmat())
def test_DrawChessboardCorners(self):
im = cv.CreateImage((512,512), cv.IPL_DEPTH_8U, 3)
cv.SetZero(im)
cv.DrawChessboardCorners(im, (5, 5), [ ((i/5)*100+50,(i%5)*100+50) for i in range(5 * 5) ], 1)
def test_ExtractSURF(self):
img = self.get_sample("samples/c/lena.jpg", 0)
w,h = cv.GetSize(img)
for hessthresh in [ 300,400,500]:
for dsize in [0,1]:
for layers in [1,3,10]:
kp,desc = cv.ExtractSURF(img, None, cv.CreateMemStorage(), (dsize, hessthresh, 3, layers))
self.assert_(len(kp) == len(desc))
for d in desc:
self.assert_(len(d) == {0:64, 1:128}[dsize])
for pt,laplacian,size,dir,hessian in kp:
self.assert_((0 <= pt[0]) and (pt[0] <= w))
self.assert_((0 <= pt[1]) and (pt[1] <= h))
self.assert_(laplacian in [-1, 0, 1])
self.assert_((0 <= dir) and (dir <= 360))
self.assert_(hessian >= hessthresh)
def test_FillPoly(self):
scribble = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 1)
random.seed(0)
for i in range(50):
cv.SetZero(scribble)
self.assert_(cv.CountNonZero(scribble) == 0)
cv.FillPoly(scribble, [ [ (random.randrange(640), random.randrange(480)) for i in range(100) ] ], (255,))
self.assert_(cv.CountNonZero(scribble) != 0)
def test_FindChessboardCorners(self):
im = cv.CreateImage((512,512), cv.IPL_DEPTH_8U, 1)
cv.Set(im, 128)
# Empty image run
status,corners = cv.FindChessboardCorners( im, (7,7) )
# Perfect checkerboard
def xf(i,j, o):
return ((96 + o) + 40 * i, (96 + o) + 40 * j)
for i in range(8):
for j in range(8):
color = ((i ^ j) & 1) * 255
cv.Rectangle(im, xf(i,j, 0), xf(i,j, 39), color, cv.CV_FILLED)
status,corners = cv.FindChessboardCorners( im, (7,7) )
self.assert_(status)
self.assert_(len(corners) == (7 * 7))
# Exercise corner display
im3 = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 3)
cv.Merge(im, im, im, None, im3)
cv.DrawChessboardCorners(im3, (7,7), corners, status)
if 0:
self.snap(im3)
# Run it with too many corners
cv.Set(im, 128)
for i in range(40):
for j in range(40):
color = ((i ^ j) & 1) * 255
x = 30 + 6 * i
y = 30 + 4 * j
cv.Rectangle(im, (x, y), (x+4, y+4), color, cv.CV_FILLED)
status,corners = cv.FindChessboardCorners( im, (7,7) )
# XXX - this is very slow
if 0:
rng = cv.RNG(0)
cv.RandArr(rng, im, cv.CV_RAND_UNI, 0, 255.0)
self.snap(im)
status,corners = cv.FindChessboardCorners( im, (7,7) )
def test_FindContours(self):
random.seed(0)
storage = cv.CreateMemStorage()
# First run FindContours on a black image.
for mode in [cv.CV_RETR_EXTERNAL, cv.CV_RETR_LIST, cv.CV_RETR_CCOMP, cv.CV_RETR_TREE]:
for method in [cv.CV_CHAIN_CODE, cv.CV_CHAIN_APPROX_NONE, cv.CV_CHAIN_APPROX_SIMPLE, cv.CV_CHAIN_APPROX_TC89_L1, cv.CV_CHAIN_APPROX_TC89_KCOS, cv.CV_LINK_RUNS]:
scratch = cv.CreateImage((800,800), 8, 1)
cv.SetZero(scratch)
seq = cv.FindContours(scratch, storage, mode, method)
x = len(seq)
if seq:
pass
for s in seq:
pass
for trial in range(10):
scratch = cv.CreateImage((800,800), 8, 1)
cv.SetZero(scratch)
def plot(center, radius, mode):
cv.Circle(scratch, center, radius, mode, -1)
if radius < 20:
return 0
else:
newmode = 255 - mode
subs = random.choice([1,2,3])
if subs == 1:
return [ plot(center, radius - 5, newmode) ]
else:
newradius = int({ 2: radius / 2, 3: radius / 2.3 }[subs] - 5)
r = radius / 2
ret = []
for i in range(subs):
th = i * (2 * math.pi) / subs
ret.append(plot((int(center[0] + r * math.cos(th)), int(center[1] + r * math.sin(th))), newradius, newmode))
return sorted(ret)
actual = plot((400,400), 390, 255 )
seq = cv.FindContours(scratch, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
def traverse(s):
if s == None:
return 0
else:
self.assert_(abs(cv.ContourArea(s)) > 0.0)
((x,y),(w,h),th) = cv.MinAreaRect2(s, cv.CreateMemStorage())
self.assert_(((w / h) - 1.0) < 0.01)
self.assert_(abs(cv.ContourArea(s)) > 0.0)
r = []
while s:
r.append(traverse(s.v_next()))
s = s.h_next()
return sorted(r)
self.assert_(traverse(seq.v_next()) == actual)
if 1:
original = cv.CreateImage((800,800), 8, 1)
cv.SetZero(original)
cv.Circle(original, (400, 400), 200, 255, -1)
cv.Circle(original, (100, 100), 20, 255, -1)
else:
original = self.get_sample("samples/c/lena.jpg", 0)
cv.Threshold(original, original, 128, 255, cv.CV_THRESH_BINARY);
contours = cv.FindContours(original, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)
def contour_iterator(contour):
while contour:
yield contour
contour = contour.h_next()
# Should be 2 contours from the two circles above
self.assertEqual(len(list(contour_iterator(contours))), 2)
# Smoke DrawContours
sketch = cv.CreateImage(cv.GetSize(original), 8, 3)
cv.SetZero(sketch)
red = cv.RGB(255, 0, 0)
green = cv.RGB(0, 255, 0)
for c in contour_iterator(contours):
cv.DrawContours(sketch, c, red, green, 0)
# self.snap(sketch)
def test_GetAffineTransform(self):
mapping = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.GetAffineTransform([ (0,0), (1,0), (0,1) ], [ (0,0), (17,0), (0,17) ], mapping)
self.assertAlmostEqual(mapping[0,0], 17, 2)
self.assertAlmostEqual(mapping[1,1], 17, 2)
def test_GetRotationMatrix2D(self):
mapping = cv.CreateMat(2, 3, cv.CV_32FC1)
for scale in [0.0, 1.0, 2.0]:
for angle in [0.0, 360.0]:
cv.GetRotationMatrix2D((0,0), angle, scale, mapping)
for r in [0, 1]:
for c in [0, 1, 2]:
if r == c:
e = scale
else:
e = 0.0
self.assertAlmostEqual(mapping[r, c], e, 2)
def test_GetSize(self):
self.assert_(cv.GetSize(cv.CreateMat(5, 7, cv.CV_32FC1)) == (7,5))
self.assert_(cv.GetSize(cv.CreateImage((7,5), cv.IPL_DEPTH_8U, 1)) == (7,5))
def test_GetStarKeypoints(self):
src = self.get_sample("samples/c/lena.jpg", 0)
storage = cv.CreateMemStorage()
kp = cv.GetStarKeypoints(src, storage)
self.assert_(len(kp) > 0)
for (x,y),scale,r in kp:
self.assert_(0 <= x)
self.assert_(x <= cv.GetSize(src)[0])
self.assert_(0 <= y)
self.assert_(y <= cv.GetSize(src)[1])
return
scribble = cv.CreateImage(cv.GetSize(src), 8, 3)
cv.CvtColor(src, scribble, cv.CV_GRAY2BGR)
for (x,y),scale,r in kp:
print x,y,scale,r
cv.Circle(scribble, (x,y), scale, cv.RGB(255,0,0))
self.snap(scribble)
def test_GetSubRect(self):
src = cv.CreateImage((100,100), 8, 1)
data = "z" * (100 * 100)
cv.SetData(src, data, 100)
start_count = sys.getrefcount(data)
iter = 77
subs = []
for i in range(iter):
sub = cv.GetSubRect(src, (0, 0, 10, 10))
subs.append(sub)
self.assert_(sys.getrefcount(data) == (start_count + iter))
src = self.get_sample("samples/c/lena.jpg", 0)
made = cv.CreateImage(cv.GetSize(src), 8, 1)
sub = cv.CreateMat(32, 32, cv.CV_8UC1)
for x in range(0, 512, 32):
for y in range(0, 512, 32):
sub = cv.GetSubRect(src, (x, y, 32, 32))
cv.SetImageROI(made, (x, y, 32, 32))
cv.Copy(sub, made)
cv.ResetImageROI(made)
cv.AbsDiff(made, src, made)
self.assert_(cv.CountNonZero(made) == 0)
for m1 in [cv.CreateMat(1, 10, cv.CV_8UC1), cv.CreateImage((10, 1), 8, 1)]:
for i in range(10):
m1[0, i] = i
def aslist(cvmat): return list(array.array('B', cvmat.tostring()))
m2 = cv.GetSubRect(m1, (5, 0, 4, 1))
m3 = cv.GetSubRect(m2, (1, 0, 2, 1))
self.assertEqual(aslist(m1), range(10))
self.assertEqual(aslist(m2), range(5, 9))
self.assertEqual(aslist(m3), range(6, 8))
def xtest_grabCut(self):
image = self.get_sample("samples/c/lena.jpg", cv.CV_LOAD_IMAGE_COLOR)
tmp1 = cv.CreateMat(1, 13 * 5, cv.CV_32FC1)
tmp2 = cv.CreateMat(1, 13 * 5, cv.CV_32FC1)
mask = cv.CreateMat(image.rows, image.cols, cv.CV_8UC1)
cv.GrabCut(image, mask, (10,10,200,200), tmp1, tmp2, 10, cv.GC_INIT_WITH_RECT)
def test_HoughLines2_PROBABILISTIC(self):
li = cv.HoughLines2(self.yield_line_image(),
cv.CreateMemStorage(),
cv.CV_HOUGH_PROBABILISTIC,
1,
math.pi/180,
50,
50,
10)
self.assert_(len(li) > 0)
self.assert_(li[0] != None)
def test_HoughLines2_STANDARD(self):
li = cv.HoughLines2(self.yield_line_image(),
cv.CreateMemStorage(),
cv.CV_HOUGH_STANDARD,
1,
math.pi/180,
100,
0,
0)
self.assert_(len(li) > 0)
self.assert_(li[0] != None)
def test_InPaint(self):
src = self.get_sample("samples/cpp/building.jpg")
msk = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
damaged = cv.CloneMat(src)
repaired = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 3)
difference = cv.CloneImage(repaired)
cv.SetZero(msk)
for method in [ cv.CV_INPAINT_NS, cv.CV_INPAINT_TELEA ]:
for (p0,p1) in [ ((10,10), (400,400)) ]:
cv.Line(damaged, p0, p1, cv.RGB(255, 0, 255), 2)
cv.Line(msk, p0, p1, 255, 2)
cv.Inpaint(damaged, msk, repaired, 10., cv.CV_INPAINT_NS)
cv.AbsDiff(src, repaired, difference)
#self.snapL([src, damaged, repaired, difference])
def test_InitLineIterator(self):
scribble = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 1)
self.assert_(len(list(cv.InitLineIterator(scribble, (20,10), (30,10)))) == 11)
def test_InRange(self):
sz = (256,256)
Igray1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
Ilow1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
Ihi1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
Igray2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
Ilow2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
Ihi2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
Imask = cv.CreateImage(sz, cv.IPL_DEPTH_8U,1)
Imaskt = cv.CreateImage(sz,cv.IPL_DEPTH_8U,1)
cv.InRange(Igray1, Ilow1, Ihi1, Imask);
cv.InRange(Igray2, Ilow2, Ihi2, Imaskt);
cv.Or(Imask, Imaskt, Imask);
def test_Line(self):
w,h = 640,480
img = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 1)
cv.SetZero(img)
tricky = [ -8000, -2, -1, 0, 1, h/2, h-1, h, h+1, w/2, w-1, w, w+1, 8000]
for x0 in tricky:
for y0 in tricky:
for x1 in tricky:
for y1 in tricky:
for thickness in [ 0, 1, 8 ]:
for line_type in [0, 4, 8, cv.CV_AA ]:
cv.Line(img, (x0,y0), (x1,y1), 255, thickness, line_type)
# just check that something was drawn
self.assert_(cv.Sum(img)[0] > 0)
def test_MinMaxLoc(self):
scribble = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 1)
los = [ (random.randrange(480), random.randrange(640)) for i in range(100) ]
his = [ (random.randrange(480), random.randrange(640)) for i in range(100) ]
for (lo,hi) in zip(los,his):
cv.Set(scribble, 128)
scribble[lo] = 0
scribble[hi] = 255
r = cv.MinMaxLoc(scribble)
self.assert_(r == (0, 255, tuple(reversed(lo)), tuple(reversed(hi))))
def xxx_test_PyrMeanShiftFiltering(self): # XXX - ticket #306
if 0:
src = self.get_sample("samples/c/lena.jpg", cv.CV_LOAD_IMAGE_COLOR)
dst = cv.CloneMat(src)
cv.PyrMeanShiftFiltering(src, dst, 5, 5)
print src, dst
self.snap(src)
else:
r = cv.temp_test()
print r
print len(r.tostring())
self.snap(r)
def test_Reshape(self):
# 97 rows
# 12 cols
rows = 97
cols = 12
im = cv.CreateMat( rows, cols, cv.CV_32FC1 )
elems = rows * cols * 1
def crd(im):
return cv.GetSize(im) + (cv.CV_MAT_CN(cv.GetElemType(im)),)
for c in (1, 2, 3, 4):
nc,nr,nd = crd(cv.Reshape(im, c))
self.assert_(nd == c)
self.assert_((nc * nr * nd) == elems)
nc,nr,nd = crd(cv.Reshape(im, 0, 97*2))
self.assert_(nr == 97*2)
self.assert_((nc * nr * nd) == elems)
nc,nr,nd = crd(cv.Reshape(im, 3, 97*2))
self.assert_(nr == 97*2)
self.assert_(nd == 3)
self.assert_((nc * nr * nd) == elems)
# Now test ReshapeMatND
mat = cv.CreateMatND([24], cv.CV_32FC1)
cv.Set(mat, 1.0)
self.assertEqual(cv.GetDims(cv.ReshapeMatND(mat, 0, [24, 1])), (24, 1))
self.assertEqual(cv.GetDims(cv.ReshapeMatND(mat, 0, [6, 4])), (6, 4))
self.assertEqual(cv.GetDims(cv.ReshapeMatND(mat, 24, [1])), (1,))
self.assertRaises(TypeError, lambda: cv.ReshapeMatND(mat, 12, [1]))
def test_Save(self):
for o in [ cv.CreateImage((128,128), cv.IPL_DEPTH_8U, 1), cv.CreateMat(16, 16, cv.CV_32FC1), cv.CreateMatND([7,9,4], cv.CV_32FC1) ]:
cv.Save("test.save", o)
loaded = cv.Load("test.save", cv.CreateMemStorage())
self.assert_(type(o) == type(loaded))
def test_SetIdentity(self):
for r in range(1,16):
for c in range(1, 16):
for t in self.mat_types_single:
M = cv.CreateMat(r, c, t)
cv.SetIdentity(M)
for rj in range(r):
for cj in range(c):
if rj == cj:
expected = 1.0
else:
expected = 0.0
self.assertEqual(M[rj,cj], expected)
def test_SnakeImage(self):
src = self.get_sample("samples/c/lena.jpg", 0)
pts = [ (512-i,i) for i in range(0, 512, 8) ]
# Make sure that weight arguments get validated
self.assertRaises(TypeError, lambda: cv.SnakeImage(cv.GetImage(src), pts, [1,2], .01, .01, (7,7), (cv.CV_TERMCRIT_ITER, 100, 0.1)))
# Smoke by making sure that points are changed by call
r = cv.SnakeImage(cv.GetImage(src), pts, .01, .01, .01, (7,7), (cv.CV_TERMCRIT_ITER, 100, 0.1))
if 0:
cv.PolyLine(src, [ r ], 0, 255)
self.snap(src)
self.assertEqual(len(r), len(pts))
self.assertNotEqual(r, pts)
# Ensure that list of weights is same as scalar weight
w = [.01] * len(pts)
r2 = cv.SnakeImage(cv.GetImage(src), pts, w, w, w, (7,7), (cv.CV_TERMCRIT_ITER, 100, 0.1))
self.assertEqual(r, r2)
def test_KMeans2(self):
size = 500
samples = cv.CreateMat(size, 1, cv.CV_32FC3)
labels = cv.CreateMat(size, 1, cv.CV_32SC1)
centers = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.Zero(samples)
cv.Zero(labels)
cv.Zero(centers)
cv.Set(cv.GetSubRect(samples, (0, 0, 1, size/2)), (255, 255, 255))
compact = cv.KMeans2(samples, 2, labels, (cv.CV_TERMCRIT_ITER, 100, 0.1), 1, 0, centers)
self.assertEqual(int(compact), 0)
random.seed(0)
for i in range(50):
index = random.randrange(size)
if index < size/2:
self.assertEqual(samples[index, 0], (255, 255, 255))
self.assertEqual(labels[index, 0], 1)
else:
self.assertEqual(samples[index, 0], (0, 0, 0))
self.assertEqual(labels[index, 0], 0)
for cluster in (0, 1):
for channel in (0, 1, 2):
self.assertEqual(int(centers[cluster, channel]), cluster*255)
def test_Sum(self):
for r in range(1,11):
for c in range(1, 11):
for t in self.mat_types_single:
M = cv.CreateMat(r, c, t)
cv.Set(M, 1)
self.assertEqual(cv.Sum(M)[0], r * c)
def test_Threshold(self):
#""" directed test for bug 2790622 """
src = self.get_sample("samples/c/lena.jpg", 0)
results = set()
for i in range(10):
dst = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
cv.Threshold(src, dst, 128, 128, cv.CV_THRESH_BINARY)
results.add(dst.tostring())
# Should have produced the same answer every time, so results set should have size 1
self.assert_(len(results) == 1)
# ticket #71 repro attempt
image = self.get_sample("samples/c/lena.jpg", 0)
red = cv.CreateImage(cv.GetSize(image), 8, 1)
binary = cv.CreateImage(cv.GetSize(image), 8, 1)
cv.Split(image, red, None, None, None)
cv.Threshold(red, binary, 42, 255, cv.CV_THRESH_BINARY)
##############################################################################
def yield_line_image(self):
""" Needed by HoughLines tests """
src = self.get_sample("samples/cpp/building.jpg", 0)
dst = cv.CreateImage(cv.GetSize(src), 8, 1)
cv.Canny(src, dst, 50, 200, 3)
return dst
# Tests for functional areas
class AreaTests(OpenCVTests):
def test_numpy(self):
if 'fromarray' in dir(cv):
import numpy
def convert(numpydims):
""" Create a numpy array with specified dims, return the OpenCV CvMat """
a1 = numpy.array([1] * reduce(operator.__mul__, numpydims)).reshape(*numpydims).astype(numpy.float32)
return cv.fromarray(a1)
def row_col_chan(m):
col = m.cols
row = m.rows
chan = cv.CV_MAT_CN(cv.GetElemType(m))
return (row, col, chan)
self.assertEqual(row_col_chan(convert((2, 13))), (2, 13, 1))
self.assertEqual(row_col_chan(convert((2, 13, 4))), (2, 13, 4))
self.assertEqual(row_col_chan(convert((2, 13, cv.CV_CN_MAX))), (2, 13, cv.CV_CN_MAX))
self.assertRaises(TypeError, lambda: convert((2,)))
self.assertRaises(TypeError, lambda: convert((11, 17, cv.CV_CN_MAX + 1)))
for t in [cv.CV_16UC1, cv.CV_32SC1, cv.CV_32FC1]:
for d in [ (8,), (1,7), (2,3,4), (7,9,2,1,8), (1,2,3,4,5,6,7,8) ]:
total = reduce(operator.__mul__, d)
m = cv.CreateMatND(d, t)
for i in range(total):
cv.Set1D(m, i, i)
na = numpy.asarray(m).reshape((total,))
self.assertEqual(list(na), range(total))
# now do numpy -> cvmat, and verify
m2 = cv.fromarray(na, True)
# Check that new cvmat m2 contains same counting sequence
for i in range(total):
self.assertEqual(cv.Get1D(m, i)[0], i)
# Verify round-trip for 2D arrays
for rows in [2, 3, 7, 13]:
for cols in [2, 3, 7, 13]:
for allowND in [False, True]:
im = cv.CreateMatND([rows, cols], cv.CV_16UC1)
cv.SetZero(im)
a = numpy.asarray(im)
self.assertEqual(a.shape, (rows, cols))
cvmatnd = cv.fromarray(a, allowND)
self.assertEqual(cv.GetDims(cvmatnd), (rows, cols))
# im, a and cvmatnd all point to the same data, so...
for i,coord in enumerate([(0,0), (0,1), (1,0), (1,1)]):
v = 5 + i + 7
a[coord] = v
self.assertEqual(im[coord], v)
self.assertEqual(cvmatnd[coord], v)
# Cv -> Numpy 3 channel check
im = cv.CreateMatND([2, 13], cv.CV_16UC3)
self.assertEqual(numpy.asarray(im).shape, (2, 13, 3))
# multi-dimensional NumPy array
na = numpy.ones([7,9,2,1,8])
cm = cv.fromarray(na, True)
self.assertEqual(cv.GetDims(cm), (7,9,2,1,8))
# Using an array object for a CvArr parameter
ones = numpy.ones((640, 480))
r = cv.fromarray(numpy.ones((640, 480)))
cv.AddS(cv.fromarray(ones), 7, r)
self.assert_(numpy.alltrue(r == (8 * ones)))
# create arrays, use them in OpenCV and replace the the array
# looking for leaks
def randdim():
return [random.randrange(1,6) for i in range(random.randrange(1, 6))]
arrays = [numpy.ones(randdim()).astype(numpy.uint8) for i in range(10)]
cs = [cv.fromarray(a, True) for a in arrays]
for i in range(1000):
arrays[random.randrange(10)] = numpy.ones(randdim()).astype(numpy.uint8)
cs[random.randrange(10)] = cv.fromarray(arrays[random.randrange(10)], True)
for j in range(10):
self.assert_(all([c == chr(1) for c in cs[j].tostring()]))
#
m = numpy.identity(4, dtype = numpy.float32)
m = cv.fromarray(m[:3, :3])
rvec = cv.CreateMat(3, 1, cv.CV_32FC1)
rvec[0,0] = 1
rvec[1,0] = 1
rvec[2,0] = 1
cv.Rodrigues2(rvec, m)
#print m
else:
print "SKIPPING test_numpy - numpy support not built"
def test_boundscatch(self):
l2 = cv.CreateMat(256, 1, cv.CV_8U)
l2[0,0] # should be OK
self.assertRaises(cv.error, lambda: l2[1,1])
l2[0] # should be OK
self.assertRaises(cv.error, lambda: l2[299])
for n in range(1, 8):
l = cv.CreateMatND([2] * n, cv.CV_8U)
l[0] # should be OK
self.assertRaises(cv.error, lambda: l[999])
tup0 = (0,) * n
l[tup0] # should be OK
tup2 = (2,) * n
self.assertRaises(cv.error, lambda: l[tup2])
def test_stereo(self):
bm = cv.CreateStereoBMState()
def illegal_delete():
bm = cv.CreateStereoBMState()
del bm.preFilterType
def illegal_assign():
bm = cv.CreateStereoBMState()
bm.preFilterType = "foo"
self.assertRaises(TypeError, illegal_delete)
self.assertRaises(TypeError, illegal_assign)
left = self.get_sample("samples/c/lena.jpg", 0)
right = self.get_sample("samples/c/lena.jpg", 0)
disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
cv.FindStereoCorrespondenceBM(left, right, disparity, bm)
gc = cv.CreateStereoGCState(16, 2)
left_disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
right_disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
def test_stereo(self):
bm = cv.CreateStereoBMState()
def illegal_delete():
bm = cv.CreateStereoBMState()
del bm.preFilterType
def illegal_assign():
bm = cv.CreateStereoBMState()
bm.preFilterType = "foo"
self.assertRaises(TypeError, illegal_delete)
self.assertRaises(TypeError, illegal_assign)
left = self.get_sample("samples/c/lena.jpg", 0)
right = self.get_sample("samples/c/lena.jpg", 0)
disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
cv.FindStereoCorrespondenceBM(left, right, disparity, bm)
gc = cv.CreateStereoGCState(16, 2)
left_disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
right_disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
cv.FindStereoCorrespondenceGC(left, right, left_disparity, right_disparity, gc)
def test_kalman(self):
k = cv.CreateKalman(2, 1, 0)
def failing_test_exception(self):
a = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
b = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
self.assertRaises(cv.error, lambda: cv.Laplace(a, b))
def test_cvmat_accessors(self):
cvm = cv.CreateMat(20, 10, cv.CV_32FC1)
def test_depths(self):
#""" Make sure that the depth enums are unique """
self.assert_(len(self.depths) == len(set(self.depths)))
def test_leak(self):
#""" If CreateImage is not releasing image storage, then the loop below should use ~4GB of memory. """
for i in range(64000):
a = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
for i in range(64000):
a = cv.CreateMat(1024, 1024, cv.CV_8UC1)
def test_histograms(self):
def split(im):
nchans = cv.CV_MAT_CN(cv.GetElemType(im))
c = [ cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 1) for i in range(nchans) ] + [None] * (4 - nchans)
cv.Split(im, c[0], c[1], c[2], c[3])
return c[:nchans]
def imh(im):
s = split(im)
hist = cv.CreateHist([256] * len(s), cv.CV_HIST_ARRAY, [ (0,255) ] * len(s), 1)
cv.CalcHist(s, hist, 0)
return hist
dims = [180]
ranges = [(0,180)]
a = cv.CreateHist(dims, cv.CV_HIST_ARRAY , ranges, 1)
src = self.get_sample("samples/c/lena.jpg", 0)
h = imh(src)
(minv, maxv, minl, maxl) = cv.GetMinMaxHistValue(h)
self.assert_(cv.QueryHistValue_nD(h, minl) == minv)
self.assert_(cv.QueryHistValue_nD(h, maxl) == maxv)
bp = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
cv.CalcBackProject(split(src), bp, h)
bp = cv.CreateImage((cv.GetSize(src)[0]-2, cv.GetSize(src)[1]-2), cv.IPL_DEPTH_32F, 1)
cv.CalcBackProjectPatch(split(src), bp, (3,3), h, cv.CV_COMP_INTERSECT, 1)
for meth,expected in [(cv.CV_COMP_CORREL, 1.0), (cv.CV_COMP_CHISQR, 0.0), (cv.CV_COMP_INTERSECT, 1.0), (cv.CV_COMP_BHATTACHARYYA, 0.0)]:
self.assertEqual(cv.CompareHist(h, h, meth), expected)
def test_remap(self):
rng = cv.RNG(0)
maxError = 1e-6
raw = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
for x in range(0, 640, 20):
cv.Line(raw, (x,0), (x,480), 255, 1)
for y in range(0, 480, 20):
cv.Line(raw, (0,y), (640,y), 255, 1)
intrinsic_mat = cv.CreateMat(3, 3, cv.CV_32FC1)
distortion_coeffs = cv.CreateMat(1, 4, cv.CV_32FC1)
cv.SetZero(intrinsic_mat)
intrinsic_mat[0,2] = 320.0
intrinsic_mat[1,2] = 240.0
intrinsic_mat[0,0] = 320.0
intrinsic_mat[1,1] = 320.0
intrinsic_mat[2,2] = 1.0
cv.SetZero(distortion_coeffs)
distortion_coeffs[0,0] = 1e-1
mapx = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
mapy = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
cv.SetZero(mapx)
cv.SetZero(mapy)
cv.InitUndistortMap(intrinsic_mat, distortion_coeffs, mapx, mapy)
rect = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
(w,h) = (640,480)
rMapxy = cv.CreateMat(h, w, cv.CV_16SC2)
rMapa = cv.CreateMat(h, w, cv.CV_16UC1)
cv.ConvertMaps(mapx,mapy,rMapxy,rMapa)
cv.Remap(raw, rect, mapx, mapy)
cv.Remap(raw, rect, rMapxy, rMapa)
cv.Undistort2(raw, rect, intrinsic_mat, distortion_coeffs)
for w in [1, 4, 4095, 4096, 4097, 4100]:
p = cv.CreateImage((w,256), 8, 1)
up = cv.CreateImage((w,256), 8, 1)
cv.Undistort2(p, up, intrinsic_mat, distortion_coeffs)
fptypes = [cv.CV_32FC1, cv.CV_64FC1]
pointsCount = 7
for t0 in fptypes:
for t1 in fptypes:
for t2 in fptypes:
for t3 in fptypes:
rotation_vector = cv.CreateMat(1, 3, t0)
translation_vector = cv.CreateMat(1, 3, t1)
cv.RandArr(rng, rotation_vector, cv.CV_RAND_UNI, -1.0, 1.0)
cv.RandArr(rng, translation_vector, cv.CV_RAND_UNI, -1.0, 1.0)
object_points = cv.CreateMat(pointsCount, 3, t2)
image_points = cv.CreateMat(pointsCount, 2, t3)
cv.RandArr(rng, object_points, cv.CV_RAND_UNI, -100.0, 100.0)
cv.ProjectPoints2(object_points, rotation_vector, translation_vector, intrinsic_mat, distortion_coeffs, image_points)
reshaped_object_points = cv.Reshape(object_points, 1, 3)
reshaped_image_points = cv.CreateMat(2, pointsCount, t3)
cv.ProjectPoints2(object_points, rotation_vector, translation_vector, intrinsic_mat, distortion_coeffs, reshaped_image_points)
error = cv.Norm(reshaped_image_points, cv.Reshape(image_points, 1, 2))
self.assert_(error < maxError)
def test_arithmetic(self):
a = cv.CreateMat(4, 4, cv.CV_8UC1)
a[0,0] = 50.0
b = cv.CreateMat(4, 4, cv.CV_8UC1)
b[0,0] = 4.0
d = cv.CreateMat(4, 4, cv.CV_8UC1)
cv.Add(a, b, d)
self.assertEqual(d[0,0], 54.0)
cv.Mul(a, b, d)
self.assertEqual(d[0,0], 200.0)
def failing_test_cvtcolor(self):
src3 = self.get_sample("samples/c/lena.jpg")
src1 = self.get_sample("samples/c/lena.jpg", 0)
dst8u = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_8U, c)) for c in (1,2,3,4)])
dst16u = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_16U, c)) for c in (1,2,3,4)])
dst32f = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_32F, c)) for c in (1,2,3,4)])
for srcf in ["BGR", "RGB"]:
for dstf in ["Luv"]:
cv.CvtColor(src3, dst8u[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
cv.CvtColor(src3, dst32f[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
cv.CvtColor(src3, dst8u[3], eval("cv.CV_%s2%s" % (dstf, srcf)))
for srcf in ["BayerBG", "BayerGB", "BayerGR"]:
for dstf in ["RGB", "BGR"]:
cv.CvtColor(src1, dst8u[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
def test_voronoi(self):
w,h = 500,500
storage = cv.CreateMemStorage(0)
def facet_edges(e0):
e = e0
while True:
e = cv.Subdiv2DGetEdge(e, cv.CV_NEXT_AROUND_LEFT)
yield e
if e == e0:
break
def areas(edges):
seen = []
seensorted = []
for edge in edges:
pts = [ cv.Subdiv2DEdgeOrg(e) for e in facet_edges(edge) ]
if not (None in pts):
l = [p.pt for p in pts]
ls = sorted(l)
if not(ls in seensorted):
seen.append(l)
seensorted.append(ls)
return seen
for npoints in range(1, 200):
points = [ (random.randrange(w), random.randrange(h)) for i in range(npoints) ]
subdiv = cv.CreateSubdivDelaunay2D( (0,0,w,h), storage )
for p in points:
cv.SubdivDelaunay2DInsert( subdiv, p)
cv.CalcSubdivVoronoi2D(subdiv)
ars = areas([ cv.Subdiv2DRotateEdge(e, 1) for e in subdiv.edges ] + [ cv.Subdiv2DRotateEdge(e, 3) for e in subdiv.edges ])
self.assert_(len(ars) == len(set(points)))
if False:
img = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 3)
cv.SetZero(img)
def T(x): return int(x) # int(300+x/16)
for pts in ars:
cv.FillConvexPoly( img, [(T(x),T(y)) for (x,y) in pts], cv.RGB(100+random.randrange(156),random.randrange(256),random.randrange(256)), cv.CV_AA, 0 );
for x,y in points:
cv.Circle(img, (T(x), T(y)), 3, cv.RGB(0,0,0), -1)
cv.ShowImage("snap", img)
if cv.WaitKey(10) > 0:
break
def perf_test_pow(self):
mt = cv.CreateMat(1000, 1000, cv.CV_32FC1)
dst = cv.CreateMat(1000, 1000, cv.CV_32FC1)
rng = cv.RNG(0)
cv.RandArr(rng, mt, cv.CV_RAND_UNI, 0, 1000.0)
mt[0,0] = 10
print
for a in [0.5, 2.0, 2.3, 2.4, 3.0, 37.1786] + [2.4]*10:
started = time.time()
for i in range(10):
cv.Pow(mt, dst, a)
took = (time.time() - started) / 1e7
print "%4.1f took %f ns" % (a, took * 1e9)
print dst[0,0], 10 ** 2.4
def test_access_row_col(self):
src = cv.CreateImage((8,3), 8, 1)
# Put these words
# Achilles
# Benedict
# Congreve
# in an array (3 rows, 8 columns).
# Then extract the array in various ways.
for r,w in enumerate(("Achilles", "Benedict", "Congreve")):
for c,v in enumerate(w):
src[r,c] = ord(v)
self.assertEqual(src.tostring(), "AchillesBenedictCongreve")
self.assertEqual(src[:,:].tostring(), "AchillesBenedictCongreve")
self.assertEqual(src[:,:4].tostring(), "AchiBeneCong")
self.assertEqual(src[:,0].tostring(), "ABC")
self.assertEqual(src[:,4:].tostring(), "llesdictreve")
self.assertEqual(src[::2,:].tostring(), "AchillesCongreve")
self.assertEqual(src[1:,:].tostring(), "BenedictCongreve")
self.assertEqual(src[1:2,:].tostring(), "Benedict")
self.assertEqual(src[::2,:4].tostring(), "AchiCong")
# The mats share the same storage, so updating one should update them all
lastword = src[2]
self.assertEqual(lastword.tostring(), "Congreve")
src[2,0] = ord('K')
self.assertEqual(lastword.tostring(), "Kongreve")
src[2,0] = ord('C')
# ABCD
# EFGH
# IJKL
#
# MNOP
# QRST
# UVWX
mt = cv.CreateMatND([2,3,4], cv.CV_8UC1)
for i in range(2):
for j in range(3):
for k in range(4):
mt[i,j,k] = ord('A') + k + 4 * (j + 3 * i)
self.assertEqual(mt[:,:,:1].tostring(), "AEIMQU")
self.assertEqual(mt[:,:1,:].tostring(), "ABCDMNOP")
self.assertEqual(mt[:1,:,:].tostring(), "ABCDEFGHIJKL")
self.assertEqual(mt[1,1].tostring(), "QRST")
self.assertEqual(mt[:,::2,:].tostring(), "ABCDIJKLMNOPUVWX")
# Exercise explicit GetRows
self.assertEqual(cv.GetRows(src, 0, 3).tostring(), "AchillesBenedictCongreve")
self.assertEqual(cv.GetRows(src, 0, 3, 1).tostring(), "AchillesBenedictCongreve")
self.assertEqual(cv.GetRows(src, 0, 3, 2).tostring(), "AchillesCongreve")
self.assertEqual(cv.GetRow(src, 0).tostring(), "Achilles")
self.assertEqual(cv.GetCols(src, 0, 4).tostring(), "AchiBeneCong")
self.assertEqual(cv.GetCol(src, 0).tostring(), "ABC")
self.assertEqual(cv.GetCol(src, 1).tostring(), "ceo")
self.assertEqual(cv.GetDiag(src, 0).tostring(), "Aen")
# Check that matrix type is preserved by the various operators
for mt in self.mat_types:
m = cv.CreateMat(5, 3, mt)
self.assertEqual(mt, cv.GetElemType(cv.GetRows(m, 0, 2)))
self.assertEqual(mt, cv.GetElemType(cv.GetRow(m, 0)))
self.assertEqual(mt, cv.GetElemType(cv.GetCols(m, 0, 2)))
self.assertEqual(mt, cv.GetElemType(cv.GetCol(m, 0)))
self.assertEqual(mt, cv.GetElemType(cv.GetDiag(m, 0)))
self.assertEqual(mt, cv.GetElemType(m[0]))
self.assertEqual(mt, cv.GetElemType(m[::2]))
self.assertEqual(mt, cv.GetElemType(m[:,0]))
self.assertEqual(mt, cv.GetElemType(m[:,:]))
self.assertEqual(mt, cv.GetElemType(m[::2,:]))
def test_addS_3D(self):
for dim in [ [1,1,4], [2,2,3], [7,4,3] ]:
for ty,ac in [ (cv.CV_32FC1, 'f'), (cv.CV_64FC1, 'd')]:
mat = cv.CreateMatND(dim, ty)
mat2 = cv.CreateMatND(dim, ty)
for increment in [ 0, 3, -1 ]:
cv.SetData(mat, array.array(ac, range(dim[0] * dim[1] * dim[2])), 0)
cv.AddS(mat, increment, mat2)
for i in range(dim[0]):
for j in range(dim[1]):
for k in range(dim[2]):
self.assert_(mat2[i,j,k] == mat[i,j,k] + increment)
def test_buffers(self):
ar = array.array('f', [7] * (360*640))
m = cv.CreateMat(360, 640, cv.CV_32FC1)
cv.SetData(m, ar, 4 * 640)
self.assert_(m[0,0] == 7.0)
m = cv.CreateMatND((360, 640), cv.CV_32FC1)
cv.SetData(m, ar, 4 * 640)
self.assert_(m[0,0] == 7.0)
m = cv.CreateImage((640, 360), cv.IPL_DEPTH_32F, 1)
cv.SetData(m, ar, 4 * 640)
self.assert_(m[0,0] == 7.0)
def xxtest_Filters(self):
print
m = cv.CreateMat(360, 640, cv.CV_32FC1)
d = cv.CreateMat(360, 640, cv.CV_32FC1)
for k in range(3, 21, 2):
started = time.time()
for i in range(1000):
cv.Smooth(m, m, param1=k)
print k, "took", time.time() - started
def assertSame(self, a, b):
w,h = cv.GetSize(a)
d = cv.CreateMat(h, w, cv.CV_8UC1)
cv.AbsDiff(a, b, d)
self.assert_(cv.CountNonZero(d) == 0)
def test_text(self):
img = cv.CreateImage((640,40), cv.IPL_DEPTH_8U, 1)
cv.SetZero(img)
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1)
message = "XgfooX"
cv.PutText(img, message, (320,30), font, 255)
((w,h),bl) = cv.GetTextSize(message, font)
# Find nonzero in X and Y
Xs = []
for x in range(640):
cv.SetImageROI(img, (x, 0, 1, 40))
Xs.append(cv.Sum(img)[0] > 0)
def firstlast(l):
return (l.index(True), len(l) - list(reversed(l)).index(True))
Ys = []
for y in range(40):
cv.SetImageROI(img, (0, y, 640, 1))
Ys.append(cv.Sum(img)[0] > 0)
x0,x1 = firstlast(Xs)
y0,y1 = firstlast(Ys)
actual_width = x1 - x0
actual_height = y1 - y0
# actual_width can be up to 8 pixels smaller than GetTextSize says
self.assert_(actual_width <= w)
self.assert_((w - actual_width) <= 8)
# actual_height can be up to 4 pixels smaller than GetTextSize says
self.assert_(actual_height <= (h + bl))
self.assert_(((h + bl) - actual_height) <= 4)
cv.ResetImageROI(img)
self.assert_(w != 0)
self.assert_(h != 0)
def test_sizes(self):
sizes = [ 1, 2, 3, 97, 255, 256, 257, 947 ]
for w in sizes:
for h in sizes:
# Create an IplImage
im = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 1)
cv.Set(im, 1)
self.assert_(cv.Sum(im)[0] == (w * h))
del im
# Create a CvMat
mt = cv.CreateMat(h, w, cv.CV_8UC1)
cv.Set(mt, 1)
self.assert_(cv.Sum(mt)[0] == (w * h))
random.seed(7)
for dim in range(1, cv.CV_MAX_DIM + 1):
for attempt in range(10):
dims = [ random.choice([1,1,1,1,2,3]) for i in range(dim) ]
mt = cv.CreateMatND(dims, cv.CV_8UC1)
cv.SetZero(mt)
self.assert_(cv.Sum(mt)[0] == 0)
# Set to all-ones, verify the sum
cv.Set(mt, 1)
expected = 1
for d in dims:
expected *= d
self.assert_(cv.Sum(mt)[0] == expected)
def test_random(self):
seeds = [ 0, 1, 2**48, 2**48 + 1 ]
sequences = set()
for s in seeds:
rng = cv.RNG(s)
sequences.add(str([cv.RandInt(rng) for i in range(10)]))
self.assert_(len(seeds) == len(sequences))
rng = cv.RNG(0)
im = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
cv.RandArr(rng, im, cv.CV_RAND_UNI, 0, 256)
cv.RandArr(rng, im, cv.CV_RAND_NORMAL, 128, 30)
if 1:
hist = cv.CreateHist([ 256 ], cv.CV_HIST_ARRAY, [ (0,255) ], 1)
cv.CalcHist([im], hist)
rng = cv.RNG()
for i in range(1000):
v = cv.RandReal(rng)
self.assert_(0 <= v)
self.assert_(v < 1)
for mode in [ cv.CV_RAND_UNI, cv.CV_RAND_NORMAL ]:
for fmt in self.mat_types:
mat = cv.CreateMat(64, 64, fmt)
cv.RandArr(cv.RNG(), mat, mode, (0,0,0,0), (1,1,1,1))
def test_MixChannels(self):
# First part - test the single case described in the documentation
rgba = cv.CreateMat(100, 100, cv.CV_8UC4)
bgr = cv.CreateMat(100, 100, cv.CV_8UC3)
alpha = cv.CreateMat(100, 100, cv.CV_8UC1)
cv.Set(rgba, (1,2,3,4))
cv.MixChannels([rgba], [bgr, alpha], [
(0, 2), # rgba[0] -> bgr[2]
(1, 1), # rgba[1] -> bgr[1]
(2, 0), # rgba[2] -> bgr[0]
(3, 3) # rgba[3] -> alpha[0]
])
self.assert_(bgr[0,0] == (3,2,1))
self.assert_(alpha[0,0] == 4)
# Second part. Choose random sets of sources and destinations,
# fill them with known values, choose random channel assignments,
# run cvMixChannels and check that the result is as expected.
random.seed(1)
for rows in [1,2,4,13,64,1000]:
for cols in [1,2,4,13,64,1000]:
for loop in range(5):
sources = [random.choice([1, 2, 3, 4]) for i in range(8)]
dests = [random.choice([1, 2, 3, 4]) for i in range(8)]
# make sure that fromTo does not have duplicates in dests, otherwise the result is not determined
while 1:
fromTo = [(random.randrange(-1, sum(sources)), random.randrange(sum(dests))) for i in range(random.randrange(1, 30))]
dests_set = list(set([j for (i, j) in fromTo]))
if len(dests_set) == len(dests):
break
# print sources
# print dests
# print fromTo
def CV_8UC(n):
return [cv.CV_8UC1, cv.CV_8UC2, cv.CV_8UC3, cv.CV_8UC4][n-1]
source_m = [cv.CreateMat(rows, cols, CV_8UC(c)) for c in sources]
dest_m = [cv.CreateMat(rows, cols, CV_8UC(c)) for c in dests]
def m00(m):
# return the contents of the N channel mat m[0,0] as a N-length list
chans = cv.CV_MAT_CN(cv.GetElemType(m))
if chans == 1:
return [m[0,0]]
else:
return list(m[0,0])[:chans]
# Sources numbered from 50, destinations numbered from 100
for i in range(len(sources)):
s = sum(sources[:i]) + 50
cv.Set(source_m[i], (s, s+1, s+2, s+3))
self.assertEqual(m00(source_m[i]), [s, s+1, s+2, s+3][:sources[i]])
for i in range(len(dests)):
s = sum(dests[:i]) + 100
cv.Set(dest_m[i], (s, s+1, s+2, s+3))
self.assertEqual(m00(dest_m[i]), [s, s+1, s+2, s+3][:dests[i]])
# now run the sanity check
for i in range(len(sources)):
s = sum(sources[:i]) + 50
self.assertEqual(m00(source_m[i]), [s, s+1, s+2, s+3][:sources[i]])
for i in range(len(dests)):
s = sum(dests[:i]) + 100
self.assertEqual(m00(dest_m[i]), [s, s+1, s+2, s+3][:dests[i]])
cv.MixChannels(source_m, dest_m, fromTo)
expected = range(100, 100 + sum(dests))
for (i, j) in fromTo:
if i == -1:
expected[j] = 0.0
else:
expected[j] = 50 + i
actual = sum([m00(m) for m in dest_m], [])
self.assertEqual(sum([m00(m) for m in dest_m], []), expected)
def test_allocs(self):
mats = [ 0 for i in range(20) ]
for i in range(1000):
m = cv.CreateMat(random.randrange(10, 512), random.randrange(10, 512), cv.CV_8UC1)
j = random.randrange(len(mats))
mats[j] = m
cv.SetZero(m)
def test_access(self):
cnames = { 1:cv.CV_32FC1, 2:cv.CV_32FC2, 3:cv.CV_32FC3, 4:cv.CV_32FC4 }
for w in range(1,11):
for h in range(2,11):
for c in [1,2]:
for o in [ cv.CreateMat(h, w, cnames[c]), cv.CreateImage((w,h), cv.IPL_DEPTH_32F, c) ][1:]:
pattern = [ (i,j) for i in range(w) for j in range(h) ]
random.shuffle(pattern)
for k,(i,j) in enumerate(pattern):
if c == 1:
o[j,i] = k
else:
o[j,i] = (k,) * c
for k,(i,j) in enumerate(pattern):
if c == 1:
self.assert_(o[j,i] == k)
else:
self.assert_(o[j,i] == (k,)*c)
test_mat = cv.CreateMat(2, 3, cv.CV_32FC1)
cv.SetData(test_mat, array.array('f', range(6)), 12)
self.assertEqual(cv.GetDims(test_mat[0]), (1, 3))
self.assertEqual(cv.GetDims(test_mat[1]), (1, 3))
self.assertEqual(cv.GetDims(test_mat[0:1]), (1, 3))
self.assertEqual(cv.GetDims(test_mat[1:2]), (1, 3))
self.assertEqual(cv.GetDims(test_mat[-1:]), (1, 3))
self.assertEqual(cv.GetDims(test_mat[-1]), (1, 3))
def xxxtest_corners(self):
a = cv.LoadImage("foo-mono.png", 0)
cv.AdaptiveThreshold(a, a, 255, param1=5)
scribble = cv.CreateImage(cv.GetSize(a), 8, 3)
cv.CvtColor(a, scribble, cv.CV_GRAY2BGR)
if 0:
eig_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
temp_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
pts = cv.GoodFeaturesToTrack(a, eig_image, temp_image, 100, 0.04, 2, use_harris=1)
for p in pts:
cv.Circle( scribble, p, 1, cv.RGB(255,0,0), -1 )
self.snap(scribble)
canny = cv.CreateImage(cv.GetSize(a), 8, 1)
cv.SubRS(a, 255, canny)
self.snap(canny)
li = cv.HoughLines2(canny,
cv.CreateMemStorage(),
cv.CV_HOUGH_STANDARD,
1,
math.pi/180,
60,
0,
0)
for (rho,theta) in li:
print rho,theta
c = math.cos(theta)
s = math.sin(theta)
x0 = c*rho
y0 = s*rho
cv.Line(scribble,
(x0 + 1000*(-s), y0 + 1000*c),
(x0 + -1000*(-s), y0 - 1000*c),
(0,255,0))
self.snap(scribble)
def test_calibration(self):
def get_corners(mono, refine = False):
(ok, corners) = cv.FindChessboardCorners(mono, (num_x_ints, num_y_ints), cv.CV_CALIB_CB_ADAPTIVE_THRESH | cv.CV_CALIB_CB_NORMALIZE_IMAGE)
if refine and ok:
corners = cv.FindCornerSubPix(mono, corners, (5,5), (-1,-1), ( cv.CV_TERMCRIT_EPS+cv.CV_TERMCRIT_ITER, 30, 0.1 ))
return (ok, corners)
def mk_object_points(nimages, squaresize = 1):
opts = cv.CreateMat(nimages * num_pts, 3, cv.CV_32FC1)
for i in range(nimages):
for j in range(num_pts):
opts[i * num_pts + j, 0] = (j / num_x_ints) * squaresize
opts[i * num_pts + j, 1] = (j % num_x_ints) * squaresize
opts[i * num_pts + j, 2] = 0
return opts
def mk_image_points(goodcorners):
ipts = cv.CreateMat(len(goodcorners) * num_pts, 2, cv.CV_32FC1)
for (i, co) in enumerate(goodcorners):
for j in range(num_pts):
ipts[i * num_pts + j, 0] = co[j][0]
ipts[i * num_pts + j, 1] = co[j][1]
return ipts
def mk_point_counts(nimages):
npts = cv.CreateMat(nimages, 1, cv.CV_32SC1)
for i in range(nimages):
npts[i, 0] = num_pts
return npts
def cvmat_iterator(cvmat):
for i in range(cvmat.rows):
for j in range(cvmat.cols):
yield cvmat[i,j]
def image_from_archive(tar, name):
member = tar.getmember(name)
filedata = tar.extractfile(member).read()
imagefiledata = cv.CreateMat(1, len(filedata), cv.CV_8UC1)
cv.SetData(imagefiledata, filedata, len(filedata))
return cv.DecodeImageM(imagefiledata)
urllib.urlretrieve("http://docs.opencv.org/data/camera_calibration.tar.gz", "camera_calibration.tar.gz")
tf = tarfile.open("camera_calibration.tar.gz")
num_x_ints = 8
num_y_ints = 6
num_pts = num_x_ints * num_y_ints
leftimages = [image_from_archive(tf, "wide/left%04d.pgm" % i) for i in range(3, 15)]
size = cv.GetSize(leftimages[0])
# Monocular test
if True:
corners = [get_corners(i) for i in leftimages]
goodcorners = [co for (im, (ok, co)) in zip(leftimages, corners) if ok]
ipts = mk_image_points(goodcorners)
opts = mk_object_points(len(goodcorners), .1)
npts = mk_point_counts(len(goodcorners))
intrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
distortion = cv.CreateMat(4, 1, cv.CV_64FC1)
cv.SetZero(intrinsics)
cv.SetZero(distortion)
# focal lengths have 1/1 ratio
intrinsics[0,0] = 1.0
intrinsics[1,1] = 1.0
cv.CalibrateCamera2(opts, ipts, npts,
cv.GetSize(leftimages[0]),
intrinsics,
distortion,
cv.CreateMat(len(goodcorners), 3, cv.CV_32FC1),
cv.CreateMat(len(goodcorners), 3, cv.CV_32FC1),
flags = 0) # cv.CV_CALIB_ZERO_TANGENT_DIST)
# print "D =", list(cvmat_iterator(distortion))
# print "K =", list(cvmat_iterator(intrinsics))
newK = cv.CreateMat(3, 3, cv.CV_64FC1)
cv.GetOptimalNewCameraMatrix(intrinsics, distortion, size, 1.0, newK)
# print "newK =", list(cvmat_iterator(newK))
mapx = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
mapy = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
for K in [ intrinsics, newK ]:
cv.InitUndistortMap(K, distortion, mapx, mapy)
for img in leftimages[:1]:
r = cv.CloneMat(img)
cv.Remap(img, r, mapx, mapy)
# cv.ShowImage("snap", r)
# cv.WaitKey()
rightimages = [image_from_archive(tf, "wide/right%04d.pgm" % i) for i in range(3, 15)]
# Stereo test
if True:
lcorners = [get_corners(i) for i in leftimages]
rcorners = [get_corners(i) for i in rightimages]
good = [(lco, rco) for ((lok, lco), (rok, rco)) in zip(lcorners, rcorners) if (lok and rok)]
lipts = mk_image_points([l for (l, r) in good])
ripts = mk_image_points([r for (l, r) in good])
opts = mk_object_points(len(good), .108)
npts = mk_point_counts(len(good))
flags = cv.CV_CALIB_FIX_ASPECT_RATIO | cv.CV_CALIB_FIX_INTRINSIC
flags = cv.CV_CALIB_SAME_FOCAL_LENGTH + cv.CV_CALIB_FIX_PRINCIPAL_POINT + cv.CV_CALIB_ZERO_TANGENT_DIST
flags = 0
T = cv.CreateMat(3, 1, cv.CV_64FC1)
R = cv.CreateMat(3, 3, cv.CV_64FC1)
lintrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
ldistortion = cv.CreateMat(4, 1, cv.CV_64FC1)
rintrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
rdistortion = cv.CreateMat(4, 1, cv.CV_64FC1)
lR = cv.CreateMat(3, 3, cv.CV_64FC1)
rR = cv.CreateMat(3, 3, cv.CV_64FC1)
lP = cv.CreateMat(3, 4, cv.CV_64FC1)
rP = cv.CreateMat(3, 4, cv.CV_64FC1)
lmapx = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
lmapy = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
rmapx = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
rmapy = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
cv.SetIdentity(lintrinsics)
cv.SetIdentity(rintrinsics)
lintrinsics[0,2] = size[0] * 0.5
lintrinsics[1,2] = size[1] * 0.5
rintrinsics[0,2] = size[0] * 0.5
rintrinsics[1,2] = size[1] * 0.5
cv.SetZero(ldistortion)
cv.SetZero(rdistortion)
cv.StereoCalibrate(opts, lipts, ripts, npts,
lintrinsics, ldistortion,
rintrinsics, rdistortion,
size,
R, # R
T, # T
cv.CreateMat(3, 3, cv.CV_32FC1), # E
cv.CreateMat(3, 3, cv.CV_32FC1), # F
(cv.CV_TERMCRIT_ITER + cv.CV_TERMCRIT_EPS, 30, 1e-5),
flags)
for a in [-1, 0, 1]:
cv.StereoRectify(lintrinsics,
rintrinsics,
ldistortion,
rdistortion,
size,
R,
T,
lR, rR, lP, rP,
alpha = a)
cv.InitUndistortRectifyMap(lintrinsics, ldistortion, lR, lP, lmapx, lmapy)
cv.InitUndistortRectifyMap(rintrinsics, rdistortion, rR, rP, rmapx, rmapy)
for l,r in zip(leftimages, rightimages)[:1]:
l_ = cv.CloneMat(l)
r_ = cv.CloneMat(r)
cv.Remap(l, l_, lmapx, lmapy)
cv.Remap(r, r_, rmapx, rmapy)
# cv.ShowImage("snap", l_)
# cv.WaitKey()
def xxx_test_Disparity(self):
print
for t in ["8U", "8S", "16U", "16S", "32S", "32F", "64F" ]:
for c in [1,2,3,4]:
nm = "%sC%d" % (t, c)
print "int32 CV_%s=%d" % (nm, eval("cv.CV_%s" % nm))
return
integral = cv.CreateImage((641,481), cv.IPL_DEPTH_32S, 1)
L = cv.LoadImage("f0-left.png", 0)
R = cv.LoadImage("f0-right.png", 0)
d = cv.CreateImage(cv.GetSize(L), cv.IPL_DEPTH_8U, 1)
Rn = cv.CreateImage(cv.GetSize(L), cv.IPL_DEPTH_8U, 1)
started = time.time()
for i in range(100):
cv.AbsDiff(L, R, d)
cv.Integral(d, integral)
cv.SetImageROI(R, (1, 1, 639, 479))
cv.SetImageROI(Rn, (0, 0, 639, 479))
cv.Copy(R, Rn)
R = Rn
cv.ResetImageROI(R)
print 1e3 * (time.time() - started) / 100, "ms"
# self.snap(d)
def local_test_lk(self):
seq = [cv.LoadImage("track/%06d.png" % i, 0) for i in range(40)]
crit = (cv.CV_TERMCRIT_ITER, 100, 0.1)
crit = (cv.CV_TERMCRIT_EPS, 0, 0.001)
for i in range(1,40):
r = cv.CalcOpticalFlowPyrLK(seq[0], seq[i], None, None, [(32,32)], (7,7), 0, crit, 0)
pos = r[0][0]
#print pos, r[2]
a = cv.CreateImage((1024,1024), 8, 1)
b = cv.CreateImage((1024,1024), 8, 1)
cv.Resize(seq[0], a, cv.CV_INTER_NN)
cv.Resize(seq[i], b, cv.CV_INTER_NN)
cv.Line(a, (0, 512), (1024, 512), 255)
cv.Line(a, (512,0), (512,1024), 255)
x,y = [int(c) for c in pos]
cv.Line(b, (0, y*16), (1024, y*16), 255)
cv.Line(b, (x*16,0), (x*16,1024), 255)
#self.snapL([a,b])
def local_test_Haar(self):
import os
hcfile = os.environ['OPENCV_ROOT'] + '/share/opencv/haarcascades/haarcascade_frontalface_default.xml'
hc = cv.Load(hcfile)
img = cv.LoadImage('Stu.jpg', 0)
faces = cv.HaarDetectObjects(img, hc, cv.CreateMemStorage())
self.assert_(len(faces) > 0)
for (x,y,w,h),n in faces:
cv.Rectangle(img, (x,y), (x+w,y+h), 255)
#self.snap(img)
def test_create(self):
#""" CvCreateImage, CvCreateMat and the header-only form """
for (w,h) in [ (320,400), (640,480), (1024, 768) ]:
data = "z" * (w * h)
im = cv.CreateImage((w,h), 8, 1)
cv.SetData(im, data, w)
im2 = cv.CreateImageHeader((w,h), 8, 1)
cv.SetData(im2, data, w)
self.assertSame(im, im2)
m = cv.CreateMat(h, w, cv.CV_8UC1)
cv.SetData(m, data, w)
m2 = cv.CreateMatHeader(h, w, cv.CV_8UC1)
cv.SetData(m2, data, w)
self.assertSame(m, m2)
self.assertSame(im, m)
self.assertSame(im2, m2)
def test_casts(self):
im = cv.GetImage(self.get_sample("samples/c/lena.jpg", 0))
data = im.tostring()
cv.SetData(im, data, cv.GetSize(im)[0])
start_count = sys.getrefcount(data)
# Conversions should produce same data
self.assertSame(im, cv.GetImage(im))
m = cv.GetMat(im)
self.assertSame(im, m)
self.assertSame(m, cv.GetImage(m))
im2 = cv.GetImage(m)
self.assertSame(im, im2)
self.assertEqual(sys.getrefcount(data), start_count + 2)
del im2
self.assertEqual(sys.getrefcount(data), start_count + 1)
del m
self.assertEqual(sys.getrefcount(data), start_count)
del im
self.assertEqual(sys.getrefcount(data), start_count - 1)
def test_morphological(self):
im = cv.CreateImage((128, 128), cv.IPL_DEPTH_8U, 1)
cv.Resize(cv.GetImage(self.get_sample("samples/c/lena.jpg", 0)), im)
dst = cv.CloneImage(im)
# Check defaults by asserting that all these operations produce the same image
funs = [
lambda: cv.Dilate(im, dst),
lambda: cv.Dilate(im, dst, None),
lambda: cv.Dilate(im, dst, iterations = 1),
lambda: cv.Dilate(im, dst, element = None),
lambda: cv.Dilate(im, dst, iterations = 1, element = None),
lambda: cv.Dilate(im, dst, element = None, iterations = 1),
]
src_h = self.hashimg(im)
hashes = set()
for f in funs:
f()
hashes.add(self.hashimg(dst))
self.assertNotEqual(src_h, self.hashimg(dst))
# Source image should be untouched
self.assertEqual(self.hashimg(im), src_h)
# All results should be same
self.assertEqual(len(hashes), 1)
# self.snap(dst)
shapes = [eval("cv.CV_SHAPE_%s" % s) for s in ['RECT', 'CROSS', 'ELLIPSE']]
elements = [cv.CreateStructuringElementEx(sz, sz, sz / 2 + 1, sz / 2 + 1, shape) for sz in [3, 4, 7, 20] for shape in shapes]
elements += [cv.CreateStructuringElementEx(7, 7, 3, 3, cv.CV_SHAPE_CUSTOM, [1] * 49)]
for e in elements:
for iter in [1, 2]:
cv.Dilate(im, dst, e, iter)
cv.Erode(im, dst, e, iter)
temp = cv.CloneImage(im)
for op in ["OPEN", "CLOSE", "GRADIENT", "TOPHAT", "BLACKHAT"]:
cv.MorphologyEx(im, dst, temp, e, eval("cv.CV_MOP_%s" % op), iter)
def test_getmat_nd(self):
# 1D CvMatND should yield (N,1) CvMat
matnd = cv.CreateMatND([13], cv.CV_8UC1)
self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (13, 1))
# 2D CvMatND should yield 2D CvMat
matnd = cv.CreateMatND([11, 12], cv.CV_8UC1)
self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (11, 12))
if 0: # XXX - ticket #149
# 3D CvMatND should yield (N,1) CvMat
matnd = cv.CreateMatND([7, 8, 9], cv.CV_8UC1)
self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (7 * 8 * 9, 1))
def test_clipline(self):
self.assert_(cv.ClipLine((100,100), (-100,0), (500,0)) == ((0,0), (99,0)))
self.assert_(cv.ClipLine((100,100), (-100,0), (-200,0)) == None)
def test_smoke_image_processing(self):
src = self.get_sample("samples/c/lena.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
#dst = cv.CloneImage(src)
for aperture_size in [1, 3, 5, 7]:
dst_16s = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_16S, 1)
dst_32f = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_32F, 1)
cv.Sobel(src, dst_16s, 1, 1, aperture_size)
cv.Laplace(src, dst_16s, aperture_size)
cv.PreCornerDetect(src, dst_32f)
eigendst = cv.CreateImage((6*cv.GetSize(src)[0], cv.GetSize(src)[1]), cv.IPL_DEPTH_32F, 1)
cv.CornerEigenValsAndVecs(src, eigendst, 8, aperture_size)
cv.CornerMinEigenVal(src, dst_32f, 8, aperture_size)
cv.CornerHarris(src, dst_32f, 8, aperture_size)
cv.CornerHarris(src, dst_32f, 8, aperture_size, 0.1)
#self.snap(dst)
def test_fitline(self):
cv.FitLine([ (1,1), (10,10) ], cv.CV_DIST_L2, 0, 0.01, 0.01)
cv.FitLine([ (1,1,1), (10,10,10) ], cv.CV_DIST_L2, 0, 0.01, 0.01)
a = self.get_sample("samples/c/lena.jpg", 0)
eig_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
temp_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
pts = cv.GoodFeaturesToTrack(a, eig_image, temp_image, 100, 0.04, 2, useHarris=1)
hull = cv.ConvexHull2(pts, cv.CreateMemStorage(), return_points = 1)
cv.FitLine(hull, cv.CV_DIST_L2, 0, 0.01, 0.01)
def test_moments(self):
im = self.get_sample("samples/c/lena.jpg", 0)
mo = cv.Moments(im)
for fld in ["m00", "m10", "m01", "m20", "m11", "m02", "m30", "m21", "m12", "m03", "mu20", "mu11", "mu02", "mu30", "mu21", "mu12", "mu03", "inv_sqrt_m00"]:
self.assert_(isinstance(getattr(mo, fld), float))
x = getattr(mo, fld)
self.assert_(isinstance(x, float))
orders = []
for x_order in range(4):
for y_order in range(4 - x_order):
orders.append((x_order, y_order))
# Just a smoke test for these three functions
[ cv.GetSpatialMoment(mo, xo, yo) for (xo,yo) in orders ]
[ cv.GetCentralMoment(mo, xo, yo) for (xo,yo) in orders ]
[ cv.GetNormalizedCentralMoment(mo, xo, yo) for (xo,yo) in orders ]
# Hu Moments we can do slightly better. Check that the first
# six are invariant wrt image reflection, and that the 7th
# is negated.
hu0 = cv.GetHuMoments(cv.Moments(im))
cv.Flip(im, im, 1)
hu1 = cv.GetHuMoments(cv.Moments(im))
self.assert_(len(hu0) == 7)
self.assert_(len(hu1) == 7)
for i in range(5):
self.assert_(abs(hu0[i] - hu1[i]) < 1e-6)
self.assert_(abs(hu0[i] + hu1[i]) < 1e-6)
def test_encode(self):
im = self.get_sample("samples/c/lena.jpg", 1)
jpeg = cv.EncodeImage(".jpeg", im)
# Smoke jpeg compression at various qualities
sizes = dict([(qual, cv.EncodeImage(".jpeg", im, [cv.CV_IMWRITE_JPEG_QUALITY, qual]).cols) for qual in range(5, 100, 5)])
# Check that the default QUALITY is 95
self.assertEqual(cv.EncodeImage(".jpeg", im).cols, sizes[95])
# Check that the 'round-trip' gives an image of the same size
round_trip = cv.DecodeImage(cv.EncodeImage(".jpeg", im, [cv.CV_IMWRITE_JPEG_QUALITY, 10]))
self.assert_(cv.GetSize(round_trip) == cv.GetSize(im))
def test_reduce(self):
srcmat = cv.CreateMat(2, 3, cv.CV_32FC1)
# 0 1 2
# 3 4 5
srcmat[0,0] = 0
srcmat[0,1] = 1
srcmat[0,2] = 2
srcmat[1,0] = 3
srcmat[1,1] = 4
srcmat[1,2] = 5
def doreduce(siz, rfunc):
dst = cv.CreateMat(siz[0], siz[1], cv.CV_32FC1)
rfunc(dst)
if siz[0] != 1:
return [dst[i,0] for i in range(siz[0])]
else:
return [dst[0,i] for i in range(siz[1])]
# exercise dim
self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst)), [3, 5, 7])
self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, -1)), [3, 5, 7])
self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, 0)), [3, 5, 7])
self.assertEqual(doreduce((2,1), lambda dst: cv.Reduce(srcmat, dst, 1)), [3, 12])
# exercise op
self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_SUM)), [3, 5, 7])
self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_AVG)), [1.5, 2.5, 3.5])
self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_MAX)), [3, 4, 5])
self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_MIN)), [0, 1, 2])
# exercise both dim and op
self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, 0, cv.CV_REDUCE_MAX)), [3, 4, 5])
self.assertEqual(doreduce((2,1), lambda dst: cv.Reduce(srcmat, dst, 1, cv.CV_REDUCE_MAX)), [2, 5])
def test_operations(self):
class Im:
def __init__(self, data = None):
self.m = cv.CreateMat(1, 32, cv.CV_32FC1)
if data:
cv.SetData(self.m, array.array('f', data), 128)
def __add__(self, other):
r = Im()
if isinstance(other, Im):
cv.Add(self.m, other.m, r.m)
else:
cv.AddS(self.m, (other,), r.m)
return r
def __sub__(self, other):
r = Im()
if isinstance(other, Im):
cv.Sub(self.m, other.m, r.m)
else:
cv.SubS(self.m, (other,), r.m)
return r
def __rsub__(self, other):
r = Im()
cv.SubRS(self.m, (other,), r.m)
return r
def __mul__(self, other):
r = Im()
if isinstance(other, Im):
cv.Mul(self.m, other.m, r.m)
else:
cv.ConvertScale(self.m, r.m, other)
return r
def __rmul__(self, other):
r = Im()
cv.ConvertScale(self.m, r.m, other)
return r
def __div__(self, other):
r = Im()
if isinstance(other, Im):
cv.Div(self.m, other.m, r.m)
else:
cv.ConvertScale(self.m, r.m, 1.0 / other)
return r
def __pow__(self, other):
r = Im()
cv.Pow(self.m, r.m, other)
return r
def __abs__(self):
r = Im()
cv.Abs(self.m, r.m)
return r
def __getitem__(self, i):
return self.m[0,i]
def verify(op):
r = op(a, b)
for i in range(32):
expected = op(a[i], b[i])
self.assertAlmostEqual(expected, r[i], 4)
a = Im([random.randrange(1, 256) for i in range(32)])
b = Im([random.randrange(1, 256) for i in range(32)])
# simple operations first
verify(lambda x, y: x + y)
verify(lambda x, y: x + 3)
verify(lambda x, y: x + 0)
verify(lambda x, y: x + -8)
verify(lambda x, y: x - y)
verify(lambda x, y: x - 1)
verify(lambda x, y: 1 - x)
verify(lambda x, y: abs(x))
verify(lambda x, y: x * y)
verify(lambda x, y: x * 3)
verify(lambda x, y: x / y)
verify(lambda x, y: x / 2)
for p in [-2, -1, -0.5, -0.1, 0, 0.1, 0.5, 1, 2 ]:
verify(lambda x, y: (x ** p) + (y ** p))
# Combinations...
verify(lambda x, y: x - 4 * abs(y))
verify(lambda x, y: abs(y) / x)
# a polynomial
verify(lambda x, y: 2 * x + 3 * (y ** 0.5))
def temp_test(self):
cv.temp_test()
def failing_test_rand_GetStarKeypoints(self):
# GetStarKeypoints [<cvmat(type=4242400d rows=64 cols=64 step=512 )>, <cv.cvmemstorage object at 0xb7cc40d0>, (45, 0.73705234376883488, 0.64282591451367344, 0.1567738743689836, 3)]
print cv.CV_MAT_CN(0x4242400d)
mat = cv.CreateMat( 64, 64, cv.CV_32FC2)
cv.GetStarKeypoints(mat, cv.CreateMemStorage(), (45, 0.73705234376883488, 0.64282591451367344, 0.1567738743689836, 3))
print mat
def test_rand_PutText(self):
#""" Test for bug 2829336 """
mat = cv.CreateMat( 64, 64, cv.CV_8UC1)
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1)
cv.PutText(mat, chr(127), (20, 20), font, 255)
def failing_test_rand_FindNearestPoint2D(self):
subdiv = cv.CreateSubdivDelaunay2D((0,0,100,100), cv.CreateMemStorage())
cv.SubdivDelaunay2DInsert( subdiv, (50, 50))
cv.CalcSubdivVoronoi2D(subdiv)
print
for e in subdiv.edges:
print e,
print " ", cv.Subdiv2DEdgeOrg(e)
print " ", cv.Subdiv2DEdgeOrg(cv.Subdiv2DRotateEdge(e, 1)), cv.Subdiv2DEdgeDst(cv.Subdiv2DRotateEdge(e, 1))
print "nearest", cv.FindNearestPoint2D(subdiv, (1.0, 1.0))
class DocumentFragmentTests(OpenCVTests):
""" Test the fragments of code that are included in the documentation """
def setUp(self):
OpenCVTests.setUp(self)
sys.path.append(".")
def test_precornerdetect(self):
from precornerdetect import precornerdetect
im = self.get_sample("samples/cpp/right01.jpg", 0)
imf = cv.CreateMat(im.rows, im.cols, cv.CV_32FC1)
cv.ConvertScale(im, imf)
(r0,r1) = precornerdetect(imf)
for r in (r0, r1):
self.assertEqual(im.cols, r.cols)
self.assertEqual(im.rows, r.rows)
def test_findstereocorrespondence(self):
from findstereocorrespondence import findstereocorrespondence
(l,r) = [self.get_sample("samples/cpp/tsukuba_%s.png" % c, cv.CV_LOAD_IMAGE_GRAYSCALE) for c in "lr"]
(disparity_left, disparity_right) = findstereocorrespondence(l, r)
disparity_left_visual = cv.CreateMat(l.rows, l.cols, cv.CV_8U)
cv.ConvertScale(disparity_left, disparity_left_visual, -16)
# self.snap(disparity_left_visual)
def test_calchist(self):
from calchist import hs_histogram
i1 = self.get_sample("samples/c/lena.jpg")
i2 = self.get_sample("samples/cpp/building.jpg")
i3 = cv.CloneMat(i1)
cv.Flip(i3, i3, 1)
h1 = hs_histogram(i1)
h2 = hs_histogram(i2)
h3 = hs_histogram(i3)
self.assertEqual(self.hashimg(h1), self.hashimg(h3))
self.assertNotEqual(self.hashimg(h1), self.hashimg(h2))
if __name__ == '__main__':
print "testing", cv.__version__
random.seed(0)
unittest.main()
# optlist, args = getopt.getopt(sys.argv[1:], 'l:rd')
# loops = 1
# shuffle = 0
# doc_frags = False
# for o,a in optlist:
# if o == '-l':
# loops = int(a)
# if o == '-r':
# shuffle = 1
# if o == '-d':
# doc_frags = True
#
# cases = [PreliminaryTests, FunctionTests, AreaTests]
# if doc_frags:
# cases += [DocumentFragmentTests]
# everything = [(tc, t) for tc in cases for t in unittest.TestLoader().getTestCaseNames(tc) ]
# if len(args) == 0:
# # cases = [NewTests]
# args = everything
# else:
# args = [(tc, t) for (tc, t) in everything if t in args]
#
# suite = unittest.TestSuite()
# for l in range(loops):
# if shuffle:
# random.shuffle(args)
# for tc,t in args:
# suite.addTest(tc(t))
# unittest.TextTestRunner(verbosity=2).run(suite)