Faça um aplicativo de rastreamento ocular e detecção de rosto como um novato

Pradyuman Dixit Blocked Desbloquear Seguir Seguindo 9 de janeiro

Nós todos sabemos, quão legal um aplicativo android parece, quando ele pode detectar o nosso rosto ou faixa, se nossos olhos estão fechados ou abertos. Torna-se muito mais legal quando o aplicativo pode até mesmo detectar se estamos sorrindo, lendo no telefone ou não olhando para ele.

Bem…

Eu acredito … o que quer que me apele, simplesmente me faz construí-lo!

Desculpe, tentei um trocadilho “O Cavaleiro das Trevas” 🙂

Por isso, façamos um aplicativo de rastreamento de olhos e detecção de rosto do Android usando a API do Google Vision.

Do Google:

O Cloud Vision API permite que os desenvolvedores entendam o conteúdo de uma imagem encapsulando poderosos modelos de aprendizado de máquina em uma API REST fácil de usar. Ele rapidamente classifica as imagens em milhares de categorias (como “veleiro”), detecta objetos e faces individuais dentro de imagens e lê palavras impressas contidas nas imagens. Você pode criar metadados em seu catálogo de imagens, moderar conteúdo ofensivo ou ativar novos cenários de marketing por meio da análise de sentimento de imagem.

Aqui estaremos fazendo um aplicativo para Android que pode rastrear nosso rosto e detectar se nossos olhos estão fechados ou abertos.

olho da trilha

Soa legal? Não é muito difícil mesmo.

Então, vamos mergulhar na compreensão de como isso funcionaria em um fluxograma simples.

Nosso aplicativo android ? Usa Câmera ? Detecta rosto ? Inicia alguma operação ? Verifica se os olhos do espectador estão abertos ? Continua a operação ? Se os olhos estiverem fechados ? Pare a operação.

Esta é a ideia básica para o nosso aplicativo Android. Para fins de aprendizado, faremos isso em nosso aplicativo, mas recursos muito mais avançados podem ser adicionados usando a API do Google Vision.

A operação que estaríamos realizando em nosso aplicativo é reproduzir um vídeo simples. Bem, eu escolhi um vídeo da PIXAR Animation .

Você pode encontrar o código-fonte completo do aplicativo aqui.

Inicie um novo projeto Android no seu IDE, como o Android Studio ou qualquer outro.

Vá para o arquivo de manifesto e adicione a seguinte permissão, pois para este aplicativo, precisamos da permissão para usar a câmera frontal do dispositivo.

 <uses-permission android: name = "android.permission.CAMERA" /> 

Também precisamos importar a API do Google Vision em nosso aplicativo para Android. Por isso, vá para o Build Gradle for app, principalmente escrito como build.gradle (Module: app) .

Você verá um arquivo com texto semelhante a este:

 aplicar plugin: 'com.android.application' 

android {
compileSdkVersion 28
defaultConfig {
applicationId "com.pd.trackeye"
minSdkVersion 15
targetSdkVersion 28
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
lançamento {
minifyEnabled false
proguardFiles getDefaultProguardFile ('proguard-android.txt'), 'proguard-rules.pro'
}
}
}

dependências {
implementação fileTree (dir: 'libs', include: ['* .jar'])
implementação 'com.android.support:appcompat-v7:28.0.0'
implementação 'com.android.support.constraint: constraint-layout: 1.1.3'
testImplementation 'junit: junit: 4.12'
androidTestImplementation 'com.android.support.test: runner: 1.0.2'
androidTestImplementation 'com.android.support.test.espresso: espresso-core: 3.0.2'
implementação 'com.google.android.gms: play-services: 12.0.1'
}

Se assim for, então você está no destino correto do arquivo. C opeda todo o código acima e cole-o nele.

Você obterá um pop-up de barra superior indicando a sincronização de arquivos. Clique em Sincronizar Agora e aguarde a construção do projeto.

Depois de obter todos os sinais de OK verdes no seu log de criação , você pode seguir em frente.

Agora vamos escrever um código android que fará a mágica. Vá para a MainActivity do arquivo e declare as seguintes variáveis, assim:

 string final estática privada TAG = "MainActivity"; 
VideoView videoView;
EditText textView;

// Para procurar registros
Adaptador ArrayAdapter;
ArrayList <> lista = novo ArrayList <> ();

CameraSource cameraSource;

Essas linhas de código devem estar abaixo da linha que diz algo assim:

 classe pública MainActivity estende AppCompatActivity { 

Agora vamos fazer o código mágico dentro do método onCreate () que você verá no mesmo arquivo.

Vamos primeiro adicionar algo em nosso código que permite ao usuário conceder permissão para adicionar o aplicativo android, já que sem isso nosso aplicativo falhará e não funcionará.

 if (ActivityCompat. checkSelfPermission (this, android.Manifest.permission. CAMERA )! = PackageManager. PERMISSION_GRANTED ) { 
ActivityCompat. requestPermissions (this, new String [] {Manifest.permission. CAMERA }, 1);
Torrada. makeText (isto, "Conceda permissão e reinicie o aplicativo", Toast. LENGTH_SHORT ) .show ();
}
outro {
videoView = findViewById (R.id. videoView );
textView = findViewById (R.id. textView );
adapter = new ArrayAdapter <> (isto, android.R.layout. simple_list_item_1 , lista);
videoView.setVideoURI (Uri. parse ("android.resource: //" + getPackageName () + "/" + .Raraw. videoplayback ));
videoView.start ();
createCameraSource ();
}

Adicione o código acima dentro do método onCreate() qual falamos acima.

Agora devemos adicionar o código que rastreia os olhos usando a API de visão do Google. Faremos uma nova aula private para isso, chamada EyesTracker . O código da classe é assim:

 A classe privada EyesTracker estende o Tracker <Face> { 

Flutuador final privado THRESHOLD = 0,75f;

private EyesTracker () {

}

@Sobrepor
public void onUpdate (Detector.Detections <Face> detecções, face do rosto) {
if (face.getIsLeftEyeOpenProbability ()> THRESHOLD || face.getIsRightEyeOpenProbability ()> THRESHOLD) {
Registro. i ( TAG , "onUpdate: Eyes Detected");
showStatus ("Olhos Detectados e abertos, assim o vídeo continua");
if (! videoView.isPlaying ())
videoView.start ();

}
outro {
if (videoView.isPlaying ())
videoView.pause ();

showStatus ("Olhos Detectados e Fechados, Vídeo Interrompido");
}
}

@Sobrepor
public void onMissing (Detector.Detections <Face> detecções) {
super.onMissing (detecções);
showStatus ("Face Not Detected yet!");
}

@Sobrepor
public void onDone () {
super.onDone ();
}
}

Aqui, videoView é a referência ao vídeo que está configurado para o atributo VideoView em activity_main.xml que é para a interface do usuário do aplicativo.

Agora podemos adicionar o código que detecta o rosto do usuário em uma nova classe private chamada FaceTrackerFactory . O código será algo como isto:

 A classe privada FaceTrackerFactory implementa o MultiProcessor.Factory <Face> { 

private FaceTrackerFactory () {

}

@Sobrepor
public Tracker <Face> create (face do rosto) {
devolve o novo EyesTracker ();
}
}

public void createCameraSource () {
Detector de faceDetector = new FaceDetector.Builder (this)
.setTrackingEnabled (true)
.setClassificationType (FaceDetector. ALL_CLASSIFICATIONS )
.setMode (FaceDetector. FAST_MODE )
.construir();
detector.setProcessor (novo MultiProcessor.Builder (new FaceTrackerFactory ()). build ());

cameraSource = new CameraSource.Builder (este, detector)
.setRequestedPreviewSize (1024, 768)
.setFacing (CameraSource. CAMERA_FACING_FRONT )
.setRequestedFps (30.0f)
.construir();

experimentar {
if (ActivityCompat. checkSelfPermission (isto, Manifest.permission. CAMERA )! = PackageManager. PERMISSION_GRANTED ) {
// TODO: Considere chamar
// ActivityCompat # requestPermissions
// aqui para solicitar as permissões perdidas e, em seguida, substituir
// public void onRequestPermissionsResult (int requestCode, String [] permissões,
// int [] grantResults)
// para lidar com o caso em que o usuário concede a permissão. Veja a documentação
// para ActivityCompat # requestPermissions para mais detalhes.
Retorna;
}
cameraSource.start ();
}
catch (IOException e) {
e.printStackTrace ();
}
}

Também precisamos pausar o vídeo e encerrar o vídeo, o qual cuidaremos dos onDestory() e onPause() de MainActivity .

Agora vamos adicionar um código XML para a interface do usuário básica do aplicativo.

Vá para o arquivo que é chamado algo como activity_main.xml . Agora apenas substitua o código nele pelo seguinte código.

 <? xml version = "1.0" encoding = "utf-8"?> 
<LinearLayout 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"
android: layout_width = "match_parent"
android: layout_height = "match_parent"
ferramentas: context = ". MainActivity"
android: orientation = "vertical">

<VideoView
android: layout_width = "match_parent"
android: layout_height = "wrap_content"
android: id = "@ + id / videoView" />

<EditText
android: layout_width = "match_parent"
android: layout_height = "match_parent"
android: id = "@ + id / textView"
android: text = "@ string / face_not_found"
android: textSize = "20sp" />

</ LinearLayout>

Tudo o que esse código faz é adicionar um EditText para exibir o texto que indica o que está sendo detectado e o que não está no usuário. E VideoView que reproduz o vídeo para o usuário.

Você pode encontrar o código-fonte completo do aplicativo aqui.

E isso é muito bonito. Você construiu seu próprio rastreamento ocular e rosto detectando o aplicativo Android.

Tudo feito, parece com isso:

Olhos abertosOlhos fechados

Agora vá e mostre !!

Leia meu post anterior sobre uma biblioteca do Android que facilmente ajuda a personalizar o Snackbar com poucas linhas de código. ChocoBar.