Browse Source

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

yigit
Yiğit Çolakoğlu 6 years ago
parent
commit
f9dc977273
2 changed files with 160 additions and 87 deletions
  1. +134
    -85
      traffic_analyzer/ambulance_detect.py
  2. +26
    -2
      traffic_analyzer/sender.py

+ 134
- 85
traffic_analyzer/ambulance_detect.py View File

@ -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()

+ 26
- 2
traffic_analyzer/sender.py View File

@ -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()


Loading…
Cancel
Save