Auto stash before merge of "efe" and "origin/yigit"

traffic_analyzer/ambulance_detect.py

@@ -1,31 +1,25 @@
 #!/usr/bin/python3
 
+import pickle
+import threading
 import numpy as np
 import os
 import sys
 import tensorflow as tf
 import cv2
 from distutils.version import StrictVersion
-import socket
 from utils import label_map_util
 
 from utils import visualization_utils as vis_util
-import psutil
 import json
 
 import base64
 from PIL import Image
 from io import BytesIO
-import psutil
 
 switch = 1
 
-import io
 import socket
-import struct
-import time
-import pickle
-import zlib
 
 # This is needed since the notebook is stored in the object_detection folder.
 sys.path.append("..")
@@ -40,9 +34,9 @@ if StrictVersion(tf.__version__) < StrictVersion('1.12.0'):
 
 encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90]
 
-MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17' #not even worth trying
-#MODEL_NAME="ssd_inception_v2_coco_11_06_2017" # not bad and fast
-#MODEL_NAME="rfcn_resnet101_coco_11_06_2017" # WORKS BEST BUT takes 4 times longer per image
+#MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17' #not even worth trying
+#MODEL_NAME = "ssd_inception_v2_coco_2017_11_17" # not bad and fast
+MODEL_NAME = "rfcn_resnet101_coco_11_06_2017" # WORKS BEST BUT takes 4 times longer per image
 #MODEL_NAME = "faster_rcnn_resnet101_coco_11_06_2017" # too slow
 MODEL_FILE = MODEL_NAME + '.tar.gz'
 DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'
@@ -60,14 +54,14 @@ with detection_graph.as_default():
     serialized_graph = fid.read()
     od_graph_def.ParseFromString(serialized_graph)
     tf.import_graph_def(od_graph_def, name='')
-    
+
 category_index = label_map_util.create_category_index_from_labelmap(PATH_TO_LABELS, use_display_name=True)
 
 def load_image_into_numpy_array(image):
   (im_width, im_height) = image.size
   return np.array(image.getdata()).reshape(
       (im_height, im_width, 3)).astype(np.uint8)
-      
+
 # For the sake of simplicity we will use only 2 images:
 # image1.jpg
 # image2.jpg
@@ -82,11 +76,7 @@ data = {"gpu_temp":"10C","gpu_load":"15%","cpu_temp":"47C","cpu_load":"15%","mem
 
 def get_temps():
     global data
-    temps = psutil.sensors_temperatures()
-    data["cpu_temp"] = str(int(temps["dell_smm"][0][1]))+"°C"
-    data["cpu_load"] = str(psutil.cpu_percent())+"%"
-    data["mem_load"] = str(dict(psutil.virtual_memory()._asdict())["percent"])+"%"
-    data["fan_speed"] = str(psutil.sensors_fans()["dell_smm"][0][1])+"RPM"
+
 
 def run_inference_for_single_image(image, graph):
   global switch
@@ -135,82 +125,141 @@ def run_inference_for_single_image(image, graph):
     if 'detection_masks' in output_dict:
       output_dict['detection_masks'] = output_dict['detection_masks'][0]
 
-
   return output_dict
-cut=[-175,-1,-175,-1]
-cut_send = [0,0,0,0]
-a = 1
+
+kill = True
+
+def listener(port=8385):
+    serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    serversocket.bind((socket.gethostname(), port))
+    serversocket.listen(5)
+    while kill:
+        serversocket.accept()
+
+    print('Bye!')
+
+
+cut = [115, 100, 400, 150]
+cut_send = [0, 0, 0, 0]
 img_counter = 0
 socket_switch = True
-cam = cv2.VideoCapture(0)
+dont_send = False
+#cam = cv2.VideoCapture(0)
+cam = cv2.VideoCapture('amb_1.mp4')
+thread = threading.Thread(target=listener)
+thread.start()
 with detection_graph.as_default():
     sess = tf.Session()
 switch = 0
 get_temps()
+amb_center = {'x': (400 + 550)/2, 'y': (115+215)/2}
+a = 1
+# frame_data = []
 while 1:
-    if(True):
+    a += 1
+    ret, image = cam.read()
+    if a % 10 != 0:
+        continue
+    try:  # Kavşak
+        t1 = time.time()
+        image_np = image
+        image_np_expanded = np.expand_dims(image_np, axis=0)
+        output_dict = run_inference_for_single_image(image_np_expanded, detection_graph)
+        height, width, channels = image_np.shape
+        # frame_data.append(output_dict)
+
+        out_dict = {'detection_boxes': [], 'detection_classes': [], 'detection_scores': []}
+        for i in output_dict['detection_classes']:
+            cont = False
+            if i in [3, 6, 8]:  # Car, bus, truck
+                index = np.where(output_dict['detection_classes'] == i)[0][0]
+                score = output_dict['detection_scores'][index]
+                if score > 0.3:
+                    if not any((output_dict['detection_boxes'][index] == b).all() for b in out_dict['detection_boxes']):
+                        avg_x = (output_dict['detection_boxes'][index][0] + output_dict['detection_boxes'][index][2])/2
+                        avg_y = (output_dict['detection_boxes'][index][1] + output_dict['detection_boxes'][index][3])/2
+                        for box in out_dict['detection_boxes']:
+                            avg_box_x = (box[0] + box[2])/2
+                            avg_box_y = (box[1] + box[3])/2
+                            if abs(avg_x-avg_box_x) < 0.1 and abs(avg_y-avg_box_y) < 0.1:
+                                cont = True
+                                continue
+
+                        if cont:
+                            continue
+                        out_dict['detection_classes'].append(i)
+                        out_dict['detection_boxes'].append(output_dict['detection_boxes'][index])
+                        out_dict['detection_scores'].append(output_dict['detection_scores'][index])
+
+        out_dict['detection_classes'] = np.array(out_dict['detection_classes'])
+        out_dict['detection_boxes'] = np.array(out_dict['detection_boxes'])
+        out_dict['detection_scores'] = np.array(out_dict['detection_scores'])
+        for i in out_dict['detection_boxes']:
+            (left, right, top, bottom) = (i[1] * width, i[3] * width,
+                                          i[0] * height, i[2] * height)
+            if abs(((left + right)/2) - amb_center['x']) < 15 and abs(((top + bottom)/2) - amb_center['y']) < 15:
+                print('Ambulance found!')
+
+        print(len(out_dict['detection_classes']), ' cars.')
+        vis_util.visualize_boxes_and_labels_on_image_array(
+            image_np,
+            out_dict['detection_boxes'],
+            out_dict['detection_classes'],
+            out_dict['detection_scores'],
+            category_index,
+            instance_masks=out_dict.get('detection_masks'),
+            use_normalized_coordinates=True,
+            line_thickness=8,
+            min_score_thresh=0.3
+        )
+        cv2.imshow('frame', image_np)
+        ex_c = [27, ord("q"), ord("Q")]
+        if cv2.waitKey(1) & 0xFF in ex_c:
+            break
+
+        t2 = time.time()
+        print("time taken for {}".format(t2-t1))
+        if dont_send:
+            continue
+        send_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        if socket_switch:
+            try:
+                client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                client_socket.connect(('192.168.1.36', 8485))
+                connection = client_socket.makefile('wb')
+                socket_switch = False
+            except:
+                socket_switch = True
+                continue
         try:
-            ret,image = cam.read()
-            image_np = image[cut[0]:cut[1],cut[2]:cut[3]]
-            #image_np = image_np[int(r[1]):int(r[1]+r[3]),int(r[0]):int(r[0]+r[2])]
-            # the array based representation of the image will be used later in order to prepare the
-            # result image with boxes and labels on it.
-
-            # Expand dimensions since the model expects images to have shape: [1, None, None, 3]
-            image_np_expanded = np.expand_dims(image_np, axis=0)
-            t1 = time.time()
-            # Actual detection.
-            output_dict = run_inference_for_single_image(image_np_expanded, detection_graph)
-            # Visualization of the results of a detection.
-            vis_util.visualize_boxes_and_labels_on_image_array(
-                image_np,
-                output_dict['detection_boxes'],
-                output_dict['detection_classes'],
-                output_dict['detection_scores'],
-                category_index,
-                instance_masks=output_dict.get('detection_masks'),
-                use_normalized_coordinates=True,
-                line_thickness=8)
-            image[cut[0]:cut[1],cut[2]:cut[3]] = image_np
-            send_image = cv2.cvtColor(image,cv2.COLOR_BGR2RGB)
-            cv2.imshow("Cam",image)
-            cv2.imshow("Cut",image_np)
-
-            if socket_switch:
-                try:
-                    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                    client_socket.connect(('127.0.0.1', 8485))
-                    connection = client_socket.makefile('wb')
-                    socket_switch = False
-                except:
-                    socket_switch=True
-                    continue
-                try:
-                    crop_img = send_image.copy(order='C')
-
-                    crop_img = Image.fromarray(crop_img,"RGB")
-                    buffered = BytesIO()
-                    crop_img.save(buffered, format="JPEG")
-                    img = base64.b64encode(buffered.getvalue()).decode("ascii")
-                    client_socket.sendall(json.dumps({"image_full":img,"image_sizes":{"x":cut_send[2],"y":cut_send[0],"width":cut_send[3],"height":cut_send[1]},"load":data}).encode('gbk')+b"\n")
-                    img_counter += 1
-
-                except:
-                    socket_switch=True
-
-            if img_counter % 10 ==0:
-                get_temps()
-            t2 = time.time()
-            print("time taken for {}".format(t2-t1))
-
-            ex_c = [27, ord("q"), ord("Q")]
-            if cv2.waitKey(1) & 0xFF in ex_c:
-                break
-        except KeyboardInterrupt:
-            if not socket_switch:
-                client_socket.sendall(b"Bye\n")
-                cam.release()
-                exit(0)
+            crop_img = send_image.copy(order='C')
+            crop_img = Image.fromarray(crop_img, "RGB")
+            buffered = BytesIO()
+            crop_img.save(buffered, format="JPEG")
+            img = base64.b64encode(buffered.getvalue()).decode("ascii")
+            lens = [len(send_image), 0, len(send_image[0])]
+            for i in range(0,len(cut), 2):
+                if cut[i] < 0:
+                    cut_send[i] = lens[i] + cut[i]
+                cut_send[i+1] = abs(cut[i])-abs(cut[i+1])
+            client_socket.sendall(json.dumps({"image_full":img,"image_sizes":{"x":cut_send[2],"y":cut_send[0],"width":cut_send[3],"height":cut_send[1]},"load":data}).encode('gbk')+b"\n")
+            img_counter += 1
+        except:
+            socket_switch = True
+
+        if img_counter % 10 == 0:
+            get_temps()
+    except Exception as e:
+        print(e)
+        break
+
+if not socket_switch:
+    client_socket.sendall(b"Bye\n")
+    cam.release()
 
+# with open('frame_data.pkl', 'wb') as f:
+#    pickle.dump(frame_data, f)
 cv2.destroyAllWindows()
 cam.release()
+kill = False
+thread.join()

traffic_analyzer/sender.py

@@ -5,10 +5,27 @@ import base64
 from PIL import Image
 from io import BytesIO
 import psutil
-
+import multiprocessing 
 cam = cv2.VideoCapture(0)
 
 
+def open_switch():
+
+    HOST = '127.0.0.1'  # Standard loopback interface address (localhost)
+    PORT = 8385        # Port to listen on (non-privileged ports are > 1023)
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind((HOST, PORT))
+        s.listen()
+        while 1:
+            conn, addr = s.accept()
+            with conn:
+                while True:
+                    data = conn.recv(1024)
+                    if not data:
+                        break
+                    conn.sendall(data)
+
 img_counter = 0
 
 encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 90]
@@ -26,6 +43,9 @@ def get_temps():
     data["mem_load"] = str(dict(psutil.virtual_memory()._asdict())["percent"])+"%"
     data["fan_speed"] = str(psutil.sensors_fans()["dell_smm"][0][1])+"RPM"
 
+p1 = multiprocessing.Process(target=open_switch) 
+p1.start()
+
 while True:
     try:
 
@@ -71,7 +91,11 @@ while True:
         if not socket_switch:
             client_socket.sendall(b"Bye\n")
         cam.release()
-        exit(0)
+        p1.terminate()
+        break
+
+cv2.destroyAllWindows()
+p1.terminate()