notas sobre detección de tortillas

publicado el 2018-08-20

parte del proyecto: tortilla-stories


empiezo a documentar por acá el proyecto computacional/electrónico(/mecánico?) como parte de tortilla stories guiado por mel.

rata panchis enfrente de una computadora; al lado una tortilla observada por una cámara

detectemos tortillas…

la idea es tener un tortillas player, un “tocatortillas” (reemplazando el “tortillas” por “disc(o)”); cada una tendrá un dibujo y al colocarse en una tornamesa, se lee y desencadena una serie de sonidos.

esta es documentación más bien técnica de los procesos y herramientas a utilizar para el acto escénico, para la cuestión artística recomiendo revisar la página y contactar a mel :)

el problema a resolver es la detección e identificación en vivo e interactiva de cada tortilla para que desencadene un evento distinto. (además de tener un plan de respaldo para simular y/o controlar externamente la interacción si todo falla)

posibles implementaciones: hardware vs software

la primera distinción sería si hacer la identificación con hardware o con software.

con hardware se podría resolver usando etiquetas nfc y un lector en la tornamesa. cada tortilla tendría que tener una etiqueta distinta y mapeada a cada evento. probablemente este sea el método más estable / con menos ruido. la desventaja es el costo y la necesidad de consumir hardware.

con software las implementaciones que se me ocurren tienen que ver con visión computacional. la ventaja es que no sería necesario consumir nada más (ya cuento con cámara web y luces), la desventaja es la posible dificultad en hacer la detección / identificación estable, además de la complejidad de la solución.

de aquí nos podemos pasar a dos ramas más: aprendizaje de máquina (¿es esa la traducción de machine learning?), o visión computacional “tradicional”.

visiones computacionales

con la implementación del aprendizaje de máquina, la solución consistiría en preparar un sistema para que pueda aprender las diferencias entre los dibujos de las tortillas por sí solo (bueno, sería necesario entrenarlo). con la implementación “tradicional”, más bien habría que programar y de alguna forma predeterminar qué y cómo es lo que se quiere detectar, posiblemente con ayuda de algún tipo de marcadores.

como extra, una “visión computacional” más rudimentaria es la de usar un lector de código de barras. el inconveniente aquí es la dificultad de asignarlos a la superficie irregular de la tortilla, además de la cuestión estética y semiótica (?) de la imagen de un código de barras en cualquier objeto.

por último, de la mano iría el uso de códigos qr. veo que con herramientas como myqr se pueden hacer qr “artisticos”. podría ser una solución robusta y con ya muchas herramientas de apoyo; de cualquier forma habría que probar su efectividad (y método de aplicación) sobre la superficie de las tortillas. de cualquier forma está bien tener estas ideas de respaldo.

actualización nocturna: también está la opción de los marcadores de reactivision que habrá que probar :)

aprendizaje de máquina

aquí algunas notas de las pruebas e investigaciones que estuve haciendo:

aprendizaje de máquina “clásico”

proyectos como wekinator o el addon de openframeworks llamado ofxGrt facilitan el uso de varias operaciones, incluyendo la clasificación (aprender a diferenciar entre varias categorías de un conjunto determinado de entradas - en este caso los pixeles de una imagen de una tortilla con un dibujo). como sea, son algoritmos más “clásicos” que si bien funcionan para entradas de pocas dimensiones (e.g. conjunto de datos de varios acelerómetros, coordenadas tridimensionales de las articulaciones de un esqueleto, etc), no tanto para el procesamiento de imágenes, pues no tienen una “noción” de las relaciones bidimensionales entre pixeles. para estos algoritmos, los pixeles mantienen su “naturaleza original”: una lista lineal de números que corresponden a intensidades de luz, y no una matriz o cuadrícula.

hice pruebas con wekinator, aprovechando el ejemplo de “simple webcam” pero aumentando la resolución de 100 pixeles a 1600, y en efecto no sirvió de mucho.

aprendizaje de máquina “profundo” (deep learning)

hace un par de años (¿o más?) se volvió más accesible el uso de deep neural networks, y para este caso en particular, el uso de convolutional neural networks (cnn). no nos meteremos aquí [en este post] en detalles, el caso es que su ventaja es que si son bien entrenadas (y hay modelos bien entrenados listos para ser descargados), pueden identificar y extraer características de las imágenes a distintos niveles de abstracción (¿bordes? ¿en qué dirección? ¿es esta una textura cuadriculada? ¿es esta una textura con cierta dirección? ¿es esta una cara? ¿es un gato? etc)

esas características (features) luego se pueden utilizar como “entradas” a un sistema “clásico” como los descritos arriba. estos sistemas con cnn son muchísimo más poderosos y versátiles para por ejemplo aprender a diferenciar imágenes (como en nuestro caso, las imágenes de las tortillas) sin importar demasiado su colocación exacta, su orientación, etc.

el projecto de ml5js funciona como “envoltura” de muchos componentes que no entiendo (¿tensorflow.js?), junto con modelos pre-entrenados, para tener un acceso fácil a este tipo de funciones complejas. tienen un ejemplo que justo hace lo deseado: classifier with feature extraction. el problema es que al parecer por el momento solo funciona bien usando el navegador chrome, y pues yo no le juego a esas cosas del spyware. desafortunadamente no pude probarlo. habrá que esperar a un mayor soporte entre navegadores…

el sitio de ml4a tiene varios ejemplos que se pueden descargar y con los que se puede “jugar” en openframeworks. para esta aplicación, dos ejemplos ideales son el de convnet classifier o el doodleclassifier. quise probarlos en mi computadora, pero me enfrenté a varias horas de dependency hell tratando de compilar las bibliotecas necesarias para su funcionamiento. recientemente hubo una actualización grande de openframeworks, y eso parece haber traido compatibilidad con sistemas gnu/linux recientes pero también roto compatibilidad con cosas como esta. ni modo, habrá que esperar para la próxima…

animación de rata panchis enfrente de una computadora con un signo de interrogación apareciendo

la vida en el dependency hell de c++ y openframeworks en gnu/linux

por último, el proyecto de runwayml suena bastante bien también, como una “super evolución” de wekinator; pero todavía no está disponible y no me queda claro si será software libre.

conclusión para el aprendizaje de máquina: nos queda debiendo por el momento :(

visión computacional “tradicional”

la verdad no sé cómo llamarle a esta rama, pero afortunadamente tengo más experiencia aquí para implementar una solución.

aquí la implementación tiene que ver con construir un sistema relativamente controlado para de manera ingeniosa identificar a las tortillas.

de alguna forma se puede ver como reinvención de algo como el código de barras o qr, como ya fueron descritos; la ventaja de hacerlo de cero y personalizado es que se puede ajustar a la aplicación tanto en especificaciones técnicas (por ejemplo, no hay la necesidad de hacer un sistema que permita miles de millones de variaciones si solo hay una docena de tortillas) como estéticas (los identificadores pueden adaptarse más al estilo o necesidades gráficas.

por el momento me estoy yendo por esta opción. distintas formas de realizarlo y que se me ocurren son:

cuatro marcadores

tener un patrón de cuatro marcadores (círculos, cuadrados) formando un cuadrado entre ellos para guiar la detección. la información identificadora estaría en las lineas/aristas entre ellos. esto probablemente requiere uso de umbrales de intensidad de luz, detección de bordes, discriminación por tamaño de área para obtener a los marcadores, tal vez algo de geometría para corroborar la forma del cuadrado, y finalmente un “warping” para obtener el cuadrado original / perpendicular / alineado. tal vez es la opción en la que tengo más experiencia y ejemplos, pero a la vez suena complicada…

línea(s)

línea(s) recta(s) con algún tipo de marcas a lo largo de su longitud, la(s) línea(s) permiten la detección y las marcas serían las identificadoras. esto probablemente requiere detección de líneas con “hough” y luego algún tipo de “warping” o de trabajo geométrico para identificar las marcas. me parece “sencillo” en teoría, pero me causa algo de ruido su posible apariencia.

lectura rotacional (?)

aprovechar la rotación de la tornamesa para tener un “punto de lectura” fijo por el que iría pasando el código… literalmente como funciona un disco analógico o digital, pero con una “region of interest” de una cámara en vez de aguja o láser, y con un tamaño de “zurcos” mucho mayor. probablemente esta sea la opción más sencilla (y divertida), lo que habría que considerar es la velocidad de rotación: ni tan lenta que la lectura tarde demasiado, ni tan rápida que la frecuencia de captura de la cámara no la alcance o se ponga borrosa; y también el diseño [probablemente redundante] del anillo de información, para que pueda tener varios puntos de inicio de lectura si no se quiere esperar a que la tortilla dé una vuelta completa.

continuará…

iré haciendo pruebas con las últimas dos implementaciones y con reactivision, así como compartiendo más al respecto (código incluido)…


para comentar, escríbeme a ratapanchis arroba eccs.world :)