Add goodfeatures python test and cleanup in test directory

modules/python/test/calchist.py

-#!/usr/bin/env python
-
-# Calculating and displaying 2D Hue-Saturation histogram of a color image
-import sys
-import cv2.cv as cv
-
-def hs_histogram(src):
-    # Convert to HSV
-    hsv = cv.CreateImage(cv.GetSize(src), 8, 3)
-    cv.CvtColor(src, hsv, cv.CV_BGR2HSV)
-
-    # Extract the H and S planes
-    h_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1)
-    s_plane = cv.CreateMat(src.rows, src.cols, cv.CV_8UC1)
-    cv.Split(hsv, h_plane, s_plane, None, None)
-    planes = [h_plane, s_plane]
-
-    h_bins = 30
-    s_bins = 32
-    hist_size = [h_bins, s_bins]
-    # hue varies from 0 (~0 deg red) to 180 (~360 deg red again */
-    h_ranges = [0, 180]
-    # saturation varies from 0 (black-gray-white) to
-    # 255 (pure spectrum color)
-    s_ranges = [0, 255]
-    ranges = [h_ranges, s_ranges]
-    scale = 10
-    hist = cv.CreateHist([h_bins, s_bins], cv.CV_HIST_ARRAY, ranges, 1)
-    cv.CalcHist([cv.GetImage(i) for i in planes], hist)
-    (_, max_value, _, _) = cv.GetMinMaxHistValue(hist)
-
-    hist_img = cv.CreateImage((h_bins*scale, s_bins*scale), 8, 3)
-
-    for h in range(h_bins):
-        for s in range(s_bins):
-            bin_val = cv.QueryHistValue_2D(hist, h, s)
-            intensity = cv.Round(bin_val * 255 / max_value)
-            cv.Rectangle(hist_img,
-                         (h*scale, s*scale),
-                         ((h+1)*scale - 1, (s+1)*scale - 1),
-                         cv.RGB(intensity, intensity, intensity),
-                         cv.CV_FILLED)
-    return hist_img
-
-if __name__ == '__main__':
-    src = cv.LoadImageM(sys.argv[1])
-    cv.NamedWindow("Source", 1)
-    cv.ShowImage("Source", src)
-
-    cv.NamedWindow("H-S Histogram", 1)
-    cv.ShowImage("H-S Histogram", hs_histogram(src))
-
-    cv.WaitKey(0)

modules/python/test/findstereocorrespondence.py

-#!/usr/bin/env python
-
-import sys
-import cv2.cv as cv
-
-def findstereocorrespondence(image_left, image_right):
-    # image_left and image_right are the input 8-bit single-channel images
-    # from the left and the right cameras, respectively
-    (r, c) = (image_left.rows, image_left.cols)
-    disparity_left = cv.CreateMat(r, c, cv.CV_16S)
-    disparity_right = cv.CreateMat(r, c, cv.CV_16S)
-    state = cv.CreateStereoGCState(16, 2)
-    cv.FindStereoCorrespondenceGC(image_left, image_right, disparity_left, disparity_right, state, 0)
-    return (disparity_left, disparity_right)
-
-
-if __name__ == '__main__':
-
-    (l, r) = [cv.LoadImageM(f, cv.CV_LOAD_IMAGE_GRAYSCALE) for f in sys.argv[1:]]
-
-    (disparity_left, disparity_right) = findstereocorrespondence(l, r)
-
-    disparity_left_visual = cv.CreateMat(l.rows, l.cols, cv.CV_8U)
-    cv.ConvertScale(disparity_left, disparity_left_visual, -16)
-    cv.SaveImage("disparity.pgm", disparity_left_visual)

modules/python/test/goodfeatures.py

-#!/usr/bin/env python
-
-import cv2.cv as cv
-import unittest
-
-class TestGoodFeaturesToTrack(unittest.TestCase):
-    def test(self):
-        arr = cv.LoadImage("../samples/c/lena.jpg", 0)
-        original = cv.CloneImage(arr)
-        size = cv.GetSize(arr)
-        eig_image = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
-        temp_image = cv.CreateImage(size, cv.IPL_DEPTH_32F, 1)
-        threshes = [ x / 100. for x in range(1,10) ]
-
-        results = dict([(t, cv.GoodFeaturesToTrack(arr, eig_image, temp_image, 20000, t, 2, useHarris = 1)) for t in threshes])
-
-        # Check that GoodFeaturesToTrack has not modified input image
-        self.assert_(arr.tostring() == original.tostring())
-
-        # Check for repeatability
-        for i in range(10):
-            results2 = dict([(t, cv.GoodFeaturesToTrack(arr, eig_image, temp_image, 20000, t, 2, useHarris = 1)) for t in threshes])
-            self.assert_(results == results2)
-
-        for t0,t1 in zip(threshes, threshes[1:]):
-             r0 = results[t0]
-             r1 = results[t1]
-
-             # Increasing thresh should make result list shorter
-             self.assert_(len(r0) > len(r1))
-
-             # Increasing thresh should monly truncate result list
-             self.assert_(r0[:len(r1)] == r1)
-
-if __name__ == '__main__':
-    unittest.main()

modules/python/test/leak1.py

-#!/usr/bin/env python
-
-import cv2.cv as cv
-import numpy as np
-cv.NamedWindow('Leak')
-while 1:
-    leak = np.random.random((480, 640)) * 255
-    cv.ShowImage('Leak', leak.astype(np.uint8))
-    cv.WaitKey(10)

modules/python/test/leak2.py

-#!/usr/bin/env python
-
-import cv2.cv as cv
-import numpy as np
-import time
-
-while True:
-    for i in range(4000):
-        a = cv.CreateImage((1024,1024), cv.IPL_DEPTH_8U, 1)
-        b = cv.CreateMat(1024, 1024, cv.CV_8UC1)
-        c = cv.CreateMatND([1024,1024], cv.CV_8UC1)
-    print "pause..."

modules/python/test/leak3.py

-#!/usr/bin/env python
-
-import cv2.cv as cv
-import math
-import time
-
-while True:
-    h = cv.CreateHist([40], cv.CV_HIST_ARRAY, [[0,255]], 1)

modules/python/test/leak4.py

-#!/usr/bin/env python
-
-import cv2.cv as cv
-import math
-import time
-
-N=50000
-print "leak4"
-while True:
-    seq=list((i*1., i*1.) for i in range(N))
-    cv.Moments(seq)

modules/python/test/precornerdetect.py

-#!/usr/bin/env python
-
-import cv2.cv as cv
-
-def precornerdetect(image):
-    # assume that the image is floating-point
-    corners = cv.CloneMat(image)
-    cv.PreCornerDetect(image, corners, 3)
-
-    dilated_corners = cv.CloneMat(image)
-    cv.Dilate(corners, dilated_corners, None, 1)
-
-    corner_mask = cv.CreateMat(image.rows, image.cols, cv.CV_8UC1)
-    cv.Sub(corners, dilated_corners, corners)
-    cv.CmpS(corners, 0, corner_mask, cv.CV_CMP_GE)
-    return (corners, corner_mask)

modules/python/test/test_goodfeatures.py

+#!/usr/bin/env python
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import cv2
+import numpy as np
+
+from tests_common import NewOpenCVTests
+
+class TestGoodFeaturesToTrack_test(NewOpenCVTests):
+    def test_goodFeaturesToTrack(self):
+        arr = self.get_sample('samples/data/lena.jpg', 0)
+        original = arr.copy(True)
+        threshes = [ x / 100. for x in range(1,10) ]
+        numPoints = 20000
+
+        results = dict([(t, cv2.goodFeaturesToTrack(arr, numPoints, t, 2, useHarrisDetector=True)) for t in threshes])
+        # Check that GoodFeaturesToTrack has not modified input image
+        self.assertTrue(arr.tostring() == original.tostring())
+        # Check for repeatability
+        for i in range(1):
+            results2 = dict([(t, cv2.goodFeaturesToTrack(arr, numPoints, t, 2, useHarrisDetector=True)) for t in threshes])
+            for t in threshes:
+                self.assertTrue(len(results2[t]) == len(results[t]))
+                for i in range(len(results[t])):
+                    self.assertTrue(cv2.norm(results[t][i][0] - results2[t][i][0]) == 0)
+
+        for t0,t1 in zip(threshes, threshes[1:]):
+             r0 = results[t0]
+             r1 = results[t1]
+             # Increasing thresh should make result list shorter
+             self.assertTrue(len(r0) > len(r1))
+             # Increasing thresh should monly truncate result list
+             for i in range(len(r1)):
+                self.assertTrue(cv2.norm(r1[i][0] - r0[i][0])==0)
\ No newline at end of file

modules/python/test/ticket_6.py

-#!/usr/bin/env python
-
-import urllib
-import cv2.cv as cv
-import Image
-import unittest
-
-class TestLoadImage(unittest.TestCase):
-    def setUp(self):
-        open("large.jpg", "w").write(urllib.urlopen("http://www.cs.ubc.ca/labs/lci/curious_george/img/ROS_bug_imgs/IMG_3560.jpg").read())
-
-    def test_load(self):
-        pilim = Image.open("large.jpg")
-        cvim = cv.LoadImage("large.jpg")
-        self.assert_(len(pilim.tostring()) == len(cvim.tostring()))
-
-class Creating(unittest.TestCase):
-    size=(640, 480)
-    repeat=100
-    def test_0_Create(self):
-        image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
-        cnt=cv.CountNonZero(image)
-        self.assertEqual(cnt, 0, msg="Created image is not black. CountNonZero=%i" % cnt)
-
-    def test_2_CreateRepeat(self):
-        cnt=0
-        for i in range(self.repeat):
-            image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
-            cnt+=cv.CountNonZero(image)
-        self.assertEqual(cnt, 0, msg="Created images are not black. Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
-
-    def test_2a_MemCreated(self):
-        cnt=0
-        v=[]
-        for i in range(self.repeat):
-            image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
-            cv.FillPoly(image, [[(0, 0), (0, 100), (100, 0)]], 0)
-            cnt+=cv.CountNonZero(image)
-            v.append(image)
-        self.assertEqual(cnt, 0, msg="Memorized images are not black. Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
-
-    def test_3_tostirng(self):
-        image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
-        image.tostring()
-        cnt=cv.CountNonZero(image)
-        self.assertEqual(cnt, 0, msg="After tostring(): CountNonZero=%i" % cnt)
-
-    def test_40_tostringRepeat(self):
-        cnt=0
-        image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
-        cv.Set(image, cv.Scalar(0,0,0,0))
-        for i in range(self.repeat*100):
-            image.tostring()
-        cnt=cv.CountNonZero(image)
-        self.assertEqual(cnt, 0, msg="Repeating tostring(): Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
-
-    def test_41_CreateToStringRepeat(self):
-        cnt=0
-        for i in range(self.repeat*100):
-            image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
-            cv.Set(image, cv.Scalar(0,0,0,0))
-            image.tostring()
-            cnt+=cv.CountNonZero(image)
-        self.assertEqual(cnt, 0, msg="Repeating create and tostring(): Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
-
-    def test_4a_MemCreatedToString(self):
-        cnt=0
-        v=[]
-        for i in range(self.repeat):
-            image = cv.CreateImage(self.size, cv.IPL_DEPTH_8U, 1)
-            cv.Set(image, cv.Scalar(0,0,0,0))
-            image.tostring()
-            cnt+=cv.CountNonZero(image)
-            v.append(image)
-        self.assertEqual(cnt, 0, msg="Repeating and memorizing after tostring(): Mean CountNonZero=%.3f" % (1.*cnt/self.repeat))
-
-if __name__ == '__main__':
-    unittest.main()

modules/python/test/tickets.py

-#!/usr/bin/env python
-
-import unittest
-import random
-import time
-import math
-import sys
-import array
-import os
-
-import cv2.cv as cv
-
-def find_sample(s):
-    for d in ["../samples/c/", "../doc/pics/"]:
-        path = os.path.join(d, s)
-        if os.access(path, os.R_OK):
-            return path
-    return s
-
-class TestTickets(unittest.TestCase):
-
-    def test_2542670(self):
-        xys = [(94, 121), (94, 122), (93, 123), (92, 123), (91, 124), (91, 125), (91, 126), (92, 127), (92, 128), (92, 129), (92, 130), (92, 131), (91, 132), (90, 131), (90, 130), (90, 131), (91, 132), (92, 133), (92, 134), (93, 135), (94, 136), (94, 137), (94, 138), (95, 139), (96, 140), (96, 141), (96, 142), (96, 143), (97, 144), (97, 145), (98, 146), (99, 146), (100, 146), (101, 146), (102, 146), (103, 146), (104, 146), (105, 146), (106, 146), (107, 146), (108, 146), (109, 146), (110, 146), (111, 146), (112, 146), (113, 146), (114, 146), (115, 146), (116, 146), (117, 146), (118, 146), (119, 146), (120, 146), (121, 146), (122, 146), (123, 146), (124, 146), (125, 146), (126, 146), (126, 145), (126, 144), (126, 143), (126, 142), (126, 141), (126, 140), (127, 139), (127, 138), (127, 137), (127, 136), (127, 135), (127, 134), (127, 133), (128, 132), (129, 132), (130, 131), (131, 130), (131, 129), (131, 128), (132, 127), (133, 126), (134, 125), (134, 124), (135, 123), (136, 122), (136, 121), (135, 121), (134, 121), (133, 121), (132, 121), (131, 121), (130, 121), (129, 121), (128, 121), (127, 121), (126, 121), (125, 121), (124, 121), (123, 121), (122, 121), (121, 121), (120, 121), (119, 121), (118, 121), (117, 121), (116, 121), (115, 121), (114, 121), (113, 121), (112, 121), (111, 121), (110, 121), (109, 121), (108, 121), (107, 121), (106, 121), (105, 121), (104, 121), (103, 121), (102, 121), (101, 121), (100, 121), (99, 121), (98, 121), (97, 121), (96, 121), (95, 121)]
-
-        #xys = xys[:12] + xys[16:]
-        pts = cv.CreateMat(len(xys), 1, cv.CV_32SC2)
-        for i,(x,y) in enumerate(xys):
-            pts[i,0] = (x, y)
-        storage = cv.CreateMemStorage()
-        hull = cv.ConvexHull2(pts, storage)
-        hullp = cv.ConvexHull2(pts, storage, return_points = 1)
-        defects = cv.ConvexityDefects(pts, hull, storage)
-
-        vis = cv.CreateImage((1000,1000), 8, 3)
-        x0 = min([x for (x,y) in xys]) - 10
-        x1 = max([x for (x,y) in xys]) + 10
-        y0 = min([y for (y,y) in xys]) - 10
-        y1 = max([y for (y,y) in xys]) + 10
-        def xform(pt):
-            x,y = pt
-            return (1000 * (x - x0) / (x1 - x0),
-                    1000 * (y - y0) / (y1 - y0))
-
-        for d in defects[:2]:
-            cv.Zero(vis)
-
-            # First draw the defect as a red triangle
-            cv.FillConvexPoly(vis, [xform(p) for p in d[:3]], cv.RGB(255,0,0))
-
-            # Draw the convex hull as a thick green line
-            for a,b in zip(hullp, hullp[1:]):
-                cv.Line(vis, xform(a), xform(b), cv.RGB(0,128,0), 3)
-
-            # Draw the original contour as a white line
-            for a,b in zip(xys, xys[1:]):
-                cv.Line(vis, xform(a), xform(b), (255,255,255))
-
-            self.snap(vis)
-
-    def test_2686307(self):
-        lena = cv.LoadImage(find_sample("lena.jpg"), 1)
-        dst = cv.CreateImage((512,512), 8, 3)
-        cv.Set(dst, (128,192,255))
-        mask = cv.CreateImage((512,512), 8, 1)
-        cv.Zero(mask)
-        cv.Rectangle(mask, (10,10), (300,100), 255, -1)
-        cv.Copy(lena, dst, mask)
-        self.snapL([lena, dst, mask])
-        m = cv.CreateMat(480, 640, cv.CV_8UC1)
-        print "ji", m
-        print m.rows, m.cols, m.type, m.step
-
-    def snap(self, img):
-        self.snapL([img])
-
-    def snapL(self, L):
-        for i,img in enumerate(L):
-            cv.NamedWindow("snap-%d" % i, 1)
-            cv.ShowImage("snap-%d" % i, img)
-        cv.WaitKey()
-        cv.DestroyAllWindows()
-
-if __name__ == '__main__':
-    random.seed(0)
-    if len(sys.argv) == 1:
-        suite = unittest.TestLoader().loadTestsFromTestCase(TestTickets)
-        unittest.TextTestRunner(verbosity=2).run(suite)
-    else:
-        suite = unittest.TestSuite()
-        suite.addTest(TestTickets(sys.argv[1]))
-        unittest.TextTestRunner(verbosity=2).run(suite)