Ejemplo n.º 1
0
    def transform(self, Xb, yb):
        Xb, yb = super(RandomFlipBatchIteratorMixin, self).transform(Xb, yb)
        Xb_flipped = Xb.copy()
        yb_flipped = yb.copy()

        if self.flip_horizontal_p > 0:
            horizontal_flip_idx = get_random_idx(Xb, self.flip_horizontal_p)
            Xb_flipped[horizontal_flip_idx] = Xb_flipped[horizontal_flip_idx, :, :, ::-1]
            yb_flipped[horizontal_flip_idx, 0] = 1 - yb_flipped[horizontal_flip_idx, 0] - yb_flipped[horizontal_flip_idx, 2]

        if self.flip_vertical_p > 0:
            vertical_flip_idx = get_random_idx(Xb, self.flip_vertical_p)
            Xb_flipped[vertical_flip_idx] = Xb_flipped[vertical_flip_idx, :, ::-1, :]
            yb_flipped[vertical_flip_idx, 1] = 1 - yb_flipped[vertical_flip_idx, 1] - yb_flipped[vertical_flip_idx, 3]

        return Xb_flipped, yb_flipped
Ejemplo n.º 2
0
    def transform(self, Xb, yb):
        Xb, yb = super(RandomFlipBatchIteratorMixin, self).transform(Xb, yb)
        Xb_flipped = Xb.copy()
        yb_flipped = yb.copy()

        if self.flip_horizontal_p > 0:
            horizontal_flip_idx = get_random_idx(Xb, self.flip_horizontal_p)
            Xb_flipped[horizontal_flip_idx] = Xb_flipped[
                horizontal_flip_idx, :, :, ::-1]
            yb_flipped[horizontal_flip_idx,
                       0] = 1 - yb_flipped[horizontal_flip_idx,
                                           0] - yb_flipped[horizontal_flip_idx,
                                                           2]

        if self.flip_vertical_p > 0:
            vertical_flip_idx = get_random_idx(Xb, self.flip_vertical_p)
            Xb_flipped[vertical_flip_idx] = Xb_flipped[
                vertical_flip_idx, :, ::-1, :]
            yb_flipped[vertical_flip_idx,
                       1] = 1 - yb_flipped[vertical_flip_idx,
                                           1] - yb_flipped[vertical_flip_idx,
                                                           3]

        return Xb_flipped, yb_flipped
Ejemplo n.º 3
0
    def transform(self, Xb, yb):
        Xb, yb = super(AffineTransformPtsBatchIteratorMixin,
                       self).transform(Xb, yb)
        # Skip if affine_p is 0. Setting affine_p may be useful for quickly
        # disabling affine transformation
        if self.affine_p == 0:
            return Xb, yb

        image_height = Xb.shape[2]
        image_width = Xb.shape[3]

        assert image_height == image_width

        idx = get_random_idx(Xb, self.affine_p)
        Xb_transformed = Xb.copy()
        yb_transformed = yb.copy()

        for i in idx:
            scale = np.random.choice(self.affine_scale_choices)
            rotation = np.random.choice(self.affine_rotation_choices)
            shear = np.random.choice(self.affine_shear_choices)
            translation_y = np.random.choice(self.affine_translation_choices)
            translation_x = np.random.choice(self.affine_translation_choices)

            transform_kwargs = dict(
                scale=scale, rotation=rotation,
                shear=shear,
                translation_y=translation_y,
                translation_x=translation_x,
                return_tform=True
            )

            img_transformed, tform = im_affine_transform(
                Xb[i], **transform_kwargs
            )

            Xb_transformed[i] = img_transformed

            pts = yb_transformed[i].reshape(-1, 2) * image_height
            pts = tform.inverse(pts).ravel()
            yb_transformed[i] = pts / image_height

        return Xb_transformed, yb_transformed
Ejemplo n.º 4
0
    def transform(self, Xb, yb):
        Xb, yb = super(AffineTransformPtsBatchIteratorMixin,
                       self).transform(Xb, yb)
        # Skip if affine_p is 0. Setting affine_p may be useful for quickly
        # disabling affine transformation
        if self.affine_p == 0:
            return Xb, yb

        image_height = Xb.shape[2]
        image_width = Xb.shape[3]

        assert image_height == image_width

        idx = get_random_idx(Xb, self.affine_p)
        Xb_transformed = Xb.copy()
        yb_transformed = yb.copy()

        for i in idx:
            scale = np.random.choice(self.affine_scale_choices)
            rotation = np.random.choice(self.affine_rotation_choices)
            shear = np.random.choice(self.affine_shear_choices)
            translation_y = np.random.choice(self.affine_translation_choices)
            translation_x = np.random.choice(self.affine_translation_choices)

            transform_kwargs = dict(scale=scale,
                                    rotation=rotation,
                                    shear=shear,
                                    translation_y=translation_y,
                                    translation_x=translation_x,
                                    return_tform=True)

            img_transformed, tform = im_affine_transform(
                Xb[i], **transform_kwargs)

            Xb_transformed[i] = img_transformed

            pts = yb_transformed[i].reshape(-1, 2) * image_height
            pts = tform.inverse(pts).ravel()
            yb_transformed[i] = pts / image_height

        return Xb_transformed, yb_transformed
Ejemplo n.º 5
0
    def transform(self, Xb, yb):
        Xb, yb = super(AffineTransformBBoxBatchIteratorMixin,
                       self).transform(Xb, yb)
        # Skip if affine_p is 0. Setting affine_p may be useful for quickly
        # disabling affine transformation
        if self.affine_p == 0:
            return Xb, yb

        image_height = Xb.shape[2]
        image_width = Xb.shape[3]

        assert image_height == image_width

        idx = get_random_idx(Xb, self.affine_p)
        Xb_transformed = Xb.copy()
        yb_transformed = yb.copy()

        for i in idx:
            scale = np.random.choice(self.affine_scale_choices)
            rotation = np.random.choice(self.affine_rotation_choices)
            shear = np.random.choice(self.affine_shear_choices)
            translation_y = np.random.choice(self.affine_translation_choices)
            translation_x = np.random.choice(self.affine_translation_choices)
            transform_kwargs = dict(scale=scale,
                                    rotation=rotation,
                                    shear=shear,
                                    translation_y=translation_y,
                                    translation_x=translation_x)

            img_transformed = im_affine_transform(Xb[i], **transform_kwargs)
            bbox_transformed = get_transformed_bbox(yb[i] * image_width,
                                                    image_width, image_height,
                                                    **transform_kwargs)

            Xb_transformed[i] = img_transformed
            yb_transformed[i] = np.array(bbox_transformed).astype(
                np.float32) / image_width

        return Xb_transformed, yb_transformed
Ejemplo n.º 6
0
    def transform(self, Xb, yb):
        Xb, yb = super(AffineTransformBBoxBatchIteratorMixin,
                       self).transform(Xb, yb)
        # Skip if affine_p is 0. Setting affine_p may be useful for quickly
        # disabling affine transformation
        if self.affine_p == 0:
            return Xb, yb

        image_height = Xb.shape[2]
        image_width = Xb.shape[3]

        assert image_height == image_width

        idx = get_random_idx(Xb, self.affine_p)
        Xb_transformed = Xb.copy()
        yb_transformed = yb.copy()

        for i in idx:
            scale = np.random.choice(self.affine_scale_choices)
            rotation = np.random.choice(self.affine_rotation_choices)
            shear = np.random.choice(self.affine_shear_choices)
            translation_y = np.random.choice(self.affine_translation_choices)
            translation_x = np.random.choice(self.affine_translation_choices)
            transform_kwargs = dict(
                scale=scale, rotation=rotation,
                shear=shear,
                translation_y=translation_y,
                translation_x=translation_x
            )

            img_transformed = im_affine_transform(
                Xb[i], **transform_kwargs)
            bbox_transformed = get_transformed_bbox(
                yb[i] * image_width, image_width, image_height, **transform_kwargs)

            Xb_transformed[i] = img_transformed
            yb_transformed[i] = np.array(bbox_transformed).astype(np.float32) / image_width

        return Xb_transformed, yb_transformed