                                             map_[..., 0],
                                             cv2.INTER_LINEAR,
                                             cv2.BORDER_TRANSPARENT)
                                   for image, map_ in zip(batch, maps)])
          warped_batch = np.array([cv2.resize(image[slices, slices, :],
                                              (self._input_size, self._input_size),
                                              cv2.INTER_AREA)
                                   for image in warped_batch])
          logger.trace("Warped batch shape: %s", warped_batch.shape)
          return warped_batch
  
      def skip_warp(self, batch):
          """ Returns the images resized and cropped for feeding the model, if warping has been
          disabled.
 
</s> remove 
    def skip_warp(self, batch):
        """ Returns the images resized and cropped for feeding the model, if warping has been
        disabled.

        Parameters
        ----------
        batch: :class:`numpy.ndarray`
            The batch should be a 4-dimensional array of shape (`batchsize`, `height`, `width`,
            `3`) and in `BGR` format.

        Returns
        -------
        :class:`numpy.ndarray`
            The given batch cropped and resized for feeding the model
        """
        logger.trace("Compiling skip warp images: batch shape: %s", batch.shape)
        slices = self._constants["tgt_slices"]
        retval = np.array([cv2.resize(image[slices, slices, :],
                                      (self._input_size, self._input_size),
                                      cv2.INTER_AREA)
                           for image in batch], dtype='float32') / 255.
        logger.trace("feed batch shape: %s", retval.shape)
        return retval
 </s> add  </s> remove         logger.trace("Warped image shape: %s", warped_batch.shape)
 </s> add         logger.trace("Warped image shape: %s", warped_batch.shape)  # type: ignore </s> remove                                  scale=self._scale).astype("float32")
        batch_maps = np.stack((mapx, mapy), axis=1) + rands
        batch_interp = np.array([[cv2.resize(map_, (pad, pad))[slices, slices] for map_ in maps]
 </s> add                                  scale=self._warp_scale).astype("float32")
        batch_maps = ne.evaluate("m + r", local_dict=dict(m=self._constants.warp_maps, r=rands))
        batch_interp = np.array([[cv2.resize(map_, self._constants.warp_pad)[slices, slices]
                                  for map_ in maps] </s> remove                                self._training_size,
                               self._training_size,
 </s> add                                self._processing_size,
                               self._processing_size, </s> remove     def _random_warp_landmarks(self, batch, batch_src_points, batch_dst_points):
        """ From dfaker. Warp the image to a similar set of landmarks from the opposite side """
        logger.trace("Randomly warping landmarks")
        edge_anchors = self._constants["warp_lm_edge_anchors"]
        grids = self._constants["warp_lm_grids"]
        slices = self._constants["tgt_slices"]
 </s> add     def _random_warp_landmarks(self,
                               batch: np.ndarray,
                               batch_src_points: np.ndarray,
                               batch_dst_points: np.ndarray) -> np.ndarray:
        """ From dfaker. Warp the image to a similar set of landmarks from the opposite side

        batch: :class:`numpy.ndarray`
            The batch should be a 4-dimensional array of shape (`batchsize`, `height`, `width`,
            `3`) and in `BGR` format.
        batch_src_points :class:`numpy.ndarray`
            A batch of 68 point landmarks for the source faces. This is a 3-dimensional array in
            the shape (`batchsize`, `68`, `2`).
        batch_dst_points :class:`numpy.ndarray`
            A batch of randomly chosen closest match destination faces landmarks. This is a
            3-dimensional array in the shape (`batchsize`, `68`, `2`).

        Returns
        ----------
        :class:`numpy.ndarray`
            A 4-dimensional array of the same shape as :attr:`batch` with warping applied.
        """
        logger.trace("Randomly warping landmarks")  # type: ignore
        edge_anchors = self._constants.warp_lm_edge_anchors
        grids = self._constants.warp_lm_grids
        logger.trace("Warped batch shape: %s", warped_batch.shape)  # type: ignore
                                             map_[..., 0],
                                             cv2.INTER_LINEAR,
                                             cv2.BORDER_TRANSPARENT)
                                   for image, map_ in zip(batch, maps)])
        logger.trace("Warped batch shape: %s", warped_batch.shape)  # type: ignore
        logger.trace("Warped batch shape: %s", warped_batch.shape)  # type: ignore
        logger.trace("Warped batch shape: %s", warped_batch.shape)  # type: ignore
        logger.trace("Warped batch shape: %s", warped_batch.shape)  # type: ignore
        logger.trace("Warped batch shape: %s", warped_batch.shape)  # type: ignore
          return warped_batch
  
      def skip_warp(self, batch):
          """ Returns the images resized and cropped for feeding the model, if warping has been
          disabled.
keep keep keep keep replace replace replace replace replace keep keep keep keep keep
 Data Augmentation update (#1263)

- lib.detected_face
    - Subclass Masks for Landmark based masks
    - Add training mask propery + methods to DetectedFace
  - lib.training_training
    - subclass TrainingDataGenerator for training and preview data
    - Split cache into own module
    - Reduce thread count to 1 to prevent image corruption + data re-use
    - Process on largest model input/output size rather than stored image size
    - Size and crop masks during caching stage
    - Implement ring buffer for data flow
    - Fix preview reload bug
  - augmentation
    - typing
    - switch color aug order
    - better initialization
    - Fix warp + landmark warp to correctly apply at different image scales
    - Slightly improved warp caching
    - Don't store whether image is_preview. Handle all data as training images implicitly
  - plugins.trainer: Typing and fixes to work with trainingdata refactor 
lib/training/augmentation.py