HMS ML 키트 detecta una sonrisa al tomar una fotograf

인용문
El Kit de Machine Learning(MLKit)es uno de los servicios más importantes.
Quépuede Hacer ML 키트??Cuál de los siguientes problemas se puede resolver durante el desarrollo de la aplicación?
Hoy,tomemos la detección de rostros como un ejempo para mostrarle las poderosas functiones de MLKIT y la convenienciia que brinda a los desarrolladores.

Capacidides Propocionadas por MLKIT 얼굴 검사

Primero,veamos la capacidad de detección de rostros de Huawei 머신러닝 서비스(MLKIT)
Como se muestra en la animación, el reconocimiento facial puede Reconcer la dirección de la cara, detectar expressiones faciales(Como feliz, Abostado, sorprendido, tristey enojado), detectar atributos faciales(Como género, edady accesorios) y detectar ya sea para abrir ocerrar los ojos, 흠페라 detección coordinada de caracter isticas tales Como caras, Ces, ojos, labios,cejas.Además,se pueden detectar varias caras al mismo tiempo.

Consejos:esta función es Refensa y cubre todos los modelos de Android.
sonrisa fotografía de la función de Desarrollo de la función de fotografía de sonrisa
Hoy,usaremos las Capacidaides de Reconcimiento de múltiples rostros y detección de expresión de MLKIT para describir una pequeña demostración para una instantánea sonriente y realizar una práctica.
Preparaciones de desarrollo 회사
Los preparativos para desarrolillar el kit de Huawei HMS son similares.Laúnica diferenceia es que se agrega La dependencia Maven y se introduce el SDK.

Agrega el repositorio de Huawei Maven al gradle de nivel de proyecto.

Agrega gradualmente las siguientes direcciones de Maven:

// Top-level build file where you can add configuration options common to all sub-projects/modules.buildscript {ext.kotlin_version = "1.3.72"repositories {google()jcenter()maven { url 'https://developer.huawei.com/repo/' } // HUAWEI Maven repository}dependencies {classpath "com.android.tools.build:gradle:4.0.0"classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"classpath 'com.huawei.agconnect:agcp:1.3.1.300'  // HUAWEI agcp plugin// NOTE: Do not place your application dependencies here; they belong// in the individual module build.gradle files}}allprojects {repositories {google()jcenter()maven { url 'https://developer.huawei.com/repo/' } // HUAWEI Maven repository}}task clean(type: Delete) {delete rootProject.buildDir}

2.Agrega la dependencia del SDK al archivo build.gradle en el nivel de la aplicación.

el SDK de reconocimiento facial y el SDK básico를 소개합니다.

dependencies{implementation 'com.huawei.hms:ml-computer-vision-face-emotion-model:1.0.4.300'implementation 'com.huawei.hms:ml-computer-vision-face-feature-model:1.0.4.300'implementation 'com.huawei.hms:ml-computer-vision-face-shape-point-model:1.0.4.300'implementation 'com.huawei.hms:ml-computer-vision-face:1.0.4.300'}

El modelo se agrega al archivo AndroidManifest.xml en modo incremental para descarga automática.

Esto se usa principalmente para actualizar el modelo.Una vez que se optimiza el algoritmo,el modelo se puede descargar automáticamente al teléfono móvil para su realización.

<applicationandroid:allowBackup="true"android:icon="@mipmap/ic_launcher"android:label="@string/app_name"android:roundIcon="@mipmap/ic_launcher_round"android:supportsRtl="true"android:theme="@style/MaterialTheme"><activity android:name=".face.LiveFaceAnalyseActivity" /><activity android:name=".MainActivity"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="android.intent.category.LAUNCHER" /></intent-filter></activity></application>

cámaray almacenamiento en el archivo Android Manifest의 허가를 구하다.xml.

<uses-feature android:name="android.hardware.camera" /><uses-permission android:name="android.permission.CAMERA" /><uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

데사로 델코디고

Creando un analizador facial y tomar fotos cuando se detecte una sonrisa.

Fotos tomadas después de la detección:
1) par á metros del analizador 구성
2) analizador al analizador par á metros del analizador의 환경 설정.
3) En 분석기.setTransaction,TransactionResult debera ser Sobrecrito para procesar el contenido después del reconocimiento face.Después del Reconcimiento facial, se devuelve un nivel de confianza(sonrisa의 확률).Solo necesita establecer el nivel de confianza en un cierto valor.

private var analyzer: MLFaceAnalyzer? = null
 private fun createFaceAnalyzer() {
     // Create a face analyzer. You can create an analyzer using the provided customized face detection parameter
     // MLFaceAnalyzerSetting
     val setting = MLFaceAnalyzerSetting.Factory()
         .setFeatureType(MLFaceAnalyzerSetting.TYPE_FEATURES)
         .setKeyPointType(MLFaceAnalyzerSetting.TYPE_UNSUPPORT_KEYPOINTS)
         .setMinFaceProportion(0.1f)
         .setTracingAllowed(true)
         .create()
     analyzer = MLAnalyzerFactory.getInstance().getFaceAnalyzer(setting)
     if (detectMode == Constant.NEAREST_PEOPLE) {
         val transactor =
             MLMaxSizeFaceTransactor.Creator(analyzer, object : MLResultTrailer<MLFace?>() {
                 override fun objectCreateCallback(
                     itemId: Int,
                     obj: MLFace?
                 ) {
                     overlay!!.clear()
                     if (obj == null) {
                         return
                     }
                     val faceGraphic = LocalFaceGraphic(
                         overlay!!,
                         obj,
                         this@LiveFaceAnalyseActivity
                     )
                     overlay!!.addGraphic(faceGraphic)
                     val emotion = obj.emotions
                     if (emotion.smilingProbability > smilingPossibility) {
                         safeToTakePicture = false
                         mHandler.sendEmptyMessage(TAKE_PHOTO)
                     }
                 }

                 override fun objectUpdateCallback(
                     var1: MLAnalyzer.Result<MLFace?>,
                     obj: MLFace?
                 ) {
                     overlay!!.clear()
                     if (obj == null) {
                         return
                     }
                     val faceGraphic = LocalFaceGraphic(
                         overlay!!,
                         obj,
                         this@LiveFaceAnalyseActivity
                     )
                     overlay!!.addGraphic(faceGraphic)
                     val emotion = obj.emotions
                     if (emotion.smilingProbability > smilingPossibility && safeToTakePicture) {
                         safeToTakePicture = false
                         mHandler.sendEmptyMessage(TAKE_PHOTO)
                     }
                 }

                 override fun lostCallback(result: MLAnalyzer.Result<MLFace?>) {
                     overlay!!.clear()
                 }

                 override fun completeCallback() {
                     overlay!!.clear()
                 }
             }).create()
         analyzer!!.setTransactor(transactor)
     } else {
         analyzer!!.setTransactor(object : MLTransactor<MLFace> {
             override fun destroy() {}
             override fun transactResult(result: MLAnalyzer.Result<MLFace>) {
                 val faceSparseArray = result.analyseList
                 var flag = 0
                 for (i in 0 until faceSparseArray.size()) {
                     val emotion = faceSparseArray.valueAt(i).emotions
                     if (emotion.smilingProbability > smilingPossibility) {
                         flag++
                     }
                 }
                 if (flag > faceSparseArray.size() * smilingRate && safeToTakePicture) {
                     safeToTakePicture = false
                     mHandler.sendEmptyMessage(TAKE_PHOTO)
                 }
             }
         })
     }
 }

Fotografía y almacenamiento:

private fun takePhoto() {
     mLensEngine!!.photograph(null,
         PhotographListener { bytes ->
             mHandler.sendEmptyMessage(STOP_PREVIEW)
             val bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
             saveBitmapToDisk(bitmap)
         })
 }

Creamos un motor visual para capturar transmissions dinámicas de video desde cámaras y envier las transmissions al analizador.

private fun createLensEngine() {
     val context: Context = this.applicationContext
     // Create LensEngine
     mLensEngine = LensEngine.Creator(context, analyzer).setLensType(lensType)
         .applyDisplayDimension(640, 480)
         .applyFps(25.0f)
         .enableAutomaticFocus(true)
         .create()
 }

Aplicación de permisos dinámicos,adjuntando el analizador y el código de creación del motor visual

override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
     setContentView(R.layout.activity_main)
     if (!allPermissionsGranted()) {
         runtimePermissions
     }
 }

 private val runtimePermissions: Unit
     get() {
         val allNeededPermissions: MutableList<String?> = ArrayList()
         for (permission in requiredPermissions) {
             if (!isPermissionGranted(this, permission)) {
                 allNeededPermissions.add(permission)
             }
         }
         if (!allNeededPermissions.isEmpty()) {
             ActivityCompat.requestPermissions(
                 this,
                 allNeededPermissions.toTypedArray(),
                 PERMISSION_REQUESTS
             )
         }
     }

 private fun allPermissionsGranted(): Boolean {
     for (permission in requiredPermissions) {
         if (!isPermissionGranted(this, permission)) {
             return false
         }
     }
     return true
 }

 private val requiredPermissions: Array<String?>
     get() = try {
         val info = this.packageManager
             .getPackageInfo(this.packageName, PackageManager.GET_PERMISSIONS)
         val ps = info.requestedPermissions
         if (ps != null && ps.size > 0) {
             ps
         } else {
             arrayOfNulls(0)
         }
     } catch (e: RuntimeException) {
         throw e
     } catch (e: Exception) {
         arrayOfNulls(0)
     }

 override fun onRequestPermissionsResult(
     requestCode: Int, permissions: Array<String>,
     grantResults: IntArray
 ) {
     super.onRequestPermissionsResult(requestCode, permissions, grantResults)
     if (requestCode != PERMISSION_REQUESTS) {
         return
     }
     var isNeedShowDiag = false
     for (i in permissions.indices) {
         if (permissions[i] == Manifest.permission.READ_EXTERNAL_STORAGE && grantResults[i] != PackageManager.PERMISSION_GRANTED
         ) {
             // If permissions aren't satisfied, show dialog.
             isNeedShowDiag = true
         }
     }
     if (isNeedShowDiag && !ActivityCompat.shouldShowRequestPermissionRationale(
             this,
             Manifest.permission.CALL_PHONE
         )
     ) {
         val dialog: AlertDialog = AlertDialog.Builder(this)
             .setMessage(getString(R.string.camera_permission_rationale))
             .setPositiveButton(
                 getString(R.string.settings)
             ) { dialog, which ->
                 val intent =
                     Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                 intent.data = Uri.parse("package:$packageName")
                 startActivityForResult(intent, 200)
                 startActivity(intent)
             }
             .setNegativeButton(
                 getString(R.string.cancel),
                 DialogInterface.OnClickListener { dialog, which -> finish() }).create()
         dialog.show()
     }
 }

결론
실험은 múltiples caras의sonrisa의captura의elefecto de la captura de múltiples caras에 관한 것이다.
Instantánea de una sola sonrisa:

Según la capacidad de detección de rostros,?quéfunctiones se pueden realizar?“Abre tu mente a nuevas ideas y características!Aquihay algunos consejos:

Agrega efectos decorativos interestantes identificando la ubicación de los rasgos faciales,como orejas,ojos,nariz,boca y cejas.

Identifica los contornos faciales y estira los contornos para generar retatos interest o desarrolla functiones de embellecimiento face paraáreas de contornos.

Desarrollar algunas functiones de control parent basadas en la identificación de la edad.

Desarrolle la función de comodidad ojos mirando la pantalla의 눈 검측기.

Implementa la detección de consores a través de comandos aleatorios(como sacudir la cabeza,parpadear y abrir la boca).

su edad y sexo의 기능에 ERTAS a los usuarios를 사용하는 것을 권장합니다.

Para obtener detalles sobre la guía de desarrollo,visita el-sitio web of icial del desarrollador de HUAWEI:
Link
O puedes visitarnos también en el foro de desarrolladores
Dev Forum