Merge pull request #147 from masouduut94/master

Handled some errors in web server

Author: masouduut94

webserver/.env

@@ -1,5 +1,4 @@
-project_root="/home/user/codes/MSD/ZQ_pedestrian/"
-py_dir="/home/user/anaconda3/envs/pedestrian_detection_environment/bin/python"
+project_root="C:\Users\ZQ_deep_sort_pytorch"
 model_type="yolov3"
 output_dir="public/"
 json_output="json_output/" # ignored for the moment in ped_det_online_server.py

webserver/config/config.py

@@ -5,8 +5,7 @@
 
 class BaseConfig:
     SECRET_KEY = os.environ.get('SECRET_KEY') or 'Sm9obiBTY2hyb20ga2lja3MgYXNz'
-    SERVER_NAME = '111.222.333.444:8888'
-    # PORT = 8888
+    SERVER_NAME = '127.0.0.1:8888'
 
 
 class DevelopmentConfig(BaseConfig):

webserver/images/Thumbs.db

@@ -9,25 +9,37 @@
 - pytorch
 - dotenv
 
+Please note that you need to install redis on your system.
 
 ### The architecture.
 
 ![web server architecture](images/arc.png)
 
 1 - `RealTimeTracking` reads frames from rtsp link using threads 
-(threads make it robust against network packet loss) 
+(Using threads make the web server robust against network packet loss) 
 
 2 - In `RealTimeTracking.run` function in each iteration frame is stored in redis cache on server.
 
 3 - Now we can serve the frames on redis to clients.
 
 4 - To start the pedestrian detection, after running 
-`rtsp_webserver.py`, go to `111.222.333.444:8888/start`
-on browser(which is configured in `config/config.py` as
- base url) to start the pedestrian_detection service.
+`rtsp_webserver.py`, send a GET request on `127.0.0.1:8888/run`
+with setting these GET method parameters
 
-5 - watch pedestrian detection stream in `111.222.333.444:8888`
+| Param | Value | Description |
+| :-------------: | :-------------: | :-------------: |
+| run  | 1/0  |  to start the tracking set 1/ to stop tracking service set it as 0|
+| camera_stream  | 'rtsp://ip:port/admin...'  | provide it with valid rtsp link |
 
-6 - To stop the service open browser and go to 
-`111.222.333.444:8888/stop`.
+for example:
 
+    (to start the service)  127.0.0.1:8888/run?run=1
+    (to stop the service)  127.0.0.1:8888/run?run=0
+    (to change the camera) 
+        1- 127.0.0.1:8888/run?run=0 (first stop the current service)
+        2- 127.0.0.1:8888/run?run=0&camera_stream=rtsp://ip:port/admin... (then start it with another rtsp link)
+    
+![web server architecture](images/request.png)
+
+
+5 - get pedestrian detection stream in `127.0.0.1:8888`

webserver/images/request.png

@@ -1,3 +1,4 @@
+import warnings
 from os import getenv
 import sys
 from os.path import dirname, abspath
@@ -12,7 +13,7 @@
 from concurrent.futures import ThreadPoolExecutor
 from redis import Redis
 
-redis_cache = Redis('111.222.333.444')
+redis_cache = Redis('127.0.0.1')
 
 
 class RealTimeTracking(object):
@@ -34,7 +35,7 @@ def __init__(self, cfg, args):
         use_cuda = self.args.use_cuda and torch.cuda.is_available()
 
         if not use_cuda:
-            raise UserWarning("Running in cpu mode!")
+            warnings.warn(UserWarning("Running in cpu mode!"))
 
         self.detector = build_detector(cfg, use_cuda=use_cuda)
         self.deepsort = build_tracker(cfg, use_cuda=use_cuda)
@@ -50,22 +51,24 @@ def __init__(self, cfg, args):
 
         self.thread = ThreadPoolExecutor(max_workers=1)
         self.thread.submit(self.update)
-        print('streaming started ...')
 
     def update(self):
         while True:
             if self.vdo.isOpened():
                 (self.status, self.frame) = self.vdo.read()
 
     def run(self):
-        while getenv('tracking') != 'off':
+        print('streaming started ...')
+        while getenv('in_progress') != 'off':
             try:
                 frame = self.frame.copy()
                 self.detection(frame=frame)
                 frame_to_bytes = cv2.imencode('.jpg', frame)[1].tobytes()
                 redis_cache.set('frame', frame_to_bytes)
             except AttributeError:
                 pass
+        print('streaming stopped ...')
+
 
     def detection(self, frame):
         im = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

webserver/readme.md

@@ -1,16 +1,10 @@
 """
-Main flask application
-
-# Reference for start/stop trick:
-    https://stackoverflow.com/questions/49821707/starting-and-stopping-a-method-using-flask-routes-python
 
 # TODO: Load ML model with redis and keep it for sometime.
     1- detector/yolov3/detector.py |=> yolov3 weightfile -> redis cache
     2- deepsort/deep/feature_extractor |=> model_path -> redis cache
     3- Use tmpfs (Insert RAM as a virtual disk and store model state): https://pypi.org/project/memory-tempfile/
 
-# TODO: Automatic turn off or switch between the cameras in ML model part.
-# TODO: send rtsp url to the ML model part and run the model for that camera.
 """
 from os.path import join
 from os import getenv, environ
@@ -19,16 +13,16 @@
 from threading import Thread
 
 from redis import Redis
-from flask import Response, Flask, jsonify
+from flask import Response, Flask, jsonify, request, abort
 
 from rtsp_threaded_tracker import RealTimeTracking
 from server_cfg import model, deep_sort_dict
 from config.config import DevelopmentConfig
 from utils.parser import get_config
 
-redis_cache = Redis('111.222.333.444')
+redis_cache = Redis('127.0.0.1')
 app = Flask(__name__)
-environ['tracking'] = 'off'
+environ['in_progress'] = 'off'
 
 
 def parse_args():
@@ -59,39 +53,101 @@ def parse_args():
 
 
 def gen():
+    """
+
+    Returns: video frames from redis cache
+
+    """
     while True:
         frame = redis_cache.get('frame')
         if frame is not None:
             yield b'--frame\r\n'b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n'
 
+
 def pedestrian_tracking(cfg, args):
+    """
+    starts the pedestrian detection on rtsp link
+    Args:
+        cfg:
+        args:
+
+    Returns:
+
+    """
     tracker = RealTimeTracking(cfg, args)
     tracker.run()
 
+
 def trigger_process(cfg, args):
-    t = Thread(target=pedestrian_tracking, args=(cfg, args))
-    t.start()
-    return jsonify({"msg": "Pedestrian detection started successfully"})
+    """
+    triggers pedestrian_tracking process on rtsp link using a thread
+    Args:
+        cfg:
+        args:
+
+    Returns:
+    """
+    try:
+        t = Thread(target=pedestrian_tracking, args=(cfg, args))
+        t.start()
+        return jsonify({"message": "Pedestrian detection started successfully"})
+    except Exception:
+        return jsonify({'message': "Unexpected exception occured in process"})
+
+
+@app.errorhandler(400)
+def bad_argument(error):
+    return jsonify({'message': error.description['message']})
+
 
 # Routes
-@app.route('/')
-def video_feed():
+@app.route('/stream', methods=['GET'])
+def stream():
+    """
+    Provides video frames on http link
+    Returns:
+
+    """
     return Response(gen(),
                     mimetype='multipart/x-mixed-replace; boundary=frame')
 
-@app.route("/start", methods=['GET'])
-def start_tracking():
-    if environ['tracking'] != 'on':
-        global cfg, args
-        environ['tracking'] = 'on'
-        return Response(trigger_process(cfg, args), mimetype="text/html")
-    else:
-        return jsonify({"msg": " Pedestrian detection is already in progress."})
-
-@app.route("/stop", methods=['GET'])
-def stop_tracking():
-    environ['tracking'] = 'off'
-    return jsonify({"msg": "Pedestrian detection terminated!"})
+
+@app.route("/run", methods=['GET'])
+def process_manager():
+    """
+    request parameters:
+    run (bool): 1  -> start the pedestrian tracking
+                0  -> stop it
+    camera_stream: str -> rtsp link to security camera
+
+    :return:
+    """
+    # data = request.args
+    data = request.args
+    status = data['run']
+    status = int(status) if status.isnumeric() else abort(400, {'message': f"bad argument for run {data['run']}"})
+    if status == 1:
+        # if pedestrian tracking is not running, start it off!
+        try:
+            if environ.get('in_progress', 'off') == 'off':
+                global cfg, args
+                vdo = data.get('camera_stream')
+                if vdo is not None:
+                    args.input = int(vdo)
+                environ['in_progress'] = 'on'
+                return trigger_process(cfg, args)
+            elif environ.get('in_progress') == 'on':
+                # if pedestrian tracking is running, don't start another one (we are short of gpu resources)
+                return jsonify({"message": " Pedestrian detection is already in progress."})
+        except Exception:
+            environ['in_progress'] = 'off'
+            return abort(503)
+    elif status == 0:
+        if environ.get('in_progress', 'off') == 'off':
+            return jsonify({"message": "pedestrian detection is already terminated!"})
+        else:
+            environ['in_progress'] = 'off'
+            return jsonify({"message": "Pedestrian detection terminated!"})
 
 
 if __name__ == '__main__':