construcciÓn de un prototipo para el …

CONSTRUCCIÓN DE UN PROTOTIPO PARA EL PROCESAMIENTO AUTOMÁTICO DE IMÁGENES DE

GELES RAPD.

CARLOS DAVID SELIGMANN TRUJILLO

TRABAJO DE GRADO

DIRECTOR CLAUDIA LUCIA JIMENEZ GUARIN

Doctora en Informática INPG

UNIVERSIDAD DE LOS ANDES FACULTAD DE INGENIERIA

DEPARTAMENTO INGENIERIA DE SISTEMAS Y COMPUTACION

BOGOTA 2003

ISC-2003-1-50

2

AGRADECIMIENTOS

A Claudia Lucía Jiménez, directora del trabajo por toda la ayuda prestada, por su paciencia y comprensión y palabras de ánimo, sobretodo en momentos de dificultad. También por las oportunas y veraces correcciones, y valiosas orientaciones acerca del manuscrito. A Carlos Jaramillo, por lo importante asesoría en todo la parte de biología molecular, además por el apoyo, interés y su amistad. A María del Pilar Villamil, asesora en ciclo terminal 1, quien además me contactó en un Claudia Jiménez, y por ende hizo posible la realización de este trabajo. También por su apoyo, y palabras de ánimo momentos de dificultad. A mis padres, por el incondicional apoyo, paciencia, cariño, toda la disposición para ayudar. A mi hermano, por el apoyo y ayuda A mis amigos muy especialmente a Verónica Fajardo, quien me ayudó a lo largo del proceso de ciclo terminal 1. A Marta Leticia Gutiérrez y Takuro Ishikawa, por la ayuda, en el momento de aclarar las ideas.

ISC-2003-1-50

3

CONTENIDO

1. INTRODUCCIÓN............................................................................................................7

1.1. OBJETIVO GENERAL ..........................................................................................................................................8

1.2. OBJETIVOS ESPECÍFICOS ................................................................................................................................8

2. ESTADO DEL ARTE...................................................................................................10

2.1. LOS GELES RAPD [RW03]............................................................................................................................... 10

2.2. LOS PROGRAMAS EXISTENTES ................................................................................................................. 12

2.3. EL PROCESAMIENTO DE IMÁGENES [GW92]...................................................................................... 14

3. ANÁLISIS DEL PROBLEMA, ALTERNATIVAS DE SOLUCIÓN.......................17

3.1. EL PROBLEMA ..................................................................................................................................................... 17

3.2. LA SOLUCIÓN PLANTEADA.......................................................................................................................... 17

4. ANALISIS DE REQUERIMIENTOS Y DISEÑO....................................................19

4.1. ANALISIS DE REQUERIMIENTOS .............................................................................................................. 19 4.1.1. USUARIOS DE LA HERRAMIENTA ........................................................................................................19 4.1.2. METAS...............................................................................................................................................................19 4.1.3. ATRIBUTOS DEL SISTEMA .......................................................................................................................20 4.1.4. REQUERIMIENTOS FUNCIONALES .......................................................................................................20

4.1.5.1. Diagrama de casos de uso.......................................................................................................................20 4.1.5.2. Análisis de Casos De Uso.......................................................................................................................21 4.1.5.3. Reglas de Negocio....................................................................................................................................24

4.1.5. REQUERIMIENTOS NO FUNCIONALES ...............................................................................................24 4.1.6.1. Requisitos De Interfaz .............................................................................................................................25 4.1.6.2. Restricciones De Diseño.........................................................................................................................27 4.1.6.3. Restricciones De Implementación.........................................................................................................28

4.2. DISEÑO..................................................................................................................................................................... 29 4.2.1. DISEÑO DE ARQUITECTURA Y MUNDO DEL PROBLEMA..........................................................29

4.2.1.1. La clase pInterfaz.....................................................................................................................................30 4.2.1.2. La clase EdgeDetector.............................................................................................................................32 4.2.1.3. La clase Pgrabber .....................................................................................................................................34 4.2.1.4. La clase Gel...............................................................................................................................................34 4.2.1.5. La clase Carril ...........................................................................................................................................35 4.2.1.6. La clase Banda..........................................................................................................................................35

4.2.2. DIAGRAMAS DE SECUENCIA ..................................................................................................................36

ISC-2003-1-50

4

4.2.3. DIAGRAMAS DE ESTADOS DE INTERACCIÓN.................................................................................38 4.2.4. DISEÑO GUI.....................................................................................................................................................39

5. IMPLEMENTACIÓN ....................................................................................................41

5.1. PANORAMA ........................................................................................................................................................... 41

5.2. ARQUITECTURA................................................................................................................................................. 42

5.3. ALCANCE DEL SIS TEMA ................................................................................................................................ 42

5.4. HEURÍSTICAS ....................................................................................................................................................... 49 5.4.1. PARA LA DETECCIÓN DE CARRILES ...................................................................................................49 5.4.2. PARA LA DETECCIÓN DE BANDAS ......................................................................................................50

5.5. ESTRUCTURA DE DIRECTORIOS Y ARCHIVOS ................................................................................. 51

5.6. OPCIONES CONFIGURABLES. ..................................................................................................................... 52

6. RESULTADOS Y PRUEBAS.................................................................................53

6.1. IMÁGENES FUENTES ........................................................................................................................................ 53

6.2. CONTRASTE. ......................................................................................................................................................... 53

6.3. RESULTADOS ....................................................................................................................................................... 55 6.3.1 DETECCIÓN DE CARRILES ........................................................................................................................56

6.3.1.1. Carriles – Sensibilidad.............................................................................................................................56 6.3.1.2. Carriles - Contraste..................................................................................................................................58

6.3.2. DETECCIÓN DE BANDAS ..........................................................................................................................59 6.3.2.1. Bandas - Sensibilidad ..............................................................................................................................59 6.3.2.2. Bandas - Contraste...................................................................................................................................61

6.4. ANÁLISIS ................................................................................................................................................................. 63 6.4.1. LOGROS DEL PROTOTIPO.........................................................................................................................63 6.4.2. PROBLEMAS DEL PROTOTIPO ................................................................................................................64

7. CONCLUSIONES Y TRABAJO FUTURO...........................................................66

MATERIAL DE REFERENCIA.......................................................................................68

GLOSARIO BIOLOGIA MOLECULAR ........................................................................70

ISC-2003-1-50

5

LISTA DE TABLAS

Tabla 2.1. Tabla comparativa de algunos de los programas utilizados para el

tratamiento de imágenes de geles. ................................................13 Tabla 4.1. Atributos del sistema.....................................................................20 Tabla 4.2. Caso de uso C.1. (Procesar imagen)................................................21 Tabla 4.3. Caso de uso C.2. (Establecer patrón)...............................................22 Tabla 4.4. Caso de uso C.3. (Buscar patrón)....................................................23 Tabla 4.5. Funciones del sistema ...................................................................24 Tabla 4.6. Restricciones de interacción ...........................................................25 Tabla 4.7. Restricciones de visualización. ........................................................25 Tabla 4.8. Restricciones de formato................................................................25 Tabla 4.9. Restricciones de color de imagen....................................................26 Tabla 4.10. Restricciones de composición de la imagen. ...................................26 Tabla 6.1. Detección de carriles con Contraste 160 y sensibilidad variable ..........56 Tabla 6.2. Detección de carriles con Contraste 140 y sensibilidad variable ..........57 Tabla 6.3. Detección de carriles con Contraste 128 y sensibilidad variable ..........57 Tabla 6.4. Detección de carriles con sensibilidad 8 y contraste variable ..............58 Tabla 6.5. Detección de carriles con sensibilidad 6 y contraste variable ..............58 Tabla 6.6. Detección de carriles con sensibilidad 4 y contraste variable ..............59 Tabla 6.7. Detección de bandas con Contraste 160 y sensibilidad variable ..........60 Tabla 6.8. Detección de bandas con Contraste 140 y sensibilidad variable ..........60 Tabla 6.9. Detección de bandas con Contraste 140 y sensibilidad variable ..........61 Tabla 6.10. Detección de bandas con sensibilidad 8 y contraste variable.............62 Tabla 6.11. Detección de bandas con sensibilidad 6 y contraste variable.............62 Tabla 6.12. Detección de bandas con sensibilidad 4 y contraste variable.............63

ISC-2003-1-50

6

LISTA DE FIGURAS

Figura 2.1. Ejemplo de un gel de un RAPD.....................................................11 Figura 2.2. Explicación de la estructura del gel RAPD. A. carril. B. banda ...........11 Figura 2.3. Máscara general de 3x3...............................................................15 Figura 2.4. Máscaras de Sobel, usadas para la detección de bordes de

imágenes: a. Máscara utilizada para detectar bordes verticales. b. Máscara utilizada para detectar bordes horizontales ........................16

Figura 2.5. Máscara usada para calcular el laplaciano. ......................................16 Figura 4.1 diagrama de casos de uso del sistema.............................................20 Figura 4.2. Restricciones de composición: a. imagen no aceptable b. imagen

aceptable. ..................................................................................26 Figura 4.3. Modelo conceptual .......................................................................29 Figura 4.4. Diagrama de paquetes .................................................................30 Figura 4.5. Paquete GUI................................................................................30 Figura 4.6. Clase pInterfaz ............................................................................31 Figura 4.7. Paquete Core ..............................................................................32 Figura 4.8. Clase EdgeDetector ......................................................................32 Figura 4.9. Clase Pgrabber ............................................................................33 Figura 4.10. Paquete Model ...........................................................................34 Figura 4.11. Diagrama de secuencia del CU Procesar imagen ............................36 Figura 4.12. Diagrama de secuencia del CU Establecer patrón ...........................37 Figura 4.13. Diagrama de secuencia del CU Buscar patrón ................................37 Figura 4.13. Diagramas de estados de interacción de casos de uso. Los

estados son: 1. principal, 2.desplegar resultados.............................38 Figura 4.14. Diseño GUI................................................................................39 Figura 4.15. Resultado del proceso sobre una imagen de un gel. .......................39 Figura 4.16. Este es el archivo de texto que queda grabado. .............................40 Figura 5.1. Mascaras de Sobel usadas para el preprocesamiento: a. detección

de bordes horizontal izquierdo y b. derecho....................................43 Figura 5.2. Progresión de imágenes en memoria, donde se resaltan con

diferentes colores los candidatos a ser principio y final de carril. a. original, b y c bordes detectados, c y d binarización, f y g posibles bordes de carril...........................................................................45

Figura 5.3. Mascaras de Sobel usadas para el preprocesamiento: a. detección de bordes vertical hacia arriba y b. hacia abajo...............................46

Figura 5.4. Progresión de imágenes en memoria, donde se resaltan con diferentes colores los candidatos a ser principio y final de bandas. a. original, b y c bordes detectados, c y d binarización, f y g posibles bordes de banda. ............................................................48

Figura 5.5. Estructura de directorios de la raiz del prototipo..............................51

ISC-2003-1-50

7

1. INTRODUCCIÓN La biología es la rama de la ciencia que se encarga del estudio de los seres vivos. El término biología viene del griego bio (ser vivo) y logos (tratado o estudio). Con el actual desarrollo y evolución de las ciencias biológicas es difícil delimitar el ámbito de trabajo de esta ciencia. Así, además de la Botánica y la Zoología, consideradas tradicionalmente herederas del saber biológico, se han venido a sumar otras tantas, como son la Fisiología, la Genética e incluso, en estos últimos años, la inteligencia artificial y las neurociencias. Según Carlos Jaramillo [JAR03], profesor-investigador del CIMPAT —Centro de Investigación en Microbiología y Parasitología Tropical de la Universidad de Los Andes—, existen varias versiones acerca de la biología molecular: (a) que es una ciencia independiente y (b) que no es en sí misma una ciencia, sino más bien un conjunto de técnicas instrumentales y de laboratorio, que consisten en la visión de la vida en función de las interacciones que causan sus átomos y moléculas constituyentes. Las técnicas de biología molecular tienen como fin el aislamiento y caracterización de estas moléculas para explicar el funcionamiento integrado del ser vivo. La Biología y la Ciencia Computacional han sido dos campos distintos. Sin embargo, con los recientes y rápidos desarrollos en Biología Molecular especialmente los relacionados con la secuenciación del ADN (Acido Desoxiribonucleico) o código genético de las especies y el estudio de estructuras proteicas, los biólogos han recurrido a científicos de la computación en busca de métodos eficientes para analizar las vastas cantidades de datos de los cuales se va disponiendo. Esta nueva disciplina se conoce como Bioinformática [UCL03]. Una de las muchas técnicas usadas en biología molecular es la de RAPD (Random Amplified Polymorphic DNA - ADN polimórfico amplificado al azar) que es un ensayo usado en biología molecular, en el que se identifican polimorfismos (variación genética) basados en la amplificación de segmentos de ADN al azar utilizando un fragmento corto (primer) de ADN de cadena simple que se usa como iniciador de la reacción de PCR (polymerase chain reaction) [SKS03]. La PCR es un procedimiento en el cual multiplica una cadena o fracción de cadena de ADN para su futura visualización. RAPDs son marcadores moleculares producidos mediante PCR que pueden reducir sustancialmente el tiempo costo y trabajo requerido para hacer caracterización molecular de genes (Secuenciación). Esta técnica puede ser usada en múltiples propósitos:

ISC-2003-1-50

8

§ Determinación de la variación genética en poblaciones y especies. § Estudio de las relaciones filogenéticas entre especies y subespecies. § Construcción y entendimiento de mapas genéticos de ligamiento,

marcación de genes y identificación de cultivares. § Cualquier aplicación de fingerprinting (como son paternidad, análisis

forense, e identificación de un individuo) El resultado de un RAPD se observa en un gel en el que se pueden visualizar unas bandas correspondientes a los fragmentos de ADN. La técnica RAPDs se explica posteriormente en el documento. Los programas de procesamiento de imágenes de geles automatizan el proceso de toma de datos, ya que permite una captura de las bandas de ADN de una forma más rápida, que puede ser directamente digitalizada para producir matrices de datos que proveen material de análisis usado en el cálculo de distanciamientos genéticos, variabilidad etc. Existen numerosos programas para el procesamiento de imágenes de geles de biología molecular, sin embargo la gran mayoría de ellos tienen un elevado costo. Por otro lado los programas para análisis de imágenes que son gratuitos, tiene una funcionalidad manual, es decir, es un experto quien analiza, no el programa. el programa construido permite analizar un gel pulsando solamente un botón, haciendo uso de técnicas para el procesamiento de imágenes y en una interfaz muy sencilla. El análisis propuesto consiste en la identificación de individuos del gel, la descripción de los mismos y finalmente en la descripción de las diferencias entre los individuos presentes en ese gel. Consecuentemente, el presente trabajo estará guiado por los siguientes objetivos:

1.1. OBJETIVO GENERAL El propósito de este trabajo es desarrollar un prototipo de un sistema que sirva como apoyo para el procesamiento automático de imágenes de Geles RAPD.

1.2. OBJETIVOS ESPECÍFICOS • Familiarizase con las técnicas de procesamiento de imágenes. • Utilizar el ambiente JAVA en desarrollo del prototipo para el procesamiento de

imágenes de geles RAPD.

ISC-2003-1-50

9

• Construir herramientas computacionales (configurables) que permitan procesar de forma automática las siguientes características de un gel RAPD:

o Identificar los carriles. o Identificar las bandas de cada carril. o Caracterizar un individuo. o Describir un gel. o Describir distancias o diferencias entre los individuos de un gel.

El presente documento está organizado de la siguiente manera: en el capítulo 2 se hace una presentación general sobre los Geles RAPD, los programas utilizados comercialmente para su análisis y las técnicas de tratamiento de imágenes utilizadas para extraer información de los mismos. En el capitulo 3 se presenta, de manera analítica el problema que se pretende solucionar, con esta aplicación, en términos de disponibilidad, precio y usuarios. Así mismo, se hace una descripción general de la solución propuesta. En el capítulo 4 se hace una análisis exhaustivo de los requerimientos que debe cumplir la aplicación: (a) Usuarios, (b) reglas, (c) metas, (d) atributos, (e) requerimientos funcionales y no funcionales, (f) diseño según la metodología UML. En el capítulo 5 se explica el código y la arquitectura descrita en el capítulo 4 (Diseño) y la estructura de archivos y directorios de la aplicación. En el capítulo 6 se muestran los resultados de las pruebas de la aplicación. Finalmente, en el capítulo 7 se presentan las conclusiones y se dan guías para desarrollo futuros.

ISC-2003-1-50

10

2. ESTADO DEL ARTE

2.1. LOS GELES RAPD [RW03] El procedimiento de los RAPD se puede resumir de la siguiente forma: el ADN genómico, es decir, de cadena doble, se pone en contacto con un primer determinado (secuencia de ADN de cadena corta conocida). Este primer hibrída, es decir, se adhiere, por afinidad a diferentes regiones complementarias del ADN genómico en las dos cadenas de ADN. La reacción de PCR produce esta manera fragmentos de ADN de diferentes peso molecular. El resultado de este procedimiento se visualiza en geles donde se observan bandas de acuerdo a los fragmentos de ADN amplificados que se separan según un gradiente de peso molecular. La presencia o ausencia de determinadas bandas son la evidencia del polimorfismo de un locus genético. Un locus se puede asociar con un gen, el polimorfismo entonces se evidencia como las formas alternativas de un gen. En la Figura 2.1., se observa una fotografía de un gel de la técnica RAPD, producida en el CIMPAT, en donde hay cuatro individuos de la población S (S1, S2, S3y S4) y cuatro de la población D. (D1, D2, D3 Y D4) cada uno de éstos constituyen un carril. M identifica diferentes marcadores de peso molecular. En cada carril, se puede ver una serie de bandas, que como anteriormente se dijo, se puede asociar con el polimorfismo de un gen. En la figura 2.2. Se ilustra más específicamente estos conceptos. El patrón de bandas de una población (para un primer determinado) se llama fingerprinting RAPD y se obtiene de acuerdo a las similitudes entre los patrones de banda de los individuos de dicha población.

ISC-2003-1-50

11

Figura 2.1. Ejemplo de un gel de un RAPD.

Fuente: laboratorio de parasitología CIMPAT

Figura 2.2. Explicación de la estructura del gel RAPD. A. carril. B. banda

Fuente: laboratorio de parasitología CIMPAT

Al tomar un individuo como muestra y establecer su patrón de bandas para un primer determinado, es posible correlacionarlo con los patrones poblacionales ya conocidos, y saber a qué población pertenece el individuo.

ISC-2003-1-50

12

Los RAPDs son ampliamente utilizados en los laboratorios de Biología Molecular. Es una técnica útil cuando hay que estudiar una alta variedad de muestras, con el fin de diferenciar especies, sin información previa de secuencia. Sin embargo, hay que tener en cuenta que los RAPDs presentan algunas desventajas, que obligan a una optimización del experimento, y a conseguir la reproducibilidad en los resultados de forma continuada.

2.2. LOS PROGRAMAS EXISTENTES Como se mencionó en la introducción, existen muchos programas de procesamiento de imágenes de geles, la funcionalidad que se va analizar es la capacidad detectar carriles y detectar bandas. Bio-Rad: Quantity One 1-D Analysis Software [BIO03] es el sistema recientemente adquirido por La Universidad De Los Andes. Existen dos versiones: la versión completa y la versión básica. La versión completa puede identificar carriles y bandas automáticamente, además tiene muchas características adicionales, la versión básica, que es gratis, no tiene la funcionalidad esperada. Scanalytics GENE PROFILER [SCA03]. es un paquete completo de software que encuentra automáticamente carriles y picos en la imagen para detectar la presencia bandas en un gel. También tiene muchas características adicionales. La licencia para un computador y un usuario tiene un costo del $2995. MediaCybernetics: GEL-PRO ANALYZER (ver. 3.1 y 4.5) [MED03] detectan automáticamente carriles y bandas, tienen características adicionales como corrección en el análisis para geles irregulares, base de datos de imágenes, soporta una amplia gama de formatos de imágenes, la versión 4.5 tiene funciones avanzadas para análisis y tratamiento de imágenes. La versión 3.1 tiene un costo de $1500 (aunque no se consigue en el mercado), la versión 4.5 tienen un costo $2500. Syngene: GENETOOLS IMAGE ANALYSIS SOFTWARE [SYN03] ofrece un análisis de un gel en tan sólo ocho segundos haciendo solamente un clic. Detecta automáticamente carriles y bandas.1 Nonlinear: Phoretix 1D Advanced + Pro [NON03] los dos programas permiten detección automática de carriles y de bandas. La versión profesional cuenta con una base de datos que permite hacer consultas y pruebas de hipótesis. La versión 1 El producto parece bueno, sin embargo el servicio técnico parece deficiente. Se intentó en muchas ocasiones conseguir el catálogo del producto, o los precios de licencias pero nunca se recibió contestación de parte de la empresa Syngene

ISC-2003-1-50

13

avanzada tiene un costo $4500. La versión profesional tiene un valor de $8500. [KEN03] Biosystematica: Bionumerics & Gelcompar [BIS 03] los dos sistemas tienen la misma funcionalidad en cuanto a el análisis de geles, es decir, identificación automática de carriles y bandas. Bionumerics puede además analizar caracteres fenotipicos y hacer análisis de secuencias de ADN. Bionumerics y Gelcompar son productos modulares, es por esto que los precios varían dependiendo los módulos instalados: de £ 3500 a £ 8300 para Gelcompar y desde £5500 a £16,200 para Bionumerics. Cross Checker - J. B. Buntjer and M. Otsen [CCH03] es una aplicación desarrollada en 1999, no tiene costo, sin embargo no presta la funcionalidad requerida. Los carriles y las bandas tienen que ser descritos por el usuario. IMAGEJ [IMA03] no es una herramienta específica para el procesamiento de geles, sin embargo tiene una funcionalidad para hacerlo. El usuario debe marcar los carriles y las bandas manualmente. Es gratis A continuación se presenta una tabla comparativa de las aplicaciones descritas anteriormente su funcionalidad y precio.

Nombre del programa.

Detección automática de carriles y bandas.

Precio

Quantity One 1-D Si GENE PROFILER Si $2,995 GEL-PRO ANALYZER Si $1500-2500 GENETOOLS Si $4500 Phoretix 1D Advanced Si $4500-8500 Bionumerics Gelcompar

Si £ 5500 a £ 16200 £ 3500 a £ 8300

Cross Checker No Gratis para fines educativos

IMAGE J No Gratis

Tabla 2.1. Tabla comparativa de algunos de los programas utilizados para el tratamiento de imágenes de geles.

En resumen, los programas existentes que tienen la funcionalidad deseada, tienen un alto costo mientras que los que son de uso libre necesitan la ayuda de un experto para realizar análisis. Esto quiere decir el usuario debe manualmente.

ISC-2003-1-50

14

2.3. EL PROCESAMIENTO DE IMÁGENES [GW92]. El proceso en el cual se extrae información de una imagen separando lo importante de lo no importante se llama segmentación. La segmentación subdivide una imagen en sus partes constituyentes. En general, la segmentación autónoma es una de las tareas más difíciles del procesamiento de imágenes. Esta etapa del proceso determina el eventual éxito o fracaso del análisis. De hecho, la segmentación rara vez llega alcanzar una solución satisfactoria. Para extraer la información relevante, se debe identificar la(s) zona(s) que contiene el dicha información. La identificación de las zonas de la imagen se realiza en dos partes: la primera donde se realzan los puntos críticos que delimitan la zona; la segunda, la captura de dichos puntos críticos o coordenadas que son usados sobre la imagen original para extraer información. La primera etapa se llama preprocesamiento, la segunda se llama procesamiento. Los algoritmos de segmentación de imágenes monocromáticas se basan en una de las dos propiedades básicas de los valores del nivel de gris: discontinuidad y similaridad. En la primera categoría, el método consiste en dividir la imagen basándose en los cambios bruscos de gris. Las principales áreas de interés de esta categoría son la detección de puntos aislados, detección de líneas y detección de bordes de una imagen. Los principales métodos de la segunda categoría están basados en la umbralización, crecimiento de región y, división y fusión de regiones. Aunque la detección de puntos y líneas son evidentemente elementos en la segmentación, la detección de bordes es con mucho el método más común para detectar discontinuidades significativas en el nivel de gris. La razón es que los puntos aislados y las líneas delgadas no son de frecuente aparición en la mayor parte de las aplicaciones prácticas. Un borde es la frontera entre regiones con propias de nivel de gris relativamente y distintas. Los bordes caracterizan las fronteras de los objetos, y por tanto son de gran utilidad de cara a la segmentación e identificación de objetos en imágenes [WSG03]. La idea más importante en la técnica de detección de bordes es el cálculo de un operador local de derivación. El módulo de la primera derivada en un punto se utiliza para detectar la presencia de un borde en una imagen, y el signo de la segunda derivada se puede utilizar para determinar si un píxel borde esta situado en el lado oscuro o claro el mismo. La forma más común identificar las discontinuidades es pasar una máscara a través de la imagen. Este tipo de procedimiento es llamado un "procedimiento del

ISC-2003-1-50

15

dominio espacial", es decir, es un procedimiento que opera directamente sobre los píxeles. Una máscara es un entorno de, por ejemplo, 3x3 píxeles, en la que los valores de los coeficientes determinan la naturaleza del proceso, como la acentuación de los bordes. (Figura 2.3)

Figura 2.3. Máscara general de 3x3

W1 W2 W3 W4 W5 W6 W7 W8 W9

Fuente [SCH89] Los procedimientos del dominio espacial, el general se pueden expresar como: g(x,y) = T [f(x,y)] donde f(x,y) es la imagen de entrada, g(x,y) es la imagen procesada y T es un operador que actúa sobre f, definido en algún entorno de (x,y). La forma más simple de T es un entorno de 1x1. T se convierte en una función de transformación del nivel de gris. Los entornos mayores permiten varias funciones de tratamiento de imagen, por ejemplo filtros. Las máscaras u operadores de Sobel 2 se pueden emplear para aproximar el módulo del gradiente (figura 2.4.). y como habíamos dicho anteriormente la primera derivada del perfil de nivel de gris en un punto de una imagen se obtiene utilizando el módulo del gradiente de ese punto, se pueden utilizar para este K. la presencia de un borde en una imagen.

2 Otras mascaras usadas en la detección de bordes, son las de Prewitt , Roberts e isotrópica, etc [WSG03]

ISC-2003-1-50

16

Figura 2.4. Máscaras de Sobel, usadas para la detección de bordes de imágenes: a. Máscara utilizada para detectar bordes horizontales. b. Máscara utilizada para detectar bordes verticales

-1 -2 -1 -1 0 1 0 0 0 -2 0 2 1 2 1 -1 0 1

a b Fuente [SCH89]

La segunda derivada se obtiene de forma similar usando el laplaciano (Figura 2.5.).

Figura 2.5. Máscara usada para calcular el laplaciano.

0 -1 0 -1 4 -1 0 -1 0

Fuente [SCH89]

El problema análisis de imágenes de geles, se puede ver con un problema de reconocimiento de patrones en imágenes. En este trabajo se aplica los conceptos anteriormente mencionados para la segmentación de imágenes de geles, y además se usa algunas de heurísticas para la extracción de información de la imagen.

ISC-2003-1-50

17

3. ANÁLISIS DEL PROBLEMA, ALTERNATIVAS DE SOLUCIÓN

3.1. EL PROBLEMA El problema consiste construir una aplicación de uso fácil, que sea capaz de extraer la información de la imagen del gel RAPD y que esté al alcance, por disponibilidad y precio, de investigadores y estudiantes, quienes hacen uso regular de la técnica RAPDs. La imagen tiene zonas con información relevante, que son los carriles (ver imagen: 2.2. A). Entonces, un primer paso es determinar cuáles son los carriles en la imagen. Un segundo paso consiste en extraer información de cada carril. Cada carril contiene la serie de bandas, la descripción de estas bandas, en cuanto a posición y grosor, será lo que determina la caracterización de un individuo. La ausencia de una banda que está presente en otra también es un dato importante, pues es la visualización de otra forma del gen. La estructura genérica de la imagen de un gel RAPD tiene manera general: son imágenes en su mayoría mono cromáticas y la distribución de las zonas de importancia dentro de la imagen, es casi siempre la misma, esto es, los carriles están orientados en una de las dimensiones de la imagen, y las bandas están orientados de forma perpendicular. Estas características serán aprovechadas para extraer información de la imagen.

3.2. LA SOLUCIÓN PLANTEADA La segmentación de imágenes es una etapa preliminar esencial en la mayor parte de problemas de reconocimiento de formas y análisis de imágenes. En este caso particular, el problema consiste en extraer la información relevante de una imagen de un gel RAPD, para su posterior análisis. Se plantea entonces, que para la segmentación de este tipo imágenes, en una primera instancia se realizará la detección vertical de bordes usando máscaras de Sobel (Figura 2.4), obteniendo así los puntos críticos que pueden determinar carriles. Con esos puntos críticos se definen heurísticas que determinan los carriles.

ISC-2003-1-50

18

Las heurísticas responden al conocimiento experto del CIMPAT y al análisis detallado imágenes capturadas; dicho análisis consiste en la descripción de la imagen como una matriz de píxeles, y cada píxel tiene un componente de color: rojo, azul y verde(RGB). Sobre cada uno de los carriles se realiza la detección horizontal de bordes usando máscaras de Sobel (Figura 2.4a.). Esto permite la detección de los puntos críticos que son candidatos a definir las bandas. Igualmente se definen heurísticas determinan las bandas. Con la información de los carriles y las bandas de cada carril, se crea un modelo del gel el cual puede ser analizado y la información contenida, puede ser guardada en algún medio de persistencia, en este caso se unas un archivo de texto.

ISC-2003-1-50

19

4. ANALISIS DE REQUERIMIENTOS y DISEÑO

4.1. ANALISIS DE REQUERIMIENTOS

4.1.1. USUARIOS DE LA HERRAMIENTA Investigadores y estudiantes de biología molecular, quienes hacen uso regular de la técnica RAPDs.

4.1.2. METAS

• La aplicación permite analizar imágenes de geles RAPD. • La aplicación debe discernir que es carril y que no. • La aplicación debe permitir el reconocimiento de bandas. • Crear un modelo ‘informático’ de la imagen • El sistema debe poder hacer un descriptor del gel conteniendo la

información de cada carril y las bandas dentro de un carril. • La aplicación debe poder ajustar diferentes grados de sensibilidad • El sistema debe apoyar la labor de comparación entre un patrón conocido y

analizado por el sistema y un patrón nuevo, que se encuentra en un gel a ser analizado.

• Generar patrones de una población a partir de muestras de individuos conocidos y analizados por el sistema.

ISC-2003-1-50

20

4.1.3. ATRIBUTOS DEL SISTEMA

Tabla 4.1. Atributos del sistema

Atributos Detalles Y Restricciones De Frontera Categoría Facilidad de uso Interfaz grafica Obligatorio

Plataforma (Detalle) Windows XP Obligatorio

Lenguaje de programación

(Detalle) JAVA Obligatorio

Forma de interacción (Detalle) Uso del puntero del Mouse y el teclado. Obligatorio

4.1.4. REQUERIMIENTOS FUNCIONALES

4.1.5.1. Diagrama de casos de uso

Figura 4.1 diagrama de casos de uso del sistema

ISC-2003-1-50

21

4.1.5.2. Análisis de Casos De Uso

Tabla 4.2. Caso de uso C.1. (Procesar imagen) REF C.1 Nombre del Caso de Uso

Procesar imagen

Resumen El sistema crea un modelo informático del gel (consistente en la identificación de carriles y bandas dentro de cada carril) y despliega ese modelo dibujado sobre el gel original.

Curso básico de eventos

ACTOR SISTEMA 1. Suministra el nombre de la imagen de origen

2.a. Identifica los carriles dentro de la imagen de origen;

2.b. por cada de cada carril identificado determina las bandas de ese carril.

2.c. despliega el resultado de 2.a y 2.b en la imagen original

Caminos Alternativos

Caminos de Excepción

Si archivo no existe, o no tiene el formato adecuado (jpg), se produce un error.

Puntos de Extensión

3. El usuario puede dar la orden de grabar los resultados del proceso en un archivo de texto

Suposiciones Precondiciones True Poscondiciones El sistema despliega gráficamente los resultados del procesamiento de la

imagen del gel. Reglas de Negocio Relacionadas

F.1, F.2, F.3

Criterios de Aceptación

El sistema debe mostrar la imagen resultante identificando: al menos el 70 % de los carriles y el 60 % de las bandas de cada carril.

Autor CDavid Seligmann

ISC-2003-1-50

22

Tabla 4.3. Caso de uso C.2. (Establecer patrón) REF C.2. Nombre del Caso de Uso

Establecer patrón

Resumen Genera un patrón (caracterización de bandas comunes en individuos de los cuales ya se tiene un modelo informático), suministrando un conjunto de individuos conocidos.


ACTOR SISTEMA 1. suministra un conjunto de individuos conocidos (de los cuales ya se tiene un modelo informático)

2. determina las similitudes en los modelos informáticos (bandas comunes) y genera el patrón


-


-


- el patron puede grabarse en la base de datos de patrones

Suposiciones - Precondiciones True Poscondiciones El sistema generó el patrón común a los individuos enviados por el usuario Reglas de Negocio Relacionadas

F.1, F.2, F.3, F.4, F.5


Si intuitivamente3 existen similitudes entre las bandas del 70% de los individuos suministrados por el usuario, el patrón generado deberá reflejarlas, es decir , tener las bandas comunes a ese 70%


3 intuitivamente: al ojo de un usuario NO experto

ISC-2003-1-50

23

Tabla 4.4. Caso de uso C.3. (Buscar patrón) REF C.3 Nombre del Caso de Uso

Buscar patrón

Resumen se realiza una búsqueda (en una base de datos de patrones) del patrón(es) más cercano(s) a la imagen suministrada por el usuario


ACTOR SISTEMA 1. envía el archivo de un individuo problema y da la orden de compararlo con patrón(es) conocido(s).

2. retorna la información de el o los patrones más cercanos (match en por lo menos del 60 % de las bandas del individuo problema) almacenados en la base de datos de patrones.



Se archivo no es válido, se produce un error


-

Suposiciones - existe una base de datos de patrones Precondiciones true PostCondiciones El sistema retornó la información de todos los patrones similares Reglas de Negocio Relacionadas

F.1, F.2, F.3, F.4, F.5, F.6



ISC-2003-1-50

24

4.1.5.3. Reglas de Negocio Las imágenes tomadas de los geles pueden tener uno o más carriles. Los carriles tienen un ancho igual dentro de un gel, pero puede variar entre un gel y otro. El gel puede contener un carril donde existe una mezcla de marcadores de peso molecular conocidos, sin embargo no es indispensable dicho patrón. (Ver figura 2.2.) Un patrón de bandas se define así: dado un conjunto de individuos, el patrón es el conjunto de bandas que están presentes en el 70% de los individuos. En la tabla 4.5. se reseñan las funciones del sistema.

Tabla 4.5. Funciones del sistema

Referencia Descripción De La Función F.1 Cargar una imagen de un gel F.2 Detectar carriles F.3 Establecer el modelo de la imagen (1 carril) F.4 Establecer el área de lectura vertical F.5 Establecer un patrón de una población conocida. F.6 Identificación de la(s) población(es) candidata(s) a contener un

individuo problema. F.7 Cambiar el nivel de contraste de una imagen dada . F.8 Establecer diferentes nivel de sensibilidad del análisis de acuerdo al

nivel de diferencias.

4.1.5. REQUERIMIENTOS NO FUNCIONALES § Portabilidad: aplicación multiplataforma, con posibilidades de uso en

Internet, dada por JAVA § Facilidad de Uso: la interacción se realiza a través de comandos del

Mouse y teclado § Instalación: es una aplicación stand alone, para efectos de compilación y

ejecución se usa un archivo ejecutable (bat). § Plataforma de visualización (usuario)

o Windows XP o Java Advanced Imaging 1.1.2-RC o tarjeta gráfica SVGA o Monitor SVGA

ISC-2003-1-50

25

o Mouse o JavaTM 2 Platform, Standard Edition (J2SE TM) ver 1.4.1_02 JRE

4.1.6.1. Requisitos De Interfaz

Tabla 4.6. Restricciones de interacción

REF NF.1 Nombre Interfaz de interacción Tipo Necesario Crítico Es crítico Descripción Interacción a través de mouse y el teclado, dentro de un

ambiente grafico (GUI) Criterio de Aceptación

Restricciones de visualización.

Tabla 4.7. Restricciones de visualización.

REF NF.2 Nombre Resolución de visualización Tipo Necesario Crítico Crítico Descripción El programa despliega el resultado del procesamiento en

una ventana correspondiente al tamaño (en píxeles) de la imagen analizada. La resolución mínima de visualización es 800 x 600

Criterio de Aceptación -

Restricciones sobre los datos

Tabla 4.8. Restricciones de formato.

REF NF.3 Nombre Restricciones de formato Tipo Necesario Crítico Crítico Descripción El formato de archivo que el programa puede procesar es

JPG Criterio de Aceptación -

ISC-2003-1-50

26

Tabla 4.9. Restricciones de color de imagen.

REF NF.4 Nombre Restricciones de color Tipo Necesario Crítico Crítico Descripción El color de las imágenes es el correspondiente para

imágenes a color de 24 bits. Criterio de Aceptación -

Tabla 4.10. Restricciones de composición de la imagen.

REF NF.5 Nombre Restricciones de composición de imagen Tipo Necesario Crítico Crítico Descripción La imagen debe tener alto contraste, asimismo el nivel de

ruido debe ser bajo. Las imágenes no deben tener artefactos como marcas escritas, burbujas en el gel (ver figura 4.2.a, 4.2.b)

Criterio de Aceptación El ojo humano, debe ser capaz de distinguir que es carril y que no lo es.

Figura 4.2.a. imagen inaceptable debido a marcas escritas

ISC-2003-1-50

27

Figura 4.2.b. imagen inaceptable debido a burbujas

Figura 4.2.a. imagen aceptable

c

4.1.6.2. Restricciones De Diseño § Estilo de arquitectura: El prototipo corresponde al estilo de arquitectura

de flujo de datos o data-flow, específicamente el subtipo es el de batch sequential [BC98], en la cual hay una transformación secuencial de los datos de entrada por programas o procesos independientes.

ISC-2003-1-50

28

§ Plataforma de operación: Windows XP

4.1.6.3. Restricciones De Implementación § Plataforma de desarrollo: § Java Advanced Imaging 1.1.2-RC § NetBeans IDE 3.4.1 § JavaTM 2 Platform, Standard Edition (J2SE TM) ver 1.4.1_01 SDK

ISC-2003-1-50

29

4.2. DISEÑO

4.2.1. DISEÑO DE ARQUITECTURA Y MUNDO DEL PROBLEMA a continuación se presenta varios diagramas UML para el entendimiento del sistema:

Figura 4.3. Modelo conceptual

ISC-2003-1-50

30

Figura 4.4. Diagrama de paquetes

Figura 4.5. Paquete GUI

4.2.1.1. La clase pInterfaz Esta clase es la que se encarga de la interacción con el usuario, y del despliegue de los resultados. Los métodos de la clase pInterfaz son dirigidos por eventos del mouse, de esta forma, los botones asociados que capturan tales eventos tienen la funcionalidad del nombre del botón. La clase además tiene métodos para el despliegue de imágenes y de archivos. El método procesarActionPerformed es el que tiene toda la secuencia instrucciones para procesar la imagen de un gel está asociado al botón procesar.

ISC-2003-1-50

31

Figura 4.6. Clase pInterfaz

ISC-2003-1-50

32

Figura 4.7. Paquete Core

4.2.1.2. La clase EdgeDetector Esta clase básicamente presta una funcionalidad para el preprocesamiento de imágenes, específicamente la detección de bordes. Los métodos de esta clase cargan una imagen de tipo BufferedImage y le aplican una operación de convolución (deteccion de bordes) devolviendo otra imagen de tipo BufferedImage.

Figura 4.8. Clase EdgeDetector

ISC-2003-1-50

33

Figura 4.9. Clase Pgrabber

ISC-2003-1-50

34

4.2.1.3. La clase Pgrabber Esta clase realiza las manipulaciones sobre las imágenes y almacena el resultado en vectores. El contenido de estos vectores son los puntos críticos sobre los cuales se basa la segmentación de las imágenes.

Figura 4.10. Paquete Model

Figura 4.11. Paquete Model clases expandidas

4.2.1.4. La clase Gel Esta clase contiene el modelo de la imagen del Gel. Tiene un vector de Carriles.

ISC-2003-1-50

35

4.2.1.5. La clase Carril Esta clase contiene el modelo de la imagen de un individuo o carril. Tiene un vector de Bandas. Sus atributos son inicio y fin que describen su posición en la dirección horizontal en el gel.

4.2.1.6. La clase Banda Esta clase contiene el modelo de una banda. Los atributos son ymin, ymax describen la posición en la dirección vertical dentro de un Carril.

ISC-2003-1-50

36

4.2.2. DIAGRAMAS DE SECUENCIA

Figura 4.11. Diagrama de secuencia del CU Procesar imagen

ISC-2003-1-50

37

Figura 4.12. Diagrama de secuencia del CU Establecer patrón

Figura 4.13. Diagrama de secuencia del CU Buscar patrón

ISC-2003-1-50

38

4.2.3. DIAGRAMAS DE ESTADOS DE INTERACCIÓN

Figura 4.13. Diagramas de estados de interacción de casos de uso. Los estados son: 1. principal, 2.desplegar resultados

ISC-2003-1-50

39

4.2.4. DISEÑO GUI A continuación se presenta una imagen con la interfaz del prototipo de la aplicación, la visualización de los resultados del análisis de la imagen, vía grafica y texto:

Figura 4.14. Diseño GUI

Figura 4.15. Resultado del proceso sobre una imagen de un gel.

ISC-2003-1-50

40

Figura 4.16. Archivo de texto generado luego de procesar la imagen 4.15 Carril 1 inicio 48 fin 120 ANCHO 72 Banda 1 ymin 377 ymax 397 Grosor 20 Banda 2 ymin 405 ymax 421 Grosor 16 Banda 3 ymin 615 ymax 642 Grosor 27 Carril 2 inicio 156 fin 216 ANCHO 60 Banda 1 ymin 405 ymax 420 Grosor 15 Banda 2 ymin 529 ymax 547 Grosor 18 Carril 3 inicio 257 fin 327 ANCHO 70 Banda 1 ymin 243 ymax 258 Grosor 15 Banda 2 ymin 383 ymax 398 Grosor 15 Banda 3 ymin 528 ymax 545 Grosor 17 Carril 4 inicio 365 fin 434 ANCHO 69 Banda 1 ymin 350 ymax 363 Grosor 13 Banda 2 ymin 524 ymax 543 Grosor 19 Banda 3 ymin 618 ymax 640 Grosor 22 Carril 5 inicio 586 fin 654 ANCHO 68 Carril 6 inicio 696 fin 762 ANCHO 66 Banda 1 ymin 421 ymax 447 Grosor 26 Banda 2 ymin 565 ymax 580 Grosor 15 Carril 7 inicio 808 fin 870 ANCHO 62 Banda 1 ymin 230 ymax 254 Grosor 24 Banda 2 ymin 357 ymax 378 Grosor 21 Banda 3 ymin 406 ymax 435 Grosor 29 Banda 4 ymin 549 ymax 574 Grosor 25 Carril 8 inicio 914 fin 975 ANCHO 61 Banda 1 ymin 352 ymax 370 Grosor 18 Banda 2 ymin 414 ymax 436 Grosor 22 Banda 3 ymin 551 ymax 573 Grosor 22

ISC-2003-1-50

41

5. IMPLEMENTACIÓN

5.1. PANORAMA Como se mencionó en la sección 4.1.6.3, el prototipo desarrollado es una aplicación stand-alone, desarrollada a través del IDE NetBeans versión 1.4.1. Para la instalacion del IDE es necesario tener JavaTM 2 Platform, Standard Edition (J2SE TM) ver 1.4.1_02 SDK tambien, y para el desarrollo del prototipo, es necesario: Java Advanced imaging 1.1.2-RC. Se tienen 3 paquetes de clases que distribuyen tanto la responsabilidad como la funcionalidad de la aplicación. Los paquetes son: GUI: que contiene la clase pInterfaz, la cual, se encarga de la interacción con el usuario, así mismo de la visualización de los resultados y finalmente es la clase que envía la orden de grabar los resultados a texto. Este paquete tiene además las clases ImageFileView, ImageFilter, ImagePreview, y Utils las cuales prestan la función de previsualización del archivo (thumbnails) dentro de la interfaz del filechooser. Model: contiene las clases que modelan en sí la imagen, se encuentran la clase Gel, la clase Carril y la clase Banda. Core: contiene las clases que se encargan de manipular los datos, en este caso, las imágenes a analizar. Dos clases se hacen cargo de esta manipulación, la clase EdgeDetector la cual contiene los métodos para el preprocesamiento de las imágenes, es decir, la detección de bordes. La clase Pgrabber que se encarga del procesamiento en si, es decir, es la que manipula en memoria las imágenes a través de objetos de tipo BufferredImage, dichos objetos se encuentran ampliamente descritos dentro de la documentación de JAVA [JAV03]. También se encuentra la clase Calculos, encargada, de realizar cálculos matemáticos relacionados con las coordenadas del la imagen y los puntos críticos capturados. Los cálculos que realiza dicha clase son: promedio, máximo, mínimo, desviación estándar, varianza.

ISC-2003-1-50

42

5.2. ARQUITECTURA Como se describió en la sección 4.1.6.2 el estilo de arquitectura del prototipo, corresponde al de arquitectura de flujo de datos o data-flow, específicamente el subtipo es el de batch sequential [BC98]. En este prototipo se tiene una entrada de datos (imagen), la cual va siendo transformada por varios procedimientos, de manera secuencial, hasta conseguir el resultado final. Dentro de la implementación del prototipo, se tiene que la entrada de datos inicial es una imagen de tipo BufferedImage que inicialmente es cargada por la clase pInterfaz. Sobre dicha imagen, la clase EdgeDetector realiza manipulaciones de preprocesamiento (detección de bordes por medio de una mascara de Sobel) y posteriormente la clase Pgrabber hace las manipulaciones de procesamiento (binarización, recorridos para identificación de puntos críticos.) La clase Pgrabber tiene como atributos los vectores descriptor, y caracterizador. Estos vectores contienen la información de puntos críticos o coordenadas (descriptor para carriles y caracterizador para bandas). La clase pInterfaz, usa los vectores de pGrabber para crear, a través de heurísticas, un Modelo del gel.

5.3. ALCANCE DEL SISTEMA De los tres casos de uso definidos en el análisis de requerimientos (sección 4.1.5) sólo se llego a la implementación del caso de uso C.1 procesar imagen. Este caso de uso es el más importante y prerrequisito para los otros dos. Se explica a continuación el proceso - secuencia de pasos - de análisis de una imagen de una forma ilustrativa, y se ejemplifica con una imagen sencilla, es decir una imagen recortada de un carril, sin embargo el software trabaja con imágenes de geles que tienen varios carriles. Debido al estilo de arquitectura, la explicación se hace de manera secuencial. Paso 1. Carga de la imagen original: en este paso se carga en memoria la imagen que va a ser procesada.

El método procesarActionPerformed de la clase pInterfaz el que posee toda la lógica del la manipulación secuencial y despliegue de las imágenes.

ISC-2003-1-50

43

Este método carga en memoria la imagen escogida por el usuario mediante la instrucción: original = this.readAsBufferedImage(t1.getText( )) la imagen original se ve en la figura 5.1

Figura 5.1. Paso 1. Imagen original

Paso 2. Detección de bordes vertical: de manera separada se realiza la detección de bordes vertical –derecha e izquierda- Sobre la imagen 5.1. se realiza la detección de bordes (vertical, tanto los bordes derechos como izquierdo) aplicando sobre ella, métodos de la clase EdgeDetector: EdgeDetector ED = new EdgeDetector() BufferedImage detectadaHD=ED.loadAndDisplayBIVD(original) BufferedImage detectadaHI=ED.loadAndDisplayBIVI(original) Las mascaras de Sobel usadas en este paso se muestran en la figura 5.2.

Figura 5.2. Mascaras de Sobel usadas para el preprocesamiento: a. detección de bordes vertical izquierdo y b. derecho

-1 0 1 1 0 -1 -2 0 2 2 0 -2 -1 0 1 1 0 -1 a b

ISC-2003-1-50

44

En este momento se tiene dos imágenes en memoria, detectadaHI y detectadaHD, que son el resultado de aplicar la detección de bordes vertical izquierdo y derecho. En la figura 5.3 se observa los resultados de este paso.

Figura 5.3. Paso 2 : imágenes con bordes verticales detectados

Paso 3. Binarización de las imágenes: las imágenes del paso 2 que están en tonos de gris se pasan a blanco y negro

Figura 5.5: imágenes binarizadas

ISC-2003-1-50

45

Paso 4. Pintar sobre la imagen original los candidatos a principio y final de carril Para la detección de carriles se utilizan las siguientes tres líneas: Pgrabber PGI = new Pgrabber(detectadaHI) PGI.loadImageCarrilDER(detectadaHD) PGI.Carriles(original) Dicho conjunto de instrucciones, dibuja los candidatos a ser principio de carriles el final de carriles sobre la imagen original. Específicamente la instrucción: PGI.loadImageCarrilDER(detectadaHD) Llena en memoria el vector descriptor, que contiene las coordenadas en x, que son los puntos críticos detectados después de binarizar la imagen (detectadaHD) y recorrerla en su totalidad. De la misma forma se obtiene otro vector descriptor con la instrucción: PGI.loadImageCarrilIZQ(detectadaHI), después de binarizar la imagen (detectadaHI) y recorrerla su totalidad. La instrucción PGI.Carriles(original) pinta sobre imagen original (en color azul) los pixels que fueron detectados como candidatos a ser principio de carril y pinta (en color verde) los pixels es que fue detectados como candidatos a ser final de carril. Anterior se puede ver mejor en el la figura 5.5.

Figura 5.5. Paso 4. posibles bordes de carril.

Paso 5. Capturar el carril Sobre la imagen 5.5 el Pgrabber ‘recorta’ una subimagen (carril) En la figura 5.6 se muestra el resultado del paso 5

ISC-2003-1-50

46

Figura 5.6 Paso 5: carril detectado

Sobre esta subimagen (Figura5.6.) se realiza un procedimiento similar al descrito para los carriles, pero esta vez sentido horizontal. Paso 6. Detección de bordes horizontal: de manera separada se realiza la detección de bordes horizontal –arriba y abajo – Sobre la imagen 5.6 se realiza operaciones de preprocesamiento (detección de bordes en sentido horizontal). Las mascaras de Sobel usadas en este paso se muestran en la figura 5.7.

Figura 5.7. Mascaras de Sobel usadas para el preprocesamiento: a. detección de bordes horizontal hacia arriba y b. hacia abajo

-1 -2 -1 1 2 1 0 0 0 0 0 0 1 2 1 -1 -2 -1

a b

En la figura 5.8 se muestran los resultados del paso 6.

ISC-2003-1-50

47

Figura 5.8 Paso 6 imágenes con bordes horizontales detectados

Paso 7. Binarización de las imágenes del paso 6 que están en tonos de gris se pasan a blanco y negro

Figura 5.9: imágenes binarizadas

Paso 8 Pintar sobre la subimagen los candidatos a principio y final de banda La instrucción PGI.bandas(carril) pinta, sobre la imagen de la figura 5.6 (en color azul) los pixels que fueron detectados como candidatos a ser principio de carril y pinta (en color verde) los pixels es que fue detectados como candidatos a ser final de carril. Anterior se puede ver mejor en el la figura 5.10.

ISC-2003-1-50

48

Figura 5.10. posibles bordes de banda.

Paso 9 Identificación de bandas: Para hacer la identificación de bandas se dan las siguientes instrucciones. pg.loadBandas(carril) Vector banditas= this.detectarBandas(pg) Los códigos de las clases pInterfaz, Pgrabber y EdgeDetector se encuentran en el anexo 1

ISC-2003-1-50

49

5.4. HEURÍSTICAS

5.4.1. PARA LA DETECCIÓN DE CARRILES La idea era trabajar, en memoria, sobre una imagen similar a la mostrada en la figura 5.11b, la cual es el resultado del proceso descrito en la sección 5.3 del paso 1 hasta el paso 4 sobre la imagen de la figura 5.11.a.

Figura 5.11. Resultado del procesamiento, antes de aplicar la heurística para detección de carriles

a b La heurística en este caso es encontrar un patrón de colores: azul, blanco-gris-negro, y verde. Sin embargo esto no es suficiente, para describir un carril debe haber por lo menos algunos azules, separados por un ancho mínimo seguido de algunos verdes (El valor numérico de algunos está dado por el archivo de configuración, sensibilidad.ini) De otra parte, como se observa en la figura 5.11.b en algunos casos como en el 7º. Carril existe una gran cantidad de ruido esto se refleja como una sucesión aleatoria de líneas azules y verdes. El conocimiento experto de una imagen de un gel dice que existen intervalos de carril y espacios libres. Entonces parte de la heurística es encontrar el ancho del carril que para cada gel es fijo.

ISC-2003-1-50

50

5.4.2. PARA LA DETECCIÓN DE BANDAS La idea de esta heurística es bastante similar al anterior sin embargo lo que se busca para escribir una banda es un patrón vertical que consiste en: tener verdes, negros y azules. En memoria, sobre una imagen similar a la mostrada en la figura 5.12b, la cual es el resultado del proceso descrito en la sección 5.3 del paso 5 hasta el paso 8 sobre la imagen de la figura 5.12.a.

Figura 5.6. Resultado del procesamiento, antes de aplicar la heurística para detección de bandas

a b

Después de hacer pruebas, se determinó la heurística: por lo menos dos píxeles verdes seguido por lo menos dos píxeles negros y seguido de por lo menos dos más píxeles azules determinan una banda. Asi se aproxima al resultado encontrado por el experto. Estos valores de dos píxeles, al momento de esta implementación no son configurables.

ISC-2003-1-50

51

5.5. ESTRUCTURA DE DIRECTORIOS Y ARCHIVOS El prototipo contiene 6 directorios: Config: los archivos de configuración del sistema Core: las fuentes de paquete Core GUI: las fuentes de paquete GUI Imágenes: las imágenes de geles y bandas usadas para las pruebas Model: las fuentes de paquete Model Resultados: las imágenes intermedias del preprocesamiento y procesamiento

de geles. Dentro del directorio raiz del prototipo se encuentran los archivos: clean.bat, compile.bat y run.bat, asi como un archivo .nbattrs creado por el IDE NetBeans y un acceso directo a run.bat llamado Procesador de Geles. La estructura general de directorios se aprecia mejor en la figura 5.7.

Figura 5.7. Estructura de directorios de la raiz del prototipo.

En la figura 5.8. se muestra el contenido de los directorios Core, Model y GUI

ISC-2003-1-50

52

Figura 5.8. Contenido de los directorios de fuentes: a. Core, b. Model , c.GUI.

a b c

5.6. OPCIONES CONFIGURABLES. El prototipo cuenta con 2 archivos de configuración: el archivo contraste.ini y sensibilidad.ini. En el primero se pone un valor para el nivel de contraste que usa el metodo contrastar de la clase Pgrabber.(los valores permitidos van entre 0 y 255) En el segundo archivo se configura la sensibilidad del sistema en cuanto a la alineación de los carriles, es decir, que tan recto es un carril en la imagen. Se puede ver de esta manera: la sensibilidad seria el número de píxeles que describen un principio o final de carril. Desde este punto de vista se tiene que en una imagen ideal debería tener un valor de 1 (correspondiendo a un píxel de grosor).

ISC-2003-1-50

53

6. RESULTADOS Y PRUEBAS

6.1. IMÁGENES FUENTES El prototipo fue desarrollado sobre una imagen base (ver Figura 2.1); la imagen fue capturada, en un scanner ACER 3300U, con una resolución 200dpi y fue capturada a color por medio del software de Windows para captura de imágenes. El archivo fue capturado en formato bmp, fue transformado a formato jpg posteriormente con el programa IRFANVIEW VER 3.61. Este archivo, llamado gel1.jpg fue recortada manualmente, usando el programa MICROSOFT PAINT, para formar imágenes más pequeñas que contienen solo un carril. Estos archivos están en el directorio /imágenes/carriles y fueron usados como archivos de prueba. Además de estas imágenes, se realizaron pruebas con imágenes de fotos de geles completos. Estas imágenes se encuentran en el directorio /imágenes/geles. Fueron capturadas de la misma forma que la imagen base.

6.2. CONTRASTE. El nivel de contraste de la imagen es muy importante para la aplicación, imágenes de un mismo gel, de bajo contraste son difícilmente procesadas por el prototipo.(ver figura 6.1.)

ISC-2003-1-50

54

Figura 6.1. a. bajo contraste (imagen original)

Figura 6.1.b. contraste medio

Figura 6.1.c. alto contraste

ISC-2003-1-50

55

al procesar la imagen 6.1.a no se encuentra ningún resultado, debido a la dificultad de encontrar bordes muy definidos en la imagen. Cuando fue necesario hacer una manipulación previa de la imagen para aumentar su contraste, se realizó la manipulación, sobre la imagen JPG, con el programa IRFANVIEW [IRF0] ocasionando un problema colateral como es el que cambió el número de colores de imagen de 24 bits a escala de grises (8 bits). Fue necesario hacer las manipulaciones con ADOBE PHOTOSHOP 7.0 [ADO] con el cual se solucionó el anterior problema. La figura 6.1.b por el contrario, tiene contornos más definidos y fácilmente identificables. En las mismas condiciones de procesamiento (contraste 160, sensibilidad 8) el prototipo detectó 0, 5 y 8 carriles (de un total de 9) respectivamente para las imágenes 6.1.a 6.1.b y 6.1.c

6.3. RESULTADOS Se realizaron pruebas con 3 niveles de contraste y 3 de sensibilidad, de la siguiente manera:

Contraste: 128, 140, 160 Sensibilidad: 4, 6, 8.

El nivel de contraste tiene que ver con el valor limite puesto para la binarización de la imagen (p.e nivel de gris < sensibilidad = negro) El nivel de sensibilidad hace referencia al número de píxeles que describen un principio o final de carril. En primer lugar, se presenta los resultados sobre la detección de carriles en imágenes de geles y se evalúa las variables de contraste y sensibilidad En segundo lugar se presenta resultados sobre la detección de bandas en imágenes de carriles. Con un valor fijo de contraste, se evalúa la detección para los diferentes niveles de sensibilidad en los dos ensayos (bandas y carriles). Posteriormente se evalúa, con un nivel de sensibilidad fijo, la detección para los diferentes niveles de contraste en los dos ensayos (bandas y carriles). En todos los casos, los números seguidos de un asterisco (*) indican que se encuentran más de un carril en esta imagen, debido a que estas imágenes sólo contienen un carril, debe describirse como un error.

ISC-2003-1-50

56

Los números que van seguidos de dos asteriscos (**), indican que se detectó bien el carril, sin embargo en el archivo de texto de resultados, dicho carril, con toda su información, aparece duplicado.

6.3.1 DETECCIÓN DE CARRILES

6.3.1.1. Carriles – Sensibilidad Con un nivel de contraste de 160, la mejor sensibilidad encontrada fue 8, como se ilustra en la tabla 6.1.

Tabla 6.1. Detección de carriles con Contraste 160 y sensibilidad variable

Número de carriles detectados por el sistema Contraste (160) - sensibilidad

Imagen Número de carriles detectados intuitivamente

8 6 4

Gel1.jpg 9 8 5 5 Gel2.jpg 9 5 5 2-6* Gel3.jpg 9 5 4-6* 3-7* Gel4.jpg 13 11-22** 11-22** 10-11* Gel5.jpg 9 6 7-10* 8-17* Gel6.jpg 9 8 8 8

*con error, detecta más carriles de los que hay ** carril aparece duplicado

Con un nivel de contraste de 140, la mejor sensibilidad encontrada fue 6 (sin embargo presenta valores muy similares al la sensibilidad 8), como se ilustra en la tabla 6.2.

ISC-2003-1-50

57


Número de carriles detectados por el sistema

Contraste (140) - sensibilidad Imagen Número de

carriles detectados intuitivamente

8 6 4

Gel1.jpg 9 2 2 7-22* Gel2.jpg 9 7-11* 7-11* 7-11* Gel3.jpg 9 4-6* 4-6* 5-8* Gel4.jpg 13 10-11* 10-11* 5 Gel5.jpg 9 6-9* 7-9* 8-14* Gel6.jpg 9 6 6 6


Con un nivel de contraste de 128, la mejor sensibilidad encontrada fue 8(se presenta menos errores de detección de carriles erróneos), como se ilustra en la tabla 6.3.



Contraste (128) - sensibilidad Imagen Número de


8 6 4

Gel1.jpg 9 4 4 4 Gel2.jpg 9 7-8* 7-10* 7-10* Gel3.jpg 9 5-6* 6-9* 6-9* Gel4.jpg 13 4-6* 9 9 Gel5.jpg 9 3-4* 5-7* 5-7* Gel6.jpg 9 7 5 5


ISC-2003-1-50

58

6.3.1.2. Carriles - Contraste Con un nivel de sensibilidad de 8, el mejor contraste encontrado fue 160 (se presenta menos errores de detección de carriles erróneos), como se ilustra en la tabla 6.4.

Tabla 6.4. Detección de carriles con sensibilidad 8 y contraste variable

Número de carriles detectados por el sistema sensibilidad (8) - contraste

Imagen Número de carriles detectados intuitivamente

160 140 128

Gel1.jpg 9 8 2 4 Gel2.jpg 9 5 7-11* 7-8* Gel3.jpg 9 5 4-6* 5-6* Gel4.jpg 13 11-22** 10-11* 4-6* Gel5.jpg 9 6 6-9* 3-4* Gel6.jpg 9 8 6 7


Con un nivel de sensibilidad de 6, el mejor contraste encontrado fue nuevamente 160 (se presenta menos errores de detección de carriles erróneos), como se ilustra en la tabla 6.5.



sensibilidad (6) - contraste Imagen Número de


160 140 128

Gel1.jpg 9 5 2 4 Gel2.jpg 9 5 7-11* 7-10* Gel3.jpg 9 4-6* 4-6* 6-9* Gel4.jpg 13 11-22** 10-11* 9 Gel5.jpg 9 7-10* 7-9* 5-7* Gel6.jpg 9 8 6 5


ISC-2003-1-50

59

Con un nivel de sensibilidad de 4, el mejor contraste encontrado fue 140 (sin embargo hay muchos errores de detección de carriles inexistentes), como se ilustra en la tabla 6.6.



sensibilidad (4) - contraste Imagen Número de


160 140 128

Gel1.jpg 9 5 7-22* 4 Gel2.jpg 9 2-6* 7-11* 7-10* Gel3.jpg 9 3-7* 5-8* 6-9* Gel4.jpg 13 10-11* 5 9 Gel5.jpg 9 8-17* 8-14* 5-7* Gel6.jpg 9 8 6 5


6.3.2. DETECCIÓN DE BANDAS

6.3.2.1. Bandas - Sensibilidad Con un nivel de contraste de 160, la mejor sensibilidad encontrada fue 8, como se ilustra en la tabla 6.7.

ISC-2003-1-50

60

Tabla 6.7. Detección de bandas con Contraste 160 y sensibilidad variable

Número de bandas detectados por el sistema Contraste (160) - sensibilidad

imagen Número de bandas detectados intuitivamente

8 6 4

Carril1.jpg 10 3 2 2 Carril2.jpg 10 2 2 2 Carril3.jpg 9 3 3 3 Carril4.jpg 10 2 2 2 Carril5.jpg 7 1 1 1 Carril6.jpg 6 1 1 1 Carril7.jpg 7 3 3 3 Carril8.jpg 7 2 2 2


Con un nivel de contraste de 140, la mejor sensibilidad encontrada fue 8, como se ilustra en la tabla 6.8.


Número de bandas detectados por el sistema

Contraste (140) - sensibilidad imagen Número de

bandas detectados intuitivamente

8 6 4

Carril1.jpg 10 3 3* 3* ** Carril2.jpg 10 3 3 3** Carril3.jpg 9 2 2 2 Carril4.jpg 10 3 3 3 Carril5.jpg 7 0 0 3 Carril6.jpg 6 1 1** 1** Carril7.jpg 7 2 2** 2** Carril8.jpg 7 4 2** 5**


ISC-2003-1-50

61

Con un nivel de contraste de 128, la mejor sensibilidad encontrada fue 8 (se presenta menos errores en la detección de carriles erróneos), como se ilustra en la tabla 6.9.



Contraste (128) - sensibilidad imagen Número de


8 6 4

Carril1.jpg 10 3 3** 3** Carril2.jpg 10 2 2** 2 Carril3.jpg 9 5 5 5 Carril4.jpg 10 5 5 5 Carril5.jpg 7 1 1 1 Carril6.jpg 6 3 3** 3** Carril7.jpg 7 2 2** 2** Carril8.jpg 7 4 4 4


6.3.2.2. Bandas - Contraste Con un nivel de sensibilidad de 8, el mejor contraste encontrado fue 128, como se ilustra en la tabla 6.10.

ISC-2003-1-50

62

Tabla 6.10. Detección de bandas con sensibilidad 8 y contraste variable

Número de bandas detectados por el sistema sensibilidad (8) - contraste

imagen Número de bandas detectados intuitivamente

160 140 128

Carril1.jpg 10 3 3 3 Carril2.jpg 10 2 3 2 Carril3.jpg 9 3 2 5 Carril4.jpg 10 2 3 5 Carril5.jpg 7 1 0 1 Carril6.jpg 6 1 1 3 Carril7.jpg 7 3 2 2 Carril8.jpg 7 2 4 4


Con un nivel de sensibilidad de 6, el mejor contraste encontrado fue 160 (se presenta menos errores en la detección de carriles erróneos), como se ilustra en la tabla 6.11.



sensibilidad (6) - contraste imagen Número de


160 140 128

Carril1.jpg 10 2 3* 3** Carril2.jpg 10 2 3 2** Carril3.jpg 9 3 2 5 Carril4.jpg 10 2 3 5 Carril5.jpg 7 1 0 1 Carril6.jpg 6 1 1** 3** Carril7.jpg 7 3 2** 2** Carril8.jpg 7 2 2** 4


ISC-2003-1-50

63

Con un nivel de sensibilidad de 4, el mejor contraste encontrado fue 160 (se presenta menos errores en la detección de carriles erróneos), como se ilustra en la tabla 6.12.



sensibilidad (4) - contraste imagen Número de


160 140 128

Carril1.jpg 10 2 3* **

3**

Carril2.jpg 10 2 3** 2 Carril3.jpg 9 3 2 5 Carril4.jpg 10 2 3 5 Carril5.jpg 7 1 3 1 Carril6.jpg 6 1 1** 3** Carril7.jpg 7 3 2** 2** Carril8.jpg 7 2 5** 4


La tendencia general presentada a lo largo de las pruebas e ilustrada en las tablas anteriores (6.1. a 6.12.) es que los mejores valores para el prototipo son 160 para contraste y 8 para sensibilidad. Se consideran estos valores como los valores por defecto de prototipo.

6.4. ANÁLISIS

6.4.1. LOGROS DEL PROTOTIPO

Con respecto a los objetivos planteados, metas propuestas y los criterios de aceptación del caso de uso C.1. se puede afirmar: • El prototipo permite realizar pruebas con diferentes imágenes, previo ajust

de las mismas.

ISC-2003-1-50

64

• Los parámetros configurables propuestos, efectivamente, cambian la capacidad de detección del prototipo –tanto para carriles, como para bandas.

• El prototipo tiene una alta eficacia en la detección de carriles

6.4.2. PROBLEMAS DEL PROTOTIPO Se presenta baja eficacia en la detección de BANDAS se expone a continuación las posibles explicaciones: A. Fallas en la algorítmica de detección:

En el Paso 8: pintar sobre la imagen, los píxeles candidatos de principio y fin. En este paso puede estar pasando lo siguiente, como se pinta secuencialmente sobre la misma imagen, ciertos candidatos a principio pueden quedar sobre-escritos por candidatos de fin de banda. La solución seria hacer un procesamiento paralelo de los candidatos en lugar de uno secuencial. En el Paso 9: La heurística propuesta NO considera todos los casos posibles. La heurística propuesta (sección 5.4.2.) tiene en cuenta que una posible banda Será algo de la forma 2 o más píxeles verdes, seguido de dos o más píxeles negros y finalizando con o mas píxeles azules. La solución propuesta es revisar la heurística, por ejemplo. Una banda esta podría estar descrita como algunos píxeles verdes seguidos de algunos píxeles azules, o algunos píxeles verdes seguidos de algunos píxeles grises y finalizando en algunos píxeles azules.

B. Dependencia de la Calidad de la imagen original: El nivel de contraste usado tiene un papel importante en este proceso. La solución propuesta consiste en incrementar el nivel de contraste de la imagen original antes del proceso con el prototipo.

La eficiencia de la detección de CARRILES es alta, sin embargo presenta errores tales como identificación de carriles inexistentes: A. Fallas en la algorítmica de detección:

En el Paso 5: pintar sobre la imagen, los píxeles candidatos de principio y fin de carril. En este paso puede estar pasando lo siguiente, como se pinta secuencialmente sobre la misma imagen, ciertos candidatos a principio pueden quedar sobre-escritos por candidatos de fin de carril. La solución seria hacer un procesamiento paralelo de los candidatos en lugar de uno secuencial. En el Paso 6: La heurística propuesta NO considera todos los casos posibles. La solución propuesta es revisar la heurística.

ISC-2003-1-50

65

B. Dependencia de la calidad de la imagen original: el nivel de contraste usado

tiene un papel importante en este proceso. La solución propuesta consiste en incrementar el nivel de contraste de la imagen original antes del proceso con el prototipo.

C. Ruido dentro de la imagen: esto dificulta ampliamente la detección e introduce el error descrito para el paso 6. La solución para disminuir el ruido dentro de la imagen es mejorar el proceso de captura de la imagen, tener una buena fuente, así mismo, el nivel de ruido se puede disminuir, en algunos casos, con aumento de contraste.

Es importante anotar que dentro de la heurística de la detección de carriles, el ancho del carril es un valor fijo (por ahora no configurable) por esto es necesario ajustar el tamaño de la imagen para que el ancho de los carriles concuerden con los rangos del ancho de la heurística (entre 53 y 90 píxeles). Tanto la fuente de la imagen, el proceso de captura, el dispositivo de captura, resolución de captura, nivel de contraste de la imagen, dificultan el proceso de las imágenes con este prototipo. Tanto heurísticas de bandas como de carriles necesitan mejorarse ya que en los mejores niveles (contraste – sensibilidad) descritos los porcentajes de acierto son de ca 70 % y ca 30% para la detección de carriles y de bandas respectivamente.

ISC-2003-1-50

66

7. CONCLUSIONES Y TRABAJO FUTURO El problema planteado en este trabajo, la construcción de un prototipo para procesamiento automático de imágenes de Geles RAPD, es un problema de alta complejidad pues tiene muchas variables intrínsecas y extrínsecas. La dificultad extrínseca del problema tiene que ver con todas las restricciones de las imágenes analizar en cuanto a formatos, color, resolución, intensidad de contraste. Se sugiere que para solucionar o controlar la injerencia de los factores externos al problema se debe establecer un protocolo para la captura de imágenes y procesamiento previo (ajustar el nivel de intensidad). El dispositivo por el cual se capturan las imágenes y la resolución a las cuales se hace, son factores que también se deben controlar. De hecho, comercialmente, existen equipos llamados Gel Documentation Systems, en los cuales hay un dispositivo para la captura de imagen del gel, este dispositivo está conectado a un computador el cual tiene el programa de procesamiento automático de geles. El ojo humano, con ayuda del cerebro, es un medio de captura de datos y análisis de los mismos muy eficiente, comparado con los equipos y programas elaborados por el hombre para este fin. El experto es capaz de detectar bandas no solamente en un carril por sí mismo, sino por comparación con los carriles adyacentes. Se sugiere una implementación con otro estilo de arquitectura, probablemente no de cambios secuenciales y graduales sino que permita un procesamiento paralelo. La dificultad intrínseca del problema es la definición de heurísticas para la detección de carriles y de bandas. Tal como se pretendía con este trabajo, se desarrolló un prototipo configurable, capaz de identificar carriles con una precisión del 73% (ver Sección 6.3. Tabla 6.1, configuración contraste - sensibilidad = 160 - 8). El sistema es capaz de identificar bandas dentro de carriles, con una eficiencia del 38% (ver sección 6.3, Tabla 6.10, configuración contraste - sensibilidad = 128 - 8). Los valores de configuración de contraste y sensibilidad son determinantes para la detección de bandas y carriles.

ISC-2003-1-50

67

Se debe mejorar las heurísticas para el reconocimiento de carriles y bandas, para esto es necesario analizar a fondo muchas imágenes de geles para poder hacer una generalización mejor de las reglas que escriben las imágenes de geles RAPD. Los trabajos interdisciplinarios aportan conocimiento nuevo e interesante para las partes participantes. Es necesario por parte de la universidad y los institutos de investigación de la misma hacer promoción de los proyectos, para lograr la vinculación de estudiantes de otras áreas en ellos.

ISC-2003-1-50

68

MATERIAL DE REFERENCIA [ADO03] ] Información del programa: ADOBEM PHOTOSHOP 7, [citado en junio, 2003] disponible en Internet <URL = http://www.adobe.com/products/photoshop/main.html > [BIO03] información general sobre el producto Quantity One 1-D Analysis Software, [citado en junio, 2003] disponible en Internet <URL= http://www.bio-rad.com/B2B/BioRad/product/br_category.jsp?BV_SessionID=@@@@1474402575.1054839749@@@@&BV_EngineID=cccdadcihggdgekcfngcfkmdhkkdfll.0&categoryPath=%2fCatalogs%2fLife+Science+Research%2fSoftware%2fThe+Discovery+Series+Imaging+Software%2fQuantity+One+1-D+Analysis+Software&searchStr=quantity+one+1-d+analysis+software+&cateName=Ordering+Information > [BIS03] información sobre precios de los productos: Bionumerics & Gelcompar, [citado en junio, 2003] disponible en Internet <URL= http://www.biosystematica.com/gc.htm> [BC98] Bass,L., Clemens,P., Kazman, R., “Software Architecture in Practice”, 1998, Addison-Wesley [CCH03] información general sobre el producto: cross checker, [citado en junio, 2003] disponible en Internet <URL= http://www.dpw.wau.nl/pv/pub/CrossCheck/> [GW92] González, R., Woods, R., 1992 "Tratamiento Digital De Imágenes", capítulo 7 Segmentación De Imágenes, pág. 487-488, ED. –––ADDISON WESLEY/DÍAZ DE SANTOS [IMA03] información general sobre el producto: imageJ, [citado en junio, 2003] disponible en Internet <URL= http://rsb.info.nih.gov/ij/ > [IRF03] Información del programa: IRFANVIEW, [citado en junio, 2003] disponible en Internet <URL = http://www.irfanview.com/> [JAR03] Jaramillo, C. (Entrevista personal, junio de 2003) [JAV03] documentación on-line de del API de J2SE 1.4.1 ). [citado en junio, 2003] disponible en Internet <URL= http://java.sun.com/j2se/1.4.1/docs/api/> [KEN03] Phoretix 1D Advanced , [citado en junio, 2003] disponible en Internet <URL= http://www.kendricklabs.com/phoretix.htm> [MED03] información general sobre el producto: GEL-PRO ANALYZER [citado en junio, 2003] disponible en Internet <URL= http://www.mediacy.com/gppage.htm > [NON03] Información general sobre el producto: PHORETIX 1D ADVANCED + PRO, citado en junio, 2003] disponible en Internet <URL= http://www.phoretix.com/products/1d_products.htm >

ISC-2003-1-50

69

[RW03] Department of Genetics, Division of Biological Sciences, Rutgers University and the Waksman Institute (2003). citado en junio, 2003] disponible en Internet <URL= http://avery.rutgers.edu/WSSP/StudentScholars/project/archives/onions/rapd.html> [SCA03] información general sobre el producto GENE PROFILER [citado en junio, 2003] disponible en Internet <URL = http://www.iplab.com/product/genePro/apps.shtml> [SCH89] Schalkoff,R., 1989, “Digital Image Processing And Computer Vision”, p 149, Ed. JOHN WILEY AND SONS, INC [SKS03]Universidad de Saskatchewan, Crop Development Centre (2003). Random Amplified Polymorphic DNA (RAPD). [citado en junio, 2003] disponible en Internet <URL= http://www.usask.ca/agriculture/plantsci/classes/plsc416/projects_2002/pawlin/resources/rapds.html > [SYN03] información general sobre el producto: GENETOOLS IMAGE ANALYSIS SOFTWARE , [citado en junio, 2003] disponible en Internet <URL= http://www.syngene.com/genetoolsshort.asp> [UCL03] University of California, Angeles (2003). [citado en junio, 2003] disponible en Internet <URL= http://www.bioinformatics.ucla.edu> [WSG03]Introducción al Procesado de Imagen; Extracción de bordes disponible en Internet citado en junio, 2003]<URL= http://wgpi.tsc.uvigo.es/libro/procesim/node7.htm >

ISC-2003-1-50

70

GLOSARIO BIOLOGIA MOLECULAR ADN: Ácido desoxirribonucleico. El ADN está compuesto por

una sucesión de pares de bases nitrogenadas. Estas pueden ser timina, guanina, adenina, citosina.

ADN GENOMICO: Ácido desoxirribonucleico de cadena doble

ADN polimórfico: Secuencias de ADN que son relativamente variables entre individuos o especies.

BANDA Evidencia visual (en un gel) de la presencia de fragmentos de ADN

CARRIL: O individuo, es la muestra de fragmentos de ADN que comparten una alineación vertical en un gel

GEL: PCR: Reacción en cadena de la polimerasa, procedimiento de

laboratorio en el cual se producen muchos fragmentos de ADN que se desea. Necesita de un primer para iniciarse. La secuencia de este primer es conocida y por eso puede escogerse el fragmento que se desea amplificar.

PRIMER O CEBADOR: Es un fragmento corto de ADN de cadena sencilla, usualmente tiene alrededor de 15 pares de bases. Es utilizado como iniciador de la reacción de cadena de la polimerasa.

RAPD: Amplificación al azar ADN polimórfico. Es una Variación de PCR, con un primer que amplifica al azar fragmentos de ADN.

123456789

10111213141516171819202122232425262728293031323334353637383940414243444546474849505152

package GUI;/* * pInterfaz.java * * Created on February 19, 2003, 1:54 AM */import Core.*;import Model.*;

import java.io.PrintWriter;import java.io.FileWriter;import java.io.IOException;

import java.awt.*;import java.awt.image.*;import java.applet.*;import java.util.*;

import java.io.*;import java.util.Vector;import javax.swing.JOptionPane;import java.awt.event.*;import javax.swing.*;import javax.swing.filechooser.*;import java.awt.image.ImageObserver;

import java.io.File;import java.awt.BorderLayout;import java.awt.Font;import java.awt.Color;import javax.swing.JPanel;import javax.swing.JLabel;import javax.media.jai.JAI;import javax.media.jai.PlanarImage;

import java.awt.image.*;import java.lang.String;import javax.swing.*;import java.awt.geom.*;import com.sun.image.codec.jpeg.*;

import java.util.*;import java.beans.*;import java.awt.*;import java.awt.image.*;import java.awt.image.renderable.*;import java.net.URI;

import javax.media.jai.*;import java.awt.image.BufferedImage;

pInterfaz.java

Page 1 of 14

5354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899

100101102103104

/** * * @author CDavid */public class pInterfaz extends javax.swing.JFrame implements ActionListener, ImageObserver

// static private String newline = "\n"; private JFileChooser fc;private PlanarImage source = null;private BufferedImage original=null;private int NoPixels=0;private String sensibilidad;private String arch_config;Calculos calc= new Calculos();private Gel GEL;//private int factorCorreccionY;/** Creates new form pInterfaz */public pInterfaz(){

try{

arch_config = "./config/sensibilidad.ini";URI u = new URI(arch_config);File arc2 = new File( arch_config );BufferedReader br2 = new BufferedReader(new InputStreamReader(new FileInputStreamsensibilidad = br2.readLine();Integer i = new Integer(sensibilidad);NoPixels=i.intValue();

}catch (Exception e){

e.printStackTrace();}

GEL = new Gel();initComponents();this.procesar.setEnabled(false);this.grabar.setEnabled(false);

Bcargar.addActionListener(this);// ventana.addActionListener(this);

}

/** This method is called from within the constructor to * initialize the form. * WARNING: Do NOT modify this code. The content of this method is * always regenerated by the Form Editor. */

private void initComponents() {//GEN-BEGIN:initComponentsjPanel1 = new javax.swing.JPanel();

pInterfaz.java

Page 2 of 14

105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156

C = new javax.swing.JPanel();CC = new javax.swing.JPanel();NN = new javax.swing.JPanel();Bcargar = new javax.swing.JButton();SS = new javax.swing.JPanel();t1 = new javax.swing.JTextField();CCC = new javax.swing.JPanel();N = new javax.swing.JPanel();S = new javax.swing.JPanel();procesar = new javax.swing.JButton();nuevo = new javax.swing.JButton();grabar = new javax.swing.JButton();jPanel2 = new javax.swing.JPanel();jPanel3 = new javax.swing.JPanel();

setTitle("Programa");addWindowListener(new java.awt.event.WindowAdapter() {

public void windowClosing(java.awt.event.WindowEvent evt) {exitForm(evt);

}});

jPanel1.setLayout(new java.awt.BorderLayout());

jPanel1.setMinimumSize(new java.awt.Dimension(0, 0));C.setLayout(new java.awt.BorderLayout());

CC.setLayout(new java.awt.BorderLayout());

Bcargar.setText("buscar archivo");Bcargar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {BcargarActionPerformed(evt);

}});

NN.add(Bcargar);

CC.add(NN, java.awt.BorderLayout.NORTH);

t1.setDragEnabled(true);t1.setPreferredSize(new java.awt.Dimension(400, 20));t1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {t1ActionPerformed(evt);

}});

SS.add(t1);

CC.add(SS, java.awt.BorderLayout.SOUTH);

pInterfaz.java

Page 3 of 14

157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208

CC.add(CCC, java.awt.BorderLayout.CENTER);

C.add(CC, java.awt.BorderLayout.SOUTH);

jPanel1.add(C, java.awt.BorderLayout.CENTER);

jPanel1.add(N, java.awt.BorderLayout.NORTH);

procesar.setText("Procesar Imagen");procesar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {procesarActionPerformed(evt);

}});

S.add(procesar);

nuevo.setText("nuevo");nuevo.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {nuevoActionPerformed(evt);

}});

S.add(nuevo);

grabar.setText("grabar a txt");grabar.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {grabarActionPerformed(evt);

}});

S.add(grabar);

jPanel1.add(S, java.awt.BorderLayout.SOUTH);

jPanel1.add(jPanel2, java.awt.BorderLayout.EAST);

jPanel1.add(jPanel3, java.awt.BorderLayout.WEST);

getContentPane().add(jPanel1, java.awt.BorderLayout.CENTER);

pack();}//GEN-END:initComponents

private void t1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_t1ActionPerformed// Add your handling code here:

}//GEN-LAST:event_t1ActionPerformed

private void grabarActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_grabarActionPerformedthis.recorrerGel();

pInterfaz.java

Page 4 of 14

209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260

}//GEN-LAST:event_grabarActionPerformed

private void nuevoActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_nuevoActionPerformed

this.procesar.setEnabled(true);

}//GEN-LAST:event_nuevoActionPerformed

/**metodo que inicia la serie de pasos del procesamiento de imágenes*contiene la heuristica de la detección de carriles en un gel*/

private void procesarActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_procesarActionPerformedGEL = new Gel();

this.consola("es la deteccion H");//capturar la imagen original en un bufferedImage para su pre-procesamientooriginal= this.readAsBufferedImage(t1.getText());BufferedImage sobreOrigin=this.readAsBufferedImage(t1.getText());this.displayBI(sobreOrigin, "Analisis");this.saveAsJPG(original, "./resultados/original.jpg");

EdgeDetector ED = new EdgeDetector();// preprocesamiento por medio de la clase Edgedetector y matrices de convolucion

BufferedImage detectadaHD=ED.loadAndDisplayBIVD(original);

BufferedImage detectadaHI=ED.loadAndDisplayBIVI(original);// this.displayBI(detectadaHI2); //la imagen desspues de detectar bordes por la izquierda -binarizada-

// * * * PARA EL GEL COMPLETO * * *

Pgrabber PGI = new Pgrabber(detectadaHI);PGI.loadImageCarrilDER(detectadaHD);PGI.loadImageCarrilIZQ(detectadaHI);PGI.Carriles(original);

Pgrabber PG = new Pgrabber(original);PG.loadCarriles(original);Vector des = PG.getDescriptorGEL();Vector posiblesI=new Vector();Vector posiblesF=new Vector();int contI = 0;for (int x=0; x<des.size()-5;x++){

if (((String)(des.get(x))).equalsIgnoreCase("AZUL") ){

int i=x;

pInterfaz.java

Page 5 of 14

261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312

int cont=1;Vector IniCarriles =new Vector();while (((String)(des.get(x))).equalsIgnoreCase("AZUL")){

cont++;IniCarriles.add(new Integer(x));x++;

}if (cont > NoPixels) // opcion configurable{

posiblesI.add(new Integer(calc.media(IniCarriles)));}

}if (((String)(des.get(x))).equalsIgnoreCase("VERDE") ){

int i=x;int cont=1;Vector FinCarriles =new Vector();while (((String)(des.get(x))).equalsIgnoreCase("VERDE")){

cont++;FinCarriles.add(new Integer(x));x++;

}if (cont >NoPixels) // opcion configurable{

//consola("es candidato a inicio");posiblesF.add(new Integer(calc.media(FinCarriles)));

}}

}

Vector Carriles= new Vector ();

// CASO UNO: igual numero de posibles iniciosif ( posiblesI.size()== posiblesF.size()){

// CICLO QUE RECORRE UNA IMAGEN PARA BUSCAR LOS CARRILES for (int j = 0; j< posiblesI.size();j++){

int xi = ((Integer)posiblesI.get(j)).intValue();int xd = ((Integer)posiblesF.get(j)).intValue();

if ((xd-xi)>53 && (xd-xi)<90){

Pgrabber pgORI = new Pgrabber(sobreOrigin);pgORI.pintarRectangulo(sobreOrigin, xi-1, xd+1, 0);BufferedImage carril=pgORI.subImagen(sobreOrigin, xi, xd, 0);Carril temp = new Carril(xi, xd);EdgeDetector ED2 = new EdgeDetector();// preprocesamiento por medio de la clase Edgedetector y matrices de convolucionBufferedImage detectadaVU=ED2.loadAndDisplayBIHup(carril);

pInterfaz.java

Page 6 of 14

313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364

BufferedImage detectadaVD=ED2.loadAndDisplayBIHdown(carril);Pgrabber PG2 = new Pgrabber(detectadaVU);//displayBI(BordesCarril); PG2.loadImageVD(detectadaVU); //analisis por arribaPG2.loadImageVU(detectadaVD); // analisis por abajoPG2.Bandas(carril); //pinta sobre la imagen carrilint num=j+1;PG2.loadBandas(carril);//this.displayBI(carril, "carril"+num);Pgrabber pg = new Pgrabber(carril);pg.loadBandas(carril);// ***** detecta bandas *******Vector banditas= this.detectarBandas(pg);temp.setBandas(banditas);pg.grabar(carril, "carril"+num);Carriles.add(temp);

}}

}if ( posiblesI.size() < posiblesF.size()){

Pgrabber pgORI = new Pgrabber(sobreOrigin);for (int j = 0; j < posiblesI.size();j++){

int diferencia = posiblesF.size() - posiblesI.size();for (int i=0; i <= diferencia; i++){

int xi = ((Integer)posiblesI.get(j)).intValue();int xd = ((Integer)posiblesF.get(j)).intValue();xd = ((Integer)posiblesF.get(j+i)).intValue();if ((xd-xi)>53 && (xd-xi)<90){

// consola("hay carril " + xi +" "+ xd); pgORI.pintarRectangulo(sobreOrigin, xi-1, xd+1, 0);BufferedImage carril=pgORI.subImagen(sobreOrigin, xi, xd, 0);Carril temp = new Carril(xi, xd);Carriles.add(temp);EdgeDetector ED2 = new EdgeDetector();// preprocesamiento por medio de la clase Edgedetector y matrices de convolucionBufferedImage detectadaVU=ED2.loadAndDisplayBIHup(carril);BufferedImage detectadaVD=ED2.loadAndDisplayBIHdown(carril);Pgrabber PG2 = new Pgrabber(detectadaVU);//displayBI(BordesCarril); PG2.loadImageVD(detectadaVU); //analisis por arribaPG2.loadImageVU(detectadaVD); // analisis por abajoPG2.Bandas(carril); //pinta sobre la imagen carril int num=j+1;Pgrabber pg = new Pgrabber(carril);//PG2.loadBandas(carril);pg.loadBandas(carril);Vector banditas= this.detectarBandas(pg);

pInterfaz.java

Page 7 of 14

365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416

temp.setBandas(banditas);pg.grabar(carril, "carril"+num);Carriles.add(temp);

}}

}//this.displayBI(original);

}if ( posiblesI.size() > posiblesF.size()){

Pgrabber pgORI = new Pgrabber(sobreOrigin);for (int j = 0; j < posiblesF.size();j++){

int diferencia = posiblesI.size() - posiblesF.size();for (int i=0; i <= diferencia; i++){

int xi = ((Integer)posiblesI.get(j)).intValue();int xd = ((Integer)posiblesF.get(j)).intValue();xi = ((Integer)posiblesI.get(j+i)).intValue();if ((xd-xi)>53 && (xd-xi)<90){

//consola("hay carril " + xi +" "+ xd); pgORI.pintarRectangulo(sobreOrigin, xi-1, xd+1, 0);BufferedImage carril=pgORI.subImagen(sobreOrigin, xi, xd, 0);Carril temp = new Carril(xi, xd);//Carriles.add(temp);EdgeDetector ED2 = new EdgeDetector();// preprocesamiento por medio de la clase Edgedetector y matrices de convolucionBufferedImage detectadaVU=ED2.loadAndDisplayBIHup(carril);BufferedImage detectadaVD=ED2.loadAndDisplayBIHdown(carril);Pgrabber PG2 = new Pgrabber(detectadaVU);//displayBI(BordesCarril); PG2.loadImageVD(detectadaVU); //analisis por arribaPG2.loadImageVU(detectadaVD); // analisis por abajoPG2.Bandas(carril); //pinta sobre la imagen carrilint num=j+1;Pgrabber pg = new Pgrabber(carril);pg.loadBandas(carril);Vector banditas= this.detectarBandas(pg);temp.setBandas(banditas);pg.grabar(carril, "carril"+num);Carriles.add(temp);pg.grabar(carril, "carril"+num);

}}

};

}

GEL.setCarriles(Carriles);this.procesar.setEnabled(false);

pInterfaz.java

Page 8 of 14

417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468

this.grabar.setEnabled(true);

}//GEN-LAST:event_procesarActionPerformed

private void BcargarActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_BcargarActionPerformed{

//Set up the file chooser.if (fc == null) {

fc = new JFileChooser();fc.setCurrentDirectory(new java.io.File("."));

//Add a custom file filter and disable the default//(Accept All) file filter.

fc.addChoosableFileFilter(new ImageFilter());fc.setAcceptAllFileFilterUsed(false);

//Add custom icons for file types.fc.setFileView(new ImageFileView());

//Add the preview pane.fc.setAccessory(new ImagePreview(fc));

}

//Show it.int returnVal = fc.showDialog(pInterfaz.this,

"ok");

//Process the results.if (returnVal == JFileChooser.APPROVE_OPTION) {

File file = fc.getSelectedFile();System.out.println("escogió "+ file.getAbsolutePath());//this.displayFILE(file.getAbsolutePath());

t1.setText(file.getAbsolutePath());

} else {System.out.println("cancelled by user.");

}

//Reset the file chooser for the next time it's shown.fc.setSelectedFile(null);

this.procesar.setEnabled(true);

}

}//GEN-LAST:event_BcargarActionPerformed

/** Exit the Application */private void exitForm(java.awt.event.WindowEvent evt) {//GEN-FIRST:event_exitForm

System.exit(0);}//GEN-LAST:event_exitForm

/**

pInterfaz.java

Page 9 of 14

469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520

* @param args the command line arguments */

public static void main(String[] args) {pInterfaz a = new pInterfaz();a.setVisible(true);

}

// Variables declaration - do not modify//GEN-BEGIN:variablesprivate javax.swing.JButton Bcargar;private javax.swing.JPanel CCC;private javax.swing.JButton nuevo;private javax.swing.JPanel jPanel3;private javax.swing.JPanel NN;private javax.swing.JPanel jPanel2;private javax.swing.JPanel N;private javax.swing.JPanel S;private javax.swing.JButton grabar;private javax.swing.JTextField t1;private javax.swing.JPanel SS;private javax.swing.JPanel C;private javax.swing.JPanel CC;private javax.swing.JPanel jPanel1;private javax.swing.JButton procesar;// End of variables declaration//GEN-END:variables

public void displayFILE(String filename){

BufferedImage img = readAsBufferedImage(filename);JFrame ventana2 = new JFrame();//ventana = new javax.swing.JInternalFrame(); ImagePanel pan = new ImagePanel(img);//System.out.println("tamaño " +img.getWidth()+" "+ img.getHeight());pan.setSize(img.getWidth(),img.getHeight());ventana2.getContentPane().add(pan);ventana2.setSize(img.getWidth(), img.getHeight());jPanel1.setSize(img.getWidth()+200, img.getHeight()+200);ventana2.pack();ventana2.setSize(img.getWidth(),img.getHeight());ventana2.show();

}public void displayBI(BufferedImage img){

//BufferedImage img = readAsBufferedImage(filename);JFrame ventana2 = new JFrame();ImagePanel pan = new ImagePanel(img);

// System.out.println("tamaño " +img.getWidth()+" "+ img.getHeight());pan.setSize(img.getWidth(),img.getHeight());ventana2.getContentPane().add(pan);ventana2.pack();ventana2.setSize(img.getWidth(),img.getHeight());ventana2.show();

}

pInterfaz.java

Page 10 of 14

521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572

public void actionPerformed(ActionEvent e) {}

public static BufferedImage readAsBufferedImage(String filename){

try{

FileInputStream fis = new FileInputStream(filename);JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(fis);BufferedImage bi = decoder.decodeAsBufferedImage();

System.out.println(bi.toString());return bi;

}catch(Exception e){

System.out.println(e);return null;

}}

public void saveAsJPG(BufferedImage bu, String file){

FileImageFactory FIF = new FileImageFactory();try {

FIF.saveAsJPEG(original, file);consola("GRABO !!!!");


System.out.println(e.toString());}

}

static class ImagePanel extends JComponent{

protected BufferedImage image;public ImagePanel(){}public ImagePanel(BufferedImage img){ image = img;}

public void setImage(BufferedImage img){ image = img; }

public void paintComponent(Graphics g){

Rectangle rect = this.getBounds();

pInterfaz.java

Page 11 of 14

573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624

if(image != null){

g.drawImage(image, 0,0,rect.width, rect.height, this);}

}}

/**método que imprime por pantalla mensajes*/

private void consola (String s){

System.out.println(s);}

/* **método que despliega en pantalla un BufferedImage, y espera el nombre pasado por parámetro, *como name

*/

public void displayBI(BufferedImage img, String name){

//BufferedImage img = readAsBufferedImage(filename);JFrame ventana2 = new JFrame(name);ImagePanel pan = new ImagePanel(img);System.out.println("tamaño " +img.getWidth()+" "+ img.getHeight());pan.setSize(img.getWidth(),img.getHeight());ventana2.getContentPane().add(pan);ventana2.pack();ventana2.setSize(img.getWidth(),img.getHeight());ventana2.show();

}

/**método que contiene la huristica de la detección de bandas en un carril**/

private Vector detectarBandas(Pgrabber p){

Vector car = p.getCaracterizadorCarril();//this.consola("tamaño caracterizador "+ car.size());Vector pVerde;Vector pAzul;

int contV=0;int contA=0;int contN=0;int u=0;Vector bandass=new Vector();// * * * CICLO QUE RECORRE EL CARRIL PARA BUSCAR LAS BANDAS

pInterfaz.java

Page 12 of 14

625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676

while (u < car.size()-5){

if (((String)(car.get(u))).equalsIgnoreCase("VERDE") ){

contV=0;pVerde = new Vector();while ( ((String)(car.get(u))).equalsIgnoreCase("VERDE") ){

contV++;pVerde.add(new Integer(u));u++;}

if (contV > 2) // opcion configurable{

if (((String)(car.get(u))).equalsIgnoreCase("NEGRO") ){

contN=0;while (((String)(car.get(u))).equalsIgnoreCase("NEGRO")){

contN++;u++;

}if (contN > 2) // opcion configurable{

if (((String)(car.get(u))).equalsIgnoreCase("AZUL") ){

contA=0;pAzul= new Vector();while (((String)(car.get(u))).equalsIgnoreCase("AZUL")){

contA++;pAzul.add(new Integer(u));u++;

}if (contA > 2) // opcion configurable{

int y1= calc.media(pVerde);int y2= calc.media(pAzul);Banda b =new Banda (y1,y2);bandass.add(b);

}}

}}

}}

u++;}

pInterfaz.java

Page 13 of 14

677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710

return bandass;}

/* *método que gravan un archivo de texto el modelo del gel. */

public void recorrerGel(){

Vector elGel = GEL.getCarriles();try{

PrintWriter fout = new PrintWriter( new FileWriter( "./resultados/gel.txt" ) );for (int i=0;i< GEL.tamaño();i++){

Carril C = (Carril)elGel.get(i);fout.println("Carril " + (i+1) +" inicio "+ C.getIni()+ " fin " + C.getFin() + " ANCHO "Vector BandasC = C.getBandas();for (int j=0;j< BandasC.size();j++){

Banda B=(Banda)BandasC.get(j);fout.println("Banda " + (j+1) + " ymin " +B.getYmin()+ " ymax " + B.getYmax()+ "

}fout.println(" ");

}fout.close();


consola(e.toString());}

}}

pInterfaz.java

Page 14 of 14

123456789

10111213141516171819202122232425262728293031323334353637383940414243444546474849505152

package Core;/* * EdgeDetector.java * * Created on February 19, 2003, 1:54 AM */

import java.awt.*;import java.awt.image.*;import java.io.*;import java.lang.String;import javax.swing.*;import java.awt.geom.*;import com.sun.image.codec.jpeg.*;

import java.io.*;import java.util.*;import java.beans.*;import java.awt.*;import java.awt.image.*;import java.awt.image.renderable.*;import java.awt.Graphics;

import javax.media.jai.*;

public class EdgeDetector{

/* *método que carga la imagen pasada por parámetro y detecta bordes verticales izquierdos */

public BufferedImage loadAndDisplayBIVI(BufferedImage img){

ConvolveOp sobelOpV = getSobelVertOpI();BufferedImage destImage2 = createEdgeImage(img, sobelOpV);FileImageFactory FIF = new FileImageFactory();try

{BufferedImage BordesBW = destImage2;FIF.saveAsJPEG(BordesBW, "./resultados/Edge_IZQ.jpg");


System.out.println(e.toString());}return destImage2;

}

EdgeDetector.java

Page 1 of 5

5354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899

100101102103104

//-----------------------------------------------------------------------------------------------------

/* *método que carga la imagen pasada por parámetro y detecta bordes verticales derechos */

public BufferedImage loadAndDisplayBIVD(BufferedImage img){

ConvolveOp sobelOpV = getSobelVertOpD();BufferedImage destImage2 = createEdgeImage(img, sobelOpV);FileImageFactory FIF = new FileImageFactory();

try{

BufferedImage BordesBW = destImage2;FIF.saveAsJPEG(BordesBW, "./resultados/Edge_DER.jpg");



}

/* *método que carga la imagen pasada por parámetro y detecta bordes horizontales arriba */

public BufferedImage loadAndDisplayBIHup(BufferedImage img){

ConvolveOp sobelOpH = getSobelHorizOpUP();BufferedImage destImage1 = createEdgeImage(img, sobelOpH);


BufferedImage BordesBW = destImage1;FIF.saveAsJPEG(BordesBW, "./resultados/Edge_UP.jpg");



}

/* *método que carga la imagen pasada por parámetro y detecta bordes horizontales abajo */public BufferedImage loadAndDisplayBIHdown(BufferedImage img)

{

ConvolveOp sobelOpH = getSobelHorizOpDOWN();BufferedImage destImage1 = createEdgeImage(img, sobelOpH);

EdgeDetector.java

Page 2 of 5

105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156


BufferedImage BordesBW = destImage1;FIF.saveAsJPEG(BordesBW, "./resultados/Edge_Down.jpg");



}

/* *despliega en pantalla un objeto de tipo BufferedImage */

public static void displayImage(BufferedImage img){

JFrame fr = new JFrame();ImagePanel pan = new ImagePanel(img);pan.setSize(img.getHeight(), img.getWidth());fr.getContentPane().add(pan);fr.pack();fr.setSize(img.getWidth(),img.getHeight());fr.show();

}static class ImagePanel extends JComponent{

protected BufferedImage image;public ImagePanel(){}public ImagePanel(BufferedImage img){ image = img;}

public void setImage(BufferedImage img){ image = img; }

public void paintComponent(Graphics g){

Rectangle rect = this.getBounds();if(image != null){

g.drawImage(image, 0,0,rect.width, rect.height, this);}

}}/*

* dado el archivo válido, el metodo retornó la imagen tipo BufferedImage */

public static BufferedImage readAsBufferedImage(String filename){

try

EdgeDetector.java

Page 3 of 5

157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208

{FileInputStream fis = new FileInputStream(filename);JPEGImageDecoder decoder = JPEGCodec.createJPEGDecoder(fis);BufferedImage bi = decoder.decodeAsBufferedImage();

System.out.println(bi.toString());return bi;


System.out.println(e);return null;

}}

public static BufferedImage createEdgeImage(BufferedImage srcImage, BufferedImageOp op){

BufferedImage destImage = op.createCompatibleDestImage(srcImage,srcImage.getColorModel());

destImage = op.filter(srcImage, destImage);return destImage;

}

/* matriz de Sobel de detección de bordes verticales izquierdos */

public static ConvolveOp getSobelVertOpI(){

float sbvMatrix[] = {-1.0f, 0.0f, 1.0f,-2.0f, 0.0f, 2.0f,-1.0f, 0.0f, 1.0f};

Kernel kernel = new Kernel (3,3, sbvMatrix);return getConvolveOp(kernel);

}/*

matriz de Sobel de detección de bordes verticales derechos */

public static ConvolveOp getSobelVertOpD(){

float sbvMatrix[] = {1.0f, 0.0f, -1.0f,2.0f, 0.0f, -2.0f,1.0f, 0.0f, -1.0f};

Kernel kernel = new Kernel (3,3, sbvMatrix);return getConvolveOp(kernel);

}/*

matriz de Sobel de detección de bordes horizontales abajo */

public static ConvolveOp getSobelHorizOpDOWN(){

float sbhMatrix[] = {1.0f, 2.0f, 1.0f,

EdgeDetector.java

Page 4 of 5

209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246

0.0f, 0.0f, 0.0f,-1.0f, -2.0f, -1.0f};

Kernel kernel = new Kernel (3,3, sbhMatrix);return getConvolveOp(kernel);

}/*

matriz de Sobel de detección de bordes horizontales arriba */

public static ConvolveOp getSobelHorizOpUP(){

float sbhMatrix[] = {-1.0f, -2.0f, -1.0f,0.0f, 0.0f, 0.0f,1.0f, 2.0f, 1.0f};

Kernel kernel = new Kernel (3,3, sbhMatrix);return getConvolveOp(kernel);

}

/* *metodo que retorna la operación de convolución dado una matriz. */

public static ConvolveOp getConvolveOp(Kernel kernel) {

RenderingHints hints =new RenderingHints(RenderingHints.KEY_RENDERING,

RenderingHints.VALUE_RENDER_QUALITY);ConvolveOp op = new ConvolveOp( kernel,

ConvolveOp.EDGE_NO_OP,hints);

return op;}

}

EdgeDetector.java

Page 5 of 5

123456789

10111213141516171819202122232425262728293031323334353637383940414243444546474849505152

package Core;/* * Created on March 11, 2003, 7:54 PM */

/** * * @author CDavid */import java.awt.*;import java.awt.image.*;import java.applet.*;import java.util.*;import java.util.Vector;

import javax.imageio.stream.FileImageOutputStream;import java.awt.image.*;import java.awt.Image;import java.io.*;import java.lang.String;import javax.swing.*;import java.awt.geom.*;import com.sun.image.codec.jpeg.*;import java.awt.image.PixelGrabber;import java.awt.Graphics;import java.lang.Integer;import java.lang.*;import java.net.URI;

public class Pgrabber extends Applet implements ImageObserver {

private String arch_config;private String sensibilidad;private int sens;private BufferedImage imga = null;private TextField tf;private TextArea ta;private Label status;private Canvas drawarea;private Image img = null;private int ppmline=0;private Vector VBandasU,VBandasD, VcarrilIZQ, VcarrilDER, descriptor, caracterizador;

// Our imported picture stuff...

private Image picture;private int[] pixels;private int targetPixelValue;private int picWidth, picHeight;private ColorModel cm = ColorModel.getRGBdefault();

Pgrabber.java

Page 1 of 19

5354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899

100101102103104

Calculos calc= null;

// Offscreen stuff...private int Xizq, Xder, Yarr;private Image image;private Graphics offscreen;private Graphics graphics;

/**método constructor de la clase Pgrabber*/public Pgrabber(BufferedImage img2){

calc = new Calculos();try{

arch_config = "./config/contraste.ini";URI u = new URI(arch_config);File arc2 = new File( arch_config );BufferedReader br2 = new BufferedReader(new InputStreamReader(new FileInputStreamsensibilidad = br2.readLine();

Integer i = new Integer(sensibilidad);sens=i.intValue();


System.out.println("NO PUDO ABRIR EL ARCHIVO");e.printStackTrace();

}imga =img2;picture=(Image)img2;image = picture;Xizq=0;Xder=0;Yarr=0;init();

//offscreen.create();}

public void loadCarriles(BufferedImage imag3){this.loadImage(imag3);updateDescriptor(offscreen, imag3);

}

public void loadBandas(BufferedImage imag3){this.loadImage(imag3);updateCaracterizador(offscreen, imag3);

}

public void loadImageHD(BufferedImage imag3){this.loadImage(imag3);

Pgrabber.java

Page 2 of 19

105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156

updateDER(offscreen, imag3);}

public void loadImageHI(BufferedImage imag3){this.loadImage(imag3);

updateIZQ(offscreen, imag3);}

public void loadImageVU(BufferedImage imag3){this.loadImage(imag3);updateBandasU(offscreen, imag3);

}

public void loadImageVD(BufferedImage imag3){this.loadImage(imag3);updateBandasD(offscreen, imag3);

}

public void loadImageCarrilDER(BufferedImage imag3){this.loadImage(imag3);updateCarrilDER(offscreen, imag3);

}

public void loadImageCarrilIZQ(BufferedImage imag3){this.loadImage(imag3);updateCarrilIZQ(offscreen, imag3);

}

public void Bandas (BufferedImage imag3){this.loadImage(imag3);this.idBandasD(offscreen,imag3,VBandasD);this.idBandasU(offscreen,imag3,VBandasU);

}public void Carriles (BufferedImage imag3){

this.loadImage(imag3);this.idCarrilDER(offscreen,imag3,VcarrilDER);this.idCarrilIZQ(offscreen,imag3,VcarrilIZQ);

}

public void pintarRectangulo(BufferedImage imag3,int xi, int xd, int ymin){

this.loadImage(imag3);rectangulo (offscreen, imag3,xi, xd, ymin);

}public void getPixs()

{Image imag =(Image)imga; ////System.out.println("pp1");

int h= imga.getHeight(); // //System.out.println("pp2");int w= imga.getWidth(); ////System.out.println("pp3");

Pgrabber.java

Page 3 of 19

157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208

// PPM output starts.////System.out.println("dimensiones");////System.out.println(Integer.toString(w) + " " + Integer.toString(h) + "\n");////System.out.println("empiezan los pixeles \n");handlepixels(imag, 0, 0, w, h);}

public void handlesinglepixel(int x, int y, int pixel){

// pixel is in RGB model. It is a 4-byte long integer.// It is converted into the string representation of PPM pixels.// ie. Hex 0x00102030 becomes "16 32 48"String s= Integer.toString((pixel & 0x00FF0000) >> 16) + " "

+ Integer.toString((pixel & 0x0000FF00) >> 8) + " "+ Integer.toString(pixel & 0x000000FF) + " ";

//// If we use PPM RAW format, then we have to use ascii characters instead.// //// char c[]= {(char) ((pixel & 0x00FF0000) >> 16),// (char) ((pixel & 0x0000FF00) >> 8) ,// (char) (pixel & 0x000000FF) };// String s=new String(c);

//System.out.print(x + " " + y +" ");if (ppmline++>=3) { // comment out if you use RAW format.

////System.out.println(s + "\n"); // comment out if you use RAW format. ppmline=0; // comment out if you use RAW format.

}// else // comment out if you use RAW format.

////System.out.println(s);}

/**me toda manipulación de los píxeles de la imagen*/public void handlepixels(Image imga, int x, int y, int w, int h) {

int[] pixels = new int[w * h];PixelGrabber pg = new PixelGrabber(imga, x, y, w, h, pixels, 0, w);try {

pg.grabPixels();} catch (InterruptedException e) {

System.err.println("interrupted waiting for pixels!");return;

}if ((pg.status() & ImageObserver.ABORT) != 0) {

System.err.println("image fetch aborted or errored");return;

}for (int j = 0; j < h; j++) {

for (int i = 0; i < w; i++) {handlesinglepixel(x+i, y+j, pixels[j * w + i]);

Pgrabber.java

Page 4 of 19

209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260

}}

}/** método que capturan los puntos críticos para la detección de carril por el lado derecho*/public void updateDER(Graphics graphics, BufferedImage bi)

{

// binariza la imagen this.binarize(graphics,bi );

// este loop captura los valores maximos //int xmin = 0;int xmax = 0;int ymin = 0;

// Vector valoresXI = new Vector();Vector valoresXD = new Vector();Vector valoresY = new Vector();int y = 3;int x = 3;

for( y = 3; y < picHeight - 3 ; y++){// step 3

for( x = picWidth - 3; x > 3 || contrastar(x,y); x--) // step 2{

if (contrastar(x,y)){

Integer Y = new Integer(y);Integer X = new Integer(x);if (! (valoresY.contains(Y))){

valoresY.add(Y);valoresXD.add(X);

}}

}}

int a = valoresXD.size();if (a != 0){

Integer tempY= new Integer(valoresY.get(0).toString());Integer temp = new Integer(valoresXD.get(0).toString());Integer temp2 = new Integer(valoresXD.lastElement().toString());xmax = temp2.intValue();ymin=calc.minimo(valoresY, picHeight);int prom= calc.media(valoresXD);int estd= calc.estDev(valoresXD);Xder = prom;

Pgrabber.java

Page 5 of 19

261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312

}Yarr = ymin;

this.grabar(graphics,bi,"resultados/bin_DER");

}

/** método que capturan los puntos críticos para la detección de carril por el lado izquierda*/public void updateIZQ(Graphics graphics, BufferedImage bi){

this.binarize(graphics,bi );int xmin = 0;int ymin = 0;

Vector valoresXI = new Vector();Vector valoresY = new Vector();

int y = 3;int x = 3;

for(y = 3; y < picHeight - 3 ; y++){// step 3for(x = 3; x < picWidth - 3 || contrastar(x,y); x++) // step 2{


Integer Y = new Integer(y);Integer X = new Integer(x);if (! (valoresY.contains(Y))){

valoresY.add(Y);valoresXI.add(X);

}}

}}

int b = valoresXI.size();if (b != 0){

Integer tempY= new Integer(valoresY.get(0).toString());Integer temp = new Integer(valoresXI.get(0).toString());xmin = temp.intValue();Integer temp2 = new Integer(valoresXI.lastElement().toString());ymin=calc.minimo(valoresY, picHeight);int prom= calc.media(valoresXI);int estd= calc.estDev(valoresXI);Xizq= prom;

}

Pgrabber.java

Page 6 of 19

313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364

Yarr = ymin;this.grabar(graphics,bi,"resultados/bin_IZQ");

}

public BufferedImage subImagen (BufferedImage bu, int xi, int xd, int y){

return bu.getSubimage(xi, y, xd - xi, bu.getHeight() - y);

}

/** This method is called when information about an image which was * previously requested using an asynchronous interface becomes * available. Asynchronous interfaces are method calls such as * getWidth(ImageObserver) and drawImage(img, x, y, ImageObserver) * which take an ImageObserver object as an argument. Those methods * register the caller as interested either in information about * the overall image itself (in the case of getWidth(ImageObserver)) * or about an output version of an image (in the case of the * drawImage(img, x, y, [w, h,] ImageObserver) call). *

* This method * should return true if further updates are needed or false if the * required information has been acquired. The image which was being * tracked is passed in using the img argument. Various constants * are combined to form the infoflags argument which indicates what * information about the image is now available. The interpretation * of the x, y, width, and height arguments depends on the contents * of the infoflags argument. * * The <code>infoflags</code> argument should be the bitwise inclusive * OR of the following flags: <code>WIDTH</code>, * <code>HEIGHT</code>, <code>PROPERTIES</code>, <code>SOMEBITS</code>, * <code>FRAMEBITS</code>, <code>ALLBITS</code>, <code>ERROR</code>, * <code>ABORT</code>. *

* @param img the image being observed. * @param infoflags the bitwise inclusive OR of the following * flags: <code>WIDTH</code>, <code>HEIGHT</code>, * <code>PROPERTIES</code>, <code>SOMEBITS</code>, * <code>FRAMEBITS</code>, <code>ALLBITS</code>, * <code>ERROR</code>, <code>ABORT</code>. * @param x the x coordinate. * @param y the y coordinate. * @param width the width. * @param height the height. * @return <code>false</code> if the infoflags indicate that the * image is completely loaded; <code>true</code> otherwise. *

* @see #WIDTH * @see #HEIGHT * @see #PROPERTIES

Pgrabber.java

Page 7 of 19

365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416

* @see #SOMEBITS * @see #FRAMEBITS * @see #ALLBITS * @see #ERROR * @see #ABORT * @see Image#getWidth * @see Image#getHeight * @see java.awt.Graphics#drawImage *

*/public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height){

return true;}

/** este método PINTA el rectangulo con las ccordenadas capturadas previamente*/public void rectangulo(Graphics graphics, BufferedImage bi,int xi, int xd , int ymin){

offscreen = picture.getGraphics();offscreen.drawImage(picture, 0, 0, this);

//pinta el borde izquierdofor(int y = ymin; y < picHeight; y++) // step 3{

offscreen.setColor(Color.red);offscreen.fillRect(xi, y, 1, 1);offscreen.fillRect(xi-1, y, 1, 1);

}//pinta el borde derechofor(int y = ymin; y < picHeight; y++) // step 3{

offscreen.setColor(Color.red);offscreen.fillRect(xd, y, 1, 1);offscreen.fillRect(xd+1, y, 1, 1);

}//pinta el borde superior

for(int x = xi; x < xd ; x++) // step 3{

offscreen.setColor(Color.red);offscreen.fillRect(x, ymin, 1, 1);offscreen.fillRect(x, ymin-1, 1, 1);

}this.grabar(graphics,bi,"resultados/analisis");

}

Pgrabber.java

Page 8 of 19

417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468

/**metodo para contrastar un pixelv con el nivel configurado por el archivo*/public boolean contrastar (int x, int y){

try{

int pix = pixels[y * picWidth + x];int gray = (cm.getRed(pix) +

cm.getGreen(pix) +cm.getBlue(pix)) / 3;

if (gray > sens){

return true;}else{

return false;}


System.out.println("ECCECCCION " + e.toString());return false;

}}/*

* método que recorre el vector descriptor del gel para la detección de carriles */

public String describir (int x, int y){

int pix = pixels[y * picWidth + x];int R = cm.getRed(pix) ;int G = cm.getGreen(pix) ;int B = cm.getBlue(pix);if (R > 230 && G<230 && B<230){

return "ROJO";}if (G > 230 && R<230 && B<230){

return "VERDE";}if (B > 230 && R<230 && G<230){

return "AZUL";}

return "n";}

Pgrabber.java

Page 9 of 19

469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520

/* * método que recorre el vector caracterizador del gel para la detección de bandas */

public String caracterizar (int x, int y){

int pix = pixels[y * picWidth + x];int R = cm.getRed(pix) ;int G = cm.getGreen(pix) ;int B = cm.getBlue(pix);

if (R > 230 && G <230 && B <230){

return "ROJO";}if (G > 230 && R<230 && B<230){

return "VERDE";}if (B > 230 && R<230 && G<230){

return "AZUL";}if (B >130 && R> 130 && G> 130){

return "none";}return "NEGRO";

}/*

* método que capturan los puntos críticos para la detección de bandas por arriba*/

public void updateBandasU(Graphics graphics, BufferedImage bi){

this.binarize(graphics,bi );

Vector valoresY = new Vector();int y = 3;int x = 3;for(y = 3; y < picHeight - 3 ; y++){// step 3for(x = 3; x < picWidth - 3 || contrastar(x,y); x++) // step 2{


Integer Y = new Integer(y);if (! (valoresY.contains(Y))){

Pgrabber.java

Page 10 of 19

521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572

valoresY.add(Y);

}}

}}VBandasU=valoresY;

this.grabar(graphics,bi,"resultados/bandas_up");

}/*

* método que capturan los puntos críticos para la detección de bandas por abajo*/public void updateBandasD(Graphics graphics, BufferedImage bi){

this.binarize(graphics,bi );Vector valoresY = new Vector();int y = 3;int x = 3;

for(y = 3; y < picHeight - 3 ;y++){// step 3for(x = 3; x < picWidth - 3 || contrastar(x,y); x++) // step 2{


Integer Y = new Integer(y);if (! (valoresY.contains(Y))){

valoresY.add(Y);

}}

}}VBandasD=valoresY;

this.grabar(graphics,bi,"resultados/bandas_down");}

/**método que identificar las bandas por arriba*/public void idBandasU(Graphics graphics, BufferedImage bi, Vector v){


for (int y=0; y < v.size(); y++){

Pgrabber.java

Page 11 of 19

573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624

Integer I= (Integer)v.get(y);int i = I.intValue();

for(int x = 0; x < bi.getWidth() ; x++) // step 3{

offscreen.setColor(Color.blue);offscreen.fillRect(x, i, 1, 1);

}}

this.grabar(graphics, bi,"resultados/idBandasU");}

/**método que identificar las bandas por abajo*/public void idBandasD(Graphics graphics, BufferedImage bi, Vector v){


for (int y=0; y < v.size(); y++){

Integer I= (Integer)v.get(y);int i = I.intValue();

for(int x = 0; x < bi.getWidth() ; x++) // step 3{

offscreen.setColor(Color.green);offscreen.fillRect(x, i, 1, 1);

}}

this.grabar(graphics, bi, "resultados/idBandasD");}/**contrasta cada uno los pixels de la imagen y los convierte a blanco y negro*/

public void binarize(Graphics graphics, BufferedImage bi) {try{

// binariza la imagen offscreen = picture.getGraphics();offscreen.drawImage(picture, 0, 0, this);

for(int y = 0; y < picWidth; y++) // step 2for(int x = 0; x < picHeight; x++) // step 3

{// step 4int pix = pixels[x * picWidth + y];int gray = (cm.getRed(pix) +

cm.getGreen(pix) +cm.getBlue(pix)) / 3;

Pgrabber.java

Page 12 of 19

625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676

// step 5if(gray > sens)

{// step 6offscreen.setColor(Color.white);offscreen.fillRect(y, x, 1, 1);}

else{// step 6offscreen.setColor(Color.black);offscreen.fillRect(y, x, 1, 1);}

}}

catch (Exception e){System.out.println("excepcion en BINARIZE " + e.toString());}}/** método genérico para cargar en memoria la imagen.*/public void loadImage(BufferedImage imag3){

// //System.out.println(imag3.toString());picture=(Image)imag3;picWidth = picture.getWidth(null);picHeight = picture.getHeight(null);// allocate enough storage for the pixel datapixels = new int[picWidth * picHeight];

try {PixelGrabber grabber = new PixelGrabber(

/* source image */ picture,/* x origin */ 0,/* y origin */ 0,/* grab width */ picWidth,/* grab height */ picHeight,/* pixel buffer */ pixels,/* offset */ 0,/* scanline width */ picWidth);

// copy the data to the pixel array////System.out.println("se creo el pixelGragber grabber");

grabber.grabPixels();//System.out.println("se creo el pixelGragber");File exitFile = new File ("C:/temp/salida1.jpg");////System.out.println("p1");FileImageOutputStream FIOS = new FileImageOutputStream(exitFile);

// //System.out.println("p2");

Pgrabber.java

Page 13 of 19

677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728


//System.out.println("execcion de grabar archivo");//System.out.println(e.toString());

} // //System.out.println("p3");getPixs();//System.out.println("");

}

public void grabar(Graphics graphics, BufferedImage bi, String name){

graphics=null;if(graphics == null){

graphics = picture.getGraphics();

graphics.drawImage(picture, 0, 0, this);FileImageFactory FIF = new FileImageFactory();

try {String name2="./"+name+".jpg";FIF.saveAsJPEG((RenderedImage)picture, name2);


//System.out.println(e.toString());}

}else{

//System.out.println("no es nulo");graphics.drawImage(image, 0, 0, this);

}}/**método genérico para grabaran en un archivo la imagen*/public void grabar( BufferedImage bi, String name){

graphics=null;if(graphics == null){

graphics = picture.getGraphics();

graphics.drawImage(picture, 0, 0, this);FileImageFactory FIF = new FileImageFactory();

try {String name2="./resultados/"+name+".jpg";FIF.saveAsJPEG((RenderedImage)picture, name2);

Pgrabber.java

Page 14 of 19

729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780


//System.out.println(e.toString());}

}else{

//System.out.println("no es nulo");graphics.drawImage(image, 0, 0, this);

}

}/**devuelve el valor crítico derecho*/public int getXder(){

return Xder;}

/**devuelve el valor crítico izquierdo*/public int getXIzq(){

return Xizq;}/** devuelve el valor crítico arriba*/public int getYarr(){

return Yarr;}

/** asigna al valor crítico derecho xd*/public void setXder(int xd){

Xder=xd;}

/** asigna al valor crítico derecho xi*/public void setXIzq(int xi){

Xizq =xi;}

Pgrabber.java

Page 15 of 19

781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832

/** actualizar los valores del vector derecho*/public void updateCarrilIZQ(Graphics graphics, BufferedImage bi){

//System.out.println("entro a Update carril izq");// binariza la imagen this.binarize(graphics,bi );

//------------------------------------------------------------------------------ Vector valoresXd = new Vector();int y = 2;int x = 2;for(x = 3; x < picWidth - 3 ; x++) // step 2 {// step 3for(y = 3; y < picHeight - 3 || contrastar(x,y); y++){


Integer X = new Integer(x);if (! (valoresXd.contains(X))){

valoresXd.add(X);System.out.println("mete al vec X " + x +" , "+y);

}}

}}

VcarrilIZQ=valoresXd;//System.out.println("vector Y tamaño " + valoresXd.size()); this.grabar(graphics,bi,"resultados/carriles_IZQ");

}/** actualizar los valores del vector de escritor de la imagen (GEL)*/public void updateDescriptor(Graphics graphics, BufferedImage bi){

//System.out.println("entro a UpdateDescriptor");// binariza la imagen

//------------------------------------------------------------------------------ descriptor = new Vector();int y = 0;int x = 0;for(x = 0; x < picWidth; x++) // step 2

{// step 3

descriptor.add(this.describir(x,y));}

//System.out.println("vector descriptor tamaño " + descriptor.size());

Pgrabber.java

Page 16 of 19

833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884

this.grabar(graphics,bi,"resultados/carriles_DER");}

/** actualizar los valores del vector de caracterizador de la imagen (carril)*/public void updateCaracterizador(Graphics graphics, BufferedImage bi){

//------------------------------------------------------------------------------ caracterizador = new Vector();int y = 0;int x = picWidth/2;for(y = 0; y < picHeight; y++) // step 2 {// step 3

caracterizador.add(this.caracterizar(x,y));}

//System.out.println("vector descriptor tamaño " + descriptor.size()); this.grabar(graphics,bi,"resultados/carriles_DER");}

/** actualizar los valores del vector izquierdo*/public void updateCarrilDER(Graphics graphics, BufferedImage bi){

this.binarize(graphics,bi );//------------------------------------------------------------------------------

Vector valoresXd = new Vector();int y = 3;int x = 3;for(x = 3; x < picWidth - 3 ; x++) // step 2 {// step 3for(y = 3; y < picHeight - 3 || contrastar(x,y); y++)

{


Integer X = new Integer(x);if (! (valoresXd.contains(X))){

valoresXd.add(X);System.out.println("mete al vec X " + x +" , "+y);

}}

}}

Pgrabber.java

Page 17 of 19

885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936

VcarrilDER=valoresXd;this.grabar(graphics,bi,"resultados/carriles_DER");

}public void idCarrilDER(Graphics graphics, BufferedImage bi, Vector v){


for (int x=0; x < v.size(); x++){

Integer I= (Integer)v.get(x);int i = I.intValue();

for(int y = 0; y < bi.getHeight() ; y++) // step 3{// step 4

offscreen.setColor(Color.green);offscreen.fillRect(i, y, 1, 1);

}}

this.grabar(graphics, bi, "resultados/idCarrilDER");}

public void idCarrilIZQ(Graphics graphics, BufferedImage bi, Vector v){


for (int x=0; x < v.size(); x++){

Integer I= (Integer)v.get(x);int i = I.intValue();

for(int y = 0; y < bi.getHeight(); y++) // step 3{

offscreen.setColor(Color.blue);offscreen.fillRect(i, y, 1, 1);

}}

this.grabar(graphics, bi, "resultados/idCarrilIZQ");}

public Vector getDescriptorGEL(){

return descriptor;}public Vector getCaracterizadorCarril(){

Pgrabber.java

Page 18 of 19

937938939940941

return caracterizador;}

}

Pgrabber.java

Page 19 of 19

construcciÓn de un prototipo para el …

Documents