Add files via upload

Author: cchighman

PredictionRunner.py

@@ -1,8 +1,7 @@
 import argparse
 import multiprocessing
 import os
-import os
-import os
+import json
 import queue
 import shutil
 import threading
@@ -36,6 +35,8 @@
 ap.add_argument("-r", "--results", required=False,
                 default=70,
                 help="Prius Results")
+ap.add_argument("-z", "--test", required=False,
+                help="True for test",default=False)
 args = vars(ap.parse_args())
 
 q = queue.Queue()
@@ -96,11 +97,11 @@ def predict_vehicle(self, image_meta):
 					eachProbability) + " at path:  " + image_meta['image_path'])
 
 				result = {
-					"time": str(dlocaltime()),
+					"time": str(time.localtime()),
 					"image_name": image_meta["image_name"],
 					"image_path": image_meta["image_path"],
 					"probability": str(eachProbability),
-					"object": str(eachObject)
+					"object": str(eachPrediction)
 				}
 
 				save_result(result)
@@ -109,6 +110,39 @@ def predict_vehicle(self, image_meta):
 
 		return dict(result=found, prob=prius_prob)
 
+	def predict_array(self, decoded):
+		start = time.time()
+		found_prius = False
+		prius_prob = 0
+		try:
+			prius.detect_vehicle_from_array(decoded)
+				#prediction_meta = dict(image_name=eachObject['name'], image_points=eachObject["box_points"],
+				                   #    image_path=eachObjectPath)
+
+				#if has_prius_color(eachObjectPath, eachObjectPath):
+				#	result_meta = self.predict_vehicle(prediction_meta)
+			#		found_prius = result_meta['result']
+		#			prius_prob = result_meta['prob']
+		'''
+		except Exception as e:
+			print("Exception while predicting: " + str(e))
+
+		try:
+			if found_prius:
+				shutil.copy(os.path.join(image_meta['image_path'], image_meta['image_name']),
+				            args['output'] + 'detection/match_' + str(prius_prob) + "_" + image_meta['image_name'])
+
+			if args['test'] is False:
+				shutil.move(os.path.join(image_meta['image_path'], image_meta['image_name']),
+				            args['output'] + 'processed/' + image_meta['image_name'])
+'''
+		except Exception as e:
+			print("Exception while predicting: " + str(e))
+
+		end = time.time()
+		print("Prediction Time: " + str(end - start))
+
+
 	def predict(self, image_meta):
 		start = time.time()
 		found_prius = False
@@ -130,8 +164,9 @@ def predict(self, image_meta):
 				shutil.copy(os.path.join(image_meta['image_path'], image_meta['image_name']),
 				            args['output'] + 'detection/match_' + str(prius_prob) + "_" + image_meta['image_name'])
 
-			shutil.move(os.path.join(image_meta['image_path'], image_meta['image_name']),
-			            args['output'] + 'processed/' + image_meta['image_name'])
+			if args['test'] is False:
+				shutil.move(os.path.join(image_meta['image_path'], image_meta['image_name']),
+				            args['output'] + 'processed/' + image_meta['image_name'])
 
 		except Exception as e:
 			print("Exception while predicting: " + str(e))

PriusObjectDetection.py

@@ -22,7 +22,7 @@ def __init__(self, image_path, model_path, output_path):
 		self.detector = ObjectDetection()
 		self.detector.setModelTypeAsYOLOv3()
 		self.detector.setModelPath(model_path + "yolo.h5")
-		self.detector.loadModel()
+		self.detector.loadModel(detection_speed="flash")
 
 		self.prediction = CustomImagePrediction()
 		self.prediction.setModelTypeAsResNet()
@@ -72,10 +72,10 @@ def detect_pca(self, image):
 
 	def detect_vehicle(self, meta_data):
 		try:
+
 			image = os.path.join(meta_data["image_path"], meta_data['image_name'])
 			output_image = self.output_path + meta_data['image_name']
-			print("Detecting vehicle for " + meta_data['image_name'] + " -> " + output_image)
-
+			#print("Detecting vehicle for " + meta_data['image_name'] + " -> " + output_image)
 			if os.path.exists(image) is not True:
 				print("File doesnt exist. File: "  + image)
 			custom_objects = self.detector.CustomObjects(car=True)
@@ -87,4 +87,18 @@ def detect_vehicle(self, meta_data):
 
 			return zip(detections, objects_path)
 		except Exception as e:
-			print("While detecting vehicle: " + str(e))
+			print("While detecting vehicle: " + str(e))
+
+	def detect_vehicle_from_array(self, decoded):
+
+			#print("Detecting vehicle for " + meta_data['image_name'] + " -> " + output_image)
+
+		custom_objects = self.detector.CustomObjects(car=True)
+		result = self.detector.detectCustomObjectsFromImage(custom_objects=custom_objects,
+		                                                                     input_type="array",
+			                                                                 input_image=np.array(decoded),
+			                                                                 #output_type="array",
+			                                                                 minimum_percentage_probability=50)
+
+		print("Detected: " + str(result))
+		return result

image_test.py

@@ -0,0 +1,109 @@
+import time
+import json
+import cv2
+import numpy as np
+import requests
+from PIL import Image
+from imageai.Detection import ObjectDetection
+from imageai.Prediction.Custom import CustomImagePrediction
+from prius_color import has_prius_color_from_array
+
+def write_json(data, filename= "prius_results.json"):
+	with open(filename, "w") as f:
+		json.dump(data, f, indent=4)
+
+
+
+def save_result(result):
+	with open("prius_results.json") as json_file:
+		data = json.load(json_file)
+		temp = data
+
+		temp.append(result)
+	write_json(data)
+
+
+
+detector = ObjectDetection()
+detector.setModelTypeAsYOLOv3()
+detector.setModelPath("./yolo.h5")
+detector.loadModel(detection_speed="fastest")
+
+prediction = CustomImagePrediction()
+prediction.setModelTypeAsResNet()
+# self.prediction.setModelPath(model_path + "model_ex-012_acc-0.988819.h5")
+prediction.setModelPath("./model_ex-043_acc-0.996787.h5")
+prediction.setJsonPath("./model_class.json")
+prediction.loadModel(prediction_speed="fastest")
+
+custom_objects = detector.CustomObjects(car=True)
+
+accuracy = 0
+imgs = []
+
+data = requests.get("http://seattle.gov/trafficcams/images/15_NW_65_NS.jpg").content
+decoded = cv2.imdecode(np.frombuffer(data, np.uint8), -1)
+imgs.append(decoded)
+data = requests.get("http://seattle.gov/trafficcams/images/15_NW_65_NS.jpg").content
+decoded = cv2.imdecode(np.frombuffer(data, np.uint8), -1)
+imgs.append(decoded)
+
+for decoded in imgs:
+
+	start1 = time.time()
+	result = detector.detectCustomObjectsFromImage(custom_objects=custom_objects,
+	                                               input_type="array",
+	                                               extract_detected_objects=True,
+	                                               input_image=np.array(decoded),
+	                                               output_type="array",
+	                                               minimum_percentage_probability=50)
+	start2 = time.time()
+	print("Detection Time: " + str(start2 - start1))
+	detected = []
+	for arr in result[1]:
+		(x1, y1, x2, y2) = arr["box_points"]
+		img = decoded[y1:y2, x1:x2]
+
+		colorStart = time.time()
+		has_color = has_prius_color_from_array(img)
+		colorEnd = time.time()
+		print("has_color Time: " + str(colorEnd - colorStart))
+
+		if has_color is not True:
+			start2 = time.time()
+			predictions, probabilities = prediction.predictImage(img, input_type="array", result_count=2)
+			start3 = time.time()
+
+			print("Prediction Time: " + str(start3 - start2))
+			for eachPrediction, eachProbability in zip(predictions, probabilities):
+				if "prius" in eachPrediction and eachProbability > accuracy:
+					try:
+						success = {
+							#'timestamp': frame_time,
+						#	'image_name': frame_file,
+						#	'image_path': frame_dir,
+						#	'cam_id': str(cam['id']),
+							'probability': str(eachProbability)
+							#'predictor':  'series'
+						}
+						r = requests.post("http://priusvision.azurewebsites.net/api/PriusTrigger", data=json.dumps(success))
+						print("---->  PRIUS IDENTIFIED.   Data: " + str(success))
+					except Exception as e:
+						print("Saving Prius result failed:  " + str(e))
+						save_result(success)
+
+					if r.status_code is not 200:
+						print("POST Failed.  Saving manually.")
+						save_result(success)
+
+					with open("./test/img2.jpg", 'wb') as handler:
+						handler.write(data)
+
+					cv2.imwrite("./test/img1.jpg", img)
+
+
+
+
+
+
+

prius_color.py

@@ -181,7 +181,7 @@ def save_result(result, file):
 
 
 def find_significant_contour(img):
-	contours, hierarchy = cv2.findContours(
+	image,contours, hierarchy = cv2.findContours(
 		img,
 		cv2.RETR_EXTERNAL,
 		cv2.CHAIN_APPROX_SIMPLE
@@ -207,14 +207,17 @@ def find_significant_contour(img):
 	contoursWithArea.sort(key=lambda meta: meta[1], reverse=True)
 	return contoursWithArea[0][0]
 
-
 def get_contour_colors(image_src):
 	# load the image and resize it to a smaller factor so that
 	# the shapes can be approximated better
 	# image = cv2.imread(os.path.join(path,image))
-	try:
-		image = cv2.imread(image_src)
+	return get_contour_colors_from_array(cv2.imread(image_src))
 
+def get_contour_colors_from_array(image):
+	# load the image and resize it to a smaller factor so that
+	# the shapes can be approximated better
+	# image = cv2.imread(os.path.join(path,image))
+	try:
 		resized = imutils.resize(image, width=300)
 		ratio = image.shape[0] / float(resized.shape[0])
 		# blur the resized image slightly, then convert it to both
@@ -243,17 +246,25 @@ def get_contour_colors(image_src):
 def has_prius_contour(image):
 	colors = get_contour_colors(image)
 	for color in colors:
-		if color in prius_color:
+		if color in prius_colors:
+			return True
+	return False
+
+def has_prius_contour_from_array(arr):
+	colors = get_contour_colors_from_array(arr)
+	for color in colors:
+		if color in prius_colors:
 			return True
 	return False
 
-def detect_color(image_src, image_name):
+def detect_color(image_src):
+	return detect_color_from_array(cv2.imread(image_src))
+
+def detect_color_from_array(image):
 	# load the image and resize it to a smaller factor so that
 	# the shapes can be approximated better
 	# image = cv2.imread(os.path.join(path,image))
 	try:
-		image = cv2.imread(image_src)
-
 		resized = imutils.resize(image, width=300)
 		ratio = image.shape[0] / float(resized.shape[0])
 		# blur the resized image slightly, then convert it to both
@@ -266,19 +277,20 @@ def detect_color(image_src, image_name):
 		# find contours in the thresholded image
 		cnts = find_significant_contour(thresh.copy())
 
-		# cnts = imutils.grab_contours(cnts)
-		# initialize the shape detector and color labeler
 		cl = ColorLabeler()
-
 		color = cl.label(lab, cnts)
-
-		#print("Image " + image_name + " has contour with color " + str(color))
 		return color
 	except Exception as e:
 		print("While detecting color: " + str(e))
 
-def has_prius_color(image, image_name):
-	detected_color = detect_color(image, image_name)
+def has_prius_color(image):
+	detected_color = detect_color(image)
+	if detected_color in prius_colors:
+		return True
+	return False
+
+def has_prius_color_from_array(image):
+	detected_color = detect_color_from_array(image)
 	if detected_color in prius_colors:
 		return True
 	return False