PREPROCESAMIENTO DE IMÁGENES PARA LA DETECCIÓN DE PLACAS DE AUTOMOVIL CAPTURADAS POR WEB CAM

Transcripción

1 UNIVERSIDAD AUTONOMA METROPOLITANA UNIDAD IZTAPALAPA LICENCIATURA EN COMPUTACIÓN PREPROCESAMIENTO DE IMÁGENES PARA LA DETECCIÓN DE PLACAS DE AUTOMOVIL CAPTURADAS POR WEB CAM AARON DAVID RAMÍREZ SEGURA ASESOR: DR. LUIS MARTIN ROJAS CÁRDENAS MÉXICO D.F., SEPTIEMBRE 2002

2 A MIS PADRES: Leonila y Aarón Gracias por todo el apoyo y comprensión que me han dado para seguir adelante en la vida, sus consejos han servido alcanzar una meta más, y me dan fuerza para seguir adelante. Gracias, y que dios los bendiga siempre.

3 INDICE GLOSARIO DE TÉRMINOS 4 LISTA DE SIGLAS 5 LISTA DE FIGURAS Y DIAGRAMAS 6 INTRODUCCIÓN 7 CAPITULO EL RECONOCIMIENTO DE PATRONES INTRODUCCIÓN EL RECONOCIMIENTO DE PLACAS OTROS TRABAJOS NUESTRA PROPUESTA 12 CAPITULO PREPROCESAMIENTO DE IMAGENES INTRODUCCIÓN COMO BAJAR IMÁGENES DE LA WEBCAM PROCESAMIENTO DE IMÁGENES EN JAVA METODOLOGÍA PROPUESTA PARA EL PREPROCESAMIENTO DESARROLLO FACTORES A CONSIDERAR 28 CONCLUSIONES 29 ANEXO 1 30 ANEXO 2 36 ANEXO

4 Glosario de términos Imagen digital.- Representación numérica de una imagen mediante pixeles (picture elements), cuyo valor puede representar, entre otros, un nivel de gris o un valor dentro de una banda espectral perteneciente a un modelo de color. Luminacia.- Es una medida, entre otras, asociada a la cantidad de energía luminosa procedente de cualquier fuente lumínica que el observador percibe. Se mide en lúmenes (lm). Morfología matemática.- Conjunto de herramientas para el procesamiento no lineal de imágenes. Está basada en la teoría de los conjuntos, en el espacio bidimensional entero Z 2, donde cada elemento de las imágenes se representa como una dupla con coordenadas (x, y). Nivel de gris.- Valor l de una imagen monocromática f en el punto dado por las coordenadas (x,y), dentro del rango L mín l L máx, que representa una variable física dada. Reconocimiento de patrones.- Clasificación de una descripción estructural o cuantitativa de un objeto o de alguna otra entidad de interés en una imagen, por medio de técnicas estadísticas, sintácticas o lógico - combinatorias. Segmentación de imágenes.- Subdivisión sin traslapes de una imagen en sus partes constituyentes u objetos. Las características de la segmentación dependerán del problema a resolver. Vecinos de un Pixel.- El pixel del centro de una malla de 3x3 tiene dos tipos de vecinos: los horizontales y verticales, denominados 4-vecinos, y los diagonales, que junto con los 4-vecinos, constituyen los 8-vecinos de dicho pixel. Umbral.- Valor que sirve para binarizar las imágenes de niveles de gris. Se utiliza para dividir un conjunto de valores en dos grupos: objetos y fondo. Patrón.- Es una descripción estructural de un objeto o de alguna otra entidad de interés en una imagen. Borde de una imagen.- Es el conjunto de puntos que son vecinos del fondo de la imagen. Adyacencia.- Dado un punto P, de coordenadas (x,y), se denominan puntos adyacentes o vecinos a todos aquellos puntos que se encuentran a distancia 1. 4

5 Lista de siglas RGB.- Red, Green, Blue. Modelo de color dependiente del dispositivo compuesto por los 3 colores básicos Rojo, Verde y Azul. Al combinarlos aditivamente entregan una gama dada de colores y que al unirlos en proporciones aproximadamente iguales, generan los tonos de gris. OCR.- Reconocimiento Óptico de Caracteres. Método para el reconocimiento de caracteres en imágenes. RITRE.- Reconocimiento Invariante a Traslación, Rotación y Escalamiento. MAH.- Memoria Asociativa Holográfica. JMF.- Java Media Framework es un protocolo de transmisión de datos para la reproducción multimedia (vídeo y sonido). API.- Application Programming Interface Conjunto de paquetes y clases Java, incluidos en el JDK que utilizan los programadores Java para realizar sus aplicaciones. AWT.- Abstract Windowing Toolkit Biblioteca de módulos pera representar interfaces gráficos provisto por Sun en la API de Java. 5

6 Lista de figuras y diagramas Figura Proceso de Acceso a un Estacionamiento. Figura Imagen final preprocesada. Figura Modelo del reproductor. Figura Modelo del procesador. Figura BufferedImage. Figura Proceso de Operaciones con Imágenes. Figura Detección de Bordes. Figura Lookup Figura Operación de Afilamiento. Figura Convolución. Diagrama Preprocesamiento de imagen de la placa. Figura Imágenes originales obtenidas por la webcam. Figura Operación de Velar en las imágenes de la placa. Figura Thresholding con umbral 128. Figura Posterización. Figura Afilamiento. Figura Thresholding con umbra 180 en escala de grises. Figura Imagen final. Figura A2.1.- Salida del programa A2.1 Figura A2.2.- Salida del programa A2.2 Figura A2.3.- Salida del programa A2.3 Figura A2.4.- Salida del programa A2.4 6

7 INTRODUCCIÓN La comunicación entre el ser humano y sus máquinas se asemeja cada vez más a la natural. Como la vista es el sentido más desarrollado que poseemos, no es de extrañar que se desarrollen nuevos sistemas informáticos capaces de reconocer, procesar e interpretar automáticamente todo tipo de gráficos, imágenes y videos. Las numerosas actividades del sector de la investigación nos han mostrado en los últimos años progresos decisivos, a pesar del altísimo poder computacional que requieren algunas de estas aplicaciones, como el procesamiento digital de imágenes, y el procesamiento digital de vídeo, el cual se realiza principalmente a través de hardware. El análisis de imágenes es un proceso que consiste en descubrir, identificar y comprender los patrones que son relevantes en el rendimiento de un trabajo basado en imágenes. Uno de los principales objetivos del análisis de imágenes por computadora consiste en dotar a una máquina, en algún sentido, de la capacidad de aproximación, similar a la de los seres humanos. Existen muchas aplicaciones en las cuales es de gran utilidad el reconocimiento de caracteres en imágenes reales, siendo una de ellas el de tomar los caracteres que se encuentran escritos sobre etiquetas o en este caso placas de automóviles. El registrar de manera automática las placas tiene aplicaciones directas en los estacionamientos, casetas de cobro, etc. Mediante uso de un dispositivo como una webcam se pueden capturar las imágenes a procesar. En la actualidad es preferible optar por webcams que se conectan por puerto USB (Universal Serial Bus), ya que permite transmitir con mayor velocidad y mejor calidad. La detección de caracteres en una imagen dada como la de una placa de automóvil, implica tomar en cuenta varios aspectos, primeramente el crear herramientas de programación para obtener la imagen de la webcam, pasar esta imagen a un formato cuya información sea fácil de manipular, determinar que secuencia de operaciones es la indicada para que al final se obtenga una imagen procesada en pixeles blancos y negros que muestren claramente la delimitación de los caracteres, para que posteriormente mediante algún algoritmo se puedan detectar dichos caracteres. Hoy en día el lenguaje de programación Java tiene gran alcance para el procesamiento de imágenes, por esta razón es recomendable utilizarlo para este tipo de aplicaciones ya que se pueden implementar diversas operaciones en imágenes. 7

8 CAPITULO 1 1. EL RECONOCIMIENTO DE PATRONES 1.1. Introducción Mucha de la información que se maneja en la vida real se presenta en la forma de patrones complejos: caras, textos escritos, enfermedades, música, flores, piezas industriales, etc. Para la psicología, el problema central en el ámbito del reconocimiento de patrones el es estudio de los mecanismos por los que las señales externas estimulan los órganos sensoriales y se convierten en experiencias perceptibles significativas, o dicho de otra forma, cómo realizamos el etiquetado de estos estímulos tan complejos asignándoles un nombre. Estos procesos continúan siendo desconocidos en su mayor parte y no se ha encontrado un modelo concluyente sobre cómo nuestro sistema nervioso realiza este reconocimiento. No obstante, se admite que esta tarea debe realizarse siguiendo un esquema general como el que se detalla a continuación. Antes del reconocimiento, un patrón debe ser percibido por los órganos sensoriales. Además, el mismo patrón o alguno similar (de la misma clase) debe haberse percibido y recordado previamente. Finalmente, debe establecerse alguna correspondencia entre la percepción actual y lo recordado. En resumen, esta aproximación al reconocimiento de patrones se centra en el estudio del mecanismo de reconocimiento presente en los seres vivos. El uso intensivo de ordenadores u otros dispositivos electrónicos en los último años ha impulsado el estudio y aplicación de técnicas de reconocimiento de patrones. En particular los dispositivos de adquisición de datos (sensores y transductores) y los convertidores A/D hacen que un ordenador pueda ser ``alimentado'' con datos (observaciones) del mundo real, utilizado para almacenar y recuperar información y para establecer la correspondencia entre observaciones pasadas y actuales (utilizando modelos adecuados, naturalmente). La aproximación al reconocimiento de patrones que adoptaremos es la del estudio de las teorías y técnicas de reconocimiento implementables en un sistema informático. En este sentido, las fuentes de este área son las Matemáticas (fundamentalmente la Estadística) y la Inteligencia Artificial, en sus aproximaciones algorítmicas a la resolución de problemas. Aunque la aplicabilidad de las técnicas resulta, a priori, muy amplia, no hay un método que sea la panacea. Diversas razones hacen que los sistemas de reconocimiento de formas operativos sean muy específicos del problema a resolver: 8

9 La naturaleza de los patrones: caracteres escritos, símbolos, dibujos, imágenes biomédicas, objetos tridimensionales, firmas, huellas dactilares, espectrogramas, imágenes de Teledetección, cromosomas, etc. Los requerimientos del sistema, especialmente en tiempo de respuesta hace que algunos métodos de reconocimiento, aún siendo superiores en éxito no sean aplicables en la práctica. Factores económicos: un sistema equipado con diferentes sensores y equipos de procesamiento muy potentes pueden dar resultados muy satisfactorios pero no pueden ser asumidos por los usuarios. Estos factores hacen que un sistema adecuado para un problema sea inaplicable para otro, lo que posibilita el estudio y desarrollo de nuevas técnicas. Debe considerarse, además, que el reconocimiento de patrones no constituye un campo de estudio cerrado sino que las técnicas relacionadas con este campo pueden encontrase en otras ramas de la Ciencia y de la Tecnología. De ahí que encontrar una definición formal para un campo tan diversificado sea imposible. Actualmente, las investigaciones se encaminan en los aspectos teóricos y prácticos en las líneas de segmentación de imágenes, el reconocimiento de objetos 2D y 3D usando técnicas de indexado, redes neuronales e invariantes geométricos y topológicos, el reconocimiento de patrones abstractos usando el enfoque lógico combinatorio, la estructuración de espacios conceptuales, así como el control de servomecanismos usando información visual. Las aplicaciones incluyen el diagnóstico médico asistido por computadora, la segmentación de imágenes usando métodos variacionales, el reconocimiento de rostros, el control de robots móviles usando información visual, etc El reconocimiento de placas Registrar de manera automática las placas tiene aplicaciones directas en los estacionamientos, casetas de cobro, departamentos de transito, etc. En particular nuestra aplicación fue requerida para llevar el registro de los automóviles en estacionamientos, donde el fin último es tener control sobre el ingreso el automóvil, es decir, se toma la imagen de la placa, a una cierta distancia de la entrada del estacionamiento, esta imagen se procesa para obtener los caracteres, y estos se comparan con la base de datos de las placas de automóviles autorizadas a tener acceso (Figura 1.1). El proyecto consiste en tener una aproximación, tolerante a situaciones de bajo contraste producido por polvo o por las condiciones de Luminacia de la placa, que permita reconocer sus caracteres en un tiempo razonable y con un buen porcentaje de éxito. 9

10 347 FKL mex mex Preprocesamiento De la Imagen Caracteres Identificados Acceso ó no al estacionamiento Comparación en Base de Datos Figura Proceso de Acceso a un Estacionamiento Otros trabajos Existen trabajos que dividen el problema en cuatro etapas: pretratamiento localización de la placa segmentación identificación de los caracteres Pretratamiento: La detección de fronteras entre dos regiones con respecto a sus niveles de gris es una de las primeras etapas por la que necesita pasar la imagen antes de la etapa de localización de la placa. La idea básica para la detección de bordes consiste en la aplicación de operadores locales diferenciales, esto es convolucionar la imagen con una máscara predefinida. Los operadores de primera derivada proporcionan una aproximación muy burda a los bordes, sujetos a gran cantidad de ruido. La segunda derivada tiene una propiedad que la hace atractiva, tiene un paso por cero, lo que representa el punto medio de una transición de nivel de gris. Esto lo hace más confiable para la detección de bordes. Localización de la placa: El problema fundamental en la localización es qué requiere detectar: áreas de cierto color, cierta geometría, etc. El primer punto de vista, el del color se descarta por el hecho de agregar una complejidad extra el manejar colores ya que la adquisición de datos es a través de una cámara que genera imágenes en 10

11 escalas de gris. La segunda alternativa, la de la geometría de la placa, conduce a buscar alguna heurística adicional para la detección de la placa. Para ello se busca detectar rectángulos en la imagen, utilizando la transformada de Hough para la detección de línea rectas, que posteriormente son agrupadas en rectángulos. Segmentación: Teniendo las coordenadas superior-izquierda e inferior-derecha de la placa, se procede a la segmentación de los caracteres. Las placas guardan cierta relación largo/alto y el número de caracteres puede variar de 6 ó 7 dependiendo del estado. Además estos guardan una relación largo/alto con respecto a la placa y es ahí donde se puede tomar ventaja. Utilizando rectángulos de relaciones n sobre m, dependiendo del tamaño de la placa en la imagen, se hace pasar sobre el área de la placa, al momento de detectar una agrupación de pixeles ``negros'' (previamente la imagen ha sido convertida a 2 niveles de gris o imagen binaria) dentro del rectángulo se pueden ya extraer. Dicho agrupamiento de pixeles debe presentar una baja conectividad con el resto de la imagen para ser segmentados como un carácter. Con las coordenadas superior-izquierda e inferior-derecha del rectángulo se procede a regresar a la figura original (en tonos de grises) y separar'' el carácter del fondo utilizando un umbral a cierta intensidad. Esto último se hace debido a que la técnica de identificación requiere calcular momentos de inercia y necesita el carácter completo, no sólo las orillas. identificación de los caracteres: Para el proceso de identificación de los caracteres se basa en un método para reconocimiento invariante a traslación, rotación y escalamiento (RITRE) de objetos bidimensionales. Se exponen resultados muy favorables al utilizar esta técnica, llegando al 99% de efectividad con imágenes artificiales de 100x100 y 45x45. La técnica RITRE consiste en calcular ciertas características invariantes en los caracteres y con estos crear una Memoria Asociativa Holográfica (MAH). La MAH basa su concepto en la holografía óptica sobreponiendo múltiples asociaciones de estímulo respuesta en una misma unidad de procesamiento. El Reconocimiento Óptico de Caracteres (OCR) es otro método para reconocer la parte textual de una imagen digitalizada. El resultado de esto es un archivo de texto que puede ser editado y usado como tal por cualquier programa o aplicación que lo necesite. La metodología del OCR es la siguiente: Binarización. Fragmentar la imagen. Adelgazar las componentes. Código de cadenas. Comparar con patrones y/o propiedades. 11

12 1.4. Nuestra propuesta Nuestro trabajo consistirá en implementar primeramente las herramientas para obtener la imagen de la webcam, determinando el formato adecuado para trabajar, en nuestro caso se tiene que tomar en cuenta que la implementación se realizará bajo la plataforma del lenguaje Java. Posteriormente se realizara el preprocesamiento de la imagen, en donde se tomará en cuenta factores como la distancia, luminacia y ruido presentado en la imagen, lo cual determinara las operaciones a realizar a dicha imagen. Por último se aplicará a la imagen operaciones para obtener como resultado final una imagen que delimite claramente los caracteres de la placa en un formato binario, en pixeles blancos y negros (Figura 2). Figura Imagen final preprocesada. Nuestro trabajo abarcará hasta esta etapa, posteriormente se tendrá que implementar un algoritmo para la detección de los caracteres, basándose en el cálculo del código de cadenas de cada componente conexa. 12

13 CAPITULO 2 2. PREPROCESAMIENTO DE IMAGENES 2.1. Introducción Antes de comenzar a desarrollar programas para procesar imágenes, debemos saber cómo se representan las imágenes dentro de nuestro ordenador. Como ya habremos oído en muchas de ocasiones los ordenadores solo entienden ceros y unos, o lo que es lo mismo números, por tanto podemos decir como primera aproximación que para un ordenador una imagen es un conjunto de números, ordenados en forma de matriz bidimensional. Coordenada x y coordenada y. Esta matriz almacena en cada una de sus posiciones un valor que representa el color del punto al que referencia. Si la imagen está en escala de grises, cada entrada de la matriz representa su valor de luminacia, la intensidad de gris del punto. Un valor 0 representa el color negro, mientras que un valor 255 representa el color blanco. De esto último se deduce que en cada entrada de la matriz se almacena un byte lo que nos proporciona los mencionados 256 valores los cuales para una imagen en escala de grises son más que suficientes. Si la imagen es en color, tenemos dos formas de almacenarla en la matriz: TRUE-COLOR: En este esquema para cada punto de la imagen se almacenan las tres componentes de color que lo definen. Para una profundidad de color de 8 bits, cada punto de la imagen se representará con 3 bytes o, lo que es lo mismo 24 bits de color. Existen otros esquemas tales como HiColor en el que cada punto ocupa 16 bits o los formatos de color de 32 bits en los cuales el byte adicional puede almacenar información de profundidad, para sistema 3D o el llamado canal alpha que representa la transparencia de ese punto y es utilizado para combinar distintas fuentes de imagen. PALETA DE COLOR: Con este esquema, se crea una tabla en la que se almacenan los colores que aparecen en la imagen, en forma de componentes R, G y B. Esta tabla recibe el nombre de paleta de color. La matriz de la imagen almacena el índice de la entrada en la paleta que contiene el color del punto que se esté referenciando. Así si la entrada 25 de la paleta contiene los valores (255,0,0), todos los puntos rojos (rojo totalmente saturado) de la imagen se referenciarán con el valor 25. Este esquema resulta interesante siempre que el número de entradas de la paleta, es decir, el tamaño del índice en bytes, sea menor que el tamaño en bytes de la definición de color. Generalmente tenemos paletas de 256 colores con lo 13

14 cual con un solo byte podemos direccionar todas sus entradas, y cada entrada de la paleta almacena 3 bytes, uno por cada componente de color. Este esquema además nos ahorra memoria, pues, por ejemplo, cuando antes nos hacía falta 3 bytes por punto, ahora llega uno más lo que ocupe la paleta. El formato de paleta de color es útil cuando se trata solamente de representar imágenes, puesto que de cara a su procesamiento es necesario convertirla a formato true-color, lo cual se hace de forma inmediata sustituyendo cada índice de la matriz de la imagen, por el contenido de la paleta apropiado. La razón por la que no se puede procesar las imagen con un formato de paleta de color, es que,en general, cuando se aplica algún tipo de procesado a la imagen se generan nuevos colores que no están definidos en la paleta, con lo cual no pueden ser representados. Además, el hecho de tener una paleta, hace que los puntos no sean independientes, es decir, todos los puntos con el valor 25 tienen el mismo color. Si tuviésemos que modificar uno solo de ellos, tendríamos que generar una nueva entrada en la paleta para ese color, o localizar ese color entre los ya definidos en la paleta. En base a lo anterior, lo que realizaremos principalmente en nuestro trabajo es manipular la matriz de nuestra imagen para obtener el resultado deseado, empleando técnicas existentes como la cuantificación de colores, técnica de Dithering, técnica del umbral, conversión a Escala de Grises, filtrado, detección de bordes, etc. Para lograr lo anterior primeramente se tendrá que solucionar el problema de obtener la imagen de la webcam, lo cual se realizara usando una de las Interfaces de Programación de Aplicación de Java como lo es JMF (Java Media Framework), ya ofrece a reveladores una caja de herramientas de gran alcance para multimedia con la capacidad de capturar de un aparato de lectura, de transmitir y de transcodificar los media. Este conjunto opcional amplía las capacidades de los multimedia de la plataforma de Java Como bajar Imágenes de la WebCam El proceso realizado fue utilizando una webcam Micro Cam con capacidad para 20 imágenes Hi-Res (Resolución Alta) o 80 low-res (Resolución baja), conectada a puerto USB. Utilizando JMF se puede obtener las imágenes desde un dispositivo de captura tal como un micrófono o cámara de vídeo, en nuestro caso webcam. Los datos de los medios capturados pueden ser almacenados y procesados para su uso. Antes de explicar el proceso se requiere conocer los siguientes conceptos utilizados en JMF. 14

15 Reproductores Un reproductor procesa una entrada de flujo de datos de los medios y los presenta en un momento exacto. Un DataSource se utiliza para enviar la información de la secuencia de medios de entrada al Reproductor, el cual determina la destinación dependiendo del tipo de medios que son presentados. Figura Modelo del reproductor. Procesadores Los procesadores se pueden también utilizar para presentar datos de los medios. Un procesador es justamente un tipo especializado de reproductor que proporciona la opción de generar otro DataSource que se puede utilizar como entrada para otro proceso con la secuencia de los medios. Un procesador utiliza los mismos controles de la presentación que un reproductor. Figura Modelo del procesador Además de proporcionar datos de los medios a los dispositivos de la presentación, proporciona con un DataSource los mismos datos de los medios como salida, para poderlos presentar por otro reproductor o procesador, manipulado más lejos por otro procesador, o entregado a alguna otra destinación, tal como un archivo. Un procesador es un reproductor que toma un DataSource como entrada de información, realiza un cierto proceso definido por el usuario en los datos de los medios, y después hace salir los datos procesados de los medios. Los multimedia que se capturan de dispositivos pueden actuar como fuente para la entrega de los datos de multimedia. Por ejemplo, un micrófono puede capturar la entrada audio o una cámara de vídeo digital capturar y entregar el vídeo. Tales dispositivos de captura se abstraen como DataSources. Por ejemplo, un dispositivo que proporciona la entrega oportuna de datos se puede representar como PushDataSource. Cualquier tipo de DataSource se puede utilizar como captura: PushDataSource, PushBufferDataSource, PullDataSource, o PullBufferDataSource. 15

16 Un DataSink se utiliza para leer datos de los medios de un DataSource y para enviar los medios a alguna destinación. Un detalle DataSink pudo escribir datos a un archivo, escribir datos a través de la red, o funcionar como un locutor de RTP. Una vez explicados estos conceptos se procede a explicar la forma para manejar los datos obtenidos por la webcam que se realiza de la siguiente manera: Primeramente se configura el dispositivo con sus características, en nuestro caso seria: defaultvideodevicename = "STV0680 Camera"; defaultvideoformatstring="size=176x144,encoding=rgb,maxdatalength= 76032"; Se sitúa el dispositivo de captura que se quiere usar llamando CaptureDeviceManager. Obtenemos un CaptureDeviceInfo objeto para el dispositivo. Obtenemos un Localizador de Medios desde el CaptureDeviceInfo objeto que se usa para crear una Fuente de Datos. Se crear un Procesador usando la Fuente de Datos. Se inicia el Procesador para empezar el proceso de captura. Para procesar explícitamente o almacenar los datos de medios capturados, se necesita usar un Procesador. Accedemos a los dispositivos de captura a través de CaptureDeviceManager. El CaptureDeviceManager es el registro central para todos los dispositivos de captura disponibles en JMF. Se puede obtener una lista de los dispositivos de captura disponibles llamando al método CaptureDeviceManager.getDeviceList que es donde aparecerá nuestra webcam. Cada dispositivo es representado por un CaptureDeviceInfo objeto. Para obtener el CaptureDeviceInfo objeto para un dispositivo particular, se llama a CaptureDeviceManager.getDevice: CaptureDeviceInfo deviceinfo = CaptureDeviceManager.getDevice("Nombre del dispositivo"); Como se quiere salvar los datos capturados de la webcam a un archivo, se necesita usamos un Procesador. Se usa un Archivo de Datos para leer datos de medios desde un objeto Procesador para obtener una fuente de datos y enviar los datos a un archivo. Se obtiene la Fuente de Datos desde el Procesador llamando a getdataoutput. 16

17 Se construye escritor al archivo de datos llamando Director.createDataSink. Se pasa la Fuente de Datos y un Localizador de Medios que especifican la localización del archivo a que se quiere escribir. Se utiliza un DataSink para leer datos de salida de los medios de un objeto DataSource del procesador y para enviar los datos a un archivo. Se obtiene la salida DataSource del procesador llamando a getdataoutput. Se construye un DataSink para escribir al archivo llamando Manager.createDataSink. Pasar el DataSource y un MediaLocator que especifique la localización del archivo en el cual se desea escribir. Se llama el DataSink para abrir el archivo y se llama el DataSink para iniciar la escritura de los datos. El formato de los datos escritos al archivo especificado es controlado a través del procesador. Por defecto, un procesador hace salir informaciones en bruto. Para cambiar el tipo contenido de salida de un objeto DataSource del procesador, se utiliza el método de setcontentdescriptor. Nuestra aplicación obtiene la secuencia de imágenes de 10 seg. La almacena en un archivo llamado proy.avi (El formato se puede modificar), ya teniendo dicho archivo se procede a seleccionar el marco deseado para obtener la imagen a procesar. (Ver Anexo 1) 2.3. Procesamiento de Imágenes en Java Java presenta herramientas para manejo de imágenes, como los son Imagen Avanzada de Java y Java 2D. En el presente trabajo se utilizo para la implementación Java 2D. El API 2D de Java introducido en el JDK 1.2 proporciona gráficos avanzados en dos dimensiones, texto, y capacidades de manejo de imágenes para los programas Java a través de la extensión del AWT. Este paquete soporta líneas artísticas, texto e imágenes en un marco de trabajo flexible y lleno de potencia para desarrollar interfaces de usuario, programas de dibujo sofisticados y editores de imágenes. Los formatos que requiere son el jpeg y bmp. El API 2D de Java proporciona: Un modelo de renderizado uniforme para pantallas e impresoras. Un amplio conjunto de gráficos primitivos geométricos, como curvas, rectángulos, y elipses y un mecanismo para renderizar virtualmente cualquier forma geométrica. Mecanismos para detectar esquinas de formas, texto e imágenes. Un modelo de composición que proporciona control sobre cómo se renderizan los objetos solapados. Soporte de color mejorado que facilita su manejo. 17

18 Soporte para imprimir documentos complejos. Al conjunto de atributos de estado asociados con un objeto Graphics2D se le conoce como Contexto de Renderizado de Graphics2D. Para mostrar texto, formas o imágenes, podemos configurar este contexto y luego llamar a uno de los métodos de renderizado de la clase Graphics2D, como draw o fill. El API 2D de Java implementa un nuevo modelo de imagen que soporta la manipulación de imágenes de resolución fija almacenadas en memoria. Una nueva clase Image en el paquete java.awt.image, se puede usar BufferedImage, para manipular datos de una imagen recuperados desde un Archivo o una URL. Por ejemplo, se puede usar un BufferedImage para implementar doble buffer -- los elementos gráficos son dibujados fuera de la pantalla en el BufferedImage y luego son copiados a la pantalla a través de llamadas al método drawimage de Graphics2D. Las clases BufferedImage y BufferedImageOp también permiten realizar una gran variedad de operaciones de filtrado de imágenes. Antes de continuar se explicara la forma en que Java 2D representa las imágenes. Las Imágenes son colecciones de pixeles organizados. Un pixel define la apariencia de una imagen en una simple localización. Una formación de pixeles dos-dimensional es llamado un raster. La apariencia de un pixel puede ser definida directamente o como un índice dentro una tabla de color para la imagen. Las Imágenes en el Java 2D tienen dos componentes primarios: Los datos de imagen cruda (los pixeles). La información necesaria para interpretar los pixeles. Una banda es un componente del espacio de color para una imagen. Por ejemplo, el Rojo, Verde, y componentes Azules son las bandas en una imagen RGB. Un pixel en una imagen de modelo de color directo puede ser pensada como una colección de valores de banda para una simple localización de pantalla. El paquete java.awt de imagen contiene varias herramientas de Modelos de Color, incluyendo esos para empaquetado y representaciones de componente pixel. El modelo de imágenes "modo inmediato" permite manipular y mostrar imágenes de pixeles mapeados cuyos datos están almacenados en memoria. Podemos acceder a los datos de la imagen en una gran variedad de formatos y usar varios tipos de operaciones de filtrado para manipular los datos. 18

19 BufferedImage es la clase clave del API del modo-inmediato. Esta clase maneja una imagen en memoria y proporciona métodos para almacenar, interpretar y dibujar cada dato de pixel. Un BufferedImage puede ser renderizado en un contexto Graphics o un contexto Graphics2D. Un BufferedImage es esencialmente un Image un buffer de datos accesible. Un BufferedImage tiene un ColorModel y un Raster de los datos de la imagen. Figura BufferedImage El ColorModel proporciona una interpretación de color de los datos de los pixeles de la imagen. El Raster representa las coordenadas rectangulares de la imagen, mantiene los datos de la imagen en memoria, y proporciona un mecanismo para crear múltiples subimágenes de un sólo buffer de imagen. El Raster también proporciona métodos para acceder a pixeles específicos dentro de la imagen. El API Java 2D define varias operaciones de filtrado para objetos BufferedImage. Cada operación de proceso de imágenes está incluida en una clase que implementa el interface BufferedImageOp. La manipulación de imágenes se realiza en el método filter. La clase BufferedImageOp en el API Java 2D soporta: Transformación afín. Escalado. Modificación de Aspecto. Combinación Lineal de Bandas. Conversión de color. Convolución. Figura Proceso de Operaciones con Imágenes. 19

20 BufferedImage soporta varios tipos de imagen predefinidos: BYTE_3de TIPO_BGR BYTE_4de TIPO_ABGR BYTE_4de TIPO_ABGR_PRE BYTE_de TIPO_BINARIO BYTE_de TIPO_GRIS BYTE_de TIPO_INDICE COSTUMBRE_de TIPO ESCRIBIR_INT_ARGB_PRE ESCRIBIR_INT_ARGB ESCRIBIR_INT_BGR ESCRIBIR_INT_RGB ESCRIBIR_USHORT_555_RGB ESCRIBIR_USHORT_565_RGB ESCRIBIR_INT_GRIS El paquete de imagen proporciona un par de interfaces que definen operaciones en BufferedImage y Raster objetos: BufferedImageOp y RasterOp. Las herramientas que proporcionan estas clases de interfaces incluyen AffineTransformOp, BandCombineOp, ColorConvertOp, ConvolveOp, LookupOp, RescaleOp, thresholding. Estas clases pueden ser usadas para transformar geométricamente, agudizar, acrecentar contraste, umbral, y colorear imágenes. Detección de Bordes Es una operación que enfatiza afilamiento, cambia en intensidad dentro una imagen. El descubrimiento de borde es comúnmente aplicado en imágenes medicas y mapas. La detección de Borde es usada para aumentar el contraste entre estructuras próximas en una imagen. Figura Detección de Bordes. Lookup Esta operación demuestra la manipulación de la tabla de pixeles. Una operación lookup puede ser usada para alterar componentes individuales de los pixeles. 20

21 Figura Lookup. Afilar La operación de Afilar es utilizada para aumentar o decrementar la intensidad de toda punta. Esto puede ser usado para aumentar el rango dinámico de una imagen neutral, trayendo en detalle una región que aparece en un plano neutral. Figura Operación de Afilamiento. Convolución Es el proceso de hacer más pesado el valor de cada pixel en una imagen con los valores de los pixeles vecinos. La mayoría de los algoritmos de filtrado espacial están basados en las operaciones de Convolución. Este permite poner fuera cada pixel que puede ser afectado por el vecino inmediato en un camino que puede ser matemáticamente especificado con un núcleo. Figura Convolución 21

22 Thresholding Thresholding realiza cambios del color a través de un "límite programadordeterminado," o del umbral, más obvio (similar a cómo las líneas del contorno en un mapa hacen límites de la altitud más obvios). Esta técnica utiliza un valor de umbral especificado, valor mínimo, y valor máximo para controlar los valores componentes del color para cada pixel de una imagen. Los valores del color debajo del umbral se asignan el valor mínimo. Los valores sobre el umbral se asignan el valor máximo. El proceso thresholding se realiza para cada componente del color de cada pixel. Cuando la operación es completa, los componentes del color de los pixeles de la imagen de la destinación contendrán el valor mínimo o el valor máximo. Por ejemplo, considere qué sucede a una imagen cuando una operación thresholding se realiza con un mínimo de 0 y a un máximo de 255. Después de que se procese la imagen, los valores rojos, verdes, y azules de los pixeles serán 0 o 255. Así, la imagen procesada puede contener solamente los colores siguientes: 1.- negro (rojo = 0, verde = 0, azul = 0) 2.- blanco (rojo = 255, verde = 255, azul = 255) 3.- rojo (rojo = 255, verde = 0, azul = 0) 4.- verde (rojo = 0, verde = 255, azul = 0) 5.- azul (rojo = 0, verde = 0, azul = 255) 6.- amarillo (rojo = 255, verde = 255, azul = 0) 7.- magenta (rojo = 255, verde = 0, azul = 255) 8.- ciánico (rojo = 0, verde = 255, azul = 255) Se puede implementar el thresholding usando un LookupOp. En el Anexo 2 se presenta el código de diversas operaciones realizadas en las imágenes de la placa Metodología propuesta para el preprocesamiento Nuestro trabajo consistirá en hacer la implementación en Java utilizando las operaciones anteriores que nos ayudarán a lograr el preprocesamiento deseado de la imagen de la placa. A partir de la imagen ya obtenida por la webcam, comenzamos realizando la conversión a RGB, posteriormente se realiza la operación de velar usando la manipulación de la tabla de pixeles, realizamos un thresholding con umbral 128, realizamos una posterización y afilamiento usando convolución, aplicamos otro thresholding con umbral 180 para pasar a blanco y negro, y por ultimo realizamos otro afilamiento. Ya teniendo la imagen se conservara en un BufferedImage, para que se pueda aplicar algún algoritmo para la detección de los caracteres, separando 22

23 componentes conexas, puesto que el reconocimiento de caracteres se realiza componente a componente. (este proceso no esta incluido en este trabajo). Diagrama Preprocesamiento de imagen de la placa. Imagen de Entrada RGB VELAR AFILAMIENTO POSTERIZACIÓN THRESHOLDING THRESHOLDING IMAGEN PREPROCESADA BLANCO Y NEGRO AFILAMIENTO 2.5. Desarrollo En nuestra aplicación se escogieron las secuencias de operaciones mencionadas anteriormente, pero estas pueden modificarse y tal vez omitir alguna operación, el programa mostrado en el Anexo 3 presenta la opción de cargar la imagen deseada, ya que no se carga directamente para dar la posibilidad de elegir las operaciones a realizar, ya determinando las operaciones deseadas solo se tendrían que hacer pequeñas modificaciones para codificar la secuencia. Ahora bien, iniciamos partir de la imagen de la placa en formato jpeg. (ver figura 2.9). 23

24 Figura Imágenes originales obtenidas por la webcam. En al figura anterior mostramos 4 placas tomadas en diferentes factores de luminosidad con el fin de ver que los resultados obtenidos sean óptimos a pesar de los diversos factores encontrados. Realizamos la conversión a escala RGB, esto se hace mediante la siguiente instrucción: BufferedImage.TYPE_INT_RGB Posteriormente se realiza la operación de velar mediante el siguiente código: El velar float ninth = 1.0f / 9.0f; float[] blurkernel = { ninth, ninth, ninth, ninth, ninth, ninth, ninth, ninth, ninth, ; mops.put("velar", new ConvolveOp( new Kernel(3, 3, blurkernel))); En donde mediante la manipulación de la tabla usando el valor del núcleo como parámetro, se elimina ruido en la imagen obteniendo los siguientes resultados. 24

25 Figura Operación de Velar en las imágenes de la placa. El código crea un ConvolveOp que combina cantidades iguales de la fuente de cada pixel y de sus vecinos. Esta técnica da lugar a un efecto que vela. El núcleo que vela hace la mirada de la imagen más impresionista. Se realiza el thresholding com umbral 128 mediante el uso del siguiente código: Thresholding (umbral) mops.put("umbral 128", createthresholdop(128, 0, 255)); /*el createthresholdop() utiliza un LookupOp para simular una operación thresholding. */ private BufferedImageOp createthresholdop(int threshold, int minimum, int maximum) { short[] thresholdarray = new short[256]; for (int i = 0; i < 256; i++) { if (i < threshold) thresholdarray[i] = (short)minimum; else thresholdarray[i] = (short)maximum; return new LookupOp(new ShortLookupTable(0, thresholdarray), null); Thresholding con el umbral = 128, mínimo = 0, y máximo = 255, obteniendo los siguientes resultados. 25

26 Figura Thresholding con umbral 128. Posteriormente realizamos la operación de posterización que es otro efecto agradable que puede aplicarse con un LookupOp. Esto implica el reducir del número de los colores usados para exhibir una imagen. Un LookupOp puede alcanzar este efecto pasando los valores de la tabla de entrada de los mapas a un sistema pequeño de valores de la salida. A continuación se muestra el código para su implementación: short[] posterize = new short[256]; short[] invert = new short[256]; short[] straight = new short[256]; for (int i = 0; i < 256; i++) { posterize[i] = (short)(i - (i % 32)); invert[i] = (short)(255 - i); straight[i] = (short)i; mops.put("posterización", new LookupOp(new ShortLookupTable(0, posterize),null)); Con esta operación obtenemos el siguiente resultado: Figura Posterización 26

27 El proceso siguente es la operación de afilamiento que es una variación simple en la detección del borde. En este caso, la imagen de fuente se agrega en un núcleo de la detección del borde como sigue: Afilamiento float[] sharpkernel = { 0.0f, -1.0f, 0.0f, -1.0f, 5.0f, -1.0f, 0.0f, -1.0f, 0.0f ; mops.put("sharpen(afilamiento)", new ConvolveOp( new Kernel(3, 3, sharpkernel), ConvolveOp.EDGE_NO_OP, null)); La opción de un núcleo 3 x 3 es algo arbitraria. Se pueden definir núcleos de cualquier tamaño, e incluso no tienen que ser cuadrados. A continuación se muestran los resultados de esta operación. Figura Afilamiento. Posteriormente volvemos aplicarotro thresholding pero ahora con umbral 180, para pasar a escala de grises de la siguiente manera: BufferedImage.GRAY_ESCALE mops.put("umbral 180", createthresholdop(180, 0, 255)); Obteniendo el resultado siguiente: 27

28 Figura Thresholding con umbra 180 en escala de grises. Por ultimo realizamos otro afilamiento y pasamos a blanco y negro obteniendo el siguiente resultado: Figura Imagen final Factores a considerar Como se puede apreciar se debe de considerar la luminosidad, ya que a menor luminosidad es más difícil obtener un buen resultado, esto se aprecia en la placa 118-NGU de la imagen anterior, otro factor a considerar es el fondo de la placa, ya que actualmente se pueden tener diversos colores de fondo en las placas, de acuerdo al fondo se tendría que modificar el programa en el valor de los umbrales para obtener un resultado optimo, por ultimo se debe tomar en cuenta la distancia en que se toma la imagen, ya que a mayor distancia se puede tener más ruido en la imagen. Se recomienda que si se va a utilizar este tipo de webcam se capturen las imágenes con la mayor luminosidad posible, a una distancia de aproximadamente 1 metro, para lograr obtener el mejor resultado. 28

29 CONCLUSIONES Por medio de este trabajo se pueden observar los grandes alcances que se pueden tener mediante el procesamiento de imágenes, gracias a las herramientas que nos ofrece el lenguaje Java con el cual se puede lograr obtener resultados óptimos. Con JMF se pueden realizar una diversidad de aplicaciones, gracias al manejo de sonido y vídeo en nuestro caso se empleo para la captura de las imágenes de la placa mediante la webcam, pero también se podría implementar otros sistemas como de monitoreo, ya se tiene el alcance de establecer un servidor usando JMF, en el cual se pueda establecer el monitoreo de varios estacionamientos desde un solo lugar. Con el procesamiento de imágenes se puede realizar varias mejoras al sistema, ya que se podría combinar con el manejo de vídeo para establecer un sistema de detección de movimiento, y tal vez se más ambiciosos y establecer un reconocimiento del conductor del automóvil. Por ultimo se recomienda que para establecer el sistema se tendría que ver la posibilidad de utilizar sensores para que a cierta distancia de la entrada del estacionamiento se inicie la captura de la imagen de la placa, implementar el algoritmo de detección de caracteres y establecer los parámetros que se manejaran en la base de datos, para realizar una búsqueda eficiente de las placas. 29

30 ANEXO 1 Con estos códigos se reproducen y se guardan los datos capturados de la webcam. Código A1.1 Class CoolCam import java.io.*; import javax.media.*; import javax.media.control.*; import javax.media.datasink.*; import javax.media.format.*; import javax.media.protocol.*; import javax.media.manager; public class CoolCam{ private static boolean debugdevicelist = false; private static String defaultvideodevicename = "STV0680 Camera"; private static String defaultaudiodevicename = "DirectSoundCapture"; private static String defaultvideoformatstring="size=176x144,encoding=rgb,maxdatalength=76032"; private static String defaultaudioformatstring = "linear, hz, 8-bit, mono, unsigned"; private static CaptureDeviceInfo private static CaptureDeviceInfo private static VideoFormat private static AudioFormat capturevideodevice = null; captureaudiodevice = null; capturevideoformat = null; captureaudioformat = null; public static void main(string args[]){ obtener argumentos de linea de comando for (int x = 0; x < args.length; x++){ -dd = debug devices list - mostrar lista de todos dispositivos de medios - y salida if (args[x].tolowercase().compareto("-dd") == 0) debugdevicelist = true; obtener una lista de todos los dispositivos de medios, dispositivos de defecto de busqueda y formato, e imprime el fuera si args[x] = "-dd" Stdout.log("Obtener lista de todos los Dispositivos de medios..."); java.util.vector devicelistvector = CaptureDeviceManager.getDeviceList(null); if (devicelistvector == null){ Stdout.log("... error: lista de de de medios vector son nulos, programa abortado"); System.exit(0); if (devicelistvector.size() == 0){ Stdout.log("... error: lista de dispositivos de medios tamaño de vector es 0, programa abortado"); System.exit(0); 30

31 for (int x = 0; x < devicelistvector.size(); x++){ Despliega los nombres de dispositivos CaptureDeviceInfo deviceinfo = (CaptureDeviceInfo) devicelistvector.elementat(x); String deviceinfotext = deviceinfo.getname(); if (debugdevicelist) Stdout.log("dispositivo " + x + ": " + deviceinfotext); Despliega los formatos de los dispositivos Format deviceformat[] = deviceinfo.getformats(); for (int y = 0; y < deviceformat.length; y++){ Busca por default los dispositivos de video if (capturevideodevice == null) if (deviceformat[y] instanceof VideoFormat) if (deviceinfo.getname().indexof(defaultvideodevicename) >= 0){ capturevideodevice = deviceinfo; Stdout.log(">>> Captura dispositivo de video = " + deviceinfo.getname()); Busca por default el formato de video if (capturevideodevice == deviceinfo) if (capturevideoformat == null) if (DeviceInfo.formatToString(deviceFormat[y]).indexOf(defaultVideoFormatString) >= 0){ capturevideoformat = (VideoFormat) deviceformat[y]; Stdout.log(">>> Captura formato de video = " + DeviceInfo.formatToString(deviceFormat[y])); Busca por default dispositivo de Audio if (captureaudiodevice == null) if (deviceformat[y] instanceof AudioFormat) if (deviceinfo.getname().indexof(defaultaudiodevicename) >= 0){ captureaudiodevice = deviceinfo; Stdout.log(">>> Captura dispositivo de audio = " + deviceinfo.getname()); Busca por default el formato de audio if (captureaudiodevice == deviceinfo) if (captureaudioformat == null) if (DeviceInfo.formatToString(deviceFormat[y]).indexOf(defaultAudioFormatString) >= 0){ captureaudioformat = (AudioFormat) deviceformat[y]; Stdout.log(">>> Captura formato de audio = " + DeviceInfo.formatToString(deviceFormat[y])); if (debugdevicelist) Stdout.log(" - formato: " + DeviceInfo.formatToString(deviceFormat[y])); Stdout.log("... lista completada."); si args[x] = "-dd" terminar ahora if (debugdevicelist) System.exit(0); 31

32 ejecuta la fuente de video MediaLocator videomedialocator = capturevideodevice.getlocator(); DataSource videodatasource = null; try { videodatasource = javax.media.manager.createdatasource(videomedialocator); catch (IOException ie) { Stdout.logAndAbortException(ie); catch (NoDataSourceException nse) { Stdout.logAndAbortException(nse); if (! DeviceInfo.setFormat(videoDataSource, capturevideoformat)) { Stdout.log("Error: incapaz de colocar formato de video - programa abortado"); System.exit(0); ejecuta la fuente de audio MediaLocator audiomedialocator = captureaudiodevice.getlocator(); DataSource audiodatasource = null; try { audiodatasource = javax.media.manager.createdatasource(audiomedialocator); catch (IOException ie) { Stdout.logAndAbortException(ie); catch (NoDataSourceException nse) { Stdout.logAndAbortException(nse); if (! DeviceInfo.setFormat(audioDataSource, captureaudioformat)) { Stdout.log("Error: incapaz de colocar formato de video - programa abortado"); System.exit(0); combinar las dos fuentes de datos DataSource mixeddatasource = null; try { DataSource darray[] = new DataSource[2]; darray[0] = videodatasource; darray[1] = audiodatasource; mixeddatasource=javax.media.manager.createmergingdatasource(darray); catch (IncompatibleSourceException ise) { Stdout.logAndAbortException(ise); crear un procesador nuevo ejecuta la salida del formato de archivo ->> msvideo FileTypeDescriptor outputtype = new FileTypeDescriptor(FileTypeDescriptor.MSVIDEO); ejecuta la salida de formato de datos de audio y video 32

33 Format outputformat[] = new Format[2]; outputformat[0] = new VideoFormat(VideoFormat.INDEO50); outputformat[1] = new AudioFormat(AudioFormat.GSM_MS /* LINEAR */); crea el procesador ProcessorModel processormodel = new ProcessorModel(mixedDataSource, outputformat, outputtype); Processor processor = null; try { processor = Manager.createRealizedProcessor(processorModel); catch (IOException e) { Stdout.logAndAbortException(e); catch (NoProcessorException e) { Stdout.logAndAbortException(e); catch (CannotRealizeException e) { Stdout.logAndAbortException(e); poner la salida del procesador DataSource source = processor.getdataoutput(); crear un protocolo de Fichero Localizador de Medios con la localizacion del fichero en que los bitvan a ser escritos MediaLocator dest = new MediaLocator("file:proy.avi"); crear un datasink para el archivo DataSink datasink = null; MyDataSinkListener datasinklistener = null; try { datasink = Manager.createDataSink(source, dest); datasinklistener = new MyDataSinkListener(); datasink.adddatasinklistener(datasinklistener); datasink.open(); catch (IOException e) { Stdout.logAndAbortException(e); catch (NoDataSinkException e) { Stdout.logAndAbortException(e); catch (SecurityException e) { Stdout.logAndAbortException(e); ahora iniciamos el datasink y el procesador try { datasink.start(); catch (IOException e) { Stdout.logAndAbortException(e); processor.start(); Stdout.log("iniciando captura..."); try { Thread.currentThread().sleep(10000); catch (InterruptedException ie) { captura por 10 seg Stdout.log("... captura realizada"); parar y cerrar el procesador cuando captura... cerrar el datasink cuando EndOfStream evento es recibido... processor.stop(); processor.close(); 33

34 datasinklistener.waitendofstream(10); datasink.close(); Stdout.log("[todo realizado]"); Código A1.2 Class DeviceInfo import java.awt.dimension; import javax.media.*; import javax.media.control.*; import javax.media.format.*; import javax.media.protocol.*; public class DeviceInfo { public static Format formatmatches (Format format, Format supported[] ) { if (supported == null) return null; for (int i = 0; i < supported.length; i++) if (supported[i].matches(format)) return supported[i]; return null; public static boolean setformat(datasource datasource, Format format) { boolean formatapplied = false; FormatControl formatcontrols[] = null; formatcontrols = ((CaptureDevice) datasource).getformatcontrols(); for (int x = 0; x < formatcontrols.length; x++) { if (formatcontrols[x] == null) continue; Format supportedformats[] = formatcontrols[x].getsupportedformats(); if (supportedformats == null) continue; if (DeviceInfo.formatMatches(format, supportedformats)!= null) { formatcontrols[x].setformat(format); formatapplied = true; return formatapplied; 34

35 public static boolean isvideo(format format) { return (format instanceof VideoFormat); public static boolean isaudio(format format) { return (format instanceof AudioFormat); public static String formattostring(format format) { if (isvideo(format)) return videoformattostring((videoformat) format); if (isaudio(format)) return audioformattostring((audioformat) format); return ("--- unknown media device format ---"); public static String videoformattostring(videoformat videoformat) { StringBuffer result = new StringBuffer(); add width x height (size) Dimension d = videoformat.getsize(); result.append("size=" + (int) d.getwidth() + "x" + (int) d.getheight() + ", "); /* try to add color depth if (videoformat instanceof IndexedColorFormat) { IndexedColorFormat f = (IndexedColorFormat) videoformat; result.append("color depth=" + f.getmapsize() + ", "); */ add encoding result.append("encoding=" + videoformat.getencoding() + ", "); add max data length result.append("maxdatalength=" + videoformat.getmaxdatalength() + ""); return result.tostring(); public static String audioformattostring(audioformat audioformat) { 35

36 StringBuffer result = new StringBuffer(); short workaround result.append(audioformat.tostring().tolowercase()); return result.tostring(); public class Stdout { public static void log(string msg) { System.out.println(msg); public static void logandabortexception(exception e) { log("" + e); flush(); System.exit(0); public static void logandaborterror(error e) { log("" + e); flush(); System.exit(0); public static void flush() { System.out.flush(); ANEXO 2 Códigos de operaciones en Java para el procesamiento de las imágenes de las placas. Código A2.1 En escala RGB <html> 36

37 <head> <title> Procesamiento de Imagen </title> </head> <body> <h1>informacion del Proyecto</h1> <hr> <font size=+1> <strong>proyecto: </strong>preprocesamiento de Imagenes<br> <strong>autor: </strong>ramírez Segura Aaron David<br> <strong>compañia: </strong> Univesidad Autónoma Metropolitana Unidad Iztapalapa<br> <strong>descripción: </strong> Preprocesamiento de Imagen obtenida por medio de webcam, para el reconocimiento de caracteres. En esta página se pueden observar 4 de las diversas operaciones realizadas en imagenes usando lenguaje Java<hr> <br> </font> <br><br> <center> <applet codebase = "." code = "PImagen1.class" name = "TestApplet" width = "400" height = "400" hspace = "0" vspace = "0" align = "top" > </applet> ProcessImg.java Copyright (c) 2002, Aaron David Ramírez Segura Compilador: javac 1.3, Java 2 SDK Autor: AAron David Ramírez Segura Creacion: 10-Ago :34: import java.awt.*; import java.awt.event.*; import javax.swing.*; 37

38 import java.awt.image.*; import java.awt.geom.affinetransform; import java.awt.font.textlayout; import java.awt.event.windowevent; import java.awt.event.windowlistener; import java.awt.event.windowadapter; import java.net.url; public class PImagen1 extends JApplet { private BufferedImage bi[]; public static final float[] SHARPEN3x3_3 = { 0.f, -1.f, 0.f, -1.f, 5.f, -1.f, 0.f, -1.f, 0.f; float[] elements = { 0.0f, -1.0f, 0.0f, -1.0f, 4.f, -1.0f, 0.0f, -1.0f, 0.0f; public void init() { setbackground(color.white); bi = new BufferedImage[4]; String s[] = { "placa5.jpg", "placa5.jpg", "placa5.jpg", "placa5.jpg"; for ( int i = 0; i < bi.length; i++ ) { Image img = getimage(geturl(s[i])); try { MediaTracker tracker = new MediaTracker(this); tracker.addimage(img, 0); tracker.waitforid(0); catch ( Exception e ) { int iw = img.getwidth(this); int ih = img.getheight(this); bi[i] = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_RGB); Graphics2D big = bi[i].creategraphics(); big.drawimage(img,0,0,this); public void paint(graphics g) { Graphics2D g2 = (Graphics2D) g; g2.setrenderinghint(renderinghints.key_antialiasing, RenderingHints.VALUE_ANTIALIAS_ON); g2.setrenderinghint(renderinghints.key_rendering, RenderingHints.VALUE_RENDER_QUALITY); int w = getsize().width; int h = getsize().height; g2.setcolor(color.black); float[][] data = {{0.1f, 0.1f, 0.1f, low-pass filter 0.1f, 0.2f, 0.1f, 0.1f, 0.1f, 0.1f, SHARPEN3x3_3; String thedesc[] = { "Convolución LowPass", "Convolución Sharpen", "Manipulación de la Tabla", "Operacion Re-escalar"; for ( int i = 0; i < bi.length; i++ ) { int iw = bi[i].getwidth(this); int ih = bi[i].getheight(this); 38

39 int x = 0, y = 0; AffineTransform at = new AffineTransform(); at.scale((w-14)/2.0/iw, (h-34)/2.0/ih); BufferedImageOp biop = null; BufferedImage bimg = new BufferedImage(iw,ih,BufferedImage.TYPE_INT_RGB); switch ( i ) { case 0 : case 1 : x = i==0?5:w/2+3; y = 15; Kernel kernel = new Kernel(3,3,data[i]); ConvolveOp cop = new ConvolveOp(kernel,ConvolveOp.EDGE_NO_OP,null); cop.filter(bi[i],bimg); biop=new AffineTransformOp(at,AffineTransformOp.TYPE_NEAREST_NEIGHBOR); break; case 2 : x = 5; y = h/2+15; byte chlut[] = new byte[256]; for ( int j=0;j<200 ;j++ ) chlut[j]=(byte)(256-j); ByteLookupTable blut=new ByteLookupTable(0,chlut); LookupOp lop = new LookupOp(blut, null); lop.filter(bi[i],bimg); biop = new AffineTransformOp(at,AffineTransformOp.TYPE_BILINEAR); break; case 3 : x = w/2+3; y = h/2+15; RescaleOp rop = new RescaleOp(1.1f,20.0f, null); rop.filter(bi[i],bimg); biop = new AffineTransformOp(at,AffineTransformOp.TYPE_BILINEAR); break; g2.drawimage(bimg,biop,x,y); TextLayout tl = new TextLayout(theDesc[i], g2.getfont(),g2.getfontrendercontext()); tl.draw(g2, (float) x, (float) y-4); protected URL geturl(string filename) { URL codebase = this.getcodebase(); URL url = null; try { url = new URL(codeBase, filename); catch (java.net.malformedurlexception e) { System.out.println("No se pudo crear la Imagen "+ "especifique URL"); return null; return url; public static void main(string s[]) { JFrame f = new JFrame("PImagen1"); f.addwindowlistener(new WindowAdapter() { public void windowclosing(windowevent e) {System.exit(0);); JApplet applet = new PImagen1(); f.getcontentpane().add("center", applet); applet.init(); f.pack(); f.setsize(new Dimension(550,550)); 39

40 f.show(); Salida del programa: Figura A2.1.- Salida del programa A2.1 Código A2.2 En escala RGB <html> <head> <title> Procesamiento de Imagen </title> </head> <body> <h1>informacion del Proyecto</h1> <hr> <font size=+1> <strong>proyecto: </strong>preprocesamiento de Imagenes<br> <strong>autor: </strong>ramírez Segura Aaron David<br> <strong>compañia: </strong> Univesidad Autónoma Metropolitana Unidad Iztapalapa<br> <strong>descripción: </strong> Preprocesamiento de Imagen obtenida por medio de webcam, para el reconocimiento de caracteres. En esta página se pueden observar otras 4 de las diversas 40

41 operaciones realizadas en imagenes usando lenguaje Java<hr> <br> </font> <br><br> <center> <applet codebase = "." code = "PImagen2.class" name = "TestApplet" width = "400" height = "400" hspace = "0" vspace = "0" align = "top" > </applet> </center> <A href="pimagen22.html">ver siguientes operaciones</a> </body> </html> ProcessImg2.java Copyright (c) 2002, Aaron David Ramírez Segura Compilador: javac 1.3, Java 2 SDK Autor: AAron David Ramírez Segura Creacion: 10-Ago :34: import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.awt.image.*; import java.awt.geom.affinetransform; import java.awt.font.textlayout; import java.awt.event.windowevent; import java.awt.event.windowlistener; import java.awt.event.windowadapter; import java.net.url; public class PImagen2 extends JApplet { private BufferedImage bi[]; public static final float[] SHARPEN3x3_3 = { 0.f, -1.f, 0.f, 41

42 -1.f, 5.f, -1.f, 0.f, -1.f, 0.f; float[] elements = { 0.0f, -1.0f, 0.0f, float[] elements2 = { 0.0f, -1.0f, 0.0f, -1.0f, 4.f, -1.0f, 0.0f, -1.0f, 0.0f; -1.0f, 7.f, -1.0f, 0.0f, -1.0f, 0.0f; public void init() { setbackground(color.white); bi = new BufferedImage[4]; String s[] = { "placa5.jpg", "placa5.jpg", "placa5.jpg", "placa5.jpg"; for ( int i = 0; i < bi.length; i++ ) { Image img = getimage(geturl(s[i])); try { MediaTracker tracker = new MediaTracker(this); tracker.addimage(img, 0); tracker.waitforid(0); catch ( Exception e ) { int iw = img.getwidth(this); int ih = img.getheight(this); bi[i] = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_RGB); Graphics2D big = bi[i].creategraphics(); big.drawimage(img,0,0,this); public void paint(graphics g) { Graphics2D g2 = (Graphics2D) g; g2.setrenderinghint(renderinghints.key_antialiasing, RenderingHints.VALUE_ANTIALIAS_ON); g2.setrenderinghint(renderinghints.key_rendering, RenderingHints.VALUE_RENDER_QUALITY); int w = getsize().width; int h = getsize().height; g2.setcolor(color.black); float[][] data = {{0.2f, 0.2f, 0.2f, low-pass filter 0.2f, 1.4f, 0.2f, 0.2f, 0.2f, 0.2f, SHARPEN3x3_3; String thedesc[] = { "Convolución LowPass(Modificado)", "Convolve Sharpen", "Agudizado", "Detección de Borde"; for ( int i = 0; i < bi.length; i++ ) { int iw = bi[i].getwidth(this); int ih = bi[i].getheight(this); int x = 0, y = 0; AffineTransform at = new AffineTransform(); at.scale((w-14)/2.0/iw, (h-34)/2.0/ih); BufferedImageOp biop = null; BufferedImage bimg = new BufferedImage(iw,ih,BufferedImage.TYPE_INT_RGB); 42

43 switch ( i ) { case 0 : case 1 : x = i==0?5:w/2+3; y = 15; Kernel kernel = new Kernel(3,3,data[i]); ConvolveOp cop = new ConvolveOp(kernel,ConvolveOp.EDGE_NO_OP,null); cop.filter(bi[i],bimg); biop=new AffineTransformOp(at,AffineTransformOp.TYPE_NEAREST_NEIGHBOR); break; case 2 : x = 5; y = h/2+15; Kernel kernel3 = new Kernel(3, 3, elements2); ConvolveOp cop3 = new ConvolveOp(kernel3, ConvolveOp.EDGE_NO_OP, null); cop3.filter(bi[i],bimg); biop = new AffineTransformOp(at,AffineTransformOp.TYPE_BILINEAR); break; case 3 : x = w/2+3; y = h/2+15; Kernel kernel2 = new Kernel(3, 3, elements); ConvolveOp cop2 = new ConvolveOp(kernel2, ConvolveOp.EDGE_NO_OP, null); cop2.filter(bi[i],bimg); biop = new AffineTransformOp(at,AffineTransformOp.TYPE_BILINEAR); break; g2.drawimage(bimg,biop,x,y); TextLayout tl = new TextLayout(theDesc[i], g2.getfont(),g2.getfontrendercontext()); tl.draw(g2, (float) x, (float) y-4); protected URL geturl(string filename) { URL codebase = this.getcodebase(); URL url = null; try { url = new URL(codeBase, filename); catch (java.net.malformedurlexception e) { System.out.println("No se pudo crear la Imagen "+ "especifique URL"); return null; return url; public static void main(string s[]) { JFrame f = new JFrame("PImagen2"); f.addwindowlistener(new WindowAdapter() { public void windowclosing(windowevent e) {System.exit(0);); JApplet applet = new PImagen2(); f.getcontentpane().add("center", applet); applet.init(); f.pack(); f.setsize(new Dimension(550,550)); f.show(); 43

44 Salida del programa: Figura A2.2.- Salida del programa A2.2 Código A2.3 En GRAY ESCALE <html> <head> <title> Procesamiento de Imagen </title> </head> <body> <h1>informacion del Proyecto</h1> <hr> <font size=+1> <strong>proyecto: </strong>preprocesamiento de Imagenes<br> <strong>autor: </strong>ramírez Segura Aaron David<br> <strong>compañia: </strong> Univesidad Autónoma Metropolitana Unidad Iztapalapa<br> <strong>descripción: </strong> Preprocesamiento de Imagen obtenida por medio de webcam, para el reconocimiento de caracteres. En esta página se pueden observar las mismas 4 imagenes en escala de gris usando lenguaje Java<hr> <br> </font> 44

45 <br><br> <center> <applet codebase = "." code = "PImagen11.class" name = "TestApplet" width = "400" height = "400" hspace = "0" vspace = "0" align = "top" > </applet> ProcessImg.java Copyright (c) 2002, Aaron David Ramírez Segura Compilador: javac 1.3, Java 2 SDK Autor: AAron David Ramírez Segura Creacion: 10-Ago :34: import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.awt.image.*; import java.awt.geom.affinetransform; import java.awt.font.textlayout; import java.awt.event.windowevent; import java.awt.event.windowlistener; import java.awt.event.windowadapter; import java.net.url; public class PImagen11 extends JApplet { private BufferedImage bi[]; public static final float[] SHARPEN3x3_3 = { 0.f, -1.f, 0.f, -1.f, 5.f, -1.f, 0.f, -1.f, 0.f; float[] elements = { 0.0f, -1.0f, 0.0f, -1.0f, 4.f, -1.0f, 0.0f, -1.0f, 0.0f; public void init() { 45

46 setbackground(color.white); bi = new BufferedImage[4]; String s[] = { "placa5.jpg", "placa5.jpg", "placa5.jpg", "placa5.jpg"; for ( int i = 0; i < bi.length; i++ ) { Image img = getimage(geturl(s[i])); try { MediaTracker tracker = new MediaTracker(this); tracker.addimage(img, 0); tracker.waitforid(0); catch ( Exception e ) { int iw = img.getwidth(this); int ih = img.getheight(this); bi[i] = new BufferedImage(iw, ih, BufferedImage.TYPE_BYTE_GRAY); Graphics2D big = bi[i].creategraphics(); big.drawimage(img,0,0,this); public void paint(graphics g) { Graphics2D g2 = (Graphics2D) g; g2.setrenderinghint(renderinghints.key_antialiasing, RenderingHints.VALUE_ANTIALIAS_ON); g2.setrenderinghint(renderinghints.key_rendering, RenderingHints.VALUE_RENDER_QUALITY); int w = getsize().width; int h = getsize().height; g2.setcolor(color.black); float[][] data = {{0.1f, 0.1f, 0.1f, low-pass filter 0.1f, 0.2f, 0.1f, 0.1f, 0.1f, 0.1f, SHARPEN3x3_3; String thedesc[] = { "Convolución LowPass", "Convolución Sharpen", "Manipulación de la Tabla", "Operacion Re-escalar"; for ( int i = 0; i < bi.length; i++ ) { int iw = bi[i].getwidth(this); int ih = bi[i].getheight(this); int x = 0, y = 0; AffineTransform at = new AffineTransform(); at.scale((w-14)/2.0/iw, (h-34)/2.0/ih); BufferedImageOp biop = null; BufferedImage bimg = new BufferedImage(iw,ih,BufferedImage.TYPE_INT_RGB); switch ( i ) { case 0 : case 1 : x = i==0?5:w/2+3; y = 15; Kernel kernel = new Kernel(3,3,data[i]); ConvolveOp cop = new ConvolveOp(kernel,ConvolveOp.EDGE_NO_OP,null); cop.filter(bi[i],bimg); biop=new AffineTransformOp(at,AffineTransformOp.TYPE_NEAREST_NEIGHBOR); break; case 2 : x = 5; y = h/2+15; byte chlut[] = new byte[256]; for ( int j=0;j<200 ;j++ ) chlut[j]=(byte)(256-j); ByteLookupTable blut=new ByteLookupTable(0,chlut); 46

47 LookupOp lop = new LookupOp(blut, null); lop.filter(bi[i],bimg); biop = new AffineTransformOp(at,AffineTransformOp.TYPE_BILINEAR); break; case 3 : x = w/2+3; y = h/2+15; RescaleOp rop = new RescaleOp(1.1f,20.0f, null); rop.filter(bi[i],bimg); biop = new AffineTransformOp(at,AffineTransformOp.TYPE_BILINEAR); break; g2.drawimage(bimg,biop,x,y); TextLayout tl = new TextLayout(theDesc[i], g2.getfont(),g2.getfontrendercontext()); tl.draw(g2, (float) x, (float) y-4); protected URL geturl(string filename) { URL codebase = this.getcodebase(); URL url = null; try { url = new URL(codeBase, filename); catch (java.net.malformedurlexception e) { System.out.println("No se pudo crear la Imagen "+ "especifique URL"); return null; return url; public static void main(string s[]) { JFrame f = new JFrame("PImagen1"); f.addwindowlistener(new WindowAdapter() { public void windowclosing(windowevent e) {System.exit(0);); JApplet applet = new PImagen11(); f.getcontentpane().add("center", applet); applet.init(); f.pack(); f.setsize(new Dimension(550,550)); f.show(); Salida del programa: 47

48 Figura A2.3.- Salida del programa A2.3 Código A2.4 En GRAY ESCALE </title> </head> <body> <h1>informacion del Proyecto</h1> <hr> <font size=+1> <strong>proyecto: </strong>preprocesamiento de Imagenes<br> <strong>autor: </strong>ramírez Segura Aaron David<br> <strong>compañia: </strong> Univesidad Autónoma Metropolitana Unidad Iztapalapa<br> <strong>descripción: </strong> Preprocesamiento de Imagen obtenida por medio de webcam, para el reconocimiento de caracteres. En esta página se pueden observar en escala de grises usando lenguaje Java<hr> <br> </font> <br><br> <center> <applet codebase = "." code = "PImagen22.class" name = "TestApplet" width = "400" height = "400" hspace = "0" 48

49 vspace = "0" align = "top" > </applet> </center> <A href="pimagen1.html">regresar al Inicio</A> </body> </html> ProcessImg2.java Copyright (c) 2002, Aaron David Ramírez Segura Compilador: javac 1.3, Java 2 SDK Autor: AAron David Ramírez Segura Creacion: 10-Ago :34: import java.awt.*; import java.awt.event.*; import javax.swing.*; import java.awt.image.*; import java.awt.geom.affinetransform; import java.awt.font.textlayout; import java.awt.event.windowevent; import java.awt.event.windowlistener; import java.awt.event.windowadapter; import java.net.url; public class PImagen22 extends JApplet { private BufferedImage bi[]; public static final float[] SHARPEN3x3_3 = { 0.f, -1.f, 0.f, -1.f, 5.f, -1.f, 0.f, -1.f, 0.f; float[] elements = { 0.0f, -1.0f, 0.0f, float[] elements2 = { 0.0f, -1.0f, 0.0f, -1.0f, 4.f, -1.0f, 0.0f, -1.0f, 0.0f; -1.0f, 7.f, -1.0f, 0.0f, -1.0f, 0.0f; 49

50 public void init() { setbackground(color.white); bi = new BufferedImage[4]; String s[] = { "placa5.jpg", "placa5.jpg", "placa5.jpg", "placa5.jpg"; for ( int i = 0; i < bi.length; i++ ) { Image img = getimage(geturl(s[i])); try { MediaTracker tracker = new MediaTracker(this); tracker.addimage(img, 0); tracker.waitforid(0); catch ( Exception e ) { int iw = img.getwidth(this); int ih = img.getheight(this); bi[i] = new BufferedImage(iw, ih, BufferedImage.TYPE_BYTE_GRAY); Graphics2D big = bi[i].creategraphics(); big.drawimage(img,0,0,this); public void paint(graphics g) { Graphics2D g2 = (Graphics2D) g; g2.setrenderinghint(renderinghints.key_antialiasing, RenderingHints.VALUE_ANTIALIAS_ON); g2.setrenderinghint(renderinghints.key_rendering, RenderingHints.VALUE_RENDER_QUALITY); int w = getsize().width; int h = getsize().height; g2.setcolor(color.black); float[][] data = {{0.2f, 0.2f, 0.2f, low-pass filter 0.2f, 1.4f, 0.2f, 0.2f, 0.2f, 0.2f, SHARPEN3x3_3; String thedesc[] = { "Convolución LowPass(Modificado)", "Convolve Sharpen", "Agudizado", "Detección de Borde"; for ( int i = 0; i < bi.length; i++ ) { int iw = bi[i].getwidth(this); int ih = bi[i].getheight(this); int x = 0, y = 0; AffineTransform at = new AffineTransform(); at.scale((w-14)/2.0/iw, (h-34)/2.0/ih); BufferedImageOp biop = null; BufferedImage bimg = new BufferedImage(iw,ih,BufferedImage.TYPE_INT_RGB); switch ( i ) { case 0 : case 1 : x = i==0?5:w/2+3; y = 15; Kernel kernel = new Kernel(3,3,data[i]); ConvolveOp cop = new ConvolveOp(kernel,ConvolveOp.EDGE_NO_OP,null); cop.filter(bi[i],bimg); biop=new AffineTransformOp(at,AffineTransformOp.TYPE_NEAREST_NEIGHBOR); break; case 2 : 50

51 x = 5; y = h/2+15; Kernel kernel3 = new Kernel(3, 3, elements2); ConvolveOp cop3 = new ConvolveOp(kernel3, ConvolveOp.EDGE_NO_OP, null); cop3.filter(bi[i],bimg); biop = new AffineTransformOp(at,AffineTransformOp.TYPE_BILINEAR); break; case 3 : x = w/2+3; y = h/2+15; Kernel kernel2 = new Kernel(3, 3, elements); ConvolveOp cop2 = new ConvolveOp(kernel2, ConvolveOp.EDGE_NO_OP, null); cop2.filter(bi[i],bimg); biop = new AffineTransformOp(at,AffineTransformOp.TYPE_BILINEAR); break; g2.drawimage(bimg,biop,x,y); TextLayout tl = new TextLayout(theDesc[i], g2.getfont(),g2.getfontrendercontext()); tl.draw(g2, (float) x, (float) y-4); protected URL geturl(string filename) { URL codebase = this.getcodebase(); URL url = null; try { url = new URL(codeBase, filename); catch (java.net.malformedurlexception e) { System.out.println("No se pudo crear la Imagen "+ "especifique URL"); return null; return url; public static void main(string s[]) { JFrame f = new JFrame("PImagen22"); f.addwindowlistener(new WindowAdapter() { public void windowclosing(windowevent e) {System.exit(0);); JApplet applet = new PImagen22(); f.getcontentpane().add("center", applet); applet.init(); f.pack(); f.setsize(new Dimension(550,550)); f.show(); Salida del programa: 51

52 Figura A2.4.- Salida del programa A2.4 ANEXO 3 Código final de la aplicación del preprocesamiento de Imagen import java.awt.*; 52