def __init__(self, initial_frame, detector, tracker, droi, show_droi, mcdf, mctf, di, counting_lines, show_counts): self.frame = initial_frame # current frame of video self.detector = detector self.tracker = tracker self.droi = droi # detection region of interest self.show_droi = show_droi self.mcdf = mcdf # maximum consecutive detection failures self.mctf = mctf # maximum consecutive tracking failures self.detection_interval = di self.counting_lines = counting_lines self.blobs = {} self.f_height, self.f_width, _ = self.frame.shape self.frame_count = 0 # number of frames since last detection self.counts = { counting_line['label']: {} for counting_line in counting_lines } # counts of vehicles by type for each counting line self.show_counts = show_counts # create blobs from initial frame droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf)
def __init__(self, initial_frame, detector, tracker, droi, show_droi, mcdf, mctf, di, cl_position): self.frame = initial_frame # current frame of video self.detector = detector self.tracker = tracker self.droi = droi # detection region of interest self.show_droi = show_droi self.mcdf = mcdf # maximum consecutive detection failures self.mctf = mctf # maximum consecutive tracking failures self.di = di # detection interval self.cl_position = cl_position # counting line position self.blobs = OrderedDict() self.blob_id = 1 self.f_height, self.f_width, _ = self.frame.shape self.frame_count = 0 # number of frames since last detection self.vehicle_count = 0 # number of vehicles counted self.counting_line = None if cl_position == None else get_counting_line( self.cl_position, self.f_width, self.f_height) # create blobs from initial frame droi_frame = get_roi_frame(self.frame, self.droi) initial_bboxes = get_bounding_boxes(droi_frame, self.detector) for box in initial_bboxes: _blob = create_blob(box, frame, self.tracker) self.blobs[self.blob_id] = _blob self.blob_id += 1
def count(self, frame): self.frame = frame blobs_list = list(self.blobs.items()) # update blob trackers blobs_list = Parallel(n_jobs=NUM_CORES, prefer='threads')( delayed(update_blob_tracker)(blob, blob_id, self.frame) for blob_id, blob in blobs_list) self.blobs = dict(blobs_list) for blob_id, blob in blobs_list: # count vehicle if it has crossed a counting line blob, self.counts = attempt_count(blob, blob_id, self.counting_lines, self.counts) self.blobs[blob_id] = blob # remove blob if it has reached the limit for tracking failures if blob.num_consecutive_tracking_failures >= self.mctf: del self.blobs[blob_id] if self.frame_count >= self.detection_interval: # rerun detection droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf) self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 self.frame_count += 1
def __init__(self, initial_frame, detector, tracker, droi, show_droi, mcdf, mctf, di, cl_position): self.frame = initial_frame # current frame of video self.detector = detector self.tracker = tracker self.droi = droi # detection region of interest self.show_droi = show_droi self.mcdf = mcdf # maximum consecutive detection failures self.mctf = mctf # maximum consecutive tracking failures self.di = di # detection interval self.cl_position = cl_position # counting line position self.blobs = OrderedDict() self.f_height, self.f_width, _ = self.frame.shape self.frame_count = 0 # number of frames since last detection self.vehicle_count = 0 # number of vehicles counted self.types_counts = OrderedDict() # counts by vehicle type self.counting_line = None if cl_position == None else get_counting_line( self.cl_position, self.f_width, self.f_height) # create blobs from initial frame droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) #print (droi_frame) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.counting_line, self.cl_position, self.mcdf)
def __init__(self, initial_frame, detector, tracker, droi, show_droi, mcdf, mctf, di, counting_lines): self.frame = initial_frame self.detector = detector self.tracker = tracker self.droi = droi self.show_droi = show_droi self.mcdf = mcdf self.mctf = mctf self.di = di self.counting_lines = counting_lines self.blobs = {} self.f_height, self.f_width, _ = self.frame.shape self.frame_count = 0 self.counts = { counting_line['label']: {} for counting_line in counting_lines } droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame) print(_bounding_boxes) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf)
def count(self, frame): self.frame = frame counts_dict = {} blobs_list = list(self.blobs.items()) blobs_list = Parallel(n_jobs=num_cores, prefer='threads')( delayed(update_blob_tracker)(blob, blob_id, self.frame) for blob_id, blob in blobs_list) self.blobs = dict(blobs_list) for blob_id, blob in blobs_list: blob, self.counts = attempt_count(blob, blob_id, self.counting_lines, self.counts) self.blobs[blob_id] = blob if blob.num_consecutive_tracking_failures >= self.mctf: del self.blobs[blob_id] if self.frame_count >= self.di: droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf) self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 self.frame_count += 1
def count(self, frame): log = [] self.frame = frame for _id, blob in list(self.blobs.items()): # update trackers success, box = blob.tracker.update(self.frame) if success: blob.num_consecutive_tracking_failures = 0 blob.update(box) else: blob.num_consecutive_tracking_failures += 1 # count vehicles that have left the frame if no counting line exists # or those that have passed the counting line if one exists if (self.counting_line == None and (blob.num_consecutive_tracking_failures == self.mctf or blob.num_consecutive_detection_failures == self.mcdf) and not blob.counted) \ or \ (self.counting_line != None and is_passed_counting_line(blob.centroid, self.counting_line, self.cl_position) and not blob.counted): blob.counted = True self.vehicle_count += 1 # classes_of_interest = ['bicycle', 'car', 'motorcycle', 'bus', 'truck', 'person'] if blob.vehicle_type == 'bicycle': self.bicycle_count += 1 elif blob.vehicle_type == 'car': self.car_count += 1 elif blob.vehicle_type == 'truck': self.truck_count += 1 elif blob.vehicle_type == 'bus': self.bus_count += 1 log.append({ 'blob_id': _id, 'count': self.vehicle_count, 'datetime': datetime.now() }) if blob.num_consecutive_tracking_failures >= self.mctf: # delete untracked blobs del self.blobs[_id] if self.frame_count >= self.di: # rerun detection droi_frame = get_roi_frame(self.frame, self.droi) boxes, classes_types = get_bounding_boxes(droi_frame, self.detector) self.blobs, current_blob_id = add_new_blobs( boxes, classes_types, self.blobs, self.frame, self.tracker, self.blob_id, self.counting_line, self.cl_position, self.mcdf) self.blob_id = current_blob_id self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 self.frame_count += 1 return log
def __init__(self, initial_frame, detector, tracker, droi, show_droi, mcdf, mctf, di, counting_lines, speed_estimation_lines , show_counts,frames_processed, processing_frame_rate, roads,veh_light, ped_light, camera_height, focal_length, pixel_length, resolution, vanishing_point): self.frame = initial_frame # current frame of video self.detector = detector self.tracker = tracker self.droi = droi # detection region of interest self.show_droi = show_droi self.mcdf = mcdf # maximum consecutive detection failures self.mctf = mctf # maximum consecutive tracking failures self.detection_interval = di self.counting_lines = counting_lines self.roads = roads self.speed_estimation_lines = speed_estimation_lines self.blobs = {} self.blobID = 0 self.blobDistance = 0.0 self.f_height, self.f_width, _ = self.frame.shape self.frame_count = 0 # number of frames since last detection self.counts = {counting_line['label']: {} for counting_line in counting_lines} # counts of vehicles by type for each counting line self.show_counts = show_counts self.processing_frame_rate = processing_frame_rate self.frames_processed = frames_processed self.waiting_zone = create_waiting_zone(self.counting_lines,self.droi) self.isWaiting = 0 self.veh_light = veh_light self.ped_light = ped_light self.extend_flag = False self.reduce_flag = False self.extend_notification = 0 self.reduce_notification = 0 self.jaywalker_flag = False self.not_slowing_down_flag = False self.camera_height = camera_height self.focal_length = focal_length self.pixel_length= pixel_length self.resolution = resolution self.vanishing_point = vanishing_point # ============================================================================= # self.nearestBlobPosition = (0.0,0.0) # self.nearestBlobLastFramePosition = (0.0,0.0) # self.nearestBlobDistance = 0.0 # self.nearestBlobLastFrameDistance=0.0 # self.nearestBlob1FrameDistance=[] # self.NearestBlob = [] # self.NearestBlob_remaining_time = 0.0 # ============================================================================= # create blobs from initial frame((3) times) for x in range(6): self.blobID += 1 droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes(droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf, self.blobID)
def count(self, frame, dict1, frames_count, fps): self.frame = frame seconds = frames_count / fps video_time = str(datetime.timedelta(seconds=seconds)) blobs_list = list(self.blobs.items()) # update blob trackers blobs_list = Parallel(n_jobs=NUM_CORES, prefer='threads')( delayed(update_blob_tracker)(blob, blob_id, self.frame) for blob_id, blob in blobs_list) self.blobs = dict(blobs_list) for blob_id, blob in blobs_list: if (dict1.get(blob_id) is None): print('No value Present for Object Id : ' + blob_id) dict1[blob_id] = blob.type_confidence print('Updated Map') print("duration in seconds:", seconds) print("video time:", video_time) else: confidencePercentage = dict1.get(blob_id) if (blob.type_confidence > confidencePercentage): dict1.update({blob_id: blob.type_confidence}) print('Confidence updated for Object' + blob_id + 'with value ' + str(blob.type_confidence)) # count object if it has crossed a counting line blob, self.counts = attempt_count(blob, blob_id, self.counting_lines, self.counts) self.blobs[blob_id] = blob # remove blob if it has reached the limit for tracking failures if blob.num_consecutive_tracking_failures >= self.mctf: del self.blobs[blob_id] if self.frame_count >= self.detection_interval: # rerun detection droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf) self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 self.frame_count += 1
def count(self, frame): self.frame = frame blobs_list = list(self.blobs.items()) time0 = time.time() # update blob trackers blobs_list = [ update_blob_tracker(blob, blob_id, self.frame) for blob_id, blob in blobs_list ] # blobs_list = Parallel(n_jobs=num_cores, prefer='threads')( # delayed(update_blob_tracker)(blob, blob_id, self.frame) for blob_id, blob in blobs_list # ) tracking_time_ms = (time.time() - time0) * 1000 print("%d - %.3f" % (len(blobs_list), tracking_time_ms)) self.running_average(tracking_time_ms, is_detection=False) self.blobs = dict(blobs_list) for blob_id, blob in blobs_list: # count vehicle if it has crossed a counting line blob, self.counts = attempt_count(blob, blob_id, self.counting_lines, self.counts) self.blobs[blob_id] = blob # remove blob if it has reached the limit for tracking failures if blob.num_consecutive_tracking_failures >= self.mctf: del self.blobs[blob_id] if self.frame_count >= self.di: time0 = time.time() # rerun detection if self.use_droi: droi_frame = get_roi_frame(self.frame, self.droi) else: droi_frame = self.frame _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf) self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 det_time = float(time.time() - time0) * 1000 print("\t", det_time) self.running_average(det_time, is_detection=True) self.frame_count += 1
def count(self, frame): log = [] self.frame = frame if self.frame_count >= self.di: # rerun detection droi_frame = get_roi_frame(self.frame, self.droi) boxes = get_bounding_boxes(droi_frame, self.detector) self.blobs, current_blob_id = add_new_blobs( boxes, self.blobs, self.frame, self.tracker, self.blob_id, self.counting_line, self.cl_position, self.mcdf) self.blob_id = current_blob_id self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 for _id, blob in list(self.blobs.items()): # update trackers success, box = blob.tracker.update(self.frame) if success: blob.num_consecutive_tracking_failures = 0 blob.update(box) else: blob.num_consecutive_tracking_failures += 1 # delete untracked blobs if blob.num_consecutive_tracking_failures >= self.mctf: del self.blobs[_id] # count vehicles if is_passed_counting_line(blob.centroid, self.counting_line, self.cl_position) and not blob.counted: blob.counted = True self.vehicle_count += 1 (x, y, w, h) = [int(v) for v in blob.bounding_box] roi = self.frame[y:y + h + 40, x:x + w + 40] #cv2.imwrite(f"./detected/{self.vehicle_count}.jpg", roi) cv2.imwrite("./roi.jpg", roi) log.append({ 'blob_id': _id, 'count': self.vehicle_count, 'datetime': datetime.now() }) self.frame_count += 1 return log
def __init__(self, initial_frame, detector, tracker, droi, show_droi, mcdf, mctf, di, counting_lines, draw_counts, use_droi): self.frame = initial_frame # current frame of video self.detector = detector self.tracker = tracker self.droi = droi # detection region of interest self.show_droi = show_droi self.use_droi = use_droi self.mcdf = mcdf # maximum consecutive detection failures self.mctf = mctf # maximum consecutive tracking failures self.di = di # detection interval self.counting_lines = counting_lines self.blobs = {} self.f_height, self.f_width, _ = self.frame.shape self.frame_count = 0 # number of frames since last detection self.counts = { counting_line['label']: {} for counting_line in counting_lines } # counts of vehicles by type for each counting line self.draw_counts = draw_counts # create blobs from initial frame droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf) self.tracking_count = 0 self.tracking_average = 0 self.detection_count = 0 self.detection_average = 0 self.use_own_KCF_impl = False if self.use_own_KCF_impl: import multiprocessing as mp self.in_queue = mp.Queue() self.out_queue = mp.Queue() self.pool = mp.Pool(4, update_blob_tracker_queue, (self.in_queue, self.out_queue))
def count_queue(self, frame): self.frame = frame for blob_id, blob in self.blobs.items(): self.in_queue.put((blob, blob_id, self.frame)) num_blobs = len(self.blobs) processed_blobs = 0 while processed_blobs < num_blobs: blob_id, blob = self.out_queue.get(True) blob, self.counts = attempt_count(blob, blob_id, self.counting_lines, self.counts) self.blobs[blob_id] = blob # remove blob if it has reached the limit for tracking failures if blob.num_consecutive_tracking_failures >= self.mctf: del self.blobs[blob_id] processed_blobs += 1 if self.frame_count >= self.di: # rerun detection if self.use_droi: droi_frame = get_roi_frame(self.frame, self.droi) else: droi_frame = self.frame _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf) self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 self.frame_count += 1
def count(self, frame): log = [] self.frame = frame for _id, blob in list(self.blobs.items()): # update trackers success, box = blob.tracker.update(self.frame) if success: blob.num_consecutive_tracking_failures = 0 blob.update(box) log_info( 'Vehicle tracker updated.', { 'event': 'TRACKER_UPDATE', 'vehicle_id': _id, 'bounding_box': blob.bounding_box, 'centroid': blob.centroid, }) f = './ProcessRecords/Vehicletrackerupdated58.txt' with open(f, "a") as file: file.write('TRACKER_UPDATE' + '-' + 'id' + str(_id) + '-' + 'bounding_box' + str(blob.bounding_box) + '-' + 'centroid' + str(blob.centroid) + "\n") else: blob.num_consecutive_tracking_failures += 1 # count vehicles that have left the frame if no counting line exists # or those that have passed the counting line if one exists if (self.counting_line == None and \ (blob.num_consecutive_tracking_failures == self.mctf or blob.num_consecutive_detection_failures == self.mcdf) and \ not blob.counted) \ or \ (self.counting_line != None and \ # don't count a blob if it was first detected at a position past the counting line # this enforces counting in only one direction not is_passed_counting_line(blob.position_first_detected, self.counting_line, self.cl_position) and \ is_passed_counting_line(blob.centroid, self.counting_line, self.cl_position) and \ not blob.counted): blob.counted = True self.vehicle_count += 1 # count by vehicle type if blob.type != None: if blob.type in self.types_counts: self.types_counts[blob.type] += 1 else: self.types_counts[blob.type] = 1 log_info( 'Vehicle counted.', { 'event': 'VEHICLE_COUNT', 'id': _id, 'type': blob.type, 'count': self.vehicle_count, 'position_first_detected': blob.position_first_detected, 'position_counted': blob.centroid, 'counted_at': time.time(), }) f = './ProcessRecords/Vehiclecounted58.txt' with open(f, "a") as file: file.write('VEHICLE_COUNT' + '-' + 'id' + str(_id) + '-' + 'type' + str(blob.type) + '-' + 'count' + str(self.vehicle_count) + '-' + 'position_first_detected' + str(blob.position_first_detected) + '-' + 'position_counted' + str(blob.centroid) + '-' + 'counted_at' + str(time.time()) + "\n") if blob.num_consecutive_tracking_failures >= self.mctf: # delete untracked blobs del self.blobs[_id] if self.frame_count >= self.di: # rerun detection droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.counting_line, self.cl_position, self.mcdf) self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 self.frame_count += 1 return log
def __init__(self, initial_frame, detector, tracker, droi, show_droi, mcdf, mctf, di, cl_position): ha = os.path.join('detect-and-count-object','detectors') path = os.path.join(ha,'yolo') labelsPath = os.path.join(path,'coco.names') LABELS = open(labelsPath).read().strip().split("\n") self.frame = initial_frame # current frame of video self.detector = detector self.tracker = tracker self.droi = droi # detection region of interest self.show_droi = show_droi self.mcdf = mcdf # maximum consecutive detection failures self.mctf = mctf # maximum consecutive tracking failures self.di = di # detection interval self.cl_position = cl_position # counting line position self.countCar = 0 self.countTruck = 0 self.countBus = 0 self.countPerson = 0 self.countBicycle = 0 self.countMotorcycle = 0 self.blobs = OrderedDict() self.blob_id = 1 self.f_height, self.f_width, _ = self.frame.shape self.frame_count = 0 # number of frames since last detection self.vehicle_count = 0 # number of vehicles counted self.counting_line = get_counting_line(self.cl_position, self.f_width, self.f_height) # create blobs from initial frame droi_frame = get_roi_frame(self.frame, self.droi) initial_bboxes = get_bounding_boxes(droi_frame, self.detector) for box in initial_bboxes: #print(box) if self.detector == 'yolo': _blob = create_blob(box[0], frame, self.tracker) style = LABELS[box[1][0]] self.blobs[self.blob_id] = _blob, style self.blob_id += 1 else: _blob = create_blob(box, frame, self.tracker) self.blobs[self.blob_id] = _blob self.blob_id += 1
def visualize(self): ha = os.path.join('detect-and-count-object','detectors') path = os.path.join(ha,'yolo') labelsPath = os.path.join(path,'coco.names') LABELS = open(labelsPath).read().strip().split("\n") # initialize a list of colors to represent each possible class label np.random.seed(42) COLORS = np.random.randint(0, 255, size=(len(LABELS), 3), dtype="uint8") frame = self.frame f_height, f_width, _ = frame.shape # draw and label blob bounding boxes droi_frame = get_roi_frame(self.frame, self.droi) boxes = get_bounding_boxes(droi_frame, self.detector) if self.detector == 'yolo': for box in boxes: boxs = box[0] for i in box[2].flatten(): (x, y) = (int(boxs[0]), int(boxs[1])) (w, h) = (int(boxs[2]), int(boxs[3])) color = [int(c) for c in COLORS[box[1][0]]] cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2) text = "{}: {:.4f}".format(LABELS[box[1][0]],box[1][1]) cv2.putText(frame, text, (x, y - 5),cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2) else: for _id, blob in self.blobs.items(): (x, y, w, h) = [int(v) for v in blob.bounding_box] cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2) cv2.putText(frame, 'v_' + str(_id), (x, y - 2), cv2.FONT_HERSHEY_DUPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA) # draw counting line cv2.line(frame, self.counting_line[0], self.counting_line[1], (0, 255, 0), 3) # display vehicle count cv2.rectangle(frame, (0, 0), (f_width, 75), (180, 132, 109), -1) textPosition = int(f_width/7) if f_width <= 1280: textSize = 0.5 else: textSize = 1 cv2.putText(frame, 'Total: ' + str(self.vehicle_count), (10, 60), cv2.FONT_HERSHEY_DUPLEX, textSize, (255, 0, 0,), 1, cv2.LINE_AA) cv2.putText(frame, 'Car: ' + str(self.countCar), (textPosition, 60), cv2.FONT_HERSHEY_DUPLEX, textSize, (255, 0, 0), 1, cv2.LINE_AA) cv2.putText(frame, 'Bus: ' + str(self.countBus), (textPosition*2, 60), cv2.FONT_HERSHEY_DUPLEX, textSize, (255, 0, 0), 1, cv2.LINE_AA) cv2.putText(frame, 'Truck: ' + str(self.countTruck), (textPosition*3, 60), cv2.FONT_HERSHEY_DUPLEX, textSize, (255, 0, 0), 1, cv2.LINE_AA) cv2.putText(frame, 'People: ' + str(self.countPerson), (textPosition*4, 60), cv2.FONT_HERSHEY_DUPLEX, textSize, (255, 0, 0), 1, cv2.LINE_AA) cv2.putText(frame, 'Bicycle: ' + str(self.countBicycle), (textPosition*5, 60), cv2.FONT_HERSHEY_DUPLEX, textSize, (255, 0, 0), 1, cv2.LINE_AA) cv2.putText(frame, 'Motorcycle: ' + str(self.countMotorcycle), (textPosition*6, 60), cv2.FONT_HERSHEY_DUPLEX, textSize, (255, 0, 0), 1, cv2.LINE_AA) # show detection roi if self.show_droi: frame = draw_roi(frame, self.droi) return frame
def count(self, frame): log = [] self.frame = frame if self.frame_count >= self.di: # rerun detection droi_frame = get_roi_frame(self.frame, self.droi) boxes = get_bounding_boxes(droi_frame, self.detector) #print(self.blobs) self.blobs, current_blob_id = add_new_blobs(boxes, self.blobs, self.frame, self.tracker, self.blob_id, self.counting_line, self.cl_position, self.mcdf, self.detector) self.blob_id = current_blob_id self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 for _id, blob in list(self.blobs.items()): # update trackers #print(blob[0]) success, box = blob[0].tracker.update(self.frame) if success: blob[0].num_consecutive_tracking_failures = 0 blob[0].update(box) else: blob[0].num_consecutive_tracking_failures += 1 # delete untracked blobs if blob[0].num_consecutive_tracking_failures >= self.mctf: del self.blobs[_id] # count vehicles if is_passed_counting_line(blob[0].centroid, self.counting_line, self.cl_position) and not blob[0].counted: blob[0].counted = True if blob[1] == 'car': self.countCar +=1 elif blob[1] == 'bus': self.countBus +=1 elif blob[1] == 'truck': self.countTruck +=1 elif blob[1] == 'person': self.countPerson +=1 elif blob[1] == 'bicycle': self.countBicycle +=1 elif blob[1] == 'motorcycle': self.countMotorcycle +=1 self.vehicle_count += 1 log.append({'blob_id': _id, 'count': self.vehicle_count, 'datetime': datetime.now()}) self.frame_count += 1 return log
import cv2 from detectors.detector import get_bounding_boxes from config import CURRENT_DIR IMAGE_PATH = f"{CURRENT_DIR}/data/screenshots/ff.jpg" IMAGE_NAME = IMAGE_PATH.split("/")[-1].split(".")[0] IMAGE_EXT = IMAGE_PATH.split("/")[-1].split(".")[1] if __name__ == "__main__": image = cv2.imread(IMAGE_PATH) _bounding_boxes, _classes, _confidences = get_bounding_boxes(image) font = cv2.FONT_HERSHEY_DUPLEX line_type = cv2.LINE_8 for i in range(0, len(_bounding_boxes)): (x, y, w, h) = [int(v) for v in _bounding_boxes[i]] cv2.rectangle(image, (x, y), (x + w, y + h), (255, 0, 0), 2) cv2.putText(image, _classes[i], (x, y - 5), font, 1, (255, 0, 0), 2, line_type) # cv2.imwrite(f"{IMAGE_NAME}_detected.{IMAGE_EXT}", image) cv2.imshow("fdf", image) cv2.waitKey(0)
def count(self, frame): _timer = cv2.getTickCount( ) # set timer to calculate processing frame rate self.frame = frame for _id, blob in list(self.blobs.items()): # update trackers success, box = blob.tracker.update(self.frame) if success: blob.num_consecutive_tracking_failures = 0 blob.update(box) logger.debug('Vehicle tracker updated.', extra={ 'meta': { 'cat': 'TRACKER_UPDATE', 'vehicle_id': _id, 'bounding_box': blob.bounding_box, 'centroid': blob.centroid, }, }) else: blob.num_consecutive_tracking_failures += 1 # count vehicles that have left the frame if no counting line exists # or those that have passed the counting line if one exists if (self.counting_line == None and \ (blob.num_consecutive_tracking_failures == self.mctf or blob.num_consecutive_detection_failures == self.mcdf) and \ not blob.counted) \ or \ (self.counting_line != None and \ # don't count a blob if it was first detected at a position past the counting line # this enforces counting in only one direction not is_passed_counting_line(blob.position_first_detected, self.counting_line, self.cl_position) and \ is_passed_counting_line(blob.centroid, self.counting_line, self.cl_position) and \ not blob.counted): blob.counted = True self.vehicle_count += 1 # count by vehicle type if blob.type != None: if blob.type in self.types_counts: self.types_counts[blob.type] += 1 else: self.types_counts[blob.type] = 1 logger.info('Vehicle counted.', extra={ 'meta': { 'cat': 'VEHICLE_COUNT', 'id': _id, 'type': blob.type, 'count': self.vehicle_count, 'position_first_detected': blob.position_first_detected, 'position_counted': blob.centroid, 'counted_at': time.time(), }, }) if blob.num_consecutive_tracking_failures >= self.mctf: # delete untracked blobs del self.blobs[_id] if self.frame_count >= self.di: # rerun detection droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes( droi_frame, self.detector) self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.counting_line, self.cl_position, self.mcdf) self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 self.frame_count += 1 self.processing_frame_rate = round( cv2.getTickFrequency() / (cv2.getTickCount() - _timer), 2) logger.debug('Processing frame rate updated.', extra={ 'meta': { 'cat': 'PROCESSING_SPEED', 'frame_rate': self.processing_frame_rate }, })
clposition = 'bottom' if args.clposition == None else args.clposition counting_line = get_counting_line(clposition, f_width, f_height) vehicle_count = 0 # create detection ROI droi = [(0, 0), (f_width, 0), (f_width, f_height), (0, f_height)] if args.droi: droi = [] points = args.droi.replace(' ', '').split('|') for point_str in points: point = tuple(map(int, point_str.split(','))) droi.append(point) # initialize trackers and create new blobs droi_frame = get_roi_frame(frame, droi) initial_bboxes = get_bounding_boxes(droi_frame, detector) for box in initial_bboxes: _blob = create_blob(box, frame, tracker) blobs[blob_id] = _blob blob_id += 1 while True: k = cv2.waitKey(1) if args.iscam or cap.get(cv2.CAP_PROP_POS_FRAMES) + 1 < cap.get( cv2.CAP_PROP_FRAME_COUNT): _, frame = cap.read() nframes = cap.get(cv2.CAP_PROP_POS_FRAMES) frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT) if nframes % 10 == 0 or nframes == 1: print("Processing {} of {} frames".format(nframes, frame_count))
def count(self, frame,frames_processed, processing_frame_rate): self.frame = frame self.processing_frame_rate = processing_frame_rate self.frames_processed = frames_processed self.isWaiting = 0 # rescan_requested = False # self.nearestBlobLastFrameDistance = self.nearestBlobDistance blobs_list = list(self.blobs.items()) # update blob trackers blobs_list = Parallel(n_jobs=NUM_CORES, prefer='threads')( delayed(update_blob_tracker)(blob, blob_id, self.frame) for blob_id, blob in blobs_list ) self.blobs = dict(blobs_list) for blob_id, blob in blobs_list: # count vehicle if it has crossed a counting line blob, self.counts = attempt_count(blob, blob_id, self.counting_lines,self.speed_estimation_lines , self.counts, self.frames_processed,self.processing_frame_rate) self.blobs[blob_id] = blob # remove blob if it has reached the limit for tracking failures if blob.num_consecutive_tracking_failures >= self.mctf: del self.blobs[blob_id] if self.detector == 'yolo': blob.onRoad = str(_is_on_which_roads(self.roads, blob)) blob.distance = distance_cal(blob.position,self.camera_height,self.focal_length,self.pixel_length,self.resolution,self.vanishing_point) # self.NearestBlob, self.nearestBlobPosition , rescan_requested = UpdateNearestBlobPosition(blob, blob_id, blobs_list, self.nearestBlobPosition, self.NearestBlob, rescan_requested) # self.nearestBlobDistance = distance_cal(self.nearestBlobPosition[1]) # check blob is waiting if self.detector == 'yolo_p': if self.veh_light == 0: point = Point(blob.bottom_point) polygon = Polygon(self.waiting_zone[0:4]) polygon2 = Polygon(self.waiting_zone[-4:]) if polygon.contains(point) == True or polygon2.contains(point) == True: blob.isJaywalker = False self.isWaiting += 1 else: blob.isJaywalker = True self.jaywalker_flag = True if self.ped_light != 0: blob.isJaywalker = False self.jaywalker_flag = False # ============================================================================= # if rescan_requested: # self.nearestBlob1FrameDistance=[] # self.nearestBlobPosition = (0,0) # for blob_id, blob in blobs_list: # self.NearestBlob, self.nearestBlobPosition , rescan_requested = UpdateNearestBlobPosition(blob, blob_id, blobs_list, self.nearestBlobPosition, self.NearestBlob,rescan_requested) # self.nearestBlobDistance = distance_cal(self.nearestBlobPosition[1]) # self.nearestBlobLastFrameDistance = self.nearestBlobDistance # rescan_requested = False # ============================================================================= # if self.processing_frame_rate > 0 and self.nearestBlobPosition[1] > 0 and self.nearestBlobDistance != self.nearestBlobLastFrameDistance and rescan_requested == False: # ============================================================================= # print('nor_list'+str(normalizing_1frame_distance(self.nearestBlobDistance,self.nearestBlobLastFrameDistance,self.nearestBlob1FrameDistance))) # print('list'+str(self.nearestBlob1FrameDistance)) # print('1 '+str(self.nearestBlobDistance)) # print('2 '+str(self.nearestBlobLastFrameDistance)) # ============================================================================= # self.NearestBlob_remaining_time = cal_remaining_time( (self.nearestBlobDistance / normalizing_1frame_distance(self.nearestBlobDistance,self.nearestBlobLastFrameDistance,self.nearestBlob1FrameDistance)),1,self.processing_frame_rate) if self.frame_count >= self.detection_interval: # rerun detection droi_frame = get_roi_frame(self.frame, self.droi) _bounding_boxes, _classes, _confidences = get_bounding_boxes(droi_frame, self.detector) self.blobID += 1 self.blobs = add_new_blobs(_bounding_boxes, _classes, _confidences, self.blobs, self.frame, self.tracker, self.mcdf, self.blobID) self.blobs = remove_duplicates(self.blobs) self.frame_count = 0 self.frame_count += 1