def get_frame(self): count = 0 _, frame = self.video.read() height, width = frame.shape[:2] if count == 0: frame, boxes, confidences, classids, idxs = infer_image( net, layer_names, height, width, frame, colors, labels, FLAGS) count += 1 else: frame, boxes, confidences, classids, idxs = infer_image( net, layer_names, height, width, frame, colors, labels, FLAGS, boxes, confidences, classids, idxs, infer=False) count = (count + 1) % 6 ret, jpeg = cv.imencode('.jpg', frame) return jpeg.tobytes()
def infer(self, vs, net, args, layer_names, colors, labels, FLAGS): """ Pass video stream to model and infer car ready signals """ count = 0 fps = FPS().start() end = time.time() + CV_INFER_SECONDS output = {} while time.time() < end: frame = vs.read() height, width = frame.shape[:2] if count == 0: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS) count += 1 else: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS, boxes, confidences, classids, idxs, infer=False) count = (count + 1) % 6 cv2.imshow('webcam', frame) print(classids, idxs) #output[datetime.now()] = [classids[idxs], confidences[idxs]] if cv2.waitKey(1) & 0xFF == ord('q'): break # update the FPS counter fps.update() # stop the timer and display FPS information fps.stop() print("[INFO] elapsed time: {:.2f}".format(fps.elapsed())) print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) # do a bit of cleanup print('clean environment: destroy windows') cv2.destroyAllWindows() output = {'time' : ['person', 100]} return (True, output)
def photo_labels(path): FLAGS = {} FLAGS['labels'] = './yolov3-coco/coco-labels' # Download the YOLOv3 models if needed # Get the labels labels = open(FLAGS['labels']).read().strip().split('\n') colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') FLAGS['config'] = './yolov3-coco/yolov3.cfg' FLAGS['weights'] = './yolov3-coco/yolov3.weights' # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet(FLAGS['config'], FLAGS['weights']) # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] img = cv.imread(path) height, width = img.shape[:2] img, _, _, classids, idxs, text = infer_image(net, layer_names, height, width, img, colors, labels, FLAGS) #print(text) return text
def test_object_improved(path_in, path_out, suffix = 'object_improved'): parser = argparse.ArgumentParser() FLAGS, unparsed = parser.parse_known_args() FLAGS.model_path = '../yolov3-coco/' FLAGS.weights = '../yolov3-coco/yolov3-spp.weights' FLAGS.config = '../yolov3-coco/yolov3-spp.cfg' FLAGS.video_path = path_in FLAGS.video_output_path = f'{path_out}_{suffix}.avi' FLAGS.labels = '../yolov3-coco/coco-labels' FLAGS.confidence = 0.1 FLAGS.threshold = 0.3 FLAGS.download_model = False FLAGS.show_time = False vid = cv.VideoCapture(FLAGS.video_path) height, width, writer = None, None, None labels = open(FLAGS.labels).read().strip().split('\n') colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') net = cv.dnn.readNetFromDarknet(FLAGS.config, FLAGS.weights) layer_names = net.getLayerNames() layer_names = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()] print(f'starting {suffix}') time_0 = time.time() frame_number = 0 while True: grabbed, frame = vid.read() if not grabbed: break else: frame_number += 1 if width is None or height is None: height, width = frame.shape[:2] img, boxes, confidences, classids, idxs = infer_image(net, layer_names, height, width, frame, colors, labels, FLAGS) output_array = [] for index in range(len(classids)): output_array.append({'name' : labels[classids[index]], 'percentage_probability' : confidences[index] * 100}) pfh.per_frame_handler(frame_number, output_array, suffix = suffix) if writer is None: fourcc = cv.VideoWriter_fourcc(*"MJPG") writer = cv.VideoWriter(FLAGS.video_output_path, fourcc, 30, (frame.shape[1], frame.shape[0]), True) writer.write(frame) writer.release() vid.release() print(f'mode {suffix} finished, elapsed time : {time.time() - time_0}s')
def classify(frame_bgr): global count frame = imutils.resize(frame_bgr, width=600) height, width = frame.shape[:2] boxes, confidences, classids = [],[],[] results = [] frame_out, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS) height, width = frame.shape[:2] if count == 0: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS) count += 1 else: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS, boxes, confidences, classids, idxs, infer=False) count = (count + 1) % 6 print_categories(boxes, confidences, classids, labels) results = [] for i in range(len(classids)): results.append((labels[classids[i]], confidences[i], boxes[i])) frame_out = frame.copy() return frame_out, results
def yolo_detect(frames,labelh,net): parser = argparse.ArgumentParser() parser.add_argument('-l', '--labels', type=str, default='./yolov3-coco/coco-labels', help='Path to the file having the labels in a new-line seperated way.') parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the Non-Max Suppresion') FLAGS, unparsed = parser.parse_known_args() # Get the labels labels = open(FLAGS.labels).read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()] height , width = None, None writer = None count = 0 for frame in frames: print("frame count :",count) detect = 0 if(count%2==0): if width is None or height is None: width = frame.shape[1] height = frame.shape[0] detect = infer_image(net, layer_names, height, width, frame, colors, labels, FLAGS,labelh) count += 1 if detect == 0: continue else: return detect return detect
def detectobject(frame): print("entered") confidence = 0.5 threshold = 0.3 height, width = frame.shape[:2] objects = [] confidences, classids, idxs = infer_image(net, layer_names, height, width, frame, labels, confidence, threshold) if len(idxs) > 0: for i in idxs.flatten(): if (labels[classids[i]] not in objects): objects.append(labels[classids[i]]) print("[INFO] Cleaning up...") return objects
def predict(self, in_path, out_img_path, out_json_path): # Read the image try: print('read image from %s' % in_path) img = cv.imread(in_path) height, width = img.shape[:2] except: raise 'Image cannot be loaded!\n\ Please check the path provided!' finally: img, json_data = infer_image(self.net, self.layer_names, height, width, img, self.colors, self.labels, self.FLAGS) cv.imwrite(out_img_path, img) with open(out_json_path, "w") as json_file: json.dump(json_data, json_file)
def detectobjects(frame, weights=os.path.join(BASE_URL, 'yolov3.weights'), config=os.path.join(BASE_URL, 'yolov3.cfg'), labels=os.path.join(BASE_URL, 'coco-labels')): print("entered") confidence = 0.5 threshold = 0.3 labels = open(labels).read().strip().split("\n") net = cv.dnn.readNetFromDarknet(config, weights) layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] frame_count = 0 # while True: # grabbed, frame = vid.read() # print(frame_count) frame_count = frame_count + 1 # if width is None or height is None: height, width = frame.shape[:2] objects = [] confidences, classids, idxs = infer_image(net, layer_names, height, width, frame, labels, confidence, threshold) if len(idxs) > 0: for i in idxs.flatten(): if (labels[classids[i]] not in objects): objects.append(labels[classids[i]]) print("[INFO] Cleaning up...") return objects
def yolo(): import numpy as np import argparse import cv2 as cv import subprocess import time import os from yolo_utils import infer_image, show_image engine = pyttsx3.init() engine.say("Welcome to the Navigation assistant.") engine.runAndWait() FLAGS = [] parser = argparse.ArgumentParser() parser.add_argument('-m', '--model-path', type=str, default='./yolov3-coco/', help='The directory where the model weights and \ configuration files are.') parser.add_argument('-w', '--weights', type=str, default='./yolov3-coco/yolov3.weights', help='Path to the file which contains the weights \ for YOLOv3.') parser.add_argument( '-cfg', '--config', type=str, default='./yolov3-coco/yolov3.cfg', help='Path to the configuration file for the YOLOv3 model.') parser.add_argument('-i', '--image-path', type=str, help='The path to the image file') parser.add_argument('-v', '--video-path', type=str, help='The path to the video file') parser.add_argument('-vo', '--video-output-path', type=str, default='./output.avi', help='The path of the output video file') parser.add_argument('-l', '--labels', type=str, default='./yolov3-coco/coco-labels', help='Path to the file having the \ labels in a new-line seperated way.') parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') parser.add_argument( '--download-model', type=bool, default=False, help='Set to True, if the model weights and configurations \ are not present on your local machine.') parser.add_argument('-t', '--show-time', type=bool, default=False, help='Show the time taken to infer each image.') FLAGS, unparsed = parser.parse_known_args() # Download the YOLOv3 models if needed if FLAGS.download_model: subprocess.call(['./yolov3-coco/get_model.sh']) # Get the labels labels = open(FLAGS.labels).read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet(FLAGS.config, FLAGS.weights) # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] # If both image and video files are given then raise error if FLAGS.image_path is None and FLAGS.video_path is None: print('Neither path to an image or path to video provided') print('Starting Inference on Webcam') count = 0 vid = cv.VideoCapture(0) while True: _, frame = vid.read() height, width = frame.shape[:2] if count == 0: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS) count += 1 else: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS, boxes, confidences, classids, idxs, infer=False) count = (count + 1) % 6 cv.imshow('webcam', frame) if cv.waitKey(1) & 0xFF == ord('q'): break vid.release() cv.destroyAllWindows()
def detectionofkiranastore( ): #function to get detected class id and conture values parser = argparse.ArgumentParser() parser.add_argument('-m', '--model-path', type=str, default='./yolov3-coco/', help='The directory where the model weights and \ configuration files are.') parser.add_argument('-w', '--weights', type=str, default='./yolov3-coco/yolov3.weights', help='Path to the file which contains the weights \ for YOLOv3.') parser.add_argument( '-cfg', '--config', type=str, default='./yolov3-coco/yolov3.cfg', help='Path to the configuration file for the YOLOv3 model.') parser.add_argument('-l', '--labels', type=str, default='./yolov3-coco/coco-labels', help='Path to the file having the \ labels in a new-line seperated way.') parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') FLAGS, unparsed = parser.parse_known_args() # Download the YOLOv3 models if needed # Get the labels labels = open(FLAGS.labels).read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet(FLAGS.config, FLAGS.weights) # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] count = 0 # Read the image try: img = cv.imread('item.jpg') #read the object shown height, width = img.shape[:2] except: raise 'Image cannot be loaded!\n\ Please check the path provided!' finally: img, _, _, _, _ = infer_image(net, layer_names, height, width, img, colors, labels, FLAGS) if count == 0: frame, boxes, confidences, classids, idxs = infer_image( net, layer_names, height, width, img, colors, labels, FLAGS) count += 1 else: frame, boxes, confidences, classids, idxs = infer_image( net, layer_names, height, width, img, colors, labels, FLAGS, boxes, confidences, classids, idxs, infer=False) count = (count + 1) % 6 return classids, boxes
def yolo(): parser = argparse.ArgumentParser() parser.add_argument('-m', '--model-path', type=str, default='./yolov3-coco/', help='The directory where the model weights and \ configuration files are.') parser.add_argument('-w', '--weights', type=str, default='./yolov3-coco/yolov3.weights', help='Path to the file which contains the weights \ for YOLOv3.') parser.add_argument( '-cfg', '--config', type=str, default='./yolov3-coco/yolov3.cfg', help='Path to the configuration file for the YOLOv3 model.') parser.add_argument('-vo', '--video-output-path', type=str, default='./output.avi', help='The path of the output video file') parser.add_argument('-l', '--labels', type=str, default='./yolov3-coco/coco-labels', help='Path to the file having the \ labels in a new-line seperated way.') parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') parser.add_argument( '--download-model', type=bool, default=False, help='Set to True, if the model weights and configurations \ are not present on your local machine.') parser.add_argument('-t', '--show-time', type=bool, default=False, help='Show the time taken to infer each image.') FLAGS, unparsed = parser.parse_known_args() #print(FLAGS) # Get the labels labels = open(FLAGS.labels).read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet(FLAGS.config, FLAGS.weights) # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] ################################ height, width = frame.shape[:2] img, bboxes, _, classid, _ = infer_image(net, layer_names, height, width, frame, colors, labels, FLAGS) global boxes boxes = [] #It's a list now j = 0 for i in classid: if i == 0: print("persons bounding box is: ", bboxes[j]) boxes.append(bboxes[j].copy()) print(boxes[i]) j = j + 1 ############################temp ###########33 #for index,value in enumerate(boxes): itr = 0 for i in range(len(boxes)): itr = itr + 1 name = 'dataset/' + str("person") + str(itr) + ".jpg" y = boxes[i][1] x = boxes[i][0] h = boxes[i][3] w = boxes[i][2] crop_img = img[y:y + h, x:x + w] cv.imwrite(name, crop_img) detector = MTCNN() print("I am a detector phewww !") print(detector.detect_faces(crop_img)) face_cropped = detector.detect_faces(crop_img) print(face_cropped, "Debug") if (len(face_cropped) > 0): boxes_face = (face_cropped[0]['box']) y1 = boxes_face[1] x1 = boxes_face[0] h1 = boxes_face[3] w1 = boxes_face[2] crop_img_2 = crop_img[y1:y1 + h1, x1:x1 + w1] name = 'dataset/' + str("face") + str(itr) + '.jpg' cv.imwrite(name, crop_img_2) #crop_img_2 = cv2.resize(crop_img_2,(100,100),interpolation=cv2.INTER_AREA) rec = FaceID() # Matching Part images = [] for img in glob.glob("dataset/face*.jpg"): n = cv2.imread(img) images.append(n) #for img in images: # img = cv2.resize(img,(100,100),interpolation=cv2.INTER_AREA) #if(np.linalg.norm(img-crop_img_2)>=0.9): # val = np.linalg.norm(img-crop_img_2) #print("Amir won",val) # Matching Part End ##########################temp done#########33 my_tuple = [] for i in bboxes: my_tuple.append(tuple(i)) #print(my_tuple) # Create MultiTracker object multiTracker = cv2.MultiTracker_create() # Initialize MultiTracker colors_multi = [] for bbox in my_tuple: multiTracker.add(createTrackerByName(trackerType), frame, bbox) colors_multi.append((randint(64, 255), randint(64, 255), randint(64, 255))) return multiTracker, colors_multi
frameCount = 0 while True: grabbed, frame = vid.read() print("Frame count",frameCount) # Checking if the complete video is read if not grabbed: break if width is None or height is None: height , width = frame.shape[:2] #Take first frame from each second for detection if(frameCount%1==0): frame, detect = infer_image(net, layer_names, height, width, frame, colors, labels, FLAGS, frameCount) if writer is None: # Initialize the video writer fourcc = cv.VideoWriter_fourcc(*"MJPG") writer = cv.VideoWriter(FLAGS.video_output_path, fourcc, fps,(frame.shape[1], frame.shape[0]), True) writer.write(frame) #Check the frame contain any detection, if detection is occur, label statutory warning on the next 120 frames if(detect==1): for i in range(1,10): grabbed,frame = vid.read() frameCount += 1 print("Frame count",frameCount) height, width = frame.shape[:2] add_label(frame,height,'smoke.png') labelledImg = cv.imread("pasted_image.jpg") if writer is None:
def gen(): parser = argparse.ArgumentParser() #############default parameters for testing pourpose############## parser.add_argument('-m', '--model-path', type=str, default='./yolov3-coco/', help='The directory where the model weights and \ configuration files are.') parser.add_argument('-w', '--weights', type=str, default='./yolov3-coco/yolov3.weights', help='Path to the file which contains the weights \ for YOLOv3.') parser.add_argument( '-cfg', '--config', type=str, default='./yolov3-coco/yolov3.cfg', help='Path to the configuration file for the YOLOv3 model.') parser.add_argument('-vo', '--video-output-path', type=str, default='./output.avi', help='The path of the output video file') parser.add_argument('-l', '--labels', type=str, default='./yolov3-coco/coco-labels', help='Path to the file having the \ labels in a new-line seperated way.') parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') FLAGS, unparsed = parser.parse_known_args() ############################################################################# # Get the labels labels = open(FLAGS.labels).read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet(FLAGS.config, FLAGS.weights) # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] # Infer real-time from webcam to webapp count = 0 vid = cv.VideoCapture( 0 ) #change 0 for webcam 1 for external camera but mounted to edge server #vid=cv.VideoCapture(ip address)for remoe camera connected to server while True: _, frame = vid.read() height, width = frame.shape[:2] if count == 0: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS) count += 1 else: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS, boxes, confidences, classids, idxs, infer=False) count = (count + 1) % 6 cv.imwrite('item.jpg', frame) yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + open('item.jpg', 'rb').read() + b'\r\n')
def imag_det(img_path, obj_dec): parser = argparse.ArgumentParser() parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') parser.add_argument( '--download-model', type=bool, default=False, help='Set to True, if the model weights and configurations \ are not present on your local machine.') parser.add_argument('-t', '--show-time', type=bool, default=False, help='Show the time taken to infer each image.') FLAGS, unparsed = parser.parse_known_args() labels = open('darknet\\data\\obj.names').read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet( 'darknet/cfg/yolov3_custom.cfg', 'darknet/backup/yolov3_custom_last.weights') # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] labels = open('darknet\\data\\obj.names').read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet( 'darknet/cfg/yolov3_custom.cfg', 'darknet/backup/yolov3_custom_last.weights') # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] try: img = cv.imread(img_path) height, width = img.shape[:2] except: raise 'Image cannot be loaded!\n\ Please check the path provided!' finally: img, _, _, _, _ = infer_image(net, obj_dec, layer_names, height, width, img, colors, labels, FLAGS) cv.imwrite('image_out.jpg', img)
def infer(self, frame): self.frame, _, _, _, _ = infer_image(self.net, self.layer_names, self.height, self.width, frame, self.colors, self.labels) return self.frame
def live_feed(obj_dec): parser = argparse.ArgumentParser() parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') parser.add_argument( '--download-model', type=bool, default=False, help='Set to True, if the model weights and configurations \ are not present on your local machine.') parser.add_argument('-t', '--show-time', type=bool, default=False, help='Show the time taken to infer each image.') FLAGS, unparsed = parser.parse_known_args() labels = open('darknet\\data\\coco.names').read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet('darknet\\cfg\\yolov3.cfg', 'darknet\\yolov3.weights') # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] #net = cv.dnn.readNetFromDarknet('darknet\\cfg/yolov3_custom.cfg', 'darknet/yolov3.weights') count = 0 vid = cv.VideoCapture(0) while True: _, frame = vid.read() height, width = frame.shape[:2] if count == 0: frame, boxes, confidences, classids, idxs = infer_image(net, obj_dec, layer_names, \ height, width, frame, colors, labels, FLAGS) count += 1 else: frame, boxes, confidences, classids, idxs = infer_image(net, obj_dec, layer_names, \ height, width, frame, colors, labels, FLAGS, boxes, confidences, classids, idxs, infer=False) count = (count + 1) % 6 cv.imshow('webcam', frame) if cv.waitKey(1) & 0xFF == ord('q'): break vid.release() cv.destroyAllWindows()
def vid_det(vid_path, obj_dec): parser = argparse.ArgumentParser() parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-vo', '--video-output-path', type=str, default='./output.avi', help='The path of the output video file') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') parser.add_argument( '--download-model', type=bool, default=False, help='Set to True, if the model weights and configurations \ are not present on your local machine.') parser.add_argument('-t', '--show-time', type=bool, default=False, help='Show the time taken to infer each image.') FLAGS, unparsed = parser.parse_known_args() labels = open('darknet\\data\\obj.names').read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet( 'darknet/cfg/yolov3_custom.cfg', 'darknet/backup/yolov3_custom_last.weights') # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] labels = open('darknet\\data\\obj.names').read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet( 'darknet/cfg/yolov3_custom.cfg', 'darknet/backup/yolov3_custom_last.weights') # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] try: vid = cv.VideoCapture(vid_path) height, width = None, None writer = None except: raise 'Video cannot be loaded!\n\ Please check the path provided!' finally: while True: grabbed, frame = vid.read() # Checking if the complete video is read if not grabbed: break if width is None or height is None: height, width = frame.shape[:2] frame, _, _, _, _ = infer_image(net, obj_dec, layer_names, height, width, frame, colors, labels, FLAGS) if writer is None: # Initialize the video writer fourcc = cv.VideoWriter_fourcc(*"MJPG") writer = cv.VideoWriter(FLAGS.video_output_path, fourcc, 30, (frame.shape[1], frame.shape[0]), True) writer.write(frame) print("[INFO] Cleaning up...") writer.release() vid.release() cap = cv.VideoCapture('output.mp4') main()
times = [] boxes_num = [] heights = [] widths = [] names = [] for i in range(FLAGS.count): path = Gen_image_path(i) img = cv.imread(path) height, width = img.shape[:2] name = path[:(len(path) - 4)] name = name[4:] names.append(name) heights.append(height) widths.append(width) t1 = time.time() img, boxes, confidences, classid, idxs = infer_image( net, layer_names, height, width, img, colors, labels, FLAGS) t2 = time.time() times.append(t2 - t1) boxes_num.append(len(idxs)) #print(idxs) cv.imwrite(Set_name_to_write(path), img) name_dict = { 'Name': names, 'Width': widths, 'Height': heights, 'Times': times, 'Number of Detections': boxes_num } df = pd.DataFrame(name_dict) df.to_csv('Test_times_{}.csv'.format(j))
def test_face_improved(path_in, path_out, suffix='face_improved'): parser = argparse.ArgumentParser() FLAGS, unparsed = parser.parse_known_args() FLAGS.model_path = '../yolov3-coco/' FLAGS.weights = '../yolov3-coco/yolov3-wider_16000.weights' FLAGS.config = '../yolov3-coco/yolov3-face.cfg' FLAGS.video_path = path_in FLAGS.video_output_path = f'{path_out}_{suffix}.avi' FLAGS.labels = '../yolov3-coco/coco-labels' FLAGS.confidence = 0.1 FLAGS.threshold = 0.3 FLAGS.download_model = False FLAGS.show_time = False emotion_model_path = '../models/emotion_model.hdf5' emotion_classifier = load_model(emotion_model_path) emotion_target_size = emotion_classifier.input_shape[1:3] emotion_labels = get_labels('fer2013') emotion_offsets = (20, 40) emotion_window = [] frame_window = 10 face_cascade = cv.CascadeClassifier( '../models/haarcascade_frontalface_default.xml') vid = cv.VideoCapture(FLAGS.video_path) height, width, writer = None, None, None labels = open(FLAGS.labels).read().strip().split('\n') colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') net = cv.dnn.readNetFromDarknet(FLAGS.config, FLAGS.weights) layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] print(f'starting {suffix}') time_0 = time.time() frame_number = 0 while True: grabbed, frame = vid.read() if not grabbed: break else: frame_number += 1 if width is None or height is None: height, width = frame.shape[:2] img, boxes, confidences, classids, idxs = infer_image( net, layer_names, height, width, frame, colors, labels, FLAGS) gray_image = cv.cvtColor(img, cv.COLOR_BGR2GRAY) rgb_image = cv.cvtColor(img, cv.COLOR_BGR2RGB) faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30), flags=cv.CASCADE_SCALE_IMAGE) analysis_stastics.emotions.add_frame() for face_coordinates in faces: x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets) gray_face = gray_image[y1:y2, x1:x2] try: gray_face = cv.resize(gray_face, (emotion_target_size)) except: continue gray_face = preprocess_input(gray_face, True) gray_face = np.expand_dims(gray_face, 0) gray_face = np.expand_dims(gray_face, -1) emotion_prediction = emotion_classifier.predict(gray_face) emotion_probability = np.max(emotion_prediction) emotion_label_arg = np.argmax(emotion_prediction) emotion_text = emotion_labels[emotion_label_arg] emotion_window.append(emotion_text) analysis_stastics.emotions.add_emotion(emotion_text) if len(emotion_window) > frame_window: emotion_window.pop(0) try: emotion_mode = mode(emotion_window) except: continue if emotion_text == 'angry': color = emotion_probability * np.asarray((255, 0, 0)) elif emotion_text == 'sad': color = emotion_probability * np.asarray((0, 0, 255)) elif emotion_text == 'happy': color = emotion_probability * np.asarray((255, 255, 0)) elif emotion_text == 'surprise': color = emotion_probability * np.asarray((0, 255, 255)) else: color = emotion_probability * np.asarray((0, 255, 0)) color = color.astype(int) color = color.tolist() draw_text(face_coordinates, rgb_image, emotion_mode, color, 0, -45, 1, 1) img = cv.cvtColor(rgb_image, cv.COLOR_RGB2BGR) output_array = [] for index in range(len(classids)): output_array.append({ 'name': labels[classids[index]], 'percentage_probability': confidences[index] * 100 }) pfh.per_frame_handler(frame_number, output_array, suffix=suffix) if writer is None: fourcc = cv.VideoWriter_fourcc(*"MJPG") writer = cv.VideoWriter(FLAGS.video_output_path, fourcc, 30, (img.shape[1], img.shape[0]), True) writer.write(img) writer.release() vid.release() print(f'mode {suffix} finished, elapsed time : {time.time() - time_0}s')
raise 'Video cannot be loaded!\n\ Please check the path provided!' finally: while True: grabbed, frame = vid.read() # Checking if the complete video is read if not grabbed: break if width is None or height is None: height, width = frame.shape[:2] #countcheck=0 frame, _, _, _, _ = infer_image(net, layer_names, height, width, frame, colors, labels, FLAGS) if writer is None: # Initialize the video writer fourcc = cv.VideoWriter_fourcc(*"MJPG") writer = cv.VideoWriter(FLAGS.video_output_path, fourcc, 30, (frame.shape[1], frame.shape[0]), True) writer.write(frame) print ("[INFO] Cleaning up...") writer.release() vid.release()
def yolo(): parser = argparse.ArgumentParser() parser.add_argument('-m', '--model-path', type=str, default='./yolov3-coco/', help='The directory where the model weights and \ configuration files are.') parser.add_argument('-w', '--weights', type=str, default='./yolov3-coco/yolov3.weights', help='Path to the file which contains the weights \ for YOLOv3.') parser.add_argument( '-cfg', '--config', type=str, default='./yolov3-coco/yolov3.cfg', help='Path to the configuration file for the YOLOv3 model.') parser.add_argument('-vo', '--video-output-path', type=str, default='./output.avi', help='The path of the output video file') parser.add_argument('-l', '--labels', type=str, default='./yolov3-coco/coco-labels', help='Path to the file having the \ labels in a new-line seperated way.') parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') parser.add_argument( '--download-model', type=bool, default=False, help='Set to True, if the model weights and configurations \ are not present on your local machine.') parser.add_argument('-t', '--show-time', type=bool, default=False, help='Show the time taken to infer each image.') FLAGS, unparsed = parser.parse_known_args() #print(FLAGS) # Get the labels labels = open(FLAGS.labels).read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configutation to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet(FLAGS.config, FLAGS.weights) # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] ################################ height, width = frame.shape[:2] img, bboxes, _, classid, _ = infer_image(net, layer_names, height, width, frame, colors, labels, FLAGS) boxes = [] #It's a list now j = 0 for i in classid: if i == 0: print("persons bounding box is: ", bboxes[j]) boxes.append(bboxes[j].copy()) #print(boxes[i]) j = j + 1 print(boxes) #all faces ############################temp ###########33 #for index,value in enumerate(boxes): global itr for i in range(len(boxes)): itr = itr + 1 # Matching part labels = {} #Matching part end y = boxes[i][1] x = boxes[i][0] h = boxes[i][3] w = boxes[i][2] crop_img = img[y:y + h, x:x + w] #cv.imwrite(name,crop_img) detector = MTCNN() print("I am a detector phewww !") print(detector.detect_faces(crop_img)) face_cropped = detector.detect_faces(crop_img) if (len(face_cropped) > 0): boxes_face = (face_cropped[0]['box']) y1 = boxes_face[1] x1 = boxes_face[0] h1 = boxes_face[3] w1 = boxes_face[2] crop_img_2 = crop_img[y1:y1 + h1, x1:x1 + w1] name = 'dataset/' + str("face") + str(itr) + '.jpg' #cv.imwrite(name,crop_img_2) #Matching Part path = 'dataset/Face' + str(itr) os.mkdir(path) name = 'dataset/Face' + str(itr) + '/' + str("person") + str( itr) + ".jpg" cv.imwrite(name, crop_img) name = 'dataset/Face' + str(itr) + '/' + str("face") + str( itr) + ".jpg" try: cv.imwrite(name, crop_img_2) except: pass #amtching #Faces_Train.py os.system('faces_train.py') #Faces_Train.py with open("labels.pickle", 'rb') as f: og_labels = pickle.load(f) labels = {v: k for k, v in og_labels.items() } #talk to me about this ;) (key, value pair conversion) face_cascade = cv2.CascadeClassifier( 'cascade/data/haarcascade_frontalface_alt2.xml' ) #only front of a face recognizer = cv2.face.LBPHFaceRecognizer_create() recognizer.read("trainer.yml") gray = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, scaleFactor=1.5, minNeighbors=5) #scaleFactor aghe peeche krke dekho print("Faces", faces) for (x, y, w, h) in faces: print(x, y, w, h) print("Amir") roi_gray = gray[y:y + h, x:x + w] #roi -> Region of Interest roi_color = crop_img[y:y + h, x:x + w] #Recognition part id_, conf = recognizer.predict( roi_gray) #id's and confidence level print(id_, conf, "moz") if (conf >= 25 and conf <= 85): print(id_) print("he") print(labels[id_]) font = cv2.FONT_HERSHEY_SIMPLEX name = labels[id_] color = (255, 255, 255) stroke = 2 cv2.putText(frame, name, (x, y), font, 1, color, stroke, cv2.LINE_AA) ##########################temp done#########33 my_tuple = [] for i in bboxes: my_tuple.append(tuple(i)) #print(my_tuple) # Create MultiTracker object multiTracker = cv2.MultiTracker_create() # Initialize MultiTracker colors_multi = [] for bbox in my_tuple: multiTracker.add(createTrackerByName(trackerType), frame, bbox) colors_multi.append((randint(64, 255), randint(64, 255), randint(64, 255))) return multiTracker, colors_multi
def yolo_detection(filename, fps_of_video): # YOLO Detection FLAGS = [] parser = argparse.ArgumentParser() parser.add_argument('-m', '--model-path', type=str, default='./yolov3-coco/', help='The directory where the model weights and \ configuration files are.') parser.add_argument('-w', '--weights', type=str, default='./yolov3-coco/yolov3.weights', help='Path to the file which contains the weights \ for YOLOv3.') parser.add_argument( '-cfg', '--config', type=str, default='./yolov3-coco/yolov3.cfg', help='Path to the configuration file for the YOLOv3 model.') parser.add_argument('-i', '--image-path', type=str, help='The path to the image file') parser.add_argument('-v', '--video-path', type=str, default='./templates/videos/' + filename, help='The path to the video file') parser.add_argument('-vo', '--video-output-path', type=str, default='./' + filename, help='The path of the output video file') parser.add_argument('-l', '--labels', type=str, default='./yolov3-coco/coco-labels', help='Path to the file having the \ labels in a new-line seperated way.') parser.add_argument('-c', '--confidence', type=float, default=0.5, help='The model will reject boundaries which has a \ probabiity less than the confidence value. \ default: 0.5') parser.add_argument('-th', '--threshold', type=float, default=0.3, help='The threshold to use when applying the \ Non-Max Suppresion') parser.add_argument( '--download-model', type=bool, default=False, help='Set to True, if the model weights and configurations \ are not present on your local machine.') parser.add_argument('-t', '--show-time', type=bool, default=False, help='Show the time taken to infer each image.') FLAGS, unparsed = parser.parse_known_args() # Download the YOLOv3 models if needed if FLAGS.download_model: subprocess.call(['./yolov3-coco/get_model.sh']) # Get the labels labels = open(FLAGS.labels).read().strip().split('\n') # Intializing colors to represent each label uniquely colors = np.random.randint(0, 255, size=(len(labels), 3), dtype='uint8') # Load the weights and configuration to form the pretrained YOLOv3 model net = cv.dnn.readNetFromDarknet(FLAGS.config, FLAGS.weights) net.setPreferableBackend(cv.dnn.DNN_BACKEND_CUDA) net.setPreferableTarget(cv.dnn.DNN_TARGET_CUDA) # Get the output layer names of the model layer_names = net.getLayerNames() layer_names = [ layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers() ] # If both image and video files are given then raise error if FLAGS.image_path is None and FLAGS.video_path is None: print('Neither path to an image or path to video provided') print('Starting Inference on Webcam') # Do inference with given image if FLAGS.image_path: # Read the image try: img = cv.imread(FLAGS.image_path) height, width = img.shape[:2] except: raise 'Image cannot be loaded!\n\ Please check the path provided!' finally: img, _, _, _, _ = infer_image(net, layer_names, height, width, img, colors, labels, FLAGS) show_image(img) elif FLAGS.video_path: # Read the video try: vid = cv.VideoCapture(FLAGS.video_path) height, width = None, None writer = None except: raise 'Video cannot be loaded!\n\ Please check the path provided!' finally: try: connection = mysql.connector.connect(host='localhost', user='******', password='') if connection.is_connected(): cursor = connection.cursor() try: print("Creating new database: 'vehicle_db'") cursor.execute("create database vehicle_db") print("Database created.") except: print("Database already exists.") print("Droping it") cursor.execute("DROP DATABASE vehicle_db") print("Creating New Database") cursor.execute("create database vehicle_db") print("New Database Created!") finally: cursor.close() connection.commit() connection.close() # Connecting to 'vehicle_db' database connection = mysql.connector.connect(host='localhost', database="vehicle_db", user='******', password='') # Creating a new cursor for the new connection cursor = connection.cursor() print("Connected to database: 'vehicle_db'") # removing all files from static folder dir_path = os.path.dirname(os.path.realpath(__file__)) dir_path += "/static/" files_to_remove = os.listdir(dir_path) for file in files_to_remove: os.remove(os.path.join(dir_path, file)) while True: grabbed, frame = vid.read() # frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB) # Checking if the complete video is read if not grabbed: break if width is None or height is None: height, width = frame.shape[:2] frame, _, _, _, _ = infer_image(net, layer_names, height, width, frame, colors, labels, connection, cursor, FLAGS) #cv.imshow('video_feed', frame) if writer is None: # Initialize the video writer fourcc = cv.VideoWriter_fourcc(*"mp4v") writer = cv.VideoWriter( FLAGS.video_output_path, fourcc, float(fps_of_video), (frame.shape[1], frame.shape[0]), True) writer.write(frame) print("[INFO] Cleaning up...") writer.release() vid.release() except Error as e: print("Connection error: {}".format(e)) finally: if (connection.is_connected()): cursor.close() connection.commit() connection.close() print("Connection closed") else: # Infer real-time on webcam count = 0 vid = cv.VideoCapture(0) while True: _, frame = vid.read() height, width = frame.shape[:2] if count == 0: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS) count += 1 else: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS, boxes, confidences, classids, idxs, infer=False) count = (count + 1) % 6 cv.imshow('webcam', frame) if cv.waitKey(1) & 0xFF == ord('q'): break vid.release() cv.destroyAllWindows()
if FLAGS.image_path is None and FLAGS.video_path is None: print('Neither path to an image or path to video provided') print('Starting Inference on Webcam') # Do inference with given image if FLAGS.image_path: # Read the image try: img = cv.imread(FLAGS.image_path) height, width = img.shape[:2] except: raise 'Image cannot be loaded!\n\ Please check the path provided!' finally: img, _, _, _, _ = infer_image(net, layer_names, height, width, img, colors, labels, FLAGS) show_image(img) elif FLAGS.video_path: # Read the video try: vid = cv.VideoCapture(FLAGS.video_path) height, width = None, None writer = None except: raise 'Video cannot be loaded!\n\ Please check the path provided!' finally: while True: grabbed, frame = vid.read()
def fun(frame, bb1): #_, frame = vid.read() #count = 0 height, width = frame.shape[:2] rgb_image = frame[:, :, ::-1] #results = model.detect([rgb_image], verbose=0) #print("count",count) if len(bb1) == 0: frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS) bb1 = get_car_boxes(boxes, classids) print("arra", bb1) #print(count) #count += 1 return frame, bb1 else: ans = [] frame, boxes, confidences, classids, idxs = infer_image(net, layer_names, \ height, width, frame, colors, labels, FLAGS)#, boxes, confidences, classids, idxs, infer=False) #count = (count + 1) #print("boxes",boxes) bb2 = [] bb2 = get_car_boxes1(boxes, classids) print("arra2", bb2) ##print("arra",bb1) overlaps = compute_overlaps(bb1, bb2) ##print("iou",iou) ##print("overlaps",overlaps) for parking_area, overlap_areas in zip(bb1, overlaps): max_IoU_overlap = np.max(overlap_areas) #print("max",max_IoU_overlap) x, y, w, h = parking_area x = x + 30 y = y + 30 w = w + 30 h = h + 30 print("max", max_IoU_overlap) if (max_IoU_overlap) < 0: for c in confidences: if c > 0.6: cv.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 3) else: for c in confidences: if c > 0.6: cv.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 3) #ans.append(max_IoU_overlap) #print("ans",ans) print("fraem", frame) return frame, bb1