INSITITUTO TECNOLOGICO SUPERIOR DEL

OCCIDENTE DEL ESTADO DE HIDALGO

REPORTE 1

OpenCV en dispositivos móviles Android.

ROMARIO FABIAN LÓPEZ SANTOS

16011891

DOCENTE:

MTRA. DULCE JAZMÍN NAVARRETE ARIAS

PERIODO: Julio 2020 -

9°A
Contenido
Introducción ............................................................................................................. 4
OpenCV .................................................................................................................. 4
Android .................................................................................................................... 4
Desarrollo ................................................................................................................ 5
Creación del proyecto ............................................................................................. 6
Importación de la librería OpenCV .......................................................................... 8
Agregando dependencias .................................................................................. 11
Importando las interfaces................................................................................... 15
Pruebas ................................................................................................................. 18
Implementación de la cámara ............................................................................ 19
Configurando el activiy_main.xml ................................................................... 19
MainActivity.java ............................................................................................ 19
Usando los metodos implementados ............................................................. 22
Configurando metodos de Android .................................................................... 23
onDestroy ....................................................................................................... 23
onPause ......................................................................................................... 24
onResume ...................................................................................................... 24
Permisos de la aplicación. ................................................................................. 24
Ejecución en un dispositivo real......................................................................... 25
Errores .................................................................................................................. 26
Conclusión............................................................................................................. 27
Recursos Usados .................................................................................................. 27
Bibliografía ............................................................................................................ 28

Imagen 1 Versión IDE Android Studio ..................................................................... 5

Imagen 2 Versión de OpenCV................................................................................. 6
Imagen 3 Selección de plantilla ............................................................................... 6
Imagen 4 Nombre del proyecto ............................................................................... 7
Imagen 5 Pantalla principal del IDE ........................................................................ 8
Imagen 6 importación del Modulo ........................................................................... 8
Imagen 7 Selección de la carpeta ........................................................................... 9
Imagen 8 ubicación de la carpeta a usar ................................................................. 9
Imagen 9 Dirección de la ubicación....................................................................... 10
Imagen 10 Descarga de componentes extras ....................................................... 10
Imagen 11 carpeta OpenCV dentro del proyecto .................................................. 11
Imagen 12 Agregación de módulos de dependencia ............................................ 11
Imagen 13 Menú de agregación ............................................................................ 12
Imagen 14 Carpeta de OpenCV ............................................................................ 13
Imagen 15 Comprobación ..................................................................................... 13
Imagen 16 .gradle(:openCVLibrary343) ................................................................ 14
Imagen 17 .gradle(:app) ........................................................................................ 14
Imagen 18 Creación carpeta JNI ........................................................................... 15
Imagen 19 Carpetas de Librerías Nativas ............................................................. 16
Imagen 20 Ubicación de la carpeta jniLibs ............................................................ 17
Imagen 21 Librerías dentro del proyecto ............................................................... 17
Imagen 22 Codigo de comprobación ..................................................................... 18
Imagen 23 Mensaje de configuración correcta ...................................................... 19
Imagen 24 Codigo Despues .................................................................................. 19
Imagen 25 Codigo Antes ....................................................................................... 19
Imagen 26 Implementación de la clase ................................................................. 20
Imagen 27 Implementación de los metodos .......................................................... 20
Imagen 28 Selección de metodos ......................................................................... 20
Imagen 29 Interfaces ya implementadas ............................................................... 21
Imagen 30 Objetos JavaCameraView y Mat ......................................................... 21
Imagen 31 Codigo dentro de onCreate ................................................................. 21
Imagen 32 Metodo BaseLoaderCallback .............................................................. 22
Imagen 33 onCameraViewStarted ........................................................................ 22
Imagen 34 onCameraViewStopped ....................................................................... 23
Imagen 35 onCameraFrame ................................................................................. 23
Imagen 36 onDestroy ............................................................................................ 23
Imagen 37 onPause .............................................................................................. 24
Imagen 38 Metodo onResume .............................................................................. 24
Imagen 39 ubicación del archivo AndroidManifest.xml .......................................... 25
Imagen 40 Permisos específicos para la aplicación .............................................. 25
Imagen 41 Ejecución en un dispositivo móvil ........................................................ 25
Imagen 42 Error de permisos ................................................................................ 26
Imagen 43 Información de la aplicación ................................................................ 27
Imagen 44 Concesión de los permisos ................................................................. 27
Introducción

La visión por computadora ha sido usada al principio para el reconocimiento de

objetos sencillos y en el proceso de calidad en el área industrial, ahora con los
avances tecnológicos en la Inteligencia Artificial este tipo de técnica se ha usado e
implementado en grandes proyectos por grandes compañías como lo son Google,
Tesla, Huawei entre otras. Gracias a esta visión por computadora, las IA
(Inteligencia Artificial) han podido ser alimentadas con grandes cantidades de
información en forma de imágenes y videos, lo cual hace que el proceso de
aprendizaje profundo sea mucho más efectivo.

OpenCV

OpenCV es una librería gratuita usada para el reconocimiento de patrones y

aprendizaje máquina, esto mediante los algoritmos que nos puede proporcionar, al
usar esta librería, esto nos permite identificar rostros, imágenes, objetos, etc.
Esta librería la podemos usar en todas las plataformas existentes, Windows, Linux,
Mac y Android, y se puede programar en los siguientes lenguajes C, C++, Python,
Java y en el sistema de Matlab.
Al tener gran versatilidad para ser usado en las plataformas anteriormente usadas,
OpenCV puede ser consultado, usado y distribuido por cualquiera que tenga
conocimiento de programacion e inteligencia artificial.
Se usa en aplicaciones como la detección de intrusos en vídeos, monitorización de
equipamientos, ayuda a navegación de robots, inspeccionar etiquetas en productos
entre otras aplicaciones en la industria.

Android

Android es un sistema operativo dirigido principalmente para dispositivos móviles,

con base kernel de Linux lo hace versátil y que cualquiera pueda usarlo. Este
sistema operativo es capaz de ejecutar aplicaciones escritas en C++, C#, Kotlin y
Java, este último es el más usado para la creación de las aplicaciones móviles de
este sistema operativo, lo cual abarca más del 80% de las aplicaciones existentes.
Desarrollo

Para poder crear una aplicación móvil que sea capaz de hacer uso de la librería
OpenCV es necesario tener instalado el IDE AndroidStudio
(https://developer.android.com/studio) y tener descargada el SDK de OpenCV () es
importante tener en cuenta que la versión de OpenCV que se usara es la 3.4.3

Imagen 1 Versión IDE Android Studio

Descargamos esta versión de OpenCV:

Imagen 2 Versión de OpenCV

Creación del proyecto

Ya descargado el archivo lo descomprimimos, creamos un nuevo proyecto en
Android Studio.

Imagen 3 Selección de plantilla

Seleccionamos el Empty Activity (ver Imagen 3), en la siguiente pantalla
colocaremos el nombre del proyecto además de seleccionar Java como lenguaje
principal. Las demás opciones las dejamos tal cual estan. Ver Imagen 4.

Imagen 4 Nombre del proyecto

Se creará el proyecto y nos mostrará el IDE y el codigo del Activity Principal.

Imagen 5 Pantalla principal del IDE

Importación de la librería OpenCV

Para hacer la importación de la librería, nos dirigimos al menú File>New>Import

Module.

Imagen 6 importación del Modulo

Este paso nos abrirá una ventana en donde localizaremos la carpeta
descomprimida.

Imagen 7 Selección de la carpeta

Damos clic en el icono de la carpeta, no saldrá una ventana donde navegaremos

hasta la carpeta donde descomprimimos el SDK de OpenCV, y seleccionamos la
carpeta que diga java.

Imagen 8 ubicación de la carpeta a usar

Damos Ok y ahora la ventana tendrá la dirección del SDK y daremos clic en Finish.
Imagen 9 Dirección de la ubicación

Esperamos un momento mientras el IDE sincroniza el archivo. gradle e indexa el

módulo importado con todo el proyecto.

Imagen 10 Descarga de componentes extras

Ya que tengamos instalado el módulo, nos aparecerá en la estructura del proyecto.

 Imagen 11 carpeta OpenCV dentro del proyecto

Agregando dependencias

Agregaremos la dependencia del módulo al proyecto, para esto nos vamos a

File>Project Structure> Dependecies, ahí veremos una ventana igual o similar a
esta.

Imagen 12 Agregación de módulos de dependencia

Daremos clic en este botón (forma de “+”):

Imagen 13 Menú de agregación

Esto nos abrirá un menú, donde seleccionaremos “Module Dependency”, eso nos
abrirá una nueva ventana donde seleccionaremos y marcaremos la casilla de
“openCVLibrary343” y daremos en “OK”.
 Imagen 14 Carpeta de OpenCV

Haciendo esto veremos que se agregara en los módulos de dependencia.

Imagen 15 Comprobación

Damos en el botón “Apply” y despues en el de “OK”.

Para no tener problemas al momento de compilar nuestra aplicación, seleccionamos
el archivo. gradle(: openCVLibrary343) y cambiaremos el targetSdkVersion y
compileSdkVersion por la versión que tengamos en él .gradle(:app), en este caso
se está usando la 29.

Imagen 16 .gradle(:openCVLibrary343)

Imagen 17 .gradle(:app)

Cuando terminemos de hacer esos cambios le damos en “Sync Now”.

Importando las interfaces

Ahora crearemos la carpeta donde contendrán estas interfaces, para esto damos
en New>Folder>JNIFolder, se abrirá una nueva ventana y seleccionaremos la
casilla “Change Folder Location” y cambiaremos el Nombre a uno que nos ayude a
reconocer que es la carpeta que usaremos enseguida.

Imagen 18 Creación carpeta JNI

Ya que tengamos creada la carpeta con el nombre (en este caso se llama jniLibs),
iremos a la carpeta donde descomprimimos los archivos de OpenCV y buscaremos
la carpeta de libs, ubicada en sdk>native>libs.
Imagen 19 Carpetas de Librerías Nativas

Seleccionamos y copiamos todas las carpetas para pegarlas en la carpeta jniLibs,

para esto nos dirigimos al IDE, y en proyecto damos clic derecho y pegar, se abrirá
una ventana donde buscaremos el folder creada anteriormente.
 Imagen 20 Ubicación de la carpeta jniLibs

Damos ok, y veremos que la carpeta tendrá las carpetas y archivos copiados.

Imagen 21 Librerías dentro del proyecto

Pruebas
Para probar que el SDK esta correctamente cargado o instalado, nos dirigimos al
MainActivity.java y colocamos el siguiente codigo dentro de la clase principal.
private static String TAG = “MainActivity”;
static
{
If(OpenCVLoader.initDebug())
{
Log.d(TAG, “OpenCV se ha cargado correctamente”);
}
Else
{
Log.d(TAG, “Algo malo paso, pero nada puede malir
sal”);
}

Imagen 22 Codigo de comprobación

Ya teniendo esto podemos ejecutar la aplicación y veremos en la consola el mensaje
si fue o no correcta la configuración.

Imagen 23 Mensaje de configuración correcta

Implementación de la cámara

Ya que tenemos el SDK de OpenCV dentro del proyecto, es hora de saber como
usar la cámara y metodos que nos proporciona esta misma librería.
Configurando el activiy_main.xml
Aquí cambiaremos el tipo de Layout, de ContraintLayout a RelativeLayout, borramos
el codigo del mensaje “Hello World”, quedaría de la siguiente manera.

Imagen 24 Codigo Despues

Imagen 25 Codigo Antes

MainActivity.java

En esta clase donde habíamos colocado la prueba de conexión al SDK,

implementaremos las interfaces a usar, para eso usamos el implements
CameraBridgeViewBase.CvCameraViewListener2. Ver imagen 26.
Imagen 26 Implementación de la clase

Nos saldrá un la linea subrayada, esto nos indica que las interfaces aun no estan
dentro del codigo, para arreglar esto simplemente damos clic en el icono de foco
que sale arriba del codigo y seleccionamos implents methods. Ver imagen 27.

Imagen 27 Implementación de los metodos

Veremos una nueva ventana donde podremos seleccionar que metodos queremos
implementar, en este caso seleccionamos todos y le damos ok. Ver imagen 28.

Imagen 28 Selección de metodos

Despues de seleccionar el OK, bajamos y veremos todo el codigo autogenerado.
Ver imagen 29.

Imagen 29 Interfaces ya implementadas

Ahora que ya tenemos implementado los metodos que usaremos mas adelante,
creamos un Objeto del tipo JavaCameraView, en este caso usaremos el nombre
de javaCameraView y dos objetos Mat. Ver imagen 30.

Imagen 30 Objetos JavaCameraView y Mat

Dentro del metodo onCreate colocamos el siguiente codigo, este codigo hará de
intermediario entre la clase JavaCameraView que nos proporciona OpenCV y el
main_activity.xml. Ver imagen 31.

Imagen 31 Codigo dentro de onCreate

Creamos un objeto con su metodo implementado dentro, con el nombre de
BaseLoaderCallback, esta clase nos ayudara a poder inicializar correctamente los
metodos implementados anteriormente. Ver imagen 32.

Imagen 32 Metodo BaseLoaderCallback

Usando los metodos implementados

Ahora será turno de usar los metodos que implementamos anteriormente, el primero
de ellos será el metodo “onCameraViewStarted”, este metodo nos permitirá abrir
la cámara con el alto y ancho que nosotros le indiquemos, en este caso usaremos
el siguiente codigo. Ver imagen 33.

Imagen 33 onCameraViewStarted

Cabe mencionar que el parámetro CvType.CV_8UC4 indica que tipo de entrada de

imagen usara, en este caso es del tipo RGBA con cuatro canales (Red, Green, Blue
y Alpha).

En siguiente metodo a usar es el onCameraViewStopped, el cual detendrá el uso

de la cámara al cerrar la aplicación, asi que usaremos el siguiente codigo. Ver
imagen 34.
Imagen 34 onCameraViewStopped

El metodo onCameraFrame nos permite visualizar la cámara dentro del cuadro

(frame) de la pantalla del dispositivo móvil del usuario, que este caso está declarado
en el archivo activity_main.xml. Asi que, para hacer uso de este, necesitamos
colocar el siguiente codigo. Ver imagen 35.

Imagen 35 onCameraFrame

La linea de codigo Core.flip, hace que la cámara gire conforme a la posición que
esta el dispositivo.
La linea de codigo Imgproc, ajusta el tamaño de la imagen a los tamaños
establecidos por mRGBA y mRGBAT.
Configurando metodos de Android
Estos metodos son usados para el ciclo de vida de las aplicaciones, es decir que
hacer si una aplicación se cierra o se manda a segundo plano.
onDestroy
Este metodo se ejecutará al momento de cerrar la aplicación y nos permitirá terminar
el proceso de la aplicación y uso de la cámara. Ver Imagen 36.

Imagen 36 onDestroy
onPause
Este metodo hará la mismo, pero solamente cuando la aplicación se mande a
segundo plano. Ver imagen 37.

Imagen 37 onPause

onResume
Este metodo nos permite reanudar la aplicación despues de estar en el metodo
onPause, para esto necesitamos el siguiente codigo. Ver Imagen 38.

Imagen 38 Metodo onResume

Es importante mencionar quitar el metodo static que usamos al momento de hacer

la prueba de conexión.

Permisos de la aplicación.

Terminando con la parte de la programacion de los metodos de OpenCV, es hora

de modificar los permisos del sistema para poder hacer uso de la cámara, para esto
es necesario ir al archivo AndroidManifest.xml dentro de la carpeta app (Ver
imagen 39).
 Imagen 39 ubicación del archivo AndroidManifest.xml

Dentro del archivo colocamos las siguientes líneas. Ver imagen 40:

Imagen 40 Permisos específicos para la aplicación

Ejecución en un dispositivo real.

Conectamos nuestro celular para poder hacer la ejecución de nuestra aplicación.

Ver Imagen 41.

Imagen 41 Ejecución en un dispositivo móvil

Errores

Es posible que salgan errores al momento de agregar los módulos de OpenCV, esto
depende de la conexión a internet.
Solución: eliminar la carpeta del módulo y volverla a colocar.
Es posible que el Manyfest de OpenCV tenga un error en las versiones mínimas y
recomendadas.
Solución: el IDE automáticamente detecta el error y lo soluciona, solo es dar
clic en el error y darle en el botón de “Do refactor”

Es posible que la aplicación no corra de manera inmediata en nuestro teléfono

celular, esto es porque la aplicación aun no tiene los permisos de hardware
necesarios. Ver Imagen 42.

Imagen 42 Error de permisos

Solución: Ir a configuración/Ajustes> Aplicaciones >” nombre de la aplicación”

> permisos. Aquí podremos habilitar la cámara. Ver Imagen 43 y 44.
 Imagen 43 Información de la aplicación Imagen 44 Concesión de los permisos

Conclusión
Podemos decir que saber cómo usar las versiones que nos proporciona, asi como
la documentación de OpenCV, podremos hacer aplicaciones que cuenten con la
capacidad de reconocimiento de patrones y/u objetos.

Recursos Usados
OpenCV Configuration in Android Studio - OpenCV Android Studio Setup Tutorial
2019 (OpenCV Library). Retrieved from:
https://www.youtube.com/watch?v=pzuwrYgOnDQ
Launch Camera with openCV in Android Studio & Process Frames - Android Deep
Learning Tutorials. Retrived from: https://www.youtube.com/watch?v=rKvIKkBefJQ
Bibliografía

Baldan. (n.d.). You have not accepted the license agreements of the following SDK
components: Retrieved from https://es.stackoverflow.com/questions/155250/you-
have-not-accepted-the-license-agreements-of-the-following-sdk-components
Gonzalez, A. N. (2011, February 9). ¿Qué es Android? Retrieved from
https://www.xatakandroid.com/sistema-operativo/que-es-android
Gracia, L. M. (2013, October 9). ¿Qué es OpenCV? Retrieved from
https://unpocodejava.com/2013/10/09/que-es-opencv/
OpenCV. (n.d.). Retrieved from https://robologs.net/tutoriales/tutoriales-opencv/
OpenCV, Instalación en Python y ejemplos básicos. (2020, February 12). Retrieved
from https://revistadigital.inesem.es/informatica-y-tics/opencv/
Versiones OpenCV. (2018, October 16). Retrieved from
https://opencv.org/releases/page/3/
Visión artificial, OpenCV y Python, primeros pasos para analizar imágnes. (2020,
May 28). Retrieved from https://programarfacil.com/podcast/81-vision-artificial-
opencv-phyton/