def get_transform()

in d2go/data/transforms/affine.py [0:0]

• 59 lines of code
• 3 McCabe index (conditional complexity)

    def get_transform(self, img: np.ndarray) -> Transform:
        im_h, im_w = img.shape[:2]
        max_size = max(im_w, im_h)
        center = [im_w / 2, im_h / 2]
        angle = random.uniform(self.angle_range[0], self.angle_range[1])
        translation = [
            random.uniform(self.translation_range[0], self.translation_range[1]),
            random.uniform(self.translation_range[0], self.translation_range[1]),
        ]
        scale = random.uniform(self.scale_range[0], self.scale_range[1])
        shear = [
            random.uniform(self.shear_range[0], self.shear_range[1]),
            random.uniform(self.shear_range[0], self.shear_range[1]),
        ]

        dummy_translation = [0.0, 0.0]
        dummy_scale = 1.0
        M_inv = T.functional._get_inverse_affine_matrix(
            center, angle, dummy_translation, dummy_scale, shear
        )
        M_inv.extend([0.0, 0.0, 1.0])
        M_inv = np.array(M_inv).reshape((3, 3))
        M = np.linalg.inv(M_inv)

        # Center in output patch
        img_corners = np.array(
            [
                [0, 0, im_w, im_w],
                [0, im_h, 0, im_h],
                [1, 1, 1, 1],
            ]
        )
        transformed_corners = M @ img_corners
        x_min = np.amin(transformed_corners[0])
        x_max = np.amax(transformed_corners[0])
        x_range = np.ceil(x_max - x_min)
        y_min = np.amin(transformed_corners[1])
        y_max = np.amax(transformed_corners[1])
        y_range = np.ceil(y_max - y_min)

        # Apply translation and scale after centering in output patch
        translation_adjustment = [(max_size - im_w) / 2, (max_size - im_h) / 2]
        translation[0] += translation_adjustment[0]
        translation[1] += translation_adjustment[1]
        scale_adjustment = min(max_size / x_range, max_size / y_range)
        scale *= scale_adjustment

        M_inv = T.functional._get_inverse_affine_matrix(
            center, angle, translation, scale, shear
        )
        # Convert to Numpy matrix so it can be inverted
        M_inv.extend([0.0, 0.0, 1.0])
        M_inv = np.array(M_inv).reshape((3, 3))
        M = np.linalg.inv(M_inv)

        do = self._rand_range() < self.prob
        if do:
            return AffineTransform(
                M_inv,
                max_size,
                max_size,
                flags=cv2.WARP_INVERSE_MAP + cv2.INTER_LINEAR,
                border_mode=cv2.BORDER_REPLICATE,
                is_inversed_M=True,
            )
        else:
            return NoOpTransform()