Пример #1
0
    def draw_instance_predictions(self, frame, predictions):
        """
        Draw instance-level prediction results on an image.

        Args:
            frame (ndarray): an RGB image of shape (H, W, C), in the range [0, 255].
            predictions (Instances): the output of an instance detection/segmentation
                model. Following fields will be used to draw:
                "pred_boxes", "pred_classes", "scores", "pred_masks" (or "pred_masks_rle").

        Returns:
            output (VisImage): image object with visualizations.
        """
        frame_visualizer = Visualizer(frame, self.metadata)
        num_instances = len(predictions)
        if num_instances == 0:
            return frame_visualizer.output

        boxes = predictions.pred_boxes.tensor.numpy() if predictions.has("pred_boxes") else None
        scores = predictions.scores if predictions.has("scores") else None
        classes = predictions.pred_classes.numpy() if predictions.has("pred_classes") else None
        keypoints = predictions.pred_keypoints if predictions.has("pred_keypoints") else None

        if predictions.has("pred_masks"):
            masks = predictions.pred_masks
            # mask IOU is not yet enabled
            # masks_rles = mask_util.encode(np.asarray(masks.permute(1, 2, 0), order="F"))
            # assert len(masks_rles) == num_instances
        else:
            masks = None

        detected = [
            _DetectedInstance(classes[i], boxes[i], mask_rle=None, color=None, ttl=8)
            for i in range(num_instances)
        ]
        colors = self._assign_colors(detected)

        labels = _create_text_labels(classes, scores, self.metadata.get("thing_classes", None))

        if self._instance_mode == ColorMode.IMAGE_BW:
            # any() returns uint8 tensor
            frame_visualizer.output.img = frame_visualizer._create_grayscale_image(
                (masks.any(dim=0) > 0).numpy() if masks is not None else None
            )
            alpha = 0.3
        else:
            alpha = 0.5

        frame_visualizer.overlay_instances(
            # boxes=None if masks is not None else boxes,  # boxes are a bit distracting
            boxes=boxes,
            masks=masks,
            labels=labels,
            keypoints=keypoints,
            assigned_colors=colors,
            alpha=alpha,
        )

        return frame_visualizer.output
Пример #2
0
    def draw_instance_predictions(self, frame, predictions, effect_type):

        frame_visualizer = Visualizer(frame, self.metadata)
        cnt = predictions["current_frame"]
        num_instances = predictions["num_instances"]
        if num_instances == 0:
            return frame_visualizer.output

        boxes = predictions["boxes"]
        scores = predictions["scores"]
        classes = predictions["classes"]
        keypoints = predictions["keypoints"]
        masks = predictions["masks"]

        detected = [
            _DetectedInstance(classes[i],
                              boxes[i],
                              mask_rle=None,
                              color=None,
                              ttl=8) for i in range(num_instances)
        ]
        colors = self._assign_colors(detected)

        labels = _create_text_labels(classes, scores,
                                     self.metadata.get("thing_classes", None))

        if self._instance_mode == ColorMode.IMAGE_BW:
            # any() returns uint8 tensor
            frame_visualizer.output.img = frame_visualizer._create_grayscale_image(
                (masks.any(dim=0) > 0).numpy() if masks is not None else None)
            alpha = 0.3
        else:
            alpha = 0.5

        if effect_type == 0:
            frame_visualizer.overlay_instances_scanning(
                boxes=None
                if masks is not None else boxes,  # boxes are a bit distracting
                cnt=cnt,
                masks=masks,
                labels=labels,
                keypoints=keypoints,
                assigned_colors=colors,
                alpha=alpha,
            )
        else:
            frame_visualizer.overlay_instances_stop_motion(
                boxes=None
                if masks is not None else boxes,  # boxes are a bit distracting
                cnt=cnt,
                masks=masks,
                labels=labels,
                keypoints=keypoints,
                assigned_colors=colors,
                alpha=alpha,
            )

        return frame_visualizer.output
Пример #3
0
    def draw_panoptic_seg_predictions(
        self, frame, panoptic_seg, segments_info, area_threshold=None, alpha=0.5
    ):
        frame_visualizer = Visualizer(frame, self.metadata)
        pred = _PanopticPrediction(panoptic_seg, segments_info, self.metadata)

        if self._instance_mode == ColorMode.IMAGE_BW:
            frame_visualizer.output.img = frame_visualizer._create_grayscale_image(
                pred.non_empty_mask()
            )

        # draw mask for all semantic segments first i.e. "stuff"
        for mask, sinfo in pred.semantic_masks():
            category_idx = sinfo["category_id"]
            try:
                mask_color = [x / 255 for x in self.metadata.stuff_colors[category_idx]]
            except AttributeError:
                mask_color = None

            frame_visualizer.draw_binary_mask(
                mask,
                color=mask_color,
                text=self.metadata.stuff_classes[category_idx],
                alpha=alpha,
                area_threshold=area_threshold,
            )

        all_instances = list(pred.instance_masks())
        if len(all_instances) == 0:
            return frame_visualizer.output
        # draw mask for all instances second
        masks, sinfo = list(zip(*all_instances))
        num_instances = len(masks)
        masks_rles = mask_util.encode(
            np.asarray(np.asarray(masks).transpose(1, 2, 0), dtype=np.uint8, order="F")
        )
        assert len(masks_rles) == num_instances

        category_ids = [x["category_id"] for x in sinfo]
        detected = [
            _DetectedInstance(category_ids[i], bbox=None, mask_rle=masks_rles[i], color=None, ttl=8)
            for i in range(num_instances)
        ]
        colors = self._assign_colors(detected)
        labels = [self.metadata.thing_classes[k] for k in category_ids]

        frame_visualizer.overlay_instances(
            boxes=None,
            masks=masks,
            labels=labels,
            keypoints=None,
            assigned_colors=colors,
            alpha=alpha,
        )
        return frame_visualizer.output
    def draw_instance_predictions(self, frame, predictions):
        """
        Draw instance-level prediction results on an image.

        Args:
            frame (ndarray): an RGB image of shape (H, W, C), in the range [0, 255].
            predictions (Instances): the output of an instance detection
                model. Following fields will be used to draw:
                "pred_boxes", "pred_classes", "scores".

        Returns:
            output (VisImage): image object with visualizations.
        """
        frame_visualizer = Visualizer(frame, self.metadata)
        num_instances = len(predictions)
        if num_instances == 0:
            return frame_visualizer.output

        boxes = predictions.pred_boxes.tensor.numpy() if predictions.has(
            "pred_boxes") else None
        scores = predictions.scores if predictions.has("scores") else None
        classes = predictions.pred_classes.numpy() if predictions.has(
            "pred_classes") else None

        detected = [
            _DetectedInstance(classes[i], boxes[i], color=None, ttl=8)
            for i in range(num_instances)
        ]
        colors = self._assign_colors(detected)

        labels = _create_text_labels(classes, scores,
                                     self.metadata.get("thing_classes", None))

        if self._instance_mode == ColorMode.IMAGE_BW:
            # any() returns uint8 tensor
            frame_visualizer.output.img = frame_visualizer._create_grayscale_image(
            )
            alpha = 0.3
        else:
            alpha = 0.5

        frame_visualizer.overlay_instances(
            boxes=boxes,  # boxes are a bit distracting
            labels=labels,
            assigned_colors=colors,
            alpha=alpha,
        )

        return frame_visualizer.output
Пример #5
0
    def draw_instance_predictions(self, frame, predictions):
        """
        Draw instance-level prediction results on an image.

        Args:
            frame (ndarray): an RGB image of shape (H, W, C), in the range [0, 255].
            predictions (Instances): the output of an instance detection/segmentation
                model. Following fields will be used to draw:
                "pred_boxes", "pred_classes", "scores", "pred_masks" (or "pred_masks_rle").

        Returns:
            output (VisImage): image object with visualizations.
        """
        frame_visualizer = Visualizer(frame, self.metadata)
        num_instances = len(predictions)
        if num_instances == 0:
            return frame_visualizer.output

        boxes = predictions.pred_boxes.tensor.numpy() if predictions.has(
            "pred_boxes") else None
        scores = predictions.scores if predictions.has("scores") else None
        classes = predictions.pred_classes.numpy() if predictions.has(
            "pred_classes") else None
        keypoints = predictions.pred_keypoints if predictions.has(
            "pred_keypoints") else None
        colors = predictions.COLOR if predictions.has(
            "COLOR") else [None] * len(predictions)
        durations = predictions.ID_duration if predictions.has(
            "ID_duration") else None
        duration_threshold = self.metadata.get("duration_threshold", 0)
        visibilities = None if durations is None else [
            x > duration_threshold for x in durations
        ]

        if predictions.has("pred_masks"):
            masks = predictions.pred_masks
            # mask IOU is not yet enabled
            # masks_rles = mask_util.encode(np.asarray(masks.permute(1, 2, 0), order="F"))
            # assert len(masks_rles) == num_instances
        else:
            masks = None

        detected = [
            _DetectedInstance(classes[i],
                              boxes[i],
                              mask_rle=None,
                              color=colors[i],
                              ttl=8) for i in range(num_instances)
        ]
        if not predictions.has("COLOR"):
            colors = self._assign_colors(detected)

        labels = _create_text_labels(classes, scores,
                                     self.metadata.get("thing_classes", None))

        if self._instance_mode == ColorMode.IMAGE_BW:
            # any() returns uint8 tensor
            frame_visualizer.output.reset_image(
                frame_visualizer._create_grayscale_image((masks.any(
                    dim=0) > 0).numpy() if masks is not None else None))
            alpha = 0.3
        else:
            alpha = 0.5

        labels = (
            None if labels is None else
            [y[0] for y in filter(lambda x: x[1], zip(labels, visibilities))]
        )  # noqa
        assigned_colors = (
            None if colors is None else
            [y[0] for y in filter(lambda x: x[1], zip(colors, visibilities))]
        )  # noqa
        frame_visualizer.overlay_instances(
            boxes=None if masks is not None else
            boxes[visibilities],  # boxes are a bit distracting
            masks=None if masks is None else masks[visibilities],
            labels=labels,
            keypoints=None if keypoints is None else keypoints[visibilities],
            assigned_colors=assigned_colors,
            alpha=alpha,
        )

        return frame_visualizer.output
    def draw_instance_predictions_custom(self,
                                         frame,
                                         predictions,
                                         incl_boxes=True,
                                         incl_labels=True,
                                         incl_scores=True,
                                         target_alpha=None):

        frame_visualizer = Visualizer(frame, self.metadata)
        num_instances = len(predictions)
        if num_instances == 0:
            return frame_visualizer.output

        boxes = predictions.pred_boxes.tensor.numpy() if predictions.has(
            "pred_boxes") else None
        scores = predictions.scores if predictions.has("scores") else None
        scores = scores if incl_scores else None
        classes = predictions.pred_classes.numpy() if predictions.has(
            "pred_classes") else None
        keypoints = predictions.pred_keypoints if predictions.has(
            "pred_keypoints") else None

        if predictions.has("pred_masks"):
            masks = predictions.pred_masks
            # mask IOU is not yet enabled
            # masks_rles = mask_util.encode(np.asarray(masks.permute(1, 2, 0), order="F"))
            # assert len(masks_rles) == num_instances
        else:
            masks = None

        detected = [
            _DetectedInstance(classes[i],
                              boxes[i],
                              mask_rle=None,
                              color=None,
                              ttl=8) for i in range(num_instances)
        ]
        colors = self._assign_colors(detected)

        labels = _create_text_labels(classes, scores,
                                     self.metadata.get("thing_classes", None))

        if self._instance_mode == ColorMode.IMAGE_BW:
            # any() returns uint8 tensor
            frame_visualizer.output.img = frame_visualizer._create_grayscale_image(
                (masks.any(dim=0) > 0).numpy() if masks is not None else None)
            alpha = 0.3
        else:
            alpha = 0.5

        boxes = boxes if incl_boxes else None
        labels = labels if incl_labels else None
        alpha = alpha if target_alpha is None else target_alpha

        frame_visualizer.overlay_instances(
            boxes=None
            if masks is not None else boxes,  # boxes are a bit distracting
            masks=masks,
            labels=labels,
            keypoints=keypoints,
            assigned_colors=colors,
            alpha=alpha,
        )

        return frame_visualizer.output
Пример #7
0
def draw_instance_predictions(visualizer, frame, predictions, tracker):
    """
    Draw instance-level prediction results on an image.

    Args:
        frame (ndarray): an RGB image of shape (H, W, C), in the range [0, 255].
        predictions (Instances): the output of an instance detection/segmentation
            model. Following fields will be used to draw:
            "pred_boxes", "pred_classes", "scores", "pred_masks" (or "pred_masks_rle").

    Returns:
        output (VisImage): image object with visualizations.
    """
    frame_visualizer = Visualizer(frame, visualizer.metadata)
    num_instances = len(predictions)
    if num_instances == 0:
        return frame_visualizer.output

    boxes = predictions.pred_boxes.tensor.numpy() if predictions.has(
        "pred_boxes") else None
    scores = predictions.scores if predictions.has("scores") else None
    classes = predictions.pred_classes.numpy() if predictions.has(
        "pred_classes") else None
    keypoints = predictions.pred_keypoints if predictions.has(
        "pred_keypoints") else None

    if predictions.has("pred_masks"):
        masks = predictions.pred_masks
        # mask IOU is not yet enabled
        # masks_rles = mask_util.encode(np.asarray(masks.permute(1, 2, 0), order="F"))
        # assert len(masks_rles) == num_instances
    else:
        masks = None

    detected = [
        detectron2.utils.video_visualizer._DetectedInstance(classes[i],
                                                            boxes[i],
                                                            mask_rle=None,
                                                            color=None,
                                                            ttl=8)
        for i in range(num_instances)
    ]
    colors = visualizer._assign_colors(detected)

    labels = detectron2.utils.video_visualizer._create_text_labels(
        classes, scores, visualizer.metadata.get("thing_classes", None))

    if visualizer._instance_mode == ColorMode.IMAGE_BW:
        # any() returns uint8 tensor
        frame_visualizer.output.img = frame_visualizer._create_grayscale_image(
            (masks.any(dim=0) > 0).numpy() if masks is not None else None)
        alpha = 0.3
    else:
        alpha = 0.5

    frame_visualizer.overlay_instances(
        boxes=None
        if masks is not None else boxes,  # boxes are a bit distracting
        masks=masks,
        labels=labels,
        keypoints=keypoints,
        assigned_colors=colors,
        alpha=alpha,
    )

    for bag_id in tracker.prev_frame_ids['bags']:
        bag_center = tracker.all_centers['bags'][bag_id]
        if bag_id in tracker.bag_person_association:
            person_id = tracker.bag_person_association[bag_id]
            if person_id is not None and person_id in tracker.prev_frame_ids[
                    'persons']:
                person_center = tracker.all_centers['persons'][person_id]

                if tracker.is_unattended(bag_id):
                    frame_visualizer.draw_line(
                        [bag_center[0], person_center[0]],
                        [bag_center[1], person_center[1]], 'r')
                else:
                    frame_visualizer.draw_line(
                        [bag_center[0], person_center[0]],
                        [bag_center[1], person_center[1]], 'g')

        if tracker.is_unattended(bag_id):
            frame_visualizer.draw_text('abandoned',
                                       tuple(bag_center[0:2]),
                                       color='r')

    return frame_visualizer.output
Пример #8
0
    def draw_instance_predictions(self, frame, predictions):
        """
        Draw instance-level prediction results on an image.

        Args:
            frame (ndarray): an RGB image of shape (H, W, C), in the range [0, 255].
            predictions (Instances): the output of an instance detection/segmentation
                model. Following fields will be used to draw:
                "pred_boxes", "pred_classes", "scores", "pred_masks" (or "pred_masks_rle").

        Returns:
            output (VisImage): image object with visualizations.
        """
        frame_visualizer = Visualizer(frame, self.metadata)

        # MOONLITE: zero out frame
        frame_visualizer.output.img = np.zeros(
            frame_visualizer.output.img.shape)

        num_instances = len(predictions)
        if num_instances == 0:
            return frame_visualizer.output

        boxes = predictions.pred_boxes.tensor.numpy() if predictions.has(
            "pred_boxes") else None
        scores = predictions.scores if predictions.has("scores") else None
        classes = predictions.pred_classes.numpy() if predictions.has(
            "pred_classes") else None
        keypoints = predictions.pred_keypoints if predictions.has(
            "pred_keypoints") else None

        if predictions.has("pred_masks"):
            masks = predictions.pred_masks
            # mask IOU is not yet enabled
            # masks_rles = mask_util.encode(np.asarray(masks.permute(1, 2, 0), order="F"))
            # assert len(masks_rles) == num_instances
        else:
            masks = None

        detected = [
            _DetectedInstance(classes[i],
                              boxes[i],
                              mask_rle=None,
                              color=None,
                              ttl=8) for i in range(num_instances)
        ]
        colors = self._assign_colors(detected)

        labels = _create_text_labels(classes, scores,
                                     self.metadata.get("thing_classes", None))

        if self._instance_mode == ColorMode.IMAGE_BW:
            # any() returns uint8 tensor
            frame_visualizer.output.img = frame_visualizer._create_grayscale_image(
                (masks.any(dim=0) > 0).numpy() if masks is not None else None)
            alpha = 0.3
        else:
            alpha = 0.5

        # only keep instance if
        class_names = self.metadata.get("thing_classes", None)
        # get indices of all
        focused_class = "person"
        num_class_instances = [
            i for i in range(num_instances)
            if (class_names[classes[i]] == focused_class)
        ]

        # strip instances down to only instances of our focused class
        boxes = [boxes[i] for i in num_class_instances]
        masks = [masks[i] for i in num_class_instances]
        labels = ["" for i in num_class_instances]
        keypoints = [keypoints[i] for i in num_class_instances]
        colors = [(scores[i], scores[i], scores[i])
                  for i in num_class_instances]

        #for i in range(num_instances):
        #    if class_names[classes[i]] == "person":
        #        colors[i] = (scores[i],scores[i],scores[i])
        #    else:
        #        colors[i] = (0.0,0.0,0.0)
        #
        #    labels[i] = ""

        alpha = 1.0

        frame_visualizer.overlay_instances(
            boxes=None
            if masks is not None else boxes,  # boxes are a bit distracting
            masks=masks,
            labels=labels,
            keypoints=keypoints,
            assigned_colors=colors,
            alpha=alpha,
        )

        return frame_visualizer.output