          batch: :class:`AlignerBatch`
              The current batch from the model with :attr:`predictions` populated
          """
          landmarks = []
          for prediction, roi, offset in zip(batch.prediction,
                                             batch.data[0]["roi"],
                                             batch.data[0]["offsets"]):
              points = np.reshape(prediction, (-1, 2))
              points *= (roi[2] - roi[0])
              points[:, 0] += (roi[0] - offset[0])
              points[:, 1] += (roi[1] - offset[1])
              landmarks.append(points)
          batch.landmarks = np.array(landmarks)
          logger.trace("Predicted Landmarks: %s", batch.landmarks)  # type:ignore
 
</s> remove         batch.landmarks = self.transform(subpixel_landmarks,
                                         batch.data[0]["center_scale"],
                                         resolution)
 </s> add         if batch.second_pass:  # Transformation handled by plugin parent for re-aligned faces
            batch.landmarks = subpixel_landmarks[..., :2] * 4.
        else:
            batch.landmarks = self.transform(subpixel_landmarks,
                                             batch.data[0]["center_scale"],
                                             resolution) </s> remove         faces, roi, offsets = self.align_image(batch)
        faces = self._normalize_faces(faces)
 </s> add         lfaces, roi, offsets = self.align_image(batch)
        batch.feed = np.array(lfaces)[..., :3] </s> remove         new_img = np.empty(new_dim, dtype=np.uint8)
 </s> add         new_img = np.zeros(new_dim, dtype=np.uint8) </s> remove     @classmethod
    def get_pts_from_predict(cls, batch: AlignerBatch):
 </s> add     def get_pts_from_predict(self, batch: AlignerBatch):
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
          batch: :class:`AlignerBatch`
              The current batch from the model with :attr:`predictions` populated
          """
          landmarks = []
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
        if batch.second_pass:
            batch.landmarks = batch.prediction.reshape(self.batchsize, -1, 2) * self.input_size
        else:
            for prediction, roi, offset in zip(batch.prediction,
                                               batch.data[0]["roi"],
                                               batch.data[0]["offsets"]):
                points = np.reshape(prediction, (-1, 2))
                points *= (roi[2] - roi[0])
                points[:, 0] += (roi[0] - offset[0])
                points[:, 1] += (roi[1] - offset[1])
                landmarks.append(points)
            batch.landmarks = np.array(landmarks)
          logger.trace("Predicted Landmarks: %s", batch.landmarks)  # type:ignore
keep keep keep keep replace replace replace replace replace replace replace replace replace keep
 Extract: Implement re-align/2nd pass
   - implement configurable re-align function in extract
  - update locales + documentation
  - re-factor align._base and split to separate modules
  - move normalization method to plugin parent
  - bugfix: FAN use zeros for pre-processing crop
  - lint AlignedFilter 
plugins/extract/align/cv2_dnn.py