c e n i d e t jose francisc… · centro nacional de investigaciÓn y desarrollo tecnolÓgico c e n...

SEP SES DGEST

CENTRO NACIONAL DE INVESTIGACIÓN Y DESARROLLO

TECNOLÓGICO

c e n i d e t

METODOLOGÍA PARA LA ESTRUCTURACIÓN Y USO DE CONOCIMIENTO EN SEGMENTACIÓN DE IMÁGENES

DIGITALES

T E S I S QUE PARA OBTENER EL GRADO DE MAESTRO EN CIENCIAS EN CIENCIAS DE LA COMPUTACIÓN P R E S E N T A: JOSÉ FRANCISCO CERVANTES ALVAREZ _

D I R E C T O R D E T E S I S: DR. RAÚL PINTO ELÍAS

C O D I R E C T O R D E T E S I S: M. C. MATILDE VELAZCO SONI

CUERNAVACA, MORELOS DICIEMBRE DE 2006

i

Tabla de contenido

Capítulo 1 Introducción.................................................................................................................... 1

1.1 Descripción del problema........................................................................................................... 3 1.2 Propuesta de solución ................................................................................................................ 3 1.2.1 Objetivos ................................................................................................................................ 3 1.2.2 Justificación............................................................................................................................ 4 1.2.3 Beneficios............................................................................................................................... 4 1.2.4 Alcances ................................................................................................................................. 4 1.2.5 Limitaciones ........................................................................................................................... 5 1.2.6 Metodología de solución ......................................................................................................... 5 1.2.7 Organización de la tesis........................................................................................................... 7

Capítulo 2 Marco teórico.................................................................................................................. 8

2.1 Marco conceptual....................................................................................................................... 8 2.1.1 Inteligencia artificial ............................................................................................................... 8 2.1.2 Sistemas basados en conocimiento .......................................................................................... 9 2.1.2.1 Concepto de conocimiento .................................................................................................. 9 2.1.2.2 Representación del conocimiento ...................................................................................... 11 2.1.2.3 Representación de conocimiento basada en reglas ............................................................. 14 2.1.2.4 Representación de conocimiento basada en marcos ........................................................... 16 2.1.2.5 Estructura de un sistema basado en conocimiento.............................................................. 20 2.1.2.6 Mecanismos de inferencia ................................................................................................. 21 2.1.3 Procesamiento digital de imágenes ........................................................................................ 22 2.1.3.1 Segmentación de imágenes................................................................................................ 22 2.1.3.2 Álgebra de imágenes......................................................................................................... 23 2.1.3.2.1 Conjunto de puntos.......................................................................................................... 23 2.1.3.2.2 Conjuntos de valores ....................................................................................................... 25 2.1.3.2.3 Imágenes......................................................................................................................... 25 2.1.3.2.4 Plantillas ......................................................................................................................... 25 2.2 Estado del arte ......................................................................................................................... 26 2.2.1 Expert Systems for Image Processing [19]............................................................................. 26 2.2.2 SVEX: A knowledge-Based System for the automation of Image [20]................................... 26 2.2.3 BORG: A Knowledge-Based System for the Automation of Image segmentation tasks [21] .. 27 2.2.4 SEISIS: A Rule-Based Systems for Segmentation of a Seismic Section Based on Texture [22].. ............................................................................................................................................. 27 2.2.5 Knowledge Representation for Program Reuse [23]............................................................... 27 2.2.6 Controlling the Segmentation Parameters by Case-Based Reasoning [24].............................. 28 2.2.7 An Intelligente FrameWork for Image Understanding [25] .................................................... 28 2.2.8 An Architecture for Knowledge Based Image Interpretation [26]........................................... 28 2.2.9 Towards Ontology Based Cognitive Vision [27].................................................................... 29 2.2.10 Towards a Cognitive Vision Platform for Semantic Image Interpretation; Application to the Recognition of Biological Organisms [28] ........................................................................................ 29

ii

2.2.11 Comparativa del estado del arte ........................................................................................... 30 2.3 Comentarios............................................................................................................................. 30

Capítulo 3 Solución propuesta........................................................................................................ 32

3.1 Introducción............................................................................................................................. 32 3.2 Arquitectura propuesta............................................................................................................. 34 3.3 Comentarios............................................................................................................................. 36

Capítulo 4 Desarrollo de la solución............................................................................................... 37

4.1 Análisis y diseño...................................................................................................................... 37 4.1.1 El conocimiento y los algoritmos .......................................................................................... 37 4.1.2 Arquitectura del sistema........................................................................................................ 38 4.1.3 Casos de uso ......................................................................................................................... 40 4.1.3.1 Adquisición de conocimiento ............................................................................................ 40 4.1.3.2 Validación de la sintaxis del conocimiento ........................................................................ 41 4.1.3.3 Generación de scripts........................................................................................................ 41 4.1.3.4 Interpretación de scripts .................................................................................................... 42 4.1.3.5 Procesamiento de petición................................................................................................ 42 4.1.3.6 Validación de resultado..................................................................................................... 43 4.1.4 Diagramas de secuencia ........................................................................................................ 43 4.1.4.1 Adquisición de conocimiento ............................................................................................ 43 4.1.4.2 Procesamiento de una petición .......................................................................................... 44 4.1.5 La biblioteca de operadores................................................................................................... 44 4.1.5.1 Los operadores.................................................................................................................. 45 4.1.5.2 Archivo de definición de operadores ................................................................................. 46 4.1.5.2.1 Datos del operador .......................................................................................................... 47 4.1.5.2.2 Parámetros ...................................................................................................................... 47 4.1.5.2.3 Errores ............................................................................................................................ 47 4.1.5.3 Formulación en álgebra de imágenes ................................................................................. 47 4.1.6 Lenguaje de segmentación de imágenes basado en scripts ..................................................... 52 4.1.7 Intérprete de scripts............................................................................................................... 54 4.1.7.1 Esquema general del intérprete.......................................................................................... 54 4.1.7.2 Diagrama de casos de uso ................................................................................................. 55 4.1.8 La base de conocimiento ....................................................................................................... 57 4.1.8.1 Lenguaje de representación de conocimiento basado en marcos y reglas............................ 57 4.1.8.1.1 Operadores primitivos ..................................................................................................... 58 4.1.9 Motor de inferencia............................................................................................................... 60 4.1.9.1 Mecanismo general de solución de problemas ................................................................... 60 4.1.9.2 Mecanismo general del motor de inferencia....................................................................... 62 4.1.9.3 Proceso de creación del script ............................................................................................ 63 4.2 Implementación ....................................................................................................................... 64 4.2.1 Interfaz de usuario................................................................................................................. 65 4.2.2 Base de conocimiento ........................................................................................................... 65 4.2.3 Parser para LBFR................................................................................................................. 65 4.2.4 Motor de inferencia............................................................................................................... 66 4.2.5 Módulo de evaluación de resultados ...................................................................................... 66 4.2.6 Intérprete de scripts............................................................................................................... 67

iii

4.2.7 Integración de los módulos del sistema.................................................................................. 67 4.3 Comentarios............................................................................................................................. 68

Capítulo 5 Experimentación y resultados ...................................................................................... 70

5.1 Descripción del ambiente de pruebas........................................................................................ 70 5.2 Plan de pruebas........................................................................................................................ 71 5.3 Descripción de los casos de prueba .......................................................................................... 71 5.4 Comentarios............................................................................................................................101

Capítulo 6 Conclusiones.................................................................................................................102

6.1 Introducción............................................................................................................................102 6.2 Objetivos alcanzados ..............................................................................................................102 6.3 Aportaciones...........................................................................................................................105 6.4 Trabajos futuros......................................................................................................................106

Referencias.....................................................................................................................................108

Anexos ............................................................................................................................................111

8.1 Nomenclatura de álgebra de imágenes.....................................................................................111 8.2 Comandos del lenguaje de segmentación basado en scripts......................................................112 8.3 Gramática EBNF del lenguaje LBFR ......................................................................................118 8.4 Base de conocimiento de ejemplo ...........................................................................................124

iv

Índice de figuras Figura 1.0.1 Modelo de visión por computadora.................................................................................. 2 Figura 2.1 Elementos básicos del conocimiento................................................................................. 10 Figura 2.2 Arquitectura de un sistema típico basado en reglas. .......................................................... 16 Figura 2.3 Marcos de boletos de autobús. .......................................................................................... 17 Figura 2.4 Estructura básica de un sistema basado en conocimiento................................................... 20 Figura 2.5 Conjunto de puntos. ......................................................................................................... 24 Figura 2.6 Conjunto de puntos de forma rectangular.......................................................................... 24 Figura 3.1 Proceso típico para crear un sistema de PDI...................................................................... 33 Figura 3.2 Sistema de PDI basado en el paradigma de los SBC ......................................................... 34 Figura 3.3 Enfoque general para la estructuración y uso de conocimiento .......................................... 35 Figura 4.1 Modelo conceptual de la arquitectura propuesta................................................................ 39 Figura 4.2 Caso de uso "Adquisición de conocimiento"..................................................................... 40 Figura 4.3 Caso de uso "Validar conocimiento"................................................................................. 41 Figura 4.4 Caso de uso "Generación de script".................................................................................. 41 Figura 4.5 Caso de uso "Interpretación de scripts"............................................................................. 42 Figura 4.6 Caso de uso "Procesamiento de petición" ......................................................................... 42 Figura 4.7 Caso de uso "Validación de resultado".............................................................................. 43 Figura 4.8 Diagrama de secuencia "Adquisición de conocimiento".................................................... 43 Figura 4.9 Diagrama de secuencia "Procesamiento de una petición" .................................................. 44 Figura 4.10 Estructura general de un operador................................................................................... 45 Figura 4.11 Librerías requeridas para crear un nuevo operador .......................................................... 46 Figura 4.12 Máscara para detectar puntos [7] .................................................................................... 48 Figura 4.13 Máscaras de Frei Chen [7].............................................................................................. 50 Figura 4.14 Arquitectura del intérprete de scripts. ............................................................................. 54 Figura 4.15 Casos de uso del intérprete de scripts.............................................................................. 55 Figura 4.16 Mecanismo general del motor de inferencia.................................................................... 62 Figura 4.17 Proceso general de creación de un script......................................................................... 64 Figura 4.18 Interfaz de usuario.......................................................................................................... 65 Figura 4.19 Módulo del parser .......................................................................................................... 66 Figura 4.20 Módulo del motor de inferencia...................................................................................... 66 Figura 4.21 Módulo del intérprete de scripts ..................................................................................... 67 Figura 4.22 Módulos del sistema....................................................................................................... 68 Figura 5.1 Última base de conocimiento utilizada por el usuario........................................................ 72 Figura 5.2 Base de conocimiento vacía.............................................................................................. 72 Figura 5.3 Petición del usuario para segmentar círculos..................................................................... 73 Figura 5.4 Mensaje del sistema para el usuario.................................................................................. 73 Figura 5.5 Adición de conocimiento al sistema para segmentar puntos .............................................. 75 Figura 5.6 Error sintáctico en la base de conocimiento ...................................................................... 76 Figura 5.7 Base de conocimiento para segmentar puntos ................................................................... 77 Figura 5.8 Petición del usuario para segmentar puntos....................................................................... 77 Figura 5.9 Script generado por el motor de inferencia........................................................................ 78 Figura 5.10 Resultado de la segmentación de puntos ......................................................................... 78 Figura 5.11 Adición de conocimiento para segmentar líneas.............................................................. 80 Figura 5.12 Base de conocimiento para segmentar líneas................................................................... 81 Figura 5.13 Petición del usuario para segmentar líneas ...................................................................... 81 Figura 5.14 Script generado por el motor de inferencia...................................................................... 82 Figura 5.15 Resultado de la segmentación de líneas .......................................................................... 82

v

Figura 5.16 Base de conocimiento para segmentar puntos y líneas..................................................... 83 Figura 5.17 Petición del usuario para segmentar círculos................................................................... 83 Figura 5.18 Mensaje de error emitido por el motor de inferencia ....................................................... 84 Figura 5.19 Error encontrado durante el proceso de inferencia........................................................... 84 Figura 5.20 Error emitido por el sistema al tratar de segmentar elipses .............................................. 84 Figura 5.21 Base de conocimiento para segmentar puntos, líneas, círculos y elipses .......................... 87 Figura 5.22 Petición del usuario para segmentar círculos................................................................... 87 Figura 5.23 Script generado por la máquina de inferencia.................................................................. 88 Figura 5.24 Resultado de la segmentación (imagen original, imagen resultante), ............................... 88 Figura 5.25 Petición para segmentar objetos elípticos........................................................................ 89 Figura 5.26 Script para segmentar elipses.......................................................................................... 89 Figura 5.27 Resultado de la segmentación......................................................................................... 90 Figura 5.28 Algoritmo de Frei chen con sub - espacio de líneas......................................................... 91 Figura 5.29 Algoritmo de Frei Chen son sub - espacio de bordes ....................................................... 92 Figura 5.30 Petición del usuario para segmentar líneas ...................................................................... 92 Figura 5.31 Script de segmentación de líneas .................................................................................... 93 Figura 5.32 Resultado de la segmentación de líneas .......................................................................... 93 Figura 5.33 Base de conocimiento actualizada................................................................................... 95 Figura 5.34 Petición del usuario para segmentar líneas ...................................................................... 95 Figura 5.35 Script de segmentación................................................................................................... 96 Figura 5.36 Resultado de la segmentación......................................................................................... 96 Figura 5.37 Resultado esperado por el usuario................................................................................... 96 Figura 5.38 Base de conocimiento para extraer descriptores .............................................................. 99 Figura 5.39 Petición del usuario para extraer descriptores.................................................................. 99 Figura 5.40 Script para extraer descriptores......................................................................................100 Figura 5.41 Resultado de la extracción de descriptores .....................................................................100 Figura 6.1 Enfoque utilizado para aplicar métodos de SBC en segmentación de imágenes ................104 Figura 6.2 Sistema de segmentación de imágenes basado en conocimiento.......................................105

vi

Índice de tablas Tabla 2.1 Estado del arte................................................................................................................... 30 Tabla 4.1 Operadores de la biblioteca de operadores. ........................................................................ 45 Tabla 4.2 Descripción de caso de uso - Cargar registro de operadores................................................ 56 Tabla 4.3 Descripción de caso de uso - Ejecutar script...................................................................... 56 Tabla 6.1 Estudio cualitativo de formalismos de representación de conocimiento .............................103

Capítulo I Introducción

José Francisco Cervantes Alvarez 1

Capítulo 1

Introducción

Durante años han sido desarrollados diversos sistemas de visión por computadora (SVC) [28], con el fin de ofrecer soluciones a una amplia variedad de problemas como seguridad, control de calidad, automatización, aplicaciones militares, etc. Sin embargo, el desarrollar sistemas de visión confiables es uno de los principales problemas en muchas áreas de aplicación y una de las estrategias para mejorar el desempeño ha sido la utilización de conocimiento acerca de la escena y los objetos que se encuentran en la misma.

Lo expuesto anteriormente induce a pensar en la necesidad que tienen los sistemas de visión de poseer la capacidad de acceder, manipular y utilizar el conocimiento necesario para mejorar su desempeño. Si bien es cierto que los sistemas de visión por computadora que se desarrollan actualmente hacen uso de este conocimiento, es bueno aclarar que el conocimiento se encuentra de forma implícita en cada uno de los algoritmos utilizados en el sistema de visión. Lo anterior es debido a que los SVC son desarrollados para resolver sólo problemas específicos, por ejemplo, un sistema que ha sido desarrollado para segmentar manzanas sobre un fondo azul muy difícilmente obtendrá un buen desempeño al tratar de segmentar naranjas sobre un fondo rojo.



Esta forma de manejar y utilizar el conocimiento dificulta la reutilización de software y eleva el costo de desarrollo y mantenimiento de los SVC. Este problema se observa claramente con el siguiente ejemplo, imagínese que está trabajando en una empresa de desarrollo de software y que se tiene un sistema que determina la calidad de manzanas, pero ahora, un cliente ha solicitado un sistema para determinar la calidad de naranjas; lo que tendrían que hacer los programadores es tratar de adaptar los algoritmos utilizados en el sistema de las manzanas para que funcionen en el nuevo sistema o en el peor de los casos volver a programar estos algoritmos.

Lo que hacen realmente los programadores, al adaptar los algoritmos, es

cambiar y/o modificar el conocimiento que se encuentra de forma implícita en ellos para solucionar el nuevo problema. Es claro que en el ejemplo anterior, a la empresa le convendría que los sistemas pudieran cambiar su funcionalidad con el simple hecho de modificar el conocimiento relacionado a cada problema en particular.

Es deseable que los sistemas de visión por computadora posean de forma separada el conocimiento, relacionado a un problema particular, del conjunto de algoritmos y procesos que integran al SVC [5]. Con lo anterior se obtendría un SVC similar a un sistema experto desde el punto de vista de que basta cambiar la base de conocimientos de un sistema experto para modificar totalmente su funcionalidad. De esta manera, un shell de sistema experto se puede utilizar para medicina, economía, etc, sin la necesidad de modificar el shell [6].

Uno de los modelos que busca alcanzar la separación entre el conocimiento y los algoritmos utilizados en las diferentes etapas del proceso de visión por computadora es el propuesto por González [7] en su libro titulado “Tratamiento digital de imágenes”. En la figura 1.1 se observa dicho modelo.

Figura 1.0.1 Modelo de visión por computadora.

En el modelo, las flechas delgadas en doble sentido indican el flujo de

conocimiento que debe existir entre la base de conocimiento y cada una de las etapas de segmentación, mientras que las flechas blancas con un solo sentido indican el flujo típico que sigue el proceso de visión por computadora.

Base de conocimiento

Segmentación

Dominio del

problema Resultado

Preprocesado

Adquisición de imágenes

Representación y descripción

Reconocimiento e interpretación



El modelo propuesto por González [7] para los SVC establece una modularidad entre cada etapa del proceso de visión artificial y la base de conocimiento. La modularidad implica la posibilidad de mantener una independencia entre los algoritmos y el conocimiento, lo cual permite la reutilización tanto de conocimiento como de los algoritmos. Sin embargo, en la práctica, cuando se desarrolla un SVC el conocimiento queda implícito en los algoritmos utilizados por los desarrolladores. Por lo que el modelo no es implementado considerando todas sus implicaciones de modularidad, reutilización e independencia entre conocimiento y algoritmos.

1.1 Descripción del problema

En este trabajo, el problema abordado consistió en desarrollar una metodología

para la segmentación de imágenes en donde el conocimiento relacionado se encuentra separado de los algoritmos necesarios para el procesamiento de la imagen. El modelo trabaja con el conocimiento explícito que proporciona el usuario. Por esto, el desarrollo se basa en la estructura que tienen los sistemas basados en conocimiento.

1.2 Propuesta de solución

1.2.1 Objetivos

El objetivo general de este trabajo es establecer una metodología para la estructuración y uso del conocimiento en problemas de visión artificial, y particularmente, en problemas de segmentación de imágenes, la cual permita la reutilización del conocimiento. Los objetivos específicos son:

1) Contestar la pregunta ¿es posible separar en un proceso de segmentación el conocimiento de los algoritmos de segmentación en un sistema para el tratamiento digital de imágenes?

2) Estudiar y evaluar los métodos existentes para la representación y uso del

conocimiento. 3) Seleccionar e implementar los métodos de representación y uso de

conocimiento adecuados para ser aplicados a la segmentación de imágenes. 4) Diseñar e implementar una metodología basada en los métodos

seleccionados para su aplicación en la segmentación de imágenes.



1.2.2 Justificación

Los sistemas para el tratamiento digital de imágenes que se han desarrollado hasta la fecha en el cenidet, no poseen una separación clara entre los algoritmos que conforman el sistema y la base de conocimientos, por lo cual se vuelve muy difícil poder extraer el conocimiento existente en el sistema.

La dificultad para extraer el conocimiento de los sistemas de visión, hace que la reutilización del conocimiento de dichos sistemas sea una tarea bastante difícil, lo cual implica costos en cuanto a recursos como tiempo, dinero, etc.

1.2.3 Beneficios

1) Mediante la utilización de la metodología propuesta, el conocimiento de los sistemas para el tratamiento digital de imágenes quedará aislado de los algoritmos de segmentación.

2) El conocimiento de los sistemas desarrollados con la metodología propuesta

podrá ser reutilizado.

3) Los sistemas resultantes de aplicar la metodología que se propone serán más fáciles de mantener.

1.2.4 Alcances

Los alcances contemplados dentro del presente trabajo son los siguientes:

1) Estudio e implementación de al menos dos formas de representación del conocimiento.

2) Estudio de técnicas de razonamiento para la explotación del conocimiento.

3) Implementación de una base de conocimientos y una máquina de inferencia.

4) Implementación de algoritmos en donde a partir de información general de los objetos, que se encuentran en una imagen, se pueda realizar la segmentación de los mismos.

5) Implementación de algoritmos de segmentación de imágenes que utilicen información explicita de la imagen a través de parámetros, para obtener mejores resultados.



6) Implementación de un módulo que permita detectar, en imágenes digitales,

primitivas geométricas 2D como líneas, círculos, etc.

7) Desarrollo del prototipo de un sistema de visión artificial, en el que la base de conocimiento se encuentre separada de los procesos de segmentación de imágenes.

1.2.5 Limitaciones

1) La máquina de inferencia trabajará con lógica de bool.

2) La base de conocimientos utilizará dos formas de representación de conocimiento.

3) El prototipo que se desarrollará trabajará con imágenes que contengan un objeto geométrico dentro de un ambiente controlado.

4) El prototipo sólo trabajará con imágenes artificiales.

1.2.6 Metodología de solución

Para resolver el problema planteado en esta tesis se propusieron las siguientes actividades:

1) Estudiar métodos existentes que permiten caracterizar una imagen dada, lo cual permitirá posteriormente tomar decisiones sobre el tipo de procesamiento que es más adecuado para obtener los resultados deseados.

2) Estudiar e implementar algoritmos de preprocesamiento como filtros, histograma, ecualización, etc. Estos algoritmos se utilizarán para mejorar las características deseadas en una imagen, para que posteriormente se pueda llevar a cabo un buen proceso de segmentación de la imagen. La implementación de los algoritmos se hará de tal forma que a través de sus parámetros pueda variar su funcionamiento. Cada uno de los algoritmos implementados serán llamados script.

3) Diseñar e implementar un módulo en donde se almacenen las características de la imagen con la cual se esté trabajando. Esta información será utilizada por los diferentes scripts con el fin de que éstos desempeñen un mejor trabajo.



4) Estudiar e implementar algoritmos de segmentación de imágenes como umbralización, discontinuidad, etc. A cada algoritmo implementado se le llamará script de segmentación.

5) Estudiar e implementar algoritmos que permitan detectar en una imagen, primitivas geométricas como puntos, líneas, bordes, círculos, etc. Todas estas primitivas son llamadas primitivas de modelos y pueden servir para, a través de ellas, modelar objetos del mundo real. De igual forma estas primitivas pueden servir para obtener más características de la imagen, y así posteriormente poder realizar un mejor proceso de segmentación.

6) Analizar y determinar una forma, a través del cual se pueda convertir la información numérica de la imagen y sus características a una representación simbólica, que pueda ser utilizada y manipulada por una máquina de inferencia. De igual forma se busca interpretar información simbólica para ejecutar acciones, y así poder controlar el proceso de segmentación.

7) Estudiar y analizar los métodos de representación del conocimiento existentes para identificar aquellos que son más adecuados para representar y utilizar el conocimiento que se tiene en un sistema de visión por artificial con el fin de implementarlo posteriormente.

8) Estudiar los métodos de inferencia existentes en sistemas expertos, y determinar cuál es el más conveniente para utilizar y/ó una combinación de los métodos existentes.

9) Desarrollar una máquina de inferencia para procesar la base de conocimiento del sistema, o en su defecto utilizar una existente que satisfaga las necesidades encontradas en el estudio anterior de los métodos de inferencia.

10) Diseño y aplicación de un plan de pruebas a la herramienta resultante de este trabajo de tesis para observar los resultados obtenidos de utilizar un sistema en donde la base de conocimiento se encuentre separada de los algoritmos de segmentación.

Al integrar los módulos desarrollados anteriormente se espera obtener un

sistema para la segmentación de imágenes, en el cual la base de conocimientos sea independiente del resto del sistema.



1.2.7 Organización de la tesis

El presente documento está organizado de la siguiente forma:

En el capítulo 2 se presenta un panorama general (marco conceptual y estado del arte) relacionado a conceptos básicos necesarios para el desarrollo de la tesis y trabajos realizados en diversas instituciones del extranjero.

En el capítulo 3 se plantea la solución propuesta al problema que se aborda

en esta tesis y se exponen las ideas principales. El capítulo 4 se divide en dos secciones principales; la primera aborda el

análisis y diseño de la arquitectura de la herramienta que permite realizar la segmentación de imágenes manteniendo el conocimiento separado de los algoritmos, la segunda sección se enfoca en la implementación de la herramienta.

En el capítulo 5 se presenta la etapa de experimentación, mostrando las

pruebas aplicadas y los resultados obtenidos, por último en este capítulo se expone el análisis de resultados.

Finalmente el capítulo 6 presenta las conclusiones de este trabajo. Además

se describen las aportaciones y trabajos futuros que pueden surgir a partir de ésta investigación.

Capítulo II Marco teórico


2 Capítulo 2

Marco teórico

Este capítulo se divide en dos partes. Primero se describen los fundamentos computacionales necesarios para el desarrollo de la arquitectura para segmentación de imágenes. La segunda parte de este capítulo comprende una exploración sobre trabajos relacionados al tema de investigación.

2.1 Marco conceptual

2.1.1 Inteligencia artificial

El termino “Inteligencia artificial” fue concebido por John McCarthy en 1955. Una definición de Inteligencia Artificial gira en torno a la comparación entre la inteligencia de las computadoras y la inteligencia del ser humano [1]. Otra definición está relacionada al desarrollo de máquinas que tratan con el dominio de la inteligencia [2]. Sin embargo, ninguna de estas definiciones ha sido aceptada universalmente debido a que hacen referencia a la palabra "inteligencia" la cual actualmente es abstracta y no puede ser medida.



Por lo tanto, una definición más adecuada de Inteligencia Artificial necesita de la formalización del término "inteligencia". Psicólogos y teóricos cognoscitivos opinan que la inteligencia ayuda en la identificación de conocimiento que puede servir a la hora en que se toman decisiones [4]. Así que la inteligencia artificial puede ser definida como la simulación de la inteligencia humana sobre una máquina, así como hacer máquinas eficientes para identificar y utilizar las piezas correctas de conocimiento para resolver un problema [3].

2.1.2 Sistemas basados en conocimiento

2.1.2.1 Concepto de conocimiento

Existen muchas definiciones de conocimiento, dependientes de la perspectiva que se tome al definirlo. Algunas definiciones son las siguientes: 1) El conocimiento es un conjunto de datos sobre hechos, verdades o de

información ganada a través de la experiencia o del aprendizaje (a posteriori), o a través de introspección (a priori). El conocimiento es una apreciación de la posesión de múltiples datos interrelacionados que solos poseen menor valor cualitativo [5].

2) En ciencias de la información, se acostumbra a definir al conocimiento como un

conjunto organizado de datos e información destinados a resolver un determinado problema [17].

3) Por su parte [6] define lo que es conocimiento en base a sus características:

a. El conocimiento es una capacidad humana y no una propiedad de un objeto como puede ser un libro. Su transmisión implica un proceso intelectual de enseñanza y aprendizaje.

b. El conocimiento carece de valor si permanece estático. Sólo genera valor

en la medida en que se mueve, es decir, es transmitido o transformado.

c. El conocimiento genera conocimiento mediante la utilización de la capacidad de razonamiento o inferencia (tanto por parte de humanos como de máquinas).

d. El conocimiento tiene estructura y es elaborado, implica la existencia de

redes de ricas relaciones semánticas entre entidades abstractas o materiales. Así, para su transmisión es necesario que el emisor (maestro) conozca el contexto o modelo del mundo del receptor (aprendiz).

e. El conocimiento puede ser explícito (cuando se puede recoger, manipular y

transferir con facilidad) o tácito que es resultado de la experiencia acumulada por individuos, el cual es difícil de describir y transmitir.



f. El conocimiento puede estar formalizado en diversos grados, pudiendo ser

también informal. La mayor parte del conocimiento transferido verbalmente es informal.

4) Conocimiento es la capacidad para convertir datos e información en acciones

efectivas [17]. 5) Por último, el Free On-Line Dictionary of Computing [7] presenta una definición

menos filosófica y más ligada a la tecnología: conocimiento son los objetos, conceptos y relaciones que se supone que existen en un área de interés. Una colección de conocimientos, representada utilizando un lenguaje de representación del conocimiento, se llama base de conocimiento, y un programa para ampliar y/o consultar una base de conocimiento es un sistema basado en conocimiento.

El conocimiento difiere de los datos o la información en que a partir del conocimiento existente puede crearse nuevo conocimiento utilizando la inferencia lógica. Si la información es datos más significado, el conocimiento es información más procesamiento (figura 2.1).

Figura 2.1 Elementos básicos del conocimiento.

Conocimiento

Procesamiento

Relaciones Objetos

Conceptos



2.1.2.2 Representación del conocimiento

Para el desarrollo del trabajo de investigación se realizó un estudio cualitativo de cinco formalismos para representar el conocimiento, estos formalismos se listan en seguida:

a) Lógica proposicional. b) Lógica de predicados. c) Reglas de producción. d) Redes semánticas e) Marcos.

En seguida se presenta cada uno de los formalismos con sus respectivas

ventajas y desventajas. a) Lógica proposicional

A continuación se enuncias algunas ventajas y desventajas de la lógica proposicional [6] [8] [9]: Ventajas:

a) Se puede modificar fácilmente. b) Es un lenguaje bastante fácil. c) Es completa. d) Tiene poderosas herramientas de inferencia.

Desventajas:

a) No es estructurado. b) No puede representar metaconocimiento. c) No puede recoger relaciones entre objetos. d) Es monótona. Si se pone una aserción más, todos los axiomas anteriores,

siguen siendo verdaderos. e) Es semidecible. No existe ningún algoritmo que sea una demostración para

indicar si un teorema es cierto o no. b) Lógica de predicados

A continuación se enuncian algunas ventajas y desventajas de la lógica de predicados [10][6][11]: Ventajas:

a) Muy expresivo. b) Alto grado de formalismo. c) Separación de conocimiento y razonamiento.



d) Soportan funciones y predicados calculables.

Desventajas: a) Mala eficiencia. (el trabajo de razonamiento es exponencial). b) No soporta razonamiento por defecto (se necesitan extensiones). c) No estructurado. d) Para utilizar el método de resolución es necesario primero convertir las

aserciones a cláusulas de Horn. e) El método de resolución es muy lento (orden exponencial). f) Es incompatible con meta-conocimiento. g) No impone una forma única de representar el conocimiento.

c) Reglas de producción

A continuación se enuncias algunas ventajas y desventajas de las reglas de producción [6] [10] [11] [12] [13]: Ventajas:

a) Idealmente cada regla es independiente a las demás, por lo que resulta sencillo modificarlas, borrarlas o introducirlas sin afectar al resto del sistema. Desafortunadamente no siempre es posible mantener esta independencia.

b) Parece un buen modelo de cómo los seres humanos representan y resuelven problemas.

c) Es bastante natural expresar el conocimiento humano en forma de reglas. d) Es bastante sencillo incrementar el conocimiento de un sistema de producción

añadiéndole nuevas reglas. e) Obligan a representar el conocimiento de una forma uniforme. f) Es el formalismo más utilizado en los sistemas expertos. g) Más expresiva que la lógica de proposiciones. h) Sistema de razonamiento más eficiente que el de la lógica de predicados. i) Implementación más estructurada. j) Algoritmo de unificación más sencillo. k) Utilizan la hipótesis del mundo cerrado (según la cual, lo que no esté escrito

en la base de conocimiento se toma como falso). l) Permite representar meta-conocimiento y heurísticas. m) Es fácil de representar y manejar. n) Necesita de extensiones para trabajar con cuantificadores. o) Soportan funciones y predicados calculables.

Desventajas:

a) Es difícil imponer que las reglas se disparen en determinada secuencia. b) Resulta difícil seguir el comportamiento de un sistema de producción. Aunque

es muy sencillo saber qué es lo que hace cada regla en cada momento, es muy difícil determinar qué es lo que el conjunto de reglas está haciendo globalmente.

c) No permite estructurar el conocimiento.



d) No todo el conocimiento se puede representar en reglas. d) Redes semánticas

A continuación se enuncias algunas ventajas y desventajas de las redes semánticas [6] [14]: Ventajas:

a) Fácil de visualizar. b) Las relaciones pueden ser arbitrariamente definidas por el ingeniero del

conocimiento. c) El conocimiento relacionado es fácilmente agrupado. d) Eficiente en requerimiento de espacio. e) Los objetos se representan sólo una vez. f) Soporta herencia pero tiene problemas cuando se presentan excepciones.

Desventajas:

a) Situar hechos erróneamente causa problemas. b) No existe un estándar para los valores de los nodos y de los arcos. c) Representar relaciones binarias es fácil pero existen problemas con otro tipo

de relaciones. d) Problemas para representar negaciones. e) Problemas para representar disyunciones. f) Es difícil de implementar cuantificadores (extensión - redes semánticas

particionadas). e) Marcos

A continuación se enuncias algunas ventajas y desventajas de la representación basada en marcos [6][14][15]: Ventajas:

a) Maneja estereotipos. b) Soporta el manejo de excepciones. c) Soporta herencia. d) Soporta conocimiento procedimental (demonios). e) Soporta valores por default. f) Estructurados. g) Son intuitivos para varias aplicaciones. h) La organización es similar a la del conocimiento del ser humano. i) Conveniente para conocimiento causal. j) Más fácil de comprender que la lógica o las reglas. k) Muy flexible. l) Soporta el manejo de clases y metaclases.



m) Activación dinámica de procesos. Desventajas:

a) No existe un estándar para los valores que rellenan los slots. b) Es más una metodología general en lugar de una representación específica. c) No tiene asociados mecanismos de inferencia/razonamiento. d) No es tan expresivo como la lógica de predicados.

2.1.2.3 Representación de conocimiento basada en reglas

Las reglas de producción son una de las técnicas de representación de conocimiento más viejas. Un sistema experto basado en reglas incluye los siguientes elementos:

a) Una base de conocimiento, representada mediante reglas. b) Una memoria de trabajo para realizar las unificaciones de patrones de datos. c) Un motor de inferencia, el cual decide qué regla se debe disparar.

Estructura de las reglas de producción

La estructura de una regla R1 puede ser formalmente representada como: R1 : P1(x) Λ P2(x) Λ P3(x) Λ … Pn( x, z) � Q1(y) ∨ Q2(Z) ∨ … Qm(y, x)

Donde Pi y Qi son predicados, x, y, z son variables; “Λ”, “∨”, y “�” denotan los operadores lógicos “Y”, “O” y “SI-ENTONCES” respectivamente [31]. La parte izquierda de R se llama antecedente o condicional y la parte derecha se llama consecuente o conclusión. La sintaxis utilizada por las reglas es: SI <antecedente> ENTONCES <consecuente>

Otra forma de expresar las reglas es como se muestra en seguida: <consecuente> :- <antecedente>

Los antecedentes y consecuentes no necesariamente son predicados. En seguida se presentan ejemplos de reglas:

SI nombre(julia) ENTONCES mujer SI nombre(juan) ENTONCES hombre



mujer :- nombre(julia) hombre :- nombre(juan)

En esta sintaxis, “:-“ significa “SI”; esto es, se cumple el consecuente si se

satisfacen previamente los antecedentes. Memoria de trabajo

La memoria de trabajo generalmente almacena sus datos en forma de cláusulas. La parte del antecedente de las reglas es emparejado con las cláusulas almacenadas en la memoria de trabajo. En el caso de que todas las variables instanciadas de las parte del antecedente de la regla sean consistentes, entonces la regla es disparada y el nuevo consecuente es agregado a la memoria de trabajo. Ciclo de reconocimiento - acción La unidad de control e interpretación en un sistema basado en reglas pasa por tres pasos, los cuales son llamados ciclo de reconocimiento – acción [32].

1. Emparejar las variables de los antecedentes de una regla, almacenadas en una base de conocimiento, con los datos almacenados en la memoria de trabajo.

2. Si más de una regla, puede ser disparada, es necesario entonces decidir cuál

de todas las reglas será disparada mediante el uso de un conjunto de estrategias con el fin de resolver el conflicto.

3. Después de disparar la regla, se agrega el nuevo consecuente o acción a la

memoria de trabajo y se retorna al paso 1.

Generalmente, un elemento inicial es almacenado en la memoria de trabajo al iniciar el procesamiento para comenzar con el ciclo de reconocimiento - acción. El procesamiento finaliza cuando no existe ninguna regla que pueda dispararse. El proceso de resolución de conflictos ayuda al sistema en la identificación de la regla que se debe disparar. Estrategias para resolución de conflictos

Las estrategias de resolución de conflictos varían de sistema en sistema y en muchos casos se utiliza más de una estrategia o la combinación de varias. Las estrategias más importantes son:



a) Disparar la regla más reciente. b) Las reglas se disparan sólo una vez. c) Disparar la regla más específica (aquella que tiene mayor número de

antecedentes). Arquitectura de un sistema basado en reglas

La figura 2.2 muestra la arquitectura de un sistema experto que utiliza reglas como técnica de representación de conocimiento [31].

Figura 2.2 Arquitectura de un sistema típico basado en reglas.

2.1.2.4 Representación de conocimiento basada en marcos

El conocimiento puede ser representado en una computadora utilizando diversos formalismos, como los mencionados anteriormente. En esta sección se aborda la representación de conocimiento basada en marcos.

Reglas Memoria de trabajo

Unidad de búsqueda

Solución de conflictos

Control de disparo de reglas

Aplicar consecuente

Agregar / eliminar cláusulas

Agregar / eliminar cláusulas

Regla elegida

Resultado de búsqueda

Búsqueda para unificación



Concepto de marco

Un marco es una estructura de datos con conocimiento típico sobre un objeto o concepto en particular [30]. Los marcos fueron propuestos por Marvin Minsky en 1975 y fueron utilizados para representar y capturar conocimiento para sistemas expertos basados en marcos.

Los boletos de autobús mostrados en la figura 2.3 representan marcos típicos con conocimiento acerca de pasajeros del autobús. Ambos marcos tienen la misma estructura. Por ejemplo un marco llamado “persona” puede tener los siguientes slots: nombre, altura, edad. Mientras que un marco llamado “computadora” tiene los slots: modelo, procesador, memoria y precio. Cada slot tiene un valor, por ejemplo el slot “Origen” tiene el valor “México”. En algunos casos los slots pueden estar asociados a marcos o a procedimientos que retornan un valor.

Figura 2.3 Marcos de boletos de autobús.

La necesidad de utilizar marcos

Los marcos brindan una forma natural para representar el conocimiento de manera estructurada y concisa. En una sola entidad, los marcos combinan todo el conocimiento necesario acerca de un objeto en particular o concepto. Los marcos proveen un medio de organización de conocimiento en slots para describir varios atributos y características de un objeto. A diferencia de las reglas de producción, los marcos tienen la ventaja de poder organizar el conocimiento relevante sobre un objeto en particular en una sola entidad, lo cual facilita la búsqueda dentro del proceso de inferencia.

Boleto de Grupo estrella Blanca Nombre: Rocío Vargas

Origen: México

Destino: Cuernavaca

Asiento: 9

Servicio: PRIMERA

Corrida: 32180

Fecha: 06/09/2006

Hora: 22:15

Boleto de Primera Plus Nombre: Michelle Arandine Barrón

Origen: Guadalajara

Destino: México

Asiento: 5

Servicio: PRIMERA

Corrida: 859

Fecha: 12/07/2006

Hora: 22:15



Los marcos como técnica de representación de conocimiento En los marcos cada slot describe un atributo particular o procedimiento del marco. Un slot puede contener valores por default, apuntadores a otros marcos, procedimientos a través del cual el slot obtiene un valor. En general los slots pueden tener la siguiente información:

a) Nombre del marco. b) La relación de un marco con otro marco. c) Una valor (simbólico, numérico o Booleano). d) Valores por default. e) Rango de valores. f) Información procedimental (un slot puede contener un procedimiento el cual

utiliza para obtener un valor).

La forma en que se relacionan los objetos dentro de un sistema de marcos puede darse de tres formas distintas:

a) Generalización: denota la relación “un tipo de” o “es un” entre una superclase y sus subclases. Por ejemplo un carro es un vehículo o en otras palabras “carro” es la subclase de la superclase “vehículo”.

b) Agregación: denota la relación “parte de” en la cual varias subclases son

componentes de una superclase. Por ejemplo, un motor es parte de un carro.

c) Asociación: describe alguna relación semántica entre diferentes clases la cuales no se encuentran relacionadas de otra manera. Por ejemplo Pedro tiene un carro y una computadora. Las clases carro y computadora son independientes pero existen una relación semántica ya que ambos objetos pertenecen a Pedro.

Debido a que en este trabajo no se requiere del uso las relaciones

mencionadas anteriormente, no se profundiza más. Para mayores referencia consulte el “Frames as a Knowledge Representation Technique” presentado en [30]. Métodos y demonios

Como se mencionó anteriormente los marcos ofrecen una forma de organizar el conocimiento de forma concisa y estructurada. Sin embargo no es suficiente con representar el conocimiento, también se espera que el conocimiento pueda ser manipulado y para esto se necesita de la existencia de métodos y demonios.

Un método es un procedimiento asociado al atributo de un marco el cual es ejecutado cuando es necesario [30]. Los métodos pueden ser utilizados para obtener el valor de una propiedad o para ejecutar una serie de actividades o procesos. En



general un demonio tiene una estructura SI – ENTONCES y es ejecutado cuando algún atributo que se encuentra dentro del SI es modificado. En esencia un método y un demonio son muy similares, y los dos términos son usados a menudo como sinónimos. Usualmente los procedimientos se utilizan cuando se requieren procesos pesados mientras que los demonios son usados como un simple SI – ENTONCES. Interacción de reglas y marcos

Muchos de los sistemas expertos basados en marcos permiten el uso de conjuntos de reglas para evaluar información contenida en los marcos. En esencia no hay diferencia entre las reglas utilizadas en un sistema experto basado en reglas y las usadas en un sistema de marcos. A menudo en los sistemas de marcos, las reglas unifican patrones mediante las cláusulas. Estas cláusulas contienen variables que son utilizadas para buscar condiciones que se puedan unificar entre todos los marcos.



2.1.2.5 Estructura de un sistema basado en conocimiento

Un sistema basado en conocimiento (SBC) es un sistema informático con capacidad de razonar y encontrar resoluciones a problemas sobre un dominio específico [16]. Los SBC poseen tres elementos básicos: una base de conocimiento, un motor de inferencia y la memoria de trabajo. En la figura 2.4 se muestra la estructura básica de un SBC.

Figura 2.4 Estructura básica de un sistema basado en conocimiento.

Adquisición de conocimiento. Es el elemento mediante el cual el experto

puede modificar la base de conocimiento. Los usuarios relacionados a este elemento son el experto y el ingeniero de conocimiento.

Base de conocimiento. Almacena un conjunto de conocimientos aplicables a un dominio en concreto y puede utilizar alguno de los formalismos mencionados en la sección 2.1.2.2 para su representación.

Motor de inferencia. Consta de un algoritmo para manipular los conocimientos y solucionar los problemas propuestos por el usuario. En la siguiente sección se presentan diversos mecanismos de inferencia los cuales pueden ser utilizados por el motor de inferencia.

Memoria de

trabajo


Motor de inferencia

Núcleo del sistema

Elementos básicos

Adquisición de conocimiento

Interfaz de usuario



Memoria de trabajo. Tiene la función de almacenar los datos proporcionados por el usuario, el objetivo propuesto y los resultados de las inferencias intermedias realizadas por el motor de inferencia.

Interfaz de usuario. Este elemento permite la entrada de datos, consultas y objetivos. Sin embargo también permite la salida de las repuestas por parte del sistema y la justificación de las mismas.

2.1.2.6 Mecanismos de inferencia

En esencia, el razonamiento es la habilidad para resolver problemas. Sin embargo, simplemente porque un dispositivo puede resolver un problema no significa que es capaz de de razonar. Por ejemplo, una calculadora puede resolver una variedad de problemas matemáticos, pero desde luego tal habilidad para resolver problemas no es un ejemplo de razonamiento [17].

Hay muchos sistemas de razonamiento que pueden ser utilizados para resolver problemas. En este trabajo se dividen estos sistemas en tres categorías principales presentadas abajo; sin embargo, existen algunas técnicas de razonamiento que abarcan más de una categoría. a) Razonamiento inductivo

En el razonamiento inductivo (inferencia no demostrativa) es aquel proceso en el que se razona partiendo de los particular para llegar a lo general, justo lo contrario que con la deducción. La base de la inducción es la suposición de que si algo es cierto en algunas ocasiones, también lo será en situaciones similares aunque no se hayan observado. Una de las formas más simples de inducción, ocurre cuando con la ayuda de una serie de encuestas, de las que se obtienen las respuestas dadas por una muestra; es decir, con una pequeña parte de la población total es pocible extraer conclusiones acerca de una población [17]. Con bastante frecuencia se realizan en la vida cotidiana dos tipos de operaciones inductivas, que se denominan predicción y causalidad.

La predicción consiste en tomar decisiones o plantear situaciones, basándose en acontecimientos futuros predecibles, como por ejemplo ocurre cuando una persona se plantea: ¿qué probabilidades de trabajo existen si se cursa una carrera? Con las evidencias que se tienen se induce una probabilidad, y se toma una decisión.

La causalidad induce al error en muchas ocasiones. La causalidad es la

necesidad que se tiene de atribuir causa a los fenómenos que ocurren alrededor. Por ejemplo, la atribución causal que se hace ante un accidente de coche depende de quien la realice, enfatizando así una de las causas y minimizando el resto (punto de



vista en base a conocimientos previos o especialidad: meteorólogo � la niebla, psicólogo � el estrés, etc). b) Razonamiento analógico

En el razonamiento analógico, se debe de hacer una correspondencia entre los elementos y operaciones de dos distintos sistemas. Normalmente, uno de los sistemas es muy bien comprendido, y el otro es sobre el cual se tienen preguntas. Se pueden contestar estas preguntas al encontrar una correspondencia con el sistema que ya se conoce. Un ejemplo es utilizar los conocimientos y la intuición acerca del flujo de fluidos para razonar acerca del flujo de la corriente eléctrica [17]. El mayor problema de este tipo de lógica es encontrar una correspondencia entre el sistema conocido y el desconocido. c) Razonamiento deductivo

El razonamiento deductivo parte de categorías generales para hacer afirmaciones sobre casos particulares. Va de lo general a lo particular. Es una forma de razonamiento donde se infiere una conclusión a partir de una o varias premisas [17]. En un razonamiento deductivo válido, la conclusión debe derivarse necesariamente de las premisas, lo que quiere decir que, si las premisas del razonamiento son verdaderas, la conclusión ha de ser verdadera. Por ejemplo, si se acepta que toda X es Z y que W es X, la conclusión lógicamente necesaria es que W es Z. No se pueden afirmar las premisas y negar la conclusión sin una contradicción. Por medio de un razonamiento de estas características se concede la máxima solidez a la conclusión, las premisas implican lógicamente la conclusión. Y la conclusión es una consecuencia lógica de las premisas.

2.1.3 Procesamiento digital de imágenes

El procesamiento digital de imágenes (PDI) se define como el conjunto de técnicas y modelos que permiten el procesamiento, análisis y explicación de cualquier tipo de información espacial obtenida a través de imágenes digitales. El modelo de González [7] esta formado por las siguientes etapas: adquisición de la imagen, preprocesamiento, segmentación, descripción y representación, reconocimiento de patrones e interpretación.

2.1.3.1 Segmentación de imágenes

En el procesamiento digital de imágenes, después de la adquisición y preprocesado de la imagen, el primer paso del análisis de imágenes generalmente es segmentar la imagen, lo cual consiste en dividir una imagen en sus partes



constituyentes u objetos. Los algoritmos de segmentación se clasifican en base a alguna de las siguientes propiedades [7]:

• Discontinuidad. La idea básica de estos métodos es dividir una imagen basándose en los cambios bruscos de nivel de gris. En la práctica, la forma más común de ver las discontinuidades es pasar una máscara a través de la imagen. Las principales áreas de interés de estos algoritmos son la detección de puntos aislados y la detección de bordes y líneas de una imagen.

• Similaridad. La idea básica de estos métodos es explotar las dos propiedades

básicas que tienen los pixeles; posición y nivel de gris. En las imágenes aparecen ciertas áreas o zonas (regiones) caracterizadas por el hecho de que constituyen agrupaciones de pixeles conectados entre sí, pero además de la conexión, los pixeles presentan propiedades o características comunes. Las principales técnicas de esta categoría se basan en la umbralización, el crecimiento de regiones, y división y fusión de regiones.

2.1.3.2 Álgebra de imágenes

En esta sección se definen los conceptos básicos del álgebra de imagen que sirve de base para poder realizar la formalización algebraica de la segmentación de imágenes digitales, para profundizar en este tema consulte [18].

2.1.3.2.1 Conjunto de puntos

Un conjunto de puntos es simplemente un espacio topológico. Así, un conjunto

de puntos consiste en una colección de objetos y una topología la cual provee nociones tales como proximidad de dos puntos, la conectividad de un subconjunto del conjunto de puntos, la vecindad de un punto, puntos de límite, curvas y arcos. Los conjuntos de puntos se denotan mediante las últimas letras del alfabeto en mayúsculas y negrita, es decir, W, X, Y y Z. Los puntos (elementos del conjunto) son denotados por las últimas letras del alfabeto en minúscula y negritas, por ejemplo: x,

y, z∈X. Nótese que si x∈nℜ , entonces x es de la forma x = (x1, x2, x3,…, xn), donde

para cada i = 1, 2,…, n, xi denota un número real llamado iesima-coordinada de x. Lo anterior se muestra en la figura 2.5.



Figura 2.5 Conjunto de puntos.

La mayoría de los conjuntos de puntos son subconjuntos discretos del espacio

euclidiano n-dimensionalnℜ con n = 1, 2 ó 3 junto con una topología discreta. La

forma más común de los conjuntos de puntos es la rectangular. Dos de los conjuntos de puntos rectangulares más comunes son de la forma:

X = ℑm X ℑn = {(x1, x2) ∈ ℑ2: 0 ≤ x1 ≤ m-1, 0 ≤ x2 ≤ n-1} ó

X = ℑ+m X ℑ+n = {(x1, x2) ∈ ℑ2: 1 ≤ x1 ≤ m, 1 ≤ x2 ≤ n} Este conjunto se puede observar de forma más clara en la figura 2.6.

Figura 2.6 Conjunto de puntos de forma rectangular.

1 2 n

m

1

2

X = ℑ+m X ℑ

+n

X (Conjunto de puntos)

x y

z

Puntos

Si x∈∈∈∈nℜ entonces

x =

x1 x2 x3 . .

xn



2.1.3.2.2 Conjuntos de valores

Un álgebra homogénea es un álgebra heterogénea con sólo un conjunto de

operandos. El álgebra homogénea será referenciada como un conjunto de valores y será denotada por letras mayúsculas en negritas, por ejemplo E, G, H. Hay conjuntos de valores que son utilizados con mayor frecuencia en procesamiento de imágenes. Por ejemplo, el conjunto de números enteros, números binarios y los números reales [18].

2.1.3.2.3 Imágenes

Los operandos principales en el álgebra de imágenes son las imágenes,

plantillas y vecindades. De estos tres tipos de operandos, las imágenes son las más importantes ya que las plantillas y vecindades pueden ser vistas como casos especiales del concepto general de una imagen. Se define una imagen en términos generales, con un mínimo de especificaciones. En adelante se usará la notación AB para denotar el conjunto de todas las funciones A � B (es decir, AB = {f: f es una función de B a A}).

Definición: Dado un conjunto de valores F y un conjunto de puntos X. Una imagen F-valuada a∈Fx (es decir, a: X�F), entonces F es llamado el conjunto de valores posibles de a y X el dominio espacial de a.

Es a menudo conveniente dar la gráfica de una imagen a∈ƒx que representa a a. El gráfico de una imagen también es llamado como la representación de estructura de datos de la imagen. Dada la representación de estructura de datos a = {(x, a(x)):x∈X}, entonces un elemento (x, a(x)) de la estructura de datos es llamado elemento de la imagen o píxel. La primera coordenada x de un píxel es llamada ubicación del píxel, y la segunda coordenada a(x) es llamada el valor del píxel de a en la ubicación x.

2.1.3.2.4 Plantillas

Las plantillas también son llamadas máscaras o ventanas. Además, plantilla

generaliza la noción de elementos estructurales, como se usa en la morfología matemática.

Definición: Una plantilla es una imagen cuyos valores del píxel son las imágenes (las funciones) [18]. En particular, una plantilla F-valuada de Y a X es una función t:Y�Fx. Así, t ∈ (Fx)y y t es una imagen Fx-valuada sobre Y. Por conveniencia rotacional se define ty≅t(y) ∀y ∈Y. ty = {(x, ty(x)): x∈X}. Los valores de píxel ty(x) de esta imagen son llamados pesos de la plantilla en el punto y.



2.2 Estado del arte

En esta sección se exponen los trabajos existentes en el estado del arte que se

consideraron de mayor importancia. Los trabajos relacionados se encuentran ordenados en orden cronológico.

2.2.1 Expert Systems for Image Processing [19]

Varios sistemas expertos para procesamiento de imágenes han propuesto facilitar el desarrollo de procesos de análisis de imágenes. Ellos utilizan el conocimiento sobre estas técnicas para componer complejos operadores primitivos para el procesamiento de imágenes. En este artículo se clasifica a estos trabajos en cuatro categorías que se listan a continuación y se discuten sus objetivos, representaciones de conocimiento, métodos de razonamiento y problemas futuros.

a) Sistema de consulta para procesar imágenes. b) Sistema de composición de programas basado en conocimiento. c) Sistema de diseño basado en reglas para algoritmos de segmentación de

imágenes. d) Sistema de segmentación de imágenes dirigido por objetivos.

En la última parte del artículo, se enfatiza la importancia de las estrategias en

la realización de un efectivo análisis de imágenes. Para ello se proponen dos métodos para representar dichas estrategias: una desde el punto de vista de la ingeniería de software y la otra desde el punto de vista de los sistemas expertos.

2.2.2 SVEX: A knowledge-Based System for the automation of Image [20]

SVEX es una herramienta basada en conocimiento multinivel para desarrollar aplicaciones en segmentación de imágenes. Ambas, computaciones numéricas e icónicas toman lugar en cada nivel, existe una transición entre estos dos dominios definida mediante la misma estructura computacional. SVEX incorpora combinación de hechos y mecanismos de control de incertidumbre. SVEX se programa mediante un leguaje declarativo de propósito específico basado en un reducido conjunto de objetos.

Todo el conocimiento involucrado en la solución de un problema de

segmentación dado es hecho explicito debido a la naturaleza declarativa del lenguaje de programación. Esta herramienta se ha probado en escenas al aire libre.



2.2.3 BORG: A Knowledge-Based System for the Automation of Image segmentation tasks [21]

En este artículo se presenta un sistema basado en conocimiento que

automatiza la ejecución de los procesos de segmentación de imágenes. Dada una imagen y un conjunto de tareas de segmentación, el sistema, llamado BORG, genera y optimiza el procesamiento de operadores de segmentación clásica. Así, el sistema debe tener la capacidad de autoconfigurar diferentes tareas de segmentación para diferentes clases de imágenes.

Los autores de este artículo se interesan en resolver los problemas de segmentación mediante la integración semántica de los procedimientos de esta etapa. El sistema realiza el razonamiento en base a conocimiento explícito acerca de la pericia en segmentación de imágenes, con el objetivo de generar un grafo de operadores.

2.2.4 SEISIS: A Rule-Based Systems for Segmentation of a Seismic Section Based on Texture [22]

SEISIS es un sistema basado en conocimiento para la segmentación

automática de secciones sísmicas de regiones grandes con propiedades de textura comunes. El conocimiento del experto humano se introduce en el sistema para resolver incertidumbres en los datos numéricos y para ayudar a tomar decisiones sobre la segmentación. Este conocimiento es dependiente del dominio. Pero también existe conocimiento que resulta de hacer la segmentación de regiones dentro de una imagen. El problema que existe en la implementación es como integrar estas distintas fuentes de conocimiento para poder lograr una buena segmentación.

2.2.5 Knowledge Representation for Program Reuse [23]

Ellos, en este trabajo abordan el tema de los programas y el conocimiento los cuales se han convertido en una parte importante del patrimonio (o propiedad intelectual) de compañías. Sin embargo, la importancia de este conocimiento es mucho mayor en el código fuente. Con el fin de administrar este conocimiento, en este trabajo se propone modelarlo mediante una ontología general para administrar programas y un lenguaje de descripción de conocimiento, para documentar, modelar y capitalizar el conocimiento sobre el uso del código. El trabajo presenta los conceptos de la ontología, su representación concreta en el lenguaje y algunos ejemplos de uso mediante diferentes mecanismos de inferencia.



2.2.6 Controlling the Segmentation Parameters by Case-Based Reasoning [24]

En este trabajo se propone un sistema de segmentación de imágenes basado

en casos, el cual toma información que no es de la imagen y características de la imagen y selecciona entre un conjunto de casos de uso, aquel que sea mejor para el problema actual. Los parámetros asociados al caso seleccionado son aplicados y tomados para la segmentación del caso seleccionado. Tomando en cuenta la información y las características de la imagen se puede reducir el espacio de solución en un subespacio de casos relevantes donde la variación entre los casos es limitada. Además que con RBC se puede aprender de forma incremental nuevos parámetros de segmentación de imágenes. En este trabajo utilizan el enfoque propuesto para la determinación de la relación brain/liquor en imágenes. Este parámetro es utilizado para el diagnóstico de la enfermedad Alzheimer.

2.2.7 An Intelligente FrameWork for Image Understanding [25]

Este trabajo está dirigido a las cuestiones de diseño de un sistema inteligente de comprensión de imágenes. Se propone un sistema que tiene dos módulos: el módulo de segmentación inteligente de imágenes (IISM) y el módulo de interpretación global de imágenes (GIIM). En el IISM, se propone utilizar una combinación de técnicas de procesamiento de imágenes y un esquema inteligente basado en conocimiento que cooperan para tomar segmentos de la imagen y etiquetarlos. Para implementar el GIIM, se propone utilizar métodos inteligentes de razonamiento basado en casos (CBR) para manipular conocimiento específico relacionado al problema de interpretación de la imagen. El CBR puede ser implementado en ambos módulos IISM y GIIM. También se propone en este trabajo utilizar un sistema basado en reglas para incorporar conocimiento general del dominio. También se presenta un estudio breve sobre cuestiones de implementación del CBR incluyendo representación de casos y medidas de similaridad.

2.2.8 An Architecture for Knowledge Based Image Interpretation [26]

Con el objetivo de cubrir el problema de reconocimiento automático de objetos complejos naturales en su ambiente natural, en este trabajo se propone una arquitectura cooperativa original basada en tres sistemas basados en conocimiento especializado. El primer sistema está dedicado a la interpretación de alto nivel. El segundo sistema contiene el conocimiento acerca de la transición entre datos numéricos y simbólicos. El tercer sistema está especializado en supervisión de programas de procesamiento de imágenes. Este trabajo considera que en el área de visión artificial existen sólo tres niveles de abstracción.

a) El nivel bajo el cual trata con conocimiento acerca del procesamiento de imágenes.



b) El nivel intermedio el cual contiene conocimiento acerca de la transición entre datos numéricos y datos simbólicos.

c) El nivel alto el cual contiene todo el conocimiento específico del dominio: escena y modelos de objetos.

La arquitectura propuesta en este trabajo está diseñada con respecto a estos

tres niveles.

2.2.9 Towards Ontology Based Cognitive Vision [27]

En este trabajo se estudia la dificultad que existe para construir bases de conocimiento para sistemas de visión basados en conocimiento. El documento busca mostrar cómo una ontología compuesta de conceptos visuales puede ser usada como guía para describir objetos de un dominio especifico de interés. Uno de los beneficios más importantes del enfoque propuesto en este trabajo es que el proceso de adquisición de conocimiento guiado por una ontología acerca más la base de conocimiento a una visión de bajo nivel. Aquí se propone una metodología genérica que sea independiente de cualquier dominio de aplicación. Finalmente en este trabajo se afirma que una ontología para la descripción de imágenes es el primer paso hacia un sistema completo de visión cognitiva que involucrará una capa de aprendizaje.

En este trabajo se identifican tres tipos de conocimiento:

a) Conocimiento sobre el dominio. b) Conocimiento acerca de cómo relacionar la escena y la imagen. c) Conocimiento sobre procesamiento digital de imágenes.

2.2.10 Towards a Cognitive Vision Platform for Semantic Image Interpretation; Application to the Recognition of Biological Organisms [28]

Este trabajo trata de la visión cognitiva y en particular de la interpretación

semántica de imágenes. Uno de los principales retos de un sistema de visión cognitivo es desarrollar un sistema flexible, adaptable, capaz de realizar tareas de análisis de imágenes complejas y de extraer información de varias escenas e imágenes. El objetivo de este trabajo es atacar estos problemas mediante el diseño de una plataforma de visión cognitiva genérica y reutilizable para problemas complejos de interpretación semántica de imágenes. La interpretación semántica es compleja y puede ser subdividida en tres sub-problemas:

a) La interpretación semántica. b) El problema de relacionar la representación de alto nivel de objetos físicos y

los datos extraídos de la imagen.



c) El problema del procesamiento de imágenes.

Para administrar y separar las diferentes tipos de conocimiento y razonamiento, se propone una arquitectura basada en la cooperación de tres sistemas basados en conocimiento. Cada sistema esta altamente especializado en uno de los problemas mencionados anteriormente. Para cada sub-problema se definieron un motor dedicado y un modelo de representación de conocimiento. Para validar la plataforma del sistema de visión cognitivo, se seleccionó una aplicación del mundo real. Este trabajo fue realizado en cooperación con INRIA.

2.2.11 Comparativa del estado del arte

La tabla 2.1 muestra un comparativo entre los trabajos encontrados en el estado del arte y el trabajo que se desarrolló en esta tesis.

Tabla 2.1 Estado del arte

Proyecto – ORION

Características [20] [21] [22] [24] [25] [23] [26] [27] [28] Tesis

Representación

Leng. Declar-ativo

Árbol AND/THEN

Reglas RBC RBC Reglas

Marcos Reglas

Marcos Reglas

Segmentación √ √ √ √ √ √ √

Interpretación X X X X √ √ X

Conocimiento Imagen Dependiente

Escena PDI

Depend Escena Imagen

Imagen

Independ.

Imagen Escena

Independ. Imagen Escena PDI

Independ. Imagen Escena PDI

Operadores Biblio. Biblioteca ? ------ Casos Biblioteca LSSI

Imágenes Aire libre

Microscopio Textura Cerebro ------ Complejas Geométricas

Tipo documento Art. Art. Art. Art. Art. Art. Art. Art. Tesis Tesis

La primer columna de la tabla 2.1 muestra las características que poseen los

artículos y tesis estudiadas, el primer renglón agrupa 4 artículos realizados por el proyecto ORION y el segundo renglón se muestran los trabajos analizados (se encuentran referenciados.)

2.3 Comentarios

Como puede verse, para el desarrollo de la tesis se requirió conocimiento de

dos áreas de la inteligencia artificial; los sistemas basados en conocimiento y la visión artificial. En el marco conceptual se exponen los conceptos básicos. Se describe la estructura básica de los sistemas basados en conocimiento y se presentan las ventajas y desventajas de cinco formalismos para representar conocimiento. De igual manera se abordan tres tipos de razonamiento; inductivo, analógico y deductivo.



Respecto a la visión artificial se abordan conceptos como el procesamiento digital de imágenes y en concreto la etapa de segmentación de imágenes, la cual puede llevarse acabo mediante técnicas basadas en similaridad o discontinuidad. Finalmente se aborda de forma breve el álgebra de imágenes la cual permite formalizar operaciones de procesamiento digital de imágenes.

Del estado del arte analizado se observa que han sido desarrollados distintos trabajos relacionados al tema de tesis, en los cuales la mayoría utiliza más de un formalismo para representar el conocimiento. Sin embargo, de los trabajos analizados, ninguno está enfocado en establecer una separación entre los algoritmos de segmentación y el conocimiento relacionado a los mismos. El siguiente capítulo está dedicado a exponer el enfoque propuesto en el desarrollo de este trabajo.

Capítulo III Solución propuesta


3 Capítulo 3

Solución propuesta

3.1 Introducción

Con el fin ofrecer un panorama global, en este capítulo se presenta de manera

general la solución propuesta. Antes de comenzar con el enfoque propuesto, se explica la problemática existente en los sistemas de procesamiento digital de imágenes.

Actualmente los sistemas de procesamiento digital de imágenes son

desarrollados a la medida, por lo que dependen fuertemente del dominio del problema. La figura 3.1 muestra la forma típica en que se desarrollan los sistemas de PDI actualmente.



Figura 3.1 Proceso típico para crear un sistema de PDI

El ejemplo mostrado en la figura 3.1 pertenece al proceso general que se lleva

a cabo para el desarrollo de un sistema de PDI en la inspección visual de cualquier producto; como de las manzanas. El primer requerimiento para el desarrollo de este sistema es la existencia de un grupo de expertos en control de calidad de manzanas, estas personas deben de transmitir todo el conocimiento referente al proceso de control de calidad, que se realiza de forma visual, a un experto en procesamiento digital de imágenes el cual procede a seleccionar los algoritmos de PDI necesarios en base al problema. Con esto, el experto en PDI desarrolla en un lenguaje procedimental (por ejemplo C++ Builder) el sistema de PDI. Como producto se obtiene un software en donde el conocimiento tanto de los expertos en el control de calidad de las manzanas como del experto en PDI se encuentra embebido en el código fuente del sistema.

Los problemas que normalmente se presentan al desarrollar los sistemas de PDI de la forma expuesta anteriormente son:

a) Problemas para reutilizar el conocimiento. b) Se dificulta la reutilización de los algoritmos de PDI. c) Dificultad para modificar el funcionamiento del sistema.

Debido a lo anterior, en este trabajo se propone establecer una estructuración

que provea una separación entre el conocimiento y los algoritmos de PDI, de tal forma que se facilite la reutilización y el mantenimiento de este tipo de sistemas.

Con el fin de separar el conocimiento, se tomó como base la estructura de los

sistemas basados en conocimiento, por lo que cabe resaltar que el desempeño del sistema resultante será totalmente dependiente de la calidad del conocimiento que se posea para resolver problemas [30].

Utilizando el paradigma de los sistemas basados en conocimiento, el proceso

de desarrollo de un sistema de PDI es como el mostrado en la figura 3.2.

Expertos en control de calidad Experto en PDI

Sistema de PDI

PDI



Figura 3.2 Sistema de PDI basado en el paradigma de los SBC

Si se compara la figura 3.2 con la figura 3.1 se siguen observando los dos actores: expertos en control de calidad y el experto en PDI. Sin embargo, en esta ocasión el experto en PDI desarrolla un sistema de segmentación basado en conocimiento en el cual el conocimiento se encuentra separado del proceso utilizado para encontrar la solución a un problema específico. De esta forma, es posible que posteriormente los expertos en control de calidad puedan vaciar su conocimiento en la base de conocimientos del sistema. Con lo anterior se obtiene un sistema de segmentación basado en conocimiento para un problema en particular. La ventaja de desarrollar el sistema de la forma que se indica en la figura 3.2 es que el conocimiento se separa del procedimiento de inferencia y de los algoritmos de segmentación.

3.2 Arquitectura propuesta

La idea básica que se plantea para resolver el problema es utilizar la estructura

de los sistemas basados en conocimiento para separar el conocimiento y utilizar los marcos y reglas como formalismos para representar dicho conocimiento, de modo que partiendo de una petición realizada por el usuario y una base de conocimiento, un motor de inferencia generará un script de segmentación, para posteriormente poder llevar a cabo el proceso de segmentación. Aquí con el fin de facilitar el problema se toma al script como una etapa intermedia entre el conocimiento y los algoritmos de PDI. En la figura 3.3 se muestra el enfoque utilizado.

SBC

Motor de inferencia

Conocimiento

SBC particular

Motor de inferencia

Expertos en control de calidad Usuario

Experto en PDI



Figura 3.3 Enfoque general para la estructuración y uso de conocimiento

En el capítulo 4 se presenta y explica con mayor detalle la arquitectura propuesta y cada uno de sus componentes, ya que el objetivo de este capítulo sólo es proveer al lector de un panorama general de la solución propuesta. En lo que resta del capítulo se define de manera general cada uno de los elementos que integran la arquitectura propuesta.

a) Biblioteca de operadores

El conjunto de programas de PDI independientes entre ellos y al archivo de

registro de los programas se les llama en este trabajo biblioteca de operadores, en donde cada operador representa a un programa en particular y posee la definición de la sintaxis de cada uno de los operadores. La manera en que pueden ser manipulados estos operadores e interactuar entre ellos, es mediante la utilización de un lenguaje basado en scripts.

b) Lenguaje de segmentación de imágenes basado en scripts

Como se mencionó anteriormente los scripts se consideran como una etapa

intermedia entre el conocimiento y la etapa de segmentación. Por lo cual se desarrolló un lenguaje de segmentación basado en scripts que permita la manipulación e interacción de los diferentes operadores existentes en la biblioteca descrita anteriormente. El lenguaje de scripts permite tener una forma de representar procesos de segmentación, sin embargo hay que ejecutar ese proceso para obtener los resultados, razón por la cual se desarrollo un intérprete para el lenguaje de scripts. En el capítulo 4 se profundiza en este tema.

Motor de inferencia

Petición

Intérprete de scripts

script

Resultados

B. C. Operadores

de PDI

Conocimiento c) e)

a) d)



c) Intérprete de scripts

El intérprete de scripts es el encargado de procesar cada uno de los comandos

existentes en el script, para que este módulo realice su trabajo es necesario abrir un archivo de definición de sintaxis, en el cual se almacena cada uno de los operadores existentes en la biblioteca. Lo anterior es con el objetivo de que el lenguaje de scripts sea dinámico y exista la opción de agregar operadores nuevos o eliminar alguno ya existente. Para agregar, eliminar o modificar un operador es necesario editar el archivo de registro de los operadores.

d) Base de conocimiento

La base de conocimiento del sistema, es la que contiene el conocimiento

relacionado a cuándo y cómo utilizar cada uno de los operadores existentes en la biblioteca de operadores. Además también permite modelar procesos para segmentar objetos específicos como líneas, círculos, etc. Para representar el conocimiento se eligieron dos formalismos: los marcos y las reglas. Por lo que se define un lenguaje que utiliza marcos y reglas como representación de conocimiento.

e) Motor de inferencia

Debido al desarrollo del lenguaje para representación de conocimiento basado

en marcos y reglas (LBFR), surgió la necesidad de implementar un motor de inferencia que explote el conocimiento representado mediante LBFR. El motor de inferencia es el que recibe la petición del usuario para realizar la segmentación, además debe indicar al motor de inferencia con qué base de conocimiento trabajará. Básicamente este elemento de la arquitectura es el encargado de buscar la solución del problema y lo hace creando un script de segmentación, el cual envía al intérprete de scripts para su procesamiento.

3.3 Comentarios

Como puede verse en la sección 3.1, es deseable que el conocimiento se

encuentre separado de los algoritmos de segmentación. En este capítulo se mostraron los elementos básicos de la arquitectura propuesta para mantener la separación entre conocimiento y algoritmos bajo el enfoque de los sistemas basados en conocimiento. Cada elemento de la arquitectura ha sido desarrollada cómo módulo independiente. En el siguiente capítulo se profundiza en cada uno de los módulos.

Capítulo IV Desarrollo de la solución


4 Capítulo 4

Desarrollo de la solución

4.1 Análisis y diseño

4.1.1 El conocimiento y los algoritmos

Los algoritmos de segmentación de imágenes son normalmente utilizados por personas denominados expertos y estos se basan en su pericia para obtener una buena segmentación como resultado. Es decir, ellos tienen el conocimiento sobre cómo ejecutar los programas, cómo ajustar los parámetros, cuándo utilizar cada uno de los algoritmos de segmentación existentes, así como también el conocimiento sobre cómo combinar los algoritmos para resolver problemas complejos [23].

Existen dos tipos de conocimiento en los algoritmos de segmentación [29], que son de interés para este trabajo.

• ¿Cuándo utilizar un algoritmo? • ¿Cómo utilizar dicho algoritmo? (es decir; ¿qué parámetros se requieren? y

¿cómo se inicializan?).



Sin embargo existe un tercer tipo de conocimiento que es el algoritmo mismo (conocimiento procedimental), lo anterior se puede ver agrupado como:

El conocimiento procedimental puede ser representado mediante lenguajes de programación clásicos como C++, en donde se describe paso a paso la solución de un problema. Mientras que el conocimiento declarativo es representado mediante reglas, marcos, redes semánticas, lógica descriptiva, etc. En esta tesis, se utiliza para representar el conocimiento procedimental el lenguaje C++ Builder, mientras que para representar el conocimiento declarativo se propone utilizar marcos y reglas. La selección de los métodos de representación de conocimiento, es el resultado de un estudio comparativo entre los diferentes métodos de representación existentes.

4.1.2 Arquitectura del sistema

En el capítulo anterior se mostró de manera general la arquitectura propuesta para establecer una separación entre el conocimiento y los algoritmos de segmentación, en el presente capítulo se profundiza en cada uno de los elementos que integran la arquitectura propuesta y se explica la forma en que se comunica cada elemento.

La arquitectura ha sido diseñada tomando en cuenta el conocimiento que se

puede separar de los algoritmos de segmentación (sección 4.1.1) y se propone la posibilidad de definir objetos en la base de conocimiento como puntos, líneas, etc. Esto es, a través de las funcionalidades que deben de llevarse a cabo para segmentar un objeto, por ejemplo una línea. La figura 4.1 muestra el modelo conceptual de la arquitectura propuesta.

Procedimental Algoritmos

Conocimiento

Declarativo

¿Cuándo utilizar el algoritmo X?

¿Cómo utilizar el algoritmo X?



Figura 4.1 Modelo conceptual de la arquitectura propuesta

En la figura 4.1 se observa cómo se estable una separación física entre la base de conocimiento y los algoritmos de segmentación. Para explicar cada elemento de la arquitectura propuesta es necesario realizar las siguientes observaciones: Aspectos relacionados al conocimiento:

a) Debido al requerimiento de una base de conocimiento, es necesario contar con un lenguaje de representación de conocimiento. En este trabajo se diseñó e implementó un lenguaje que se basa en dos formalismos: marcos y reglas. En apartados siguientes se expone el lenguaje desarrollado.

b) El desarrollo del lenguaje para representar el conocimiento implicó

también la necesidad de diseñar e implementar un motor de inferencia que procese el conocimiento.

Aspectos relacionados a los algoritmos:

c) Partiendo de la idea de crear un script de segmentación como etapa intermedia del procesamiento de la imagen, surge la necesidad de diseñar e implementar un leguaje basado en scripts. Para lo cual se estableció el siguiente requerimiento:

Motor de inferencia (MI-PDI)

Base de conocimiento (BC-COM)

Adquisición de conocimiento nuevo

Validación de conocimiento nuevo Biblioteca de operadores

(Programas)

Intérprete de scripts (SI)

Script

Conocimiento

Conocimiento

Conocimiento Sintaxis

Conocimiento Parámetros Resultado

Petición Imagen

BMP

Archivo de definición de operadores

Sintaxis

BMP

Resultados

CONOCIMIENTO ALGORITMOS



� El lenguaje debe ser dinámico para que soporte agregar nuevos comandos al lenguaje, eliminarlos o modificar sus sintaxis.

d) Debido a lo anterior se plantea la existencia de un archivo en donde se

registren las sintaxis de los comandos que pertenecen al lenguaje. Mientras tanto los algoritmos de segmentación quedan aislados unos de otros como programas independientes (operadores).

e) El conjunto de programas de segmentación que estén registrados en el

archivo de registro de sintaxis forman la biblioteca de operadores.

En secciones posteriores se profundiza en cada uno de los componentes de la arquitectura.

4.1.3 Casos de uso

En esta sección se presentan los principales casos de uso para la arquitectura propuesta. Los principales casos de uso son:

1) Adquisición de conocimiento. 2) Validación de conocimiento. 3) Generación de scripts. 4) Interpretación de scripts. 5) Procesamiento de petición. 6) Validación de resultado.

4.1.3.1 Adquisición de conocimiento

Codificar en LBFR

Fuente de conocim iento(experto)

Explicitar conocimiento

Figura 4.2 Caso de uso "Adquisición de conocimiento"

En la figura 4.2 se muestra el primer caso de uso, el cual consiste en la

adquisición de nuevo conocimiento como su nombre lo indica. En este caso el



experto en PDI es quien agrega nuevo conocimiento al sistema, lo cual implica explicitar el conocimiento mediante el lenguaje LBFR.

4.1.3.2 Validación de la sintaxis del conocimiento

SistemaValidar conocimiento Validar gramática

Análisis léxico

Análisis Sintáctico

Figura 4.3 Caso de uso "Validar conocimiento"

Como su nombre lo indica el objetivo de este caso es validar el conocimiento que el usuario agregó al sistema. En la figura 4.3 se observa el caso de uso en UML, en la etapa de validación el sistema realiza un análisis léxico y sintáctico para verificar que el conocimiento esté explicitado de forma correcta en LBFR. Sin embargo se recomienda como trabajo futuro hacer otro tipo de validación sobre el conocimiento adquirido.

4.1.3.3 Generación de scripts

Crear peticiónUsuario

Generar script Procesar conocimiento

Inferencias

Generar comandos

Figura 4.4 Caso de uso "Generación de script"

La generación de scripts requiere que el usuario previamente cree una petición, indicando qué imagen va a procesar, cuál es el objeto de interés y algunas características de la imagen si así lo requiere el usuario. En la figura 4.4 se muestra el diagrama del caso de uso, se observa que para generar el script es necesario que el sistema procese el conocimiento realizando inferencias y a la vez debe ir generando los comandos para el script.



4.1.3.4 Interpretación de scripts

Usuario Procesar script Interpretar script

Ejecutar comandos

Cargar sintaxis

Figura 4.5 Caso de uso "Interpretación de scripts"

En la figura 4.5 se observa el diagrama que corresponde al caso de uso, se muestra que para procesar un script, es necesario realizar una interpretación del mismo.

4.1.3.5 Procesamiento de petición

Crear petición

Generar script

Procesar conocimiento

Inferencias

Generar comandos

Usuario

Procesar petición

Interpretar script Mostrar resultados

Figura 4.6 Caso de uso "Procesamiento de petición"

Este caso de uso engloba los cuatro primeros casos de uso presentados (figura 4.6), ya que abarca todo el proceso de explotación de conocimiento y llega hasta la presentación de resultados. La secuencia en la que se lleva acabo el procesamiento se muestra en la sección 4.1.4.



4.1.3.6 Validación de resultado

Usuario Validar resultado

Figura 4.7 Caso de uso "Validación de resultado"

El último caso de uso contemplado es el de validación de los resultados. Esto

es, después del procesamiento realizado sobre la imagen el usuario puede evaluar de forma manual los resultados obtenidos. En la figura 4.7 se observa el diagrama del caso de uso.

4.1.4 Diagramas de secuencia

En esta sección se muestra la forma en que interactúan cada uno de los componentes de la arquitectura presentada en la figura 4.1. En los diagramas de secuencia se agrega un elemento llamado IGU (Interfaz gráfica de usuario).

4.1.4.1 Adquisición de conocimiento

: experto : IGU : Parser : Base de conocim iento

nuevoConocimiento

val idarConocimiento

val idación

agregarConocimiento

conocimientoAlmacenado

Figura 4.8 Diagrama de secuencia "Adquisición de conocimiento"

En la figura 4.8 se puede observar la forma en que interactúan los elementos de la arquitectura propuesta cuando se quiere agregar nuevo conocimiento al sistema.



4.1.4.2 Procesamiento de una petición

: Biblioteca de operadores

: usuario : Motor de inferencia : Base de conocim iento

: Parser : Intérprete de scripts

: IGU

procesarPetición()leerConocimiento()

conocimiento

val idarConocimiento()

val idación

iniciarRazonamiento

razonamiento

crearComandos

script

procesarScript cargarSintaxis

sintaxi sComandos

Análisis léxico, sintáctico y semántico

ejecutarComando

resultado

Figura 4.9 Diagrama de secuencia "Procesamiento de una petición"

En el diagrama 4.9 se muestra la secuencia en la que interactúan los elementos de la arquitectura cuando un usuario realiza una petición de segmentación al sistema.

4.1.5 La biblioteca de operadores

Como se mencionó en el capítulo 3, la biblioteca de operadores se integra a un conjunto de programas para segmentar imágenes y las operaciones básicas para abrir, guardar y mostrar las imágenes. En la tabla 4.1 se listan los operadores que conforman la biblioteca considerados para este trabajo y la función de cada uno de ellos.



Tabla 4.1 Operadores de la biblioteca de operadores.

# Operador Función 1 VerImagen Permite visualizar una imagen 2 AbrirImagenGris Permite abrir una imagen 3 GuardarImagenGris Permite guardar una imagen 4 BinariazarImagenGris Permite aplicar un umbral 5 AbrirMascara Permite cargar una mascara 6 Convolución Aplica la operación de convolución 7 PKernelGaussiano Crea una máscara gaussiana 8 Canny Algoritmo de segmentación de bordes 9 FreiChen Permite segmentar líneas

10 HoughLine Detecta líneas 11 CHT Detecta círculos 12 EHT Detecta elipses 13 ExtraerContorno Extrae el contorno de un objeto segmentado 14 ExtraerCaracteristicas Extrae los momentos invariantes de Hu

4.1.5.1 Los operadores

Librerias del núcleo para el manejo de datos (números, cadenas, imágenes y mascaras).

Recepción de argumentos (rutas de archivos donde se encuentra el contenido de los argumento).

Cuerpo del operador (procedimientos del algori tmo de PDI).

Retornar resultado (se hace almacenando el contenido en la ruta indicada por el último argumento del programa).

Figura 4.10 Estructura general de un operador.

En la figura 4.10 se muestra de manera general la estructura que debe poseer

un operador para que pueda formar parte de la biblioteca y pueda interactuar en un futuro con otros operadores a través del intérprete de scripts. Algunos elementos de la estructura pueden omitirse, por ejemplo, en la cabecera sólo se deben incluir aquellas librerías del núcleo (figura 4.11) que se necesiten. No es necesario que un operador retorne algún resultado, por ejemplo el operador para mostrar una imagen sólo despliega la imagen en pantalla sin necesidad de retornar datos. Sin embargo por default es necesario que un operador reciba al menos un argumento.



Se puede ver claramente que el requerimiento para que un operador pueda ser utilizado como parte de la biblioteca es que utilice los tipos de datos definidos en el intérprete y que los parámetros que necesite para su ejecución se reciban mediante la especificación de las rutas de archivos en donde se encuentra el contenido.

Finalmente también es necesario que los datos de salida se almacenen en un archivo, especificado por el último argumento que recibe el programa. En la figura 4.11 se muestran las librerías que son necesarias para crear un nuevo operador.

Figura 4.11 Librerías requeridas para crear un nuevo operador

4.1.5.2 Archivo de definición de operadores

En la figura 4.1 se observa, como parte de la arquitectura propuesta, un archivo de definición de operadores. Este archivo es texto plano y el contenido es el registro de cada uno de los operadores que integran la biblioteca de operadores. Para que el sistema pueda utilizar algún operador es necesario que este sea previamente registrado en el archivo de definición. La información que se almacena por cada operador se organiza en tres secciones:

1. Datos del operador. 2. Datos de parámetros. 3. Errores.

CBMP24

CNumero

CCadena

CContorno

CMascara

Imágenes BMP de 24 bits

Números reales y enteros

Cadenas y literales

Contornos de objetos

Mascaras para convolución



4.1.5.2.1 Datos del operador

Los datos del operador permiten identificarlo e indican de forma general la

sintaxis del operador. Los datos que constituyen esta sección son:

a) Nombre del operador. b) Ruta del archivo ejecutable. c) Ruta del archivo de ayuda. d) Número de parámetros de entrada. e) Número de parámetros de salida. f) Número de errores.

4.1.5.2.2 Parámetros

Después de la sección de datos del operador continua la sección de datos de

parámetros, aquí por cada parámetro que requiera el método se debe tener la siguiente información:

a) Nombre del parámetro. b) Flujo del parámetro (entrada / salida). c) Tipo de dato. d) Comentarios.

4.1.5.2.3 Errores

Esta sección tiene el objetivo de registrar los códigos de error que puede retornar el operador en caso de algún evento inesperado. Los datos por cada error posible son:

a) Código de error. b) Mensaje para el usuario.

4.1.5.3 Formulación en álgebra de imágenes

Cada uno de los operadores que se han mencionado anteriormente y que forman parte de la biblioteca de operadores, pueden ser formalizados mediante el uso de álgebra de imágenes; debido a que el objetivo de este trabajo no es la formalización de los operadores, este documento se limita a presentar dos ejemplos. En la descripción de cada uno de los ejemplos primero se explica el método y posteriormente se expone la formalización en álgebra de imágenes.



a) Detección de puntos

La detección de puntos aislados dentro de una imagen se obtiene directamente utilizando la máscara que se muestra en la figura 14.12.

Figura 4.12 Máscara para detectar puntos [7]

Se sabe que se ha detectado un punto en la posición en la que está centrada

la máscara si se cumple |R|>ττττ, donde ττττ es un umbral no negativo, y R está dado por la ecuación 1:

R = w1z1+ w2z2 +…+ w9z9 (1)

Donde zi es el coeficiente asociado con la máscara wi. La respuesta de la máscara está definida con respecto a la posición de su centro. La idea básica de esta formulación es que el nivel de gris de un punto aislado será bastante diferente del de sus vecinos [18]. Formulación en álgebra de imágenes

Dada la imagen original a∈ℜ x y dada la máscara t definida como se indica a continuación:

La imagen resultante (con los puntos detectados) ésta dada por la convolución lineal derecha que se muestra en seguida:

b:= a ⊕⊕⊕⊕ t

Donde, dado que Y ⊂ Rm, a∈FX, y t∈(FX)Y y donde F∈{ℜℜℜℜ}. El producto de convolución lineal derecha se define como:

a ⊕⊕⊕⊕ t = {(y, b(y)): y∈Y, b(y) = ∑∩∈ )S(tXx y

a(x) ty(x)}

Posteriormente hay que binarizar la imagen b, utilizando un umbralττττ. La imagen

c estará dada por la función característica:

-1 -1 -1 -1 8 -1 -1 -1 -1

W1 W2 W3 W4 W5 W6 W7 W8 W9

t(i, j)(y) = -1 si x = (i-1, j-1), (i-1, j), (i-1, j+1), (i, j-1), (i, j+1), (i+1, j-1), (i+1, j), (i+1, j+1) 8 si x = (i, j)



b) Detección de líneas

Una sub-imagen b de una imagen a podría pensarse como un vector ℜ9. Por ejemplo, la sub-imagen mostrada en la siguiente máscara:

Tiene una representación vectorial

La estructura matemática del vector espacial ℜ9 puede ser representado como un espacio vectorial de sub-imagen de 3 × 3. Dado V que denota el espacio vectorial de sub-imágenes de 3 × 3. Una base ortogonal para V, Βv, que es usada para el método Frei-Chen es la mostrada en la figura 4.13. El sub-espacio E de V que es atravesado por las sub-imágenes v1, v2, v3 y v4 se llama sub-espacio de bordes de V. El método de detección de bordes Frei-Chen se basa en determinar los puntos de borde mediante el tamaño del ángulo entre la sub-imagen b y su proyección sobre el espacio de bordes. El ángulo θE entre b y su proyección sobre el espacio de bordes ésta dado por:

El producto dot de b, c ∈ V, ésta dado por

b •••• c =∑=

8

0iiicb .

Un valor pequeño de θE implica un mejor ajuste entre b y el sub-espacio de

bordes.

1 si b(x) ≥ ττττ 0 si no

c (x) =

b4 b3 b2

b5 b0 b1

b6 b7 b8

b =

b0

b1

.

.

b8

b =



Figura 4.13 Máscaras de Frei Chen [7]

Para cada punto (x, y) en la imagen original a, el algoritmo Frei-Chen para cada detección de borde calcula el ángulo θE entre la proyección de la sub-imagen de 3 × 3 centrada en (x, y) y el sub-espacio de bordes de V. Después de que θE es calculado para cada punto de la imagen, se aplica un umbral ττττ para seleccionar los puntos para los cuales θE < ττττ.

Se puede utilizar también la umbralización basada en la estadística [18]:

Base sub-espacial (Bordes)

1 2 1

0 0 0 -1 - 2 -1

1 0 -1

2 0 - 2 1 0 -1

V1 V2

0 -1 2 1 0 -1

- 2 1 0

2 -1 0

-1 0 1 0 1 - 2

V3 V2

Base sub-espacial (Líneas)

0 1 0 -1 0 -1 0 1 0

-1 0 1 0 0 0 1 0 -1

V5 V6

1 -2 1 -2 4 -2 1 -2 1

-2 1 -2 1 4 1 -2 1 -2

V7 V8

1 1 1 1 1 1 1 1 1

V9



La cual es fácil de procesar. En este caso, un valor grande indica la existencia de un punto de borde fuerte. El método de Frei-Chen puede ser utilizado para detectar líneas. Las sub-imágenes v5, v6, v7 y v8 forman las bases del sub-espacio de líneas de V. El umbralizado para la detección de líneas se realiza utilizando:

Los valores altos indican la existencia de un punto que pertenece a una línea. Formulación en álgebra de imágenes

Sea la imagen fuente a ∈ ℜℜℜℜx y v(i)y denota la plantilla (máscara) parametrizada cuyos valores son definidos por la imagen vi de la figura anterior. La celda central de la imagen vi de la plantilla está dada por la posición de y. Para un nivel de umbral ττττ dado, la imagen de líneas l de Frei-Chen está dada por [18]

La imagen e de bordes de Frei-Chen ésta dada por:



4.1.6 Lenguaje de segmentación de imágenes basado en scripts

El lenguaje de scripts permite manipular los operadores existentes en la biblioteca de operadores, de forma que puedan interactuar entre sí, para satisfacer las necesidades del usuario en cuanto a problemas de segmentación de imágenes.

El lenguaje consta de la definición de los siguientes tipos de datos: Entero, Real, Cadena, ImagenGris, Mascara y Contorno. De igual forma se definen las operaciones de asignación, suma, resta, multiplicación y división. El lenguaje posee las siguientes estructuras básicas:

• Declaración. • Asignación. • Llamada a operador.

Lo anterior forma una estructura general, y el resto depende de los operadores

que sean registrados en la biblioteca de operadores. A lo anterior se le denomina núcleo del lenguaje. Es por esta razón que el intérprete del lenguaje de scripts es tan importante. Esta forma de definir el lenguaje en donde sólo se establecen las estructuras pero no se definen los elementos del lenguaje ofrece la ventaja de permitir agregar elementos o comandos nuevos de forma dinámica, sin la necesidad de modificar el código del núcleo. La única restricción para agregar un operador a la biblioteca es seguir la especificación de una estructura básica (que se presenta posteriormente) para la interacción entre el núcleo y los operadores.

Antes de comenzar con la gramática del lenguaje, debe quedar claro que en el momento en el que un usuario necesite agregar operadores a la biblioteca y los registre en el sistema entonces el número de métodos que soporte el programa y la gramática crecerá.

Dado el siguiente alfabeto del lenguaje: ∑∑∑∑ = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, g, h, i, j, k, l, m, n, ñ, o, p, q, r, s, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N, Ñ, O, P, Q, R, S, T, U, V, W, X, Y, Z, Entero, Real, Cadena, ImagenGris, Mascara, :, \, ,,’, (, ), /, *, -, +, =}

La gramática esta definida por: G = {NT, T, P, S} donde: NT = No terminales, T = Terminales, P = Reglas de producción y S = Símbolo inicial. NT = {Declaración, Asignación, Método, ExpresiónAritmetica, Variable, NUMERO, ENTERO, REAL, Literal, Digito, Digito2, Decimal, Carácter, Símbolo, Método} T = {Entero, Real, ImagenGris, Mascara, Contorno, AbrirImagenGris, VerImagenGris, GuardarImagenGris, BinarizarImagenGris, NegativoImagenGris, RestarImagenGris,



AbrirMascara, Convolución, CrearMascaraG, Canny, ExtraerContorno, ExtraerCaracteristicas, FreiChen, Lineas, Circulos, Elipses}

Nota: Los elementos terminales que se encuentran en cursiva son métodos que se agregaron dinámicamente, igual que estos, el usuario puede registrar sus propios métodos. En la gramática se ésta omitiendo la representación de los parámetros de los métodos en cursiva, ya que estos dependen del usuario y pueden ser modificados. S: es el símbolo inicial. P: conjunto de reglas de producción. < S > :: = <Declaración> | <Asignación> | <Método> <Declaración> :: = Entero (<VARIABLE>,)* <VARIABLE> <VARIABLE> :: = <Carácter>+ (<Carácter> | <Digito>)* <Carácter> :: = a | b | c | d | e | f | g | h | i | j | k | l | m | n | ñ | o | p | q | r | s | t | u | v | w | x | y | z | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z <Digito> :: = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 <Digito2> :: = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 <NUMERO> :: = - (ENTERO | REAL) | (ENTERO | REAL) <ENTERO> :: = 0 | <Digito2> (<Digito>)* <REAL> :: = (0 . <Digito>+) | (<Digito2>+ <Digito>*. <Digito>+) <Asignación> :: = <Variable> = (<Variable> | <Método> | <ExpresiónAritmetica>) <Método> :: = AbrirImagenGris | VerImagenGris | GuardarImagenGris | BinarizarImagenGris | NegativoImagenGris | RestarImagenGris | AbrirMascara | Convolución | CrearMascaraG | Canny | ExtraerContorno | ExtraerCaracteristicas | FreiChen | Lineas | Circulos | Elipses <ExpresiónAritmetica> :: = <E> + <E> |<E> - <E> |<E> / <E> |<E> * <E> |<( E )> |<E> < E > :: = <NUMERO> | <VARIABLE> | <ExpresiónAritmetica>



En la sección de anexos se presenta la sintaxis de cada uno de los comandos que se encuentran registrados como parte del lenguaje, también se especifican las precondiciones y poscondiciones para cada uno de los comandos.

4.1.7 Intérprete de scripts

Dentro de la arquitectura propuesta, el intérprete de scripts es quien controla la secuencia de ejecución de los operadores que procesan una imagen. En esta sección se muestran los detalles del diseño del intérprete.

4.1.7.1 Esquema general del intérprete

La arquitectura del sistema esta diseñada para que el lenguaje pueda crecer de forma modular en base a las necesidades de los usuarios. La idea principal en el desarrollo de este intérprete es que los comandos de los scripts se puedan registrar de forma dinámica. En la figura 4.14, se observan los componentes que integran el esquema general del intérprete.

Figura 4.14 Arquitectura del intérprete de scripts.

El archivo de definición de operadores es el lugar en donde se registran los

operadores existentes en la biblioteca. Para que el intérprete reconozca un operador como parte del lenguaje de scripts es necesario que éste registrado en el archivo.

Cuando el intérprete recibe el script que debe procesar, lo primero que hace

es aplicarle un parser para verificar que los comandos están libres de errores léxicos, sintácticos y semánticos. Posteriormente envía el script al administrador de procesos el cual comienza a procesar cada uno de los comandos.

Biblioteca de operadores (Programas)

Administrador de memoria

Archivo de definición de operadores

script

BMP

Resultados


Parser

Administrador de procesos

Sintaxis Script

Resultados intermedios

Operadores



4.1.7.2 Diagrama de casos de uso

Cargar Script

Crear script

<<include>>

Se refiere a crear la instancia de un script, lo cual se puede hacer; escribiendo un nuevo script, abriendo uno existente y/o modificando el script existente.

Usuario

Ejecutar Script

Cargar registro de operadores

Aplicar parser<<include>>

Administrar procesos

<<include>>

Interprete

Administrar memoria

<<include>>

Figura 4.15 Casos de uso del intérprete de scripts

En la figura 4.15 se muestran los principales casos de uso del sistema. En

secciones posteriores se describirá la forma en que interactúan los componentes del sistema y el flujo de trabajo, así como los mensajes con los que se comunican entre sí. Descripción del caso de uso - Cargar registro de operadores

Este caso de uso se lleva acabo cuando se inicia el intérprete y básicamente consiste en leer el contenido del archivo que contiene el registro de los operadores que integran a la biblioteca de operadores. Recuérdese que los operadores son programas independientes, para la segmentación de imágenes. En secciones



posteriores se abarca el tema de los operadores. La tabla 4.2 muestra una descripción del caso de uso.

Tabla 4.2 Descripción de caso de uso - Cargar registro de operadores. Identificador CU-C1 Nombre Cargar registro de operadores Actor Intérprete Función Construir en memoria las estructuras sintácticas y semánticas que

permitirán reconocer los operadores en el script que se vaya a procesar.

Descripción El intérprete lee el contenido del registro de operadores que pertenecen a la biblioteca de operadores y carga a memoria sus estructuras sintácticas y semánticas.

Pre-condición Ninguna Paso Acción

1 Abrir archivo del registro de operadores 2 Mientras haya operadores seguir, si no ir a 7 3 Tomar operador 4 Crear estructura sintáctica 5 Crear estructura semántica 6 Cargar estructuras, el alias y ruta del operador en

memoria. 7 Retornar a 2

Secuencia normal

8 Finaliza la carga del registro Post-Condición Estructuras sintácticas y semánticas de los operadores. Presunción El sistema se encuentra listo para comenzar a ejecutar scripts.

Descripción de caso de uso – Ejecutar script La tabla 4.3 muestra la descripción del caso de uso – ejecutar script.

Tabla 4.3 Descripción de caso de uso - Ejecutar script. Identificador CU-C2 Nombre Ejecutar script Actor Intérprete Función El intérprete inicia la ejecución de los comandos (operadores). Descripción El intérprete comienza a buscar errores en el script, en caso de que

no se encuentre ningún error se procede a ejecutar cada comando (operador).

Pre-condición El archivo de definición de los operadores debe estar cargado. Paso Acción

1 Inicializar buffer de errores. 2 Inicializar memoria. 3 Análisis léxico. 4 Si no hay errores: Análisis sintáctico. 5 Si no hay errores: Análisis semántico. 6 Si no hay errores: Actualizar memoria.

Secuencia normal

7 Procesar el script. Post-Condición Resultado de la ejecución. Presunción El sistema ejecutó el script satisfactoriamente.



4.1.8 La base de conocimiento

Se seleccionaron para su implementación los métodos de representación de conocimiento basado en marcos y reglas. La idea es utilizar la capacidad de los marcos para representar conceptos y/u objetos, mientras que las reglas permitirán controlar el comportamiento de los operadores de segmentación, existentes en la biblioteca de operadores. La base de conocimiento tiene las siguientes características de implementación:

• La base de conocimiento se almacena en un archivo de texto plano. • La extensión utilizada por un archivo de base de conocimiento es *.bdc.

• La base de conocimiento se puede editar en cualquier editor de texto plano

sin formato.

• En es sistema sólo se puede cargar una base de conocimiento a la vez.

• El conocimiento se agrega a la base de conocimiento de manera secuencial, respetando la gramática del lenguaje LBFR.

4.1.8.1 Lenguaje de representación de conocimiento basado en marcos y reglas

El lenguaje que se propone sólo cubre las necesidades de estructuración y

uso de conocimiento en problemas de segmentación de imágenes. Para ello se proponen marcos predeterminados que se presentarán más adelante.

Un aspecto muy importante en la definición de este lenguaje es el tipo de conocimiento que se va a representar (ver sección 4.1.1). A partir de esta observación se comienza a definir los elementos del lenguaje LBFR. A continuación se presentan los marcos predefinidos que conforman al lenguaje LBFR.

• OperadorPrimitivo. • Imagen.

• Objeto.

• Petición.

Estos 4 elementos son el núcleo del lenguaje LBFR, cabe mencionar que dentro de los marcos OperadorCompuesto y Objeto se definen conjuntos de reglas las cuales controlan el comportamiento de las secuencias de ejecución.



4.1.8.1.1 Operadores primitivos

Retomando la idea básica de contar con una biblioteca de operadores en un

lenguaje basado en scripts, en LBFR existe un elemento llamado OperadorPrimitivo el cual equivale a un operador dentro de la biblioteca. En otras palabras OperadorPrimitivo es el enlace entre el conocimiento procedimental y el conocimiento declarativo. Este marco posee los siguientes slots.

• Nombre. • Comentario. • Características. • ParametrosEntrada. • ParametrosSalida. • ReglasParametros. • Comando.

Los dos primeros slots se describen por sí mismos, el primero permite asignar un nombre que identifique al marco (este identificador debe ser único en toda la base de conocimiento) y el segundo admite un comentario el cual puede ser una descripción del marco o de su uso.

El objetivo del slot Características es almacenar qué propiedades posee el

operador, por ejemplo; velocidad, costo computacional, calidad, etc.

Los dos siguientes slots llamados ParametrosEntrada y ParámetrosSalida permiten especificar, como sus nombres lo indican, los parámetros necesarios para que pueda ser utilizado el operador y los parámetros en donde se almacenan los resultados obtenidos después de ser aplicado dicho operador.

Finalmente el slots ReglasParametros es distinto a los anteriores en donde el contenido eran propiedades, sin embargo en este caso el contenido del slot son un conjunto de reglas las cuales hacen que el operador pueda modificar su comportamiento en base a la imagen de entrada y a sus propias características del OperadorPrimitivo, en la sección 4.1.8.2 se profundiza sobre el funcionamiento de las reglas.

El slot Comando permite establecer la relación entre el conocimiento declarativo y el conocimiento procedimental, básicamente es el operador de la biblioteca que se debe ejecutar. Los marcos considerados en este trabajo son los siguientes:

a) Imagen

Este marco permite especificar al usuario cuál es la imagen sobre la que se va

a realizar el procesamiento. De igual forma se pueden especificar propiedades de la



imagen, por ejemplo; indicar si una imagen es binaria o que existe la presencia de ruido en la misma. Los slots que contiene este marco son:

• Nombre. • Archivo. • Características.

El slot Nombre permite asignar un identificador al marco (el identificador debe

ser único). En el slot llamado “Archivo” se almacena la ruta en donde se encuentra el la imagen en formato BMP. Finalmente el slot llamado “Características” permite especificar algunas propiedades de la imagen, por ejemplo si es binaria, etc.

b) Objeto

Este marco permite estructurar el conocimiento y etiquetarlo con un nombre

simbólico el cual puede adquirir significado semántico. Básicamente el conocimiento que se estructura son las funcionalidades que pueden ser utilizadas para segmentar a un objeto en cuestión e información que ayude a realizar el procesamiento. Por ejemplo, se puede crear un objeto y etiquetarlo como línea. Para el usuario el concepto línea tiene un significado; sin embargo, para la computadora sólo existen conjuntos de píxeles con una topología.

Es por eso que el conocimiento que agrupa el objeto línea son las funcionalidades necesarias para poder unir dentro de un conjunto de píxeles (imagen). Los slots que tiene el objeto marco son:

• Nombre. • Comentarios. • Propiedades. • ReglasObjeto.

El slot llamado “Propiedades” permite al usuario especificar características del

objeto. El slot llamado “ReglasObjeto” es el más importante de este marco y permite especificar las reglas que rigen la forma en que se lleva acabo el procesamiento para poder segmentar en una imagen el objeto en cuestión (punto, línea, círculo o elipse).

c) Petición

Este marco permite al usuario especificar cuál es su objetivo. En este marco

se debe de indicar qué imagen se va a procesar, el objeto a buscar y las características deseables durante el procesamiento. Los slots que forman este marco:



• Nombre. • Imagen. • Características. • Objeto.

Este marco sólo se usa para que el usuario ingrese al sistema la información necesaria para comenzar con el procesamiento. Este marco sólo puede existir en tiempo de ejecución y no se puede almacenar en la base de conocimiento.

d) Reglas

Anteriormente se mencionó que los marcos contienen slots con reglas. En

este momento se mencionan algunas cuestiones relacionadas con la reglas. La sintaxis general de las reglas de producción que se utiliza es similar a la sintaxis que utiliza el lenguaje de programación Prolog.

Acción:- condición_1, condición_2,..., condición_N

Para que la acción se lleve a cabo es necesario que las condicionantes se

cumplan, y se comienza a verificar de izquierda a derecha. Las condicionantes pueden ser otras reglas de producción, expresiones relacionales o átomos. El punto más importante es que los átomos representan marcos dentro de la base de conocimiento.

Como parte de las expresiones relacionales se aceptan los operadores: >, <,

==. Los operandos pueden ser números, cadenas o propiedades pertenecientes al marco. Para acceder a la propiedad de un marco es necesario realizarlo de la siguiente forma: <nombre_marco>.<propiedad_marco>. Los átomos que representan a un operador obtienen el valor de verdadero o falso, en base a si están declarados en la base de conocimiento y si es posible utilizarlos con el conocimiento que se encuentra en la base de conocimiento.

En la sección de anexos se presenta la gramática del lenguaje LBFR en EBNF (Forma Backus-Naur extendida) y también algunas bases de conocimiento utilizadas que muestran cómo se utilizan las reglas dentro de los marcos.

4.1.9 Motor de inferencia

4.1.9.1 Mecanismo general de solución de problemas

1. Primero el usuario debe ingresar al sistema una descripción de los siguientes aspectos:



a. Petición (¿Qué quiere el usuario?). b. Imagen (características de la imagen). c. Objeto a procesar.

Estas descripciones se deben realizar en LBFR.

2. Al mismo tiempo que se introduce al sistema el conjunto de descripciones, también se le debe indicar cuál es la imagen que se desea procesar. En este punto el sistema ya posee todo el conocimiento necesario para iniciar el procesamiento.

3. Aquí el motor de inferencia sobre PDI es lanzado e inicia el procesamiento de

los elementos mencionados en el punto anterior, con el fin de seguir una estrategia de solución (El funcionamiento de este motor de inferencia se explica más adelante).

4. Para realizar el procesamiento el MI-PDI necesita acceder al conocimiento existente en la base de conocimiento. Es importante destacar que los resultados que se obtengan dependen en gran medida al conocimiento que exista en las bases de conocimiento.

5. En este punto el MI-PDI ha generado una estrategia de solución en forma de

script utilizando el lenguaje LSSI (Lenguaje de scripts para segmentación de imágenes) y ahora lo envía al intérprete para que lo ejecute.

6. El intérprete de scripts comienza a ejecutar los comandos que ha recibido.

Para esto, utiliza los programas existentes en la biblioteca de operadores.

7. El intérprete de scripts después de la ejecución de los operadores genera la imagen segmentada y un archivo que contiene frames de descripción del objeto segmentado. Este archivo de descripción y la imagen son enviados al MI-PDI para que verifique los resultados obtenidos.

8. Si no hay errores en el resultado, el MI-PDI indica al intérprete de scripts que

muestre los resultados, pero en caso de que el MI-PDI determine la presencia de errores en los resultados, este tiene que buscar una solución alternativa.

El proceso de solución finaliza cuando se obtiene una segmentación

satisfactoria o cuando ya no existen más soluciones alternativas que utilizar. El resultado de la segmentación es evaluada de forma manual por el usuario.



4.1.9.2 Mecanismo general del motor de inferencia

Todos los elementos mencionados en LBFR son explotados por un mecanismo de inferencia para resolver problemas. El papel de este motor de inferencia es buscar un plan de ejecución que satisfaga el objetivo del usuario.

La solución de un problema de segmentación de imágenes inicia con la petición que realiza el usuario al sistema, el cual indica la funcionalidad, los datos sobre los cuales se trabajará y el objeto que se busca segmentar. Entonces el motor de inferencia para la segmentación de imágenes es lanzado.

Figura 4.16 Mecanismo general del motor de inferencia

Inicio

Leer petición

Cargar base de conocimiento

Unificar petición con marcos de la

B.C.

¿Objeto unificado?

“Error” No

Procesar las reglas del objeto

Se crean comandos

Si

Guardar script

Fin



4.1.9.3 Proceso de creación del script

El proceso de creación de script comienza cuando el motor de inferencia (MI)

encuentra él objeto a procesar. Suponga que el motor de inferencia se encuentra con el siguiente marco de tipo objeto. Objeto { Nombre linea Comentario "Prueba 1" Propiedades Entero Longitud 5 Cadena Orientacion "Vertical" ReglasObjeto linea:-FreiChen.imgI=Imagen.Archivo,FreiChen,

Hough.imgI=FreiChen.imgO,Hough FreiChen Hough }

En el slot ReglasObjeto se encuentra un conjunto de reglas que permiten

especificar el esqueleto para crear el script. Aquí se encuentran dos elementos muy importantes para que se pueda crear el script y son.

a) Relación de la imagen original con el primer operador. Aquí se indica al motor de inferencia qué imagen se quiere procesar. Esto se observa en la primera asignación de la regla que tiene la cabeza línea. (FreiChen.imgI=Imagen.Archivo). El motor de inferencia con el objetivo de crear el script interpreta la asignación anterior y agrega al script el siguiente código:

ImagenGris imgI; imgI=AbrirImagenGris(“ruta_archivo_imagen”);

La ruta que se utiliza es la que se indique en el slot Archivo del marco

Imagen. Por default Archivo contiene la ruta de la imagen a procesar. b) Relación de entrada y salida entre los operadores. Las operaciones de

asignación dentro las reglas se pueden utilizar para relacionar las entradas y salidas de distintos operadores.

Después de obtener la relación de los operadores con la imagen original y las

relaciones de entrada y salida entre los distintos operadores, ahora sólo es necesario extraer de cada operador los comandos para agregarlos al script. En la figura 4.17 se muestra el flujo de trabajo para construir el script.



De forma general es el procedimiento que se sigue para construir un script,

desde luego el procesamiento se lleva de forma paralela al trabajo que realiza el motor de inferencia.

Finalmente el script se almacena en un archivo y se invoca al intérprete de scripts para que lo ejecute.

Figura 4.17 Proceso general de creación de un script

4.2 Implementación

En esta sección se muestra la implementación de cada uno de los

componentes que integran al sistema resultante de aplicar la arquitectura propuesta. Cada elemento de la arquitectura se implementó como módulo independiente de los demás. Los módulos resultantes son los siguientes:

1. Interfaz de usuario. 2. Base de conocimiento. 3. Parser para LBFR. 4. Motor de inferencia. 5. Módulo de evaluación de resultados. 6. Intérprete de scripts.

Inicio Construir comandos para cargar imagen original

Crear comandos para ejecutar un operador

Crear relaciones de la salida del operador anterior y el

siguiente.

¿Existen más operadores?

Fin

No

Si



4.2.1 Interfaz de usuario

Se desarrolló una interfaz de usuario desde la cual el usuario puede interactuar con el sistema. Debido a que cada módulo del sistema se implementó como programas independientes, es la interfaz de usuario la que se encarga de invocar cada uno de los módulos en forma de procesos externos. En la figura 4.18 se observa la interfaz de usuario.

Figura 4.18 Interfaz de usuario

4.2.2 Base de conocimiento

Se implementaron varias bases de conocimiento para la realización de pruebas en la etapa de experimentación. Las bases de conocimiento se desarrollaron utilizando el lenguaje LBFR. En la sección 8.4 se muestran una base de conocimiento de ejemplo.

4.2.3 Parser para LBFR

Se desarrolló en ANTLR un parser para el lenguaje LBFR con el objeto de ayudar al usuario a detectar errores léxicos y sintácticos. En la sección 8.3 de anexos se muestra la gramática del lenguaje LBFR utilizando la sintaxis EBNF de ANTLR. Esta gramática la utiliza ANTLR para generar código en C++ el cual es compilado posteriormente para obtener el parser. En la figura 4.19 se observa el módulo del parser, en donde se muestran sus entradas y salidas.



Figura 4.19 Módulo del parser

4.2.4 Motor de inferencia El motor de inferencia se muestra como una caja negra la cual recibe

parámetros y después de un proceso de inferencia genera un resultado.

Figura 4.20 Módulo del motor de inferencia

Este módulo recibe como parámetros de entrada dos archivos, el primero corresponde a la petición de procesamiento realizado por el usuario y el segundo es el archivo de la base de conocimiento que se va a utilizar durante el proceso de inferencia. Después de que se realiza el procesamiento este módulo genera dos archivos de salida: el script de segmentación y los posibles errores que se encuentren. El motor de inferencia se desarrolló en C++ Builder y no posee interfaz gráfica. La forma en que interactúa con el resto de los módulos del sistema es mediante archivos.

4.2.5 Módulo de evaluación de resultados El proceso de evaluación de resultados es realizado de forma manual por el

usuario del sistema. Este módulo se conforma básicamente por interfaces que permiten al usuario observar los resultados del sistema (script, errores, imagen procesada), para posteriormente poder mejorar el conocimiento o ajustar el script de segmentación.

Este módulo se integra por las siguientes interfaces de usuario:

Parser Script

Script sin errores

Errores

Motor de inferencia

Petición


Script

Errores



• Visor de scripts generados por el motor de inferencia. • Visor de resultados de segmentación. • Visor de errores (sintácticos, léxicos, semánticos, conocimiento y de

inferencia)

4.2.6 Intérprete de scripts

El intérprete de scripts se desarrolló en dos versiones, en donde la única diferencia es que una cuenta con interfaz de usuario, mientras que la otra no cuenta con ninguna interfaz ya que es invocada como proceso externo desde la interfaz de usuario del sistema principal. En la figura 4.21 se muestra este módulo como una caja negra en donde se indican sus entradas y salidas.

Figura 4.21 Módulo del intérprete de scripts

En la siguiente sección se muestra la integración de todos los módulos en el

sistema de segmentación basado en conocimiento.

4.2.7 Integración de los módulos del sistema

En la figura 4.22 se muestra un diagrama de los módulos que integran el sistema y la forma en que interactúan entre ellos mediante archivos.


Script Segmentación

Errores

Sintaxis de los operadores



Figura 4.22 Módulos del sistema

El flujo de trabajo entre los módulos que integran el sistema se puede dar de distintas formas dependiendo del escenario en el que se encuentre el usuario. El módulo IGU (interfaz gráfica de usuario) es el que controla el flujo de datos y conocimiento entre los distintos módulos del sistema. A través del IGU el usuario puede agregar nuevo conocimiento al sistema y crear peticiones al sistema para realizar la segmentación de algún objeto sobre una imagen dada, utilizando una base de conocimiento determinada. En el sistema cada módulo es en realidad un proceso, independiente entre ellos, los cuales son invocados desde el módulo IGU y mediante archivos se mantiene una interacción entre los distintos módulos.

4.3 Comentarios

Como se ve en la sección 4.1 el conocimiento relacionado a los algoritmos de

segmentación puede relacionarse a ¿cuándo utilizar un algoritmo? Y ¿cómo utilizar un algoritmo?, además dicho conocimiento puede ser representado de forma declarativa, sin embargo el algoritmo en si, debe estar representado en forma procedimental.

La arquitectura propuesta consta de una biblioteca de operadores, un lenguaje

de segmentación de imágenes basado en scripts, una base de conocimiento y un

Analizador léxico y

sintáctico para B. C.

Comandos

Errores

Registro de

errores

Biblioteca de operadores

Resultado

IGU


Script

Motor de inferencia


Imagen

Registro de operadores

Especificaciones

Parámetros

Resultados

Errores

Petición y B. C.

B. C.

Script y/o errores

Conocimiento

Script Resultado



lenguaje para representación de conocimiento (LBFR), un módulo de validación de conocimiento, un motor de inferencia y un intérprete de scripts.

Debido a que cada elemento de la arquitectura ha sido desarrollado como

módulo independiente, resulta fácil sustituir alguno de los elementos de la arquitectura por una nueva versión del mismo, sin necesidad de modificaciones adicionales en la arquitectura.

La interacción de los operadores de segmentación mediante el uso de archivos

facilita el desarrollo de operadores en lenguajes de programación distinto al utilizado en el desarrollo de esta tesis.

La implementación del sistema se realizó en el ambiente de progración C++

Builder Versión 5. El capítulo siguiente muestra algunas de las pruebas a las cuales ha sido sometido el sistema resultante de utilizar la arquitectura propuesta en el desarrollo de un sistema de segmentación y se presentan los resultados obtenidos.

Capítulo V Experimentación y resultados


5 Capítulo 5

Experimentación y resultados

5.1 Descripción del ambiente de pruebas

En esta sección se muestran las características del equipo de cómputo utilizado en la aplicación de los casos de prueba y el tipo de imágenes con las cuales se trabajó.

• Las imágenes tienen formato BMP de 24 bits. • Las imágenes utilizadas para los casos de prueba son de dos tipos:

o Imágenes artificiales simples. o Imágenes descargadas de Internet.

• El equipo en el que se ejecutaron los casos de prueba es un Pentium 4 a 2.8

GHz con 512 MB en RAM y tarjeta de video Intel(R) 82852/82855 GM/GME Graphics con 64 MB de memoria de video, bajo el sistema operativo Windows XP SP2.



5.2 Plan de pruebas

Se realizaron diferentes tipos de pruebas por medio de las cuales se observó

el desempeño del sistema en la segmentación de imágenes y se pudo mostrar la separación entre los algoritmos de segmentación de imágenes y el conocimiento asociado a ellas, la reutilización de conocimiento y la facilidad para cambiar el funcionamiento del sistema. El plan de pruebas está formado por los siguientes casos de experimentación:

Caso 1. Validación de la capacidad de adquisición de nuevo conocimiento.

Caso 2. Separación entre la base de conocimiento y algoritmos de segmentación.

Caso 3. Reutilización de conocimiento.

Caso 4. Capacidad del sistema para cambiar su funcionalidad.

5.3 Descripción de los casos de prueba

Caso 1 Validación de la capacidad de adquisición de nuevo conocimiento El objetivo de esta prueba es validar que el sistema posee la capacidad de adquirir nuevo conocimiento, es decir, se espera que la base de conocimiento sea capaz de crecer en base a las necesidades del usuario. Para realizar el proceso de validación inicialmente se utilizó una base de conocimiento vacía y posteriormente se fue agregando nuevo conocimiento. Caso 1.1. Verificar que el sistema depende del conocimiento

Objetivo. En este caso se busca mostrar que el sistema requiere de

conocimiento para trabajar. La prueba consiste en tratar de segmentar objetos circulares en una imagen que contiene una célula (objeto circular), sin embargo la base de conocimiento que se utilizó esta vacía. Desarrollo de la prueba.

a) Al iniciar el sistema se selecciona el icono ‘B. C.’ que se encuentra del lado izquierdo, el cual muestra la base de conocimiento activa (figura 5.1). El sistema por default presenta al usuario la última base de conocimiento con la que trabajó.



Figura 5.1 Última base de conocimiento utilizada por el usuario

b) Posteriormente se elige la opción ‘Examinar…’ para seleccionar una base de

conocimiento sin contenido como se observa en la figura 5.2.

Figura 5.2 Base de conocimiento vacía

c) Elegir el icono ‘Petición’ que se encuentra a la izquierda, para crear una

petición al sistema, como se observa en la figura 5.3.



Figura 5.3 Petición del usuario para segmentar círculos

d) Seleccionar el botón “Procesar Petición” para iniciar el procesamiento de la

petición. Sin embargo, debido a que la base de conocimiento carece de conocimiento, el sistema emite el mensaje que se muestra en la figura 5.4.

Figura 5.4 Mensaje del sistema para el usuario

Comentarios. Se observó que el sistema depende de la existencia de

conocimiento para que se lleve a cabo el procesamiento de la petición del usuario. Caso 1.2 Agregar conocimiento para la detección de puntos

Objetivo. En este caso se busca mostrar que el sistema puede adquirir nuevo conocimiento, en este caso en particular se trata de conocimiento sobre la detección de puntos. Desarrollo de la prueba: En la base de conocimiento inicial, se agregó conocimiento sobre cómo segmentar puntos en una imagen, el sistema permite modificar directamente la base de conocimiento y posteriormente validarla de forma léxica y sintáctica. El conocimiento que se agregó es básico y se presenta en seguida:



OperadorPrimitivo { Nombre PasaAlto Comentario 'Mascara de filtro pasa alto' Cadena Caracteristicas 'sencillo' ParametrosSalida Mascara mscO ReglasParametros Comando 'mscO=AbrirMascara('D:\sbc\mascaras\puntos.mas')' } OperadorPrimitivo { Nombre Convolucion Comentario 'Operador para realizar convolucion' Cadena Caracteristicas 'rapido' ParametrosEntrada ImagenGris imgI Mascara mscI ParametrosSalida ImagenGris imgO Comando 'imgO=Convolucion(imgI,mscI)' } OperadorPrimitivo { Nombre Binarizar Comentario 'Operador para umbralizar una imagen' Cadena Caracteristicas '' ParametrosEntrada ImagenGris imgI Entero umbral ParametrosSalida ImagenGris imgO ReglasParametros umbral=100 Comando 'imgO=BinarizarImagenGris(imgI,umbral)' } OperadorPrimitivo { Nombre VerImagen Comentario 'Operador para visualizar una imagen' Cadena Caracteristicas '' ParametrosEntrada ImagenGris imgI Comando 'VerImagenGris(imgI)' }



Objeto { Nombre Punto Comentario 'Prueba 1 para segmentar puntos' Propiedades Cadena Fondo ReglasObjeto Punto:-Convolucion.imgI=myImage.Archivo,PasaAlto,Convolucion. mscI=PasaAlto.mscO,Convolucion, Binarizar.imgI=Convolucion.imgO, Binarizar,VerImagen.imgI=Binarizar.imgO, VerImagen Convolucion PasaAlto Binarizar VerImagen }

El conocimiento anterior se muestra en la figura 5.5. Posteriormente se guardaron los cambios, con el fin de poder explotar el conocimiento mediante las peticiones del usuario.

Figura 5.5 Adición de conocimiento al sistema para segmentar puntos

Una vez que se ha agregado el conocimiento el usuario puede utilizar el botón “Validar”, con lo que el sistema realiza un análisis léxico y sintáctico del contenido d e la base de conocimiento. En caso de que el conocimiento tenga errores el sistema muestra un mensaje al usuario como el mostrado en la figura 5.6.



Figura 5.6 Error sintáctico en la base de conocimiento

Comentarios. Se observó de forma satisfactoria que el sistema permite adquirir y almacenar nuevo conocimiento, sin embargo aunque se puede validar la base de conocimientos de forma léxica y sintáctica, es necesario desarrollar en un futuro un editor para bases de conocimiento que brinde ayuda durante la codificación del conocimiento (similar a la ayuda [sintaxis] que brinda C++ Builder en proceso de redacción de las sentencias). Caso 1.3 Verificar el funcionamiento del sistema con el nuevo conocimiento para la segmentación de puntos

Objetivo. Con esta prueba se busca verificar que el sistema tiene la capacidad de explotar el conocimiento adquirido.

La prueba consiste en realizar al sistema una petición para segmentar puntos sobre la imagen que contiene la célula, con el fin de observar el resultado y mostrar que el sistema utiliza el nuevo conocimiento. Desarrollo de la prueba:

a) Seleccionar la base de conocimiento que contiene el conocimiento relacionado a la segmentación de puntos como se muestra en la figura 5.7.



Figura 5.7 Base de conocimiento para segmentar puntos

b) Crear una petición para que el sistema realice la segmentación de puntos en

la imagen seleccionada, como se muestra en la figura 5.8.

Figura 5.8 Petición del usuario para segmentar puntos

c) Elegir la opción ‘Procesar Petición’ con lo cuál el sistema inicia la explotación

de conocimiento, este trabajo es realizado por el motor de inferencia y como resultado genera un script (figura 5.9) el cual es ejecutado para obtener los resultados de la petición de segmentación. El resultado se observa en la figura 5.10.



Figura 5.9 Script generado por el motor de inferencia

Figura 5.10 Resultado de la segmentación de puntos

Comentarios. Se observó de forma satisfactoria que el sistema permite

explotar el nuevo conocimiento que fue adquirido en el caso 1.2 y se observa el resultado de la segmentación, sin embargo, es importante recordar que el resultado de la segmentación depende del conocimiento que se posea. En esta prueba el conocimiento utilizado es básico. Caso 1.4 Agregar conocimiento para segmentar líneas

Objetivo. En este caso se buscó mostrar que el sistema puede adquirir nuevo conocimiento y preservar el existente, en este caso en particular se trata de agregar



conocimiento para segmentar líneas en la base de conocimiento que ya posee el conocimiento relacionado a la segmentación de puntos. Desarrollo de la prueba: En la base de conocimiento del caso 1.2, se agrega conocimiento sobre cómo segmentar líneas en una imagen, el sistema permite modificar directamente la base de conocimiento y posteriormente validarla de forma léxica y sintáctica. El conocimiento que se agrego se muestra a continuación: OperadorPrimitivo { Nombre LHT Comentario 'Identifica lineas' Cadena Caracteristicas 'lento' ParametrosEntrada ImagenGris imgI Entero ro Entero theta Entero minP Entero maxD ParametrosSalida ImagenGris imgO ReglasParametros ro=1 theta=1 minP=50 maxD=2 Comando 'imgO=Lineas(imgI,ro,theta,minP,maxD)' } OperadorPrimitivo { Nombre FreiChen Comentario 'Operador para segmentar líneas' ParametrosEntrada ImagenGris imgI Real umbral ParametrosSalida ImagenGris imgO ReglasParametros umbral=2.0 Comando 'imgO=FreiChen(imgI,umbral)' } Objeto { Nombre Linea Comentario 'Objeto que encapsula la segmentacion de lineas' Propiedades



Cadena Fondo ReglasObjeto Linea:-FreiChen.imgI=myImage.Archivo,FreiChen,

LHT.imgI=FreiChen.imgO,LHT,VerImagen. imgI=LHT.imgO,VerImagen

FreiChen Hough VerImagen LHT } El conocimiento agregado se muestra en la figura 5.11. Posteriormente se deben guardar los cambios, con el fin de poder explotar el conocimiento mediante las peticiones del usuario.

Figura 5.11 Adición de conocimiento para segmentar líneas

Comentarios. Se observó de forma satisfactoria que el sistema si permite adquirir nuevo conocimiento y preservar el existente. Caso 1.5 Verificar el funcionamiento del sistema con el nuevo conocimiento para la segmentación de líneas

Objetivo. Con esta prueba se busca verificar que el sistema tiene la capacidad de explotar el nuevo conocimiento que fue adquirido en la prueba anterior para la segmentación de líneas. La prueba consistie en realizar una petición al sistema para segmentar líneas sobre una imagen artificial que contiene un rectángulo.



Desarrollo de la prueba:

a) Seleccionar la base de conocimiento que contiene el conocimiento relacionado a la segmentación de puntos y líneas como se muestra en la figura 5.12.

Figura 5.12 Base de conocimiento para segmentar líneas

b) Crear una petición para que el sistema realice la segmentación de líneas en la imagen seleccionada, como se muestra en la figura 5.13.

Figura 5.13 Petición del usuario para segmentar líneas

c) Elegir la opción ‘Procesar Petición’ con lo cual el sistema inicia la explotación

de conocimiento, este trabajo es realizado por el motor de inferencia y como



resultado genera un script (figura 5.14) el cual es ejecutado para obtener los resultados de la petición de segmentación.

Figura 5.14 Script generado por el motor de inferencia

d) El resultado de la segmentación se observa en la figura 5.15.

Figura 5.15 Resultado de la segmentación de líneas

Comentarios. Se observó de forma satisfactoria que el sistema permite

explotar el nuevo conocimiento que fue adquirido en el caso 1.4 y se observa el resultado de la segmentación, sin embargo, es importante recordar que el resultado de la segmentación depende del conocimiento que se posea. Caso 1.6 Comprobar que el sistema verifica que cuenta con el conocimiento necesario para procesar la solicitud del usuario.

Objetivo. Con esta prueba se busca verificar que cuando el usuario solicita segmentar algún objeto como círculos y elipses, pero en la base de conocimiento no



se cuenta el conocimiento sobre estos objetos, el sistema indica la falta de conocimiento.

La prueba consiste en realizar al sistema peticiones para segmentar círculos y elipses sobre imágenes artificial que contienen objetos circulares y elípticos. Desarrollo de la prueba:

a) Seleccionar la base de conocimiento que contiene el conocimiento relacionado a la segmentación de puntos y líneas como se muestra en la figura 5.16.

Figura 5.16 Base de conocimiento para segmentar puntos y líneas

b) Crear una petición para que el sistema realice la segmentación de círculos

dentro de una imagen artificial, esto se observa en la figura 5.17.


c) Seleccionar la opción ‘Procesar petición’. En este momento se detecta un

error durante el proceso de inferencia (figura 5.18) y el sistema responde con



un mensaje en donde indica que hace falta conocimiento el cual despliega en la pantalla que se muestra en la figura 5.19.

Figura 5.18 Mensaje de error emitido por el motor de inferencia

Figura 5.19 Error encontrado durante el proceso de inferencia

d) Se sigue el mismo procedimiento para segmentar objetos elípticos, recibiendo

la siguiente respuesta por parte del sistema (Figura 5.20).

Figura 5.20 Error emitido por el sistema al tratar de segmentar elipses



Comentarios. Se observa nuevamente que el comportamiento del sistema depende directamente del conocimiento que se posee la base de conocimiento que se esta utilizando durante el procesamiento. Caso 1.7 Adición de conocimiento sobre segmentación de círculos y elipses, y verificación del comportamiento del sistema.

Objetivo. Con esta prueba se busca verificar que al agregar el conocimiento para segmentar círculos y elipses, el sistema pudo explotar el nuevo conocimiento y respondió a la petición del usuario a segmentar este tipo de objetos.

La prueba consiste en realizar al sistema peticiones para segmentar círculos y elipses sobre imágenes que contienen objetos circulares y elípticos, pero ahora con el conocimiento adecuado para llevar acabo este procesamiento. Desarrollo de la prueba:

a) Seleccionar la base de conocimiento que contiene el conocimiento relacionado a la segmentación de puntos y líneas.

b) Agregar el conocimiento para segmentar círculos y elipses como se muestra

en seguida: OperadorPrimitivo { Nombre CHT Comentario 'Identifica circulos' Cadena Caracteristicas 'lento' ParametrosEntrada ImagenGris imgI Entero rX Entero rY Entero minP Entero minR Entero maxR ParametrosSalida ImagenGris imgO ReglasParametros rX=1 rY=1 minP=120 minR=150 maxR=150 Comando 'imgO=Circulos(imgI,rX,rY,minP,minR,maxR)' }



OperadorPrimitivo { Nombre EHT Comentario 'Identifica elipses' Cadena Caracteristicas 'lento' ParametrosEntrada ImagenGris imgI Entero rX Entero rY Entero mxI Entero mxS Entero mnI Entero mnS Entero ne ParametrosSalida ImagenGris imgO ReglasParametros rX=1 rY=1 mxI=35 mxS=35 mnI=15 mnS=15 ne=1 Comando 'imgO=Elipses(imgI,rX,rY,mxI,mxS,mnI,mnS,ne)' } Objeto { Nombre Circulo Comentario 'Objeto que encapsula la segmentacion de circulos' Propiedades Cadena Fondo ReglasObjeto Circulo:-CHT.imgI=myImage.Archivo,CHT,VerImagen.imgI=CHT.imgO,VerImagen CHT VerImagen } Objeto { Nombre Elipse Comentario 'Objeto que encapsula la segmentacion de elipses' Propiedades Cadena Fondo ReglasObjeto



Elipse:-Binarizar.imgI=myImage.Archivo,Binarizar.umbral=120,Binarizar, Convolucion.imgI=Binarizar.imgO,PasaAlto,

Convolucion.mscI=PasaAlto.mscO, Convolucion, EHT.imgI=Convolucion.imgO,EHT,VerImagen.imgI=EHT.imgO,

VerImagen Binarizar Convolucion PasaAlto EHT VerImagen }

En la figura 5.21 se observa la base de conocimiento con la que se trabajó, la cual contiene el nuevo conocimiento sobre segmentación de círculos y elipses más el conocimiento existente previamente sobre segmentación de puntos y líneas.

Figura 5.21 Base de conocimiento para segmentar puntos, líneas, círculos y elipses

c) Crear la petición del usuario para segmentar círculos, esto se observa en la

figura 5.22.




d) Solicitar al sistema que procese la petición, con lo cual, el sistema genera el script que se muestra en la figura 5.23.

Figura 5.23 Script generado por la máquina de inferencia

e) Después de generar el script de segmentación el sistema procede a ejecutarlo

con lo cual se obtuvo el resultado mostrado en la figura 5.24.

Figura 5.24 Resultado de la segmentación (imagen original, imagen resultante),

f) Crear ahora la petición para segmentar objetos elípticos, para lo cual se selecciona la imagen de una galaxia, esto se observa en la figura 5.25.



Figura 5.25 Petición para segmentar objetos elípticos

g) Procesar la petición, con lo cual el sistema genera el script que se observa en la figura 5.26.

Figura 5.26 Script para segmentar elipses

h) El sistema procede a ejecutar el script, con lo cual se obtiene el resultado

mostrado en la figura 5.27. También se muestran los resultados intermedios del proceso de segmentación que realiza el sistema mediante el script.



a) imagen original

b) Resultado intermedio

c) Resultado intermedio

c) Resultado de segmentación

Figura 5.27 Resultado de la segmentación

Comentarios. Se observa que con el conocimiento para la segmentación de

círculos y elipses el sistema responde satisfactoriamente a las peticiones de segmentación de objetos circulares y objetos elípticos. Con el caso de prueba 1 no sólo se observa la capacidad del sistema de adquirir y explotar nuevo conocimiento, sino que también se muestra que el desempeño del sistema depende directamente del conocimiento que este posea sobre el problema que se quiere resolver. Caso 2 Separación entre la base de conocimiento y algoritmos de

segmentación Objetivo. En esta prueba se pretende mostrar la separación que se logró establecer entre los algoritmos de segmentación (conocimiento procedimental) y la base de conocimiento (conocimiento declarativo) asociado a los mismos.

Para verificar esta característica del sistema, se procedió a modificar el código del algoritmo de FreiChen [18] que es utilizado como parte del proceso de segmentación de líneas, se recompiló y posteriormente se probó el sistema sin necesidad de realizar modificaciones en la base de conocimiento. Con lo cual se observa la capacidad de modificar los algoritmos de forma independiente a la base de conocimiento.



Desarrollo de la prueba:

a) El primer paso es modificar el código del algoritmo de Frei Chen, básicamente se cambió el sub-espacio de líneas con el que se estaba trabajando por el sub-espacio de bordes. En la figura 5.38 se observa el algoritmo inicial.

Figura 5.28 Algoritmo de Frei chen con sub - espacio de líneas

b) En la figura 5.29 se muestran las modificaciones realizadas. Posteriormente se compila el programa hecho en C++ Builder y el ejecutable se copia y sustituye en lugar del original.

c) Iniciar el sistema y seleccionar la base de conocimiento del caso de prueba

1.4 en la cual se encuentra conocimiento para segmentar líneas.

d) Crear la petición por parte del usuario, tal y como se observa en la figura 5.30.



Figura 5.29 Algoritmo de Frei Chen son sub - espacio de bordes


e) Procesar la petición con lo que el sistema genera el script de segmentación

que se observa en la figura 5.31.



Figura 5.31 Script de segmentación de líneas

f) El sistema procede a ejecutar el script con lo cual se obtiene el siguiente

resultado (figura 5.32).

Figura 5.32 Resultado de la segmentación de líneas

Con esta prueba se muestra la independencia entre la base de conocimiento y los algoritmos de segmentación ya que ambos pueden sufrir modificaciones de forma independiente debido a la separación que existe entre algoritmos y la base de conocimiento. Caso 3 Reutilización de conocimiento Objetivo. En el caso de reutilización de conocimiento, se muestra cómo el conocimiento existente en una base de conocimiento para un problema, en particular imágenes artificiales (imagen con un rectángulo), puede ser reutilizado para



segmentar imágenes reales (imagen de una carretera), desde luego es necesario adicionar conocimiento.

La prueba consiste en adicionar conocimiento para poder realizar la segmentación de líneas sobre una imagen real en la cual se observa una carretera, se parte del conocimiento existente en la base de conocimiento del caso de prueba 1.7. Desarrollo de la prueba:

a) El primer paso es adicionar el siguiente conocimiento al sistema. OperadorPrimitivo { Nombre LHT Comentario 'Identifica lineas' Cadena Caracteristicas 'lento' ParametrosEntrada ImagenGris imgI Entero ro Entero theta Entero minP Entero maxD ParametrosSalida ImagenGris imgO ReglasParametros ro=1 theta=1 minP=100:-myImage.Caracteristicas=='Carretera' minP=50:-myImage.Caracteristicas=='Rectangulo' maxD=15:-myImage.Caracteristicas=='Carretera' maxD=2:-myImage.Caracteristicas=='Rectangulo' Comando 'imgO=Lineas(imgI,ro,theta,minP,maxD)' } Objeto { Nombre Linea Comentario 'Objeto que encapsula la segmentacion de lineas' Propiedades Cadena Fondo ReglasObjeto Linea:-Binarizar.imgI=myImage.Archivo,

myImage.Caracteristicas=='Carretera', Binarizar.umbral=230,Binarizar,FreiChen.imgI=Binarizar.imgO,



FreiChen,LHT.imgI=FreiChen.imgO,LHT, VerImagen.imgI=LHT.imgO,VerImagen

Linea:-FreiChen.imgI=myImage.Archivo, FreiChen,LHT.imgI=FreiChen.imgO,

LHT,VerImagen.imgI=LHT.imgO,VerImagen FreiChen Binarizar VerImagen LHT }

La base de conocimiento se observa en la figura 5.33, la cual ya contiene el nuevo conocimiento y las modificaciones pertinentes al ya existente.

Figura 5.33 Base de conocimiento actualizada

b) Crear la petición para que el sistema segmente las líneas que se encuentren

en la imagen. Esto se observa en la figura 5.34.


c) Ahora se procesa la petición y la máquina de inferencia genera el script que se

observa en la figura 5.35.



Figura 5.35 Script de segmentación

d) El sistema ejecuta el script y presenta el resultado que se observa en la figura

5.36.

Figura 5.36 Resultado de la segmentación

Al segmentar la imagen original en busca de líneas, el usuario esperaría

obtener el siguiente resultado de la figura 5.37 mediante el uso de la transformada de Hough.

Figura 5.37 Resultado esperado por el usuario



Sin embargo difiere del resultado mostrado por el sistema en la figura 5.36, lo cual se debe a modificaciones que se hicieron al algoritmo de Hough. Las modificaciones realizadas son:

• Se agrega un parámetro para definir la cantidad mínima de punto que debe

contener una línea para que se considere como tal. • Se agrega un parámetro para indicar la distancia máxima a la que deben de

estar dos puntos para ser considerados como parte de una misma línea.

• Se aplica un algoritmo de agrupamiento a los puntos obtenidos en los acumuladores tomando en cuenta los dos parámetros agregados.

Con esta prueba se observa que el sistema tiene la capacidad de reutilizar el conocimiento existente para imágenes artificiales y mediante la modificación y adición de conocimiento se puede emplear el sistema para segmentar imágenes reales. Es muy importante aclarar que mientras más complejo es el proceso de segmentación, es también mayor el requerimiento de conocimiento por parte del sistema. Caso 4 Capacidad del sistema para cambiar su funcionalidad

Objetivo. Con esta prueba se muestra la flexibilidad de la arquitectura propuesta para poder modificar la funcionalidad del sistema, es decir, la capacidad del sistema de no sólo trabajar con la segmentación de imágenes.

Para esto se agregan algoritmos de descripción y representación de imágenes (extracción de contorno y momentos de Hu) a la base de operadores del sistema, se registran en el intérprete de scripts y finalmente se agrega conocimiento al sistema para realizar la descripción y representación del objeto segmentado en la imagen. Desarrollo de la prueba:

a) El primer paso es desarrollar en C++ Builder dos programas uno para extraer contornos de imágenes binarias y el otro para calcular los momentos Hu, los cuales son utilizados como descriptores.

b) Registrar en el módulo de scripts los nuevos operadores.

c) Una vez registrados se procede a crear una pequeña base de conocimiento la

cual se presenta en seguida. OperadorPrimitivo {



Nombre ExtraerContorno Comentario 'Operador extraer los contornos de una imagen binaria' Cadena Caracteristicas 'binaria' ParametrosEntrada ImagenGris imgI Entero nc ParametrosSalida Contorno cO ReglasParametros nc=1 Comando 'cO=ExtraerContorno(imgI,nc)' } OperadorPrimitivo { Nombre ExtraerCaracteristicas Comentario 'Crea una descripcion del objeto con los momentos de Hu' Cadena Caracteristicas '' ParametrosEntrada Contorno cI Cadena ruta Comando 'ExtraerCaracteristicas(cI,'d:\rectangulo.des')' } Objeto { Nombre DesRectangulo Comentario 'Descripcion de un rectangulo' Propiedades Cadena Fondo ReglasObjeto DesRectangulo:-ExtraerContorno.imgI=myImage.Archivo,

ExtraerContorno,ExtraerCaracteristicas.cI=ExtraerContorno.cO, ExtraerCaracteristicas

ExtraerContorno ExtraerCaracteristicas } En la figura 5.38 se observa la base de conocimiento con la cual se realiza esta prueba.



Figura 5.38 Base de conocimiento para extraer descriptores

d) Crear la petición de usuario para llevar acabo el procesamiento como se muestra en la figura 5.39. En este caso el objeto de interés es la descripción de un rectángulo (DesRectangulo).

Figura 5.39 Petición del usuario para extraer descriptores

e) El sistema inicia el procesamiento de la petición y genera el script que se

observa en la figura 5.40.



Figura 5.40 Script para extraer descriptores

f) El sistema ejecuta el script lo cual genera el resultado que se observa en la

figura 5.41.

Figura 5.41 Resultado de la extracción de descriptores

Del lado izquierdo se observa la imagen procesada y del lado derecho se muestra la descripción del objeto encontrado (momentos de Hu).

Comentarios. Con este caso de prueba se muestra como el sistema puede utilizarse en otras etapas de la visión artificial de una forma sencilla.



5.4 Comentarios

Los resultados obtenidos mediante la aplicación de los casos de prueba son

satisfactorios ya que muestran como un sistema resultante de utilizar la arquitectura propuesta para su desarrollo, permite mantener separado el conocimiento y los algoritmos de segmentación.

Sin embargo cabe resaltar que los resultados obtenidos en la segmentación de

imágenes, dependen en gran medida de la capacidad que tienen los algoritmos de segmentación para desempeñar un buen trabajo. Un ejemplo de esto es la transformada de Hough, la cual depende fuertemente de los parámetros que recibe. Esto es, si se quiere segmentar un objeto circular de un radio aproximado de 25 pixeles y sin embargo, al algoritmo se le pasa un radio de 5 pixeles, el algoritmo nunca segmentará correctamente el objeto circular deseado.

Mediante las pruebas aplicadas, también se concluye que la arquitectura

propuesta puede ser utilizada en cada una de las etapas de los sistemas de visión artificial, con lo cuál, se obtendrían sistemas de visión en donde el conocimiento puede ser reutilizado en diferentes problemas.

De forma adicional la eficiencia del sistema depende directamente del

conocimiento existente en la base de conocimiento para cada problema en particular, ya que sin el conocimiento adecuado el sistema presentará resultados no deseados.

Capítulo VI Conclusiones


6 Capítulo 6

Conclusiones

6.1 Introducción

Esta sección ésta dedicada a mostrar que con el desarrollo de este trabajo se

cumplió con cada uno de los objetivos contemplados en la propuesta de tesis. A continuación se presenta cada uno de los objetivos y cómo se logro cubrir cada uno de ellos.

6.2 Objetivos alcanzados

Los objetivos planteados inicialmente en la propuesta de tesis son los

siguientes:



Objetivo 1. Contestar la pregunta ¿es posible separar el conocimiento del proceso de segmentación en un sistema para el tratamiento digital de imágenes? La respuesta a esta pregunta es “Sí”, y la prueba es el prototipo desarrollado en esta tesis. Sin embargo cabe aclarar que el conocimiento que se puede separar es el siguiente:

• Conocimiento sobre el dominio.

• Conocimiento sobre la imagen.

• Conocimiento sobre objetos de interés.

• Conocimiento de cómo utilizar un algoritmo de PDI.

• Conocimiento de cuándo utilizar un algoritmo de PDI.

Los algoritmos de PDI siguen teniendo una representación procedimental. Objetivo 2. Estudiar y evaluar los métodos existentes para la representación y uso de conocimiento Para atender este objetivo se procedió a realizar un estudio cualitativo entre los formalismos de representación de conocimiento. Como resultado del estudio se obtuvo la tabla 6.1.

Tabla 6.1 Estudio cualitativo de formalismos de representación de conocimiento

Características Lógica

proposicional Lógica de

predicados Reglas

Redes semánticas

Marcos

Expresividad Poco expresivo

Es el más expresivo

Nivel medio Nivel medio Nivel medio

Valores por defecto No No No Si Si

Excepciones No No No Si Si

Herencia No No No Si Si

Relaciones No Si Si Problemas Si

Metaconocimiento No Si Si No No

Modularidad No Problemas Si Si Si

Estructurado No No No Medio Si

Procedimental No Si Si No Si

Razonamiento Potente No es

eficiente Potente Medio Medio

Explicativo Problemas Problemas Si Medio Medio

Sencillez Si No Si Medio Medio

Inter. con usuario Problemas Muchos

problemas Si Si Si



Objetivo 3. Seleccionar e implementar los métodos de representación y uso de conocimiento adecuados para ser aplicados a la segmentación de imágenes. Los métodos seleccionados para la representación de conocimiento fueron frames y reglas de producción y la decisión fue tomada en base al estudio realizado anteriormente. Posteriormente se diseño e implemento un lenguaje (LBFR) para representación de conocimiento el cual se basa en una combinación de frames y reglas. En este lenguaje es en el que se encuentran escritas las bases de conocimiento. Objetivo 4. Diseñar e implementar una metodología basada en los métodos seleccionados para su aplicación en la segmentación de imágenes. La idea básica que se planteo para aplicar los métodos seleccionados (pertenecientes a los sistemas basados en conocimiento), fue que partiendo de una petición realizada por el usuario y una base de conocimiento, un motor de inferencia generará un script de segmentación, para posteriormente poder llevar a cabo el proceso mismo de segmentación. Aquí con el fin de facilitar el problema se toma al script como una etapa intermedia entre el conocimiento y los algoritmos de procesamiento digital de imágenes. En la figura 6.1 se muestra el enfoque utilizado.

Figura 6.1 Enfoque utilizado para aplicar métodos de SBC en segmentación de imágenes

Objetivo general. Establecer una metodología para la estructuración y uso de conocimiento en problemas de segmentación de imágenes, la cual permita la reutilización del conocimiento.

Este objetivo se logró con el diseño e implementación de la arquitectura que se propone en esta tesis. En la figura 6.1 se muestra un diagrama de los módulos del sistema y la forma en que se comunican.

Motor de inferencia

Petición


script

Resultados

B. C.

Operadores de PDI

Conocimiento



Figura 6.2 Sistema de segmentación de imágenes basado en conocimiento

Como se observa se cumplió con cada uno de los objetivos planteados inicialmente en la propuesta de tesis por lo cual el desarrollo de este trabajo ha llegado a su fin. Finalmente con el desarrollo de este trabajo se puede concluir que el conocimiento a priori ayuda a mejorar el desempeño de los algoritmos de segmentación en un sistema de visión artificial, pero también es cierto que sólo mediante la separación de los algoritmos y el conocimiento, es posible reutilizar los sistemas de segmentación de forma eficaz, sin necesidad de interactuar con el código de los algoritmos.

6.3 Aportaciones

• La principal aportación de este trabajo es la arquitectura propuesta para los

sistemas de segmentación de imágenes, la cual mantiene una separación entre los algoritmos de segmentación y el conocimiento relacionado a los mismos. Dicha arquitectura puede ser utilizada en cada una de las etapas de la visión artificial.

• Se desarrolló un lenguaje de segmentación de imágenes basado en scripts,

el cual posee una estructura dinámica, permitiendo de esta forma, la adición de nuevos elementos sin necesidad de modificar el código del intérprete de scripts.

Analizador léxico y

sintáctico para B. C.

Comandos

Errores

Registro de

errores

Biblioteca de operadores

Resultado

IGU


Script

Motor de inferencia


Imagen

Registro de operadores

Especificaciones

Parámetros

Resultados

Errores

Petición y B. C.

B. C.

Script y/o errores

Conocimiento

Script Resultado



• El intérprete de scripts implementado administra la ejecución de los

operadores de segmentación y controla la interacción entre ellos. El intérprete es el encargado de mostrar los resultados al usuario.

• Se estableció una sintaxis básica para el desarrollo de operadores de

segmentación.

• Se creó una biblioteca de operadores de segmentación y manipulación de imágenes (14 operadores) para el lenguaje basado en scripts.

• Se desarrolló un prototipo de lenguaje para representar conocimiento,

basándose en los formalismos de reglas de producción y marcos (lenguaje LBFR).

• Se implemento el prototipo de una máquina de inferencia para el lenguaje

LBFR.

• Finalmente se desarrolló el prototipo de un sistema de segmentación de imágenes basado en la arquitectura propuesta. También se crearon las bases de conocimiento para segmentar puntos, líneas, círculos y elipses.

• Cabe mencionar que durante el desarrolló de este trabajo se publicaron los

siguientes artículos:

o Lenguaje de scripts para segmentación de imágenes, Looking Foorward, Computer Society, IEEE, vol. 13, verano 2006.

o El conocimiento en los sistemas de segmentación de imágenes,

Universidad de Colima, Jornadas Internacionales de Ciencias Computacionales 2005.

• De igual forma se participo en las siguientes conferencias:

o Sistemas basados en conocimiento y visión artificial, Participación

durante la XII Semana Nacional de Ciencia y Tecnología, Centro de Estudios Tecnológicos e Industriales y de Servicios No. 99, Morelos, 2005.

6.4 Trabajos futuros

Ya que se ha probado la arquitectura propuesta mediante el desarrollo de un

prototipo en la segmentación de imágenes, el siguiente paso en investigaciones futuras es probar el prototipo con cada una de las etapas de la visión artificial para finalmente iniciar el desarrollo de un sistema robusto.



Algunas consideraciones que se deben tomar en cuenta para el desarrollo de un sistema robusto basado en la arquitectura propuesta son:

• Agregar a la máquina de inferencia la capacidad de realizar

razonamiento geométrico, con el fin de poder trabajar con objetos compuestos por primitivas (puntos, líneas, círculos, elipses, etc.).

• Implementar los operadores de segmentación en lenguaje ensamblador

con el fin de reducir el tiempo de procesamiento en cada uno de los operadores.

• Sustituir el lenguaje LBFR y su máquina de inferencia (son prototipos)

por un lenguaje más robusto. El cual puede ser adquirido o desarrollado por el mismo cenidet.

• Utilizar XML para almacenar el contenido de la base de conocimiento, lo

cual podría brindar portabilidad a la base de conocimiento con otros sistemas.

Referencias


Referencias [1] Bender, Edgard A., Mathematical Methods in Artificial Intelligence, IEEE Computer Society Press, Los Alamitos, CA, 1996. [2] Haugeland, J., Ed., Artificial Intelligence: The Very Idea, MIT Press, Cambridge, 1985. [3] Amit konar, Artificial Intelligence and Soft Computing: Behavioral and Cognitive Modeling of the Human Brain, Deparment of Electronics and Tele-communication Engineering, Jadavpur University, Calcuta, India, 1999. [4] Konar A., Uncertainty Management in Expert Systems using Fuzzy Petri Nets, Ph.D. thesis, Jadavpur University, Calcutta, 1994. [5] Hernández Sosa D., Cabrera Gámez J. “SVEX: A Knowledge-Based Tool for Image Segmentation”, Departamento de Informática y Sistemas, Universidad de Las Palmas de Gran Canaria, Campus Universitario de Tafira, 35017 Las Palmas, España,1995. [6] E. Rich, K. Knight, “Inteligencia Artificial”, (2da edición; Aravaca, Madrid, España: McGraw-Hill. 1994). [7] Rafael C. Gonzáles, “Tratamiento digital de imágenes”. (3ra edición; Wilmington, Delaware, E.U.A.: Addisson Wesley. 1996). [8] M. Delgado y W. Fajardo, Apuntes de ingeniería del conocimiento. Universidad de Granada, España. [9] Miguel A. Gutiérrez Naranjo, “Introducción a la ingeniería de conocimiento“. Universidad de Sevilla. Depto. De Ciencias Computacionales e Inteligencia Artificial. Curso 2004-2005. [10] Sistemas inteligentes: Representación del conocimiento, 2001 DIT-ETSIT-UPM, Universidad Politécnica de Madrid. [11] Miguel A. Gutiérrez Naranjo, “Introducción a la ingeniería de conocimiento“. Universidad de Sevilla. Depto. De Ciencias Computacionales e Inteligencia Artificial. Curso 2004-2005. [12] M. Chantal Pérez Hernández. Explotación de los córpora textuales informatizados para la creación de bases de datos terminológicas basadas en el conocimiento, Universidad de Málaga. Volumen 18 (2002). ISSN:1139-8736. Localización: http://elies.rediris.es/elies18/. Fecha de consulta: 24-septiembre-2005.

Referencias


[13] C. S. Krishnamoorthy, S. Rajeev, “Artificial Intelligence and Expert Systems for Engineers”, CRC Press, CRC Press LLC, 1996. [14] Ricardo Aler M., Daniel Borrajo M., Andrés Silva V., Universidad Carlos III de Madrid, Área de Ciencias Computacionales e Inteligencia Artificial. Ubicación: www.uc3m.es [15] Raisa Socorro, Mailyn Moreno, “Las ontologías en la representación del conocimiento”, Centro de Estudios en Ingeniería de Sistemas (CEIS), Instituto Superior Politécnico, 1998. [16] Pérez J. Luis, “Introducción a la inteligencia artificial”, Curso 2003-2004, Universidad de Málaga, www.lcc.uma.es/~perez/introia/tema6-1.pdf, fecha de consulta: 12-septiembre-2005. [17] Martin A. Fischler, “Intelligence: The eye, the brain, and the computer”, Ed. Addison-Wesley. 1987. [18] Gerhard X. Ritter, “HandBook of Computer Vision Algorithms in Image Algebra”, 2da. Edición, Editorial CRC Press, 2001. [19] Takashi Matsuyam, “Expert Systems for Image Processing –Knowledge-Based Composition of Image Analysis Processes”. Departament of Information Engineering, Tohoku University. Sendai, Miyagi 980, Japan, 1988. [20] Hernández-Sosa, D., Cabrera-Gámez, J., Falcón-Martel, A., Hernández-Tejera, M., “SVEX: A knowledge-Based Tool for Image Segmentation”, Departamento de Informática y Sistemas. Universidad de las Palmas de la Gran Canaria. Campus universitario de Tafira, 35017 Las Palmas, Spain, 1995. [21] R. Clouard, A. Elmoataz, C. Porquet & M. Revenu, “BORG: A Knowledge-Based System for the Automation of Image segmentation tasks”. Research Group in Computer Science, Image and Instrumentation of Caen, France. Image Processing and its Aplications, 4-6 Julio 1995, Conference Publication No. 410, © IEEE 1995. [22] Marwan A. Simaan, Zhen Zhang, “SEISIS: A Rule-Based systems for Segmentation of a Seismic Section Base don texture”. University of Pittsburg, Department of Electrical engineering, 1995. [23] Sabine Moisan, “Knowledge Representation for Program Reuse”, ECAI 2002, Lyon, France 2000. [24] Petra Perner, “Controlling the Segmentation Parameters by Case-Based Reasoning”, http://members.aol.com/ibaiperner. 2000 IEEE. [25] Ahmed E. Ibrahim, “An Intelligente Framework for Image Understanding”, 2003. Fecha de consulta: 10-11-2005.

Referencias


http://www.engr.uconn.edu/~ibrahim/publications/image.html [26] Céline Hudelot, Monique Thonnat, “An Architecture for Knowledge Based Image Interpretation”, INRIA, Sophia Antipolis, Frances – Orion Team, 2003. [27] Nicolas Maillot, Monique Thonnat, Alain Boucher, “Towards Ontology Based Cognitive Vision”, INRIA, Sophia Antipolis – Orion Team. France. 2004. [28] Céline Hudelot, “Towards a Cognitive Vision Platform for Semantic Image Interpretation; Application to the Recognition of Biological Organisms”, ORION – INRIA Sophia – Antipolis. Francia. 2005. [29] Sabine Moisan, “Program Supervisión: YAKL and PEGASE+”, Repport de Recherche, INRIA, December 2003. [30] Michael Negnevitsky, “Artificial Intelligence; A Guide to Intelligent Systems”, Segunda Edición, Addison-wesley, England, 2005. [31] Amit Konar, “Artificial Intelligence and Soft Computting: Behavioral and Cognitive Modeling of the Human Brain”, CR Press, USA, 2000. [32] Jackson, P., Introduction to Expert Systems, Addison-Wesley, Reading, MA, 1986.

Anexos


7 Anexos

7.1 Nomenclatura de álgebra de imágenes X, Y, Z Letras mayúsculas representan conjuntos arbitrarios.

x, y, z Letras minúsculas representan elementos de un conjunto arbitrario.

X, Y, Z Letras mayúsculas en negrita representan conjuntos de puntos.

x, y, z Letras minúsculas en negrita representan elementos de un conjunto de puntos (es decir puntos).

ƒ Representa un conjunto de valores arbitrario.

ℜ Denota al conjunto de los números reales.

ℑ Denota al conjunto de los números enteros.

F Conjunto arbitrario de valores.

∈ Es un elemento de.

⊂ Es subconjunto de.

ττττ Umbral.

Anexos


7.2 Comandos del lenguaje de segmentación basado en scripts

Antes de comenzar con la descripción de los comandos que forman el lenguaje de segmentación cabe mencionar que cada uno se encuentra relacionado a un operador (programa hecho en C++ Builder 5.0). Cada uno de los operadores es independiente y la forma en que interactúan entre ellos es mediante archivos. Los operadores implementados son los siguientes: VerImagen.exe Este operador es el único que cuenta con interfaz gráfica ya que es el que permite que el usuario visualice en pantalla una imagen, la cual puede ser el resultado de un procesamiento. La especificación de este operador para el intérprete de scripts es la siguiente:

Nombre del comando VerImagenGris Archivo ejecutable VerImagen.exe Parámetros de entrada 1 Parámetro Parámetros de salida 0 Parámetros Sintaxis del operador: VerImagenGris ([imagen]) [imagen]

� Es una variable de tipo ImagenGris la cual contiene en memoria la imagen que se quiere visualizar.

AbrirImagenGris.exe Este operador permite que el usuario cargue en memoria una imagen. El contenido de la imagen se almacena en una variable para su posterior procesamiento. La especificación de este operador para el intérprete de scripts es la siguiente:

Nombre del comando AbrirImagenGris Archivo ejecutable AbrirImagenGris.exe Parámetros de entrada 1 Parámetro Parámetros de salida 1 Parámetros Sintaxis del operador: [Imagen]=AbrirImagenGris ([ruta_archivo_imagen]) [imagen]

� Es una variable de tipo ImagenGris la cual almacenará en memoria la imagen que se indica en [ruta_archivo_imagen].

[ruta_archivo_imagen]

� Es una literal que especifica la ruta y el nombre de archivo de la imagen que se quiere cargar a memoria.

Nota: El formato de imágenes que soporta el intérprete es BMP de 24 bits, sin comprensión. Sin embargo sólo se trabaja con la banda Azul. Por lo cual las imágenes se verán en escala de grises sin importar que originalmente se trate de una imagen a color.

Anexos


GuardarImagenGris.exe

Este operador permite que el usuario almacene en archivo el contenido de una imagen. La especificación de este operador para el intérprete de scripts es la siguiente:

Nombre del comando GuardarImagenGris Archivo ejecutable GuardarImagenGris.exe Parámetros de entrada 2 Parámetros Parámetros de salida 0 Parámetros Sintaxis del operador: GuardarImagenGris ([imagen], [ruta_archivo_imagen]) [imagen]

� Es una variable de tipo ImagenGris la cual almacenará en memoria la imagen que se indica en [ruta_archivo_imagen].

[ruta_archivo_imagen]

� Es una literal que especifica la ruta y el nombre de archivo de la imagen que se quiere cargar a memoria.


BinarizarImagenGris.exe

Este operador permite que el usuario aplique un nivel de umbral para realizar la binarización de una imagen. La especificación de este operador para el intérprete de scripts es la siguiente:

Nombre del comando BinarizarImagenGris Archivo ejecutable BinarizarImagenGris.exe Parámetros de entrada 2 Parámetros Parámetros de salida 1 Parámetro Sintaxis del operador: [imagenFinal]=AbrirImagenGris ([imagenInicial], [umbral]) [imagenFinal]

� Es una variable de tipo ImagenGris la cual almacena en memoria la imagen resultante del proceso de umbralización (imagen binaria).

[imagenInicial] � Es una variable de tipo ImagenGris que contiene la imagen original a la cual se le aplicará el proceso de

umbralización. [umbral]

� Este parámetro es de tipo Entero y el valor debe estar en el rango de 0 a 255, en base a este umbral se aplica una umbralización.


NegativoImagen.exe

Permite al usuario crear el negativo de una imagen. La especificación de este operador para el intérprete de scripts es la siguiente:

Anexos


Nombre del comando NegativoImagen Archivo ejecutable NegativoImagen.exe Parámetros de entrada 1 Parámetro Parámetros de salida 1 Parámetro Sintaxis del operador: [imagenFinal]=NegativoImagen ([imagenInicial]) [imagenFinal]

� Es una variable de tipo ImagenGris la cual almacena en memoria la imagen resultante del proceso de crear el negativo (imagen binaria).

[imagenInicial] � Es una variable de tipo ImagenGris que contiene la imagen original a la cual se le aplicará el proceso para crear

el negativo.

AbrirMascara.exe

Permite al usuario cargar en memoria una máscara para poder ser utilizada posteriormente en un proceso de convolución. La especificación de este operador para el intérprete de scripts es la siguiente:

Nombre del comando AbrirMascara Archivo ejecutable AbrirMascara.exe Parámetros de entrada 1 Parámetro Parámetros de salida 1 Parámetro Sintaxis del operador: [mascara]=AbrirMascara ([ruta_archivo_mascara]) [mascara]

� Es una variable de tipo Mascara la cual almacena en memoria el contenido de la máscara que se encuentra almacenada en un archivo.

[ruta_archivo_mascara] � Es una literal que indica la ruta y el nombre del archivo en donde se encuentra la mascara que se cargará en

memoria. Nota: La máscara se encuentra almacenada en el archivo en forma binaria y la extensión del archivo es *.MAS.

Convolucion.exe

Permite al usuario realizar un proceso de convolución entre una imagen y una máscara indicada por el usuario. La especificación de este operador para el intérprete de scripts es la siguiente:

Nombre del comando Convolución Archivo ejecutable Convolución.exe Parámetros de entrada 2 Parámetros Parámetros de salida 1 Parámetro Sintaxis del operador: [imagenFinal]=Convolucion ([imagenInicial],[mascara]) [mascara]

� Es una variable de tipo Mascara que almacena en memoria el contenido de la máscara que se encuentra

Anexos


almacenada en un archivo. [imagenFinal]

� Es una variable de tipo ImagenGris que almacena en memoria la imagen resultante del proceso de convolución. [imagenInicial]

� Es una variable de tipo ImagenGris que contiene la imagen original a la cual se le aplicará el proceso de convolución.

PKernelGaussiano.exe

Permite al usuario crear el núcleo de una máscara gaussiana. La especificación de este operador para el intérprete de scripts es la siguiente:

Nombre del comando CrearMascaraG Archivo ejecutable PKernelGaussiano.exe Parámetros de entrada 3 Parámetros Parámetros de salida 1 Parámetro Sintaxis del operador: [mascara]=CrearMascaraG ([columnas],[renglones],[sigma]) [mascara]

� Es una variable de tipo Mascara que almacena en memoria el contenido de la máscara gaussiana que resulta del procesamiento.

[columnas] � Es un valor entero e indica el número de columnas que debe tener la máscara.

[renglones] � Es un valor entero e indica el número de renglones que debe tener la máscara.

[sigma] � Es el valor de la desviación que utilizará el sistema para generar el núcleo de la máscara gaussiana. Cuando

sigma tiene el valor de 1.0 se está utilizando una desviación estándar. Sigma es un valor Real positivo.

Canny.exe


Nombre del comando Canny Archivo ejecutable Canny.exe Parámetros de entrada 3 Parámetros Parámetros de salida 1 Parámetro Sintaxis del operador: [imagenFinal]=Canny ([imagenInicial],[umbral_inf],[umbral_sup]) [imagenFinal]

� Es una variable ImagenGris que almacena el resultado del procesamiento que realiza el algoritmo de Canny. [iamgenInicial]

� Es una variable ImagenGris que contiene la imagen original que será procesada por Canny. [umbral_inf]

� Es un valor entero que representa un valor de umbral inferior que requiere el algoritmo de Canny. [umbral_sup]

� Es un valor entero que representa un valor de umbral superior que requiere el algoritmo de Canny.

Anexos


FreiChen.exe


Nombre del comando FreiChen Archivo ejecutable FreiChen.exe Parámetros de entrada 2 Parámetros Parámetros de salida 1 Parámetro Sintaxis del operador: [imagenFinal]=FreiChen ([imagenInicial],[umbral]) [imagenFinal]

� Es una variable ImagenGris que almacena el resultado del procesamiento que realiza el algoritmo de FreiChen. [iamgenInicial]

� Es una variable ImagenGris que contiene la imagen original que será procesada por FreiChen. [umbral]

� Es un valor real que representa un valor de umbral inferior que requiere el algoritmo de FreiChen.

HoughLine.exe

Permite al usuario al usuario identificar los pixeles que pertenecen a líneas que cumplan los siguientes criterios que son especificados por el usuario:

• Número mínimo de pixeles que debe tener una línea para ser considerada como tal y no como ruido.

• La distancia entre un píxel que forma parte de una línea y el nuevo píxel.

Adicionalmente el usuario puede especificar la resolución que será utilizada para procesar la imagen en busca de líneas. Los parámetros a los que se puede modificar la resolución son:

• El ángulo. • El valor de theta.

La resolución evita la existencia de posibles líneas repetidas, en donde la

diferencia entre ellas sea mínima, con el ángulo y theta indica al sistema cuál es la diferencia entre dos líneas para considerarse independientes.

Nombre del comando Líneas Archivo ejecutable HoughLine.exe Parámetros de entrada 5 Parámetros Parámetros de salida 1 Parámetro Sintaxis del operador: [imagenFinal]=Lineas ([imagenInicial],[ro],[theta],[minP],[maxD]) [imagenFinal]

� Es una variable ImagenGris que almacena el resultado del procesamiento que realiza el algoritmo de la transformada de Hough para líneas.

[iamgenInicial] � Es una variable ImagenGris que contiene la imagen original que será procesada por la transformada de Hough.

[ro]

Anexos


� Valor de la resolución que se maneja en ro. [theta]

� Valor de la resolución que se maneja en el ángulo theta. [minP]

� cantidad mínima de puntos que debe tener una línea para ser considerada como tal. [maxD]

� Distancia máxima que debe existir entre dos puntos y poder considerar los como parte de una línea.

CHT.exe

Permite al usuario al usuario identificar los pixeles que pertenecen a círculos que cumplan los siguientes criterios que son especificados por el usuario:

• Número mínimo de pixeles que debe pertenecer a un círculo para ser considerada como tal y no como ruido.

• El radio del circulo que se quiero segmentar.

Adicionalmente el usuario puede especificar la resolución que será utilizada

para procesar la imagen en busca de círculos. Los parámetros a los cuales se les puede modificar la resolución son:

Nombre del comando Círculos Archivo ejecutable CHT.exe Parámetros de entrada 6 Parámetros Parámetros de salida 1 Parámetro Sintaxis del operador: [imagenFinal]=Circulos ([imagenInicial],[rX],[rY],[minP],[minR],[maxR]) [imagenFinal]

� Es una variable ImagenGris que almacena el resultado del procesamiento que realiza el algoritmo de la transformada de Hough para círculos.

[iamgenInicial] � Es una variable ImagenGris que contiene la imagen original que será procesada por la transformada de Hough.

[rX] � Valor de la resolución que se maneja en el eje X.

[rY] � Valor de la resolución que se maneja en el eje Y.

[minP] � cantidad mínima de puntos que debe tener un círculo para ser considerada como tal.

[minR] � Valor mínimo que tiene el círculo que se quiere detectar.

[maxR] � Valor máximo que tiene el círculo que se quiere detectar.

Anexos


7.3 Gramática EBNF del lenguaje LBFR

options { language="Cpp"; } class operadorLexer extends Lexer; options { charVocabulary = '\3'..'\377'; //Unicodes usuales testLiterals = false; k=11; } tokens { OP_PRIMITIVO ="OperadorPrimitivo"; OP_COMPUESTO ="OperadorCompuesto"; NOMBRE ="Nombre"; COMENTARIO ="Comentario"; CARACTERISTICAS ="Caracteristicas"; PAR_ENTRADA ="ParametrosEntrada"; PAR_SALIDA ="ParametrosSalida"; TIPO_ENTERO ="Entero"; TIPO_REAL ="Real"; TIPO_CADENA ="Cadena"; TIPO_IMAGEN ="ImagenGris"; TIPO_MASCARA ="Mascara"; TIPO_CONTORNO ="Contorno"; REGLAS_PAR ="ReglasParametros"; REGLAS_SEL ="ReglasSeleccion"; IMAGEN ="Imagen"; PROPIEDADES_IMG ="PropiedadesImagen"; OBJETO ="Objeto"; PROPIEDADES ="Propiedades"; REGLAS_OBJETO ="ReglasObjeto"; ACCIONES ="Acciones"; ESTRATEGIA ="Estrategia"; ARCHIVO ="Archivo"; COMANDO ="Comando"; }

Anexos


BLANCO : ( ' ' | '\t' | '\n' ) {_ttype=ANTLR_USE_NAMESPACE(antlr)Token::SKIP;} ; IDENT options {testLiterals=true;} : (('a'..'z')|('A'..'Z')) (('a'..'z')|('A'..'Z')| ('0'..'9')|'_')* ; //Operadores aritmeticos OP_ASIGNACION :'='; OP_MENOR :"<"; OP_MAYOR :">"; OP_SI :":-"; OP_PUNTO :'.'; OP_COMA :','; OP_COMPARA :"=="; //Separadores LLAVE_AB :'{'; LLAVE_CE :'}'; LIT_NUMERO : (('1'..'9') ('0'..'9')* '.') => ('1'..'9') ('0'..'9')* '.' ('0'..'9')+ {$setType(LIT_REAL);} | ('0' '.') => '0' '.' ('0'..'9')+ {$setType(LIT_REAL);} | (('1'..'9') ('0'..'9')*) {$setType(LIT_ENTERO);} ; LIT_CADENA : '\"' ! (~('\"' | '\n' | '\r'))* '\"' ! ; class operadorParser extends Parser;

Anexos


options { k=11; } bc : (imagen)* (op_primitivo)+ (objeto)+ ; op_primitivo : OP_PRIMITIVO LLAVE_AB nombre comentario caracteristicas (parametros_entrada)? (parametros_salida)? (reglas_parametros)? comando LLAVE_CE ; nombre : NOMBRE IDENT ; comentario : | COMENTARIO LIT_CADENA ; parametros_salida : PAR_SALIDA (tipo IDENT (valor)?)+ ; parametros_entrada : PAR_ENTRADA (tipo IDENT (valor)?)+

Anexos


; valor : LIT_CADENA | LIT_ENTERO | LIT_REAL ; tipo : TIPO_ENTERO | TIPO_REAL | TIPO_CADENA | TIPO_IMAGEN | TIPO_MASCARA | TIPO_CONTORNO ; caracteristicas : TIPO_CADENA CARACTERISTICAS lista_cadena ; lista_cadena : LIT_CADENA (OP_COMA LIT_CADENA)* ; reglas_seleccion : REGLAS_SEL (regla_sel)+ ; reglas_parametros : REGLAS_PAR lista_reglas ; regla_sel : IDENT OP_SI lista_condiciones ; lista_reglas :

Anexos


(regla)+ ; regla :

IDENT OP_ASIGNACION (ident_compuesto | valor) (OP_SI lista_condiciones)?

; ident_compuesto : IDENT (OP_PUNTO (IDENT|ARCHIVO|CARACTERISTICAS))? ; lista_condiciones : condicion (OP_COMA condicion)* ; op_signo: OP_MENOR | OP_COMPARA | OP_MAYOR ; condicion : ident_compuesto (op_signo (ident_compuesto|valor))? ; comando : COMANDO LIT_CADENA (valor|ident_compuesto)* ; imagen : IMAGEN LLAVE_AB nombre PROPIEDADES_IMG TIPO_CADENA archivo caracteristicas LLAVE_CE ; archivo

Anexos


: ARCHIVO LIT_CADENA ; objeto : OBJETO LLAVE_AB nombre comentario PROPIEDADES (propiedad)+ REGLAS_OBJETO (reglas_objeto)? LLAVE_CE ; propiedad : tipo IDENT (valor)? ; reglas_objeto : lista_reglas_objeto ; lista_reglas_objeto : (regla_objeto)+ ; regla_objeto : IDENT (OP_SI lista_condiciones_objeto)? ; lista_condiciones_objeto : condicion_objeto (OP_COMA condicion_objeto)* ; condicion_objeto :

ident_compuesto ((OP_ASIGNACION|OP_COMPARA) (ident_compuesto|valor))?

;

Anexos


7.4 Base de conocimiento de ejemplo

OperadorPrimitivo { Nombre PasaAlto Comentario "Mascara de filtro pasa alto" Cadena Caracteristicas "sencillo" ParametrosSalida Mascara mscO Comando "mscO=AbrirMascara('D:\sbc\mascaras\puntos.mas')" } OperadorPrimitivo { Nombre Convolucion Comentario "Operador para realizar convolucion" Cadena Caracteristicas "rapido" ParametrosEntrada ImagenGris imgI Mascara mscI ParametrosSalida ImagenGris imgO Comando "imgO=Convolucion(imgI,mscI)" } OperadorPrimitivo { Nombre Binarizar Comentario "Operador para umbralizar una imagen" Cadena Caracteristicas "" ParametrosEntrada ImagenGris imgI Entero umbral1 ParametrosSalida ImagenGris imgO Comando "imgO=BinarizarImagenGris(imgI,umbral1)" } OperadorPrimitivo { Nombre VerImagen Comentario "Operador para visualizar una imagen" Cadena Caracteristicas ""

Anexos


ParametrosEntrada ImagenGris imgI Comando "VerImagenGris(imgI)" } OperadorPrimitivo { Nombre LHT Comentario "Identifica lineas" Cadena Caracteristicas "lento" ParametrosEntrada ImagenGris imgI Entero ro Entero theta Entero minP Entero maxD ParametrosSalida ImagenGris imgO ReglasParametros ro=1 theta=1 minP=100:-myImage.Caracteristicas=="Carretera" minP=50:-myImage.Caracteristicas=="Rectangulo" maxD=15:-myImage.Caracteristicas=="Carretera" maxD=2:-myImage.Caracteristicas=="Rectangulo" Comando "imgO=Lineas(imgI,ro,theta,minP,maxD)" } OperadorPrimitivo { Nombre FreiChen Comentario "Operador para segmentar líneas" Cadena Caracteristicas "eficiente" ParametrosEntrada ImagenGris imgI Real umbral ParametrosSalida ImagenGris imgO ReglasParametros umbral=2.0 Comando "imgO=FreiChen(imgI,umbral)" } OperadorPrimitivo { Nombre CHT Comentario "Identifica circulos"

Anexos


Cadena Caracteristicas "lento" ParametrosEntrada ImagenGris imgI Entero rX Entero rY Entero minP Entero minR Entero maxR ParametrosSalida ImagenGris imgO ReglasParametros rX=1 rY=1 minP=120 minR=150 maxR=150 Comando "imgO=Circulos(imgI,rX,rY,minP,minR,maxR)" } OperadorPrimitivo { Nombre EHT Comentario "Identifica elipses" Cadena Caracteristicas "lento" ParametrosEntrada ImagenGris imgI Entero rX Entero rY Entero mxI Entero mxS Entero mnI Entero mnS Entero ne ParametrosSalida ImagenGris imgO ReglasParametros rX=1 rY=1 mxI=35 mxS=35 mnI=15 mnS=15 ne=1 Comando "imgO=Elipses(imgI,rX,rY,mxI,mxS,mnI,mnS,ne)" } Objeto

Anexos


{ Nombre Punto Comentario "Objeto que encapsula la segmentacion de puntos" Propiedades Cadena Fondo ReglasObjeto Punto:-Convolucion.imgI=myImage.Archivo,PasaAlto,

Convolucion.mscI=PasaAlto.mscO,Convolucion, Binarizar.imgI=Convolucion.imgO,Binarizar.umbral1=120, Binarizar,VerImagen.imgI=Binarizar.imgO,VerImagen

Convolucion Binarizar PasaAlto VerImagen } Objeto { Nombre Linea Comentario "Objeto que encapsula la segmentacion de lineas" Propiedades Cadena Fondo ReglasObjeto Linea:-Binarizar.imgI=myImage.Archivo,

myImage.Caracteristicas=="Carretera",Binarizar.umbral1=230, Binarizar,FreiChen.imgI=Binarizar.imgO,FreiChen, LHT.imgI=FreiChen.imgO,LHT,VerImagen.imgI=LHT.imgO, VerImagen

Linea:-FreiChen.imgI=myImage.Archivo,FreiChen, LHT.imgI=FreiChen.imgO,LHT,VerImagen.imgI=LHT.imgO, VerImagen

FreiChen Binarizar VerImagen LHT } Objeto { Nombre Circulo Comentario "Objeto que encapsula la segmentacion de circulos" Propiedades Cadena Fondo ReglasObjeto Circulo:-CHT.imgI=myImage.Archivo,

CHT,VerImagen.imgI=CHT.imgO,VerImagen CHT

Anexos


VerImagen } Objeto { Nombre Elipse Comentario "Objeto que encapsula la segmentacion de elipses" Propiedades Cadena Fondo ReglasObjeto Elipse:-Binarizar.imgI=myImage.Archivo,Binarizar.umbral1=120,

Binarizar,Convolucion.imgI=Binarizar.imgO,PasaAlto, Convolucion.mscI=PasaAlto.mscO,Convolucion, EHT.imgI=Convolucion.imgO,EHT,VerImagen.imgI=EHT.imgO, VerImagen

Binarizar Convolucion PasaAlto EHT VerImagen }

c e n i d e t jose francisc… · centro nacional de investigaciÓn y desarrollo tecnolÓgico c e n...

Documents