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         if 1:
 472             original = cv.CreateImage((800,800), 8, 1)
 473             cv.SetZero(original)
 474             cv.Circle(original, (400, 400), 200, 255, -1)
 475             cv.Circle(original, (100, 100), 20, 255, -1)
 476         else:
 477             original = self.get_sample("samples/c/lena.jpg", 0)
 478             cv.Threshold(original, original, 128, 255, cv.CV_THRESH_BINARY);
 479
 480         contours = cv.FindContours(original, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)
 481
 482
 483         def contour_iterator(contour):
 484             while contour:
 485                 yield contour
 486                 contour = contour.h_next()
 487
 488         # Should be 2 contours from the two circles above
 489         self.assertEqual(len(list(contour_iterator(contours))), 2)
 490
 491         # Smoke DrawContours
 492         sketch = cv.CreateImage(cv.GetSize(original), 8, 3)
 493         cv.SetZero(sketch)
 494         red = cv.RGB(255, 0, 0)
 495         green = cv.RGB(0, 255, 0)
 496         for c in contour_iterator(contours):
 497             cv.DrawContours(sketch, c, red, green, 0)
 498         # self.snap(sketch)
 499
 500     def test_GetAffineTransform(self):
 501         mapping = cv.CreateMat(2, 3, cv.CV_32FC1)
 502         cv.GetAffineTransform([ (0,0), (1,0), (0,1) ], [ (0,0), (17,0), (0,17) ], mapping)
 503         self.assertAlmostEqual(mapping[0,0], 17, 2)
 504         self.assertAlmostEqual(mapping[1,1], 17, 2)
 505
 506     def test_GetRotationMatrix2D(self):
 507         mapping = cv.CreateMat(2, 3, cv.CV_32FC1)
 508         for scale in [0.0, 1.0, 2.0]:
 509             for angle in [0.0, 360.0]:
 510                 cv.GetRotationMatrix2D((0,0), angle, scale, mapping)
 511                 for r in [0, 1]:
 512                     for c in [0, 1, 2]:
 513                         if r == c:
 514                             e = scale
 515                         else:
 516                             e = 0.0
 517                         self.assertAlmostEqual(mapping[r, c], e, 2)
 518
 519     def test_GetSize(self):
 520         self.assert_(cv.GetSize(cv.CreateMat(5, 7, cv.CV_32FC1)) == (7,5))
 521         self.assert_(cv.GetSize(cv.CreateImage((7,5), cv.IPL_DEPTH_8U, 1)) == (7,5))
 522
 523     def test_GetStarKeypoints(self):
 524         src = self.get_sample("samples/c/lena.jpg", 0)
 525         storage = cv.CreateMemStorage()
 526         kp = cv.GetStarKeypoints(src, storage)
 527         self.assert_(len(kp) > 0)
 528         for (x,y),scale,r in kp:
 529             self.assert_(0 <= x)
 530             self.assert_(x <= cv.GetSize(src)[0])
 531             self.assert_(0 <= y)
 532             self.assert_(y <= cv.GetSize(src)[1])
 533         return
 534         scribble = cv.CreateImage(cv.GetSize(src), 8, 3)
 535         cv.CvtColor(src, scribble, cv.CV_GRAY2BGR)
 536         for (x,y),scale,r in kp:
 537             print x,y,scale,r
 538             cv.Circle(scribble, (x,y), scale, cv.RGB(255,0,0))
 539         self.snap(scribble)
 540
 541     def test_GetSubRect(self):
 542         src = cv.CreateImage((100,100), 8, 1)
 543         data = "z" * (100 * 100)
 544
 545         cv.SetData(src, data, 100)
 546         start_count = sys.getrefcount(data)
 547
 548         iter = 77
 549         subs = []
 550         for i in range(iter):
 551             sub = cv.GetSubRect(src, (0, 0, 10, 10))
 552             subs.append(sub)
 553         self.assert_(sys.getrefcount(data) == (start_count + iter))
 554
 555         src = self.get_sample("samples/c/lena.jpg", 0)
 556         made = cv.CreateImage(cv.GetSize(src), 8, 1)
 557         sub = cv.CreateMat(32, 32, cv.CV_8UC1)
 558         for x in range(0, 512, 32):
 559             for y in range(0, 512, 32):
 560                 sub = cv.GetSubRect(src, (x, y, 32, 32))
 561                 cv.SetImageROI(made, (x, y, 32, 32))
 562                 cv.Copy(sub, made)
 563         cv.ResetImageROI(made)
 564         cv.AbsDiff(made, src, made)
 565         self.assert_(cv.CountNonZero(made) == 0)
 566
 567     def test_HoughLines2_PROBABILISTIC(self):
 568         li = cv.HoughLines2(self.yield_line_image(),
 569                                                 cv.CreateMemStorage(),
 570                                                 cv.CV_HOUGH_PROBABILISTIC,
 571                                                 1,
 572                                                 math.pi/180,
 573                                                 50,
 574                                                 50,
 575                                                 10)
 576         self.assert_(len(li) > 0)
 577         self.assert_(li[0] != None)
 578
 579     def test_HoughLines2_STANDARD(self):
 580         li = cv.HoughLines2(self.yield_line_image(),
 581                                                 cv.CreateMemStorage(),
 582                                                 cv.CV_HOUGH_STANDARD,
 583                                                 1,
 584                                                 math.pi/180,
 585                                                 100,
 586                                                 0,
 587                                                 0)
 588         self.assert_(len(li) > 0)
 589         self.assert_(li[0] != None)
 590
 591     def test_InPaint(self):
 592         src = self.get_sample("doc/pics/building.jpg")
 593         msk = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
 594         damaged = cv.CloneMat(src)
 595         repaired = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 3)
 596         difference = cv.CloneImage(repaired)
 597         cv.SetZero(msk)
 598         for method in [ cv.CV_INPAINT_NS, cv.CV_INPAINT_TELEA ]:
 599             for (p0,p1) in [ ((10,10), (400,400)) ]:
 600                 cv.Line(damaged, p0, p1, cv.RGB(255, 0, 255), 2)
 601                 cv.Line(msk, p0, p1, 255, 2)
 602             cv.Inpaint(damaged, msk, repaired, 10., cv.CV_INPAINT_NS)
 603         cv.AbsDiff(src, repaired, difference)
 604         #self.snapL([src, damaged, repaired, difference])
 605
 606     def test_InitLineIterator(self):
 607         scribble = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 1)
 608         self.assert_(len(list(cv.InitLineIterator(scribble, (20,10), (30,10)))) == 11)
 609
 610     def test_InRange(self):
 611
 612         sz = (256,256)
 613         Igray1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 614         Ilow1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 615         Ihi1 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 616         Igray2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 617         Ilow2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 618         Ihi2 = cv.CreateImage(sz,cv.IPL_DEPTH_32F,1)
 619
 620         Imask = cv.CreateImage(sz, cv.IPL_DEPTH_8U,1)
 621         Imaskt = cv.CreateImage(sz,cv.IPL_DEPTH_8U,1)
 622
 623         cv.InRange(Igray1, Ilow1, Ihi1, Imask);
 624         cv.InRange(Igray2, Ilow2, Ihi2, Imaskt);
 625
 626         cv.Or(Imask, Imaskt, Imask);
 627
 628     def test_Line(self):
 629         w,h = 640,480
 630         img = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 1)
 631         cv.SetZero(img)
 632         tricky = [ -8000, -2, -1, 0, 1, h/2, h-1, h, h+1, w/2, w-1, w, w+1, 8000]
 633         for x0 in tricky:
 634             for y0 in tricky:
 635                 for x1 in tricky:
 636                     for y1 in tricky:
 637                         for thickness in [ 0, 1, 8 ]:
 638                             for line_type in [0, 4, 8, cv.CV_AA ]:
 639                                 cv.Line(img, (x0,y0), (x1,y1), 255, thickness, line_type)
 640         # just check that something was drawn
 641         self.assert_(cv.Sum(img)[0] > 0)
 642
 643     def test_MinMaxLoc(self):
 644         scribble = cv.CreateImage((640,480), cv.IPL_DEPTH_8U, 1)
 645         los = [ (random.randrange(480), random.randrange(640)) for i in range(100) ]
 646         his = [ (random.randrange(480), random.randrange(640)) for i in range(100) ]
 647         for (lo,hi) in zip(los,his):
 648             cv.Set(scribble, 128)
 649             scribble[lo] = 0
 650             scribble[hi] = 255
 651             r = cv.MinMaxLoc(scribble)
 652             self.assert_(r == (0, 255, tuple(reversed(lo)), tuple(reversed(hi))))
 653
 654     def test_Reshape(self):
 655         # 97 rows
 656         # 12 cols
 657         rows = 97
 658         cols = 12
 659         im = cv.CreateMat( rows, cols, cv.CV_32FC1 )
 660         elems = rows * cols * 1
 661         def crd(im):
 662             return cv.GetSize(im) + (cv.CV_MAT_CN(cv.GetElemType(im)),)
 663
 664         for c in (1, 2, 3, 4):
 665             nc,nr,nd = crd(cv.Reshape(im, c))
 666             self.assert_(nd == c)
 667             self.assert_((nc * nr * nd) == elems)
 668
 669         nc,nr,nd = crd(cv.Reshape(im, 0, 97*2))
 670         self.assert_(nr == 97*2)
 671         self.assert_((nc * nr * nd) == elems)
 672
 673         nc,nr,nd = crd(cv.Reshape(im, 3, 97*2))
 674         self.assert_(nr == 97*2)
 675         self.assert_(nd == 3)
 676         self.assert_((nc * nr * nd) == elems)
 677
 678         return # XXX - blocked by fixes for #166, #150
 679
 680         # Now test ReshapeMatND
 681         mat = cv.CreateMatND([2, 2, 2], cv.CV_32F)
 682         print cv.ReshapeMatND(mat, 0, []);
 683
 684     def test_Save(self):
 685         for o in [ cv.CreateImage((128,128), cv.IPL_DEPTH_8U, 1), cv.CreateMat(16, 16, cv.CV_32FC1) ]:
 686             cv.Save("test.save", o)
 687             loaded = cv.Load("test.save", cv.CreateMemStorage())
 688             self.assert_(type(o) == type(loaded))
 689
 690     def test_SetIdentity(self):
 691         for r in range(1,16):
 692             for c in range(1, 16):
 693                 for t in self.mat_types_single:
 694                     M = cv.CreateMat(r, c, t)
 695                     cv.SetIdentity(M)
 696                     for rj in range(r):
 697                         for cj in range(c):
 698                             if rj == cj:
 699                                 expected = 1.0
 700                             else:
 701                                 expected = 0.0
 702                             self.assertEqual(M[rj,cj], expected)
 703
 704     def test_Sum(self):
 705         for r in range(1,11):
 706             for c in range(1, 11):
 707                 for t in self.mat_types_single:
 708                     M = cv.CreateMat(r, c, t)
 709                     cv.Set(M, 1)
 710                     self.assertEqual(cv.Sum(M)[0], r * c)
 711
 712     def test_Threshold(self):
 713         """ directed test for bug 2790622 """
 714         src = self.get_sample("samples/c/lena.jpg", 0)
 715         results = set()
 716         for i in range(10):
 717             dst = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
 718             cv.Threshold(src, dst, 128, 128, cv.CV_THRESH_BINARY)
 719             results.add(dst.tostring())
 720         # Should have produced the same answer every time, so results set should have size 1
 721         self.assert_(len(results) == 1)
 722
 723         # ticket #71 repro attempt
 724         image = self.get_sample("samples/c/lena.jpg", 0)
 725         red = cv.CreateImage(cv.GetSize(image), 8, 1)
 726         binary = cv.CreateImage(cv.GetSize(image), 8, 1)
 727         cv.Split(image, red, None, None, None)
 728         cv.Threshold(red, binary, 42, 255, cv.CV_THRESH_BINARY)
 729
 730     ##############################################################################
 731
 732     def yield_line_image(self):
 733         """ Needed by HoughLines tests """
 734         src = self.get_sample("doc/pics/building.jpg", 0)
 735         dst = cv.CreateImage(cv.GetSize(src), 8, 1)
 736         cv.Canny(src, dst, 50, 200, 3)
 737         return dst
 738
 739 # Tests for functional areas
 740
 741 class AreaTests(OpenCVTests):
 742
 743     def test_numpy(self):
 744         if 'fromarray' in dir(cv):
 745             import numpy
 746
 747             def convert(numpydims):
 748                 """ Create a numpy array with specified dims, return the OpenCV CvMat """
 749                 a1 = numpy.array([1] * reduce(operator.__mul__, numpydims)).reshape(*numpydims)
 750                 return cv.fromarray(a1)
 751             def row_col_chan(m):
 752                 (col, row) = cv.GetSize(m)
 753                 chan = cv.CV_MAT_CN(cv.GetElemType(m))
 754                 return (row, col, chan)
 755
 756             self.assertEqual(row_col_chan(convert((2, 13))), (2, 13, 1))
 757             self.assertEqual(row_col_chan(convert((2, 13, 4))), (2, 13, 4))
 758             self.assertEqual(row_col_chan(convert((2, 13, cv.CV_CN_MAX))), (2, 13, cv.CV_CN_MAX))
 759             self.assertRaises(TypeError, lambda: convert((2,)))
 760             self.assertRaises(TypeError, lambda: convert((11, 17, cv.CV_CN_MAX + 1)))
 761
 762             for t in [cv.CV_16UC1, cv.CV_32SC1, cv.CV_32FC1]:
 763                 for d in [ (8,), (1,7), (2,3,4), (7,9,2,1,8), (1,2,3,4,5,6,7,8) ]:
 764                     total = reduce(operator.__mul__, d)
 765                     m = cv.CreateMatND(d, t)
 766                     for i in range(total):
 767                         cv.Set1D(m, i, i)
 768                     na = numpy.asarray(m).reshape((total,))
 769                     self.assertEqual(list(na), range(total))
 770
 771                     # now do numpy -> cvmat, and verify
 772                     m2 = cv.fromarray(na, True)
 773
 774                     # Check that new cvmat m2 contains same counting sequence
 775                     for i in range(total):
 776                         self.assertEqual(cv.Get1D(m, i)[0], i)
 777
 778             # Verify round-trip for 2D arrays
 779             for rows in [2, 3, 7, 13]:
 780                 for cols in [2, 3, 7, 13]:
 781                     for allowND in [False, True]:
 782                         im = cv.CreateMatND([rows, cols], cv.CV_16UC1)
 783                         cv.SetZero(im)
 784                         a = numpy.asarray(im)
 785                         self.assertEqual(a.shape, (rows, cols))
 786                         cvmatnd = cv.fromarray(a, allowND)
 787                         self.assertEqual(cv.GetDims(cvmatnd), (rows, cols))
 788
 789                         # im, a and cvmatnd all point to the same data, so...
 790                         for i,coord in enumerate([(0,0), (0,1), (1,0), (1,1)]):
 791                             v = 5 + i + 7
 792                             a[coord] = v
 793                             self.assertEqual(im[coord], v)
 794                             self.assertEqual(cvmatnd[coord], v)
 795
 796             # Cv -> Numpy 3 channel check
 797             im = cv.CreateMatND([2, 13], cv.CV_16UC3)
 798             self.assertEqual(numpy.asarray(im).shape, (2, 13, 3))
 799
 800             # multi-dimensional NumPy array
 801             na = numpy.ones([7,9,2,1,8])
 802             cm = cv.fromarray(na, True)
 803             print cv.GetDims(cm)
 804
 805         else:
 806             print "SKIPPING test_numpy - numpy support not built"
 807
 808     def test_stereo(self):
 809         bm = cv.CreateStereoBMState()
 810         def illegal_delete():
 811             bm = cv.CreateStereoBMState()
 812             del bm.preFilterType
 813         def illegal_assign():
 814             bm = cv.CreateStereoBMState()
 815             bm.preFilterType = "foo"
 816
 817         self.assertRaises(TypeError, illegal_delete)
 818         self.assertRaises(TypeError, illegal_assign)
 819
 820         left = self.get_sample("samples/c/lena.jpg", 0)
 821         right = self.get_sample("samples/c/lena.jpg", 0)
 822         disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
 823         cv.FindStereoCorrespondenceBM(left, right, disparity, bm)
 824
 825         gc = cv.CreateStereoGCState(16, 2)
 826         left_disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
 827         right_disparity = cv.CreateMat(512, 512, cv.CV_16SC1)
 828         cv.FindStereoCorrespondenceGC(left, right, left_disparity, right_disparity, gc)
 829
 830     def test_kalman(self):
 831         k = cv.CreateKalman(2, 1, 0)
 832
 833     def failing_test_exception(self):
 834         a = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
 835         b = cv.CreateImage((640, 480), cv.IPL_DEPTH_8U, 1)
 836         self.assertRaises(cv.error, lambda: cv.Laplace(a, b))
 837
 838     def test_cvmat_accessors(self):
 839         cvm = cv.CreateMat(20, 10, cv.CV_32FC1)
 840
 841     def test_depths(self):
 842         """ Make sure that the depth enums are unique """
 843         self.assert_(len(self.depths) == len(set(self.depths)))
 844
 845     def test_leak(self):
 846         """ If CreateImage is not releasing image storage, then the loop below should use ~4GB of memory. """
 847         for i in range(4000):
 848             a = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
 849         for i in range(4000):
 850             a = cv.CreateMat(1024, 1024, cv.CV_8UC1)
 851
 852     def test_histograms(self):
 853         def split(im):
 854             nchans = cv.CV_MAT_CN(cv.GetElemType(im))
 855             c = [ cv.CreateImage(cv.GetSize(im), cv.IPL_DEPTH_8U, 1) for i in range(nchans) ] + [None] * (4 - nchans)
 856             cv.Split(im, c[0], c[1], c[2], c[3])
 857             return c[:nchans]
 858         def imh(im):
 859             s = split(im)
 860             hist = cv.CreateHist([256] * len(s), cv.CV_HIST_ARRAY, [ (0,255) ] * len(s), 1)
 861             cv.CalcHist(s, hist, 0)
 862             return hist
 863
 864         dims = [180]
 865         ranges = [(0,180)]
 866         a = cv.CreateHist(dims, cv.CV_HIST_ARRAY , ranges, 1)
 867         src = self.get_sample("samples/c/lena.jpg", 0)
 868         h = imh(src)
 869         (minv, maxv, minl, maxl) = cv.GetMinMaxHistValue(h)
 870         self.assert_(cv.QueryHistValue_nD(h, minl) == minv)
 871         self.assert_(cv.QueryHistValue_nD(h, maxl) == maxv)
 872         bp = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_8U, 1)
 873         cv.CalcBackProject(split(src), bp, h)
 874         bp = cv.CreateImage((cv.GetSize(src)[0]-2, cv.GetSize(src)[1]-2), cv.IPL_DEPTH_32F, 1)
 875         cv.CalcBackProjectPatch(split(src), bp, (3,3), h, cv.CV_COMP_INTERSECT, 1)
 876
 877         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)]:
 878             self.assertEqual(cv.CompareHist(h, h, meth), expected)
 879
 880     def test_arithmetic(self):
 881         a = cv.CreateMat(4, 4, cv.CV_8UC1)
 882         a[0,0] = 50.0
 883         b = cv.CreateMat(4, 4, cv.CV_8UC1)
 884         b[0,0] = 4.0
 885         d = cv.CreateMat(4, 4, cv.CV_8UC1)
 886         cv.Add(a, b, d)
 887         self.assertEqual(d[0,0], 54.0)
 888         cv.Mul(a, b, d)
 889         self.assertEqual(d[0,0], 200.0)
 890
 891
 892     def failing_test_cvtcolor(self):
 893         src3 = self.get_sample("samples/c/lena.jpg")
 894         src1 = self.get_sample("samples/c/lena.jpg", 0)
 895         dst8u = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_8U, c)) for c in (1,2,3,4)])
 896         dst16u = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_16U, c)) for c in (1,2,3,4)])
 897         dst32f = dict([(c,cv.CreateImage(cv.GetSize(src1), cv.IPL_DEPTH_32F, c)) for c in (1,2,3,4)])
 898
 899         for srcf in ["BGR", "RGB"]:
 900             for dstf in ["Luv"]:
 901                 cv.CvtColor(src3, dst8u[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
 902                 cv.CvtColor(src3, dst32f[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
 903                 cv.CvtColor(src3, dst8u[3], eval("cv.CV_%s2%s" % (dstf, srcf)))
 904
 905         for srcf in ["BayerBG", "BayerGB", "BayerGR"]:
 906             for dstf in ["RGB", "BGR"]:
 907                 cv.CvtColor(src1, dst8u[3], eval("cv.CV_%s2%s" % (srcf, dstf)))
 908
 909     def test_voronoi(self):
 910         w,h = 500,500
 911
 912         storage = cv.CreateMemStorage(0)
 913
 914         def facet_edges(e0):
 915             e = e0
 916             while True:
 917                 e = cv.Subdiv2DGetEdge(e, cv.CV_NEXT_AROUND_LEFT)
 918                 yield e
 919                 if e == e0:
 920                     break
 921
 922         def areas(edges):
 923             seen = []
 924             seensorted = []
 925             for edge in edges:
 926                 pts = [ cv.Subdiv2DEdgeOrg(e) for e in facet_edges(edge) ]
 927                 if not (None in pts):
 928                     l = [p.pt for p in pts]
 929                     ls = sorted(l)
 930                     if not(ls in seensorted):
 931                         seen.append(l)
 932                         seensorted.append(ls)
 933             return seen
 934
 935         for npoints in range(1, 200):
 936             points = [ (random.randrange(w), random.randrange(h)) for i in range(npoints) ]
 937             subdiv = cv.CreateSubdivDelaunay2D( (0,0,w,h), storage )
 938             for p in points:
 939                 cv.SubdivDelaunay2DInsert( subdiv, p)
 940             cv.CalcSubdivVoronoi2D(subdiv)
 941             ars = areas([ cv.Subdiv2DRotateEdge(e, 1) for e in subdiv.edges ] + [ cv.Subdiv2DRotateEdge(e, 3) for e in subdiv.edges ])
 942             self.assert_(len(ars) == len(set(points)))
 943
 944             if False:
 945                 img = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 3)
 946                 cv.SetZero(img)
 947                 def T(x): return int(x) # int(300+x/16)
 948                 for pts in ars:
 949                     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 );
 950                 for x,y in points:
 951                     cv.Circle(img, (T(x), T(y)), 3, cv.RGB(0,0,0), -1)
 952
 953                 cv.ShowImage("snap", img)
 954                 if cv.WaitKey(10) > 0:
 955                     break
 956
 957     def perf_test_pow(self):
 958         mt = cv.CreateMat(1000, 1000, cv.CV_32FC1)
 959         dst = cv.CreateMat(1000, 1000, cv.CV_32FC1)
 960         rng = cv.RNG(0)
 961         cv.RandArr(rng, mt, cv.CV_RAND_UNI, 0, 1000.0)
 962         mt[0,0] = 10
 963         print
 964         for a in [0.5, 2.0, 2.3, 2.4, 3.0, 37.1786] + [2.4]*10:
 965             started = time.time()
 966             for i in range(10):
 967                 cv.Pow(mt, dst, a)
 968             took = (time.time() - started) / 1e7
 969             print "%4.1f took %f ns" % (a, took * 1e9)
 970         print dst[0,0], 10 ** 2.4
 971
 972     def test_access_row_col(self):
 973         src = cv.CreateImage((8,3), 8, 1)
 974         # Put these words
 975         #     Achilles
 976         #     Benedict
 977         #     Congreve
 978         # in an array (3 rows, 8 columns).
 979         # Then extract the array in various ways.
 980
 981         for r,w in enumerate(("Achilles", "Benedict", "Congreve")):
 982             for c,v in enumerate(w):
 983                 src[r,c] = ord(v)
 984         self.assertEqual(src.tostring(), "AchillesBenedictCongreve")
 985         self.assertEqual(src[:,:].tostring(), "AchillesBenedictCongreve")
 986         self.assertEqual(src[:,:4].tostring(), "AchiBeneCong")
 987         self.assertEqual(src[:,0].tostring(), "ABC")
 988         self.assertEqual(src[:,4:].tostring(), "llesdictreve")
 989         self.assertEqual(src[::2,:].tostring(), "AchillesCongreve")
 990         self.assertEqual(src[1:,:].tostring(), "BenedictCongreve")
 991         self.assertEqual(src[1:2,:].tostring(), "Benedict")
 992         self.assertEqual(src[::2,:4].tostring(), "AchiCong")
 993         # The mats share the same storage, so updating one should update them all
 994         lastword = src[2]
 995         self.assertEqual(lastword.tostring(), "Congreve")
 996         src[2,0] = ord('K')
 997         self.assertEqual(lastword.tostring(), "Kongreve")
 998         src[2,0] = ord('C')
 999
1000         # ABCD
1001         # EFGH
1002         # IJKL
1003         #
1004         # MNOP
1005         # QRST
1006         # UVWX
1007
1008         mt = cv.CreateMatND([2,3,4], cv.CV_8UC1)
1009         for i in range(2):
1010             for j in range(3):
1011                 for k in range(4):
1012                     mt[i,j,k] = ord('A') + k + 4 * (j + 3 * i)
1013         self.assertEqual(mt[:,:,:1].tostring(), "AEIMQU")
1014         self.assertEqual(mt[:,:1,:].tostring(), "ABCDMNOP")
1015         self.assertEqual(mt[:1,:,:].tostring(), "ABCDEFGHIJKL")
1016         self.assertEqual(mt[1,1].tostring(), "QRST")
1017         self.assertEqual(mt[:,::2,:].tostring(), "ABCDIJKLMNOPUVWX")
1018
1019         # Exercise explicit GetRows
1020         self.assertEqual(cv.GetRows(src, 0, 3).tostring(), "AchillesBenedictCongreve")
1021         self.assertEqual(cv.GetRows(src, 0, 3, 1).tostring(), "AchillesBenedictCongreve")
1022         self.assertEqual(cv.GetRows(src, 0, 3, 2).tostring(), "AchillesCongreve")
1023
1024         self.assertEqual(cv.GetRow(src, 0).tostring(), "Achilles")
1025
1026         self.assertEqual(cv.GetCols(src, 0, 4).tostring(), "AchiBeneCong")
1027
1028         self.assertEqual(cv.GetCol(src, 0).tostring(), "ABC")
1029         self.assertEqual(cv.GetCol(src, 1).tostring(), "ceo")
1030
1031         self.assertEqual(cv.GetDiag(src, 0).tostring(), "Aen")
1032
1033         # Check that matrix type is preserved by the various operators
1034
1035         for mt in self.mat_types:
1036             m = cv.CreateMat(5, 3, mt)
1037             self.assertEqual(mt, cv.GetElemType(cv.GetRows(m, 0, 2)))
1038             self.assertEqual(mt, cv.GetElemType(cv.GetRow(m, 0)))
1039             self.assertEqual(mt, cv.GetElemType(cv.GetCols(m, 0, 2)))
1040             self.assertEqual(mt, cv.GetElemType(cv.GetCol(m, 0)))
1041             self.assertEqual(mt, cv.GetElemType(cv.GetDiag(m, 0)))
1042             self.assertEqual(mt, cv.GetElemType(m[0]))
1043             self.assertEqual(mt, cv.GetElemType(m[::2]))
1044             self.assertEqual(mt, cv.GetElemType(m[:,0]))
1045             self.assertEqual(mt, cv.GetElemType(m[:,:]))
1046             self.assertEqual(mt, cv.GetElemType(m[::2,:]))
1047
1048     def test_addS_3D(self):
1049         for dim in [ [1,1,4], [2,2,3], [7,4,3] ]:
1050             for ty,ac in [ (cv.CV_32FC1, 'f'), (cv.CV_64FC1, 'd')]:
1051                 mat = cv.CreateMatND(dim, ty)
1052                 mat2 = cv.CreateMatND(dim, ty)
1053                 for increment in [ 0, 3, -1 ]:
1054                     cv.SetData(mat, array.array(ac, range(dim[0] * dim[1] * dim[2])), 0)
1055                     cv.AddS(mat, increment, mat2)
1056                     for i in range(dim[0]):
1057                         for j in range(dim[1]):
1058                             for k in range(dim[2]):
1059                                 self.assert_(mat2[i,j,k] == mat[i,j,k] + increment)
1060
1061     def test_buffers(self):
1062         ar = array.array('f', [7] * (360*640))
1063
1064         m = cv.CreateMat(360, 640, cv.CV_32FC1)
1065         cv.SetData(m, ar, 4 * 640)
1066         self.assert_(m[0,0] == 7.0)
1067
1068         m = cv.CreateMatND((360, 640), cv.CV_32FC1)
1069         cv.SetData(m, ar, 4 * 640)
1070         self.assert_(m[0,0] == 7.0)
1071
1072         m = cv.CreateImage((640, 360), cv.IPL_DEPTH_32F, 1)
1073         cv.SetData(m, ar, 4 * 640)
1074         self.assert_(m[0,0] == 7.0)
1075
1076     def xxtest_Filters(self):
1077         print
1078         m = cv.CreateMat(360, 640, cv.CV_32FC1)
1079         d = cv.CreateMat(360, 640, cv.CV_32FC1)
1080         for k in range(3, 21, 2):
1081             started = time.time()
1082             for i in range(1000):
1083                 cv.Smooth(m, m, param1=k)
1084             print k, "took", time.time() - started
1085
1086     def assertSame(self, a, b):
1087         w,h = cv.GetSize(a)
1088         d = cv.CreateMat(h, w, cv.CV_8UC1)
1089         cv.AbsDiff(a, b, d)
1090         self.assert_(cv.CountNonZero(d) == 0)
1091
1092     def test_text(self):
1093         img = cv.CreateImage((640,40), cv.IPL_DEPTH_8U, 1)
1094         cv.SetZero(img)
1095         font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1)
1096         message = "XgfooX"
1097         cv.PutText(img, message, (320,30), font, 255)
1098         ((w,h),bl) = cv.GetTextSize(message, font)
1099
1100         # Find nonzero in X and Y
1101         Xs = []
1102         for x in range(640):
1103             cv.SetImageROI(img, (x, 0, 1, 40))
1104             Xs.append(cv.Sum(img)[0] > 0)
1105         def firstlast(l):
1106             return (l.index(True), len(l) - list(reversed(l)).index(True))
1107
1108         Ys = []
1109         for y in range(40):
1110             cv.SetImageROI(img, (0, y, 640, 1))
1111             Ys.append(cv.Sum(img)[0] > 0)
1112
1113         x0,x1 = firstlast(Xs)
1114         y0,y1 = firstlast(Ys)
1115         actual_width = x1 - x0
1116         actual_height = y1 - y0
1117
1118         # actual_width can be up to 8 pixels smaller than GetTextSize says
1119         self.assert_(actual_width <= w)
1120         self.assert_((w - actual_width) <= 8)
1121
1122         # actual_height can be up to 4 pixels smaller than GetTextSize says
1123         self.assert_(actual_height <= (h + bl))
1124         self.assert_(((h + bl) - actual_height) <= 4)
1125
1126         cv.ResetImageROI(img)
1127         self.assert_(w != 0)
1128         self.assert_(h != 0)
1129
1130     def test_sizes(self):
1131         sizes = [ 1, 2, 3, 97, 255, 256, 257, 947 ]
1132         for w in sizes:
1133             for h in sizes:
1134                 # Create an IplImage
1135                 im = cv.CreateImage((w,h), cv.IPL_DEPTH_8U, 1)
1136                 cv.Set(im, 1)
1137                 self.assert_(cv.Sum(im)[0] == (w * h))
1138                 del im
1139                 # Create a CvMat
1140                 mt = cv.CreateMat(h, w, cv.CV_8UC1)
1141                 cv.Set(mt, 1)
1142                 self.assert_(cv.Sum(mt)[0] == (w * h))
1143
1144         random.seed(7)
1145         for dim in range(1, cv.CV_MAX_DIM + 1):
1146             for attempt in range(10):
1147                 dims = [ random.choice([1,1,1,1,2,3]) for i in range(dim) ]
1148                 mt = cv.CreateMatND(dims, cv.CV_8UC1)
1149                 cv.SetZero(mt)
1150                 self.assert_(cv.Sum(mt)[0] == 0)
1151                 # Set to all-ones, verify the sum
1152                 cv.Set(mt, 1)
1153                 expected = 1
1154                 for d in dims:
1155                     expected *= d
1156                 self.assert_(cv.Sum(mt)[0] == expected)
1157
1158     def test_random(self):
1159         seeds = [ 0, 1, 2**48, 2**48 + 1 ]
1160         sequences = set()
1161         for s in seeds:
1162             rng = cv.RNG(s)
1163             sequences.add(str([cv.RandInt(rng) for i in range(10)]))
1164         self.assert_(len(seeds) == len(sequences))
1165
1166         rng = cv.RNG(0)
1167         im = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
1168         cv.RandArr(rng, im, cv.CV_RAND_UNI, 0, 256)
1169         cv.RandArr(rng, im, cv.CV_RAND_NORMAL, 128, 30)
1170         if 1:
1171             hist = cv.CreateHist([ 256 ], cv.CV_HIST_ARRAY, [ (0,255) ], 1)
1172             cv.CalcHist([im], hist)
1173
1174         rng = cv.RNG()
1175         for i in range(1000):
1176             v = cv.RandReal(rng)
1177             self.assert_(0 <= v)
1178             self.assert_(v < 1)
1179
1180         for mode in [ cv.CV_RAND_UNI, cv.CV_RAND_NORMAL ]:
1181             for fmt in self.mat_types:
1182                 mat = cv.CreateMat(64, 64, fmt)
1183                 cv.RandArr(cv.RNG(), mat, mode, (0,0,0,0), (1,1,1,1))
1184
1185     def test_MixChannels(self):
1186
1187         # First part - test the single case described in the documentation
1188         rgba = cv.CreateMat(100, 100, cv.CV_8UC4)
1189         bgr = cv.CreateMat(100, 100, cv.CV_8UC3)
1190         alpha = cv.CreateMat(100, 100, cv.CV_8UC1)
1191         cv.Set(rgba, (1,2,3,4))
1192         cv.MixChannels([rgba], [bgr, alpha], [
1193            (0, 2),    # rgba[0] -> bgr[2]
1194            (1, 1),    # rgba[1] -> bgr[1]
1195            (2, 0),    # rgba[2] -> bgr[0]
1196            (3, 3)     # rgba[3] -> alpha[0]
1197         ])
1198         self.assert_(bgr[0,0] == (3,2,1))
1199         self.assert_(alpha[0,0] == 4)
1200
1201         # Second part.  Choose random sets of sources and destinations,
1202         # fill them with known values, choose random channel assignments,
1203         # run cvMixChannels and check that the result is as expected.
1204
1205         random.seed(1)
1206
1207         for rows in [1,2,4,13,64,1000]:
1208             for cols in [1,2,4,13,64,1000]:
1209                 for loop in range(5):
1210                     sources = [random.choice([1, 2, 3, 4]) for i in range(8)]
1211                     dests = [random.choice([1, 2, 3, 4]) for i in range(8)]
1212                     # make sure that fromTo does not have duplicates in dests, otherwise the result is not determined
1213                     while 1:
1214                         fromTo = [(random.randrange(-1, sum(sources)), random.randrange(sum(dests))) for i in range(random.randrange(1, 30))]
1215                         dests_set = list(set([j for (i, j) in fromTo]))
1216                         if len(dests_set) == len(dests):
1217                             break
1218
1219                     # print sources
1220                     # print dests
1221                     # print fromTo
1222
1223                     def CV_8UC(n):
1224                         return [cv.CV_8UC1, cv.CV_8UC2, cv.CV_8UC3, cv.CV_8UC4][n-1]
1225                     source_m = [cv.CreateMat(rows, cols, CV_8UC(c)) for c in sources]
1226                     dest_m =   [cv.CreateMat(rows, cols, CV_8UC(c)) for c in dests]
1227
1228                     def m00(m):
1229                         # return the contents of the N channel mat m[0,0] as a N-length list
1230                         chans = cv.CV_MAT_CN(cv.GetElemType(m))
1231                         if chans == 1:
1232                             return [m[0,0]]
1233                         else:
1234                             return list(m[0,0])[:chans]
1235
1236                     # Sources numbered from 50, destinations numbered from 100
1237
1238                     for i in range(len(sources)):
1239                         s = sum(sources[:i]) + 50
1240                         cv.Set(source_m[i], (s, s+1, s+2, s+3))
1241                         self.assertEqual(m00(source_m[i]), [s, s+1, s+2, s+3][:sources[i]])
1242
1243                     for i in range(len(dests)):
1244                         s = sum(dests[:i]) + 100
1245                         cv.Set(dest_m[i], (s, s+1, s+2, s+3))
1246                         self.assertEqual(m00(dest_m[i]), [s, s+1, s+2, s+3][:dests[i]])
1247
1248                     # now run the sanity check
1249
1250                     for i in range(len(sources)):
1251                         s = sum(sources[:i]) + 50
1252                         self.assertEqual(m00(source_m[i]), [s, s+1, s+2, s+3][:sources[i]])
1253
1254                     for i in range(len(dests)):
1255                         s = sum(dests[:i]) + 100
1256                         self.assertEqual(m00(dest_m[i]), [s, s+1, s+2, s+3][:dests[i]])
1257
1258                     cv.MixChannels(source_m, dest_m, fromTo)
1259
1260                     expected = range(100, 100 + sum(dests))
1261                     for (i, j) in fromTo:
1262                         if i == -1:
1263                             expected[j] = 0.0
1264                         else:
1265                             expected[j] = 50 + i
1266
1267                     actual = sum([m00(m) for m in dest_m], [])
1268                     self.assertEqual(sum([m00(m) for m in dest_m], []), expected)
1269
1270     def test_allocs(self):
1271         mats = [ 0 for i in range(20) ]
1272         for i in range(1000):
1273             m = cv.CreateMat(random.randrange(10, 512), random.randrange(10, 512), cv.CV_8UC1)
1274             j = random.randrange(len(mats))
1275             mats[j] = m
1276             cv.SetZero(m)
1277
1278     def test_access(self):
1279         cnames = { 1:cv.CV_32FC1, 2:cv.CV_32FC2, 3:cv.CV_32FC3, 4:cv.CV_32FC4 }
1280
1281         for w in range(1,11):
1282             for h in range(2,11):
1283                 for c in [1,2]:
1284                     for o in [ cv.CreateMat(h, w, cnames[c]), cv.CreateImage((w,h), cv.IPL_DEPTH_32F, c) ][1:]:
1285                         pattern = [ (i,j) for i in range(w) for j in range(h) ]
1286                         random.shuffle(pattern)
1287                         for k,(i,j) in enumerate(pattern):
1288                             if c == 1:
1289                                 o[j,i] = k
1290                             else:
1291                                 o[j,i] = (k,) * c
1292                         for k,(i,j) in enumerate(pattern):
1293                             if c == 1:
1294                                 self.assert_(o[j,i] == k)
1295                             else:
1296                                 self.assert_(o[j,i] == (k,)*c)
1297
1298         test_mat = cv.CreateMat(2, 3, cv.CV_32FC1)
1299         cv.SetData(test_mat, array.array('f', range(6)), 12)
1300         self.assertEqual(cv.GetDims(test_mat[0]), (1, 3))
1301         self.assertEqual(cv.GetDims(test_mat[1]), (1, 3))
1302         self.assertEqual(cv.GetDims(test_mat[0:1]), (1, 3))
1303         self.assertEqual(cv.GetDims(test_mat[1:2]), (1, 3))
1304         self.assertEqual(cv.GetDims(test_mat[-1:]), (1, 3))
1305         self.assertEqual(cv.GetDims(test_mat[-1]), (1, 3))
1306
1307     def xxxtest_corners(self):
1308         a = cv.LoadImage("foo-mono.png", 0)
1309         cv.AdaptiveThreshold(a, a, 255, param1=5)
1310         scribble = cv.CreateImage(cv.GetSize(a), 8, 3)
1311         cv.CvtColor(a, scribble, cv.CV_GRAY2BGR)
1312         if 0:
1313             eig_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
1314             temp_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
1315             pts = cv.GoodFeaturesToTrack(a, eig_image, temp_image, 100, 0.04, 2, use_harris=1)
1316             for p in pts:
1317                 cv.Circle( scribble, p, 1, cv.RGB(255,0,0), -1 )
1318             self.snap(scribble)
1319         canny = cv.CreateImage(cv.GetSize(a), 8, 1)
1320         cv.SubRS(a, 255, canny)
1321         self.snap(canny)
1322         li = cv.HoughLines2(canny,
1323                                                 cv.CreateMemStorage(),
1324                                                 cv.CV_HOUGH_STANDARD,
1325                                                 1,
1326                                                 math.pi/180,
1327                                                 60,
1328                                                 0,
1329                                                 0)
1330         for (rho,theta) in li:
1331             print rho,theta
1332             c = math.cos(theta)
1333             s = math.sin(theta)
1334             x0 = c*rho
1335             y0 = s*rho
1336             cv.Line(scribble,
1337                             (x0 + 1000*(-s), y0 + 1000*c),
1338                             (x0 + -1000*(-s), y0 - 1000*c),
1339                             (0,255,0))
1340         self.snap(scribble)
1341
1342     def test_calibration(self):
1343
1344         def get_corners(mono, refine = False):
1345             (ok, corners) = cv.FindChessboardCorners(mono, (num_x_ints, num_y_ints), cv.CV_CALIB_CB_ADAPTIVE_THRESH | cv.CV_CALIB_CB_NORMALIZE_IMAGE)
1346             if refine and ok:
1347                 corners = cv.FindCornerSubPix(mono, corners, (5,5), (-1,-1), ( cv.CV_TERMCRIT_EPS+cv.CV_TERMCRIT_ITER, 30, 0.1 ))
1348             return (ok, corners)
1349
1350         def mk_object_points(nimages, squaresize = 1):
1351             opts = cv.CreateMat(nimages * num_pts, 3, cv.CV_32FC1)
1352             for i in range(nimages):
1353                 for j in range(num_pts):
1354                     opts[i * num_pts + j, 0] = (j / num_x_ints) * squaresize
1355                     opts[i * num_pts + j, 1] = (j % num_x_ints) * squaresize
1356                     opts[i * num_pts + j, 2] = 0
1357             return opts
1358
1359         def mk_image_points(goodcorners):
1360             ipts = cv.CreateMat(len(goodcorners) * num_pts, 2, cv.CV_32FC1)
1361             for (i, co) in enumerate(goodcorners):
1362                 for j in range(num_pts):
1363                     ipts[i * num_pts + j, 0] = co[j][0]
1364                     ipts[i * num_pts + j, 1] = co[j][1]
1365             return ipts
1366
1367         def mk_point_counts(nimages):
1368             npts = cv.CreateMat(nimages, 1, cv.CV_32SC1)
1369             for i in range(nimages):
1370                 npts[i, 0] = num_pts
1371             return npts
1372
1373         def cvmat_iterator(cvmat):
1374             for i in range(cvmat.rows):
1375                 for j in range(cvmat.cols):
1376                     yield cvmat[i,j]
1377
1378         def image_from_archive(tar, name):
1379             member = tar.getmember(name)
1380             filedata = tar.extractfile(member).read()
1381             imagefiledata = cv.CreateMat(1, len(filedata), cv.CV_8UC1)
1382             cv.SetData(imagefiledata, filedata, len(filedata))
1383             return cv.DecodeImageM(imagefiledata)
1384
1385         urllib.urlretrieve("http://pr.willowgarage.com/data/camera_calibration/camera_calibration.tar.gz", "camera_calibration.tar.gz")
1386         tf = tarfile.open("camera_calibration.tar.gz")
1387
1388         num_x_ints = 8
1389         num_y_ints = 6
1390         num_pts = num_x_ints * num_y_ints
1391
1392         leftimages = [image_from_archive(tf, "wide/left%04d.pgm" % i) for i in range(3, 15)]
1393         size = cv.GetSize(leftimages[0])
1394
1395         # Monocular test
1396
1397         if True:
1398             corners = [get_corners(i) for i in leftimages]
1399             goodcorners = [co for (im, (ok, co)) in zip(leftimages, corners) if ok]
1400
1401             ipts = mk_image_points(goodcorners)
1402             opts = mk_object_points(len(goodcorners), .1)
1403             npts = mk_point_counts(len(goodcorners))
1404
1405             intrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
1406             distortion = cv.CreateMat(4, 1, cv.CV_64FC1)
1407             cv.SetZero(intrinsics)
1408             cv.SetZero(distortion)
1409             # focal lengths have 1/1 ratio
1410             intrinsics[0,0] = 1.0
1411             intrinsics[1,1] = 1.0
1412             cv.CalibrateCamera2(opts, ipts, npts,
1413                        cv.GetSize(leftimages[0]),
1414                        intrinsics,
1415                        distortion,
1416                        cv.CreateMat(len(goodcorners), 3, cv.CV_32FC1),
1417                        cv.CreateMat(len(goodcorners), 3, cv.CV_32FC1),
1418                        flags = 0) # cv.CV_CALIB_ZERO_TANGENT_DIST)
1419             # print "D =", list(cvmat_iterator(distortion))
1420             # print "K =", list(cvmat_iterator(intrinsics))
1421
1422             newK = cv.CreateMat(3, 3, cv.CV_64FC1)
1423             cv.GetOptimalNewCameraMatrix(intrinsics, distortion, size, 1.0, newK)
1424             # print "newK =", list(cvmat_iterator(newK))
1425
1426             mapx = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
1427             mapy = cv.CreateImage((640, 480), cv.IPL_DEPTH_32F, 1)
1428             for K in [ intrinsics, newK ]:
1429                 cv.InitUndistortMap(K, distortion, mapx, mapy)
1430                 for img in leftimages[:1]:
1431                     r = cv.CloneMat(img)
1432                     cv.Remap(img, r, mapx, mapy)
1433                     # cv.ShowImage("snap", r)
1434                     # cv.WaitKey()
1435
1436         rightimages = [image_from_archive(tf, "wide/right%04d.pgm" % i) for i in range(3, 15)]
1437
1438         # Stereo test
1439
1440         if True:
1441             lcorners = [get_corners(i) for i in leftimages]
1442             rcorners = [get_corners(i) for i in rightimages]
1443             good = [(lco, rco) for ((lok, lco), (rok, rco)) in zip(lcorners, rcorners) if (lok and rok)]
1444
1445             lipts = mk_image_points([l for (l, r) in good])
1446             ripts = mk_image_points([r for (l, r) in good])
1447             opts = mk_object_points(len(good), .108)
1448             npts = mk_point_counts(len(good))
1449
1450             flags = cv.CV_CALIB_FIX_ASPECT_RATIO | cv.CV_CALIB_FIX_INTRINSIC
1451             flags = cv.CV_CALIB_SAME_FOCAL_LENGTH + cv.CV_CALIB_FIX_PRINCIPAL_POINT + cv.CV_CALIB_ZERO_TANGENT_DIST
1452             flags = 0
1453
1454             T = cv.CreateMat(3, 1, cv.CV_64FC1)
1455             R = cv.CreateMat(3, 3, cv.CV_64FC1)
1456             lintrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
1457             ldistortion = cv.CreateMat(4, 1, cv.CV_64FC1)
1458             rintrinsics = cv.CreateMat(3, 3, cv.CV_64FC1)
1459             rdistortion = cv.CreateMat(4, 1, cv.CV_64FC1)
1460             lR = cv.CreateMat(3, 3, cv.CV_64FC1)
1461             rR = cv.CreateMat(3, 3, cv.CV_64FC1)
1462             lP = cv.CreateMat(3, 4, cv.CV_64FC1)
1463             rP = cv.CreateMat(3, 4, cv.CV_64FC1)
1464             lmapx = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
1465             lmapy = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
1466             rmapx = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
1467             rmapy = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
1468
1469             cv.SetIdentity(lintrinsics)
1470             cv.SetIdentity(rintrinsics)
1471             lintrinsics[0,2] = size[0] * 0.5
1472             lintrinsics[1,2] = size[1] * 0.5
1473             rintrinsics[0,2] = size[0] * 0.5
1474             rintrinsics[1,2] = size[1] * 0.5
1475             cv.SetZero(ldistortion)
1476             cv.SetZero(rdistortion)
1477
1478             cv.StereoCalibrate(opts, lipts, ripts, npts,
1479                                lintrinsics, ldistortion,
1480                                rintrinsics, rdistortion,
1481                                size,
1482                                R,                                  # R
1483                                T,                                  # T
1484                                cv.CreateMat(3, 3, cv.CV_32FC1),    # E
1485                                cv.CreateMat(3, 3, cv.CV_32FC1),    # F
1486                                (cv.CV_TERMCRIT_ITER + cv.CV_TERMCRIT_EPS, 30, 1e-5),
1487                                flags)
1488
1489             for a in [-1, 0, 1]:
1490                 cv.StereoRectify(lintrinsics,
1491                                  rintrinsics,
1492                                  ldistortion,
1493                                  rdistortion,
1494                                  size,
1495                                  R,
1496                                  T,
1497                                  lR, rR, lP, rP,
1498                                  alpha = a)
1499
1500                 cv.InitUndistortRectifyMap(lintrinsics, ldistortion, lR, lP, lmapx, lmapy)
1501                 cv.InitUndistortRectifyMap(rintrinsics, rdistortion, rR, rP, rmapx, rmapy)
1502
1503                 for l,r in zip(leftimages, rightimages)[:1]:
1504                     l_ = cv.CloneMat(l)
1505                     r_ = cv.CloneMat(r)
1506                     cv.Remap(l, l_, lmapx, lmapy)
1507                     cv.Remap(r, r_, rmapx, rmapy)
1508                     # cv.ShowImage("snap", l_)
1509                     # cv.WaitKey()
1510
1511
1512     def xxx_test_Disparity(self):
1513         print
1514         for t in ["8U", "8S", "16U", "16S", "32S", "32F", "64F" ]:
1515           for c in [1,2,3,4]:
1516             nm = "%sC%d" % (t, c)
1517             print "int32 CV_%s=%d" % (nm, eval("cv.CV_%s" % nm))
1518         return
1519         integral = cv.CreateImage((641,481), cv.IPL_DEPTH_32S, 1)
1520         L = cv.LoadImage("f0-left.png", 0)
1521         R = cv.LoadImage("f0-right.png", 0)
1522         d = cv.CreateImage(cv.GetSize(L), cv.IPL_DEPTH_8U, 1)
1523         Rn = cv.CreateImage(cv.GetSize(L), cv.IPL_DEPTH_8U, 1)
1524         started = time.time()
1525         for i in range(100):
1526             cv.AbsDiff(L, R, d)
1527             cv.Integral(d, integral)
1528             cv.SetImageROI(R, (1, 1, 639, 479))
1529             cv.SetImageROI(Rn, (0, 0, 639, 479))
1530             cv.Copy(R, Rn)
1531             R = Rn
1532             cv.ResetImageROI(R)
1533         print 1e3 * (time.time() - started) / 100, "ms"
1534         # self.snap(d)
1535
1536     def local_test_lk(self):
1537         seq = [cv.LoadImage("track/%06d.png" % i, 0) for i in range(40)]
1538         crit = (cv.CV_TERMCRIT_ITER, 100, 0.1)
1539         crit = (cv.CV_TERMCRIT_EPS, 0, 0.001)
1540
1541         for i in range(1,40):
1542             r = cv.CalcOpticalFlowPyrLK(seq[0], seq[i], None, None, [(32,32)], (7,7), 0, crit, 0)
1543             pos = r[0][0]
1544             #print pos, r[2]
1545
1546             a = cv.CreateImage((1024,1024), 8, 1)
1547             b = cv.CreateImage((1024,1024), 8, 1)
1548             cv.Resize(seq[0], a, cv.CV_INTER_NN)
1549             cv.Resize(seq[i], b, cv.CV_INTER_NN)
1550             cv.Line(a, (0, 512), (1024, 512), 255)
1551             cv.Line(a, (512,0), (512,1024), 255)
1552             x,y = [int(c) for c in pos]
1553             cv.Line(b, (0, y*16), (1024, y*16), 255)
1554             cv.Line(b, (x*16,0), (x*16,1024), 255)
1555             #self.snapL([a,b])
1556
1557
1558
1559     def local_test_Haar(self):
1560         import os
1561         hcfile = os.environ['OPENCV_ROOT'] + '/share/opencv/haarcascades/haarcascade_frontalface_default.xml'
1562         hc = cv.Load(hcfile)
1563         img = cv.LoadImage('Stu.jpg', 0)
1564         faces = cv.HaarDetectObjects(img, hc, cv.CreateMemStorage())
1565         self.assert_(len(faces) > 0)
1566         for (x,y,w,h),n in faces:
1567             cv.Rectangle(img, (x,y), (x+w,y+h), 255)
1568         #self.snap(img)
1569
1570     def test_create(self):
1571         """ CvCreateImage, CvCreateMat and the header-only form """
1572         for (w,h) in [ (320,400), (640,480), (1024, 768) ]:
1573             data = "z" * (w * h)
1574
1575             im = cv.CreateImage((w,h), 8, 1)
1576             cv.SetData(im, data, w)
1577             im2 = cv.CreateImageHeader((w,h), 8, 1)
1578             cv.SetData(im2, data, w)
1579             self.assertSame(im, im2)
1580
1581             m = cv.CreateMat(h, w, cv.CV_8UC1)
1582             cv.SetData(m, data, w)
1583             m2 = cv.CreateMatHeader(h, w, cv.CV_8UC1)
1584             cv.SetData(m2, data, w)
1585             self.assertSame(m, m2)
1586
1587             self.assertSame(im, m)
1588             self.assertSame(im2, m2)
1589
1590
1591     def test_casts(self):
1592         im = cv.GetImage(self.get_sample("samples/c/lena.jpg", 0))
1593         data = im.tostring()
1594         cv.SetData(im, data, cv.GetSize(im)[0])
1595
1596         start_count = sys.getrefcount(data)
1597
1598         # Conversions should produce same data
1599         self.assertSame(im, cv.GetImage(im))
1600         m = cv.GetMat(im)
1601         self.assertSame(im, m)
1602         self.assertSame(m, cv.GetImage(m))
1603         im2 = cv.GetImage(m)
1604         self.assertSame(im, im2)
1605
1606         self.assertEqual(sys.getrefcount(data), start_count + 2)
1607         del im2
1608         self.assertEqual(sys.getrefcount(data), start_count + 1)
1609         del m
1610         self.assertEqual(sys.getrefcount(data), start_count)
1611         del im
1612         self.assertEqual(sys.getrefcount(data), start_count - 1)
1613
1614     def test_morphological(self):
1615         im = cv.CreateImage((128, 128), cv.IPL_DEPTH_8U, 1)
1616         cv.Resize(cv.GetImage(self.get_sample("samples/c/lena.jpg", 0)), im)
1617         dst = cv.CloneImage(im)
1618         shapes = [eval("cv.CV_SHAPE_%s" % s) for s in ['RECT', 'CROSS', 'ELLIPSE']]
1619         elements = [cv.CreateStructuringElementEx(sz, sz, sz / 2 + 1, sz / 2 + 1, shape) for sz in [3, 4, 7, 20] for shape in shapes]
1620         elements += [cv.CreateStructuringElementEx(7, 7, 3, 3, cv.CV_SHAPE_CUSTOM, [1] * 49)]
1621         for e in elements:
1622             for iter in [1, 2]:
1623                 cv.Dilate(im, dst, e, iter)
1624                 cv.Erode(im, dst, e, iter)
1625                 temp = cv.CloneImage(im)
1626                 for op in ["OPEN", "CLOSE", "GRADIENT", "TOPHAT", "BLACKHAT"]:
1627                         cv.MorphologyEx(im, dst, temp, e, eval("cv.CV_MOP_%s" % op), iter)
1628
1629     def failing_test_getmat_nd(self):
1630         # 1D CvMatND should yield 1D CvMat
1631         matnd = cv.CreateMatND([13], cv.CV_8UC1)
1632         self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (13,))
1633
1634         # 2D CvMatND should yield 2D CvMat
1635         matnd = cv.CreateMatND([11,12], cv.CV_8UC1)
1636         self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (11, 12))
1637
1638         # 3D CvMatND should yield 1D CvMat
1639         matnd = cv.CreateMatND([8,8,8], cv.CV_8UC1)
1640         self.assertEqual(cv.GetDims(cv.GetMat(matnd, allowND = True)), (8 * 8 * 8,))
1641
1642     def test_clipline(self):
1643         self.assert_(cv.ClipLine((100,100), (-100,0), (500,0)) == ((0,0), (99,0)))
1644         self.assert_(cv.ClipLine((100,100), (-100,0), (-200,0)) == None)
1645
1646     def test_smoke_image_processing(self):
1647         src = self.get_sample("samples/c/lena.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE)
1648         #dst = cv.CloneImage(src)
1649         for aperture_size in [1, 3, 5, 7]:
1650           dst_16s = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_16S, 1)
1651           dst_32f = cv.CreateImage(cv.GetSize(src), cv.IPL_DEPTH_32F, 1)
1652
1653           cv.Sobel(src, dst_16s, 1, 1, aperture_size)
1654           cv.Laplace(src, dst_16s, aperture_size)
1655           cv.PreCornerDetect(src, dst_32f)
1656           eigendst = cv.CreateImage((6*cv.GetSize(src)[0], cv.GetSize(src)[1]), cv.IPL_DEPTH_32F, 1)
1657           cv.CornerEigenValsAndVecs(src, eigendst, 8, aperture_size)
1658           cv.CornerMinEigenVal(src, dst_32f, 8, aperture_size)
1659           cv.CornerHarris(src, dst_32f, 8, aperture_size)
1660           cv.CornerHarris(src, dst_32f, 8, aperture_size, 0.1)
1661
1662         #self.snap(dst)
1663
1664     def test_fitline(self):
1665         cv.FitLine([ (1,1), (10,10) ], cv.CV_DIST_L2, 0, 0.01, 0.01)
1666         cv.FitLine([ (1,1,1), (10,10,10) ], cv.CV_DIST_L2, 0, 0.01, 0.01)
1667         a = self.get_sample("samples/c/lena.jpg", 0)
1668         eig_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
1669         temp_image = cv.CreateImage(cv.GetSize(a), cv.IPL_DEPTH_32F, 1)
1670         pts = cv.GoodFeaturesToTrack(a, eig_image, temp_image, 100, 0.04, 2, use_harris=1)
1671         hull = cv.ConvexHull2(pts, cv.CreateMemStorage(), return_points = 1)
1672         cv.FitLine(hull, cv.CV_DIST_L2, 0, 0.01, 0.01)
1673
1674     def test_moments(self):
1675         im = self.get_sample("samples/c/lena.jpg", 0)
1676         mo = cv.Moments(im)
1677         orders = []
1678         for x_order in range(4):
1679           for y_order in range(4 - x_order):
1680             orders.append((x_order, y_order))
1681
1682         # Just a smoke test for these three functions
1683         [ cv.GetSpatialMoment(mo, xo, yo) for (xo,yo) in orders ]
1684         [ cv.GetCentralMoment(mo, xo, yo) for (xo,yo) in orders ]
1685         [ cv.GetNormalizedCentralMoment(mo, xo, yo) for (xo,yo) in orders ]
1686
1687         # Hu Moments we can do slightly better.  Check that the first
1688         # six are invariant wrt image reflection, and that the 7th
1689         # is negated.
1690
1691         hu0 = cv.GetHuMoments(cv.Moments(im))
1692         cv.Flip(im, im, 1)
1693         hu1 = cv.GetHuMoments(cv.Moments(im))
1694         self.assert_(len(hu0) == 7)
1695         self.assert_(len(hu1) == 7)
1696         for i in range(5):
1697           self.assert_(abs(hu0[i] - hu1[i]) < 1e-6)
1698         self.assert_(abs(hu0[i] + hu1[i]) < 1e-6)
1699
1700     def test_encode(self):
1701         im = self.get_sample("samples/c/lena.jpg", 1)
1702         jpeg = cv.EncodeImage(".jpeg", im)
1703
1704         # Smoke jpeg compression at various qualities
1705         sizes = dict([(qual, cv.EncodeImage(".jpeg", im, [cv.CV_IMWRITE_JPEG_QUALITY, qual]).cols) for qual in range(5, 100, 5)])
1706
1707         # Check that the default QUALITY is 95
1708         self.assertEqual(cv.EncodeImage(".jpeg", im).cols, sizes[95])
1709
1710         # Check that the 'round-trip' gives an image of the same size
1711         round_trip = cv.DecodeImage(cv.EncodeImage(".jpeg", im, [cv.CV_IMWRITE_JPEG_QUALITY, 10]))
1712         self.assert_(cv.GetSize(round_trip) == cv.GetSize(im))
1713
1714     def test_reduce(self):
1715         srcmat = cv.CreateMat(2, 3, cv.CV_32FC1)
1716         # 0 1 2
1717         # 3 4 5
1718         srcmat[0,0] = 0
1719         srcmat[0,1] = 1
1720         srcmat[0,2] = 2
1721         srcmat[1,0] = 3
1722         srcmat[1,1] = 4
1723         srcmat[1,2] = 5
1724         def doreduce(siz, rfunc):
1725             dst = cv.CreateMat(siz[0], siz[1], cv.CV_32FC1)
1726             rfunc(dst)
1727             if siz[0] != 1:
1728                 return [dst[i,0] for i in range(siz[0])]
1729             else:
1730                 return [dst[0,i] for i in range(siz[1])]
1731
1732         # exercise dim
1733         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst)), [3, 5, 7])
1734         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, -1)), [3, 5, 7])
1735         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, 0)), [3, 5, 7])
1736         self.assertEqual(doreduce((2,1), lambda dst: cv.Reduce(srcmat, dst, 1)), [3, 12])
1737
1738         # exercise op
1739         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_SUM)), [3, 5, 7])
1740         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_AVG)), [1.5, 2.5, 3.5])
1741         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_MAX)), [3, 4, 5])
1742         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, op = cv.CV_REDUCE_MIN)), [0, 1, 2])
1743
1744         # exercise both dim and op
1745         self.assertEqual(doreduce((1,3), lambda dst: cv.Reduce(srcmat, dst, 0, cv.CV_REDUCE_MAX)), [3, 4, 5])
1746         self.assertEqual(doreduce((2,1), lambda dst: cv.Reduce(srcmat, dst, 1, cv.CV_REDUCE_MAX)), [2, 5])
1747
1748     def test_operations(self):
1749         class Im:
1750
1751             def __init__(self, data = None):
1752                 self.m = cv.CreateMat(1, 32, cv.CV_32FC1)
1753                 if data:
1754                     cv.SetData(self.m, array.array('f', data), 128)
1755
1756             def __add__(self, other):
1757                 r = Im()
1758                 if isinstance(other, Im):
1759                     cv.Add(self.m, other.m, r.m)
1760                 else:
1761                     cv.AddS(self.m, (other,), r.m)
1762                 return r
1763
1764             def __sub__(self, other):
1765                 r = Im()
1766                 if isinstance(other, Im):
1767                     cv.Sub(self.m, other.m, r.m)
1768                 else:
1769                     cv.SubS(self.m, (other,), r.m)
1770                 return r
1771
1772             def __rsub__(self, other):
1773                 r = Im()
1774                 cv.SubRS(self.m, (other,), r.m)
1775                 return r
1776
1777             def __mul__(self, other):
1778                 r = Im()
1779                 if isinstance(other, Im):
1780                     cv.Mul(self.m, other.m, r.m)
1781                 else:
1782                     cv.ConvertScale(self.m, r.m, other)
1783                 return r
1784
1785             def __rmul__(self, other):
1786                 r = Im()
1787                 cv.ConvertScale(self.m, r.m, other)
1788                 return r
1789
1790             def __div__(self, other):
1791                 r = Im()
1792                 if isinstance(other, Im):
1793                     cv.Div(self.m, other.m, r.m)
1794                 else:
1795                     cv.ConvertScale(self.m, r.m, 1.0 / other)
1796                 return r
1797
1798             def __pow__(self, other):
1799                 r = Im()
1800                 cv.Pow(self.m, r.m, other)
1801                 return r
1802
1803             def __abs__(self):
1804                 r = Im()
1805                 cv.Abs(self.m, r.m)
1806                 return r
1807
1808             def __getitem__(self, i):
1809                 return self.m[0,i]
1810
1811         def verify(op):
1812             r = op(a, b)
1813             for i in range(32):
1814                 expected = op(a[i], b[i])
1815                 self.assertAlmostEqual(expected, r[i], 4)
1816
1817         a = Im([random.randrange(1, 256) for i in range(32)])
1818         b = Im([random.randrange(1, 256) for i in range(32)])
1819
1820         # simple operations first
1821         verify(lambda x, y: x + y)
1822         verify(lambda x, y: x + 3)
1823         verify(lambda x, y: x + 0)
1824         verify(lambda x, y: x + -8)
1825
1826         verify(lambda x, y: x - y)
1827         verify(lambda x, y: x - 1)
1828         verify(lambda x, y: 1 - x)
1829
1830         verify(lambda x, y: abs(x))
1831
1832         verify(lambda x, y: x * y)
1833         verify(lambda x, y: x * 3)
1834
1835         verify(lambda x, y: x / y)
1836         verify(lambda x, y: x / 2)
1837
1838         for p in [-2, -1, -0.5, -0.1, 0, 0.1, 0.5, 1, 2 ]:
1839             verify(lambda x, y: (x ** p) + (y ** p))
1840
1841         # Combinations...
1842         verify(lambda x, y: x - 4 * abs(y))
1843         verify(lambda x, y: abs(y) / x)
1844
1845         # a polynomial
1846         verify(lambda x, y: 2 * x + 3 * (y ** 0.5))
1847
1848     def temp_test(self):
1849         cv.temp_test()
1850
1851     def failing_test_rand_GetStarKeypoints(self):
1852         # GetStarKeypoints [<cvmat(type=4242400d rows=64 cols=64 step=512 )>, <cv.cvmemstorage object at 0xb7cc40d0>, (45, 0.73705234376883488, 0.64282591451367344, 0.1567738743689836, 3)]
1853         print cv.CV_MAT_CN(0x4242400d)
1854         mat = cv.CreateMat( 64, 64, cv.CV_32FC2)
1855         cv.GetStarKeypoints(mat, cv.CreateMemStorage(), (45, 0.73705234376883488, 0.64282591451367344, 0.1567738743689836, 3))
1856         print mat
1857
1858     def test_rand_PutText(self):
1859         """ Test for bug 2829336 """
1860         mat = cv.CreateMat( 64, 64, cv.CV_8UC1)
1861         font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1)
1862         cv.PutText(mat, chr(127), (20, 20), font, 255)
1863
1864     def failing_test_rand_FindNearestPoint2D(self):
1865         subdiv = cv.CreateSubdivDelaunay2D((0,0,100,100), cv.CreateMemStorage())
1866         cv.SubdivDelaunay2DInsert( subdiv, (50, 50))
1867         cv.CalcSubdivVoronoi2D(subdiv)
1868         print
1869         for e in subdiv.edges:
1870             print e,
1871             print "  ", cv.Subdiv2DEdgeOrg(e)
1872             print "  ", cv.Subdiv2DEdgeOrg(cv.Subdiv2DRotateEdge(e, 1)), cv.Subdiv2DEdgeDst(cv.Subdiv2DRotateEdge(e, 1))
1873         print "nearest", cv.FindNearestPoint2D(subdiv, (1.0, 1.0))
1874
1875 class NewTests(OpenCVTests):
1876
1877     pass
1878
1879 if __name__ == '__main__':
1880     random.seed(0)
1881     optlist, args = getopt.getopt(sys.argv[1:], 'l:r')
1882     loops = 1
1883     shuffle = 0
1884     for o,a in optlist:
1885         if o == '-l':
1886             loops = int(a)
1887         if o == '-r':
1888             shuffle = 1
1889
1890     cases = [PreliminaryTests, FunctionTests, AreaTests]
1891     everything = [(tc, t) for tc in cases for t in unittest.TestLoader().getTestCaseNames(tc) ]
1892     if len(args) == 0:
1893         # cases = [NewTests]
1894         args = everything
1895     else:
1896         args = [(tc, t) for (tc, t) in everything if t in args]
1897
1898     suite = unittest.TestSuite()
1899     for l in range(loops):
1900         if shuffle:
1901             random.shuffle(args)
1902         for tc,t in args:
1903             suite.addTest(tc(t))
1904     unittest.TextTestRunner(verbosity=2).run(suite)