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