def detect_common_objects(image): """Detects common objects""" bbox, label, conf = cv.detect_common_objects(image, confidence=0.25, model="yolov4-tiny") output_image = draw_bbox(image, bbox, label, conf) return output_image
def analyzeHike(): global masterCounter, start_time for i in range(MAX_INDEX + 1): imagePath = dataPath + str(hikeID) + "/" + str(i) + "_cam2r.jpg" im = cv2.imread(imagePath) bbox, label, conf = cv.detect_common_objects(im) print("# image {}: \n\t{} \n\t{}".format(i, label, conf)) res = [] for j in range(len(label)): if (conf[j] > CONF_THRESHOLD): res.append(label[j]) tmpCounter = Counter(res) masterCounter += tmpCounter print("### Filtered: {}".format(tmpCounter)) print("### Updated Master: {}".format(masterCounter)) # if (i > 5): # exit() print("--- %s seconds ---" % (time.time() - start_time))
def check_for_objects(image_path): # load image with OpenCV image = cv2.imread(image_path) # get dimensions of original image og_height, og_width, rgb = image.shape total_widths = 0 total_heights = 0 # with computer vision, identify objects and return the bounding box co-ordinates, corrensponding labels and confidence scores coordinates, item, confidence = cvlib.detect_common_objects(image) if coordinates and coordinates[0]: # save coordinates of object for coordinate in coordinates: # unpacking coordinates of each object found x1, y1, x2, y2 = coordinate total_widths += (x2 - x1) total_heights += (y2 - y1) # calculate area to see if the objects occupy at least 50% of the image if (total_widths * total_heights) / (og_width * og_height) > 0.5: # add rectangles around the objects to the image with the axes, readjust rgb color back to original since OpenCV reads image colors differently output_image = cv2.cvtColor( draw_bbox(image, coordinates, item, confidence), cv2.COLOR_BGR2RGB) pyplot.imshow(output_image) return True return False
def obj_detect(img): """Function to proccess an image through cvlib API. Args: img (numpy.ndarray) = Array of image to proccess. Return: Dictionary of results. """ name = str(uuid4()) result = {} # Apply object detection bbox, labels, conf = cv.detect_common_objects(img, confidence=0.40) # Create results dictionary. for element in labels: result[element] = labels.count(element) # Draw bounding box over detected objects out = draw_bbox(img, bbox, labels, conf) img_data = base64.b64encode(out) #_, img_encoded = cv2.imencode('.jpg', out) #result['img'] = img_data try: os.mkdir('image/') except FileExistsError as error: pass # Save output archive_name = "image/" + name + ".jpg" cv2.imwrite(archive_name, out) # Function to save img in blob storage send_to_blob() return(result)
def detect_objects(image): im = cv2.imread(image) bbox, label, conf = cv.detect_common_objects(im) output_image = draw_bbox(im, bbox, label, conf) output_image = cv2.cvtColor(output_image, cv2.COLOR_BGR2RGB) plt.imsave('{}/response.jpg'.format(image.split('/')[0]), output_image)
def is_correct(self, obj, url, taskkey): while True: try: image = requests.get(url) nparr = np.frombuffer(image.content, np.uint8) im = cv2.imdecode(nparr, flags=1) objects = cv.detect_common_objects(im, confidence=0.5, nms_thresh=1, enable_gpu=False)[1] if obj.lower() in objects: print( f'{Fore.GREEN}[{Fore.WHITE}INFO{Fore.GREEN}] {Fore.CYAN}{taskkey}.jpg is a {obj}' ) self.builder['answers'][taskkey] = 'true' return print( f'{Fore.GREEN}[{Fore.WHITE}INFO{Fore.GREEN}] {Fore.CYAN}{taskkey}.jpg is not a {obj}' ) self.builder['answers'][taskkey] = 'false' break except Exception as e: print( f"{Fore.RED}[{Fore.WHITE}ERROR{Fore.RED}] Unexpected error: {Fore.WHITE}{e}" )
def main(): config.init() iteration = 0 savedContentList = [] for framename in os.listdir(config.input_dir): print("iteration: " + str(iteration)) frame = cv2.imread(config.input_dir + "/" + framename) #collect infos frame, emotions, face_boxes = config.emotion_model.recognise_emotion(frame) person_boxes, env_boxes, person_labels, env_labels, confs = cvlib.detect_common_objects(frame, confidence=.75) frame = cvlib.object_detection.draw_person_bbox(frame, person_boxes, person_labels, confs, write_conf=False) frame = cvlib.object_detection.draw_env_bbox(frame, env_boxes, env_labels, confs, write_conf=False) words = txtConv.convert(frame) # create photoObject photo_object = po.PhotoObject(emotions, face_boxes, person_boxes, env_boxes, person_labels, env_labels, words, time.time()) #check content_identifier = isValidContent(photo_object, savedContentList) if(content_identifier != "no_identifer"): cv2.imwrite(config.output_dir + '%s_%s.jpeg' % (iteration, content_identifier), frame) row_content = [framename[4:5],iteration,content_identifier,time.strftime('%H:%M:%S', helper.getLocalTime(photo_object.photo_time))] helper.save_to_csv('output/contents.csv', row_content) savedContentList.append(po.ContentToSave(content_identifier, photo_object)) print("relevant picture saved.") iteration+=1
def detect(self, frame: np.array, det_objs: set = None) -> (int, np.array, list): bbox, labels, conf = cv.detect_common_objects( frame, confidence=.5, model=self.model, ) self.logger.info(labels) # only keep in the det_objs set if det_objs is not None: idxs = [i for i, l in enumerate(labels) if l in det_objs] labels = list(np.array(labels)[idxs]) bbox = list(np.array(bbox)[idxs]) conf = list(np.array(conf)[idxs]) frame = draw_bbox( img=frame, bbox=bbox, labels=labels, confidence=conf, write_conf=False, ) return 0, frame, labels
def getCoordinatesMultiTargetLP(self, img, targets=[]): if len(targets) == 0: targets.append(self.target) bbox, label, conf = cv.detect_common_objects( img, model='yolov4-tiny') #detects objects returnTargets = [] #creates the array for returning the objects if len(label) != 0: #xCo=None #yCo=None for i in range(0, len(label)): #loops through the labels if label[ i] in self.targets: #checks if the label is equal to one of the targets x = bbox[i] xCo = (x[0] + x[2] ) / 2 #calculates the centre of the bounding box yCo = (x[1] + x[3]) / 2 returnTargets.append( [label[i], xCo, yCo]) #appends the label and coordiates to the list #except: else: #xCo=None #yCo=None returnTargets = None #sets the list to None if self.imageReturnQueue != None: warnings.warn('placing an image on the return Queue') self.imageReturnQueue.put({ 'img': img, 'box': bbox, 'label': label, 'confidence': conf }) #returns the image else: warning.warn('no queue found') return returnTargets
def uploadPhoto(photo): im = cv2.imread(photo) bbox, label, conf = cv.detect_common_objects(im) output_image = draw_bbox(im, bbox, label, conf) print(label) addQuery(label) return output_image
def main(): # instantiate video capture object cap = cv2.VideoCapture(0) # creating a queue to share data to speech process speakQ = multiprocessing.Queue() # creating speech process to not hang processor p1 = multiprocessing.Process(target=speak, args=(speakQ, )) # starting process 1 - speech p1.start() # keeps program running forever until ctrl+c or window is closed while True: # capture image _, img = cap.read() # use detect common objects model to label objects bbox, labels, conf = cv.detect_common_objects(img) # draw labels img = draw_bbox(img, bbox, labels, conf) # send unique string denoting new labels being sent to speech speakQ.put('#new#') # send each label to text to speech process for label in labels: speakQ.put(label.lower()) # display and wait 10ms cv2.imshow('my webcam', img) cv2.waitKey(10) # clean up if you want to remove while loop cap.release() p1.terminate() cv2.destroyAllWindows()
def process(time): counts = {1: 29, 2: 26, 3: 75, 4: 51} for i in range(4): if int(time) <= lot_limit[i]: img_name = '../img/' + lot[i] + '_' + time + '.jpg' im = cv2.imread(img_name) bbox, label, conf = cv.detect_common_objects(im) output_image = draw_bbox(im, bbox, label, conf, colors=np.random.uniform(80, 81, size=(80, 3))) # plt.savefig("../output_img/"+lot[i] + '_' + time + '.jpg') cv2.imwrite("../output_img/" + lot[i] + '_' + time + '.jpg', output_image) # plt.subplots() # plt.imshow(output_image) # plt.show() count = label.count('car') counts[i + 1] -= count else: counts[i + 1] = -1 return counts
def detect(): path = os.getcwd() img = cv2.imread(path + "/pics/frame5.jpg") boxes, labels, _conf = cv.detect_common_objects(img, model="yolov3") print(labels) return labels
def detect(self, image): npimg = np.fromstring(image, np.uint8) image = cv2.imdecode(npimg, cv2.IMREAD_COLOR) _, labels, _ = cv.detect_common_objects(image) if "cat" in labels: self.found = True self.missed_frame = MISSED_FRAME_COUNTER self.lost_timestamp = None if self.found_timestamp is None: self.found_timestamp = datetime.now() now = datetime.now() if self.last_time_saved is None or now > self.last_time_saved: self.last_time_saved = now + timedelta(minutes = 5) cv2.imwrite(os.path.join(os.getcwd(), 'cat', str(now.timestamp()) + ".jpg"), image) print("Cat found at: {}". format(now)) elif self.found: if self.missed_frame > 0: self.missed_frame -= 1 if self.lost_timestamp is None: self.lost_timestamp = datetime.now() else: Thread(target=save_event, args=[self.found_timestamp, self.lost_timestamp]).start() self.found = False self.found_timestamp = None
def car_count(image_path): """ Parameters ---------- image_path : string expects a file path to an image in jpg format. Returns ------- car_count: integer If the file path is valid, a count of the number of cars, trucks, and buses in the image is returned. """ try: # read in image im = cv2.imread(image_path) # detect objects in image bbox, label, conf = cv.detect_common_objects(im) # sum the number of trucks cars and buses car_count = label.count('truck') + label.count('car') + label.count( 'bus') except: # if unable to read image return NA car_count = np.nan return car_count
def get_objects_of_interest(frame): """REQUIRED function. There are two options for getting a detector's results: Either get_confidence_score() OR get_objects_of_interest() get_confidence_score() must return a confidence level from 0.00 to 1.00. This represents how confident the detector is that something is out of the ordinary. get_objects_of_interest() returns a list of tuples, where each object is formatted like this: (geometry, object_name, object_confidence) """ global _min_confidence if _min_confidence is None: # Ensure _min_confidence != None logger.error("Unable to fetch _min_confidence from the database!") logger.error("_min_confidence was None!") logger.warning("Falling back to default confidence of 0.25.") _min_confidence = 0.25 objects_of_interest = [] geometry, label, conf = cv.detect_common_objects( frame, confidence=_min_confidence, model='yolov3-tiny') for i in range(len(label)): # Iterate over every object object_tuple = (geometry[i], label[i], conf[i]) objects_of_interest.append(object_tuple) # All objects should be in the list now... return objects_of_interest
def detect_objects_basic(self, frame, mask): detected_objects = [] print(frame.shape) # bbox, label, conf = detect_common_objects(frame, confidence=0.25) # bbox, label, conf = detect_common_objects(frame, confidence=0.75, enable_gpu=True) bbox, label, conf = detect_common_objects(frame, confidence=0.3, model='yolov3-tiny') if DEBUG_MODE: output_image = draw_bbox(frame, bbox, label, conf) cv2.imshow('all objects', output_image) # for i in range(len(bbox)): # detected_objects.append({ # 'label': label[i], # 'bbox': bbox[i], # 'conf': conf[i], # 'x': extracted_object['x'], # 'y': extracted_object['y'], # 'width': extracted_object['width'], # 'height': extracted_object['height'], # 'center_x': int(extracted_object['x'] + extracted_object['width'] / 2), # 'center_y': int(extracted_object['y'] + extracted_object['height'] / 2) # }) print(detected_objects) return detected_objects
def countVeh(imagePath): """ TO COUNT NO OF VEHICHLES Using Tiny Yolo v3 Pre-Trained on Ms-Coco dataset Arguments: imagePath {[string]} -- [path of image] """ image = cv2.imread(imagePath) #boundingbox, label, conf = cv.detect_common_objects(image) boundingbox, label, conf = cv.detect_common_objects(image, confidence=0.25, model='yolov3-tiny') output_image = draw_bbox(image, boundingbox, label, conf) plt.imshow(output_image) plt.show() print('Number of Objects in the image is ', "Cars :", str(label.count('car')), " Bikes :", str(label.count('motorcycle')), " Bicycles :", str(label.count('bicycle')), " Trucks :", str(label.count('truck')), "Bus :", str(label.count('bus'))) countJson = { "Labels": { "Cars": label.count('car'), "Bikes": label.count('motorcycle'), "Bicycles": label.count('bicycle'), "Trucks": label.count('truck'), "Bus": label.count('bus') } } allImageCount[imagePath] = countJson
def live(): loadvideo = cv2.VideoCapture('data/demo.mp4') if not loadvideo.isOpened(): print("Could not open video") exit() while loadvideo.isOpened(): status, frame = loadvideo.read() if not status: break bbox, label, conf = cv.detect_common_objects(frame, confidence=0.25, model='yolov3-tiny') print(bbox, label, conf) out = draw_bbox(frame, bbox, label, conf, write_conf=True) cv2.imshow("Real-time object detection", out) if cv2.waitKey(1) & 0xFF == ord('q'): break loadvideo.release() cv2.destroyAllWindows()
def obj_det(): global obj_list,frame while not stop: resz_frame=cv2.resize(frame,(160,120)) with tf.device("/CPU:0"): b,l,c = cv.detect_common_objects(resz_frame,enable_gpu=False,model='yolov3lite') ls1=[] for box,label,conf in zip(b,l,c): if label=='person': x1=int(box[0]*d[0]/160) y1=int(box[1]*d[1]/120) x2=int(box[2]*d[0]/160) y2=int(box[3]*d[1]/120) x=int(x1+(x2-x1)/2) y=int(y2+(y1-y2)/2) color = list(np.random.random(size=3) * 256) ls1.append((x,y)) obj_list=ls1[:] return
def upload_to_aws(): #we know for sure that the apple.jpg is in fact existent s3 = boto3.client('s3', aws_access_key_id=ACCESS_KEY, aws_secret_access_key=SECRET_KEY) bucketname = 'elasticbeanstalk-us-east-1-864793221722' keyname = 'input.jpg' tmp = tempfile.NamedTemporaryFile() with open(tmp.name, 'wb') as f: s3.download_fileobj(bucketname, keyname, f) im = cv2.imread(tmp.name) h, w, c = im.shape centerx = w / 2 centery = h / 2 bbox, label, conf = cv.detect_common_objects(im) finallist = [x for x in bbox if determine(x, centerx, centery)] if (len(finallist) > 0): left = finallist[0][0] top = finallist[0][1] right = finallist[0][2] bottom = finallist[0][3] im1 = im[top:bottom, left:right] cv2.imwrite("output.jpg", im1) s3.upload_file("output.jpg", bucketname, 'trial2.jpg') os.remove("output.jpg") return 'went fine'
def video_stream(): # grab the frame from the threaded video stream frame = cap.read() frame = frame[1] if args.get("input", False) else frame #print(_) # convert the input frame from BGR to RGB then resize it to have # a width of 750px (to speedup processing) rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) rgb = imutils.resize(frame, width=750) #plt.imshow(frame) #plt.show() #r = frame.shape[1] / float(rgb.shape[1]) # detect the (x, y)-coordinates of the bounding boxes # corresponding to each face in the input frame, then compute # the facial embeddings for each face bbox, label, conf = cv.detect_common_objects(rgb, enable_gpu=True) frame = draw_bbox(rgb, bbox, label, conf) #cv2.line(frame, (0, 250),(750,250),(0, 0, 0)) #are supposed to display the output frame to # the screen if args["display"] > 0: fram = frame cv2image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGBA) img = Image.fromarray(cv2image) imgtk = ImageTk.PhotoImage(image=img) lmain.imgtk = imgtk lmain.configure(image=imgtk) lmain.after(1, video_stream)
def calibrate_camera(): img = cv2.imread('images/calibration_30.jpg') bbox, label, conf = cv.detect_common_objects(img) width = bbox[label.index('orange')][2] - \ bbox[label.index('orange')][0] width *= FACTOR_FROM_RESIZE focal_length = (width * KNOWN_DISTANCE) / KNOWN_SIZE return focal_length
def detect3(): im = cv2.imread('image/cam3.jpeg') bbox, label, conf = cv.detect_common_objects(im) output_image = draw_bbox(im, bbox, label, conf) s3 = int(label.count('car')) s3d = s3 print("number of vehicles", s3) calculation3(s3)
def clicked(self): filename = askopenfilename() img = mpimg.imread(filename) imgplot = plt.imshow(img) im = cv2.imread(filename) bbox, label, conf = cv.detect_common_objects(im) output_image = draw_bbox(im, bbox, label, conf) plt.imshow(output_image) plt.show()
def detect4(): im = cv2.imread('image/cam4.jpeg') bbox, label, conf = cv.detect_common_objects(im) output_image = draw_bbox(im, bbox, label, conf) s4 = int(label.count('car')) s4d = s4 print("no of vehicles", s4) calculation4(s4d)
def detect(): im = cv2.imread('image/cam1.jpeg') bbox, label, conf = cv.detect_common_objects(im) output_image = draw_bbox(im, bbox, label, conf) s=int(label.count('car')) s1d=s print("no of vehicles1 ",s) calculation1(s)
def countVehicleVideo(videoPath): """[summary] Arguments: videoPath {[string]} -- [VideoPath] """ vidObj = cv2.VideoCapture(videoPath) count = 0 success = 1 while success: success, image = vidObj.read() boundingbox, label, conf = cv.detect_common_objects( image, confidence=0.20, model='yolov3-tiny') output_image = draw_bbox(image, boundingbox, label, conf) car = label.count('car') bike = label.count('motorcycle') bicycle = label.count('bicycle') truck = label.count('truck') bus = label.count('bus') if not ((bike == 0) and (car == 0) and (truck == 0) and (bus == 0) and (bicycle == 0)): print(len(label)) plt.imshow(output_image) plt.show() print('Number of Objects in the image is ', "Cars :", str(car), " Bikes :", str(bike), " Bicycles :", str(bicycle), " Trucks :", str(truck), "Bus :", str(bus)) countJson = { "Labels": { "Cars": car, "Bikes": bike, "Bicycles": bicycle, "Trucks": truck, "Bus": bus } } allImageCount["img{:d}".format(count)] = countJson count += 1 #boundingbox, label, conf = cv.detect_common_objects(image) vidObj.release() cv2.destroyAllWindows()
def detect2(): im = cv2.imread('image/cam2.jpeg') bbox, label, conf = cv.detect_common_objects(im) output_image = draw_bbox(im, bbox, label, conf) s2 = int(label.count('car')) s2d = s2 print("no of vehicles2", s2) calculation2(s2)
def get_image_data(df): #df = pd.read_csv("data/data.csv") df = df.values freq_list = [] sessions = {} for i in range(len(df)): X = df[i, 1] X = json.loads(X) Y = df[i, 2] Y = json.loads(Y) im = cv2.imread('data/images/image' + str(i) + '.png') dim = (1920, 1080) resized = cv2.resize(im, dim, interpolation=cv2.INTER_AREA) bbox, label, conf = cv.detect_common_objects(resized) freq = 0 for j in range(len(label)): if label[j] != 'laptop' and label[j] != 'tv': x1, y1, x2, y2 = bbox[j] for k in range(len(X)): if FindPoint(x1, y1, x2, y2, X[k], Y[k]): freq += 1 if len(X) != 0: freq_list.append(freq / len(X)) else: freq_list.append(0) output_image = draw_bbox(resized, bbox, label, conf) if len(X) > 2: try: hmax = sns.kdeplot(X, Y, color='r', shade=True, cmap=alpha_cmap(plt.cm.viridis), shade_lowest=False) #hmax.collections[0].set_alpha(0) xmin = min([x for x in X if x > 0]) xmax = max([x for x in X if x < 1980]) ymin = min([x for x in Y if x > 0]) ymax = max([x for x in Y if x < 1080]) print(xmin, xmax, ymin, ymax) if df[i, 4] not in sessions: sessions[df[i, 4]] = [(abs((ymax - ymin) * (xmax - xmin)), (im.shape[0] * im.shape[1]))] else: sessions[df[i, 4]].append((abs( (ymax - ymin) * (xmax - xmin)), (im.shape[0] * im.shape[1]))) except: print("exception occured") plt.imshow(output_image, zorder=0) plt.savefig("heatmaps/map" + str(i) + ".png") plt.clf() return freq_list, sessions