Repo init

Author: Windows

README.md

@@ -1,2 +1,46 @@
 # ObjectTracking_CNN
 A KCF tracker implementation which uses cnn feature as core.
+
+# Inspired
+This project was inspired from [tiago-cerveira/KCF-Tracker-CNN-Features].But change the backend from theano + lasagne to pytorch.And add muti-target tracing function.
+
+# Details
+* Support Muti-Target tracking
+* Support tripwire and restricted zone checking
+* Support CUDA accleration
+* Use PyTorch as cnn backend
+
+[tiago-cerveira/KCF-Tracker-CNN-Features]: https://github.com/tiago-cerveira/KCF-Tracker-CNN-Features
+
+# Requirement
+
+## Runtime
+* Anaconda: Python 3.7.5
+
+## Library Requirement
+
+### From Python pip
+* numpy == any
+* opencv == 3.4.5.20
+
+### From Anaconda 
+* PyTorch == any
+
+### CUDA (Optional)
+* CUDA == 9.1 
+* cuDNN == 9.1
+
+# Useage
+## Run main
+```
+python main.py <path of the video file>
+```
+
+## Use KCFMultiTracker
+```
+tracker = KCFMultiTracker(True, True)
+tracker.init(rois, frist_frame)
+while not_ended:
+    success, result_rois = tracker.update(next_frame)
+    next_frame = get_next_frame()
+```

gui/backend_gui_bridge.py

@@ -0,0 +1,120 @@
+import cv2
+import gui.util.cv_rectutil as cvrect
+import gui.extra_function.area_monitor as amonitor
+import gui.extra_function.structs as structs
+from motion_detect import motion_detector as motdet
+
+white = (255, 255, 255)
+red = (255, 0, 0)
+green = (0, 255, 0)
+blue = (0, 0, 255)
+black = (0, 0, 0)
+
+
+class BackendGuiBridge:
+    def __init__(self, video_path, lines=[], areas=[], draw_trace=True):
+        self._video_cap = cv2.VideoCapture(video_path)
+        self._area_monitor = amonitor.AreaMonitor()
+        self._draw_trace = draw_trace
+        self._current_frame_index = 0
+        self._motion_detector = motdet.MotionDetector()
+        self._log_list = []
+        self._rect_touched_area = 0
+        self._rect_touched_line = 0
+        self._all_frame_rect_centers = []
+        for l in lines:
+            sline = structs.Line()
+            sline.from_cv_line(l)
+            self._area_monitor.add_line(sline)
+        for a in areas:
+            sarea = structs.Rectangle()
+            sarea.from_cv_rect(a)
+            self._area_monitor.add_rect(sarea)
+
+    def __del__(self):
+        self._video_cap.release()
+
+    # add tripwire
+    def add_tripwire(self, line: structs.Line):
+        self._area_monitor.add_line(line)
+
+    # add forbidden area
+    def add_area(self, area: structs.Rectangle):
+        sarea = structs.Rectangle()
+        sarea.from_cv_rect(area)
+        self._area_monitor.add_rect(sarea)
+
+    # print log touched log
+    def _print_line_log(self, rect: structs.Rectangle, line: structs.Line):
+        r = rect.to_cv_rect()
+        p0 = list(line.a_point.to_cv_point())
+        p1 = list(line.b_point.to_cv_point())
+        self._log_list.append(
+            'target ({0},{1},{2},{3}) has touched the line [({4},{5}),({6},{7})]'.format(int(r[0]), int(r[1]),
+                                                                                         int(r[2]), int(r[3]),
+                                                                                         int(p0[0]), int(p0[1]),
+                                                                                         int(p1[0]),
+                                                                                         int(p1[1])))
+
+    # Print area entrance log
+    def _print_area_log(self, rect: structs.Rectangle, area: structs.Rectangle):
+        r = rect.to_cv_rect()
+        a = area.to_cv_rect()
+        self._log_list.append(
+            'target ({0},{1},{2},{3}) has entered the area({4},{5},{6},{7})'.format(int(r[0]), int(r[1]), int(r[2]),
+                                                                                    int(r[3]),
+                                                                                    int(a[0]), int(a[1]), int(a[2]),
+                                                                                    int(a[3])))
+
+    def _draw_area(self, frame):
+        for line in self._area_monitor.get_lines():
+            cvrect.draw_line(frame, line.a_point.to_cv_point(), line.b_point.to_cv_point(), blue)
+        for area in self._area_monitor.get_rects():
+            cvrect.draw_rect(frame, area.to_cv_rect(), blue)
+        return frame
+
+    def _draw_tracking_rects(self, frame, rect_problems=[]):
+        # clear log
+        self._log_list.clear()
+        # check warnings
+        for rect_problem in rect_problems:
+            who = rect_problem.which_rect
+            # tripwire warnings
+            for line in rect_problem.line_touched:
+                self._print_line_log(who, line)
+            # area warnings
+            for area in rect_problem.rect_trespassed:
+                self._print_area_log(who, area)
+            # change different color for different target
+            if len(rect_problem.rect_trespassed) > 0 or len(rect_problem.line_touched) > 0:
+                cvrect.draw_rect(frame, who.to_cv_rect(), red)
+            else:
+                cvrect.draw_rect(frame, who.to_cv_rect(), green)
+        return frame
+
+    # get a pre-processed frame
+    def get_frame(self):
+        success, frame = self._video_cap.read()
+        if success:
+            self._current_frame_index = self._current_frame_index + 1
+            rects = self._motion_detector.detect(frame)
+            if self._draw_trace:
+                self._all_frame_rect_centers.append(self._get_rect_centers(rects))
+            rect_problems = self._area_monitor.check_problems(rects)
+            frame = self._draw_area(frame)
+            frame = self._draw_tracking_rects(frame, rect_problems)
+            if self._draw_trace:
+                frame = self._draw_trace(frame)
+            return success, frame
+        else:
+            return success, None
+
+    def get_logs(self):
+        return self._log_list
+
+    def _get_rect_centers(self, rects=[]):
+        current_frame_center = []
+        for x, y, a, b in rects:
+            center = [x + a / 2, y + b / 2]
+            current_frame_center.append(center)
+        return current_frame_center

gui/extra_function/area_monitor.py

@@ -0,0 +1,40 @@
+import gui.extra_function.structs as models
+import gui.extra_function.intersection_check as icheck
+
+
+class AreaMonitor:
+    def __init__(self):
+        self._lines = []
+        self._rects = []
+
+    def add_line(self, new_line: models.Line):
+        self._lines.append(new_line)
+
+    def get_lines(self):
+        return self._lines
+
+    def add_rect(self, new_rect: models.Rectangle):
+        self._rects.append(new_rect)
+
+    def get_rects(self):
+        return self._rects
+
+    def clear_monitoring_area(self):
+        self._lines = []
+        self._rects = []
+
+    def check_problems(self, tracking_rects=[]):
+        result = []
+        for tracking_rect in tracking_rects:
+            rect_problem = models.RectProblem()
+            rect_problem.which_rect.from_cv_rect(tracking_rect)
+            result.append(rect_problem)
+        for i in range(len(tracking_rects)):
+            for line in self._lines:
+                if icheck.is_line_rect_intersection(line=line, rect=result[i].which_rect):
+                    result[i].line_touched.append(line)
+            for area in self._rects:
+                center = result[i].which_rect.center()
+                if icheck.is_point_in_rect(center, area):
+                    result[i].rect_trespassed.append(area)
+        return result

gui/extra_function/intersection_check.py

@@ -0,0 +1,76 @@
+import gui.extra_function.structs as structs
+
+
+def is_cross(p0: structs.Point, p1: structs.Point, p2: structs.Point):
+    x1 = p1.x - p0.x
+    y1 = p1.y - p0.y
+    x2 = p2.x - p0.x
+    y2 = p2.y - p0.y
+    return x1 * y2 - x2 * y1
+
+
+def is_line_line_intersection(line0: structs.Line, line1: structs.Line):
+    p0 = line0.a_point
+    p1 = line0.b_point
+    p2 = line1.a_point
+    p3 = line1.b_point
+    result = False
+    if (
+            max(p0.x, p1.x) >= min(p2.x, p3.x)
+            and max(p2.x, p3.x) >= min(p0.x, p1.x)
+            and max(p0.y, p1.y) >= min(p2.y, p3.y)
+            and max(p2.y, p3.y) >= min(p0.y, p1.y)
+    ):
+        if (is_cross(p0, p1, p2) * is_cross(p0, p1, p3) <= 0 and is_cross(p2, p3, p0) * is_cross(p2, p3, p1) <= 0):
+            result = True
+
+    return result
+
+
+def is_point_in_rect(point: structs.Point, rect: structs.Rectangle):
+    minx, miny = rect.a_point.to_cv_point()
+    maxx, maxy = rect.c_point.to_cv_point()
+    return (point.x >= minx and point.x <= maxx and point.y >= miny and point.y <= maxy)
+
+
+def is_line_rect_intersection(line: structs.Line, rect: structs.Rectangle):
+    if is_point_in_rect(line.a_point, rect) and is_point_in_rect(line.b_point, rect):
+        return True
+    pa, pb = rect.a_point, rect.c_point
+    line0 = structs.Line()
+    line0.a_point = rect.a_point
+    line0.b_point = rect.d_point
+
+    line1 = structs.Line()
+    line1.a_point = rect.a_point
+    line1.b_point = rect.b_point
+
+    line2 = structs.Line()
+    line2.a_point = rect.b_point
+    line2.b_point = rect.c_point
+
+    line3 = structs.Line()
+    line3.a_point = rect.c_point
+    line3.b_point = rect.d_point
+
+    if is_line_line_intersection(line, line0):
+        return True
+    if is_line_line_intersection(line, line1):
+        return True
+    if is_line_line_intersection(line, line2):
+        return True
+    if is_line_line_intersection(line, line3):
+        return True
+    return False
+
+
+def is_rect_rect_intersection(rect0: structs.Rectangle, rect1: structs.Rectangle):
+    if is_point_in_rect(rect0.a_point, rect1):
+        return True
+    if is_point_in_rect(rect0.b_point, rect1):
+        return True
+    if is_point_in_rect(rect0.c_point, rect1):
+        return True
+    if is_point_in_rect(rect0.d_point, rect1):
+        return True
+    return False

gui/extra_function/structs.py

@@ -0,0 +1,70 @@
+class Point:
+    def __init__(self):
+        self.x = int()
+        self.y = int()
+
+    def from_cv_point(self, cv_point):
+        self.x, self.y = list(cv_point)
+
+    def to_cv_point(self):
+        return (self.x, self.y)
+
+
+'''
+a_point *------* b_point
+        |      |
+        |      |
+        |      |
+d_point *------* c_point
+'''
+
+
+class Rectangle:
+    def __init__(self):
+        self.a_point = Point()
+        self.b_point = Point()
+        self.c_point = Point()
+        self.d_point = Point()
+        self.width = int()
+        self.height = int()
+
+    def center(self):
+        p = Point()
+        p.x = self.a_point.x + self.width / 2
+        p.y = self.a_point.y + self.height / 2
+        return p
+
+    def from_cv_rect(self, cv_rect):
+        x, y, self.width, self.height = cv_rect
+        self.a_point.from_cv_point([x, y])
+        self.b_point.from_cv_point([x + self.width, y])
+        self.c_point.from_cv_point([x + self.width, y + self.height])
+        self.d_point.from_cv_point([x, y + self.height])
+
+    def to_cv_rect(self):
+        return [self.a_point.x, self.a_point.y, self.width, self.height]
+
+
+'''
+a_point *------* b_point
+'''
+
+
+class Line:
+    def __init__(self):
+        self.a_point = Point()
+        self.b_point = Point()
+
+    def from_cv_line(self, line):
+        self.a_point.from_cv_point(line[0])
+        self.b_point.from_cv_point(line[1])
+
+    def to_cv_line(self):
+        return [self.a_point.to_cv_point(), self.a_point.to_cv_point()]
+
+
+class RectProblem:
+    def __init__(self):
+        self.which_rect = Rectangle()
+        self.line_touched = []
+        self.rect_trespassed = []