Detección de Rostros con Cámara

Para realizar la detección de rostros en iOS, hay CIDetector (Apple) o Mobile Vision (Google) API.

IMO, Google Mobile Vision proporciona un mejor rendimiento.

Si estás interesado, aquí está el proyecto con el que puedes jugar. (iOS 10.2, Swift 3)

Después de WWDC 2017, Apple introduce CoreML en iOS 11. El marco Vision hace que la detección de rostros sea más precisa:)

He hecho una demostración Proyecto. contiene Vision v. s. CIDetector. Además, contiene detección de puntos de referencia de cara en tiempo real.

extension CameraViewController: AVCaptureMetadataOutputObjectsDelegate {
  func captureOutput(_ captureOutput: AVCaptureOutput!, didOutputMetadataObjects metadataObjects: [Any]!, from connection: AVCaptureConnection!) {
    if findFaceControl {
      findFaceControl = false
      let faces = metadata.flatMap { $0 as? AVMetadataFaceObject } .flatMap { (face) -> CGRect in
                  guard let localizedFace =
      previewLayer?.transformedMetadataObject(for: face) else { return nil }
                  return localizedFace.bounds }
      for face in faces {
        let temp = UIView(frame: face)
        temp.layer.borderColor = UIColor.white
        temp.layer.borderWidth = 2.0
        view.addSubview(view: temp)
      }
    }
  }
}

Asegúrese de eliminar las vistas creadas por didOutputMetadataObjects.

Mantener un registro de los identificadores faciales activos es la mejor manera de hacer esto ^

También cuando está tratando de encontrar la ubicación de las caras para su capa de vista previa, es mucho más fácil usar datos faciales y transformar. También creo que CIDetector es basura, metadataoutput utilizará cosas de hardware para la detección de rostros, lo que lo hace muy rápido.

Un poco tarde, pero aquí está la solución para el problema de las coordenadas. Hay un método que puede llamar a la capa de vista previa para transformar el objeto de metadatos en su sistema de coordenadas: transformedMetadataObject(para: metadataObject).

guard let transformedObject = previewLayer.transformedMetadataObject(for: metadataObject) else {
     continue
}
let bounds = transformedObject.bounds
showBounds(at: bounds)

Fuente: https://developer.apple.com/documentation/avfoundation/avcapturevideopreviewlayer/1623501-transformedmetadataobjectformeta

Por cierto, en caso de que esté utilizando (o actualice su proyecto a) Swift 4, el método delegado de AVCaptureMetadataOutputsObject ha cambiado a:

func metadataOutput(_ output: AVCaptureMetadataOutput, didOutput metadataObjects: [AVMetadataObject], from connection: AVCaptureConnection)

Saludos cordiales

Al mirar su código, detecté 2 cosas que podrían conducir a una detección de rostros incorrecta/deficiente.

1. Uno de ellos es el detector de caras con opciones donde se filtran los resultados por [CIDetectorSmile: true, CIDetectorEyeBlink: true]. Intenta configurarlo en cero: faceDetector?.features(in: faceImage, options: nil)
2. Otra conjetura que tengo es el resultado orientación de la imagen. Me di cuenta de que utiliza el método AVCapturePhotoOutput.jpegPhotoDataRepresentation para generar la imagen de origen para la detección y el sistema, por defecto, genera esa imagen con un orientación, de tipo Left/LandscapeLeft, Creo. Por lo tanto, básicamente se puede decir que el detector de la cara para tener eso en mente mediante el uso de la CIDetectorImageOrientation llave.

CIDetectorImageOrientation : el valor de esta clave es un entero NSNumber de 1..8 como la que se encuentra en kCGImagePropertyOrientation. Si está presente, la detección se realizará en función de esa orientación, pero las coordenadas en las entidades devueltas seguirán basándose en las de la imagen.

Intenta configurarlo como faceDetector?.features(in: faceImage, options: [CIDetectorImageOrientation: 8 /*Left, bottom*/]).

1. Crear CaptureSession

2. Para AVCaptureVideoDataOutput crear los siguientes ajustes

   Salida.videoSettings = [kCVPixelBufferPixelFormatTypeKey como AnyHashable: Int (kCMPixelFormat_32BGRA)]

3.Cuando reciba CMSampleBuffer, cree una imagen

DispatchQueue.main.async {
    let sampleImg = self.imageFromSampleBuffer(sampleBuffer: sampleBuffer)
    self.imageView.image = sampleImg
}
func imageFromSampleBuffer(sampleBuffer : CMSampleBuffer) -> UIImage
    {
        // Get a CMSampleBuffer's Core Video image buffer for the media data
        let  imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
        // Lock the base address of the pixel buffer
        CVPixelBufferLockBaseAddress(imageBuffer!, CVPixelBufferLockFlags.readOnly);


        // Get the number of bytes per row for the pixel buffer
        let baseAddress = CVPixelBufferGetBaseAddress(imageBuffer!);

        // Get the number of bytes per row for the pixel buffer
        let bytesPerRow = CVPixelBufferGetBytesPerRow(imageBuffer!);
        // Get the pixel buffer width and height
        let width = CVPixelBufferGetWidth(imageBuffer!);
        let height = CVPixelBufferGetHeight(imageBuffer!);

        // Create a device-dependent RGB color space
        let colorSpace = CGColorSpaceCreateDeviceRGB();

        // Create a bitmap graphics context with the sample buffer data
        var bitmapInfo: UInt32 = CGBitmapInfo.byteOrder32Little.rawValue
        bitmapInfo |= CGImageAlphaInfo.premultipliedFirst.rawValue & CGBitmapInfo.alphaInfoMask.rawValue
        //let bitmapInfo: UInt32 = CGBitmapInfo.alphaInfoMask.rawValue
        let context = CGContext.init(data: baseAddress, width: width, height: height, bitsPerComponent: 8, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo)
        // Create a Quartz image from the pixel data in the bitmap graphics context
        let quartzImage = context?.makeImage();
        // Unlock the pixel buffer
        CVPixelBufferUnlockBaseAddress(imageBuffer!, CVPixelBufferLockFlags.readOnly);

        // Create an image object from the Quartz image
        let image = UIImage.init(cgImage: quartzImage!);

        return (image);
    }