lineFunction = LineFunction(line[0], line[1]) # check to see if the object has been counted or not # if the direction is negative (indicating the object # is moving up) AND the centroid is above the center # line, count the object # if updown_direction if line[2] == 'down': if updown_direction < 0 and lineFunction.fx( centroid) * lineFunction.fx(mean_point) < 0: totalExit += 1 box_draw_controller.exit_register(objectID) stay_estimator.add_frame_out(frame_number) to.centroids = list() # if the direction is positive (indicating the object # is moving down) AND the centroid is below the # center line, count the object elif updown_direction > 0 and lineFunction.fx( centroid) * lineFunction.fx(mean_point) < 0: totalEnter += 1 box_draw_controller.enter_register(objectID) stay_estimator.add_frame_in(frame_number) to.centroids = list() elif line[2] == 'up': if updown_direction < 0 and lineFunction.fx( centroid) * lineFunction.fx(mean_point) < 0: totalEnter += 1 box_draw_controller.enter_register(objectID)
def doStuff(self, frame, origFrame, W, H): # the frame from BGR to RGB for dlib # frame = imutils.resize(frame, width=500) rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) # if the frame dimensions are empty, set them if W is None or H is None: (H, W) = frame.shape[:2] if self.origW is None or self.origH is None: (self.origW, self.origH) = origFrame.shape[:2] # initialize the current status along with our list of bounding # box rectangles returned by either (1) our object detector or # (2) the correlation trackers status = "Waiting" rects = [] # check to see if we should run a more computationally expensive # object detection method to aid our tracker if self.totalFrames % self.SKIP_FRAMES == 0: # set the status and initialize our new set of object trackers status = "Detecting" self.trackers = [] yoloDetections = self.yoloInference.runInference( frame, W, H, self.CONFIDENCE_LIMIT) # loop over the detections for detection in yoloDetections: class_type = detection.classType # compute the (x, y)-coordinates of the bounding box # for the object box = detection.box[0:4] * np.array([1, 1, 1, 1]) (startX, startY, endX, endY) = box.astype("int") # construct a dlib rectangle object from the bounding # box coordinates and then start the dlib correlation # tracker tracker = dlib.correlation_tracker() rect = dlib.rectangle(startX, startY, endX, endY) if __myDebug__: cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 0, 0), 1) cv2.putText(frame, class_type, (startX, startY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1) tracker.start_track(rgb, rect) container = TrackerExt(class_type, tracker, (startX, startY, endX, endY)) # add the tracker to our list of trackers so we can # utilize it during skip frames self.trackers.append(container) # otherwise, we should utilize our object *trackers* rather than # object *detectors* to obtain a higher frame processing throughput else: # loop over the trackers for trackerContainer in self.trackers: # set the status of our system to be 'tracking' rather # than 'waiting' or 'detecting' status = "Tracking" tracker = trackerContainer.tracker # update the tracker and grab the updated position tracker.update(rgb) pos = tracker.get_position() # unpack the position object startX = int(pos.left()) startY = int(pos.top()) endX = int(pos.right()) endY = int(pos.bottom()) trackerContainer.rect = (startX, startY, endX, endY) # add the bounding box coordinates to the rectangles list rects.append(trackerContainer.rect) if __myDebug__: cv2.rectangle(frame, (startX, startY), (endX, endY), (0, 0, 0), 2) cv2.putText(frame, trackerContainer.class_type, (startX, startY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2) # use the centroid tracker to associate the (1) old object # centroids with (2) the newly computed object centroids extractedRects = [ trackerContainer for trackerContainer in self.trackers ] objects = self.ct.update(extractedRects) # loop over the tracked objects for (objectID, centroidTrackerData) in objects.items(): # check to see if a trackable object exists for the current # object ID to = self.trackableObjects.get(objectID, None) centroid = centroidTrackerData[0] className = centroidTrackerData[1] rect = centroidTrackerData[2] directionX = 0 directionY = 0 ratioH = self.origH / H ratioW = self.origW / W # if there is no existing trackable object, create one if to is None: rect2 = (rect[0] * ratioW, rect[1] * ratioH, rect[2] * ratioW, rect[3] * ratioH) clipped = clipImage(origFrame, rect2) if className == 'car' or className == 'truck': details = self.__getObjectDetails__(origFrame, rect, typeName=className) if details and len(details) > 0: predictions = details["predictions"] try: isPost = next((match for match in predictions if float(match["probability"]) > 0.7 and match["tagName"] == "Post"), None) except GeneratorExit: pass if isPost: className = "postcar" messageIoTHub = IoTHubMessage( """{"Name":"Postauto"}""") AppState.HubManager.send_event_to_output( "output2", messageIoTHub, 0) self.__saveToBlobStorage(clipped, id=objectID, typeName=className) fullName = className + "-full" clipped = clipImage(origFrame, [0, 0, self.origW, self.origH]) self.__saveToBlobStorage(clipped, id=objectID, typeName=fullName) to = TrackableObject(objectID, className, centroid) self.__sendToIoTHub__(to, rect, frame) # otherwise, there is a trackable object so we can utilize it # to determine direction else: # the difference between the y-coordinate of the *current* # centroid and the mean of *previous* centroids will tell # us in which direction the object is moving y = [c[1] for c in to.centroids] x = [c[0] for c in to.centroids] directionY = centroid[1] - np.mean(y) directionX = centroid[0] - np.mean(x) if len(to.centroids) >= 300: temp = to.centroids[2:] to.centroids = temp to.centroids.append(centroid) # check to see if the object has been counted or not if not to.counted: if int(directionY) == 0 and int(directionX) == 0: #self.totalUp += 1 to.counted = True # if the direction is positive (indicating the object # is moving down) AND the centroid is below the # center line, count the object elif directionY > 0 and centroid[1] > H // 2: self.totalDown += 1 to.counted = True # store the trackable object in our dictionary self.trackableObjects[objectID] = to # draw both the ID of the object and the centroid of the # object on the output frame directX = int(round(directionX, 1)) directY = int(round(directionY, 1)) colorCircle = (20, 250, 130) colorArrow = (0, 0, 250) colorText = (0, 255, 0) text = "{}: {}".format(objectID, to.type) cv2.putText(frame, text, (centroid[0] - 10, centroid[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, colorText, 1) cv2.circle(frame, (centroid[0], centroid[1]), 4, colorCircle, -1) cv2.arrowedLine(frame, (centroid[0], centroid[1]), (centroid[0] + directX, centroid[1] + directY), colorArrow, 2) #if len(to.centroids)>1 : # cv2.polylines(frame, np.int32(to.centroids), True, colorCircle, 1) # increment the total number of frames processed thus far and # then update the FPS counter self.totalFrames += 1 self.fps.update()