class PriusPredictor(object): def __init__(self, image_path, model_path, output_path): self.avgColor = [] self.pcaColors = [] self.detector = ObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath(model_path + "yolo.h5") self.detector.loadModel(detection_speed="flash") self.prediction = CustomImagePrediction() self.prediction.setModelTypeAsResNet() #self.prediction.setModelPath(model_path + "model_ex-012_acc-0.988819.h5") self.prediction.setModelPath(model_path + "model_ex-043_acc-0.996787.h5") self.prediction.setJsonPath(model_path + "model_class.json") self.prediction.loadModel(num_objects=2) now = time.localtime() self.frame_folder = str(now.tm_year) + str(now.tm_mon) + str(now.tm_mday) self.image_path = image_path self.output_path = output_path + "detection/" + self.frame_folder + "/" if os.path.exists(image_path) is False: os.mkdir(image_path) if os.path.exists(output_path) is False: os.mkdir(output_path) if os.path.exists(os.path.join(output_path, 'detection')) is False: os.mkdir(os.path.join(output_path, 'detection')) if os.path.exists(os.path.join(output_path, 'processed')) is False: os.mkdir(os.path.join(output_path, 'processed')) self.create_output_folder() def create_output_folder(self): if os.path.exists(self.output_path) is False: os.mkdir(self.output_path) def predict_vehicle_method(self, prediction_meta): detected_img = os.path.join(prediction_meta['image_path'], prediction_meta['image_name']) if os.path.exists(detected_img) is not True: detected_img = prediction_meta['image_path'] return self.prediction.predictImage(detected_img, result_count=2) def predict_vehicle(self, prediction_meta): detected_img = prediction_meta['image_path'] return self.prediction.predictImage(detected_img, result_count=2) def detect_pca(self, image): priusImage = PriusImage.from_path(image) return priusImage.has_pca_match() 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) if os.path.exists(image) is not True: print("File doesnt exist. File: " + image) custom_objects = self.detector.CustomObjects(car=True) detections, objects_path = self.detector.detectCustomObjectsFromImage(custom_objects=custom_objects, input_image=image, extract_detected_objects=True, output_image_path=output_image, minimum_percentage_probability=50) return zip(detections, objects_path) except Exception as 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
textSizeWidth, textSizeHeight = textSize ptLowerLeftTextOriginX = int(ptCenterOfTextAreaX - (textSizeWidth / 2)) ptLowerLeftTextOriginY = int(ptCenterOfTextAreaY + (textSizeHeight / 2)) cv2.putText(imgOriginalScene, licPlate.strChars, (ptLowerLeftTextOriginX, ptLowerLeftTextOriginY), intFontFace, fltFontScale, SCALAR_YELLOW, intFontThickness) execution_path = os.getcwd() detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel() # cv2.imwrite("imgg.jpg", frames) # cv2.imwrite("imgg.jpg",frames) detections = detector.detectObjectsFromImage( input_image=os.path.join(execution_path, "shah.jpg"), output_image_path=os.path.join(execution_path, "imagenew.jpg")) for eachObject in detections: if eachObject["name"] == "car": # cv2.imshow("Image",eachObject["box_image"]) number_plate(eachObject["box_image"]) # print(eachObject["color"]) # save_image = Image.fromarray(eachObject["box_image"],'RGB') # save_image.save('my.png') # break # cv2.imwrite() # save_image = misc.imread(eachObject["box_image"])
class LiveDetector: def __init__(self): # Instantiate detector self.detector = ObjectDetection() # Set and load model self.model_path = "D:/Final-Year-Project/Object-tracking/models/yolo.h5" self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath(self.model_path) self.detector.loadModel() # Set custom objects self.custom_objects = self.detector.CustomObjects(car=True, motorcycle=True, person=True, bicycle=True, dog=True) self.tracker = CentroidTracker() def track_objects(self, frame): rects = [] names = [] data = {} frame = self.pixelate_frontyard((100, 100), frame) returned_image, detection = self.detector.detectCustomObjectsFromImage( custom_objects=self.custom_objects, input_image=frame, output_type="array", input_type="array") for eachObject in detection: rects.append(eachObject["box_points"]) names.append(eachObject["name"]) (startX, startY, endX, endY) = eachObject["box_points"] cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 255, 0), 2) self.blur_object((startX, startY), (endX, endY), (11, 11), frame) objects = self.tracker.update(rects, names) if objects is not None: for objectID, objectDetails in objects.items(): # draw both the ID of the object and the centroid of the # object on the output frame centroid = objectDetails[0] name = objectDetails[1] if self.tracker.disappeared[objectID] < 1: text = name + " " + str(objectID) cv2.putText(frame, text, (centroid[0] - 30, centroid[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) cv2.circle(frame, (centroid[0], centroid[1]), 4, (0, 255, 0), -1) data[name] = objectID return frame, data def blur_object(self, topLeft, bottomRight, kSize, frame): x, y = topLeft[0], topLeft[1] w, h = bottomRight[0] - topLeft[0], bottomRight[1] - topLeft[1] ROI = frame[y:y + h, x:x + w] blur = cv2.GaussianBlur(ROI, kSize, 0) frame[y:y + h, x:x + w] = blur def blur_frontyard(self, kSize, frame): height, width, channel = frame.shape ROI_corners = np.array([[(320, 490), (895, 320), (895, height), (320, height)]], dtype=np.int32) blurred_frame = cv2.GaussianBlur(frame, kSize, 0) mask = np.zeros(frame.shape, dtype=np.uint8) ignore_mask_color = (255, ) * channel cv2.fillPoly(mask, ROI_corners, ignore_mask_color) mask_inverse = np.ones(mask.shape).astype(np.uint8) * 255 - mask frame = cv2.bitwise_and(blurred_frame, mask) + cv2.bitwise_and( frame, mask_inverse) return frame def pixelate_frontyard(self, kSize, frame): height, width, channel = frame.shape w, h = kSize ROI_corners = np.array([[(320, 490), (895, 320), (895, height), (320, height)]], dtype=np.int32) temp = cv2.resize(frame, (w, h), interpolation=cv2.INTER_LINEAR) pixelated_frame = cv2.resize(temp, (width, height), interpolation=cv2.INTER_NEAREST) mask = np.zeros(frame.shape, dtype=np.uint8) ignore_mask_color = (255, ) * channel cv2.fillPoly(mask, ROI_corners, ignore_mask_color) mask_inverse = np.ones(mask.shape).astype(np.uint8) * 255 - mask frame = cv2.bitwise_and(pixelated_frame, mask) + cv2.bitwise_and( frame, mask_inverse) return frame
import os import cv2 from PIL import Image cap = cv2.VideoCapture(0) # Load Yolo execution_path = os.getcwd() detector = ObjectDetection() #detector.setModelTypeAsTinyYOLOv3() # YOLOv3 #detector.setModelPath( os.path.join(execution_path , "models/yolo-tiny.h5")) detector.setModelTypeAsRetinaNet() # Other types are TinyYOLOv3, YOLOv3 detector.setModelPath( os.path.join(execution_path , "models/resnet50_coco_best_v2.0.1.h5")) #yolo-tiny.h5 detector.loadModel() #detection_speed="fastest" process_this_frame = True while 1: # reads frames from a camera ret, img = cap.read() # img_str = cv2.imencode('.jpg', img)[1].tostring() if process_this_frame: img = cv2.resize(img, (0,0), fx=0.5, fy=0.5) detections = detector.detectObjectsFromImage(input_type="array", input_image=img, output_type="file") print(detections)
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)
# class_text = ['run','sit','stand','walk','standup'] class_text = [ 'a01', 'a02', 'Two Hand Wave', 'a04', 'a05', 'a06', 'a07', 'a08', 'a09', 'a10', 'a11', 'a12', 'hand clap', 'a14', 'a15', 'a16', 'a17', 'a18' ] ### ImageAI # model_path = "pretrain/yolo-tiny.h5" model_path = "pretrain/yolo.h5" detector = ObjectDetection() # detector.setModelTypeAsTinyYOLOv3() detector.setModelTypeAsYOLOv3() detector.setModelPath(model_path) detector.loadModel( detection_speed="normal" ) #"normal"(default), "fast", "faster" , "fastest" and "flash". custom_objects = detector.CustomObjects(person=True) ### Main cap = cv2.VideoCapture(0) # Crop setting width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) # float height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) # float length_x_q = [[] for i in range(max_person)] length_y_q = [[] for i in range(max_person)] max_length = 5 mid_x_q = [[] for i in range(max_person)] mid_y_q = [[] for i in range(max_person)] max_mid = 3
def object(self, selection): if selection == []: layout = BoxLayout(orientation="vertical", spacing=10, padding=10) popupLabel = Label(text="No file is selected .") print("No file is selected .") closeButton = Button(background_normal='img\close.png', background_down='img\close.png', size_hint=(.38, .6), pos_hint={"center_x": .5}) layout.add_widget(popupLabel) layout.add_widget(closeButton) popup = Popup(title='Error', content=layout, size_hint=(.8, .6)) popup.open() closeButton.bind(on_press=popup.dismiss) engine = pyttsx3.init() print("No file is selected .") if self.soundcount == 0 : engine.say("No file is selected .") engine.runAndWait() else : engine = pyttsx3.init() print("Please Wait .") if self.soundcount == 0: engine.say("Please Wait .") engine.runAndWait() detector = ObjectDetection() model_path = "./model/yolo-tiny.h5" input_path = selection[0] output_path = "{} obj.png".format(selection[0]) detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path) detector.loadModel() detection = detector.detectObjectsFromImage(input_image=input_path, output_image_path=output_path) engine = pyttsx3.init() print("Input Path : {}".format(input_path)) print("Output Path : {}".format(output_path)) if self.soundcount == 0: engine.say("There are ") print("There are ") flag = 0 temp="" items="" for eachItem in detection: print(eachItem["name"], " : ", eachItem["percentage_probability"]) if self.soundcount == 0: if eachItem["name"] != temp: engine.say(eachItem["name"]) temp = eachItem["name"] items = items + temp + ", " flag = flag + 1 if flag == 0: if self.soundcount == 0: engine.say("no object's in the image .") print("no object's in the image .") else: if self.soundcount == 0: engine.say("in the image .") print("in the image .") layout = BoxLayout(orientation="vertical", spacing=10, padding=10) popupImage = Image(source = output_path) closeButton = Button(background_normal='img\close.png', background_down='img\close.png', size_hint=(.38, .31), pos_hint={"center_x": .5}) layout.add_widget(popupImage) layout.add_widget(closeButton) popup = Popup(title=items, content=layout, size_hint=(.8, .9)) popup.open() closeButton.bind(on_press=popup.dismiss) engine.runAndWait()
def object_detection(): execution_path = os.getcwd() detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath(settings.OBJECT_RECOGNITION_MODEL) detector.loadModel() done = 0 total_photos = Photo.objects.count() t = datetime.now() for photo in Photo.objects.all().order_by('pk'): if not photo.exists(check_input=True): logger.warning("Path does not exist!", id=photo.id, name=photo.name) total_photos -= 1 continue if photo.get_objects(): total_photos -= 1 continue ext = photo.name.split('.')[1] tmp_file = os.path.join(execution_path, f"photo.{ext}") new_tmp_file = os.path.join(execution_path, f"photo_out.{ext}") if os.path.islink(tmp_file): os.unlink(tmp_file) os.symlink(photo.get_input_path(), tmp_file,) detections = detector.detectObjectsFromImage( input_image=tmp_file, output_image_path=new_tmp_file ) with transaction.atomic(): for detection in detections: object_category, _ = ObjectCategory.objects.get_or_create(name=detection["name"]) ObjectIdentification.objects.create( photo=photo, category=object_category, confidence=detection["percentage_probability"] ) os.unlink(tmp_file) if os.path.isfile(photo.get_output_path()): os.remove(photo.get_output_path()) os.rename(new_tmp_file, photo.get_output_path()) done += 1 elapsed_time = (datetime.now() - t).seconds estimated_time_left = elapsed_time / done * (total_photos - done) stats = dict( name=photo.name, id=photo.pk, done=done, left=total_photos-done, proc=f'{"%.2f" % (done / total_photos * 100)}', est_left=f'{"%.2f" % estimated_time_left}s' ) if not len(detections): logger.warning( "No objects found!", **stats ) else: logger.info( "Detecting", **stats ) logger.info("Finished image recognition")
def main(origin_images_path="../data/raw_data/cars_train", destination_images_path="../data/object_detection_data/output_images_YOLO", final_images_path="../data/object_detection_data", sample=True): file_path = (os.path.dirname(os.path.abspath(__file__))).replace('\\', '/') if not os.path.exists(destination_images_path): os.makedirs(destination_images_path) logging.info('Starting detecting objects') detector = ObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath("../data/raw_data/YOLO_weights/yolo.h5") detector.loadModel() images = os.listdir(origin_images_path) if sample: images = images[:10] for i in images: detector.detectObjectsFromImage(input_image=origin_images_path + '/' + i, output_image_path=destination_images_path + "/new_{}".format(i), extract_detected_objects=True) logging.info('Finished detecting objects') logging.info('Starting assigining objects to folder output_image_cropped') # Keep only the biggest cut car dirs = list(filter(os.path.isdir, [destination_images_path + '/' + i for i in os.listdir(destination_images_path)])) for directory in dirs: files = os.listdir(directory) cars_size = {} for file in files: if not (file.startswith('car') or file.startswith('truck')): os.unlink(directory + "/" + file) remaining_files = os.listdir(directory) for file in remaining_files: cars_size[file] = Image.open(directory + str("/") + file).size if len(cars_size) > 1: biggest_car = None dim = (0, 0) for car in cars_size.keys(): if cars_size[car][0] * cars_size[car][1] > dim[0] * dim[1]: biggest_car = car dim = cars_size[car] to_delete = (list(set(cars_size.keys()))) to_delete.remove(biggest_car) for small_car in to_delete: os.unlink(directory + str("/") + small_car) # Rename the images as number.jpg dirs = filter(os.path.isdir, [destination_images_path + '/' + i for i in os.listdir(destination_images_path)]) for directory in dirs: files = os.listdir(directory) for file in files: number = re.search(r"[0-9]+", str(directory)) new_name = str(number.group())+".jpg" start = directory + str("/") + file end = directory + str("/") + new_name os.rename(start, end) # Put the all the cut cars into a folder named "output_images_cropped" dirs = filter(os.path.isdir, [destination_images_path + '/' + i for i in os.listdir(destination_images_path)]) if not os.path.exists(final_images_path + "/output_images_cropped"): os.mkdir(final_images_path + "/output_images_cropped") for directory in dirs: files = os.listdir(directory) for file in files: start = directory + str("/") + file destination = str(final_images_path + "/output_images_cropped") + str("/") + file shutil.copyfile(start, destination) logging.info('Finished entire process')
class ObjectOnlyCompressor: def __init__(self, model_path, api_key): self.detector = ObjectDetection() self.detector.setModelTypeAsRetinaNet() self.detector.setModelPath(model_path) self.detector.loadModel() self.api_key = api_key def compress(self, input_path, output_path): image = Image.open(input_path).convert('RGB') image.thumbnail((255, 255)) items = self.detector.detectObjectsFromImage( input_image=np.asarray(image), input_type='array', output_image_path='debug.jpg', ) file_content = bytearray() for item in items: file_content.extend(item['name'].encode('ascii')) file_content.append(0) file_content.extend(item['box_points']) with open(output_path, 'wb') as file: file.write(file_content) def decompress(self, input_path, output_path): with open(input_path, 'rb') as input_file: input_file_contents = input_file.read() output_image = Image.new('RGB', (255, 255), (255, 255, 255)) items = [] while input_file_contents: delimiter_index = input_file_contents.index(0) name = input_file_contents[:delimiter_index].decode('ascii') box_points = [ int(input_file_contents[delimiter_index + offset]) for offset in range(1, 5) ] items.append((name, box_points)) input_file_contents = input_file_contents[delimiter_index + 5:] for item in items: name, box_points = item print(name, box_points) response = requests.post("https://api.deepai.org/api/text2img", data={'text': name}, headers={'api-key': self.api_key}) url = response.json()['output_url'] image = fetch_image(url) image = image.resize(( box_points[2] - box_points[0], box_points[3] - box_points[1], )) output_image.paste(image, (box_points[0], box_points[1])) output_image.save(output_path)
class App: def __init__(self, master, portV): # initiating Arduino serial port if portV: try: self.arduino = serial.Serial(portV, 9600) except (serial.SerialException): tk.messagebox.showinfo("Error", "Invalid port.") else: self.arduino = None self.cam = cv2.VideoCapture(1) self.lightMode = 0 self.followMode = True self.height = 0 self.width = 0 self.xBound = 0 self.yBound = 0 self.x = 0 self.y = 0 # Initiating object detection model self.detector = ObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath("yolo.h5") self.custom = self.detector.CustomObjects(person=True) self.detector.loadModel("faster") self.start = 0 # Creating GUI self.master = master master.title('Feed') self.cFont = font.Font(family='Comic Sans MS', size=15, weight=font.BOLD) frame = tk.Frame(master, bg='white') frame.pack() self.timeLabel = tk.Label(frame, text="FPS: ", fg='white', bg='orange', width=15, height=1) self.timeLabel['font'] = self.cFont if showFeed: self.timeLabel.grid(row=0, column=0) else: self.timeLabel.grid(row=0, column=1) self.lightToggle = tk.Button(frame, text="Light:\nOff", fg='white', bg='orange', height=3, width=15, cursor='arrow', command=self.toggleLight) self.lightToggle['font'] = self.cFont if showFeed: self.lightToggle.grid(row=2, column=0, sticky='W') else: self.lightToggle.grid(row=1, column=0) self.followToggle = tk.Button(frame, text="Following:\nTrue", fg='white', bg='orange', height=3, width=15, cursor='arrow', command=self.toggleFollow) self.followToggle['font'] = self.cFont if showFeed: self.followToggle.grid(row=2, column=0) else: self.followToggle.grid(row=1, column=1) self.stop = tk.Button(master=frame, text="Stop", fg='white', bg='orange', height=3, width=15, cursor='arrow', command=self.master.destroy) self.stop['font'] = self.cFont if showFeed: self.stop.grid(row=2, column=0, sticky='E') else: self.stop.grid(row=1, column=2) ret, output = self.cam.read() # Set image bounds self.height, self.width, channels = output.shape self.xBound = self.width / 10 self.yBound = self.height / 8 detPic, det = self.detector.detectCustomObjectsFromImage( custom_objects=self.custom, input_type="array", input_image=output, output_type="array", minimum_percentage_probability=15) if showFeed: imageN = ImageTk.PhotoImage(image=Image.fromarray(detPic)) self.imgLabel = tk.Label(frame, image=imageN) self.imgLabel.grid(row=1, column=0) self.loop() # Turn light on and off def toggleLight(self): if self.lightMode == 0: self.lightMode = 1 self.lightToggle.configure(text="Light:\nOn") else: self.lightMode = 0 self.lightToggle.configure(text="Light:\nOff") # Turn object detection and following on/off def toggleFollow(self): self.followMode = not self.followMode if self.followMode: self.followToggle.configure(text="Following:\nTrue") else: self.followToggle.configure(text="Following:\nFalse") def loop(self): self.start = time.time() ret, output = self.cam.read() # If follow mode is set to on if self.followMode: # Detect hands detPic, det = self.detector.detectCustomObjectsFromImage( custom_objects=self.custom, input_type="array", input_image=output, output_type="array", minimum_percentage_probability=15) # If hand is detected if len(det) > 0: #Get location of detected objects location = det[0]['box_points'] self.x = (location[0] + location[2]) / 2 self.y = (location[1] + location[3]) / 2 if (self.x > (self.width / 2 + self.xBound)): self.x = 2 elif (self.x < (self.width / 2 - self.xBound)): self.x = 0 else: self.x = 1 if (self.y > (self.height / 2 + self.yBound)): self.y = 0 elif (self.y < (self.height / 2 - self.yBound)): self.y = 2 else: self.y = 1 else: self.x = 1 self.y = 1 print(str(self.x) + " " + str(self.y) + " " + str(self.lightMode)) # Send to Arduino over serial if self.arduino is not None: self.arduino.write( struct.pack('>BBB', self.x, self.y, self.lightMode)) else: # If nothing is detected concatted = "1 1 " + str(self.lightMode) print(concatted) if self.arduino is not None: self.arduino.write(struct.pack('>BBB', 1, 1, self.lightMode)) if showFeed: # Display image if self.followMode: imageN = ImageTk.PhotoImage(image=Image.fromarray(detPic)) else: imageN = ImageTk.PhotoImage(image=Image.fromarray(output)) self.imgLabel.configure(image=imageN) self.imgLabel.image = imageN # FPS counter self.timeLabel.configure(text="FPS: " + str(1 / (time.time() - self.start))[0:5]) else: if self.followMode: self.timeLabel.configure( text="FPS: " + str(1 / (time.time() - self.start))[0:5]) else: self.timeLabel.configure(text="FPS: Very Fast") # Loop back to itself self.master.after(1, self.loop)
def predict(): if request.method == 'POST': from keras import backend as K K.clear_session() print("POST") # loading model here in background detector = ObjectDetection() # use fat yolo since tiny yolo sux detector.setModelTypeAsYOLOv3() path = "./models/yolo.h5" detector.setModelPath(path) detector.loadModel() # creating list of custom objects custom = detector.CustomObjects(backpack=True, umbrella=True, cup=True) object_plastic_map = plastic_dict.plastic_dict # req_data = request.get_json() # image = req_data["image"] print(list(request.form.keys())) str_image = request.form["image"] print(str_image[:20]) str_image = base64.b64decode(str_image) print(str_image[:20]) # str_image = str_image.decode('utf-8') # str_image = base64_bytes.decode("base64") # print(str_image) # converting bytes information into string into np array # str_image = image.decode("utf-8") # print(str_image) image = Image.open(BytesIO(str_image)).convert("RGB") # image = ast.literal_eval(str_image) # print(image) im_array = np.array(image,dtype=np.uint8) # print(np.shape(image)) print(np.shape(im_array)) detection = detector.detectCustomObjectsFromImage(custom_objects=custom, input_type="array", input_image=im_array, output_type="array", minimum_percentage_probability=70) K.clear_session() to_return = "" for eachItem in detection[1]: name = eachItem["name"] print(name + " : ", eachItem["percentage_probability"]) to_return += name # to_return += ":" # to_return += str(object_plastic_map[name]) to_return += str(",") if to_return == "": print("nothing detected") print(to_return) return to_return else: return no_input()
# In[2]: model_path = os.getcwd() # In[3]: PRE_TRAINED_MODELS = ["yolo.h5"] # In[4]: # create imageAI objects and load models object_detector = ObjectDetection() object_detector.setModelTypeAsYOLOv3() object_detector.setModelPath(os.path.join(model_path, PRE_TRAINED_MODELS[0])) object_detector.loadModel() object_detections = object_detector.detectObjectsFromImage( input_image="people_umbrella.jpg") # In[5]: #define model paths and allow file extention UPLOAD_FOLDER = model_path ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg', 'gif']) # In[6]: app = Flask(__name__) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER # In[7]:
def main(): # setup folders image_path = "../kaggle/challenge2018_test/" model_weight_path = "resnet50_coco_best_v2.0.1.h5" print('Reading and transformin class information ...') # Read classes from RetinaNet. Prepared list taken from: https://github.com/fizyr/keras-retinanet/blob/master/examples/ResNet50RetinaNet.ipynb labels_to_names = { 0: 'person', 1: 'bicycle', 2: 'car', 3: 'motorcycle', 4: 'airplane', 5: 'bus', 6: 'train', 7: 'truck', 8: 'boat', 9: 'traffic light', 10: 'fire hydrant', 11: 'stop sign', 12: 'parking meter', 13: 'bench', 14: 'bird', 15: 'cat', 16: 'dog', 17: 'horse', 18: 'sheep', 19: 'cow', 20: 'elephant', 21: 'bear', 22: 'zebra', 23: 'giraffe', 24: 'backpack', 25: 'umbrella', 26: 'handbag', 27: 'tie', 28: 'suitcase', 29: 'frisbee', 30: 'skis', 31: 'snowboard', 32: 'sports ball', 33: 'kite', 34: 'baseball bat', 35: 'baseball glove', 36: 'skateboard', 37: 'surfboard', 38: 'tennis racket', 39: 'bottle', 40: 'wine glass', 41: 'cup', 42: 'fork', 43: 'knife', 44: 'spoon', 45: 'bowl', 46: 'banana', 47: 'apple', 48: 'sandwich', 49: 'orange', 50: 'broccoli', 51: 'carrot', 52: 'hot dog', 53: 'pizza', 54: 'donut', 55: 'cake', 56: 'chair', 57: 'couch', 58: 'potted plant', 59: 'bed', 60: 'dining table', 61: 'toilet', 62: 'tv', 63: 'laptop', 64: 'mouse', 65: 'remote', 66: 'keyboard', 67: 'cell phone', 68: 'microwave', 69: 'oven', 70: 'toaster', 71: 'sink', 72: 'refrigerator', 73: 'book', 74: 'clock', 75: 'vase', 76: 'scissors', 77: 'teddy bear', 78: 'hair drier', 79: 'toothbrush' } retina_classes = pd.DataFrame(list(labels_to_names.items()), columns=['ID', 'Label']) # Read classes from Google google_classes = pd.read_csv("class-descriptions-boxable.csv", delimiter=";", names=['ID', 'Label']) google_classes['Label'] = google_classes['Label'].apply(str.lower) # Iterate over Retina_classes and check if they're in Google classes. # If so, take google ID in new class mappings label_mappings = pd.DataFrame(columns=['ID', 'Label']) coco_to_google = {} for i in range(0, retina_classes.shape[0]): for j in range(0, google_classes.shape[0]): if (retina_classes["Label"][i] == google_classes["Label"][j]): label_mappings.loc[i] = google_classes.iloc[j] coco_to_google[retina_classes["Label"] [i]] = google_classes.iloc[j]['ID'] print('Loading resnet model ...') model_weight_path = "resnet50_coco_best_v2.0.1.h5" detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath(model_weight_path) detector.loadModel() print('Starting object detection method ...') detect_objects(detector_fn=detector.detectObjectsFromImage, img_path=image_path, results_fname='challenge_submission.csv', minimum_percentage_probability=50, translation_dict=coco_to_google)
class CaptionDataset(): def __init__(self): self.execution_path = os.getcwd() self.detector = ObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath(os.path.join(self.execution_path, "yolo.h5")) self.detector.loadModel(detection_speed="flash") self.transforms = tv.transforms.Compose( [tv.transforms.Resize(224), tv.transforms.ToTensor(), normalize]) data = t.load('caption.pth') self.ix2id = data['ix2id'] img_path = 'ai_challenger_caption_train_20170902/caption_train_images_20170902/' imgs = [os.path.join(img_path, self.ix2id[_]) \ for _ in range(len(self.ix2id))] self.imgs = imgs def __getitem__(self, index): img = Image.open(self.imgs[index]).convert('RGB') img_area = img.size[0] * img.size[1] detections = self.detector.detectObjectsFromImage( input_image=self.imgs[index]) block_num = len(detections) cut_imgs = [] if block_num == 2: for eachObject in detections: cropped = img.crop(eachObject["box_points"]) # print(eachObject["box_points"]) m = eachObject["box_points"][2] - eachObject["box_points"][0] n = eachObject["box_points"][3] - eachObject["box_points"][1] # print('截图宽:%d,截图高:%d' % (m, n)) jie = (m * n) / img_area * 100 # print('截图占比:%.2f%%' % jie) if jie < 10: cut_imgs.append(self.transforms(img)) else: cut_imgs.append(self.transforms(cropped)) if block_num == 1: for eachObject in detections: cropped = img.crop(eachObject["box_points"]) # print(eachObject["box_points"]) m = eachObject["box_points"][2] - eachObject["box_points"][0] n = eachObject["box_points"][3] - eachObject["box_points"][1] # print('截图宽:%d,截图高:%d' % (m, n)) jie = (m * n) / img_area * 100 # print('截图占比:%.2f%%' % jie) if jie < 10: cut_imgs.append(self.transforms(img)) else: cut_imgs.append(self.transforms(cropped)) cut_imgs.append(self.transforms(img)) if block_num == 0: for i in range(2): cut_imgs.append(self.transforms(img)) if block_num > 2: jie_d = {} for eachObject in detections: cropped = img.crop(eachObject["box_points"]) # print(eachObject["box_points"]) m = eachObject["box_points"][2] - eachObject["box_points"][0] n = eachObject["box_points"][3] - eachObject["box_points"][1] # print('截图宽:%d,截图高:%d' % (m, n)) jie = (m * n) / img_area * 100 # print('截图占比:%.2f%%' % jie) jie_d[jie] = cropped jie_l = sorted(jie_d.keys(), reverse=True) for l in range(2): if jie_l[l] < 10: cut_imgs.append(self.transforms(img)) else: cut_imgs.append(self.transforms(jie_d[jie_l[l]])) return cut_imgs, index def __len__(self): return len(self.imgs)
sigmaM = 0.0001 sigmaZ = 3 * noise Q = sigmaM**2 * np.eye(4) R = sigmaZ**2 * np.eye(2) listCenterX = [] listCenterY = [] listpuntos = [] execution_path = os.getcwd() detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(os.path.join(execution_path, "yolo-tiny.h5")) detector.loadModel(detection_speed="flash") custom = detector.CustomObjects(sports_ball=True) cap = cv2.VideoCapture(0) x = () while (True): ret, frame = cap.read() img1 = Image.fromarray(frame, 'RGB') img1.save('image1.jpg') detections, extracted_objects_array = detector.detectCustomObjectsFromImage( custom_objects=custom, input_image=os.path.join(execution_path, "image1.jpg"), output_image_path=os.path.join(execution_path, "image3new-custom.jpg"), extract_detected_objects=True, minimum_percentage_probability=30) for detection, object_path in zip(detections, extracted_objects_array): print(object_path)
def car_detections(): images = {} with open('./detections/jpglist.json', 'r') as f: jpgs = f.read() paths = json.loads(jpgs) imgdet = 0 # downloads es el contador que indica en cual link arranca la descarga de imagenes images_number = 300000 # aca va el numero de links guardados en el json for imgdet in range(imgdet, images_number): # en caso de no poder ver el error en consola y ver en que imagen te quedaste # creo un archivo que va guardando el ultimo estado de imgdet, o sea la ultima imagen que analicé images['images'] = imgdet with open('./detections/info.json', "w") as file: json.dump(images, file) realimage = paths[ 'jpg' + str(imgdet )] # realimage es la imagen original la cual hay que analizar execution_path = os.getcwd() detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel() print("Analazing", realimage, "/ image", imgdet + 1, "of", images_number) # defino de que sitio web proviene para luego colocarlo en el json if 'ml' in realimage: website = 'ml' elif 'olx' in realimage: website = 'olx' elif 'demotores' in realimage: website = 'demotores' elif 'rosariogarage' in realimage: website = 'rosariogarage' else: website = 'unknown' custom_objects = detector.CustomObjects(car=True) detections = detector.detectCustomObjectsFromImage( input_type="file", custom_objects=custom_objects, input_image=os.path.join(execution_path, realimage), output_image_path=os.path.join("./detections/images/car" + str(imgdet + 1) + ".jpg"), output_type="file", minimum_percentage_probability=90, extract_detected_objects=False) if len(detections) == 0: # no detecto autos os.remove("./detections/images/car" + str(imgdet + 1) + ".jpg") # que borre la foto y continue print("No cars detected") continue else: # si detecto autos # a continuacion el proceso para obtener el auto de mayor relevancia wh = [] sub_image = [] for y in range(0, len(detections)): dots = detections[y]['box_points'] coords = [dots[2] - dots[0], dots[3] - dots[1]] sub_image += [[coords[0] * coords[1], dots]] wh += [coords[0] * coords[1]] maximo = max(wh) for x in range(0, len(sub_image)): if maximo == sub_image[x][0]: maximo = sub_image[x][1] os.remove("./detections/images/car" + str(imgdet + 1) + ".jpg") # remuevo la imagen con las detecciones print("Image removed") shutil.copy(realimage, "./detections/images/car" + str(imgdet + 1) + ".jpg") # copio la imagen original print("Original image saved") # JSON: # traigo los datos del auto que estan en el .json en la carpeta original para tambien guardarlos en el # nuevo json realjson = os.path.dirname(os.path.abspath( realimage)) + "/meta.json" # obtengo el meta.json que esta en # en el mismo path que la imagen que estoy analizando with open(realjson, 'r') as f: car_data = f.read() data = json.loads(car_data) # agrego un par de datos mas al .json data[ 'Web Site'] = website # guardo sitio web de donde proviene la imagen data[ 'boxpoints'] = maximo # guardo los 4 puntos que forman el cuadrilatero donde se encuentra # el auto principal de la imagen en cuestion # guardo el .json with open("./detections/images/car" + str(imgdet + 1) + ".json", 'w') as fp: json.dump(data, fp) print("Created .json") print("End")
class StartWindows(QMainWindow): def __init__(self, camera=None, parent=None): super(StartWindows, self).__init__(parent=parent) self.ui = Ui_Form() self.ui.setupUi(self) #detector #button self.ui.pushButton.clicked.connect(self.start) self.ui.pushButton_2.clicked.connect(self.stop) #camera self.camera = cv2.VideoCapture(0) #timer self.update_timer = QTimer() self.update_timer.timeout.connect(self.update) def start(self): model = self.ui.comboBox.currentText() print(model) if model == "YOLO V3": self.yolo() elif model == "YOLO TINY": self.yolo_tiny() elif model == "RESNET": self.resnet() def yolo(self): self.update_timer.start(30) self.execution_path = os.getcwd() self.detector = ObjectDetection() self.detector.setModelTypeAsYOLOv3() self.detector.setModelPath(os.path.join(self.execution_path, "yolo.h5")) self.detector.loadModel(detection_speed="flash") print("###you are use yolo model###") def yolo_tiny(self): self.update_timer.start(30) self.execution_path = os.getcwd() self.detector = ObjectDetection() self.detector.setModelTypeAsTinyYOLOv3() self.detector.setModelPath( os.path.join(self.execution_path, "yolo-tiny.h5")) self.detector.loadModel(detection_speed="flash") print("###you are use yolo_tiny model###") def resnet(self): self.update_timer.start(30) self.execution_path = os.getcwd() self.detector = ObjectDetection() self.detector.setModelTypeAsRetinaNet() self.detector.setModelPath( os.path.join(self.execution_path, "resnet50_coco_best_v2.0.1.h5")) self.detector.loadModel(detection_speed="fastest") print("###you are use resnet model###") def stop(self): self.update_timer.stop() def update(self): ret, frame = self.camera.read() frame = cv2.flip(frame, 1) #detected custom = self.ui.comboBox_2.currentText() print(custom) if custom == "Person": custom_objects = self.detector.CustomObjects(person=True) elif custom == "orange": custom_objects = self.detector.CustomObjects(orange=True) elif custom == "Cell Phone": custom_objects = self.detector.CustomObjects(cell_phone=True) detected_image_array, detections = self.detector.detectCustomObjectsFromImage( custom_objects=custom_objects, input_type="array", input_image=frame, output_type="array") #detected_image_array, detections = self.detector.detectCustomObjectsFromImage(custom_objects=custom_objects,output_type="array",input_type="array", input_image= frame,display_percentage_probability=True, display_object_name=True) for eachObject in detections: print(eachObject["name"], " : ", eachObject["percentage_probability"], " : ", eachObject["box_points"]) #resize detected_image_array = cv2.resize(detected_image_array, (801, 391)) height, width, channel = detected_image_array.shape bytesPerLine = 3 * width qImg = QImage(detected_image_array.data, width, height, bytesPerLine, QImage.Format_RGB888).rgbSwapped() pixmap01 = QPixmap.fromImage(qImg) pixmap_image = QPixmap(pixmap01) self.ui.label.setPixmap(pixmap_image) self.ui.label.show()
from imageai.Detection import ObjectDetection import cv2 import requests import numpy as np import time detector = ObjectDetection() detector.setModelTypeAsYOLOv3() detector.setModelPath("yolo.h5") detector.loadModel(detection_speed="normal") url = "" t = 0 tim = 0 ti = 0 while t < 10: #ret, img = cap.read() img_resp = requests.get(url) img_arr = np.array(bytearray(img_resp.content), dtype=np.uint8) img = cv2.imdecode(img_arr, -1) start = time.clock() custom = detector.CustomObjects(person=True) ti = ti + (time.clock() - start) tim = tim + ti ti = 0
from imageai.Detection import ObjectDetection import os from time import time execution_path = os.getcwd() detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path , "resnet50_coco_best_v2.0.1.h5")) detector.loadModel(detection_speed="flash") our_time = time() detections = detector.detectObjectsFromImage(input_image=os.path.join(execution_path , "6.jpg"), output_image_path=os.path.join(execution_path , "6flash.jpg"), minimum_percentage_probability=30) print("IT TOOK : ", time() - our_time) for eachObject in detections: print(eachObject["name"] + " : " + eachObject["percentage_probability"] ) print("--------------------------------")
from imageai.Detection import ObjectDetection import os import time dir = ObjectDetection() dir.setModelTypeAsRetinaNet() dir.setModelPath(os.path.abspath('retinanet.h5')) dir.loadModel(detection_speed='faster') objects = dir.CustomObjects(car=True, bus=True, train=True, truck=True, traffic_light=True, stop_sign=True) print('----- detecting -----') t = time.time() det = dir.detectCustomObjectsFromImage( custom_objects=objects, input_image=os.path.abspath('imageai_test_2.jpg'), output_image_path=os.path.abspath('imageai_test_2_res.jpg')) print(time.time() - t) for each_obj in det: print(each_obj)
''' Editor: Ahan M R Date: 18-06-2018 Python 3.6.0 ''' #PS1 CROWD DETECTION IN THE SITUATION ''' From imageAI API, we import Object detection and use it to detect the object classes in the image ''' from imageai.Detection import ObjectDetection import os #os.getcwd gets the current working directory of the image execution_path = os.getcwd() detection = ObjectDetection() detection.setModelTypeAsRetinaNet() detection.setModelPath( os.path.join(execution_path , "resnet50_coco_best_v2.0.1.h5")) detection.loadModel() detections = detection.detectObjectsFromImage(input_image=os.path.join(execution_path , "xi.jpg"), output_image_path=os.path.join(execution_path , "imagenew.jpg")) for eachObject in detections: print(eachObject["name"] + " : " + eachObject["percentage_probability"])
detector.loadModel() ''' '''YOLO TINY model_path="models/yolo-tiny.h5" detector = ObjectDetection() detector.setModelTypeAsTinyYOLOv3() detector.setModelPath(model_path) detector.loadModel() ''' '''RESNET''' model_path="models/resnet50_coco.h5" detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath(model_path) detector.loadModel(detection_speed='fast') video_detector = VideoObjectDetection() video_detector.setModelTypeAsRetinaNet() video_detector.setModelPath(model_path) video_detector.loadModel() objects_dict = {} pub_str = rospy.Publisher('objects_detected', String, queue_size=100) custom = detector.CustomObjects(bottle=True, wine_glass=True, cup=True, fork=True, knife=True, spoon=True, banana=True, apple=True, sandwich=True, orange=True, mouse=True, remote=True, cell_phone=True, book=True, scissors=True)
def main(): detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel("faster") s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: #s.bind((socket.gethostname(), 8000)) s.bind((HOST, 8000)) except socket.error as err: print("Error de bind") sys.exit() s.listen(5) img = carga_imagen("listo.png") canvas.create_image(0, 0, image=img, anchor=NW) text.config(state="normal") text.delete(1.0, END) text.insert(INSERT, "Esperando una conexion") text.config(state="disabled") while True: print("esperando una conexion") clientsocket, address = s.accept() print(f"Conexion desde {address} establecida ") f = open("recibido.png", "wb") img = carga_imagen("cargando1.png") canvas.create_image(0, 0, image=img, anchor=NW) full_msg = '' #msg = clientsocket.recv(1024) #print(msg) #temp = msg[22:] #full_msg += temp.decode("utf-8") while True: msg = clientsocket.recv(1024) #print(msg) if len(msg) < 1024: try: #temp = msg[7:] #full_msg += temp.decode("utf-8") full_msg += msg.decode("utf-8") except: print("No se pudo decodificar el mensaje") break try: full_msg += msg.decode("utf-8") except: print("No se pudo decodificar el mensaje") #msg = clientsocket.recv(100000) print(full_msg) try: js = literal_eval(str(full_msg)) except: print("No se pudo convertir el mensaje a formato json") text.config(state="normal") text.delete(1.0, END) text.insert( INSERT, "Datos sensor ultrasonico: " + str(js["distancia"]) + "cm de distancia\n\nDatos camara: Fotografia con un peso de " + str(len(js["imagen"])) + " bytes\n\n") text.config(state="disabled") try: imagen = base64.b64decode(js["imagen"]) f.write(imagen) detections = detector.detectObjectsFromImage( input_image=os.path.join(execution_path, "recibido.png"), output_image_path=os.path.join(execution_path, "imagenew.png"), minimum_percentage_probability=40) img = carga_imagen("imagenew.png") canvas.create_image(0, 0, image=img, anchor=NW) objetos_detectados = compilar1(detections) """if len(detections) != 0: for eachObject in detections: objetos_detectados += ""+str(verificarGen(traducir(eachObject["name"])))+ ";" + str(eachObject["percentage_probability"] )+" " else: objetos_detectados += "una pared u objeto desconocido " """ text.config(state="normal") text.insert( INSERT, "Objeto(s) identificado(s): " + objetos_detectados + "\n\n") msg_to_send = compilar2(detections, js) #msg_to_send = direccion(str(js["direccion"]))+"hay "+objetos_detectados+"a "+str(js["distancia"])+"cm de distancia de usted" print("Natural: " + msg_to_send) print("\nMorse: " + str(encode(msg_to_send))) text.insert( INSERT, "Mensaje en lenguaje natural: " + msg_to_send + "\n\nMensaje en codigo morse: " + encode(msg_to_send) + "\n\n") text.config(state="disabled") clientsocket.send(bytes(msg_to_send, "utf-8")) clientsocket.close() except: print("Error grave") clientsocket.close() img = carga_imagen("listo.png") canvas.create_image(0, 0, image=img, anchor=NW) text.config(state="normal") text.delete(1.0, END) text.insert(INSERT, "Esperando una conexion") text.config(state="disabled")
# import speech_recognition as sr import cv2 import serial import numpy as np from imageai.Detection import ObjectDetection import os execution_path = os.getcwd() detector = ObjectDetection() detector.setModelTypeAsRetinaNet() ## NOTE: Установка модели в качестве..... detector.setModelPath( os.path.join( execution_path, "C:\\Users\\Admin_Robo\\Desktop\\project\\models\\resnet50_coco_best_v2.0.1.h5" )) # NOTE: Модели загрузка detector.loadModel() ## NOTE: + Установка скорости. print('LOADED') print('LOADED2') cap = cv2.VideoCapture() ret, frame = cap.read() cv2.imwrite('C:\\Users\\Admin_Robo\\Desktop\\project\\images\\test.png', frame) cap.release() cv2.destroyAllWindows() while True: ## NOTE: Обработка detections = detector.detectObjectsFromImage( input_image=os.path.join( execution_path, "C:\\Users\\Admin_Robo\\Desktop\\project\\images\\test.png"), output_image_path=os.path.join( execution_path,
# ref: https://imageai.readthedocs.io/en/latest/detection/index.html # This module will count the objects in an image and store them import time from imageai.Detection import ObjectDetection import os img_detector = ObjectDetection() img_detector.setModelTypeAsYOLOv3() #147 layers img_detector.setModelPath( os.path.join("/catkin_ws/src/master_pkg/src/", "yolo.h5")) #147 layers img_detector.loadModel( detection_speed="fast") #normal, fast, faster, fastest, flash # Note increases in speed should coorespond to lower a 'min. % probability' value def count(image_array): try: det_frame, detections = img_detector.detectObjectsFromImage( input_type="array", minimum_percentage_probability=60, input_image=image_array, output_type="array") print("-------------") for item in detections: print(item["name"]) print("-------------") except: rospy.loginfo("Could not count objects.")
output_file_path= os.path.join(execution_path ,"Detected {}".format(os.path.basename(file_path[:-4]))), frames_per_second=29, minimum_percentage_probability=min_prob, log_progress=True) else: with graph.as_default(): video_path = detector.detectObjectsFromVideo(input_file_path=file_path, output_file_path=os.path.join(execution_path ,"Detected {}".format(os.path.basename(file_path[:-4]))), minimum_percentage_probability=min_prob, frames_per_second=29, log_progress=True) #video_path = detector.detectObjectsFromVideo(input_file_path=file_path, # output_file_path=os.path.join(execution_path,"Detected {}".format(os.path.basename(file_path[:-4]))), # frames_per_second=29, log_progress=True) return(video_path) detector1 = ObjectDetection() detector1.setModelTypeAsYOLOv3() detector1.setModelPath("yolo.h5") detector1.loadModel() graph1 = tf.get_default_graph() result=tuple() listt=[] prob={} def ImageDetection(file_path,objects=None,min_prob=30): print(file_path) execution_path = r'./media/output_video' #detector = ObjectDetection() #detector.setModelTypeAsYOLOv3() #detector.setModelPath("yolo.h5") #detector.loadModel() if objects: print(objects) def func(person,truck,bus,bicycle,bird,motorcycle): #for k,v in objects.items():"%s = %s" % (k,v)
import matplotlib matplotlib.use('agg') import matplotlib.pyplot as plt from imageai.Detection import ObjectDetection import os workdir = os.getcwd() find_objects = ObjectDetection() find_objects.setModelTypeAsRetinaNet() find_objects.setModelPath(os.path.join(workdir, "resnet50_coco_best_v2.0.1.h5")) find_objects.loadModel() objects_found = find_objects.detectObjectsFromImage( input_image=os.path.join(workdir, "ilia.jpg"), output_image_path=os.path.join(workdir, "iliaRevealed.jpg")) for objects in objects_found: print(objects["name"] + " : " + str(objects["percentage_probability"]))
def getImageDetails(): image = request.files print() print(image) filestr = image['img'].read() #convert string data to numpy array npimg = numpy.fromstring(filestr, numpy.uint8) # convert numpy array to image print(1) img = cv2.imdecode(npimg, cv2.IMREAD_UNCHANGED) print(1) # img = cv2.imread(filename) cv2.imshow("image from post", img) cv2.imwrite("image_from_post_request.jpeg", img) print(1) cv2.waitKey(0) cv2.destroyAllWindows() # plt.imshow(img) # plt.show() filename = "image_from_post_request.jpeg" execution_path = os.getcwd() file_name = "image_from_post_request" detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join(execution_path, "resnet50_coco_best_v2.0.1.h5")) detector.loadModel() detections = detector.detectObjectsFromImage( input_image=os.path.join(execution_path, file_name + ".jpeg"), output_image_path=os.path.join(execution_path, file_name + "detected.jpeg")) image = cv2.imread(file_name + ".jpeg") copy = image.copy() face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') # ROI_number = 0 # return(jsonify({"out" : "Success !!!!"})) output = { "humna_face": { "count": 0 }, "animal": { "count": 0, "objects_found": dict() }, "object": { "count": 0, "objects_found": dict() } } animal = [ "bird", "cat", "dog", 'horse', "sheep", "cow", "elephant", "bear", "zebra", "giraffe" ] for eachObject in detections: print(output, eachObject.keys()) print(eachObject["name"], " : ", eachObject["percentage_probability"]) if (eachObject['name'] == 'person'): x, y, w, h = eachObject['box_points'] ROI = image[y:y + h, x:x + w] cv2.imwrite('ROI.jpeg', ROI) cv2.rectangle(copy, (x, y), (x + w, y + h), (36, 255, 12), 2) person = cv2.imread('ROI.jpeg') # Convert into grayscale gray = cv2.cvtColor(person, cv2.COLOR_BGR2GRAY) # Detect faces faces = face_cascade.detectMultiScale(gray, 1.4, 1, minSize=(1, 1)) if (len(faces) == 0): pass else: output['human_face']['count'] += 1 elif (eachObject['name'] in animal): output['animal']['count'] += 1 if (eachObject['name'] not in output['animal']['objects_found'].keys()): output['animal']['objects_found'][eachObject['name']] = 0 output['animal']['objects_found'][eachObject['name']] += 1 else: output['object']['count'] += 1 if (eachObject['name'] not in output['object']['objects_found'].keys()): output['object']['objects_found'][eachObject['name']] = 0 output['object']['objects_found'][eachObject['name']] += 1 # return(send_file(filename_or_fp = file_name + "detected.jpeg", mimetype="image/gif")) # return(m.to_string(), {'Content-Type': m.content_type}) return (jsonify(output))
# , frames_per_second=29, log_progress=True) #print(video_path) from imageai.Detection import ObjectDetection import os execution_path = os.getcwd() detector = ObjectDetection() detector.setModelTypeAsRetinaNet() detector.setModelPath( os.path.join( execution_path, "C:\\Users\\Admin_Robo\\Desktop\\resnet50_coco_best_v2.0.1.h5")) detector.loadModel( detection_speed='faster' ) ## NOTE: 1 секунда, 5 объектов, самое быстрое для распознавания. print('LOADED') print('LOADED2') detections = detector.detectObjectsFromImage( input_image=os.path.join( execution_path, "C:\\Users\\Admin_Robo\\Desktop\\WIN_20190919_18_18_19_Pro.jpg"), output_image_path=os.path.join( execution_path, "C:\\Users\\Admin_Robo\\Desktop\\iimg666.jpg")) print( '=================================IMG 1=================================') for eachObject in detections: print(eachObject["name"], " : ", eachObject["percentage_probability"])
class disjoin_counter: def __init__(self, Pass, recording_path): #intilizing the fundamental veriable self.recording_path = recording_path self.Pass = Pass self.my_col = None def connect(self): self.my_col = my_collection(self.Pass) if self.my_col == -1: print("Please enter a valid access key !") exit() print(" Disjoin counter started successfully!") def get_detector(self): # starting ObjectDetection module self.detector = ObjectDetection() self.detector.setModelTypeAsRetinaNet() self.detector.setModelPath('Model/resnet50_coco_best_v2.1.0.h5') self.detector.loadModel() def start(self, store_output_video=False): self.connect() self.get_detector() # starting the video capture activity vid = cv2.VideoCapture('input_video.mp4') #str(self.recording_path)) i = 0 j = 10 while (vid.isOpened()): ret, frame = vid.read() if ret == True: if (j % 10 == 0): # taking every 10th frame t = datetime.now() t = t + timedelta(seconds=1) custom = self.detector.CustomObjects(person=True) returned_image, detections = self.detector.detectCustomObjectsFromImage( custom_objects=custom, input_image=frame, output_type="array", minimum_percentage_probability=30, input_type="array") out_img = "Store/" + "imagenew" + str(i) + ".jpg" if store_output_video: cv2.imwrite(out_img, returned_image) cv2.imshow('F', returned_image) i += 1 count = len(detections) d = t.strftime("%m/%d/%Y, %H:%M:%S") mydict = {"_id": i, "count": count, "Date_time": d} x = self.my_col.insert_one( mydict) # inserting into database if cv2.waitKey(25) & 0xFF == ord('q'): break j += 1 else: break vid.release() #out.release() cv2.destroyAllWindows()