Bauen Sie ein Gesicht-Erkennung-app mit machine-learning-und Feuerstellung ML Kit

Mit der Veröffentlichung von Technologien wie TensorFlow und CloudVision, es ist immer leichter zu verwenden, machine learning (ML) in Ihre mobile apps, aber training machine-learning-Modelle immer noch erfordert eine erhebliche Menge an Zeit und Mühe.

Mit FB ML Kit, Google strebt maschinelles lernen leichter zugänglich, indem wir eine Reihe von vor-geschult sind, Modelle, die Sie verwenden können, in Ihre iOS-und Android-apps.

In diesem Artikel werde ich Ihnen zeigen, wie ML-Kit, fügen Sie leistungsfähige Maschine lernen Fähigkeiten, um Ihre apps, auch wenn Sie null machine-learning-wissen, oder haben einfach nicht die Zeit und Ressourcen erforderlich sind, zu trainieren, zu optimieren und zu implementieren Ihre eigenen ML-Modelle.

Konzentrieren wir uns auf ML Kit ist die Face-Detection-API, die Sie verwenden können, zu identifizieren Gesichter in Fotos, videos und live-streams. Bis Ende dieses Artikels haben Sie eine app erstellt haben, identifizieren können, Gesichter in einem Bild, und zeigen Sie Informationen über diese Gesichter, wie etwa, ob die person lächelt, oder hat Ihre Augen geschlossen.

Was ist die Face-Detection-API?

Diese API ist Teil der cross-Plattform Firebase ML Kit SDK, die eine Reihe von APIs für die gängigen mobilen use cases. Derzeit können Sie verwenden, ML-Kit zu erkennen, text, Wahrzeichen und Gesichter, scan-barcodes und label-Bilder, mit Google planen zum hinzufügen von mehr APIs in der Zukunft.

Sie können die Face-Detection-API zu identifizieren Gesichter in den visuellen Medien, und extrahieren Sie die Informationen über die position, Größe und Ausrichtung jedes Gesicht. Aber die Face-Detection-API wirklich beginnt, interessant zu werden, wenn Sie es verwenden, um zu analysieren, die folgenden:

  • Sehenswürdigkeiten. Dies sind die Punkte von Interesse innerhalb einer Fläche, wie das Rechte Auge oder das linke Ohr. Anstatt die Erkennung von Landmarken ersten und dann mit Ihnen als Referenzpunkte, um zu erkennen, das ganze Gesicht, ML-Kit erkennt Gesichter und Sehenswürdigkeiten separat.
    Die Klassifizierung. Dies ist, wo Sie analysieren, ob eine bestimmte Gesichts-Merkmal vorhanden ist. Derzeit ist die Face-Detection-API feststellen kann, ob der Rechte und linke Auge geschlossen oder geöffnet sind, und ob die person lächelt.

Sie können diese API verwenden, zu verbessern, eine Breite Palette von bereits vorhandenen Funktionen, zum Beispiel könnten Sie verwenden Gesichtserkennung, um Benutzern zu helfen zuschneiden Ihr Profil-Bild, tag oder Freunde und Familie in Ihren Fotos. Sie können diese API auch verwenden, um design, ganz neue features, wie zum Beispiel die Hände-freien Kontrollen, die einen neuen Weg der Interaktion mit Ihrem Handy-Spiel, oder bieten die Grundlage für die Zugänglichkeit Dienste.

Just bewusst sein, dass diese API bietet face – detection und face recognition, so kann es Ihnen sagen, die genaue Koordinaten der person, die Links und rechts aus den Ohren, aber nicht , wer diese person ist.

Schließen Sie Ihr Projekt auf FB

Jetzt wissen wir, was die Gesichtserkennung ist, erstellen wir eine Anwendung mit dieser API!

Erstellen Sie ein neues Projekt mit den Einstellungen deiner Wahl, und dann verbinden Sie dieses Projekt auf den FB-Servern.

Finden Sie detaillierte Anweisungen, wie dies zu tun, Extrahieren von text aus Bildern mit Google ‚ s Machine-Learning-SDK.

Herunterladen Google vorab geschult, machine-learning-Modelle

Standardmäßig ist die app nur herunterladen, das ML-Kit Modelle, wie und Wann Sie verpflichtet sind, herunterzuladen anstatt Sie während der Installation. Diese Verzögerung hätte einen negativen Einfluss auf die user experience, denn es gibt keine Garantie, das Gerät wird über einen starken, zuverlässigen Internet-Verbindung die erste Zeit, die benötigt wird eine bestimmte ML-Modell.

Sie können anweisen, Ihre Anwendung zu laden eine oder mehrere ML-Modelle zu installieren-Zeit, indem Sie einige Metadaten zu Ihrem Manifest. Ich habe zwar das Manifest offen, ich bin auch durch die WRITE_EXTERNAL_STORAGE-und KAMERA-Berechtigungen, die wir verwenden werden später in diesem tutorial.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.jessicathornsby.facerecog"> //Hinzufügen von SPEICHER und KAMERA-Zugriffsrechte// <uses-permission android:name="android.die Genehmigung.WRITE_EXTERNAL_STORAGE" /> <uses-permission android:name="android.die Genehmigung.KAMERA" /> <Anwendung
android:allowBackup="true"
android:icon="@mipmap - /ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap - /ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/AppTheme"> <Aktivität android:name=".MainActivity">
<intent-filter> <action android:name="android.Absicht.Aktion.MAIN" /> <Kategorie android:name="android.Absicht.Kategorie.LAUNCHER" />
</intent-filter>
</activity> //Laden Sie die Face-detection-Modell bei der Installation aus-Zeit// <meta-Daten
android:name="com.google.FB.ml.vision.ABHÄNGIGKEITEN" android:value="Gesicht" />

Erstellen das layout

Als Nächstes brauchen wir die folgenden UI-Elemente:

  • Eine Bildansicht. Zunächst, es erscheint ein Platzhalter, aber es wird aktualisiert, sobald der Benutzer wählt ein Bild aus Ihrer Galerie, oder nimmt ein Foto mit Ihrem Gerät eingebauten Kamera.
  • Eine TextView. Sobald die Face-Detection-API analysiert das Bild, ich werde Anzeige Ihre Erkenntnisse in ein TextView.
  • Eine ScrollView. Da es keine Garantie gibt das Bild und die extrahierte information wird ordentlich passen auf dem Bildschirm, und ich bin Platzierung die TextView und die Bildansicht innerhalb einer ScrollView.

Öffnen activity_main.xml und fügen Sie die folgenden:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="20dp"
tools:context=".MainActivity"> <ScrollView
android:layout_width="match_parent"
android:layout_height="match_parent"> <LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical"> <Bildansicht
android:id="@+id/Bildansicht"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:adjustViewBounds="true" android:src="@drawable/ic_placeholder" /> <TextView
android:id="@+id/textView"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:textAppearance="@style/TextAppearance.AppCompat.Medium"
android:layout_marginTop="20dp"/> </LinearLayout> </ScrollView> </RelativeLayout>

Nächste, öffnen Sie Ihr Projekt strings.xml Datei, und definieren Sie die Zeichenfolgen, die wir in diesem Projekt.

<resources> <string name="app_name">FaceRecog</string> <string name="action_gallery">Galerie</string> <string name="storage_denied">Diese app benötigt Zugriff auf Dateien auf Ihrem Gerät.</string> <string name="action_camera">Kamera</string> <string name="camera_denied">Diese app benötigt Zugriff auf die Kamera.</string> <string name="error">keinen Zugriff ML Kit</string>
</resources>

Wir müssen auch schaffen, ein „ic_placeholder“ Ressource:

  • Wählen Sie „Datei“ > “ Neu “ > „Bild “ Asset“ aus dem Android-Studio-Symbolleiste.
  • Öffnen Sie das Symbol „Typ“ dropdown und wählen Sie „Aktionsleiste und Tab Icons.“
  • Stellen Sie sicher, dass die „Clip Art“ radio-button ausgewählt ist.
  • Geben Sie den „Clip Art“ – Taste ein klicken.
  • Wählen Sie das Bild, das Sie verwenden möchten, als Ihre Platzhalter; ich bin mit „Hinzufügen Fotos“.
  • Klicken Sie auf „OK“.
  • In der „Name“ – Feld, geben Sie „ic_placeholder.“

  • Klicken Sie Auf „Weiter“. Lesen Sie die Informationen, und wenn Sie glücklich sind, um fortzufahren, klicken Sie dann auf „Fertig stellen“.

Die Aktion anpassen, bar

Als Nächstes werde ich zwei action bar icons, lasse dem Benutzer die Wahl zwischen wählen Sie ein Bild aus Ihrer Galerie oder nehmen ein Foto mit Ihrem Gerät die Kamera.

Falls Ihr Projekt dort nicht bereits enthalten, die eine „Menü“ – Verzeichnis, dann:

  • Control-klicken Sie auf Ihr Projekt „res“ – Verzeichnis und wählen Sie „Neu“ > “ Android-Ressource-Verzeichnis.“
  • Öffnen Sie die „Ressource-Typ“ dropdown und wählen Sie „Menü“.
  • Die „Verzeichnis-Namen“ update auf „Menü“ automatisch, aber wenn es nicht funktioniert dann müssen Sie benennen Sie Sie manuell.
  • Klicken Sie auf „OK“.

Als Nächstes erstellen Sie die Menü-Ressource-Datei:

  • Control-Klick auf das “ Projekt „Menü“ – Verzeichnis und wählen Sie „Neu“ > “ Menü-Ressource-Datei.“
  • Nennen Sie diese Datei „my_menu.“
  • Klicken Sie auf „OK“.
  • Öffnen Sie die „my_menu.xml“ Datei, und fügen Sie die folgenden:
<?xml version="1.0" encoding="utf-8"?> <menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" > <item
android:id="@+id/action_gallery"
android:orderInCategory="101"
android:title="@string/action_gallery"
android:icon="@drawable/ic_gallery"
app:showAsAction="ifRoom"/> <item
android:id="@+id/action_camera"
android:orderInCategory="102"
android:title="@string/action_camera"
android:icon="@drawable/ic_camera"
app:showAsAction="ifRoom"/> </menu>

Erstellen Sie als Nächstes die „ic_gallery“ und „ic_camera“ drawables:

  • Wählen Sie „Datei“ > “ Neu “ > “ Image-Asset.“
  • Legen Sie die „Symbol Typ“ dropdown-Liste „Aktionsleiste und Tab Icons.“
  • Klicken Sie auf die „Clip Art“ – Taste.
  • Wählen Sie ein drawable. Ich verwende „Bild“ für mein „ic_gallery“ – Symbol.
  • Klicken Sie auf „OK“.
  • Um sicherzustellen, dass dieses Symbol gut sichtbar in der Menüleiste, öffnen Sie die „Thema“ – dropdown und wählen Sie „HOLO_DARK.“
  • Bezeichnung dieses Symbol „ic_gallery.“
  • „Klicken Sie auf „Weiter“, gefolgt von „Fertig stellen“.

Wiederholen Sie diesen Vorgang zum erstellen einer „ic_camera“ Ressource; ich verwende die „Foto-Kamera“ drawable.

Handhabung Erlaubnis Anfragen ein und klicken Sie auf Veranstaltungen

Ich werde alle Aufgaben, die nicht direkt mit der Gesichtserkennung in einem separaten BaseActivity Klasse, einschließlich der Instanziierung des Menüs, Handhabung der action bar klicken Sie auf Ereignisse, und den Zugang zu Speicher des Geräts und der Kamera.

  • Wählen Sie „Datei“ > “ Neu “ > „Java class“ von Android Studio-Symbolleiste.
  • Name dieser Klasse „BaseActivity.“
  • Klicken Sie auf „OK“.
  • Öffnen BaseActivity, und fügen Sie dann die folgenden:
importieren android.app.Tätigkeit;
importieren android.os.Bündel;
importieren android.Inhalt.DialogInterface;
importieren android.Inhalt.Vorsatz;
importieren android.Inhalt.pm.PackageManager;
importieren android.Manifest;
importieren android.Anbieter.MediaStore;
importieren android.Blick.Menü;
importieren android.Blick.MenuItem;
importieren android.Anbieter.Einstellungen;
importieren android.Unterstützung.Anmerkung.Null;
importieren android.Unterstützung.Anmerkung.Null-Werte zulässt; importieren android.Unterstützung.v4.app.ActivityCompat;
importieren android.Unterstützung.v7.app.ActionBar;
importieren android.Unterstützung.v7.app.AlertDialog;
importieren android.Unterstützung.v7.app.AppCompatActivity;
importieren android.Unterstützung.v4.Inhalt.FileProvider; importieren android.net.Uri; import java.io.Datei; public class BaseActivity erstreckt AppCompatActivity { public static final int WRITE_STORAGE = 100; public static final int KAMERA = 102; public static final int SELECT_PHOTO = 103; public static final int TAKE_PHOTO = 104; public static final String ACTION_BAR_TITLE = "action_bar_title"; öffentliche Datei photoFile; @Override protected void onCreate(@Nullable-Bundle savedInstanceState) {
super.onCreate(savedInstanceState); ActionBar actionBar = getSupportActionBar(); wenn (actionBar != null) {
actionBar.setDisplayHomeAsUpEnabled(true);
actionBar.setTitle(getIntent().getStringExtra(ACTION_BAR_TITLE));
}
} @Override public boolean onCreateOptionsMenu(Menu Menu) { getMenuInflater().inflate(R. menu.my_menu-Menü); return true;
} @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R. id.action_camera:
checkPermission(KAMERA);
break; case R. id.action_gallery:
checkPermission(WRITE_STORAGE);
break;
} return super.onOptionsItemSelected(item);
} @Override public void onRequestPermissionsResult(int requestCode, @Null String[] Berechtigungen, @Null int[] grantResults) { super.onRequestPermissionsResult(requestCode, Berechtigungen, grantResults); switch (requestCode) { Fall KAMERA: wenn (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
launchCamera(); } else { requestPermission(requestCode, R. string.camera_denied);
}
break; Fall WRITE_STORAGE: wenn (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
selectPhoto(); } else { requestPermission(requestCode, R. string.storage_denied);
}
break;
}
} public static void requestPermission(Letzte Aktivität, final int requestCode, int message) { AlertDialog.Builder alert = new AlertDialog.Generator(Aktivität);
alert.setMessage(message); alert.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
@Override public void onClick(DialogInterface dialogInterface, int i) {
dialogInterface.dismiss(); Intent intent = new Intent ("Einstellungen".ACTION_APPLICATION_DETAILS_SETTINGS); Absicht.setData(Uri.parse("package:" + Aktivität.getPackageName())); Aktivität.startActivityForResult(intent, requestCode);
}
}); alert.setNegativeButton(android.R.string.Abbrechen", new DialogInterface.OnClickListener() {
@Override public void onClick(DialogInterface dialogInterface, int i) {
dialogInterface.dismiss();
}
});
alert.setCancelable(false);
alert.show();
} public void checkPermission(int requestCode) { switch (requestCode) { Fall KAMERA: int hasCameraPermission = ActivityCompat.checkSelfPermission(dies zu Manifestieren.die Genehmigung.KAMERA); wenn (hasCameraPermission == PackageManager.PERMISSION_GRANTED) {
launchCamera(); } else { ActivityCompat.requestPermissions(this, new String[]{Manifest.die Genehmigung.KAMERA}, requestCode);
}
break; Fall WRITE_STORAGE: int hasWriteStoragePermission = ActivityCompat.checkSelfPermission(dies zu Manifestieren.die Genehmigung.WRITE_EXTERNAL_STORAGE); wenn (hasWriteStoragePermission == PackageManager.PERMISSION_GRANTED) {
selectPhoto(); } else { ActivityCompat.requestPermissions(this, new String[]{Manifest.die Genehmigung.WRITE_EXTERNAL_STORAGE}, requestCode);
}
break;
}
} private void selectPhoto() { photoFile = MyHelper.createTempFile(photoFile); Intent intent = new Intent(Intent.ACTION_PICK, MediaStore.Bilder.Media.EXTERNAL_CONTENT_URI); startActivityForResult(Vorsatz, SELECT_PHOTO);
} private void launchCamera() { photoFile = MyHelper.createTempFile(photoFile); Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); Uri Foto = FileProvider.getUriForFile(getPackageName() + ".der Anbieter", photoFile); Absicht.putExtra(MediaStore.EXTRA_OUTPUT, Foto); startActivityForResult(Vorsatz, TAKE_PHOTO);
}
}

Erstellen Sie eine Helper-Klasse: Größe der Bilder

Als Nächstes erstellen Sie eine „MyHelper“ Klasse, wo wir sind wir werden die Größe des Benutzer-ausgewählten Bild:

importieren android.Grafik.Bitmap;
importieren android.Grafik.BitmapFactory;
importieren android.Inhalt.Kontext;
importieren android.Datenbank.Cursor;
importieren android.os.Umwelt;
importieren android.- widget.Bildansicht;
importieren android.Anbieter.MediaStore;
importieren android.net.Uri; importieren statische android.Grafik.BitmapFactory.decodeFile;
importieren statische android.Grafik.BitmapFactory.decodeStream; import java.io.Datei;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException; public class MyHelper { public static String getPath(Context context, Uri uri) { String Pfad = ""; String[] projection = {MediaStore.Bilder.Media.DATEN}; Cursor Cursor = Kontext.getContentResolver().query(uri, projection, null, null, null); int column_index; if (cursor != null) { column_index = cursor.getColumnIndexOrThrow(MediaStore.Bilder.Media.DATEN);
cursor.moveToFirst(); Pfad = cursor.getString(column_index);
cursor.close();
} return path;
} public static File createTempFile(File Datei) { File directory = new File(Environment.getExternalStorageDirectory().getPath() + "/com.jessicathornsby.myapplication"); if (!- Verzeichnis.exists() || !- Verzeichnis.isDirectory()) { - Verzeichnis.mkdirs();
} if (Datei == null) { Datei = new File(directory, "orig.jpg");
} return Datei;
} public static Bitmap resizePhoto(File imageFile, Context context, Uri uri, Bildansicht anzeigen) { BitmapFactory.Optionen newOptions = new BitmapFactory.Optionen(); try { decodeStream(Kontext.getContentResolver().openInputStream(uri), null, newOptions); int photoHeight = newOptions.outHeight; int photoWidth = newOptions.outWidth; newOptions.inSampleSize = Math.min(photoWidth / anzeigen.getWidth(), photoHeight / anzeigen.getHeight()); zurück compressPhoto(imageFile, BitmapFactory.decodeStream(Kontext.getContentResolver().openInputStream(uri), null, newOptions)); } catch (FileNotFoundException Ausnahme) {
Ausnahme.printStackTrace(); return null;
}
} public static Bitmap resizePhoto(File imageFile, String path, Bildansicht anzeigen) { BitmapFactory.Optionen Optionen = new BitmapFactory.Optionen(); decodeFile(path, options); int photoHeight = Optionen.outHeight; int photoWidth = Optionen.outWidth; Optionen.inSampleSize = Math.min(photoWidth / anzeigen.getWidth(), photoHeight / anzeigen.getHeight()); zurück compressPhoto(imageFile, BitmapFactory.decodeFile(path, options));
} private static Bitmap compressPhoto(photoFile Datei, Bitmap bitmap) { try { FileOutputStream fOutput = new FileOutputStream(photoFile); bitmap.komprimieren(Bitmap.CompressFormat.JPEG, 70, fOutput);
fOutput.close(); } catch (IOException exception) {
Ausnahme.printStackTrace();
} return bitmap;
}
}

Freigeben von Dateien mit FileProvider

Ich bin auch ein FileProvider, die es erlauben, unser Projekt zu teilen von Dateien mit anderen Anwendungen.

Wenn Ihr Projekt nicht enthalten eine „xml“ – Verzeichnis, dann:

  • Control-klicken Sie auf Ihr Projekt „res“ – Verzeichnis und wählen Sie „Neu“ > “ Android-Ressource-Verzeichnis.“
  • Öffnen Sie die „Ressource-Typ“ dropdown und wählen Sie „xml.“
  • Die Verzeichnis-Namen ändern sollte „auf “ xml“ automatisch, aber wenn es nicht funktioniert dann müssen Sie es manuell ändern.
  • Klicken Sie auf „OK“.

Als Nächstes benötigen wir eine XML-Datei erstellen mit dem Pfad(s) unserer FileProvider verwenden:

  • Control-Klick auf das „XML“ – Verzeichnis und wählen Sie „Neu“ > “ XML resource-Datei.“
  • Geben Sie dieser Datei den Namen „provider“ und klicken Sie dann auf „OK“.
  • Öffnen Sie Ihre neue provider.xml Datei und fügen Sie die folgenden:
<?xml version="1.0" encoding="utf-8"?>
<Pfade> //Unsere app auch in die öffentlichen externen Speicher// <external-path name="external_files" path="."/>
</paths>

Sie müssen dann registrieren Sie diese FileProvider in Ihrem Manifest:

<meta-Daten
android:name="com.google.FB.ml.vision.ABHÄNGIGKEITEN" android:value="Gesicht" /> //Fügen Sie den folgenden block// <provider
android:name="android.Unterstützung.v4.Inhalt.FileProvider" //Android verwendet "Behörden" zu unterscheiden zwischen den Anbietern// android:authorities="${applicationId}.Anbieter" //Wenn Ihr Anbieter nicht müssen öffentlich sein, dann sollten Sie sich immer setzen Sie diese auf "false"// android:exportiert="false"
android:grantUriPermissions="true">
<meta-Daten
android:name="android.Unterstützung.FILE_PROVIDER_PATHS"
android:resource="@xml/provider"/>
</provider> </application> </manifest>

Die Konfiguration der Gesichtserkennung,

Der einfachste Weg zur Durchführung der Gesichtserkennung, ist die Verwendung des präsenzmelders Standard-Einstellungen. Aber für beste Ergebnisse sollten Sie passen Sie den Detektor so, es stellt nur die Informationen, die Ihre app benötigt, so können diese oft beschleunigen die face-detection-Prozess.

Bearbeiten Sie die Gesichtserkennung, die Standard-Einstellungen, müssen Sie eine FirebaseVisionFaceDetectorOptions Beispiel:

 FirebaseVisionFaceDetectorOptions Optionen = new FirebaseVisionFaceDetectorOptions.Builder()

Sie können dann alle folgenden änderungen an den Detektor Standard-Einstellungen:

Schnell oder genau?

Um die best mögliche user-experience, die Sie benötigen, um ein Gleichgewicht zwischen Geschwindigkeit und Genauigkeit.

Es gibt mehrere Möglichkeiten, zwicken, balance, aber einer der wichtigsten Schritte ist die Konfiguration der Melder zu Gunsten entweder der Geschwindigkeit oder der Genauigkeit. In unserer app, ich werde mit schnell-Modus, wo das Gesicht-Detektor verwendet Optimierungen und Verknüpfungen, die machen Gesichtserkennung schneller, aber Sie können einen negativen Einfluss auf die API der Genauigkeit.

.setModeType(FirebaseVisionFaceDetectorOptions.ACCURATE_MODE)
.setModeType(FirebaseVisionFaceDetectorOptions.FAST_MODE)

Wenn Sie nicht angeben, ein Modus, Gesichtserkennung verwenden FAST_MODE standardmäßig.

Klassifikationen: Ist die person lächeln?

Klassifizieren Sie erkannten Gesichter in Kategorien wie „linkes Auge öffnen“ oder „lächeln.“ Ich werde mit Klassifizierungen, um zu bestimmen, ob eine person hat die Augen offen, und ob Sie lächeln.

.setClassificationType(FirebaseVisionFaceDetectorOptions.ALL_CLASSIFICATIONS)
.setClassificationType(FirebaseVisionFaceDetectorOptions.NO_CLASSIFICATIONS)

Der Standardwert ist NO_CLASSIFICATIONS.

Landmark detection

Da die Gesichtserkennung und das Wahrzeichen Erkennung unabhängig auftreten, Sie können Umschalten, landmark detection-und ausschalten.

.setLandmarkType(FirebaseVisionFaceDetectorOptions.ALL_LANDMARKS)
.setLandmarkType(FirebaseVisionFaceDetectorOptions.NO_LANDMARKS)

Wenn Sie möchten, führen Gesichts-Klassifikation, so müssen Sie explizit aktivieren Wahrzeichen Erkennung, so werden wir mit ALL_LANDMARKS in unserer app.

Konturen erkennen

Die Face-Detection-API können auch Gesichts-Konturen, mit dem Sie eine genaue Karte von dem erkannten Gesicht, das von unschätzbarem Wert sein kann für die Erstellung von augmented-reality-apps, wie zum Beispiel Programme, hinzufügen, Objekte, Kreaturen oder Snapchat-Stil Filter auf den Benutzer der Kamera-feed.

.setContourMode(FirebaseVisionFaceDetectorOptions.ALL_CONTOURS)
.setContourMode(FirebaseVisionFaceDetectorOptions.NO_CONTOURS)

Wenn Sie nicht angeben, eine Kontur-Modus, Gesicht-Erkennung verwenden NO_CONTOURS standardmäßig.

Mindestens Fläche Größe

Dies ist die minimale Größe der Flächen, die API identifizieren sollte, ausgedrückt als ein Verhältnis der Breite des erkannten Gesichts, bezogen auf die Breite des Bildes. Zum Beispiel, wenn Sie den angegebenen a-Wert von 0,1 dann Ihre app nicht erkennen, keine Gesichter, die kleiner als etwa 10% der Breite des Bildes.

Ihre app ist setMinFaceSize auswirken wird, dass alle wichtigen Geschwindigkeit/Genauigkeit Gleichgewicht. Verringern Sie den Wert und die API wird mehr erkennen von Gesichtern, aber kann länger abgeschlossen, face-detection-Operationen; erhöhen Sie den Wert, und Operationen werden schneller ausgeführt, aber Ihre Anwendung kann fehlschlagen, um zu identifizieren, kleinere Gesichter.

.setMinFaceSize(0,15 f)

Wenn Sie keinen Wert angeben, dann wird Ihre app verwenden, 0.1 f.

Face-tracking

Face-tracking weist eine ID zu einem Gesicht, so kann es verfolgt werden, die über mehrere aufeinanderfolgende Bilder oder video-frames. Während dies auch klingen mag wie der Gesichtserkennung, die API ist immer noch nichts von der Identität der person, ist, technisch gesehen, immer noch als die Gesichtserkennung.

Es wird empfohlen, dass Sie deaktivieren tracking, wenn Ihre app verarbeitet nicht oder nicht aufeinander folgende Bilder.

.setTrackingEnabled(true)
.setTrackingEnabled(false)

Der Standardwert ist „false“.

Führen Sie die Gesichtserkennung

Sobald Sie konfiguriert haben, die Gesichtserkennung, müssen Sie konvertieren Sie das Bild in einem format, das von dem Detektor verstehen können.

ML Kit kann nur Bilder Bearbeiten wenn Sie in der FirebaseVisionImage-format. Da wir mit Bitmaps arbeiten, wir führen diese Umwandlung durch Aufruf der fromBitmap() die utility-Methode, und übergeben Sie die bitmap:

 FirebaseVisionImage Bild = FirebaseVisionImage.fromBitmap(myBitmap);

Als Nächstes benötigen wir eine Instanz zu schaffen FirebaseVisionFaceDetector, der ein Detektor-Klasse, sucht alle Instanzen der FirebaseVisionFace in dem mitgelieferten Bild.

 FirebaseVisionFaceDetector Detektor = FirebaseVision.getInstance().getVisionFaceDetector(Optionen);

Wir können dann prüfen, die FirebaseVisionImage Objekt für Flächen, die von der übergabe an die detectInImage Methode und Durchführung die folgende Rückrufe:

  • onSuccess. Wenn ein oder mehrere Gesichter erkannt werden, dann eine List<FirebaseVisionFace> – Instanz übergeben werden, um die OnSuccessListener. Jeder FirebaseVisionFace-Objekt repräsentiert ein Gesicht erkannt wurde in das Bild.
  • onFailure. Die addOnFailureListener ist, wo wir behandeln alle Fehler.

Dies gibt uns die folgenden:

Detektor.detectInImage(Bild).addOnSuccessListener(neu
OnSuccessListener<List<FirebaseVisionFace>>() {
@Override //Aufgabe erfolgreich abgeschlossen// public void onSuccess(List<FirebaseVisionFace> Gesichter) {
//Do something//
} }).addOnFailureListener(neue OnFailureListener() {
@Override //Aufgabe gescheitert, mit einer Ausnahme// public void onFailure (@Nicht-null-Ausnahme Ausnahme) {
//Do something//
}
}); }

Die Analyse FirebaseVisionFace Objekte

Ich bin mit der Klassifizierung zu erkennen, ob jemand hat die Augen offen, und ob Sie lächeln. Klassifikation, ausgedrückt als Wahrscheinlichkeit, Wert zwischen 0.0 und 1.0, so dass, wenn die API zurückkehrt 0,7 Rechtssicherheit für die „lächelnden“ – Einstufung, dann ist es sehr wahrscheinlich, dass die person auf dem Foto lächelt.

Für jede Klassifizierung, die Sie benötigen, um eine minimale Schwelle, die mit Ihrer app zu akzeptieren. Im folgenden Schnipsel, bin ich abrufen, das lächeln Wahrscheinlichkeit Wert:

 für (FirebaseVisionFace Gesicht : Gesichter) { if (face.getSmilingProbability() != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) { smilingProbability = Gesicht.getSmilingProbability(); }

Sobald Sie diesen Wert haben, werden Sie brauchen, um zu überprüfen, dass es erfüllt Ihre app-Schwelle:

 Ergebnis.append("Lächeln: "); wenn (smilingProbability > 0.5) { Ergebnis.append("ja \nProbability:" + smilingProbability); } else {
Ergebnis.append("Keine"); }

Ich werde wiederholen Sie diesen Vorgang für das linke und Rechte Auge Klassifikationen.

Hier ist meine ausgefüllte MainActivity:

importieren android.Grafik.Bitmap;
importieren android.os.Bündel;
importieren android.- widget.Bildansicht;
importieren android.Inhalt.Vorsatz;
importieren android.- widget.TextView;
importieren android.net.Uri; importieren android.Unterstützung.Anmerkung.Null;
importieren android.- widget.Toast; import com.google.FB.ml.vision.FirebaseVision;
import com.google.FB.ml.vision.Gesicht.FirebaseVisionFace;
import com.google.FB.ml.vision.Gesicht.FirebaseVisionFaceDetector;
import com.google.FB.ml.vision.Gesicht.FirebaseVisionFaceDetectorOptions;
import com.google.FB.ml.vision.common.FirebaseVisionImage;
import com.google.android.gms.Aufgaben.OnFailureListener;
import com.google.android.gms.Aufgaben.OnSuccessListener; import java.util.Liste; public class MainActivity extends BaseActivity { private Bildansicht myImageView; private TextView myTextView; private Bitmap myBitmap; @Override protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R. layout.activity_main); myTextView = findViewById(R. id.textView); myImageView = findViewById(R. id.Bildansicht); } @Override protected void onActivityResult(int requestCode, int "resultCode", Intent data) { super.onActivityResult(requestCode, "resultCode", data); wenn ("resultCode" = = RESULT_OK) { switch (requestCode) { Fall WRITE_STORAGE:
checkPermission(requestCode); Fall KAMERA:
checkPermission(requestCode);
break; Fall SELECT_PHOTO: Uri dataUri = Daten.getData(); String Pfad = MyHelper.getPath(dataUri); if (Pfad == null) { myBitmap = MyHelper.resizePhoto(photoFile, diese, dataUri, myImageView); } else { myBitmap = MyHelper.resizePhoto(photoFile, Pfad, myImageView);
} wenn (myBitmap != null) {
myTextView.setText(null);
myImageView.setImageBitmap(myBitmap);
runFaceDetector(myBitmap);
}
break; Fall TAKE_PHOTO: myBitmap = MyHelper.resizePhoto(photoFile, photoFile.getPath(), myImageView); wenn (myBitmap != null) {
myTextView.setText(null);
myImageView.setImageBitmap(myBitmap);
runFaceDetector(myBitmap);
}
break;
}
}
} private void runFaceDetector(Bitmap bitmap) { //Erstellen Sie eine FirebaseVisionFaceDetectorOptions-Objekt// FirebaseVisionFaceDetectorOptions Optionen = new FirebaseVisionFaceDetectorOptions.Builder() //Stellen Sie den Modus-Typ; ich bin mit FAST_MODE// .setModeType(FirebaseVisionFaceDetectorOptions.FAST_MODE) //Ausführen zusätzliche Klassifikatoren für die Charakterisierung von Gesichtszügen// .setClassificationType(FirebaseVisionFaceDetectorOptions.ALL_CLASSIFICATIONS) //Erkennen, alle Gesichts-Sehenswürdigkeiten// .setLandmarkType(FirebaseVisionFaceDetectorOptions.ALL_LANDMARKS) //Die kleinste gewünschte Fläche Größe// .setMinFaceSize(0.1 f) //Deaktivieren der Gesichtsverfolgung// .setTrackingEnabled(false)
.build(); FirebaseVisionImage Bild = FirebaseVisionImage.fromBitmap(myBitmap); FirebaseVisionFaceDetector Detektor = FirebaseVision.getInstance().getVisionFaceDetector(Optionen); Detektor.detectInImage(Bild).addOnSuccessListener(neue OnSuccessListener<List<FirebaseVisionFace>>() {
@Override public void onSuccess(List<FirebaseVisionFace> Gesichter) {
myTextView.setText(runFaceRecog(Gesichter));
} }).addOnFailureListener(neue OnFailureListener() {
@Override public void onFailure (@Nicht-null-Ausnahme Ausnahme) {
Toast.makeText(MainActivity.diese, "Ausnahme", Toast.LENGTH_LONG).show();
}
});
} private String runFaceRecog(List<FirebaseVisionFace> Gesichter) { StringBuilder Ergebnis = new StringBuilder(); float smilingProbability = 0; float rightEyeOpenProbability = 0; float leftEyeOpenProbability = 0; für (FirebaseVisionFace Gesicht : Gesichter) { //Abrufen der Wahrscheinlichkeit, dass das Gesicht lächelt// if (face.getSmilingProbability() != //Prüfen, ob die Eigenschaft wurde nicht un-Computertomographie// FirebaseVisionFace.UNCOMPUTED_PROBABILITY) { smilingProbability = Gesicht.getSmilingProbability();
} //Abrufen der Wahrscheinlichkeit, dass das Rechte Auge offen ist// if (face.getRightEyeOpenProbability() != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) { rightEyeOpenProbability = Gesicht.getRightEyeOpenProbability ();
} //Abrufen der Wahrscheinlichkeit, dass das linke Auge geöffnet ist// if (face.getLeftEyeOpenProbability() != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) { leftEyeOpenProbability = Gesicht.getLeftEyeOpenProbability();
} //Print "Lachen:" zu den TextView// Ergebnis.append("Lächeln: "); //Wenn die Wahrscheinlichkeit von 0,5 oder höher...// wenn (smilingProbability > 0.5) { //...print die folgenden// Ergebnis.append("ja \nProbability:" + smilingProbability); //Wenn die Wahrscheinlichkeit liegt bei 0,4 oder niedriger...// } else { //...print die folgenden// Ergebnis.append("Keine");
} Ergebnis.append("\n\nRight Auge: "); //Überprüfen, ob das Rechte Auge öffnen und drucken der Ergebnisse// wenn (rightEyeOpenProbability > 0.5) { Ergebnis.append("Open \nProbability:" + rightEyeOpenProbability); } else {
Ergebnis.append("Schließen");
} Ergebnis.append("\n\nLeft Auge: "); //Prüfen, ob das linke Auge ist offen und die Ergebnisse gedruckt werden// wenn (leftEyeOpenProbability > 0.5) { Ergebnis.append("Open \nProbability:" + leftEyeOpenProbability); } else {
Ergebnis.append("Schließen");
}
Ergebnis.append("\n\n");
} Ergebnis zurückgeben.toString();
} }

Testen des Projekts

Stellen Sie Ihre app auf die Probe, indem Sie es auf Ihrem Android-Gerät, und dann wählen Sie entweder ein Bild aus Ihrer Galerie, oder nehmen Sie ein neues Foto.

Sobald Sie geliefert haben, ein Bild, der Detektor sollte laufen automatisch und zeigt die Ergebnisse an.

ML Kit

Sie können auch laden Sie das fertige Projekt von GitHub.

Zusammenfassung

In diesem Artikel, wir verwendet, ML-Kit zur Erkennung von Gesichtern in Fotos, und dann sammeln Sie Informationen über jene Flächen, einschließlich der Frage, ob die person lächelt, oder hatten Ihre Augen offen.

Google haben bereits mehr APIs geplant ML Kit, aber was ist machine-learning-Themen-APIs würden Sie gerne in zukünftigen Versionen? Lassen Sie uns wissen in den Kommentaren unten!

Ersten Kommentar schreiben

Antworten

Deine E-Mail-Adresse wird nicht veröffentlicht.


*