Merge pull request #2180 from Killer2OP/Parking

[ADDED]: Parking Space Detection System

Author: avinashkranjan

Parking Space Detection System/README.md

@@ -0,0 +1,19 @@
+# OVERVIEW
+Finding parking space for your vehicle is a major problem in big cities. The rise of car ownership has created an imbalance between parking demand and supply. In the current situation, a parking management system that can track parking spots has become a necessity for all major cities. The system has to be scalable, efficient, reliable, and affordable at the same time. In recent years, the advances in deep learning powered computer vision algorithms have shown very promising results in a variety of tasks. Similar techniques can be used to address the problem of parking space detection.
+
+how to build a simple parking space detection system using deep learning. Let's get straight to the business. We will break down our pipeline into three major components:
+
+- Detection of parking spots.
+- Detection of cars.
+- Calculate IoU.
+
+![Diagram](image.png)
+
+On each frame of the input video, we will first use the Mask-RCNN object detection model to detect the cars and their bounding boxes. After getting the bounding boxes from the Mask-RCNN, we will compute the Intersection over Union (IoU) on each pair of the bounding boxes and parking spot coordinates. If the IoU value for any parking spot is greater than a certain threshold, we will consider that parking spot as occupied.
+
+## Dependencies
+- Python 3.6
+- Tensorflow ≥1.3.0
+- OpenCV
+- Matplotlib
+- Shapely

Parking Space Detection System/detector.py

@@ -0,0 +1,140 @@
+import argparse
+import cv2
+import numpy as np
+import pickle
+from pathlib import Path
+from shapely.geometry import Polygon as shapely_poly
+from mrcnn.model import MaskRCNN
+import mrcnn.utils
+import mrcnn.config
+import os
+import sys
+import time
+
+
+class Config(mrcnn.config.Config):
+    NAME = "model_config"
+    IMAGES_PER_GPU = 1
+    GPU_COUNT = 1
+    NUM_CLASSES = 81
+
+
+def download_model_weights(model_path):
+    if not os.path.exists(model_path):
+        print("Downloading pre-trained weights...")
+        mrcnn.utils.download_trained_weights(model_path)
+
+
+def load_parking_regions(regions_path):
+    regions_file = Path(regions_path)
+    if regions_file.exists():
+        with open(regions_file, 'rb') as f:
+            parked_car_boxes = pickle.load(f)
+            return parked_car_boxes
+    else:
+        print("Error: Could not find the regions file.")
+        sys.exit(1)
+
+
+def get_car_boxes(boxes, class_ids):
+    cars = []
+    for i, box in enumerate(boxes):
+        if class_ids[i] in [3, 8, 6]:
+            cars.append(box)
+    return np.array(cars)
+
+
+def compute_overlaps(parked_car_boxes, car_boxes):
+    new_car_boxes = []
+    for box in car_boxes:
+        y1, x1, y2, x2 = box
+        p1 = (x1, y1)
+        p2 = (x2, y1)
+        p3 = (x2, y2)
+        p4 = (x1, y2)
+        new_car_boxes.append([p1, p2, p3, p4])
+
+    overlaps = np.zeros((len(parked_car_boxes), len(new_car_boxes)))
+    for i, park_area in enumerate(parked_car_boxes):
+        for j, car_box in enumerate(new_car_boxes):
+            polygon1_shape = shapely_poly(park_area)
+            polygon2_shape = shapely_poly(car_box)
+
+            polygon_intersection = polygon1_shape.intersection(polygon2_shape).area
+            polygon_union = polygon1_shape.union(polygon2_shape).area
+            iou = polygon_intersection / polygon_union
+            overlaps[i][j] = iou
+
+    return overlaps
+
+
+def draw_parking_area(frame, parking_area, color=(71, 27, 92), thickness=2):
+    cv2.drawContours(frame, [np.array(parking_area)], contourIdx=-1, color=color, thickness=thickness)
+
+
+def draw_overlay(frame, overlay, alpha):
+    cv2.addWeighted(overlay, alpha, frame, 1 - alpha, 0, frame)
+
+
+def process_video(video_path, regions_path, output_path):
+    parked_car_boxes = load_parking_regions(regions_path)
+
+    config = Config()
+    model = MaskRCNN(mode="inference", model_dir=model_dir, config=config)
+    model_path = os.path.join(model_dir, "mask_rcnn_coco.h5")
+    download_model_weights(model_path)
+    model.load_weights(model_path, by_name=True)
+
+    alpha = 0.6
+    video_capture = cv2.VideoCapture(video_path)
+    video_FourCC = cv2.VideoWriter_fourcc(*'XVID')
+    video_fps = video_capture.get(cv2.CAP_PROP_FPS)
+    video_size = (int(video_capture.get(cv2.CAP_PROP_FRAME_WIDTH)), int(video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT)))
+    out = cv2.VideoWriter(output_path, video_FourCC, video_fps, video_size)
+
+    while video_capture.isOpened():
+        success, frame = video_capture.read()
+        if not success:
+            break
+
+        start_time = time.time()
+        rgb_image = frame[:, :, ::-1]
+        results = model.detect([rgb_image], verbose=0)
+        inference_time = time.time() - start_time
+
+        cars = get_car_boxes(results[0]['rois'], results[0]['class_ids'])
+        overlaps = compute_overlaps(parked_car_boxes, cars)
+
+        overlay = frame.copy()
+
+        for park_area, overlap_areas in zip(parked_car_boxes, overlaps):
+            max_iou_overlap = np.max(overlap_areas)
+            if max_iou_overlap < 0.15:
+                draw_parking_area(overlay, park_area)
+
+        draw_overlay(frame, overlay, alpha)
+        cv2.putText(frame, f"Inference Time: {inference_time:.2f}s", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+
+        cv2.imshow('Parking Space Detection', frame)
+        out.write(frame)
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+
+    video_capture.release()
+    out.release()
+    cv2.destroyAllWindows()
+    print("Output saved as", output_path)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('video_path', help="Video file")
+    parser.add_argument('regions_path', help="Regions file")
+    parser.add_argument('--output', '-o', help="Output file", default="output.avi")
+    args = parser.parse_args()
+
+    video_path = args.video_path
+    regions_path = args.regions_path
+    output_path = args.output
+
+    process_video(video_path, regions_path, output_path)

Parking Space Detection System/image.png

@@ -0,0 +1,8 @@
+scikit-image
+tensorflow==1.15.2
+keras>=2.0.8
+opencv-python
+matplotlib
+numpy
+gitpython
+shapely

Parking Space Detection System/requirements.txt

@@ -0,0 +1,112 @@
+import os
+import numpy as np
+import cv2
+import pickle
+import argparse
+import matplotlib.pyplot as plt
+from matplotlib.patches import Polygon
+from matplotlib.widgets import PolygonSelector
+from matplotlib.collections import PatchCollection
+from shapely.geometry import box
+from shapely.geometry import Polygon as shapely_poly
+
+points = []
+prev_points = []
+patches = []
+total_points = []
+breaker = False
+
+
+class SelectFromCollection(object):
+    def __init__(self, ax):
+        self.canvas = ax.figure.canvas
+
+        self.poly = PolygonSelector(ax, self.onselect)
+        self.ind = []
+
+    def onselect(self, verts):
+        global points
+        points = verts
+        self.canvas.draw_idle()
+
+    def disconnect(self):
+        self.poly.disconnect_events()
+        self.canvas.draw_idle()
+
+
+def break_loop(event):
+    global breaker
+    global globSelect
+    global savePath
+    if event.key == 'b':
+        globSelect.disconnect()
+        if os.path.exists(savePath):
+            os.remove(savePath)
+
+        print("Data saved in " + savePath + " file")
+        with open(savePath, 'wb') as f:
+            pickle.dump(total_points, f, protocol=pickle.HIGHEST_PROTOCOL)
+        exit()
+
+
+def onkeypress(event):
+    global points, prev_points, total_points
+    if event.key == 'n':
+        pts = np.array(points, dtype=np.int32)
+        if points != prev_points and len(set(points)) == 4:
+            print("Points: " + str(pts))
+            patches.append(Polygon(pts))
+            total_points.append(pts)
+            prev_points = points
+
+
+def process_video(video_path, out_file):
+    global globSelect
+    global savePath
+    savePath = out_file if out_file.endswith(".p") else out_file + ".p"
+
+    print("\n> Select a region in the figure by enclosing it within a quadrilateral.")
+    print("> Press the 'f' key to go full screen.")
+    print("> Press the 'esc' key to discard the current quadrilateral.")
+    print("> Try holding the 'shift' key to move all of the vertices.")
+    print("> Try holding the 'ctrl' key to move a single vertex.")
+    print("> After marking a quadrilateral, press 'n' to save the current quadrilateral, and then press 'q' to start marking a new quadrilateral.")
+    print("> When you are done, press 'b' to exit the program.\n")
+
+    video_capture = cv2.VideoCapture(video_path)
+    cnt = 0
+    rgb_image = None
+    while video_capture.isOpened():
+        success, frame = video_capture.read()
+        if not success:
+            break
+        if cnt == 5:
+            rgb_image = frame[:, :, ::-1]
+        cnt += 1
+    video_capture.release()
+
+    fig, ax = plt.subplots()
+    image = rgb_image
+    ax.imshow(image)
+
+    p = PatchCollection(patches, alpha=0.7)
+    p.set_array(10 * np.ones(len(patches)))
+    ax.add_collection(p)
+
+    globSelect = SelectFromCollection(ax)
+    bbox = plt.connect('key_press_event', onkeypress)
+    break_event = plt.connect('key_press_event', break_loop)
+    plt.show()
+    globSelect.disconnect()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('video_path', help="Path of the video file")
+    parser.add_argument('--out_file', help="Name of the output file", default="regions.p")
+    args = parser.parse_args()
+
+    video_path = args.video_path
+    out_file = args.out_file
+
+    process_video(video_path, out_file)