Introducción a HMS Core

1

Creación de Cámara Selfie con Kits de Huawei

2

Depuración de Aplicaciones en la Nube con Huawei Cloud Debugging

3

Desarrollo de Aplicaciones con Huawei Mobile Services Core

4

Creación de Proyecto Android Studio con Huawei Kits

5

Creación de Aplicaciones en AppGallery Connect de Huawei

6

Generación de Huella Digital SHA-256 para Android Studio

7

Configuración de APIs Huawei para Proyecto de Selfies en Android Studio

8

Configuración de Gradle para Huawei en Android Studio

9

Sincronización de aplicaciones con dependencias Huawei en Gradle

Autenticación con HMS Account Kit

10

Diseño de Pantalla de Login con Huawei Account Kit

11

Autenticación con Huawei Account Kit en Aplicaciones Android

12

Autenticación con Huawei ID en Aplicaciones Android

13

Implementación de Logout con Huawei AccountKit y Refactorización en Android

Construyendo nuestra cámara de selfies con HMS ML Kit

14

Diseño de Pantalla en Selficam con Huawei ML Kit

15

Permisos de Cámara en Aplicaciones Android

16

Configuración y Personalización de Cámaras en Android

17

Personalización de Interfaz Gráfica para Cámara en Android

18

Reconocimiento Facial con Machine Learning en Android

19

Creación del Motor de Lente para Selfie Cam en Android

20

Implementación de Layout para Actividad de Cámara en Android

21

Integración de Cámara y Botones en Aplicación de Selfies

22

Implementación de Verificación Facial en App Android

23

Detección de Sonrisa y Rostro en Cámaras Huawei

24

Detección de Rostros y Cambio de Cámara en Android Studio

25

Implementación de Funcionalidad de Toma y Retoma de Fotos en Android

26

Guardar fotos en la galería con Android y Huawei Machine Learning

Aplicando notificaciones push con HMS Push kit

27

Implementación de Huawei Push Notifications en Android

28

Implementación de Push Notifications en AppGallery Connect

29

Configuración y Envío de Notificaciones Push en AppGallery Connect

Conclusiones y consejos

30

Solución de Problemas Comunes en Desarrollo con Huawei HMS Core

31

Eventos de Huawei para Desarrolladores y Servicios Ofrecidos

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Reconocimiento Facial con Machine Learning en Android

18/31
Recursos

¿Cómo crear un layout personalizado para reconocimiento facial en Android?

Personalizar el layout al agregar capacidades de reconocimiento facial no solo mejora la experiencia del usuario, sino que también incorpora avanzada tecnología de Machine Learning. Esta clase te guiará a través del proceso de creación de un cuadro alrededor del rostro detectado por la cámara frontal, optimizando el uso de píxeles y utilizando objetos de Machine Learning para reconocer las facciones.

¿Qué es y cómo se utiliza el paquete 'utils'?

El primer paso en la personalización del reconocimiento facial es configurar el paquete utils. Este paquete es esencial para convertir density pixels a píxeles reales en Android, dado que el objeto de la cámara trabaja con Canvas y solo entiende píxeles reales. Aquí está cómo lograrlo:

// Creación de la función para convertir density pixels a píxeles reales
object Utils {
    fun dpToPx(context: Context, value: Float): Float {
        return value * context.resources.displayMetrics.density + 0.5f
    }
}

¿Cómo crear la clase 'local face graphic'?

La clase LocalFaceGraphic ayudará a pintar un cuadrado sobre el rostro detectado por la cámara. Aquí se describe cómo configurar esta clase:

  1. Herencia y constructor: Hereda de BaseGraphic y recibe un GraphicOverlay como parámetro en el constructor.
  2. Variables esenciales:
    • facePaint: para definir el estilo y color del cuadro.
    • face: un campo de tipo volátil que almacena información del rostro.
    • context: para las operaciones relacionadas con los recursos de la aplicación.
  3. Métodos clave:
    • Inicialización del face paint: Define estilo y color del cuadro. Para este ejemplo, usamos un tono rojo de Huawei.
    • Funcionamiento del método draw: Si no hay rostro reconocido, simply return. De lo contrario, calcula las coordenadas para trazar el cuadro.
// Ejemplo de implementación de LocalFaceGraphic
class LocalFaceGraphic(overlay: GraphicOverlay, private val face: MLFace, private val context: Context) :
    BaseGraphic(overlay) {

    private val facePaint: Paint = Paint().apply {
        color = Color.parseColor("#EF484B") // Color rojo de Huawei
        style = Paint.Style.STROKE
        strokeWidth = Utils.dpToPx(context, 1f)
    }

    override fun draw(canvas: Canvas) {
        if (face == null) return

        val points = ... // Puntos faciales para trazar el rectángulo
        ...
        // Crear y agregar el rectángulo al canvas
        canvas.drawRect(rectangle, facePaint)
    }
}

¿Cómo se realiza el trazado del rectángulo?

Para pintar un rectángulo alrededor del rostro identificado, sigue estos pasos clave:

  • Detección de puntos faciales: Se obtienen los puntos clave del rostro como los ojos y las esquinas de la cara.
  • Cálculo de coordenadas: Para determinar los límites del rectángulo, se calcula el mínimo y máximo de las coordenadas verticales y horizontales.
  • Dibujo del rectángulo: Utiliza estas coordenadas para dibujar sobre el Canvas.

Esta es la esencia del Machine Learning aplicada al reconocimiento facial sencillo, permitiendo que el software actúe inteligentemente reconociendo y marcando rostros. Recuerda que la práctica es crucial; así que sigue experimentando y expandiendo tus habilidades. Tu próxima clase te guiará en el uso del cuadro de reconocimiento facial en el lente de cámara. ¡Sigue así y tu dominio de esta tecnología irá en aumento!

Aportes 5

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

**CommonUtils **

package com.sandoval.hselfiecamera.utils

import android.content.Context

object CommonUtils {
    fun dp2px(context: Context, dipValue: Float): Float {
        return dipValue * context.resources.displayMetrics.density + 0.5f
    }
}

LocalFaceGraphic

package com.sandoval.hselfiecamera.overlay

import android.content.Context
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.Paint
import android.graphics.Rect
import com.huawei.hms.mlsdk.face.MLFace
import com.huawei.hms.mlsdk.face.MLFaceShape
import com.sandoval.hselfiecamera.utils.CommonUtils.dp2px

class LocalFaceGraphic(
    private val overlay: GraphicOverlay,
    @field:Volatile private var face: MLFace?,
    private val mContext: Context
) : BaseGraphic(overlay) {

    private val facePaint: Paint

    init {
        val lineWidth = dp2px(mContext, 1f)
        facePaint = Paint()
        facePaint.color = Color.parseColor("#EF484B")
        facePaint.style = Paint.Style.STROKE
        facePaint.strokeWidth = lineWidth
    }

    override fun draw(canvas: Canvas?) {
        if (face == null) {
            return
        }

        val faceShape = face!!.getFaceShape(MLFaceShape.TYPE_FACE)
        val points = faceShape.points
        var verticalMin = Float.MAX_VALUE
        var verticalMax = 0f
        var horizontalMin = Float.MAX_VALUE
        var horizontalMax = 0f
        for (i in points.indices) {
            val point = points[i] ?: continue
            if (point.x != null && point.y != null) {
                if (point.x > horizontalMax) horizontalMax = point.x
                if (point.x < horizontalMin) horizontalMin = point.x
                if (point.y > verticalMax) verticalMax = point.y
                if (point.y < verticalMin) verticalMin = point.y
            }
        }
        val rect = Rect(
            translateX(horizontalMin).toInt(),
            translateY(verticalMin).toInt(),
            translateY(horizontalMax).toInt(),
            translateY(verticalMax).toInt()
        )
        canvas!!.drawRect(rect, facePaint)
    }

}

Es interesante como MLFace tiene utilidades para detectar rostros o cosas mas detalladas como los ojos

Desconocía que Android Canvas no es compatible con DensityPoints

Revisando el código noté que al declarar la clase Rect() de android.graphics, se pasa 3 veces el método translateY(), por lo que a mi parecer debería de ser de la siguiente manera:

 val rect = Rect(
            translateX(horizontalMin).toInt(),
            translateY(verticalMin).toInt(),
            translateX(horizontalMax).toInt(),
            translateY(verticalMax).toInt()
        )
        canvas!!.drawRect(rect, facePaint)

Ya que esto es lo que solicita el método Rect():

 public Rect(int left, int top, int right, int bottom) {
        throw new RuntimeException("Stub!");
    }

No estoy completamente seguro de si mi teoría es la correcta…
Saludos