      """ Rotate the landmarks and bounding box for faces
          found in rotated images.
          Pass in a DetectedFace object"""
      rotation_matrix = cv2.invertAffineTransform(rotation_matrix)
      bounding_box = [[face.x, face.y],
                      [face.x + face.w, face.y],
                      [face.x + face.w, face.y + face.h],
                      [face.x, face.y + face.h]]
      landmarks = face.landmarksXY
      rotated = list()
      for item in (bounding_box, landmarks):
          points = np.array(item, np.int32)
          points = np.expand_dims(points, axis=0)
          transformed = cv2.transform(points,
 
</s> remove         Pass in a DetectedFace object"""
 </s> add         Pass in a DetectedFace object, Alignments dict or DLib rectangle"""
    if isinstance(face, DetectedFace):
        bounding_box = [[face.x, face.y],
                        [face.x + face.w, face.y],
                        [face.x + face.w, face.y + face.h],
                        [face.x, face.y + face.h]]
        landmarks = face.landmarksXY

    elif isinstance(face, dict):
        bounding_box = [[face.get("x", 0), face.get("y", 0)],
                        [face.get("x", 0) + face.get("w", 0),
                         face.get("y", 0)],
                        [face.get("x", 0) + face.get("w", 0),
                         face.get("y", 0) + face.get("h", 0)],
                        [face.get("x", 0),
                         face.get("y", 0) + face.get("h", 0)]]
        landmarks = face.get("landmarksXY", list())

    elif isinstance(face, dlib.rectangle):
        bounding_box = [[face.left(), face.top()],
                        [face.right(), face.top()],
                        [face.right(), face.bottom()],
                        [face.left(), face.bottom()]]
        landmarks = list()
    else:
        raise ValueError("Unsupported face type")
 </s> remove     exclude_names = [basename(Path(x).stem[:Path(x).stem.rfind('_')] +
                              Path(x).suffix) for x in exclude]
 </s> add     exclude_names = [os.path.basename(Path(x).stem[:Path(x).stem.rfind('_')] +
                                      Path(x).suffix) for x in exclude] </s> remove     def have_face(self, filename):
        """ return path of images that have faces """
        return os.path.basename(filename) in self.faces_detected

    def get_faces(self, image, rotation=0):
        """ Extract the faces from an image """
        faces_count = 0
        faces = detect_faces(image,
                             self.args.detector,
                             self.args.verbose,
                             rotation=rotation,
                             dlib_buffer=self.args.dlib_buffer,
                             mtcnn_kwargs=self.mtcnn_kwargs)

        for face in faces:
            if self.filter and not self.filter.check(face):
                if self.args.verbose:
                    print("Skipping not recognized face!")
                continue
            yield faces_count, face

            self.num_faces_detected += 1
            faces_count += 1

        if faces_count > 1 and self.args.verbose:
            self.verify_output = True

    def get_faces_alignments(self, filename, image):
        """ Retrieve the face alignments from an image """
        faces_count = 0
        faces = self.faces_detected[os.path.basename(filename)]
        for rawface in faces:
            face = DetectedFace(**rawface)
            # Rotate the image if necessary
            # NB: Rotation of landmarks now occurs at extract stage
            # This is here for legacy alignments
            if face.r != 0:
                image, _ = rotate_image_by_angle(image, face.r)
            face.image = image[face.y: face.y + face.h,
                               face.x: face.x + face.w]
            if self.filter and not self.filter.check(face):
                if self.args.verbose:
                    print("Skipping not recognized face!")
                continue
 </s> add class Images():
    """ Holds the full frames/images """
    def __init__(self, arguments):
        self.args = arguments
        self.input_images = self.get_input_images()
        self.images_found = len(self.input_images) </s> remove def __indent_text_block(text):
    a = text.splitlines()
    if len(a)>1:
        b = a[0] + "\r\n"
        for i in range(1, len(a)-1):
            b = b + "        " + a[i] + "\r\n"
        b = b +  "        " + a[-1]
        return b
    else:
        return text

def Term_Support_Color():
    global OS_Version
    return (OS_Version[0] == "Linux" or OS_Version[0] == "Darwin")

def INFO(text):
    t = "%sINFO   %s " % (color_green, color_default) if Term_Support_Color() else "INFO    "
    print(t + __indent_text_block(text))
 </s> add 
      """ Rotate the landmarks and bounding box for faces
          found in rotated images.
          Pass in a DetectedFace object"""
      rotation_matrix = cv2.invertAffineTransform(rotation_matrix)





      rotated = list()
      for item in (bounding_box, landmarks):
          points = np.array(item, np.int32)
          points = np.expand_dims(points, axis=0)
          transformed = cv2.transform(points,
keep keep keep keep replace replace replace replace replace keep keep keep keep keep
 Extraction - Speed improvements (#522) (#523)

* Extraction - Speed improvements (#522)

* Initial Plugin restructure

* Detectors to plugins. Detector speed improvements

* Re-implement dlib aligner, remove models, FAN to TF. Parallel processing

* Update manual, update convert, implement parallel/serial switching

* linting + fix cuda check (setup.py). requirements update keras 2.2.4

* Add extract size option. Fix dlib hog init

* GUI: Increase tooltip width

* Update alignment tool to support new DetectedFace

* Add skip existing faces option

* Fix sort tool to new plugin structure

* remove old align plugin

* fix convert -skip faces bug

* Fix convert skipping no faces frames

* Convert - draw onto transparent layer

* Fix blur threshold bug

* fix skip_faces convert bug

* Fix training 
lib/utils.py