Detecta poses con ML Kit en iOS

El Kit de AA proporciona dos SDK optimizados para la detección de poses.

Probar

• Prueba la app de ejemplo para ver un ejemplo de uso de esta API.

Antes de comenzar

1. Incluye los siguientes pods del ML Kit en tu Podfile:

   # If you want to use the base implementation:
   pod 'GoogleMLKit/PoseDetection', '3.2.0'
   
   # If you want to use the accurate implementation:
   pod 'GoogleMLKit/PoseDetectionAccurate', '3.2.0'
   

2. Después de instalar o actualizar los Pods de tu proyecto, abre el proyecto de Xcode con su xcworkspace. El Kit de AA es compatible con Xcode 13.2.1 o versiones posteriores.

1. Crea una instancia de PoseDetector.

Para detectar una pose en una imagen, primero crea una instancia de PoseDetector y si lo deseas, puedes especificar la configuración del detector.

PoseDetector opciones

Modo de detección

PoseDetector funciona en dos modos de detección. Asegúrate de elegir la que coincida para tu caso de uso.

stream (predeterminada)

El detector de poses primero detectará a una persona prominente en la imagen y, luego, ejecuta la detección de poses. En los fotogramas posteriores, el paso de detección de personas no se realizará, a menos que la persona sea o se ocultan o ya no se detectan con un alto nivel de confianza. El detector de poses rastrear a la persona más destacada y devolver su pose en cada la inferencia. Esto reduce la latencia y suaviza la detección. Usa este modo cuando detectar la pose en una transmisión de video por Internet.

singleImage

El detector de poses detectará a una persona y, luego, ejecutará la pose de detección de intrusiones. El paso de detección de personas se ejecutará para cada imagen, por lo que ser más altos y no hay seguimiento de personas. Usa este modo cuando uses la postura de detección en imágenes estáticas o en las que no se desea realizar un seguimiento.

Especifica las opciones del detector de poses:

// Base pose detector with streaming, when depending on the PoseDetection SDK
let options = PoseDetectorOptions()
options.detectorMode = .stream

// Accurate pose detector on static images, when depending on the
// PoseDetectionAccurate SDK
let options = AccuratePoseDetectorOptions()
options.detectorMode = .singleImage

// Base pose detector with streaming, when depending on the PoseDetection SDK
MLKPoseDetectorOptions *options = [[MLKPoseDetectorOptions alloc] init];
options.detectorMode = MLKPoseDetectorModeStream;

// Accurate pose detector on static images, when depending on the
// PoseDetectionAccurate SDK
MLKAccuratePoseDetectorOptions *options =
    [[MLKAccuratePoseDetectorOptions alloc] init];
options.detectorMode = MLKPoseDetectorModeSingleImage;

Por último, obtén una instancia de PoseDetector. Pasa las opciones que especificaste:

let poseDetector = PoseDetector.poseDetector(options: options)

MLKPoseDetector *poseDetector =
    [MLKPoseDetector poseDetectorWithOptions:options];

2. Prepara la imagen de entrada

Para detectar poses, haz lo siguiente con cada imagen o fotograma de video. Si habilitaste el modo de transmisión, debes crear objetos VisionImage a partir de CMSampleBuffer

Crea un objeto VisionImage con un objeto UIImage o CMSampleBuffer

Si usas un UIImage, sigue estos pasos:

• Crea un objeto VisionImage con UIImage. Asegúrate de especificar el .orientation correcto.

  Swift

  let image = VisionImage(image: UIImage)
  visionImage.orientation = image.imageOrientation

  Objective-C

  MLKVisionImage *visionImage = [[MLKVisionImage alloc] initWithImage:image];
  visionImage.orientation = image.imageOrientation;

Si usas un CMSampleBuffer, sigue estos pasos:

• Especificar la orientación de los datos de imagen que se incluyen en la CMSampleBuffer

  Para obtener la orientación de la imagen, haz lo siguiente:

  Swift

  func imageOrientation(
    deviceOrientation: UIDeviceOrientation,
    cameraPosition: AVCaptureDevice.Position
  ) -> UIImage.Orientation {
    switch deviceOrientation {
    case .portrait:
      return cameraPosition == .front ? .leftMirrored : .right
    case .landscapeLeft:
      return cameraPosition == .front ? .downMirrored : .up
    case .portraitUpsideDown:
      return cameraPosition == .front ? .rightMirrored : .left
    case .landscapeRight:
      return cameraPosition == .front ? .upMirrored : .down
    case .faceDown, .faceUp, .unknown:
      return .up
    }
  }
        

  Objective-C

  - (UIImageOrientation)
    imageOrientationFromDeviceOrientation:(UIDeviceOrientation)deviceOrientation
                           cameraPosition:(AVCaptureDevicePosition)cameraPosition {
    switch (deviceOrientation) {
      case UIDeviceOrientationPortrait:
        return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationLeftMirrored
                                                              : UIImageOrientationRight;
  
      case UIDeviceOrientationLandscapeLeft:
        return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationDownMirrored
                                                              : UIImageOrientationUp;
      case UIDeviceOrientationPortraitUpsideDown:
        return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationRightMirrored
                                                              : UIImageOrientationLeft;
      case UIDeviceOrientationLandscapeRight:
        return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationUpMirrored
                                                              : UIImageOrientationDown;
      case UIDeviceOrientationUnknown:
      case UIDeviceOrientationFaceUp:
      case UIDeviceOrientationFaceDown:
        return UIImageOrientationUp;
    }
  }
        

• Crea un objeto VisionImage con el elemento Objeto CMSampleBuffer y orientación:

  Swift

  let image = VisionImage(buffer: sampleBuffer)
  image.orientation = imageOrientation(
    deviceOrientation: UIDevice.current.orientation,
    cameraPosition: cameraPosition)

  Objective-C

   MLKVisionImage *image = [[MLKVisionImage alloc] initWithBuffer:sampleBuffer];
   image.orientation =
     [self imageOrientationFromDeviceOrientation:UIDevice.currentDevice.orientation
                                  cameraPosition:cameraPosition];

3. Procesa la imagen

Pasa el VisionImage a uno de los métodos de procesamiento de imágenes del detector de poses. Puedes usar el método asíncrono process(image:) o el método síncrono results().

Para detectar objetos de manera síncrona, haz lo siguiente:

var results: [Pose]
do {
  results = try poseDetector.results(in: image)
} catch let error {
  print("Failed to detect pose with error: \(error.localizedDescription).")
  return
}
guard let detectedPoses = results, !detectedPoses.isEmpty else {
  print("Pose detector returned no results.")
  return
}

// Success. Get pose landmarks here.

NSError *error;
NSArray *poses = [poseDetector resultsInImage:image error:&error];
if (error != nil) {
  // Error.
  return;
}
if (poses.count == 0) {
  // No pose detected.
  return;
}

// Success. Get pose landmarks here.

Para detectar objetos de manera asíncrona, haz lo siguiente:

poseDetector.process(image) { detectedPoses, error in
  guard error == nil else {
    // Error.
    return
  }
  guard !detectedPoses.isEmpty else {
    // No pose detected.
    return
  }

  // Success. Get pose landmarks here.
}

[poseDetector processImage:image
                completion:^(NSArray * _Nullable poses,
                             NSError * _Nullable error) {
                    if (error != nil) {
                      // Error.
                      return;
                    }
                    if (poses.count == 0) {
                      // No pose detected.
                      return;
                    }

                    // Success. Get pose landmarks here.
                  }];

4. Obtén información sobre la pose detectada

Si se detecta una persona en la imagen, la API de detección de poses pasa una array de objetos Pose al controlador de finalización o muestra el array dependiendo de si llamaste al método asíncrono o síncrono.

Si la persona no estaba completamente dentro de la imagen, el modelo asigna las coordenadas de los puntos de referencia faltantes fuera del marco y les InFrameConfidence.

Si no se detectó a una persona, el array estará vacío.

for pose in detectedPoses {
  let leftAnkleLandmark = pose.landmark(ofType: .leftAnkle)
  if leftAnkleLandmark.inFrameLikelihood > 0.5 {
    let position = leftAnkleLandmark.position
  }
}

for (MLKPose *pose in detectedPoses) {
  MLKPoseLandmark *leftAnkleLandmark =
      [pose landmarkOfType:MLKPoseLandmarkTypeLeftAnkle];
  if (leftAnkleLandmark.inFrameLikelihood > 0.5) {
    MLKVision3DPoint *position = leftAnkleLandmark.position;
  }
}

Sugerencias para mejorar el rendimiento

La calidad de los resultados depende de la calidad de la imagen de entrada:

• Para que el Kit de AA detecte la pose con precisión, la persona que aparece en la imagen debe ser se debe representar con datos de píxeles suficientes; para obtener el mejor rendimiento, el sujeto debe Debe ser de, al menos, 256 x 256 píxeles.
• Si detectas la pose en una aplicación en tiempo real, también deberías considerar las dimensiones generales de las imágenes de entrada. Las imágenes más pequeñas se pueden procesar más rápido, así que, para reducir la latencia, captura imágenes con resoluciones más bajas, pero tenga en cuenta los requisitos de resolución anteriores y asegúrese de que el tema se ocupe la mayor parte posible de la imagen.
• Un enfoque de imagen deficiente también puede afectar la precisión. Si no obtienes resultados aceptables, pedirle al usuario que vuelva a capturar la imagen.

Si quieres usar la detección de poses en una aplicación en tiempo real, sigue estos lineamientos para lograr la mejor velocidad de fotogramas:

• Usa el SDK base de PoseDetection y el modo de detección stream.
• Intenta capturar imágenes con una resolución más baja. Sin embargo, también ten en cuenta los requisitos de dimensiones de imágenes de esta API.
• Para procesar fotogramas de video, usa la API síncrona results(in:) del detector. Llama a este método desde el elemento AVCaptureVideoDataOutputSampleBufferDelegate. captureOutput(_, didOutput:from:) para obtener resultados de un fotograma de video determinado de forma síncrona. Mantén el elemento alwaysDiscardsLateVideoFrames de AVCaptureVideoDataOutput como verdadero para limitar las llamadas al detector. Si hay un fotograma de video nuevo disponible mientras se ejecuta el detector, se descartará.
• Si usas la salida del detector para superponer gráficos en la imagen de entrada, primero obtén el resultado del ML Kit y, luego, procesa la imagen y la superposición en un solo paso. De esta manera, procesas la superficie de visualización solo una vez por cada fotograma de entrada procesado. Consulta la previewOverlayView y MLKDetectionOverlayView en la aplicación de muestra de ejemplo.

Próximos pasos

• Si quieres aprender a usar puntos de referencia para clasificar poses, consulta Sugerencias para la clasificación de poses.
• Consulta la muestra de inicio rápido del Kit de AA alojada en GitHub para ver un ejemplo de esta API en uso.