opencv/tests/python/test.py

   1 import unittest
   2 import random
   3 import time
   4 import math
   5 import sys
   6 import array
   7 import urllib
   8 import tarfile
   9 import hashlib
  10 import os
  11 import getopt
  12 import operator
  13 import functools
  14
  15 import cv
  16
  17 class OpenCVTests(unittest.TestCase):
  18
  19     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 ]
  20
  21     mat_types = [
  22         cv.CV_8UC1,
  23         cv.CV_8UC2,
  24         cv.CV_8UC3,
  25         cv.CV_8UC4,
  26         cv.CV_8SC1,
  27         cv.CV_8SC2,
  28         cv.CV_8SC3,
  29         cv.CV_8SC4,
  30         cv.CV_16UC1,
  31         cv.CV_16UC2,
  32         cv.CV_16UC3,
  33         cv.CV_16UC4,
  34         cv.CV_16SC1,
  35         cv.CV_16SC2,
  36         cv.CV_16SC3,
  37         cv.CV_16SC4,
  38         cv.CV_32SC1,
  39         cv.CV_32SC2,
  40         cv.CV_32SC3,
  41         cv.CV_32SC4,
  42         cv.CV_32FC1,
  43         cv.CV_32FC2,
  44         cv.CV_32FC3,
  45         cv.CV_32FC4,
  46         cv.CV_64FC1,
  47         cv.CV_64FC2,
  48         cv.CV_64FC3,
  49         cv.CV_64FC4,
  50     ]
  51     mat_types_single = [
  52         cv.CV_8UC1,
  53         cv.CV_8SC1,
  54         cv.CV_16UC1,
  55         cv.CV_16SC1,
  56         cv.CV_32SC1,
  57         cv.CV_32FC1,
  58         cv.CV_64FC1,
  59     ]
  60
  61     def depthsize(self, d):
  62         return { cv.IPL_DEPTH_8U : 1,
  63                  cv.IPL_DEPTH_8S : 1,
  64                  cv.IPL_DEPTH_16U : 2,
  65                  cv.IPL_DEPTH_16S : 2,
  66                  cv.IPL_DEPTH_32S : 4,
  67                  cv.IPL_DEPTH_32F : 4,
  68                  cv.IPL_DEPTH_64F : 8 }[d]
  69
  70     def get_sample(self, filename, iscolor = cv.CV_LOAD_IMAGE_COLOR):
  71         if not filename in self.image_cache:
  72             filedata = urllib.urlopen("https://code.ros.org/svn/opencv/trunk/opencv/" + filename).read()
  73             imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1)
  74             cv.SetData(imagefiledata, filedata, len(filedata))
  75             self.image_cache[filename] = cv.DecodeImageM(imagefiledata, iscolor)
  76         return self.image_cache[filename]
  77
  78     def setUp(self):
  79         self.image_cache = {}
  80
  81     def snap(self, img):
  82         self.snapL([img])
  83
  84     def snapL(self, L):
  85         for i,img in enumerate(L):
  86             cv.NamedWindow("snap-%d" % i, 1)
  87             cv.ShowImage("snap-%d" % i, img)
  88         cv.WaitKey()
  89         cv.DestroyAllWindows()
  90
  91 # Tests to run first; check the handful of basic operations that the later tests rely on
  92
  93 class PreliminaryTests(OpenCVTests):
  94
  95     def test_lena(self):
  96         # Check that the lena jpg image has loaded correctly
  97         # This test uses a 'golden' MD5 hash of the Lena image
  98         # If the JPEG decompressor changes, it is possible that the MD5 hash will change,
  99         # so the hash here will need to change.
 100
 101         im = self.get_sample("samples/c/lena.jpg")
 102         # self.snap(im)     # uncomment this line to view the image, when regilding
 103         self.assertEqual(hashlib.md5(im.tostring()).hexdigest(), "9dcd9247f9811c6ce86675ba7b0297b6")
 104
 105     def test_LoadImage(self):
 106         self.assertRaises(TypeError, lambda: cv.LoadImage())
 107         self.assertRaises(TypeError, lambda: cv.LoadImage(4))
 108         self.assertRaises(TypeError, lambda: cv.LoadImage('foo.jpg', 1, 1))
 109         self.assertRaises(TypeError, lambda: cv.LoadImage('foo.jpg', xiscolor=cv.CV_LOAD_IMAGE_COLOR))
 110
 111     def test_types(self):
 112         self.assert_(type(cv.CreateImage((7,5), cv.IPL_DEPTH_8U, 1)) == cv.iplimage)
 113         self.assert_(type(cv.CreateMat(5, 7, cv.CV_32FC1)) == cv.cvmat)
 114         for i,t in enumerate(self.mat_types):
 115             basefunc = [
 116                 cv.CV_8UC,
 117                 cv.CV_8SC,
 118                 cv.CV_16UC,
 119                 cv.CV_16SC,
 120                 cv.CV_32SC,
 121                 cv.CV_32FC,
 122                 cv.CV_64FC,
 123             ][i / 4]
 124             self.assertEqual(basefunc(1 + (i % 4)), t)
 125
 126     def test_tostring(self):
 127
 128         for w in [ 1, 4, 64, 512, 640]:
 129             for h in [ 1, 4, 64, 480, 512]:
 130                 for c in [1, 2, 3, 4]:
 131                     for d in self.depths:
 132                         a = cv.CreateImage((w,h), d, c);
 133                         self.assert_(len(a.tostring()) == w * h * c * self.depthsize(d))
 134
 135         for w in [ 32, 96, 480 ]:
 136             for h in [ 32, 96, 480 ]:
 137                 depth_size = {
 138                     cv.IPL_DEPTH_8U : 1,
 139                     cv.IPL_DEPTH_8S : 1,
 140                     cv.IPL_DEPTH_16U : 2,
 141                     cv.IPL_DEPTH_16S : 2,
 142                     cv.IPL_DEPTH_32S : 4,
 143                     cv.IPL_DEPTH_32F : 4,
 144                     cv.IPL_DEPTH_64F : 8
 145                 }
 146                 for f in  self.depths:
 147                     for channels in (1,2,3,4):
 148                         img = cv.CreateImage((w, h), f, channels)
 149                         esize = (w * h * channels * depth_size[f])
 150                         self.assert_(len(img.tostring()) == esize)
 151                         cv.SetData(img, " " * esize, w * channels * depth_size[f])
 152                         self.assert_(len(img.tostring()) == esize)
 153
 154                 mattype_size = {
 155                     cv.CV_8UC1 : 1,
 156                     cv.CV_8UC2 : 1,
 157                     cv.CV_8UC3 : 1,
 158                     cv.CV_8UC4 : 1,
 159                     cv.CV_8SC1 : 1,
 160                     cv.CV_8SC2 : 1,
 161                     cv.CV_8SC3 : 1,
 162                     cv.CV_8SC4 : 1,
 163                     cv.CV_16UC1 : 2,
 164                     cv.CV_16UC2 : 2,
 165                     cv.CV_16UC3 : 2,
 166                     cv.CV_16UC4 : 2,
 167                     cv.CV_16SC1 : 2,
 168                     cv.CV_16SC2 : 2,
 169                     cv.CV_16SC3 : 2,
 170                     cv.CV_16SC4 : 2,
 171                     cv.CV_32SC1 : 4,
 172                     cv.CV_32SC2 : 4,
 173                     cv.CV_32SC3 : 4,
 174                     cv.CV_32SC4 : 4,
 175                     cv.CV_32FC1 : 4,
 176                     cv.CV_32FC2 : 4,
 177                     cv.CV_32FC3 : 4,
 178                     cv.CV_32FC4 : 4,
 179                     cv.CV_64FC1 : 8,
 180                     cv.CV_64FC2 : 8,
 181                     cv.CV_64FC3 : 8,
 182                     cv.CV_64FC4 : 8
 183                 }
 184
 185                 for t in self.mat_types:
 186                     for im in [cv.CreateMat(h, w, t), cv.CreateMatND([h, w], t)]:
 187                         elemsize = cv.CV_MAT_CN(cv.GetElemType(im)) * mattype_size[cv.GetElemType(im)]
 188                         cv.SetData(im, " " * (w * h * elemsize), (w * elemsize))
 189                         esize = (w * h * elemsize)
 190                         self.assert_(len(im.tostring()) == esize)
 191                         cv.SetData(im, " " * esize, w * elemsize)
 192                         self.assert_(len(im.tostring()) == esize)
 193
 194 # Tests for specific OpenCV functions
 195
 196 class FunctionTests(OpenCVTests):
 197
 198     def test_AvgSdv(self):
 199         m = cv.CreateMat(1, 8, cv.CV_32FC1)
 200         for i,v in enumerate([2, 4, 4, 4, 5, 5, 7, 9]):
 201             m[0,i] = (v,)
 202         self.assertAlmostEqual(cv.Avg(m)[0], 5.0, 3)
 203         avg,sdv = cv.AvgSdv(m)
 204         self.assertAlmostEqual(avg[0], 5.0, 3)
 205         self.assertAlmostEqual(sdv[0], 2.0, 3)
 206
 207     def test_CalcEMD2(self):
 208         cc = {}
 209         for r in [ 5, 10, 37, 38 ]:
 210             scratch = cv.CreateImage((100,100), 8, 1)
 211             cv.SetZero(scratch)
 212             cv.Circle(scratch, (50,50), r, 255, -1)
 213             storage = cv.CreateMemStorage()
 214             seq = cv.FindContours(scratch, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
 215             arr = cv.CreateMat(len(seq), 3, cv.CV_32FC1)
 216             for i,e in enumerate(seq):
 217                 arr[i,0] = 1
 218                 arr[i,1] = e[0]
 219                 arr[i,2] = e[1]
 220             cc[r] = arr
 221         def myL1(A, B, D):
 222             return abs(A[0]-B[0]) + abs(A[1]-B[1])
 223         def myL2(A, B, D):
 224             return math.sqrt((A[0]-B[0])**2 + (A[1]-B[1])**2)
 225         def myC(A, B, D):
 226             return max(abs(A[0]-B[0]), abs(A[1]-B[1]))
 227         contours = set(cc.values())
 228         for c0 in contours:
 229             for c1 in contours:
 230                 self.assert_(abs(cv.CalcEMD2(c0, c1, cv.CV_DIST_L1) - cv.CalcEMD2(c0, c1, cv.CV_DIST_USER, myL1)) < 1e-3)
 231                 self.assert_(abs(cv.CalcEMD2(c0, c1, cv.CV_DIST_L2) - cv.CalcEMD2(c0, c1, cv.CV_DIST_USER, myL2)) < 1e-3)
 232                 self.assert_(abs(cv.CalcEMD2(c0, c1, cv.CV_DIST_C) - cv.CalcEMD2(c0, c1, cv.CV_DIST_USER, myC)) < 1e-3)
 233
 234     def test_CalcOpticalFlowBM(self):
 235         a = self.get_sample("samples/c/lena.jpg", 0)
 236         b = self.get_sample("samples/c/lena.jpg", 0)
 237         (w,h) = cv.GetSize(a)
 238         vel_size = (w - 8, h - 8)
 239         velx = cv.CreateImage(vel_size, cv.IPL_DEPTH_32F, 1)
 240         vely = cv.CreateImage(vel_size, cv.IPL_DEPTH_32F, 1)
 241         cv.CalcOpticalFlowBM(a, b, (8,8), (1,1), (8,8), 0, velx, vely)
 242
 243     def test_CartToPolar(self):
 244         x = cv.CreateMat(5, 5, cv.CV_32F)
 245         y = cv.CreateMat(5, 5, cv.CV_32F)
 246         mag = cv.CreateMat(5, 5, cv.CV_32F)
 247         angle = cv.CreateMat(5, 5, cv.CV_32F)
 248         x2 = cv.CreateMat(5, 5, cv.CV_32F)
 249         y2 = cv.CreateMat(5, 5, cv.CV_32F)
 250
 251         for i in range(5):
 252             for j in range(5):
 253                 x[i, j] = i
 254                 y[i, j] = j
 255
 256         for in_degrees in [False, True]:
 257             cv.CartToPolar(x, y, mag, angle, in_degrees)
 258             cv.PolarToCart(mag, angle, x2, y2, in_degrees)
 259             for i in range(5):
 260                 for j in range(5):
 261                     self.assertAlmostEqual(x[i, j], x2[i, j], 1)
 262                     self.assertAlmostEqual(y[i, j], y2[i, j], 1)
 263
 264     def test_Circle(self):
 265         for w,h in [(2,77), (77,2), (256, 256), (640,480)]:
 266             img = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 1)
 267             cv.SetZero(img)
 268             tricky = [ -8000, -2, -1, 0, 1, h/2, h-1, h, h+1, w/2, w-1, w, w+1, 8000]
 269             for x0 in tricky:
 270                 for y0 in tricky:
 271                     for r in [ 0, 1, 2, 3, 4, 5, w/2, w-1, w, w+1, h/2, h-1, h, h+1, 8000 ]:
 272                         for thick in [1, 2, 10]:
 273                             for t in [0, 8, 4, cv.CV_AA]:
 274                                 cv.Circle(img, (x0,y0), r, 255, thick, t)
 275         # just check that something was drawn
 276         self.assert_(cv.Sum(img)[0] > 0)
 277
 278     def test_ConvexHull2(self):
 279         # Draw a series of N-pointed stars, find contours, assert the contour is not convex,
 280         # assert the hull has N segments, assert that there are N convexity defects.
 281
 282         def polar2xy(th, r):
 283             return (int(400 + r * math.cos(th)), int(400 + r * math.sin(th)))
 284         storage = cv.CreateMemStorage(0)
 285         for way in ['CvSeq', 'CvMat', 'list']:
 286             for points in range(3,20):
 287                 scratch = cv.CreateImage((800,800), 8, 1)
 288                 cv.SetZero(scratch)
 289                 sides = 2 * points
 290                 cv.FillPoly(scratch, [ [ polar2xy(i * 2 * math.pi / sides, [100,350][i&1]) for i in range(sides) ] ], 255)
 291
 292                 seq = cv.FindContours(scratch, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
 293
 294                 if way == 'CvSeq':
 295                     # pts is a CvSeq
 296                     pts = seq
 297                 elif way == 'CvMat':
 298                     # pts is a CvMat
 299                     arr = cv.CreateMat(len(seq), 1, cv.CV_32SC2)
 300                     for i,e in enumerate(seq):
 301                         arr[i,0] = e
 302                     pts = arr
 303                 elif way == 'list':
 304                     # pts is a list of 2-tuples
 305                     pts = list(seq)
 306                 else:
 307                     assert False
 308
 309                 self.assert_(cv.CheckContourConvexity(pts) == 0)
 310                 hull = cv.ConvexHull2(pts, storage, return_points = 1)
 311                 self.assert_(cv.CheckContourConvexity(hull) == 1)
 312                 self.assert_(len(hull) == points)
 313
 314                 if way in [ 'CvSeq', 'CvMat' ]:
 315                     defects = cv.ConvexityDefects(pts, cv.ConvexHull2(pts, storage), storage)
 316                     self.assert_(len([depth for (_,_,_,depth) in defects if (depth > 5)]) == points)
 317
 318     def test_CreateImage(self):
 319         for w in [ 1, 4, 64, 512, 640]:
 320             for h in [ 1, 4, 64, 480, 512]:
 321                 for c in [1, 2, 3, 4]:
 322                     for d in self.depths:
 323                         a = cv.CreateImage((w,h), d, c);
 324                         self.assert_(a.width == w)
 325                         self.assert_(a.height == h)
 326                         self.assert_(a.nChannels == c)
 327                         self.assert_(a.depth == d)
 328                         self.assert_(cv.GetSize(a) == (w, h))
 329                         # self.assert_(cv.GetElemType(a) == d)
 330         self.assertRaises(cv.error, lambda: cv.CreateImage((100, 100), 9, 1))
 331
 332     def test_CreateMat(self):
 333         for rows in [1, 2, 4, 16, 64, 512, 640]:
 334             for cols in [1, 2, 4, 16, 64, 512, 640]:
 335                 for t in self.mat_types:
 336                     m = cv.CreateMat(rows, cols, t)
 337                     self.assertEqual(cv.GetElemType(m), t)
 338                     self.assertEqual(m.type, t)
 339         self.assertRaises(cv.error, lambda: cv.CreateMat(0, 100, cv.CV_8SC4))
 340         self.assertRaises(cv.error, lambda: cv.CreateMat(100, 0, cv.CV_8SC4))
 341         # Uncomment when ticket #100 is fixed
 342         # self.assertRaises(cv.error, lambda: cv.CreateMat(100, 100, 666666))
 343
 344     def test_DrawChessboardCorners(self):
 345         im = cv.CreateImage((512,512), cv.IPL_DEPTH_8U, 3)
 346         cv.SetZero(im)
 347         cv.DrawChessboardCorners(im, (5, 5), [ (100,100) for i in range(5 * 5) ], 1)
 348         self.assert_(cv.Sum(im)[0] > 0)
 349
 350         self.assertRaises(TypeError, lambda: cv.DrawChessboardCorners(im, (4, 5), [ (100,100) for i in range(5 * 5) ], 1))
 351
 352     def test_ExtractSURF(self):
 353         img = self.get_sample("samples/c/lena.jpg", 0)
 354         w,h = cv.GetSize(img)
 355         for hessthresh in [ 300,400,500]:
 356             for dsize in [0,1]:
 357                 for layers in [1,3,10]:
 358                     kp,desc = cv.ExtractSURF(img, None, cv.CreateMemStorage(), (dsize, hessthresh, 3, layers))
 359                     self.assert_(len(kp) == len(desc))
 360                     for d in desc:
 361                         self.assert_(len(d) == {0:64, 1:128}[dsize])
 362                     for pt,laplacian,size,dir,hessian in kp:
 363                         self.assert_((0 <= pt[0]) and (pt[0] <= w))
 364                         self.assert_((0 <= pt[1]) and (pt[1] <= h))
 365                         self.assert_(laplacian in [-1, 0, 1])
 366                         self.assert_((0 <= dir) and (dir <= 360))
 367                         self.assert_(hessian >= hessthresh)
 368
 369     def test_FillPoly(self):
 370         scribble = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 1)
 371         random.seed(0)
 372         for i in range(50):
 373             cv.SetZero(scribble)
 374             self.assert_(cv.CountNonZero(scribble) == 0)
 375             cv.FillPoly(scribble, [ [ (random.randrange(640), random.randrange(480)) for i in range(100) ] ], (255,))
 376             self.assert_(cv.CountNonZero(scribble) != 0)
 377
 378     def test_FindChessboardCorners(self):
 379         im = cv.CreateImage((512,512), cv.IPL_DEPTH_8U, 1)
 380         cv.Set(im, 128)
 381
 382         # Empty image run
 383         status,corners = cv.FindChessboardCorners( im, (7,7) )
 384
 385         # Perfect checkerboard
 386         def xf(i,j, o):
 387             return ((96 + o) + 40 * i, (96 + o) + 40 * j)
 388         for i in range(8):
 389             for j in range(8):
 390                 color = ((i ^ j) & 1) * 255
 391                 cv.Rectangle(im, xf(i,j, 0), xf(i,j, 39), color, cv.CV_FILLED)
 392         status,corners = cv.FindChessboardCorners( im, (7,7) )
 393         self.assert_(status)
 394         self.assert_(len(corners) == (7 * 7))
 395
 396         # Exercise corner display
 397         im3 = cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 3)
 398         cv.Merge(im, im, im, None, im3)
 399         cv.DrawChessboardCorners(im3, (7,7), corners, status)
 400
 401         if 0:
 402             self.snap(im3)
 403
 404         # Run it with too many corners
 405         cv.Set(im, 128)
 406         for i in range(40):
 407             for j in range(40):
 408                 color = ((i ^ j) & 1) * 255
 409                 x = 30 + 6 * i
 410                 y = 30 + 4 * j
 411                 cv.Rectangle(im, (x, y), (x+4, y+4), color, cv.CV_FILLED)
 412         status,corners = cv.FindChessboardCorners( im, (7,7) )
 413
 414         # XXX - this is very slow
 415         if 0:
 416             rng = cv.RNG(0)
 417             cv.RandArr(rng, im, cv.CV_RAND_UNI, 0, 255.0)
 418             self.snap(im)
 419             status,corners = cv.FindChessboardCorners( im, (7,7) )
 420
 421     def test_FindContours(self):
 422         random.seed(0)
 423
 424         storage = cv.CreateMemStorage()
 425
 426         # First run FindContours on a black image.
 427         scratch = cv.CreateImage((800,800), 8, 1)
 428         cv.SetZero(scratch)
 429         seq = cv.FindContours(scratch, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
 430
 431         for trial in range(10):
 432             scratch = cv.CreateImage((800,800), 8, 1)
 433             cv.SetZero(scratch)
 434             def plot(center, radius, mode):
 435                 cv.Circle(scratch, center, radius, mode, -1)
 436                 if radius < 20:
 437                     return 0
 438                 else:
 439                     newmode = 255 - mode
 440                     subs = random.choice([1,2,3])
 441                     if subs == 1:
 442                         return [ plot(center, radius - 5, newmode) ]
 443                     else:
 444                         newradius = int({ 2: radius / 2, 3: radius / 2.3 }[subs] - 5)
 445                         r = radius / 2
 446                         ret = []
 447                         for i in range(subs):
 448                             th = i * (2 * math.pi) / subs
 449                             ret.append(plot((int(center[0] + r * math.cos(th)), int(center[1] + r * math.sin(th))), newradius, newmode))
 450                         return sorted(ret)
 451
 452             actual = plot((400,400), 390, 255 )
 453
 454             seq = cv.FindContours(scratch, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE)
 455
 456             def traverse(s):
 457                 if s == None:
 458                     return 0
 459                 else:
 460                     self.assert_(abs(cv.ContourArea(s)) > 0.0)
 461                     ((x,y),(w,h),th) = cv.MinAreaRect2(s, cv.CreateMemStorage())
 462                     self.assert_(((w / h) - 1.0) < 0.01)
 463                     self.assert_(abs(cv.ContourArea(s)) > 0.0)
 464                     r = []
 465                     while s:
 466                         r.append(traverse(s.v_next()))
 467                         s = s.h_next()
 468                     return sorted(r)
 469             self.assert_(traverse(seq.v_next()) == actual)
 470
 471     def test_GetAffineTransform(self):
 472         mapping = cv.CreateMat(2, 3, cv.CV_32FC1)
 473         cv.GetAffineTransform([ (0,0), (1,0), (0,1) ], [ (0,0), (17,0), (0,17) ], mapping)
 474         self.assertAlmostEqual(mapping[0,0], 17, 2)
 475         self.assertAlmostEqual(mapping[1,1], 17, 2)
 476
 477     def test_GetRotationMatrix2D(self):
 478         mapping = cv.CreateMat(2, 3, cv.CV_32FC1)
 479         for scale in [0.0, 1.0, 2.0]:
 480             for angle in [0.0, 360.0]:
 481                 cv.GetRotationMatrix2D((0,0), angle, scale, mapping)
 482                 for r in [0, 1]:
 483                     for c in [0, 1, 2]:
 484                         if r == c:
 485                             e = scale
 486                         else:
 487                             e = 0.0
 488                         self.assertAlmostEqual(mapping[r, c], e, 2)
 489
 490     def test_GetSize(self):
 491         self.assert_(cv.GetSize(cv.CreateMat(5, 7, cv.CV_32FC1)) == (7,5))
 492         self.assert_(cv.GetSize(cv.CreateImage((7,5), cv.IPL_DEPTH_8U, 1)) == (7,5))
 493
 494     def test_GetStarKeypoints(self):
 495         src = self.get_sample("samples/c/lena.jpg", 0)
 496         storage = cv.CreateMemStorage()
 497         kp = cv.GetStarKeypoints(src, storage)
 498         self.assert_(len(kp) > 0)
 499         for (x,y),scale,r in kp:
 500             self.assert_(0 <= x)
 501             self.assert_(x <= cv.GetSize(src)[0])
 502             self.assert_(0 <= y)
 503             self.assert_(y <= cv.GetSize(src)[1])
 504         return
 505         scribble = cv.CreateImage(cv.GetSize(src), 8, 3)
 506         cv.CvtColor(src, scribble, cv.CV_GRAY2BGR)
 507         for (x,y),scale,r in kp:
 508             print x,y,scale,r
 509             cv.Circle(scribble, (x,y), scale, cv.RGB(255,0,0))
 510         self.snap(scribble)
 511
 512     def test_GetSubRect(self):
 513         src = cv.CreateImage((100,100), 8, 1)
 514         data = "z" * (100 * 100)
 515
 516         cv.SetData(src, data, 100)
 517         start_count = sys.getrefcount(data)
 518
 519         iter = 77
 520         subs = []
 521         for i in range(iter):
 522             sub = cv.GetSubRect(src, (0, 0, 10, 10))
 523             subs.append(sub)
 524         self.assert_(sys.getrefcount(data) == (start_count + iter))
 525
 526         src = self.get_sample("samples/c/lena.jpg", 0)
 527         made = cv.CreateImage(cv.GetSize(src), 8, 1)
 528         sub = cv.CreateMat(32, 32, cv.CV_8UC1)
 529         for x in range(0, 512, 32):
 530             for y in range(0, 512, 32):
 531                 sub = cv.GetSubRect(src, (x, y, 32, 32))
 532                 cv.SetImageROI(made, (x, y, 32, 32))
 533                 cv.Copy(sub, made)
 534         cv.ResetImageROI(made)
 535         cv.AbsDiff(made, src, made)
 536         self.assert_(cv.CountNonZero(made) == 0)
 537
 538     def test_HoughLines2_PROBABILISTIC(self):
 539         li = cv.HoughLines2(self.yield_line_image(),
 540                                                 cv.CreateMemStorage(),
 541                                                 cv.CV_HOUGH_PROBABILISTIC,
 542                                                 1,
 543                                                 math.pi/180,
 544                                                 50,
 545                                                 50,
 546                                                 10)
 547         self.assert_(len(li) > 0)
 548         self.assert_(li[0] != None)
 549
 550     def test_HoughLines2_STANDARD(self):
 551         li = cv.HoughLines2(self.yield_line_image(),
 552                                                 cv.CreateMemStorage(),
 553                                                 cv.CV_HOUGH_STANDARD,
 554                                                 1,
 555                                                 math.pi/180,
 556                                                 100,
 557                                                 0,
 558                                                 0)
 559         self.assert_(len(li) > 0)
 560         self.assert_(li[0] != None)
 561
 562     def test_InPaint(self):
 563         src = self.get_sample("doc/pics/building.jpg")
 564         msk = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
 565         damaged = cv.CloneMat(src)
 566         repaired = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 3)
 567         difference = cv.CloneImage(repaired)
 568         cv.SetZero(msk)
 569         for method in [ cv.CV_INPAINT_NS, cv.CV_INPAINT_TELEA ]:
 570             for (p0,p1) in [ ((10,10), (400,400)) ]:
 571                 cv.Line(damaged, p0, p1, cv.RGB(255, 0, 255), 2)
 572                 cv.Line(msk, p0, p1, 255, 2)
 573             cv.Inpaint(damaged, msk, repaired, 10., cv.CV_INPAINT_NS)
 574         cv.AbsDiff(src, repaired, difference)
 575         #self.snapL([src, damaged, repaired, difference])
 576
 577     def test_InitLineIterator(self):
 578         scribble = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 1)
 579         self.assert_(len(list(cv.InitLineIterator(scribble, (20,10), (30,10)))) == 11)
 580
 581     def test_InRange(self):
 582
 583         sz = (256,256)
 584         Igray1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 585         Ilow1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 586         Ihi1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 587         Igray2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 588         Ilow2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 589         Ihi2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 590
 591         Imask = cv.CreateImage(sz, cv.IPL_DEPTH_8U,1)
 592         Imaskt = cv.CreateImage(sz,cv.IPL_DEPTH_8U,1)
 593
 594         cv.InRange(Igray1, Ilow1, Ihi1, Imask);
 595         cv.InRange(Igray2, Ilow2, Ihi2, Imaskt);
 596
 597         cv.Or(Imask, Imaskt, Imask);
 598
 599     def test_Line(self):
 600         w,h = 640,480
 601         img = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 1)
 602         cv.SetZero(img)
 603         tricky = [ -8000, -2, -1, 0, 1, h/2, h-1, h, h+1, w/2, w-1, w, w+1, 8000]
 604         for x0 in tricky:
 605             for y0 in tricky:
 606                 for x1 in tricky:
 607                     for y1 in tricky:
 608                         for thickness in [ 0, 1, 8 ]:
 609                             for line_type in [0, 4, 8, cv.CV_AA ]:
 610                                 cv.Line(img, (x0,y0), (x1,y1), 255, thickness, line_type)
 611         # just check that something was drawn
 612         self.assert_(cv.Sum(img)[0] > 0)
 613
 614     def test_MinMaxLoc(self):
 615         scribble = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 1)
 616         los = [ (random.randrange(480), random.randrange(640)) for i in range(100) ]
 617         his = [ (random.randrange(480), random.randrange(640)) for i in range(100) ]
 618         for (lo,hi) in zip(los,his):
 619             cv.Set(scribble, 128)
 620             scribble[lo] = 0
 621             scribble[hi] = 255
 622             r = cv.MinMaxLoc(scribble)
 623             self.assert_(r == (0, 255, tuple(reversed(lo)), tuple(reversed(hi))))
 624
 625     def test_Reshape(self):
 626         # 97 rows
 627         # 12 cols
 628         rows = 97
 629         cols = 12
 630         im = cv.CreateMat( rows, cols, cv.CV_32FC1 )
 631         elems = rows * cols * 1
 632         def crd(im):
 633             return cv.GetSize(im) + (cv.CV_MAT_CN(cv.GetElemType(im)),)
 634
 635         for c in (1, 2, 3, 4):
 636             nc,nr,nd = crd(cv.Reshape(im, c))
 637             self.assert_(nd == c)
 638             self.assert_((nc * nr * nd) == elems)
 639
 640         nc,nr,nd = crd(cv.Reshape(im, 0, 97*2))
 641         self.assert_(nr == 97*2)
 642         self.assert_((nc * nr * nd) == elems)
 643
 644         nc,nr,nd = crd(cv.Reshape(im, 3, 97*2))
 645         self.assert_(nr == 97*2)
 646         self.assert_(nd == 3)
 647         self.assert_((nc * nr * nd) == elems)
 648
 649         return # XXX - blocked by fixes for #166, #150
 650
 651         # Now test ReshapeMatND
 652         mat = cv.CreateMatND([2, 2, 2], cv.CV_32F)
 653         print cv.ReshapeMatND(mat, 0, []);
 654
 655     def test_Save(self):
 656         for o in [ cv.CreateImage((128,128), cv.IPL_DEPTH_8U, 1), cv.CreateMat(16, 16, cv.CV_32FC1) ]:
 657             cv.Save("test.save", o)
 658             loaded = cv.Load("test.save", cv.CreateMemStorage())
 659             self.assert_(type(o) == type(loaded))
 660
 661     def test_SetIdentity(self):
 662         for r in range(1,16):
 663             for c in range(1, 16):
 664                 for t in self.mat_types_single:
 665                     M = cv.CreateMat(r, c, t)
 666                     cv.SetIdentity(M)
 667                     for rj in range(r):
 668                         for cj in range(c):
 669                             if rj == cj:
 670                                 expected = 1.0
 671                             else:
 672                                 expected = 0.0
 673                             self.assertEqual(M[rj,cj], expected)
 674
 675     def test_Sum(self):
 676         for r in range(1,11):
 677             for c in range(1, 11):
 678                 for t in self.mat_types_single:
 679                     M = cv.CreateMat(r, c, t)
 680                     cv.Set(M, 1)
 681                     self.assertEqual(cv.Sum(M)[0], r * c)
 682
 683     def test_Threshold(self):
 684         """ directed test for bug 2790622 """
 685         src = self.get_sample("samples/c/lena.jpg", 0)
 686         results = set()
 687         for i in range(10):
 688             dst = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
 689             cv.Threshold(src, dst, 128, 128, cv.CV_THRESH_BINARY)
 690             results.add(dst.tostring())
 691         # Should have produced the same answer every time, so results set should have size 1
 692         self.assert_(len(results) == 1)
 693
 694         # ticket #71 repro attempt
 695         image = self.get_sample("samples/c/lena.jpg", 0)
 696         red = cv.CreateImage(cv.GetSize(image), 8, 1)
 697         binary = cv.CreateImage(cv.GetSize(image), 8, 1)
 698         cv.Split(image, red, None, None, None)
 699         cv.Threshold(red, binary, 42, 255, cv.CV_THRESH_BINARY)
 700
 701     ##############################################################################
 702
 703     def yield_line_image(self):
 704         """ Needed by HoughLines tests """
 705         src = self.get_sample("doc/pics/building.jpg", 0)
 706         dst = cv.CreateImage(cv.GetSize(src), 8, 1)
 707         cv.Canny(src, dst, 50, 200, 3)
 708         return dst
 709
 710 # Tests for functional areas
 711
 712 class AreaTests(OpenCVTests):
 713
 714     def test_numpy(self):
 715         if 'fromarray' in dir(cv):
 716             import numpy
 717             for t in [cv.CV_16UC1, cv.CV_32SC1, cv.CV_32FC1]:
 718                 for d in [ (8,), (1,7), (2,3,4), (7,9,2,1,8), (1,2,3,4,5,6,7,8) ]:
 719                     total = reduce(operator.__mul__, d)
 720                     m = cv.CreateMatND(d, t)
 721                     for i in range(total):
 722                         cv.Set1D(m, i, i)
 723                     na = numpy.asarray(m).reshape((total,))
 724                     self.assertEqual(list(na), range(total))
 725
 726                     # now do numpy -> cvmat, and verify
 727                     m2 = cv.fromarray(na)
 728
 729                     # Check that new cvmat m2 contains same counting sequence
 730                     for i in range(total):
 731                         self.assertEqual(cv.Get1D(m, i)[0], i)
 732
 733             im = cv.CreateMatND([2, 13], cv.CV_16UC1)
 734             cv.SetZero(im)
 735             im[0,0] = 3
 736             a = numpy.asarray(im)
 737             cvmatnd = cv.fromarray(a)
 738             self.assertEqual(cv.GetDims(cvmatnd), (2, 13))
 739
 740             # im, a and cvmatnd all point to the same data, so...
 741             a[0, 1] = 77
 742             self.assertEqual(im[0, 1], 77)
 743             cvmatnd[1, 0] = 12
 744             self.assertEqual(a[1, 0], 12)
 745
 746             im = cv.CreateMatND([2, 13], cv.CV_16UC3)
 747             self.assertEqual(numpy.asarray(im).shape, (2, 13, 3))
 748         else:
 749             print "SKIPPING test_numpy - numpy support not built"
 750
 751     def test_stereo(self):
 752         bm = cv.CreateStereoBMState()
 753         def illegal_delete():
 754             bm = cv.CreateStereoBMState()
 755             del bm.preFilterType
 756         def illegal_assign():
 757             bm = cv.CreateStereoBMState()
 758             bm.preFilterType = "foo"
 759
 760         self.assertRaises(TypeError, illegal_delete)
 761         self.assertRaises(TypeError, illegal_assign)
 762
 763         left = self.get_sample("samples/c/lena.jpg", 0)
 764         right = self.get_sample("samples/c/lena.jpg", 0)
 765         disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
 766         cv.FindStereoCorrespondenceBM(left, right, disparity, bm)
 767
 768         gc = cv.CreateStereoGCState(16, 2)
 769         left_disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
 770         right_disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
 771         cv.FindStereoCorrespondenceGC(left, right, left_disparity, right_disparity, gc)
 772
 773     def test_kalman(self):
 774         k = cv.CreateKalman(2, 1, 0)
 775
 776     def failing_test_exception(self):
 777         a = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
 778         b = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
 779         self.assertRaises(cv.error, lambda: cv.Laplace(a, b))
 780
 781     def test_cvmat_accessors(self):
 782         cvm = cv.CreateMat(20, 10, cv.CV_32FC1)
 783
 784     def test_depths(self):
 785         """ Make sure that the depth enums are unique """
 786         self.assert_(len(self.depths) == len(set(self.depths)))
 787
 788     def test_leak(self):
 789         """ If CreateImage is not releasing image storage, then the loop below should use ~4GB of memory. """
 790         for i in range(4000):
 791             a = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
 792         for i in range(4000):
 793             a = cv.CreateMat(1024, 1024, cv.CV_8UC1)
 794
 795     def test_histograms(self):
 796         def split(im):
 797             nchans = cv.CV_MAT_CN(cv.GetElemType(im))
 798             c = [ cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 1) for i in range(nchans) ] + [None] * (4 - nchans)
 799             cv.Split(im, c[0], c[1], c[2], c[3])
 800             return c[:nchans]
 801         def imh(im):
 802             s = split(im)
 803             hist = cv.CreateHist([256] * len(s), cv.CV_HIST_ARRAY, [ (0,255) ] * len(s), 1)
 804             cv.CalcHist(s, hist, 0)
 805             return hist
 806
 807         dims = [180]
 808         ranges = [(0,180)]
 809         a = cv.CreateHist(dims, cv.CV_HIST_ARRAY , ranges, 1)
 810         src = self.get_sample("samples/c/lena.jpg", 0)
 811         h = imh(src)
 812         (minv, maxv, minl, maxl) = cv.GetMinMaxHistValue(h)
 813         self.assert_(cv.QueryHistValue_nD(h, minl) == minv)
 814         self.assert_(cv.QueryHistValue_nD(h, maxl) == maxv)
 815         bp = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
 816         cv.CalcBackProject(split(src), bp, h)
 817         bp = cv.CreateImage((cv.GetSize(src)[0]-2, cv.GetSize(src)[1]-2), cv.IPL_DEPTH_32F, 1)
 818         cv.CalcBackProjectPatch(split(src), bp, (3,3), h, cv.CV_COMP_INTERSECT, 1)
 819
 820         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)]:
 821             self.assertEqual(cv.CompareHist(h, h, meth), expected)
 822
 823     def test_arithmetic(self):
 824         a = cv.CreateMat(4, 4, cv.CV_8UC1)
 825         a[0,0] = 50.0
 826         b = cv.CreateMat(4, 4, cv.CV_8UC1)
 827         b[0,0] = 4.0
 828         d = cv.CreateMat(4, 4, cv.CV_8UC1)
 829         cv.Add(a, b, d)
 830         self.assertEqual(d[0,0], 54.0)
 831         cv.Mul(a, b, d)
 832         self.assertEqual(d[0,0], 200.0)
 833
 834
 835     def failing_test_cvtcolor(self):
 836         src3 = self.get_sample("samples/c/lena.jpg")
 837         src1 = self.get_sample("samples/c/lena.jpg", 0)
 838         dst8u = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_8U, c)) for c in (1,2,3,4)])
 839         dst16u = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_16U, c)) for c in (1,2,3,4)])
 840         dst32f = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_32F, c)) for c in (1,2,3,4)])
 841
 842         for srcf in ["BGR", "RGB"]:
 843             for dstf in ["Luv"]:
 844                 cv.CvtColor(src3, dst8u[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
 845                 cv.CvtColor(src3, dst32f[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
 846                 cv.CvtColor(src3, dst8u[3], eval("cv.CV_%s2%s" % (dstf, srcf)))
 847
 848         for srcf in ["BayerBG", "BayerGB", "BayerGR"]:
 849             for dstf in ["RGB", "BGR"]:
 850                 cv.CvtColor(src1, dst8u[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
 851
 852     def test_voronoi(self):
 853         w,h = 500,500
 854
 855         storage = cv.CreateMemStorage(0)
 856
 857         def facet_edges(e0):
 858             e = e0
 859             while True:
 860                 e = cv.Subdiv2DGetEdge(e, cv.CV_NEXT_AROUND_LEFT)
 861                 yield e
 862                 if e == e0:
 863                     break
 864
 865         def areas(edges):
 866             seen = []
 867             seensorted = []
 868             for edge in edges:
 869                 pts = [ cv.Subdiv2DEdgeOrg(e) for e in facet_edges(edge) ]
 870                 if not (None in pts):
 871                     l = [p.pt for p in pts]
 872                     ls = sorted(l)
 873                     if not(ls in seensorted):
 874                         seen.append(l)
 875                         seensorted.append(ls)
 876             return seen
 877
 878         for npoints in range(1, 200):
 879             points = [ (random.randrange(w), random.randrange(h)) for i in range(npoints) ]
 880             subdiv = cv.CreateSubdivDelaunay2D( (0,0,w,h), storage )
 881             for p in points:
 882                 cv.SubdivDelaunay2DInsert( subdiv, p)
 883             cv.CalcSubdivVoronoi2D(subdiv)
 884             ars = areas([ cv.Subdiv2DRotateEdge(e, 1) for e in subdiv.edges ] + [ cv.Subdiv2DRotateEdge(e, 3) for e in subdiv.edges ])
 885             self.assert_(len(ars) == len(set(points)))
 886
 887             if False:
 888                 img = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 3)
 889                 cv.SetZero(img)
 890                 def T(x): return int(x) # int(300+x/16)
 891                 for pts in ars:
 892                     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 );
 893                 for x,y in points:
 894                     cv.Circle(img, (T(x), T(y)), 3, cv.RGB(0,0,0), -1)
 895
 896                 cv.ShowImage("snap", img)
 897                 if cv.WaitKey(10) > 0:
 898                     break
 899
 900     def perf_test_pow(self):
 901         mt = cv.CreateMat(1000, 1000, cv.CV_32FC1)
 902         dst = cv.CreateMat(1000, 1000, cv.CV_32FC1)
 903         rng = cv.RNG(0)
 904         cv.RandArr(rng, mt, cv.CV_RAND_UNI, 0, 1000.0)
 905         mt[0,0] = 10
 906         print
 907         for a in [0.5, 2.0, 2.3, 2.4, 3.0, 37.1786] + [2.4]*10:
 908             started = time.time()
 909             for i in range(10):
 910                 cv.Pow(mt, dst, a)
 911             took = (time.time() - started) / 1e7
 912             print "%4.1f took %f ns" % (a, took * 1e9)
 913         print dst[0,0], 10 ** 2.4
 914
 915     def test_access_row_col(self):
 916         src = cv.CreateImage((8,3), 8, 1)
 917         # Put these words
 918         #     Achilles
 919         #     Benedict
 920         #     Congreve
 921         # in an array (3 rows, 8 columns).
 922         # Then extract the array in various ways.
 923
 924         for r,w in enumerate(("Achilles", "Benedict", "Congreve")):
 925             for c,v in enumerate(w):
 926                 src[r,c] = ord(v)
 927         self.assertEqual(src.tostring(), "AchillesBenedictCongreve")
 928         self.assertEqual(src[:,:].tostring(), "AchillesBenedictCongreve")
 929         self.assertEqual(src[:,:4].tostring(), "AchiBeneCong")
 930         self.assertEqual(src[:,0].tostring(), "ABC")
 931         self.assertEqual(src[:,4:].tostring(), "llesdictreve")
 932         self.assertEqual(src[::2,:].tostring(), "AchillesCongreve")
 933         self.assertEqual(src[1:,:].tostring(), "BenedictCongreve")
 934         self.assertEqual(src[1:2,:].tostring(), "Benedict")
 935         self.assertEqual(src[::2,:4].tostring(), "AchiCong")
 936         # The mats share the same storage, so updating one should update them all
 937         lastword = src[2]
 938         self.assertEqual(lastword.tostring(), "Congreve")
 939         src[2,0] = ord('K')
 940         self.assertEqual(lastword.tostring(), "Kongreve")
 941         src[2,0] = ord('C')
 942
 943         # ABCD
 944         # EFGH
 945         # IJKL
 946         #
 947         # MNOP
 948         # QRST
 949         # UVWX
 950
 951         mt = cv.CreateMatND([2,3,4], cv.CV_8UC1)
 952         for i in range(2):
 953             for j in range(3):
 954                 for k in range(4):
 955                     mt[i,j,k] = ord('A') + k + 4 * (j + 3 * i)
 956         self.assertEqual(mt[:,:,:1].tostring(), "AEIMQU")
 957         self.assertEqual(mt[:,:1,:].tostring(), "ABCDMNOP")
 958         self.assertEqual(mt[:1,:,:].tostring(), "ABCDEFGHIJKL")
 959         self.assertEqual(mt[1,1].tostring(), "QRST")
 960         self.assertEqual(mt[:,::2,:].tostring(), "ABCDIJKLMNOPUVWX")
 961
 962         # Exercise explicit GetRows
 963         self.assertEqual(cv.GetRows(src, 0, 3).tostring(), "AchillesBenedictCongreve")
 964         self.assertEqual(cv.GetRows(src, 0, 3, 1).tostring(), "AchillesBenedictCongreve")
 965         self.assertEqual(cv.GetRows(src, 0, 3, 2).tostring(), "AchillesCongreve")
 966
 967         self.assertEqual(cv.GetRow(src, 0).tostring(), "Achilles")
 968
 969         self.assertEqual(cv.GetCols(src, 0, 4).tostring(), "AchiBeneCong")
 970
 971         self.assertEqual(cv.GetCol(src, 0).tostring(), "ABC")
 972         self.assertEqual(cv.GetCol(src, 1).tostring(), "ceo")
 973
 974         self.assertEqual(cv.GetDiag(src, 0).tostring(), "Aen")
 975
 976         # Check that matrix type is preserved by the various operators
 977
 978         for mt in self.mat_types:
 979             m = cv.CreateMat(5, 3, mt)
 980             self.assertEqual(mt, cv.GetElemType(cv.GetRows(m, 0, 2)))
 981             self.assertEqual(mt, cv.GetElemType(cv.GetRow(m, 0)))
 982             self.assertEqual(mt, cv.GetElemType(cv.GetCols(m, 0, 2)))
 983             self.assertEqual(mt, cv.GetElemType(cv.GetCol(m, 0)))
 984             self.assertEqual(mt, cv.GetElemType(cv.GetDiag(m, 0)))
 985             self.assertEqual(mt, cv.GetElemType(m[0]))
 986             self.assertEqual(mt, cv.GetElemType(m[::2]))
 987             self.assertEqual(mt, cv.GetElemType(m[:,0]))
 988             self.assertEqual(mt, cv.GetElemType(m[:,:]))
 989             self.assertEqual(mt, cv.GetElemType(m[::2,:]))
 990
 991     def test_addS_3D(self):
 992         for dim in [ [1,1,4], [2,2,3], [7,4,3] ]:
 993             for ty,ac in [ (cv.CV_32FC1, 'f'), (cv.CV_64FC1, 'd')]:
 994                 mat = cv.CreateMatND(dim, ty)
 995                 mat2 = cv.CreateMatND(dim, ty)
 996                 for increment in [ 0, 3, -1 ]:
 997                     cv.SetData(mat, array.array(ac, range(dim[0] * dim[1] * dim[2])), 0)
 998                     cv.AddS(mat, increment, mat2)
 999                     for i in range(dim[0]):
1000                         for j in range(dim[1]):
1001                             for k in range(dim[2]):
1002                                 self.assert_(mat2[i,j,k] == mat[i,j,k] + increment)
1003
1004     def test_buffers(self):
1005         ar = array.array('f', [7] * (360*640))
1006
1007         m = cv.CreateMat(360, 640, cv.CV_32FC1)
1008         cv.SetData(m, ar, 4 * 640)
1009         self.assert_(m[0,0] == 7.0)
1010
1011         m = cv.CreateMatND((360, 640), cv.CV_32FC1)
1012         cv.SetData(m, ar, 4 * 640)
1013         self.assert_(m[0,0] == 7.0)
1014
1015         m = cv.CreateImage((640, 360), cv.IPL_DEPTH_32F, 1)
1016         cv.SetData(m, ar, 4 * 640)
1017         self.assert_(m[0,0] == 7.0)
1018
1019     def xxtest_Filters(self):
1020         print
1021         m = cv.CreateMat(360, 640, cv.CV_32FC1)
1022         d = cv.CreateMat(360, 640, cv.CV_32FC1)
1023         for k in range(3, 21, 2):
1024             started = time.time()
1025             for i in range(1000):
1026                 cv.Smooth(m, m, param1=k)
1027             print k, "took", time.time() - started
1028
1029     def assertSame(self, a, b):
1030         w,h = cv.GetSize(a)
1031         d = cv.CreateMat(h, w, cv.CV_8UC1)
1032         cv.AbsDiff(a, b, d)
1033         self.assert_(cv.CountNonZero(d) == 0)
1034
1035     def test_text(self):
1036         img = cv.CreateImage((640,40), cv.IPL_DEPTH_8U, 1)
1037         cv.SetZero(img)
1038         font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1)
1039         message = "XgfooX"
1040         cv.PutText(img, message, (320,30), font, 255)
1041         ((w,h),bl) = cv.GetTextSize(message, font)
1042
1043         # Find nonzero in X and Y
1044         Xs = []
1045         for x in range(640):
1046             cv.SetImageROI(img, (x, 0, 1, 40))
1047             Xs.append(cv.Sum(img)[0] > 0)
1048         def firstlast(l):
1049             return (l.index(True), len(l) - list(reversed(l)).index(True))
1050
1051         Ys = []
1052         for y in range(40):
1053             cv.SetImageROI(img, (0, y, 640, 1))
1054             Ys.append(cv.Sum(img)[0] > 0)
1055
1056         x0,x1 = firstlast(Xs)
1057         y0,y1 = firstlast(Ys)
1058         actual_width = x1 - x0
1059         actual_height = y1 - y0
1060
1061         # actual_width can be up to 8 pixels smaller than GetTextSize says
1062         self.assert_(actual_width <= w)
1063         self.assert_((w - actual_width) <= 8)
1064
1065         # actual_height can be up to 4 pixels smaller than GetTextSize says
1066         self.assert_(actual_height <= (h + bl))
1067         self.assert_(((h + bl) - actual_height) <= 4)
1068
1069         cv.ResetImageROI(img)
1070         self.assert_(w != 0)
1071         self.assert_(h != 0)
1072
1073     def test_sizes(self):
1074         sizes = [ 1, 2, 3, 97, 255, 256, 257, 947 ]
1075         for w in sizes:
1076             for h in sizes:
1077                 # Create an IplImage
1078                 im = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 1)
1079                 cv.Set(im, 1)
1080                 self.assert_(cv.Sum(im)[0] == (w * h))
1081                 del im
1082                 # Create a CvMat
1083                 mt = cv.CreateMat(h, w, cv.CV_8UC1)
1084                 cv.Set(mt, 1)
1085                 self.assert_(cv.Sum(mt)[0] == (w * h))
1086
1087         random.seed(7)
1088         for dim in range(1, cv.CV_MAX_DIM + 1):
1089             for attempt in range(10):
1090                 dims = [ random.choice([1,1,1,1,2,3]) for i in range(dim) ]
1091                 mt = cv.CreateMatND(dims, cv.CV_8UC1)
1092                 cv.SetZero(mt)
1093                 self.assert_(cv.Sum(mt)[0] == 0)
1094                 # Set to all-ones, verify the sum
1095                 cv.Set(mt, 1)
1096                 expected = 1
1097                 for d in dims:
1098                     expected *= d
1099                 self.assert_(cv.Sum(mt)[0] == expected)
1100
1101     def test_random(self):
1102         seeds = [ 0, 1, 2**48, 2**48 + 1 ]
1103         sequences = set()
1104         for s in seeds:
1105             rng = cv.RNG(s)
1106             sequences.add(str([cv.RandInt(rng) for i in range(10)]))
1107         self.assert_(len(seeds) == len(sequences))
1108
1109         rng = cv.RNG(0)
1110         im = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
1111         cv.RandArr(rng, im, cv.CV_RAND_UNI, 0, 256)
1112         cv.RandArr(rng, im, cv.CV_RAND_NORMAL, 128, 30)
1113         if 1:
1114             hist = cv.CreateHist([ 256 ], cv.CV_HIST_ARRAY, [ (0,255) ], 1)
1115             cv.CalcHist([im], hist)
1116
1117         rng = cv.RNG()
1118         for i in range(1000):
1119             v = cv.RandReal(rng)
1120             self.assert_(0 <= v)
1121             self.assert_(v < 1)
1122
1123         for mode in [ cv.CV_RAND_UNI, cv.CV_RAND_NORMAL ]:
1124             for fmt in self.mat_types:
1125                 mat = cv.CreateMat(64, 64, fmt)
1126                 cv.RandArr(cv.RNG(), mat, mode, (0,0,0,0), (1,1,1,1))
1127
1128     def test_MixChannels(self):
1129
1130         # First part - test the single case described in the documentation
1131         rgba = cv.CreateMat(100, 100, cv.CV_8UC4)
1132         bgr = cv.CreateMat(100, 100, cv.CV_8UC3)
1133         alpha = cv.CreateMat(100, 100, cv.CV_8UC1)
1134         cv.Set(rgba, (1,2,3,4))
1135         cv.MixChannels([rgba], [bgr, alpha], [
1136            (0, 2),    # rgba[0] -> bgr[2]
1137            (1, 1),    # rgba[1] -> bgr[1]
1138            (2, 0),    # rgba[2] -> bgr[0]
1139            (3, 3)     # rgba[3] -> alpha[0]
1140         ])
1141         self.assert_(bgr[0,0] == (3,2,1))
1142         self.assert_(alpha[0,0] == 4)
1143
1144         # Second part.  Choose random sets of sources and destinations,
1145         # fill them with known values, choose random channel assignments,
1146         # run cvMixChannels and check that the result is as expected.
1147
1148         random.seed(1)
1149
1150         for rows in [1,2,4,13,64,1000]:
1151             for cols in [1,2,4,13,64,1000]:
1152                 for loop in range(5):
1153                     sources = [random.choice([1, 2, 3, 4]) for i in range(8)]
1154                     dests = [random.choice([1, 2, 3, 4]) for i in range(8)]
1155                     # make sure that fromTo does not have duplicates in dests, otherwise the result is not determined
1156                     while 1:
1157                         fromTo = [(random.randrange(-1, sum(sources)), random.randrange(sum(dests))) for i in range(random.randrange(1, 30))]
1158                         dests_set = list(set([j for (i, j) in fromTo]))
1159                         if len(dests_set) == len(dests):
1160                             break
1161
1162                     # print sources
1163                     # print dests
1164                     # print fromTo
1165
1166                     def CV_8UC(n):
1167                         return [cv.CV_8UC1, cv.CV_8UC2, cv.CV_8UC3, cv.CV_8UC4][n-1]
1168                     source_m = [cv.CreateMat(rows, cols, CV_8UC(c)) for c in sources]
1169                     dest_m =   [cv.CreateMat(rows, cols, CV_8UC(c)) for c in dests]
1170
1171                     def m00(m):
1172                         # return the contents of the N channel mat m[0,0] as a N-length list
1173                         chans = cv.CV_MAT_CN(cv.GetElemType(m))
1174                         if chans == 1:
1175                             return [m[0,0]]
1176                         else:
1177                             return list(m[0,0])[:chans]
1178
1179                     # Sources numbered from 50, destinations numbered from 100
1180
1181                     for i in range(len(sources)):
1182                         s = sum(sources[:i]) + 50
1183                         cv.Set(source_m[i], (s, s+1, s+2, s+3))
1184                         self.assertEqual(m00(source_m[i]), [s, s+1, s+2, s+3][:sources[i]])
1185
1186                     for i in range(len(dests)):
1187                         s = sum(dests[:i]) + 100
1188                         cv.Set(dest_m[i], (s, s+1, s+2, s+3))
1189                         self.assertEqual(m00(dest_m[i]), [s, s+1, s+2, s+3][:dests[i]])
1190
1191                     # now run the sanity check
1192
1193                     for i in range(len(sources)):
1194                         s = sum(sources[:i]) + 50
1195                         self.assertEqual(m00(source_m[i]), [s, s+1, s+2, s+3][:sources[i]])
1196
1197                     for i in range(len(dests)):
1198                         s = sum(dests[:i]) + 100
1199                         self.assertEqual(m00(dest_m[i]), [s, s+1, s+2, s+3][:dests[i]])
1200
1201                     cv.MixChannels(source_m, dest_m, fromTo)
1202
1203                     expected = range(100, 100 + sum(dests))
1204                     for (i, j) in fromTo:
1205                         if i == -1:
1206                             expected[j] = 0.0
1207                         else:
1208                             expected[j] = 50 + i
1209
1210                     actual = sum([m00(m) for m in dest_m], [])
1211                     self.assertEqual(sum([m00(m) for m in dest_m], []), expected)
1212
1213     def test_allocs(self):
1214         mats = [ 0 for i in range(20) ]
1215         for i in range(1000):
1216             m = cv.CreateMat(random.randrange(10, 512), random.randrange(10, 512), cv.CV_8UC1)
1217             j = random.randrange(len(mats))
1218             mats[j] = m
1219             cv.SetZero(m)
1220
1221     def test_access(self):
1222         cnames = { 1:cv.CV_32FC1, 2:cv.CV_32FC2, 3:cv.CV_32FC3, 4:cv.CV_32FC4 }
1223
1224         for w in range(1,11):
1225             for h in range(2,11):
1226                 for c in [1,2]:
1227                     for o in [ cv.CreateMat(h, w, cnames[c]), cv.CreateImage((w,h), cv.IPL_DEPTH_32F, c) ][1:]:
1228                         pattern = [ (i,j) for i in range(w) for j in range(h) ]
1229                         random.shuffle(pattern)
1230                         for k,(i,j) in enumerate(pattern):
1231                             if c == 1:
1232                                 o[j,i] = k
1233                             else:
1234                                 o[j,i] = (k,) * c
1235                         for k,(i,j) in enumerate(pattern):
1236                             if c == 1:
1237                                 self.assert_(o[j,i] == k)
1238                             else:
1239                                 self.assert_(o[j,i] == (k,)*c)
1240
1241         test_mat = cv.CreateMat(2, 3, cv.CV_32FC1)
1242         cv.SetData(test_mat, array.array('f', range(6)), 12)
1243         self.assertEqual(cv.GetDims(test_mat[0]), (1, 3))
1244         self.assertEqual(cv.GetDims(test_mat[1]), (1, 3))
1245         self.assertEqual(cv.GetDims(test_mat[0:1]), (1, 3))
1246         self.assertEqual(cv.GetDims(test_mat[1:2]), (1, 3))
1247         self.assertEqual(cv.GetDims(test_mat[-1:]), (1, 3))
1248         self.assertEqual(cv.GetDims(test_mat[-1]), (1, 3))
1249
1250     def xxxtest_corners(self):
1251         a = cv.LoadImage("foo-mono.png", 0)
1252         cv.AdaptiveThreshold(a, a, 255, param1=5)
1253         scribble = cv.CreateImage(cv.GetSize(a), 8, 3)
1254         cv.CvtColor(a, scribble, cv.CV_GRAY2BGR)
1255         if 0:
1256             eig_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
1257             temp_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
1258             pts = cv.GoodFeaturesToTrack(a, eig_image, temp_image, 100, 0.04, 2, use_harris=1)
1259             for p in pts:
1260                 cv.Circle( scribble, p, 1, cv.RGB(255,0,0), -1 )
1261             self.snap(scribble)
1262         canny = cv.CreateImage(cv.GetSize(a), 8, 1)
1263         cv.SubRS(a, 255, canny)
1264         self.snap(canny)
1265         li = cv.HoughLines2(canny,
1266                                                 cv.CreateMemStorage(),
1267                                                 cv.CV_HOUGH_STANDARD,
1268                                                 1,
1269                                                 math.pi/180,
1270                                                 60,
1271                                                 0,
1272                                                 0)
1273         for (rho,theta) in li:
1274             print rho,theta
1275             c = math.cos(theta)
1276             s = math.sin(theta)
1277             x0 = c*rho
1278             y0 = s*rho
1279             cv.Line(scribble,
1280                             (x0 + 1000*(-s), y0 + 1000*c),
1281                             (x0 + -1000*(-s), y0 - 1000*c),
1282                             (0,255,0))
1283         self.snap(scribble)
1284
1285     def test_calibration(self):
1286
1287         def get_corners(mono, refine = False):
1288             (ok, corners) = cv.FindChessboardCorners(mono, (num_x_ints, num_y_ints), cv.CV_CALIB_CB_ADAPTIVE_THRESH | cv.CV_CALIB_CB_NORMALIZE_IMAGE)
1289             if refine and ok:
1290                 corners = cv.FindCornerSubPix(mono, corners, (5,5), (-1,-1), ( cv.CV_TERMCRIT_EPS+cv.CV_TERMCRIT_ITER, 30, 0.1 ))
1291             return (ok, corners)
1292
1293         def mk_object_points(nimages, squaresize = 1):
1294             opts = cv.CreateMat(nimages * num_pts, 3, cv.CV_32FC1)
1295             for i in range(nimages):
1296                 for j in range(num_pts):
1297                     opts[i * num_pts + j, 0] = (j / num_x_ints) * squaresize
1298                     opts[i * num_pts + j, 1] = (j % num_x_ints) * squaresize
1299                     opts[i * num_pts + j, 2] = 0
1300             return opts
1301
1302         def mk_image_points(goodcorners):
1303             ipts = cv.CreateMat(len(goodcorners) * num_pts, 2, cv.CV_32FC1)
1304             for (i, co) in enumerate(goodcorners):
1305                 for j in range(num_pts):
1306                     ipts[i * num_pts + j, 0] = co[j][0]
1307                     ipts[i * num_pts + j, 1] = co[j][1]
1308             return ipts
1309
1310         def mk_point_counts(nimages):
1311             npts = cv.CreateMat(nimages, 1, cv.CV_32SC1)
1312             for i in range(nimages):
1313                 npts[i, 0] = num_pts
1314             return npts
1315
1316         def cvmat_iterator(cvmat):
1317             for i in range(cvmat.rows):
1318                 for j in range(cvmat.cols):
1319                     yield cvmat[i,j]
1320
1321         def image_from_archive(tar, name):
1322             member = tar.getmember(name)
1323             filedata = tar.extractfile(member).read()
1324             imagefiledata = cv.CreateMat(1, len(filedata), cv.CV_8UC1)
1325             cv.SetData(imagefiledata, filedata, len(filedata))
1326             return cv.DecodeImageM(imagefiledata)
1327
1328         urllib.urlretrieve("http://pr.willowgarage.com/data/camera_calibration/camera_calibration.tar.gz", "camera_calibration.tar.gz")
1329         tf = tarfile.open("camera_calibration.tar.gz")
1330
1331         num_x_ints = 8
1332         num_y_ints = 6
1333         num_pts = num_x_ints * num_y_ints
1334
1335         leftimages = [image_from_archive(tf, "wide/left%04d.pgm" % i) for i in range(3, 15)]
1336         size = cv.GetSize(leftimages[0])
1337
1338         # Monocular test
1339
1340         if True:
1341             corners = [get_corners(i) for i in leftimages]
1342             goodcorners = [co for (im, (ok, co)) in zip(leftimages, corners) if ok]
1343
1344             ipts = mk_image_points(goodcorners)
1345             opts = mk_object_points(len(goodcorners), .1)
1346             npts = mk_point_counts(len(goodcorners))
1347
1348             intrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
1349             distortion = cv.CreateMat(4, 1, cv.CV_64FC1)
1350             cv.SetZero(intrinsics)
1351             cv.SetZero(distortion)
1352             # focal lengths have 1/1 ratio
1353             intrinsics[0,0] = 1.0
1354             intrinsics[1,1] = 1.0
1355             cv.CalibrateCamera2(opts, ipts, npts,
1356                        cv.GetSize(leftimages[0]),
1357                        intrinsics,
1358                        distortion,
1359                        cv.CreateMat(len(goodcorners), 3, cv.CV_32FC1),
1360                        cv.CreateMat(len(goodcorners), 3, cv.CV_32FC1),
1361                        flags = 0) # cv.CV_CALIB_ZERO_TANGENT_DIST)
1362             # print "D =", list(cvmat_iterator(distortion))
1363             # print "K =", list(cvmat_iterator(intrinsics))
1364
1365             newK = cv.CreateMat(3, 3, cv.CV_64FC1)
1366             cv.GetOptimalNewCameraMatrix(intrinsics, distortion, size, 1.0, newK)
1367             # print "newK =", list(cvmat_iterator(newK))
1368
1369             mapx = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
1370             mapy = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
1371             for K in [ intrinsics, newK ]:
1372                 cv.InitUndistortMap(K, distortion, mapx, mapy)
1373                 for img in leftimages[:1]:
1374                     r = cv.CloneMat(img)
1375                     cv.Remap(img, r, mapx, mapy)
1376                     # cv.ShowImage("snap", r)
1377                     # cv.WaitKey()
1378
1379         rightimages = [image_from_archive(tf, "wide/right%04d.pgm" % i) for i in range(3, 15)]
1380
1381         # Stereo test
1382
1383         if True:
1384             lcorners = [get_corners(i) for i in leftimages]
1385             rcorners = [get_corners(i) for i in rightimages]
1386             good = [(lco, rco) for ((lok, lco), (rok, rco)) in zip(lcorners, rcorners) if (lok and rok)]
1387
1388             lipts = mk_image_points([l for (l, r) in good])
1389             ripts = mk_image_points([r for (l, r) in good])
1390             opts = mk_object_points(len(good), .108)
1391             npts = mk_point_counts(len(good))
1392
1393             flags = cv.CV_CALIB_FIX_ASPECT_RATIO | cv.CV_CALIB_FIX_INTRINSIC
1394             flags = cv.CV_CALIB_SAME_FOCAL_LENGTH + cv.CV_CALIB_FIX_PRINCIPAL_POINT + cv.CV_CALIB_ZERO_TANGENT_DIST
1395             flags = 0
1396
1397             T = cv.CreateMat(3, 1, cv.CV_64FC1)
1398             R = cv.CreateMat(3, 3, cv.CV_64FC1)
1399             lintrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
1400             ldistortion = cv.CreateMat(4, 1, cv.CV_64FC1)
1401             rintrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
1402             rdistortion = cv.CreateMat(4, 1, cv.CV_64FC1)
1403             lR = cv.CreateMat(3, 3, cv.CV_64FC1)
1404             rR = cv.CreateMat(3, 3, cv.CV_64FC1)
1405             lP = cv.CreateMat(3, 4, cv.CV_64FC1)
1406             rP = cv.CreateMat(3, 4, cv.CV_64FC1)
1407             lmapx = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
1408             lmapy = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
1409             rmapx = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
1410             rmapy = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
1411
1412             cv.SetIdentity(lintrinsics)
1413             cv.SetIdentity(rintrinsics)
1414             lintrinsics[0,2] = size[0] * 0.5
1415             lintrinsics[1,2] = size[1] * 0.5
1416             rintrinsics[0,2] = size[0] * 0.5
1417             rintrinsics[1,2] = size[1] * 0.5
1418             cv.SetZero(ldistortion)
1419             cv.SetZero(rdistortion)
1420
1421             cv.StereoCalibrate(opts, lipts, ripts, npts,
1422                                lintrinsics, ldistortion,
1423                                rintrinsics, rdistortion,
1424                                size,
1425                                R,                                  # R
1426                                T,                                  # T
1427                                cv.CreateMat(3, 3, cv.CV_32FC1),    # E
1428                                cv.CreateMat(3, 3, cv.CV_32FC1),    # F
1429                                (cv.CV_TERMCRIT_ITER + cv.CV_TERMCRIT_EPS, 30, 1e-5),
1430                                flags)
1431
1432             for a in [-1, 0, 1]:
1433                 cv.StereoRectify(lintrinsics,
1434                                  rintrinsics,
1435                                  ldistortion,
1436                                  rdistortion,
1437                                  size,
1438                                  R,
1439                                  T,
1440                                  lR, rR, lP, rP,
1441                                  alpha = a)
1442
1443                 cv.InitUndistortRectifyMap(lintrinsics, ldistortion, lR, lP, lmapx, lmapy)
1444                 cv.InitUndistortRectifyMap(rintrinsics, rdistortion, rR, rP, rmapx, rmapy)
1445
1446                 for l,r in zip(leftimages, rightimages)[:1]:
1447                     l_ = cv.CloneMat(l)
1448                     r_ = cv.CloneMat(r)
1449                     cv.Remap(l, l_, lmapx, lmapy)
1450                     cv.Remap(r, r_, rmapx, rmapy)
1451                     # cv.ShowImage("snap", l_)
1452                     # cv.WaitKey()
1453
1454
1455     def xxx_test_Disparity(self):
1456         print
1457         for t in ["8U", "8S", "16U", "16S", "32S", "32F", "64F" ]:
1458           for c in [1,2,3,4]:
1459             nm = "%sC%d" % (t, c)
1460             print "int32 CV_%s=%d" % (nm, eval("cv.CV_%s" % nm))
1461         return
1462         integral = cv.CreateImage((641,481), cv.IPL_DEPTH_32S, 1)
1463         L = cv.LoadImage("f0-left.png", 0)
1464         R = cv.LoadImage("f0-right.png", 0)
1465         d = cv.CreateImage(cv.GetSize(L), cv.IPL_DEPTH_8U, 1)
1466         Rn = cv.CreateImage(cv.GetSize(L), cv.IPL_DEPTH_8U, 1)
1467         started = time.time()
1468         for i in range(100):
1469             cv.AbsDiff(L, R, d)
1470             cv.Integral(d, integral)
1471             cv.SetImageROI(R, (1, 1, 639, 479))
1472             cv.SetImageROI(Rn, (0, 0, 639, 479))
1473             cv.Copy(R, Rn)
1474             R = Rn
1475             cv.ResetImageROI(R)
1476         print 1e3 * (time.time() - started) / 100, "ms"
1477         # self.snap(d)
1478
1479     def local_test_lk(self):
1480         seq = [cv.LoadImage("track/%06d.png" % i, 0) for i in range(40)]
1481         crit = (cv.CV_TERMCRIT_ITER, 100, 0.1)
1482         crit = (cv.CV_TERMCRIT_EPS, 0, 0.001)
1483
1484         for i in range(1,40):
1485             r = cv.CalcOpticalFlowPyrLK(seq[0], seq[i], None, None, [(32,32)], (7,7), 0, crit, 0)
1486             pos = r[0][0]
1487             #print pos, r[2]
1488
1489             a = cv.CreateImage((1024,1024), 8, 1)
1490             b = cv.CreateImage((1024,1024), 8, 1)
1491             cv.Resize(seq[0], a, cv.CV_INTER_NN)
1492             cv.Resize(seq[i], b, cv.CV_INTER_NN)
1493             cv.Line(a, (0, 512), (1024, 512), 255)
1494             cv.Line(a, (512,0), (512,1024), 255)
1495             x,y = [int(c) for c in pos]
1496             cv.Line(b, (0, y*16), (1024, y*16), 255)
1497             cv.Line(b, (x*16,0), (x*16,1024), 255)
1498             #self.snapL([a,b])
1499
1500
1501
1502     def local_test_Haar(self):
1503         import os
1504         hcfile = os.environ['OPENCV_ROOT'] + '/share/opencv/haarcascades/haarcascade_frontalface_default.xml'
1505         hc = cv.Load(hcfile)
1506         img = cv.LoadImage('Stu.jpg', 0)
1507         faces = cv.HaarDetectObjects(img, hc, cv.CreateMemStorage())
1508         self.assert_(len(faces) > 0)
1509         for (x,y,w,h),n in faces:
1510             cv.Rectangle(img, (x,y), (x+w,y+h), 255)
1511         #self.snap(img)
1512
1513     def test_create(self):
1514         """ CvCreateImage, CvCreateMat and the header-only form """
1515         for (w,h) in [ (320,400), (640,480), (1024, 768) ]:
1516             data = "z" * (w * h)
1517
1518             im = cv.CreateImage((w,h), 8, 1)
1519             cv.SetData(im, data, w)
1520             im2 = cv.CreateImageHeader((w,h), 8, 1)
1521             cv.SetData(im2, data, w)
1522             self.assertSame(im, im2)
1523
1524             m = cv.CreateMat(h, w, cv.CV_8UC1)
1525             cv.SetData(m, data, w)
1526             m2 = cv.CreateMatHeader(h, w, cv.CV_8UC1)
1527             cv.SetData(m2, data, w)
1528             self.assertSame(m, m2)
1529
1530             self.assertSame(im, m)
1531             self.assertSame(im2, m2)
1532
1533
1534     def test_casts(self):
1535         im = cv.GetImage(self.get_sample("samples/c/lena.jpg", 0))
1536         data = im.tostring()
1537         cv.SetData(im, data, cv.GetSize(im)[0])
1538
1539         start_count = sys.getrefcount(data)
1540
1541         # Conversions should produce same data
1542         self.assertSame(im, cv.GetImage(im))
1543         m = cv.GetMat(im)
1544         self.assertSame(im, m)
1545         self.assertSame(m, cv.GetImage(m))
1546         im2 = cv.GetImage(m)
1547         self.assertSame(im, im2)
1548
1549         self.assertEqual(sys.getrefcount(data), start_count + 2)
1550         del im2
1551         self.assertEqual(sys.getrefcount(data), start_count + 1)
1552         del m
1553         self.assertEqual(sys.getrefcount(data), start_count)
1554         del im
1555         self.assertEqual(sys.getrefcount(data), start_count - 1)
1556
1557     def test_morphological(self):
1558         im = cv.CreateImage((128, 128), cv.IPL_DEPTH_8U, 1)
1559         cv.Resize(cv.GetImage(self.get_sample("samples/c/lena.jpg", 0)), im)
1560         dst = cv.CloneImage(im)
1561         shapes = [eval("cv.CV_SHAPE_%s" % s) for s in ['RECT', 'CROSS', 'ELLIPSE']]
1562         elements = [cv.CreateStructuringElementEx(sz, sz, sz / 2 + 1, sz / 2 + 1, shape) for sz in [3, 4, 7, 20] for shape in shapes]
1563         elements += [cv.CreateStructuringElementEx(7, 7, 3, 3, cv.CV_SHAPE_CUSTOM, [1] * 49)]
1564         for e in elements:
1565             for iter in [1, 2]:
1566                 cv.Dilate(im, dst, e, iter)
1567                 cv.Erode(im, dst, e, iter)
1568                 temp = cv.CloneImage(im)
1569                 for op in ["OPEN", "CLOSE", "GRADIENT", "TOPHAT", "BLACKHAT"]:
1570                         cv.MorphologyEx(im, dst, temp, e, eval("cv.CV_MOP_%s" % op), iter)
1571
1572     def failing_test_getmat_nd(self):
1573         # 1D CvMatND should yield 1D CvMat
1574         matnd = cv.CreateMatND([13], cv.CV_8UC1)
1575         self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (13,))
1576
1577         # 2D CvMatND should yield 2D CvMat
1578         matnd = cv.CreateMatND([11,12], cv.CV_8UC1)
1579         self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (11, 12))
1580
1581         # 3D CvMatND should yield 1D CvMat
1582         matnd = cv.CreateMatND([8,8,8], cv.CV_8UC1)
1583         self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (8 * 8 * 8,))
1584
1585     def test_clipline(self):
1586         self.assert_(cv.ClipLine((100,100), (-100,0), (500,0)) == ((0,0), (99,0)))
1587         self.assert_(cv.ClipLine((100,100), (-100,0), (-200,0)) == None)
1588
1589     def test_smoke_image_processing(self):
1590         src = self.get_sample("samples/c/lena.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
1591         #dst = cv.CloneImage(src)
1592         for aperture_size in [1, 3, 5, 7]:
1593           dst_16s = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_16S, 1)
1594           dst_32f = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_32F, 1)
1595
1596           cv.Sobel(src, dst_16s, 1, 1, aperture_size)
1597           cv.Laplace(src, dst_16s, aperture_size)
1598           cv.PreCornerDetect(src, dst_32f)
1599           eigendst = cv.CreateImage((6*cv.GetSize(src)[0], cv.GetSize(src)[1]), cv.IPL_DEPTH_32F, 1)
1600           cv.CornerEigenValsAndVecs(src, eigendst, 8, aperture_size)
1601           cv.CornerMinEigenVal(src, dst_32f, 8, aperture_size)
1602           cv.CornerHarris(src, dst_32f, 8, aperture_size)
1603           cv.CornerHarris(src, dst_32f, 8, aperture_size, 0.1)
1604
1605         #self.snap(dst)
1606
1607     def test_fitline(self):
1608         cv.FitLine([ (1,1), (10,10) ], cv.CV_DIST_L2, 0, 0.01, 0.01)
1609         cv.FitLine([ (1,1,1), (10,10,10) ], cv.CV_DIST_L2, 0, 0.01, 0.01)
1610         a = self.get_sample("samples/c/lena.jpg", 0)
1611         eig_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
1612         temp_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
1613         pts = cv.GoodFeaturesToTrack(a, eig_image, temp_image, 100, 0.04, 2, use_harris=1)
1614         hull = cv.ConvexHull2(pts, cv.CreateMemStorage(), return_points = 1)
1615         cv.FitLine(hull, cv.CV_DIST_L2, 0, 0.01, 0.01)
1616
1617     def test_moments(self):
1618         im = self.get_sample("samples/c/lena.jpg", 0)
1619         mo = cv.Moments(im)
1620         orders = []
1621         for x_order in range(4):
1622           for y_order in range(4 - x_order):
1623             orders.append((x_order, y_order))
1624
1625         # Just a smoke test for these three functions
1626         [ cv.GetSpatialMoment(mo, xo, yo) for (xo,yo) in orders ]
1627         [ cv.GetCentralMoment(mo, xo, yo) for (xo,yo) in orders ]
1628         [ cv.GetNormalizedCentralMoment(mo, xo, yo) for (xo,yo) in orders ]
1629
1630         # Hu Moments we can do slightly better.  Check that the first
1631         # six are invariant wrt image reflection, and that the 7th
1632         # is negated.
1633
1634         hu0 = cv.GetHuMoments(cv.Moments(im))
1635         cv.Flip(im, im, 1)
1636         hu1 = cv.GetHuMoments(cv.Moments(im))
1637         self.assert_(len(hu0) == 7)
1638         self.assert_(len(hu1) == 7)
1639         for i in range(5):
1640           self.assert_(abs(hu0[i] - hu1[i]) < 1e-6)
1641         self.assert_(abs(hu0[i] + hu1[i]) < 1e-6)
1642
1643     def test_encode(self):
1644         im = self.get_sample("samples/c/lena.jpg", 1)
1645         jpeg = cv.EncodeImage(".jpeg", im)
1646
1647         # Smoke jpeg compression at various qualities
1648         sizes = dict([(qual, cv.EncodeImage(".jpeg", im, [cv.CV_IMWRITE_JPEG_QUALITY, qual]).cols) for qual in range(5, 100, 5)])
1649
1650         # Check that the default QUALITY is 95
1651         self.assertEqual(cv.EncodeImage(".jpeg", im).cols, sizes[95])
1652
1653         # Check that the 'round-trip' gives an image of the same size
1654         round_trip = cv.DecodeImage(cv.EncodeImage(".jpeg", im, [cv.CV_IMWRITE_JPEG_QUALITY, 10]))
1655         self.assert_(cv.GetSize(round_trip) == cv.GetSize(im))
1656
1657     def test_reduce(self):
1658         srcmat = cv.CreateMat(2, 3, cv.CV_32FC1)
1659         # 0 1 2
1660         # 3 4 5
1661         srcmat[0,0] = 0
1662         srcmat[0,1] = 1
1663         srcmat[0,2] = 2
1664         srcmat[1,0] = 3
1665         srcmat[1,1] = 4
1666         srcmat[1,2] = 5
1667         def doreduce(siz, rfunc):
1668             dst = cv.CreateMat(siz[0], siz[1], cv.CV_32FC1)
1669             rfunc(dst)
1670             if siz[0] != 1:
1671                 return [dst[i,0] for i in range(siz[0])]
1672             else:
1673                 return [dst[0,i] for i in range(siz[1])]
1674
1675         # exercise dim
1676         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst)), [3, 5, 7])
1677         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, -1)), [3, 5, 7])
1678         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, 0)), [3, 5, 7])
1679         self.assertEqual(doreduce((2,1), lambda dst: cv.Reduce(srcmat, dst, 1)), [3, 12])
1680
1681         # exercise op
1682         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_SUM)), [3, 5, 7])
1683         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_AVG)), [1.5, 2.5, 3.5])
1684         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_MAX)), [3, 4, 5])
1685         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_MIN)), [0, 1, 2])
1686
1687         # exercise both dim and op
1688         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, 0, cv.CV_REDUCE_MAX)), [3, 4, 5])
1689         self.assertEqual(doreduce((2,1), lambda dst: cv.Reduce(srcmat, dst, 1, cv.CV_REDUCE_MAX)), [2, 5])
1690
1691     def test_operations(self):
1692         class Im:
1693
1694             def __init__(self, data = None):
1695                 self.m = cv.CreateMat(1, 32, cv.CV_32FC1)
1696                 if data:
1697                     cv.SetData(self.m, array.array('f', data), 128)
1698
1699             def __add__(self, other):
1700                 r = Im()
1701                 if isinstance(other, Im):
1702                     cv.Add(self.m, other.m, r.m)
1703                 else:
1704                     cv.AddS(self.m, (other,), r.m)
1705                 return r
1706
1707             def __sub__(self, other):
1708                 r = Im()
1709                 if isinstance(other, Im):
1710                     cv.Sub(self.m, other.m, r.m)
1711                 else:
1712                     cv.SubS(self.m, (other,), r.m)
1713                 return r
1714
1715             def __rsub__(self, other):
1716                 r = Im()
1717                 cv.SubRS(self.m, (other,), r.m)
1718                 return r
1719
1720             def __mul__(self, other):
1721                 r = Im()
1722                 if isinstance(other, Im):
1723                     cv.Mul(self.m, other.m, r.m)
1724                 else:
1725                     cv.ConvertScale(self.m, r.m, other)
1726                 return r
1727
1728             def __rmul__(self, other):
1729                 r = Im()
1730                 cv.ConvertScale(self.m, r.m, other)
1731                 return r
1732
1733             def __div__(self, other):
1734                 r = Im()
1735                 if isinstance(other, Im):
1736                     cv.Div(self.m, other.m, r.m)
1737                 else:
1738                     cv.ConvertScale(self.m, r.m, 1.0 / other)
1739                 return r
1740
1741             def __pow__(self, other):
1742                 r = Im()
1743                 cv.Pow(self.m, r.m, other)
1744                 return r
1745
1746             def __abs__(self):
1747                 r = Im()
1748                 cv.Abs(self.m, r.m)
1749                 return r
1750
1751             def __getitem__(self, i):
1752                 return self.m[0,i]
1753
1754         def verify(op):
1755             r = op(a, b)
1756             for i in range(32):
1757                 expected = op(a[i], b[i])
1758                 self.assertAlmostEqual(expected, r[i], 4)
1759
1760         a = Im([random.randrange(1, 256) for i in range(32)])
1761         b = Im([random.randrange(1, 256) for i in range(32)])
1762
1763         # simple operations first
1764         verify(lambda x, y: x + y)
1765         verify(lambda x, y: x + 3)
1766         verify(lambda x, y: x + 0)
1767         verify(lambda x, y: x + -8)
1768
1769         verify(lambda x, y: x - y)
1770         verify(lambda x, y: x - 1)
1771         verify(lambda x, y: 1 - x)
1772
1773         verify(lambda x, y: abs(x))
1774
1775         verify(lambda x, y: x * y)
1776         verify(lambda x, y: x * 3)
1777
1778         verify(lambda x, y: x / y)
1779         verify(lambda x, y: x / 2)
1780
1781         for p in [-2, -1, -0.5, -0.1, 0, 0.1, 0.5, 1, 2 ]:
1782             verify(lambda x, y: (x ** p) + (y ** p))
1783
1784         # Combinations...
1785         verify(lambda x, y: x - 4 * abs(y))
1786         verify(lambda x, y: abs(y) / x)
1787
1788         # a polynomial
1789         verify(lambda x, y: 2 * x + 3 * (y ** 0.5))
1790
1791     def temp_test(self):
1792         cv.temp_test()
1793
1794     def failing_test_rand_GetStarKeypoints(self):
1795         # GetStarKeypoints [<cvmat(type=4242400d rows=64 cols=64 step=512 )>, <cv.cvmemstorage object at 0xb7cc40d0>, (45, 0.73705234376883488, 0.64282591451367344, 0.1567738743689836, 3)]
1796         print cv.CV_MAT_CN(0x4242400d)
1797         mat = cv.CreateMat( 64, 64, cv.CV_32FC2)
1798         cv.GetStarKeypoints(mat, cv.CreateMemStorage(), (45, 0.73705234376883488, 0.64282591451367344, 0.1567738743689836, 3))
1799         print mat
1800
1801     def test_rand_PutText(self):
1802         """ Test for bug 2829336 """
1803         mat = cv.CreateMat( 64, 64, cv.CV_8UC1)
1804         font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1)
1805         cv.PutText(mat, chr(127), (20, 20), font, 255)
1806
1807     def failing_test_rand_FindNearestPoint2D(self):
1808         subdiv = cv.CreateSubdivDelaunay2D((0,0,100,100), cv.CreateMemStorage())
1809         cv.SubdivDelaunay2DInsert( subdiv, (50, 50))
1810         cv.CalcSubdivVoronoi2D(subdiv)
1811         print
1812         for e in subdiv.edges:
1813             print e,
1814             print "  ", cv.Subdiv2DEdgeOrg(e)
1815             print "  ", cv.Subdiv2DEdgeOrg(cv.Subdiv2DRotateEdge(e, 1)), cv.Subdiv2DEdgeDst(cv.Subdiv2DRotateEdge(e, 1))
1816         print "nearest", cv.FindNearestPoint2D(subdiv, (1.0, 1.0))
1817
1818 class NewTests(OpenCVTests):
1819
1820     pass
1821
1822 if __name__ == '__main__':
1823     random.seed(0)
1824     optlist, args = getopt.getopt(sys.argv[1:], 'l:r')
1825     loops = 1
1826     shuffle = 0
1827     for o,a in optlist:
1828         if o == '-l':
1829             loops = int(a)
1830         if o == '-r':
1831             shuffle = 1
1832
1833     cases = [PreliminaryTests, FunctionTests, AreaTests]
1834     everything = [(tc, t) for tc in cases for t in unittest.TestLoader().getTestCaseNames(tc) ]
1835     if len(args) == 0:
1836         # cases = [NewTests]
1837         args = everything
1838     else:
1839         args = [(tc, t) for (tc, t) in everything if t in args]
1840
1841     suite = unittest.TestSuite()
1842     for l in range(loops):
1843         if shuffle:
1844             random.shuffle(args)
1845         for tc,t in args:
1846             suite.addTest(tc(t))
1847     unittest.TextTestRunner(verbosity=2).run(suite)