Add 2 new tests, bugfixed in old tests

modules/python/test/test_camshift.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+
+'''
+Camshift tracker
+================
+
+This is a demo that shows mean-shift based tracking
+You select a color objects such as your face and it tracks it.
+This reads from video camera (0 by default, or the camera number the user enters)
+
+http://www.robinhewitt.com/research/track/camshift.html
+
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+import sys
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    xrange = range
+
+import numpy as np
+import cv2
+from tst_scene_render import TestSceneRender
+
+def intersectionRate(s1, s2):
+
+    x1, y1, x2, y2 = s1
+    s1 = [[x1, y1], [x2,y1], [x2, y2], [x1, y2] ]
+
+    x1, y1, x2, y2 = s2
+    s2 = [[x1, y1], [x2,y1], [x2, y2], [x1, y2] ]
+
+    area, intersection = cv2.intersectConvexConvex(np.array(s1), np.array(s2))
+    return 2 * area / (cv2.contourArea(np.array(s1)) + cv2.contourArea(np.array(s2)))
+
+
+from tests_common import NewOpenCVTests
+
+class camshift_test(NewOpenCVTests):
+
+    frame = None
+    selection = None
+    drag_start = None
+    show_backproj = False
+    track_window = None
+    render = None
+
+    def prepareRender(self):
+
+        cv2.namedWindow('camshift')
+        self.render = TestSceneRender(self.get_sample('samples/data/pca_test1.jpg'))
+
+    def runTracker(self):
+
+        framesCounter = 0
+        self.selection = True
+
+        xmin, ymin, xmax, ymax = self.render.getCurrentRect()
+
+        self.track_window = (xmin, ymin, xmax - xmin, ymax - ymin)
+
+        while True:
+            framesCounter += 1
+            self.frame = self.render.getNextFrame()
+            vis = self.frame.copy()
+            hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV)
+            mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
+
+            if self.selection:
+                x0, y0, x1, y1 = self.render.getCurrentRect() + 50
+                x0 -= 100
+                y0 -= 100
+
+                hsv_roi = hsv[y0:y1, x0:x1]
+                mask_roi = mask[y0:y1, x0:x1]
+                hist = cv2.calcHist( [hsv_roi], [0], mask_roi, [16], [0, 180] )
+                cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)
+                self.hist = hist.reshape(-1)
+
+                vis_roi = vis[y0:y1, x0:x1]
+                cv2.bitwise_not(vis_roi, vis_roi)
+                vis[mask == 0] = 0
+
+                self.selection = False
+
+            if self.track_window and self.track_window[2] > 0 and self.track_window[3] > 0:
+                self.selection = None
+                prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1)
+                prob &= mask
+                term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
+                track_box, self.track_window = cv2.CamShift(prob, self.track_window, term_crit)
+
+                if self.show_backproj:
+                    vis[:] = prob[...,np.newaxis]
+
+                cv2.rectangle(vis, (self.track_window[0], self.track_window[1]), (self.track_window[0] + self.track_window[2], self.track_window[1] + self.track_window[3]), (0, 255, 0), 2)
+
+            trackingRect = np.array(self.track_window)
+            trackingRect[2] += trackingRect[0]
+            trackingRect[3] += trackingRect[1]
+
+            print(intersectionRate((self.render.getCurrentRect()), trackingRect))
+            self.assertGreater(intersectionRate((self.render.getCurrentRect()), trackingRect), 0.5)
+
+            if framesCounter > 300:
+                break
+
+    def test_camshift(self):
+        self.prepareRender()
+        self.runTracker()

modules/python/test/test_facedetect.py

@@ -93,9 +93,9 @@ class facedetect_test(NewOpenCVTests):
                     faces_matches += 1
                     #check eyes
                     if len(eyes[i]) == 2:
-                        if intersectionRate(eyes[i][0], testFaces[j][1]) > eps and intersectionRate(eyes[i][1], testFaces[j][2]):
+                        if intersectionRate(eyes[i][0], testFaces[j][1]) > eps and intersectionRate(eyes[i][1] , testFaces[j][2]) > eps:
                             eyes_matches += 1
-                        elif intersectionRate(eyes[i][1], testFaces[j][1]) > eps and intersectionRate(eyes[i][0], testFaces[j][2]):
+                        elif intersectionRate(eyes[i][1], testFaces[j][1]) > eps and intersectionRate(eyes[i][0], testFaces[j][2]) > eps:
                             eyes_matches += 1
 
         self.assertEqual(faces_matches, 2)

modules/python/test/test_letter_recog.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+
+'''
+The sample demonstrates how to train Random Trees classifier
+(or Boosting classifier, or MLP, or Knearest, or Support Vector Machines) using the provided dataset.
+
+We use the sample database letter-recognition.data
+from UCI Repository, here is the link:
+
+Newman, D.J. & Hettich, S. & Blake, C.L. & Merz, C.J. (1998).
+UCI Repository of machine learning databases
+[http://www.ics.uci.edu/~mlearn/MLRepository.html].
+Irvine, CA: University of California, Department of Information and Computer Science.
+
+The dataset consists of 20000 feature vectors along with the
+responses - capital latin letters A..Z.
+The first 10000 samples are used for training
+and the remaining 10000 - to test the classifier.
+======================================================
+  Models: RTrees, KNearest, Boost, SVM, MLP
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2
+
+def load_base(fn):
+    a = np.loadtxt(fn, np.float32, delimiter=',', converters={ 0 : lambda ch : ord(ch)-ord('A') })
+    samples, responses = a[:,1:], a[:,0]
+    return samples, responses
+
+class LetterStatModel(object):
+    class_n = 26
+    train_ratio = 0.5
+
+    def load(self, fn):
+        self.model.load(fn)
+    def save(self, fn):
+        self.model.save(fn)
+
+    def unroll_samples(self, samples):
+        sample_n, var_n = samples.shape
+        new_samples = np.zeros((sample_n * self.class_n, var_n+1), np.float32)
+        new_samples[:,:-1] = np.repeat(samples, self.class_n, axis=0)
+        new_samples[:,-1] = np.tile(np.arange(self.class_n), sample_n)
+        return new_samples
+
+    def unroll_responses(self, responses):
+        sample_n = len(responses)
+        new_responses = np.zeros(sample_n*self.class_n, np.int32)
+        resp_idx = np.int32( responses + np.arange(sample_n)*self.class_n )
+        new_responses[resp_idx] = 1
+        return new_responses
+
+class RTrees(LetterStatModel):
+    def __init__(self):
+        self.model = cv2.ml.RTrees_create()
+
+    def train(self, samples, responses):
+        sample_n, var_n = samples.shape
+        self.model.setMaxDepth(20)
+        self.model.train(samples, cv2.ml.ROW_SAMPLE, responses.astype(int))
+
+    def predict(self, samples):
+        ret, resp = self.model.predict(samples)
+        return resp.ravel()
+
+
+class KNearest(LetterStatModel):
+    def __init__(self):
+        self.model = cv2.ml.KNearest_create()
+
+    def train(self, samples, responses):
+        self.model.train(samples, cv2.ml.ROW_SAMPLE, responses)
+
+    def predict(self, samples):
+        retval, results, neigh_resp, dists = self.model.findNearest(samples, k = 10)
+        return results.ravel()
+
+
+class Boost(LetterStatModel):
+    def __init__(self):
+        self.model = cv2.ml.Boost_create()
+
+    def train(self, samples, responses):
+        sample_n, var_n = samples.shape
+        new_samples = self.unroll_samples(samples)
+        new_responses = self.unroll_responses(responses)
+        var_types = np.array([cv2.ml.VAR_NUMERICAL] * var_n + [cv2.ml.VAR_CATEGORICAL, cv2.ml.VAR_CATEGORICAL], np.uint8)
+
+        self.model.setWeakCount(15)
+        self.model.setMaxDepth(10)
+        self.model.train(cv2.ml.TrainData_create(new_samples, cv2.ml.ROW_SAMPLE, new_responses.astype(int), varType = var_types))
+
+    def predict(self, samples):
+        new_samples = self.unroll_samples(samples)
+        ret, resp = self.model.predict(new_samples)
+
+        return resp.ravel().reshape(-1, self.class_n).argmax(1)
+
+
+class SVM(LetterStatModel):
+    def __init__(self):
+        self.model = cv2.ml.SVM_create()
+
+    def train(self, samples, responses):
+        self.model.setType(cv2.ml.SVM_C_SVC)
+        self.model.setC(1)
+        self.model.setKernel(cv2.ml.SVM_RBF)
+        self.model.setGamma(.1)
+        self.model.train(samples, cv2.ml.ROW_SAMPLE, responses.astype(int))
+
+    def predict(self, samples):
+        ret, resp = self.model.predict(samples)
+        return resp.ravel()
+
+
+class MLP(LetterStatModel):
+    def __init__(self):
+        self.model = cv2.ml.ANN_MLP_create()
+
+    def train(self, samples, responses):
+        sample_n, var_n = samples.shape
+        new_responses = self.unroll_responses(responses).reshape(-1, self.class_n)
+        layer_sizes = np.int32([var_n, 100, 100, self.class_n])
+
+        self.model.setLayerSizes(layer_sizes)
+        self.model.setTrainMethod(cv2.ml.ANN_MLP_BACKPROP)
+        self.model.setBackpropMomentumScale(0)
+        self.model.setBackpropWeightScale(0.001)
+        self.model.setTermCriteria((cv2.TERM_CRITERIA_COUNT, 20, 0.01))
+        self.model.setActivationFunction(cv2.ml.ANN_MLP_SIGMOID_SYM, 2, 1)
+
+        self.model.train(samples, cv2.ml.ROW_SAMPLE, np.float32(new_responses))
+
+    def predict(self, samples):
+        ret, resp = self.model.predict(samples)
+        return resp.argmax(-1)
+
+from tests_common import NewOpenCVTests
+
+class letter_recog_test(NewOpenCVTests):
+
+    def test_letter_recog(self):
+
+        eps = 0.01
+
+        models = [RTrees, KNearest, Boost, SVM, MLP]
+        models = dict( [(cls.__name__.lower(), cls) for cls in models] )
+        testErrors = {RTrees: (98.930000, 92.390000), KNearest: (94.960000, 92.010000),
+         Boost: (85.970000, 74.920000), SVM: (99.780000, 95.680000), MLP: (90.060000, 87.410000)}
+
+        for model in models:
+            Model = models[model]
+            classifier = Model()
+
+            samples, responses = load_base(self.repoPath + '/samples/data/letter-recognition.data')
+            train_n = int(len(samples)*classifier.train_ratio)
+
+            classifier.train(samples[:train_n], responses[:train_n])
+            train_rate = np.mean(classifier.predict(samples[:train_n]) == responses[:train_n].astype(int))
+            test_rate  = np.mean(classifier.predict(samples[train_n:]) == responses[train_n:].astype(int))
+
+            self.assertLess(train_rate - testErrors[Model][0], eps)
+            self.assertLess(test_rate - testErrors[Model][1], eps)

modules/python/test/test_peopledetect.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+
+'''
+example to detect upright people in images using HOG features
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2
+
+
+def inside(r, q):
+    rx, ry, rw, rh = r
+    qx, qy, qw, qh = q
+    return rx > qx and ry > qy and rx + rw < qx + qw and ry + rh < qy + qh
+
+def intersectionRate(s1, s2):
+
+    x1, y1, x2, y2 = s1
+    s1 = [[x1, y1], [x2,y1], [x2, y2], [x1, y2] ]
+
+    x1, y1, x2, y2 = s2
+    s2 = [[x1, y1], [x2,y1], [x2, y2], [x1, y2] ]
+    area, intersection = cv2.intersectConvexConvex(np.array(s1), np.array(s2))
+
+    return 2 * area / (cv2.contourArea(np.array(s1)) + cv2.contourArea(np.array(s2)))
+
+from tests_common import NewOpenCVTests
+
+class peopledetect_test(NewOpenCVTests):
+    def test_peopledetect(self):
+
+        hog = cv2.HOGDescriptor()
+        hog.setSVMDetector( cv2.HOGDescriptor_getDefaultPeopleDetector() )
+
+        dirPath = 'samples/data/'
+        samples = ['basketball1.png', 'basketball2.png']
+
+        testPeople = [
+        [[23, 76, 164, 477], [440, 22, 637, 478]],
+        [[23, 76, 164, 477], [440, 22, 637, 478]]
+        ]
+
+        eps = 0.5
+
+        for sample in samples:
+
+            img = self.get_sample(dirPath + sample, 0)
+
+            found, w = hog.detectMultiScale(img, winStride=(8,8), padding=(32,32), scale=1.05)
+            found_filtered = []
+            for ri, r in enumerate(found):
+                for qi, q in enumerate(found):
+                    if ri != qi and inside(r, q):
+                        break
+                else:
+                    found_filtered.append(r)
+
+            matches = 0
+
+            for i in range(len(found_filtered)):
+                for j in range(len(testPeople)):
+
+                    found_rect = (found_filtered[i][0], found_filtered[i][1],
+                        found_filtered[i][0] + found_filtered[i][2],
+                        found_filtered[i][1] + found_filtered[i][3])
+
+                    if intersectionRate(found_rect, testPeople[j][0]) > eps or intersectionRate(found_rect, testPeople[j][1]) > eps:
+                        matches += 1
+
+            self.assertGreater(matches, 0)

modules/python/test/tst_scene_render.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+from numpy import pi, sin, cos
+
+import cv2
+
+defaultSize = 512
+
+class TestSceneRender():
+
+    def __init__(self, bgImg = None, **params):
+        self.time = 0.0
+        self.timeStep = 1.0 / 30.0
+
+        if bgImg != None:
+            self.sceneBg = bgImg.copy()
+        else:
+            self.sceneBg = np.zeros((defaultSize, defaultSize, 3), np.uint8)
+
+        self.w = self.sceneBg.shape[0]
+        self.h = self.sceneBg.shape[1]
+
+        self.initialRect = np.array([ (self.h/2, self.w/2), (self.h/2, self.w/2 + self.w/10),
+         (self.h/2 + self.h/10, self.w/2 + self.w/10), (self.h/2 + self.h/10, self.w/2)])
+        self.currentRect = self.initialRect
+
+    def setInitialRect(self, rect):
+        self.initialRect = rect
+
+    def getCurrentRect(self):
+        x0, y0 = self.currentRect[0]
+        x1, y1 = self.currentRect[2]
+        return np.array([x0, y0, x1, y1])
+
+    def getNextFrame(self):
+        self.time += self.timeStep
+        img = self.sceneBg.copy()
+
+        self.currentRect = self.initialRect + np.int( 30*cos(self.time) + 50*sin(self.time/3))
+        cv2.fillConvexPoly(img, self.currentRect, (0, 0, 255))
+
+        return img
+
+    def resetTime(self):
+        self.time = 0.0
+
+
+if __name__ == '__main__':
+
+    backGr = cv2.imread('../../../samples/data/lena.jpg')
+
+    render = TestSceneRender(backGr)
+
+    while True:
+
+        img = render.getNextFrame()
+        cv2.imshow('img', img)
+
+        ch = 0xFF & cv2.waitKey(3)
+        if  ch == 27:
+            break
+    cv2.destroyAllWindows()

samples/python/letter_recog.py

@@ -95,7 +95,8 @@ class Boost(LetterStatModel):
         new_responses = self.unroll_responses(responses)
         var_types = np.array([cv2.ml.VAR_NUMERICAL] * var_n + [cv2.ml.VAR_CATEGORICAL, cv2.ml.VAR_CATEGORICAL], np.uint8)
 
-        self.model.setMaxDepth(5)
+        self.model.setWeakCount(15)
+        self.model.setMaxDepth(10)
         self.model.train(cv2.ml.TrainData_create(new_samples, cv2.ml.ROW_SAMPLE, new_responses.astype(int), varType = var_types))
 
     def predict(self, samples):
@@ -112,7 +113,8 @@ class SVM(LetterStatModel):
     def train(self, samples, responses):
         self.model.setType(cv2.ml.SVM_C_SVC)
         self.model.setC(1)
-        self.model.setKernel(cv2.ml.SVM_LINEAR)
+        self.model.setKernel(cv2.ml.SVM_RBF)
+        self.model.setGamma(.1)
         self.model.train(samples, cv2.ml.ROW_SAMPLE, responses.astype(int))
 
     def predict(self, samples):
@@ -131,10 +133,10 @@ class MLP(LetterStatModel):
 
         self.model.setLayerSizes(layer_sizes)
         self.model.setTrainMethod(cv2.ml.ANN_MLP_BACKPROP)
-        self.model.setBackpropMomentumScale(0)
+        self.model.setBackpropMomentumScale(0.0)
         self.model.setBackpropWeightScale(0.001)
-        self.model.setTermCriteria((cv2.TERM_CRITERIA_COUNT, 300, 0.01))
-        self.model.setActivationFunction(cv2.ml.ANN_MLP_SIGMOID_SYM)
+        self.model.setTermCriteria((cv2.TERM_CRITERIA_COUNT, 20, 0.01))
+        self.model.setActivationFunction(cv2.ml.ANN_MLP_SIGMOID_SYM, 2, 1)
 
         self.model.train(samples, cv2.ml.ROW_SAMPLE, np.float32(new_responses))