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