          bottom = box[3] + offset[1]
          return [left, top, right, bottom]
  
      @staticmethod
      def get_square_box(box):
          """Get a square box out of the given box, by expanding it."""
          left = box[0]
          top = box[1]
          right = box[2]
          bottom = box[3]
  
 
</s> remove     @staticmethod
    def move_box(box, offset):
        """Move the box to direction specified by vector offset"""
 </s> add     @classmethod
    def move_box(cls,
                 box: List[int],
                 offset: Tuple[int, int]) -> List[int]:
        """Move the box to direction specified by vector offset

        Parameters
        ----------
        box: list
            The (`left`, `top`, `right`, `bottom`) box positions
        offset: tuple
            (x, y) offset to move the box

        Returns
        -------
        list
            The original box shifted by the offset
        """ </s> remove     @staticmethod
    def pad_image(box, image):
        """Pad image if face-box falls outside of boundaries """
 </s> add     @classmethod
    def pad_image(cls, box: List[int], image: np.ndarray) -> Tuple[np.ndarray, Tuple[int, int]]:
        """Pad image if face-box falls outside of boundaries

        Parameters
        ----------
        box: list
            The (`left`, `top`, `right`, `bottom`) roi box positions
        image: :class:`numpy.ndarray`
            The image to be padded

        Returns
        -------
        :class:`numpy.ndarray`
            The padded image
        """ </s> remove         logger.trace("Padding: (l: %s, t: %s, r: %s, b: %s)", pad_l, pad_t, pad_r, pad_b)
 </s> add         logger.trace("Padding: (l: %s, t: %s, r: %s, b: %s)",  # type:ignore
                     pad_l, pad_t, pad_r, pad_b) </s> remove     def align_image(self, batch):
        """ Align the incoming image for prediction """
        logger.trace("Aligning image around center")
 </s> add         Returns
        -------
        box: list
            The [left, top, right, bottom] bounding box
        offset: int
            The offset of the box (difference between half width vs height)
        """

        box = cast(List[int], [face.left,
                               face.top,
                               face.right,
                               face.bottom])
        diff_height_width = cast(int, face.height) - cast(int, face.width)
        offset = int(abs(diff_height_width / 2))
        return box, offset

    def align_image(self, batch: AlignerBatch) -> Tuple[List[np.ndarray],
                                                        List[List[int]],
                                                        List[Tuple[int, int]]]:
        """ Align the incoming image for prediction

        Parameters
        ----------
        batch: :class:`AlignerBatch`
            The current batch to align the input for

        Returns
        -------
        faces: list
            List of feed faces for the aligner
        rois: list
            List of roi's for the faces
        offsets: list
            List of offsets for the faces
        """
        logger.trace("Aligning image around center")  # type:ignore </s> remove     def crop(self, batch):  # pylint:disable=too-many-locals
        """ Crop image around the center point """
 </s> add     def _crop_image(self,
                    image: np.ndarray,
                    top_left: np.ndarray,
                    bottom_right: np.ndarray) -> np.ndarray:
        """ Crop a single image

        Parameters
        ----------
        image: :class:`numpy.ndarray`
            The image to crop
        top_left: :class:`numpy.ndarray`
            The top left (x, y) point to crop from
        bottom_right: :class:`numpy.ndarray`
            The bottom right (x, y) point to crop to

        Returns
        -------
        :class:`numpy.ndarray`
            The cropped image
        """
        bottom_right_width, bottom_right_height = bottom_right[0].astype('int32')
        top_left_width, top_left_height = top_left[0].astype('int32')
        new_dim = (bottom_right_height - top_left_height,
                   bottom_right_width - top_left_width,
                   3 if image.ndim > 2 else 1)
        new_img = np.empty(new_dim, dtype=np.uint8)

        new_x = slice(max(0, -top_left_width),
                      min(bottom_right_width, image.shape[1]) - top_left_width)
        new_y = slice(max(0, -top_left_height),
                      min(bottom_right_height, image.shape[0]) - top_left_height)
        old_x = slice(max(0, top_left_width), min(bottom_right_width, image.shape[1]))
        old_y = slice(max(0, top_left_height), min(bottom_right_height, image.shape[0]))
        new_img[new_y, new_x] = image[old_y, old_x]

        interp = cv2.INTER_CUBIC if new_dim[0] < self.input_size else cv2.INTER_AREA
        return cv2.resize(new_img,
                          dsize=(self.input_size, self.input_size),
                          interpolation=interp)

    def crop(self, batch: AlignerBatch, center_scale: np.ndarray) -> List[np.ndarray]:
        """ Crop image around the center point

        Parameters
        ----------
        batch: :class:`AlignerBatch`
            The current batch to crop the image for
        center_scale: :class:`numpy.ndarray`
            The center and scale for the bounding box

        Returns
        -------
        list
            List of cropped images for the batch
        """
    def get_square_box(box: List[int]) -> List[int]:
        """Get a square box out of the given box, by expanding it.

        Parameters
        ----------
        box: list
            The (`left`, `top`, `right`, `bottom`) box positions

        Returns
        -------
        list
            The original box but made square
        """
          bottom = box[3] + offset[1]
          return [left, top, right, bottom]
  
      @staticmethod
    def get_square_box(box: List[int]) -> List[int]:
        """Get a square box out of the given box, by expanding it.

        Parameters
        ----------
        box: list
            The (`left`, `top`, `right`, `bottom`) box positions

        Returns
        -------
        list
            The original box but made square
        """
    def get_square_box(box: List[int]) -> List[int]:
        """Get a square box out of the given box, by expanding it.

        Parameters
        ----------
        box: list
            The (`left`, `top`, `right`, `bottom`) box positions

        Returns
        -------
        list
            The original box but made square
        """
          left = box[0]
          top = box[1]
          right = box[2]
          bottom = box[3]
  
keep keep keep keep replace replace keep keep keep keep keep
 Extract updates:
  - Default CPU detector to MTCNN
  - add basic Aligner false positive filters
  - Typing: align + plugins
  - Use specific AlignerBatch class for alignment
  - 
plugins/extract/align/cv2_dnn.py