def execute(self) -> StageResult: """ Executes all stages in this pipeline sequentially. """ result = None for stage in self.stages: stage.before_execute() result = stage.execute() stage.after_execute() if result.continue_pipeline and not result.next_stage: break if not result.continue_pipeline: return StageResult(False, None) should_continue = False if not self.stages: should_continue = True if result is not None: should_continue = result.next_stage return StageResult(True, should_continue)
def execute(self) -> StageResult: """ Tests for the press of the "Q" key or the end of the video. """ if cv2.waitKey(25) & 0xFF == ord("q"): return StageResult(False, None) return StageResult(True, True)
def execute(self) -> StageResult: """ Registers the history frame. """ history_frames = self._history_frames.history_frames transformation_matrices = self._transformation_matrices.transformation_matrices self.shifted_history_frames = [ Frame( cv2.warpPerspective( history_frame.get_frame(), M, ( history_frame.get_frame().shape[1], history_frame.get_frame().shape[0], ), ).astype(np.uint8), history_frame.get_frame_number(), ) for history_frame, M in zip(history_frames, transformation_matrices) ] return StageResult(True, True)
def execute(self) -> StageResult: ShowLastFrame.execute(self) # This searches the previous object for frame types. if not self._frame_video_writers: self._frame_video_writers = { f: cv2.VideoWriter( "./output/{stage_name}.{frame_attribute}.mp4".format( stage_name=type(self._dependent).__name__, frame_attribute=f, ), cv2.VideoWriter_fourcc(*"mp4v"), self._capture.fps, (self._capture.frame_width, self._capture.frame_height), ) for f in self._frame_attributes } # Write one frame to the video for each frame object. for frame_attribute in self._frame_attributes: frame = getattr(self._dependent, frame_attribute).get_frame() if len(frame.shape) == 2: frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR) self._frame_video_writers[frame_attribute].write(frame) return StageResult(True, True)
def execute(self) -> StageResult: """ Displays the frame within a window for the user to see. Automatically sizes the window to the user's screen. """ if os.environ.get("DISPLAY", "") != "": # This searches the previous object for frame types. if not self._frame_attributes: self._frame_attributes = [ a for a in dir(self._dependent) if isinstance(getattr(self._dependent, a), Frame) ] # Display one cv2.imshow for each frame object. for frame_attribute in self._frame_attributes: cv2.imshow( "{stage_name}.{frame_attribute}".format( stage_name=type(self._dependent).__name__, frame_attribute=frame_attribute, ), cv2.resize( getattr(self._dependent, frame_attribute).get_frame(), self.im_size, ), ) return StageResult(True, True)
def execute(self) -> StageResult: """ Registers the history frame. """ # Do nothing. if not self._history_frames.is_full(): return StageResult(True, False) processed_frame = self._preprocessed_frame.processed_frame history_frames = self._history_frames.history_frames self.transformation_matrices = [ self._register(f, processed_frame) for f in history_frames ] return StageResult(True, True)
def execute(self) -> StageResult: idx = next(self._progress) while idx < self._frame.frame.get_frame_number(): idx = next(self._progress) return StageResult(True, True)
def execute(self) -> StageResult: self.baboons = [ b for b in self._baboons.baboons if self._calc_area(b) >= self._min_size ] return StageResult(True, True)
def execute(self) -> StageResult: """ Detect and returns locations of blobs from foreground mask Returns list of coordinates """ foreground_mask = self._moving_foregrouned.moving_foreground.get_frame() contours, _ = cv2.findContours( foreground_mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE ) rectangles = [cv2.boundingRect(c) for c in contours] rectangles = [(r[0], r[1], r[0] + r[2], r[1] + r[3]) for r in rectangles] blob_image = cv2.cvtColor(foreground_mask, cv2.COLOR_GRAY2BGR) for rect in rectangles: blob_image = cv2.rectangle( blob_image, (rect[0], rect[1]), (rect[2], rect[3]), (0, 255, 0), 2 ) self.blob_image = Frame( blob_image, self._moving_foregrouned.moving_foreground.get_frame_number(), ) self.baboons = [Baboon(r) for r in rectangles] return StageResult(True, True)
def execute(self) -> StageResult: if self._result is None: self._result = np.zeros_like( self._moving_foreground.moving_foreground.get_frame()) self._motion_observations = np.zeros_like( self._moving_foreground.moving_foreground.get_frame()) self._no_motion_observations = np.zeros_like( self._moving_foreground.moving_foreground.get_frame()) mask = self._moving_foreground.moving_foreground.get_frame() == 255 not_mask = self._moving_foreground.moving_foreground.get_frame() == 0 self._motion_observations[not_mask] = 0 self._motion_observations[mask] += 1 self._no_motion_observations[mask] = 0 self._no_motion_observations[not_mask] += 1 self._result[self._motion_observations == self._required_motion_observations] = 255 self._result[self._no_motion_observations == self._required_motion_observations] = 0 self.moving_foreground = Frame( self._result, self._moving_foreground.moving_foreground.get_frame_number()) return StageResult(True, True)
def execute(self) -> StageResult: moving_foreground = self._moving_foreground.moving_foreground.get_frame() element = cv2.getStructuringElement( cv2.MORPH_ELLIPSE, (self._erode_kernel_size, self._erode_kernel_size) ) eroded = cv2.erode(moving_foreground, element) element = cv2.getStructuringElement( cv2.MORPH_ELLIPSE, (self._dilate_kernel_size, self._dilate_kernel_size) ) opened_mask = cv2.dilate(eroded, element) combined_mask = np.zeros(opened_mask.shape).astype(np.uint8) combined_mask[opened_mask == moving_foreground] = 255 combined_mask[moving_foreground == 0] = 0 element = cv2.getStructuringElement( cv2.MORPH_ELLIPSE, (self._combine_kernel_size, self._combine_kernel_size) ) dialated = cv2.dilate(combined_mask, element) self.moving_foreground = Frame( cv2.erode(dialated, element), self._moving_foreground.moving_foreground.get_frame_number(), ) return StageResult(True, True)
def execute(self) -> StageResult: shifted_history_frames = self._shifted_history_frames.shifted_history_frames quantized_frames = self._quantized_frames.quantized_frames self.history_of_dissimilarity = self._get_history_of_dissimilarity( shifted_history_frames, quantized_frames) return StageResult(True, True)
def execute(self) -> StageResult: """ Executes all stages in this pipeline in parallel. """ for stage in self.stages: stage.before_execute() result = stage.execute() stage.after_execute() if result.continue_pipeline and not result.next_stage: break if not result.continue_pipeline: return StageResult(False, None) return StageResult(True, True)
def execute(self) -> StageResult: """Quantizes the shifted history frame.""" self.quantized_frames = [ self._quantize_frame(f) for f in self._shifted_history_frames.shifted_history_frames ] return StageResult(True, True)
def execute(self) -> StageResult: self.processed_frame = Frame( cv2.fastNlMeansDenoising( self._preprocessed_frame.processed_frame.get_frame(), h=5 ), self._preprocessed_frame.processed_frame.get_frame_number(), ) return StageResult(True, True)
def execute(self) -> StageResult: grouped_shifted_history_frames = ( self._group_shifted_history_frames.grouped_shifted_history_frames) grouped_quantized_frames = ( self._group_shifted_history_frames.grouped_quantized_frames) self.intersected_frames = self._intersect_all_frames( grouped_shifted_history_frames, grouped_quantized_frames) return StageResult(True, True)
def execute(self) -> StageResult: """ Converts a color image to a gray-scale image. """ self.processed_frame = Frame( cv2.cvtColor(self._frame_mixin.frame.get_frame(), cv2.COLOR_BGR2GRAY), self._frame_mixin.frame.get_frame_number(), ) return StageResult(True, True)
def execute(self) -> StageResult: """ Get a video frame from a video file. """ success, frame = self._capture.read() self.frame = Frame(frame, self._frame_number) self._frame_number += 1 return StageResult(success, success)
def execute(self) -> StageResult: # This cleans up the edges after performing image registration. for mask in self._shifted_masks.shifted_masks: self.moving_foreground = Frame( np.multiply( self._moving_foreground.moving_foreground.get_frame(), mask ), self._frame.frame.get_frame_number(), ) return StageResult(True, True)
def execute(self) -> StageResult: """ Implements a storage of historical frame step for motion detection. """ if self.is_full(): frame = self.history_frames.popleft() self._history_frame_popped_subject.on_next(frame) self.history_frames.append(self._preprocessed_frame.processed_frame) return StageResult(True, True)
def execute(self) -> StageResult: frame = self._preprocessed_frame.processed_frame union = self._unioned_frames.unioned_frames weights = self._weights.weights frame_new = self._zero_weights(frame.get_frame(), weights) union_new = self._zero_weights(union, weights) self.foreground = cv2.absdiff(frame_new, union_new) return StageResult(True, True)
def execute(self) -> StageResult: weights = self._weights.weights foreground = self._foreground.foreground history_of_dissimilarity = ( self._history_of_dissimilarity.history_of_dissimilarity) self.moving_foreground = Frame( self._get_moving_foreground(weights, foreground, history_of_dissimilarity), self._frame.frame.get_frame_number(), ) return StageResult(True, True)
def execute(self) -> StageResult: """ Blurs a gray frame using a Gaussian blur. """ self.processed_frame = Frame( cv2.GaussianBlur( self._preprocessed_frame.processed_frame.get_frame(), (5, 5), 0), self._preprocessed_frame.processed_frame.get_frame_number(), ) return StageResult(True, True)
def execute(self) -> StageResult: transformation_matrices = self._transformation_matrices.transformation_matrices frame = self._frame.processed_frame img = np.ones(frame.get_frame().shape).astype(np.uint8) self.shifted_masks = [ cv2.warpPerspective( img, M, (frame.get_frame().shape[1], frame.get_frame().shape[0]), ) for M in transformation_matrices ] return StageResult(True, True)
def execute(self) -> StageResult: shifted_history_frames = self._shifted_history_frames.shifted_history_frames quantized_frames = self._quantized_frames.quantized_frames frame_group_index = range(len(shifted_history_frames) - 1) frame_group_index = [(r, r + 1) for r in frame_group_index] self.grouped_shifted_history_frames = [(shifted_history_frames[g[0]], shifted_history_frames[g[1]]) for g in frame_group_index] self.grouped_quantized_frames = [(quantized_frames[g[0]], quantized_frames[g[1]]) for g in frame_group_index] return StageResult(True, True)
def execute(self) -> StageResult: for baboon in self._baboons.baboons: x1, y1, x2, y2 = baboon.rectangle self._file.write(str(x1)) self._file.write(", ") self._file.write(str(y1)) self._file.write(", ") self._file.write(str(x2)) self._file.write(", ") self._file.write(str(y2)) self._file.write(", ") self._file.write(str(self._frame.frame.get_frame_number())) self._file.write("\n") return StageResult(True, True)
def execute(self) -> StageResult: moving_foreground = np.zeros_like( self._moving_foreground.moving_foreground.get_frame()) height, width = moving_foreground.shape _execute( moving_foreground, self._moving_foreground.moving_foreground.get_frame(), self._group_size, height, width, ) self.moving_foreground = Frame( moving_foreground, self._moving_foreground.moving_foreground.get_frame_number(), ) return StageResult(True, True)
def execute(self) -> StageResult: """ Detect and returns locations of blobs from foreground mask Returns list of coordinates """ foreground_mask = self._moving_foregrouned.moving_foreground.get_frame( ) keypoints = self._detector.detect(foreground_mask) self.blob_image = Frame( cv2.drawKeypoints( cv2.cvtColor(foreground_mask, cv2.COLOR_GRAY2BGR), keypoints, np.array([]), (0, 255, 0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS, ), self._moving_foregrouned.moving_foreground.get_frame_number(), ) self.baboons = [Baboon((k.pt[0], k.pt[1]), k.size) for k in keypoints] return StageResult(True, True)
def execute(self) -> StageResult: region_frame = self._frame.frame.get_frame().copy() rectangles = [(b.rectangle, b.id_str) for b in self._baboons.baboons] for rect, id_str in rectangles: region_frame = cv2.rectangle(region_frame, (rect[0], rect[1]), (rect[2], rect[3]), (0, 255, 0), 2) if id_str is not None: cv2.putText( region_frame, id_str, (rect[0], rect[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (36, 255, 12), 2, ) self.region_frame = Frame(region_frame, self._frame.frame.get_frame_number()) return StageResult(True, True)
def execute(self) -> StageResult: quantized_frames = self._quantized_frames.quantized_frames self.weights = self._get_weights(quantized_frames) return StageResult(True, True)