1#!/usr/bin/env python
2
3'''
4Feature homography
5==================
6
7Example of using features2d framework for interactive video homography matching.
8ORB features and FLANN matcher are used. The actual tracking is implemented by
9PlaneTracker class in plane_tracker.py
10'''
11
12# Python 2/3 compatibility
13from __future__ import print_function
14
15import numpy as np
16import cv2 as cv
17import sys
18PY3 = sys.version_info[0] == 3
19
20if PY3:
21    xrange = range
22
23# local modules
24from tst_scene_render import TestSceneRender
25
26def intersectionRate(s1, s2):
27
28    x1, y1, x2, y2 = s1
29    s1 = np.array([[x1, y1], [x2,y1], [x2, y2], [x1, y2]])
30
31    area, _intersection = cv.intersectConvexConvex(s1, np.array(s2))
32    return 2 * area / (cv.contourArea(s1) + cv.contourArea(np.array(s2)))
33
34from tests_common import NewOpenCVTests
35
36class feature_homography_test(NewOpenCVTests):
37
38    render = None
39    tracker = None
40    framesCounter = 0
41    frame = None
42
43    def test_feature_homography(self):
44
45        self.render = TestSceneRender(self.get_sample('samples/data/graf1.png'),
46            self.get_sample('samples/data/box.png'), noise = 0.5, speed = 0.5)
47        self.frame = self.render.getNextFrame()
48        self.tracker = PlaneTracker()
49        self.tracker.clear()
50        self.tracker.add_target(self.frame, self.render.getCurrentRect())
51
52        while self.framesCounter < 100:
53            self.framesCounter += 1
54            tracked = self.tracker.track(self.frame)
55            if len(tracked) > 0:
56                tracked = tracked[0]
57                self.assertGreater(intersectionRate(self.render.getCurrentRect(), np.int32(tracked.quad)), 0.6)
58            else:
59                self.assertEqual(0, 1, 'Tracking error')
60            self.frame = self.render.getNextFrame()
61
62
63# built-in modules
64from collections import namedtuple
65
66FLANN_INDEX_KDTREE = 1
67FLANN_INDEX_LSH    = 6
68flann_params= dict(algorithm = FLANN_INDEX_LSH,
69                   table_number = 6, # 12
70                   key_size = 12,     # 20
71                   multi_probe_level = 1) #2
72
73MIN_MATCH_COUNT = 10
74
75'''
76  image     - image to track
77  rect      - tracked rectangle (x1, y1, x2, y2)
78  keypoints - keypoints detected inside rect
79  descrs    - their descriptors
80  data      - some user-provided data
81'''
82PlanarTarget = namedtuple('PlaneTarget', 'image, rect, keypoints, descrs, data')
83
84'''
85  target - reference to PlanarTarget
86  p0     - matched points coords in target image
87  p1     - matched points coords in input frame
88  H      - homography matrix from p0 to p1
89  quad   - target boundary quad in input frame
90'''
91TrackedTarget = namedtuple('TrackedTarget', 'target, p0, p1, H, quad')
92
93class PlaneTracker:
94    def __init__(self):
95        self.detector = cv.AKAZE_create(threshold = 0.003)
96        self.matcher = cv.FlannBasedMatcher(flann_params, {})  # bug : need to pass empty dict (#1329)
97        self.targets = []
98        self.frame_points = []
99
100    def add_target(self, image, rect, data=None):
101        '''Add a new tracking target.'''
102        x0, y0, x1, y1 = rect
103        raw_points, raw_descrs = self.detect_features(image)
104        points, descs = [], []
105        for kp, desc in zip(raw_points, raw_descrs):
106            x, y = kp.pt
107            if x0 <= x <= x1 and y0 <= y <= y1:
108                points.append(kp)
109                descs.append(desc)
110        descs = np.uint8(descs)
111        self.matcher.add([descs])
112        target = PlanarTarget(image = image, rect=rect, keypoints = points, descrs=descs, data=data)
113        self.targets.append(target)
114
115    def clear(self):
116        '''Remove all targets'''
117        self.targets = []
118        self.matcher.clear()
119
120    def track(self, frame):
121        '''Returns a list of detected TrackedTarget objects'''
122        self.frame_points, frame_descrs = self.detect_features(frame)
123        if len(self.frame_points) < MIN_MATCH_COUNT:
124            return []
125        matches = self.matcher.knnMatch(frame_descrs, k = 2)
126        matches = [m[0] for m in matches if len(m) == 2 and m[0].distance < m[1].distance * 0.75]
127        if len(matches) < MIN_MATCH_COUNT:
128            return []
129        matches_by_id = [[] for _ in xrange(len(self.targets))]
130        for m in matches:
131            matches_by_id[m.imgIdx].append(m)
132        tracked = []
133        for imgIdx, matches in enumerate(matches_by_id):
134            if len(matches) < MIN_MATCH_COUNT:
135                continue
136            target = self.targets[imgIdx]
137            p0 = [target.keypoints[m.trainIdx].pt for m in matches]
138            p1 = [self.frame_points[m.queryIdx].pt for m in matches]
139            p0, p1 = np.float32((p0, p1))
140            H, status = cv.findHomography(p0, p1, cv.RANSAC, 3.0)
141            status = status.ravel() != 0
142            if status.sum() < MIN_MATCH_COUNT:
143                continue
144            p0, p1 = p0[status], p1[status]
145
146            x0, y0, x1, y1 = target.rect
147            quad = np.float32([[x0, y0], [x1, y0], [x1, y1], [x0, y1]])
148            quad = cv.perspectiveTransform(quad.reshape(1, -1, 2), H).reshape(-1, 2)
149
150            track = TrackedTarget(target=target, p0=p0, p1=p1, H=H, quad=quad)
151            tracked.append(track)
152        tracked.sort(key = lambda t: len(t.p0), reverse=True)
153        return tracked
154
155    def detect_features(self, frame):
156        '''detect_features(self, frame) -> keypoints, descrs'''
157        keypoints, descrs = self.detector.detectAndCompute(frame, None)
158        if descrs is None:  # detectAndCompute returns descs=None if no keypoints found
159            descrs = []
160        return keypoints, descrs
161
162
163if __name__ == '__main__':
164    NewOpenCVTests.bootstrap()
165