vcs.maemo.org Git - opencv/blob - tests/python/test.py

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