Method __call__

detrsmpl/models/utils/SMPLX.py:252–337

Crops the HD images using the provided bounding boxes. Parameters ---------- full_imgs: ImageList An image list structure with the full resolution images center: torch.Tensor A Bx2 tensor that contains the coordinates of the ce

(self, full_imgs, center, bbox_size)

        return F.grid_sample(full_imgs, sampling_grid, align_corners=True)

    def __call__(self, full_imgs, center, bbox_size):
        """Crops the HD images using the provided bounding boxes.

        Parameters
        ----------
            full_imgs: ImageList
                An image list structure with the full resolution images
            center: torch.Tensor
                A Bx2 tensor that contains the coordinates of the center of
                the bounding box that will be cropped from the original
                image
            bbox_size: torch.Tensor
                A size B tensor that contains the size of the corp

        Returns
        -------
            cropped_images: torch.Tensoror
                The images cropped from the high resolution input
            sampling_grid: torch.Tensor
                The grid used to sample the crops
        """

        batch_size, _, H, W = full_imgs.shape
        self.grid = self.grid.to(device=full_imgs.device)
        transforms = torch.eye(3,
                               dtype=full_imgs.dtype,
                               device=full_imgs.device).reshape(
                                   1, 3, 3).expand(batch_size, -1,
                                                   -1).contiguous()

        hd_to_crop = torch.eye(3,
                               dtype=full_imgs.dtype,
                               device=full_imgs.device).reshape(
                                   1, 3, 3).expand(batch_size, -1,
                                                   -1).contiguous()

        # Create the transformation that maps crop pixels to image coordinates,
        # i.e. pixel (0, 0) from the crop_size x crop_size grid gets mapped to
        # the top left of the bounding box, pixel
        # (crop_size - 1, crop_size - 1) to the bottom right corner of the
        # bounding box
        transforms[:, 0, 0] = bbox_size  # / (self.crop_size - 1)
        transforms[:, 1, 1] = bbox_size  # / (self.crop_size - 1)
        transforms[:, 0, 2] = center[:, 0] - bbox_size * 0.5
        transforms[:, 1, 2] = center[:, 1] - bbox_size * 0.5

        hd_to_crop[:, 0, 0] = 2 * (self.crop_size - 1) / bbox_size
        hd_to_crop[:, 1, 1] = 2 * (self.crop_size - 1) / bbox_size
        hd_to_crop[:, 0,
                   2] = -(center[:, 0] - bbox_size * 0.5) * hd_to_crop[:, 0,
                                                                       0] - 1
        hd_to_crop[:, 1,
                   2] = -(center[:, 1] - bbox_size * 0.5) * hd_to_crop[:, 1,
                                                                       1] - 1

        size_bbox_sizer = torch.eye(3,
                                    dtype=full_imgs.dtype,
                                    device=full_imgs.device).reshape(