modules/python/test/test.py

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