              # Legacy extract. Don't crop, just return batch with landmarks
              return batch, np.array([face.landmarks for face in aligned])
  
          if not self._cache["crop_size"]:
              size = aligned[0].get_cropped_size(self._config["centering"])
              logger.debug("caching crop size: (centering: '%s', full size: %s, crop size: %s)",
                           self._config["centering"], batch.shape[1], size)
              self._cache["crop_size"] = size
          size = self._cache["crop_size"]
  
 
</s> remove         cropped = np.zeros((batch.shape[0], size, size, batch.shape[3]), dtype=batch.dtype)

        for out, align, img in zip(cropped, aligned, batch):
            slices = align.get_cropped_slices(self._config["centering"])
            out[slices["out"][0], slices["out"][1], :] = img[slices["in"][0], slices["in"][1], :]
 </s> add         cropped = np.array([align.extract_face(img) for align, img in zip(aligned, batch)]) </s> remove     def get_cropped_size(self, centering):
        """ Obtain the size of a cropped face from a full head centered image.

        Parameters
        ----------
        centering: ["legacy", "face"]
            The type of centering to obtain the region of interest for. "legacy" places the nose
            in the center of the image (the original method for aligning). "face" aligns for the
            nose to be in the center of the face (top to bottom) but the center of the skull for
            left to right.

        Returns
        -------
        int
           The pixel size of a sub-crop image from a full head aligned image

        Notes
        -----
        The ROI in relation to the source image is calculated by rounding the padding of one side
        to the nearest integer then applying this padding to the center of the crop, so the size
        is calculated in the same way.
        """
        if self._centering != "head":
            raise ValueError("Sub ROI can only be obtained from an aligned face with 'head' "
                             "centering")
        with self._cache["cropped_size"][1]:
            if not self._cache["cropped_size"][0].get(centering):
                src_size = self.size - (self._size * _EXTRACT_RATIOS["head"])
                size = 2 * int(np.rint(src_size / (1 - _EXTRACT_RATIOS[centering]) / 2))
                logger.trace("centering: %s, size: %s, crop_size: %s", centering, self._size, size)
                self._cache["cropped_size"][0][centering] = size
        return self._cache["cropped_size"][0][centering]

    def get_cropped_slices(self, centering):
 </s> add     def _get_cropped_slices(self): </s> remove 
        # Revert back to the correct centering and size and reset the cache
        self._centering = old_centering
        self._size = old_size
        self._cache = self._set_cache()
 </s> add 
            size = aligned[0].size
              # Legacy extract. Don't crop, just return batch with landmarks
              return batch, np.array([face.landmarks for face in aligned])
  
          if not self._cache["crop_size"]:
            size = aligned[0].size
              logger.debug("caching crop size: (centering: '%s', full size: %s, crop size: %s)",
                           self._config["centering"], batch.shape[1], size)
              self._cache["crop_size"] = size
          size = self._cache["crop_size"]
  
keep keep keep keep replace keep keep keep keep keep
 Bugfix - Warp to landmarks 
lib/training_data.py