REPORTE DE PROYECTO TERMINAL I Y I1
82
INGENIE~A ELECTR~NICA LICENCIATURA EN COMPUTACI~N REPORTE DE PROYECTO TERMINAL I Y I1 4 93 3 %3- ASESOR: Mariko Nakano Miyatake INTEGRANTES: /Ávila Molina Sergio 91320224 Moreno Montiel Victor Hugo 90220647 /Tapia Tapia Rubén 91325798 19 de Noviembre de 1996
Transcript of REPORTE DE PROYECTO TERMINAL I Y I1
I N G E N I E ~ A ELECTR~NICA LICENCIATURA EN COMPUTACI~N
REPORTE DE PROYECTO TERMINAL I Y I1
4 93 3 %3- ASESOR: Mariko Nakano Miyatake
INTEGRANTES: /Ávila Molina Sergio 91320224
Moreno Montiel Victor Hugo 90220647 /Tapia Tapia Rubén 91325798
19 de Noviembre de 1996
Dedicado a;
Mariko Nakano por su infinita paciencia y gran ayuda para la realización de este proyecto.
Nuestros Padrespor su apoyo incondicional brindado a lo largo de nuestra carrera universitaria.
2
ÍNDICE
Agradecimientos 2
CAPÍTULO 1. REDES NEURONALES CELULARES. (CNN)
1.1 Introducción a las redes neuronales 1.2 Redes neuronales celulares (CNN) 1.3 Arquitectura de una CNN 1.4 Aplicaciones
CAPÍTULO 2. PROCESAMIENTO DE IMÁGENES CON CNN.
2.1 Antecedentes técnicos. 2.1.1 Archivos TIFF’S 2.1.2 Templates
2.2 Sistema a desarrollar. 2.2.1 Etapa 1 (Desplegar imagen original) 2.2.2 Etapa 2 (Obtención del Cloning Template) 2.2.3 Etapa 3 (Selección del método de integración) 2.2.4 Etapa 4 (Cálculo de CNN) 2.2.5 Etapa 5 (Desplegar imagen procesada)
APÉNDICES.
Apéndice A. Red de Hopfield Apéndice B. Código fuente Apéndice C. Manual de usuario
4 7 9 15
20 25
30 31 32 32 32
33 37 75
B i bliografia
3
82
L
1890-1950
1950-1969
1970- 1985
_I
as investigaciones sobre redes neuronales artificiales comenzaron a finales del siglo XIX, algunos psicólogos hicieron intentos para identificar la base neuronal de la inteligencia. En 1950, los modelos computacionales
abstractos de inteligencia comenzaron a surgir. Con el advenimiento de la computación de propósito general, extensas simulaciones de redes neuronales artificiales comprendiendo una unidad simple (así como las que comprenden una capa de unidades) fueron llevadas a cabo, y algoritmos de aprendizaje simple para redes neuronales artificiales que contienen una unidad desarrollada. En 1969, un análisis teórico revelo limitaciones significantes de modelos simples.
Durante la década de los 70s y principios de los 80s técnicas teóricas de termodinámica y sistemas teóricos fueron adaptados para el análisis y desarrollo de redes generales no lineales, de multicapas, culminando en el desarrollo de poderosos procedimientos de aprendizaje. Estos procedimientos de aprendizaje se conocieron ampliamente en 1985, año que marco el advenimiento de modernas investigaciones sobre redes neuronales artificiales.
La tabla 1-1 resume las etapas significativas de las investigaciones sobre redes neuronales artificiales.
Ideas preliminares en las bases de la inteligencia: James, Hebb, Lashley, y otros. Modelos computacionales abstractos de redes neuronales: McCulloch y Pitts. Las primeras redes neuronales computacionales: Minsky, Rosenblatt, Selfridge, Widrow y Samuel. Continúan los trabajos sobre memoria asociativa: Kohonen, Willshaw, Kaverva, Anderson y simulaciones de reconocimiento de Hopfield y maquinas de Botzmann: Kikpatrick, Ackley, Hinton y Seynowsky Atxendizaie en redes de multicaDas: Werbs. Parker. Le Cun v Rumelhart.
Tabla 1-1.
Muchos creen que las ideas fundamentales de las conexiones se originaron con los escritos del psicólogo William James, en el siglo XIX, quien argumento que esas asociaciones elementales forman la base de complejas relaciones. Él propuso una regla de aprendizaje primitiva.
4
Muchos de los importantes desarrollos en computación y neurociencia se pudieron unir a principios del siglo XIX en el trabajo de McCulloch y Pitts, quienes fundamentalmente estudiaron la representación de las capacidades de una simple red neuronal artificial. En 1950, Hebb postuló reglas simples para el aprendizaje asociativo y Lashley presentó evidencia biológica injustificada de representaciones distribuidas.
1.1.2 Definición.
Una red neuronal artificial es un sistema de procesamiento de información que tiene ciertas características en común con las redes neuronales biológicas. Las redes neuronales artificiales han sido realizadas como generalizaciones de modelos matemáticos de la percepción humana o neurobiología, basadas en las suposiciones siguientes:
1) El procesamiento de información ocurre en muchos elementos simples llamados
2) Las señales pasan a través de las neuronas en uniones de conexión. 3) Cada unión de conexión tiene un peso asociado, el cual en una red neuronal típica,
multiplica la señal, transmitida. 4) Cada neurona aplica una función de transmisión (usualmente no lineal) para su entrada a
la red ( la suma de las señales de entrada que son pesadas) para determinar su señal de salida.
neuronas.
Una red neuronal esta caracterizada por (1) su patrón de conexiones entre las neuronas (llamada su arquitectura), (2) su método para la determinación de los pesos en las conexiones (llamado su algoritmo de preparación o de aprendizaje), y (3) su función de activación.
Una vez que se distingue a las redes neuronales (artificiales) de otras aproximaciones para el procesamiento de información se proporciona una introducción del como y cuando usar las redes neuronales, pero primero vamos a definir las características de las redes neuronales.
Una red neuronal consiste de un gran número de elementos de procesamiento simples llamados neuronas, unidades, células o nodus. Cada neurona esta conectada a otras neuronas mediante uniones de conexión directa, cada una con un peso asociado. El peso representa la información que es usada por la red para resolver un problema. Las redes neuronales pueden ser aplicadas a una amplia variedad de problemas tales como almacenamiento y recuperación de datos o patrones, realización de mapas generales de entrada de patrones a salida de patrones, agrupación de patrones similares, o encontrar soluciones para problemas de optimización.
Cada neurona tiene un estado interno, llamado su activación o nivel de actividad, el cual es una función de las entradas que ha recibido. Típicamente, una neurona envía su
5
activación como una señal a varias neuronas. Es importante notar que una neurona puede enviar una señal a la vez, aunque la señal es transmitida a varias neuronas.
Durante los últimos años la actividad en el campo de las redes neuronales artificiales se ha incrementado exponencialmente. Esta confluencia de esfuerzos ha provocado un enorme volumen de investigaciones publicadas, 500 o más, tan solo en 1989, y también en la creación de nuevos periódicos y revistas relacionadas con este campo.
El trabajo en esta área es nuevo como el procesamiento de imágenes, robótica, procesamiento de señales, óptica, ingeniería medica, sistemas de manufacturación, todo en un intento para establecer nuevos estándares de realización para la observación de viejos problemas en una nueva manera.
Hay tres principales ingredientes para una red neuronal:
a) la disposición de los nodos y uniones entre ellos; b) un algoritmo para el primer nodo de operación de la red, la training phase y c ) un método de interpretación de la respuesta durante su segundo modo de operación, la
‘recal’ phase.
6
xiste una nueva arquitectura de circuitos llamada “Red Neuronal Celular”, que se considera como un modelo computacional con las principales características de E las redes neuronales, la cual tiene aplicaciones potenciales importantes en las
áreas de procesamiento de imágenes y reconocimiento de patrones. Dado que nuestro estudio esta enfocado al procesamiento de imágenes se hará énfasis en el modelo de redes neuronales celulares.
tiene estructura de “Feedback”. La estructura general de CNN se muestra en la figura 1. La red neuronal celular (CNN) consiste de una capa de entrada y una capa de salida, y
A
Estructura de la red neuronal celular
7
La estructura mostrada en la figural es idéntica a la red de Hopfield (Ver apéndice C). Sin embargo existe una gran diferencia entre estas dos redes. La red de Hopfield tiene conexión completa, por otro lado en CNN, las conexiones no son completas, sino locales.
Comparada con otras redes neuronales, CNN se puede implementar fácilmente en circuitos analógicos. Comparando con los métodos convencionales para el procesamiento de imágenes en CNN hay que iterar hasta que la red haya convergido para obtener una imagen procesada, sin embargo, la implementación analógica de CNN tiene características de velocidad para la convergencia.
8
L a unidad básica del circuito de una red neuronal celular es llamada célula. Una célula contiene elementos lineales y no lineales de circuito. Estos elementos típicamente son capacitores lineales, resistores lineales, fuentes controladas
lineales y no lineales y fuentes independientes. En una CNN cualquier célula es conectada solo a las células vecinas más cercanas. Las células adyacentes pueden interactuar directamente con cada una de las otras. Las células conectadas no directamente pueden afectar juntas indirectamente a las otras, debido a que se tienen efectos de propagación de la dinámica de tiempo continuo. Un ejemplo de una red neuronal celular de dos dimensiones se muestra en la figura 2. Teóricamente, podemos definir una CNN de cualquier dimensión, pero en nuestro caso nos concentraremos al tipo bidimensional, porque nuestra atención esta enfocada al procesamiento de imágenes.
y N columnas. Llamaremos célula(ij) a la célula ubicada en el i-ésimo renglón y en la j- ésima columna y la denotaremos por C(ij)como en la figura 2.
Considere una CNN de M x N al conjunto de MxN células ordenadas en M renglones
Una CNN de tipo bidi- al. El tamaño del circui-
to es de 4x4. Los cuadros son los circuitos unitarios llamados célu- las. Las conexiones entre las célu- las indican que hay interconexión entre las células conectadas.
Ahora definiremos lo que llamamos vecindad de C(ij). Definición: r- Vecindad.
La r-Vecindad de una célula C(ij) en una CNN esta definida por:
V,( i j )= { C(k,l)/max{ Ik-iI, ll-jl}<r, 1 I k l M ; 1 < l < N ) ............. (1)
9
donde “r” es un número entero positivo.
Es decir la vecindad V,(ij) de una célula C(ij) es el conjunto de todas las células tales
La figura 3 muestra tres vecindades de la misma célula. (La vecindad se muestra que k y 1 satisfagan las condiciones dadas.
sombreada y la célula en “negrita”) con r = 1, r =2 y r =3 respectivamente.
0 0 0 0 0 3 0 1 7
r = I
0 0 0 0 0 0 0 0 o ~ u n o o n o n o o 0 0 o O 0 O O 0 G o n o 0 0 0 0 0 0 0 0
r=2
o n n u n o c i o G o o o o O o
r =3
La vecindad de la célula C(ij) para r =1, r =2 y r =3 respectivamente.
Un ejemplo típico de una célula C(ij) de una CNN se muestra en la figura 4, donde los sufijos “u”, “x” y “y” denotan la entrada, el estado y la salida respectivamente. El nodo Vx,J de C(ij) es llamado el estado de la célula y se asume que tiene como condición inicial una magnitud menor o igual a 1. El nodo Vu,J es definido como la entrada de C(ij) y se asume que tiene como condición inicial una constante menor o igual a 1. El nodo V,, es definido como la salida. De la figura 4 podemos observar que cada célula C(ij) esta constituida por una fuente de voltaje independiente E,, una fuente de corriente independiente I, un capacitor lineal C, dos resistores lineales R, y Ry , y a lo mas 2m fuentes de corriente lineales controladas por voltaje (m = ## Vr(i,j)), las cuales están acopladas a sus células vecinas vía el voltaje de entrada Vu, y el voltaje de salida V,, de cada una de las células de la vecindad. La relación entre las células se observa en el siguiente hecho: I,,(i,j;k,I) y Ixu(ij;k,l) son fuentes de corriente controladas por voltaje con la siguiente característica:
Y
para todas las células C(k,l) tales que C(k,l) E V,(ij).
En otras palabras cada una de las fuentes de corriente I,,,(ij;k,l) y Ixu(ij;k,l) dependen del voltaje (ponderado por un factor A(ij;k,l) del nodo salida y entrada de la célula
10
correspondiente C(k,l), respectivamente. Por tanto en el nodo estado de cada célula C(ij) tenemos 2m fuentes (m = No de células vecinas ); en donde cada una de las primeras m fuentes dependen del voltaje del nodo de entrada de cada una de las m células vecinas C(k,l), junto con otras m fuentes que dependen cada una del voltaje del nodo de salida de cada una de las células vecinas C(k,l).
El único elemento no lineal de cada célula es una fuente de corriente controlada por voltaje Iyx=(l/Ry)f(Vx~j) ubicada en el nodo “salida”; donde F() es una función con un comportamiento mostrado en la figura 5.
Vxij . . . . . . . .
Eij
Y
Ejemplo del circuito de una célula. Donde: Ixy(iJ;k,l) = A(ij;k,l)Vykl Ixu(ij;k,l) = B(iJ;k,l)V,,kl 1, = ( 1 /2Ry)( I Vxij+ 1 I - I Vxi- 1 I )
f(v) = (1/2)[ I v+l I - I v-1 I ]
La característica de la fuente controlada no lineal.
11
Todas las fuentes controladas no lineales de nuestra red neuronal celular se pueden fácilmente implementar con amplificadores operacionales. Un ejemplo simple de una célula implementada con amplificadores operacionales se muestra en la figura 6 .
Vxij . Vyij
A) Circuito simplificado de una célula.
B) Implementación con amplificadores operacionales.
Implementación con amplificadores operacionales de un circuito simplificado de una célula de una CNN.
12
Si aplicamos la leyes de voltaje y corriente de Kirchhoff al circuito de la figura 4 obtenemos fácilmente las ecuaciones del circuito de la célula:
ECUACIÓN DE ESTADO
P a r a l l i l M 1 l j l N
E C U A C I ~ N DE SALIDA
P a r a l l i l M 1 5 j l N
ECUACIÓN DE ENTRADA
(2c) ...................................................................................... V u'l .. =E.. ,, P a r a l l i l M 1 l j l N
CONDICIONES DE LÍMITE
( 2 4 I Vxij(0) I s 1 l 5 i l M 1 l j l N ..................................................
I vuij I 5 1 1 l i l M 1 l j l N (2e) ..................................................
PARÁMETROS ASUMIDOS
A(i,j;k,l) = A(k,l;i,j) (20 1 I i , k I M ; 1 Ij , 1 I N .........................................................................
C >O , Rx > O (2g) .............................................................................................
13
PUNTUACIONES
I) Todas las células internas de una CNN tienen la misma estructura de circuito y los mismos valores de sus elementos. Las células mas internas son aquellas que tienen (2r+1)2-1 células vecinas, donde r esta definido en (1). Las otras células son llamadas “Células fronterizas”. Una CNN es caracterizada completamente por el conjunto de todas las ecuaciones diferenciales en (2) asociadas con las células del circuito.
11) Cada célula de una CNN tiene al menos tres nodos (algunas veces elegimos E, = O si B(i,j;k,l) = O para todas las células de la red. En este caso, hay solo dos nodos en un circuito célula).
111) La dinámica de una CNN tiene dos mecanismos, el de “Feedback de salida” y el de “Control de entrada”. El efecto del feedback de salida depende del parámetro interactivo A(ij;k,l) y el efecto de control de entrada depende de B(ij;k,l). En consecuencia algunas veces es instructivo denominar a A(ij;k,l) como el “Operador feedback’ y a B(ij;k,l) como el “Operador control”.
IV) Los valores de los elementos de un circuito pueden ser elegidos convenientemente en la práctica. R, y Ry determinan la potencia disipada en el circuito y generalmente son elegidos entre 1kR y 1MR. CR, es la constante de tiempo de la dinámica del circuito y es generalmente elegida entre 1 O-* y 1 O-5 segundos.
1- I
Matriz de feedback
Función no lineal
Matriz de control
Aquí A y B son “cloning templates”. A es el template de Feedback y B es el template de control.
Proceso inforrnático de una célula en una CNN.
14
as redes neuronales celulares (CNN) tienen aplicaciones potenciales importantes en las áreas de procesamiento de imágenes, “reconocimiento de patrones” y en L una gran cantidad de áreas de interés del manejo de imágenes.
En seguida se presentan algunas de las principales aplicaciones de las redes neuronales celulares (discutidas en el 2” taller internacional en aplicaciones de CNN desarrollado en la Universidad Técnica de Munich, Alemania).
RECONOCIMIENTO DE CARECTER JAPONÉS KANJI USANDO CNN
EL caracter japonés Kanji tiene su propio significado estructural. Estos están compuestos de cierto número de líneas cruzadas. Aproximadamente 3000 caracteres son incluidos en el primer grupo del estándar industrial japonés (JIS), el cual es usado diariamente . En total, son aproximadamente 6000 caracteres los recomendados por JIS para ser usados cotidianamente. Las estructuras de estos caracteres son muy similares y muy complicadas. Por esta razón el reconocimiento del caracter japonés Kanji posee una gran dificultad inherente.
Las redes neuronales aprovechan que el reconocimiento de patrones son clasificados en las siguientes categorías. Primero, los patrones de distorsión son aplicados directamente a las redes neuronales y de esta manera las características topológicas son obtenidas a través de la red. El patrón es reconocido por medio de la comparación de este con un patrón estándar. En el segundo método algunas características de distorsión son obtenidas por métodos convencionales, y estas características son aplicadas a redes neuronales de multicapas. El tercer método es una combinación de aprendizaje y propagación hacia atrás, el cual es situado a lo largo de la escala del reconocimiento de caracteres.
Ahora es propuesta una nueva aplicación que es el “reconocimiento del caracter japonés Kanji”. Esta consta de una red neuronal celular para la obtención de las características de los segmentos de línea que forman el caracter.
15
s IMULACI~N
La sig. Figura muestra un ejemplo de un patrón de caracter Kanji japonés en manuscrito distorsionado. Está expresado usando 24 x 24 puntos.
Ejemplo de Pahín disdorcioiudo
a) PaMn de enlrada. b) Pahínesqueietizado.
UN SISTEMA EXPERIMENTAL PARA LA DETECCI~N ÓPTICA DE ERRORES DE DISEÑO DE TARJETAS DE CIRCUITOS IMPRESOS USANDO TEMPLATES
APRENDIDOS MEDIANTE CNN
Las redes neuronales celulares son consideradas aquí como un arreglo de procesamiento multidimensional de células analógicas programables con lógica y memoria distribuida.
Los pesos de interconexión entre las células vecinas son definidos por valores de los templates, junto con los templates lineales, los no-lineales y los de retardo prueban ser suficientes para las aplicaciones.
Un cloning template define la transformación de una entrada y su estado inicial a una salida. Algunos templates han sido encontrados por el método de “prueba y error”, pero recientemente se han reportado templates obtenidos por medio de algoritmos con sistema de aprendizaje, es decir se obtienen aprendidos mediante un algoritmo.
Los templetes encontrados por estos métodos son robustos, es decir, son menos sensibles a los cambios de los valores de sus elementos.
En la industria de los circuitos integrados existen reglas para el chequeo del diseño de las tarjetas, por medio de estas reglas se verifica la manufactura y se determina si cumple con los requisitos. La detección de errores de diseño requiere en su mayor parte de información geométrica local de ahi que la tarea es precisa para solucionarse por medio de CNN.
16
APLICACIÓN DE AUTÓMATAS CELULARES A EL PROCESO DE ADELGAZAMIENTO DE IMÁGENES CON CNN.
Las redes neuronales celulares permiten procesar señales en tiempo real por medio del uso de solo interconexiones de células vecinas. Se ha descubierto una nueva regla denominada B132 la cual puede ser explotada en el diseño de CNN en el proceso de adelgazamiento de una imagen.
La regla B132 antes mencionada consiste en la utilización de autómatas celulares unidimencionales utilizados en el proceso de adelgazamiento de imágenes.
El adelgazamiento de imágenes tiene gran importancia en el campo de reconocimiento de caracteres en el cual, antes de descodificar o reconocer el caracter es necesario reducir la imagen original a líneas simples. El adelgazamiento es más dificil de lo que parece, básicamente son dos tareas a desarrollar: Eliminar los pixeles que hacen ver la imagen gorda o ancha y parar el proceso de adelgazamiento cuando el tamaño de la imagen es de uno a dos pixeles de gruesa. El algoritmo de la regla B132 puede implementar estas dos tareas al mismo tiempo.
El proceso de adelgazamiento se transforma de un problema de 2-D a problemas de 1 -D, en particular los problemas “horizontal X” y “vertical Y” .
La regla B132 utiliza funciones booleanas para la realización del proceso, a saber AND, OR y NOT y dado que estas funciones pueden ser fácilmente implementadas en CNN con ciertos templates, entonces es posible crear un proceso de adelgazamiento utilizando CNN.
En seguida se presenta un ejemplo de la aplicación de la regla B132 a una imagen en sus diferentes etapas y también en un caracter.
Ejemplos:
A) Original B) Salida usando el autómata celular para la parte vertical
17
C) Salida usando el autómata para la parte horizontal.
R l i i i i i i i i i i i i i i i i i i i i l D) Combinación de resultados.
R Resultado de la simulación del proceso de adelgazamiento
mediante CNN de un caracter ingles
SISTEMA DE TRACCI~N ÓPTICA PARA VEHÍCULOS GUIADOS AUTOMÁTICAMENTE USANDO REDES NEURONALES CELULARES
Los sistemas de manufactura computarizada (CIM) tienen el rol importante en la industria moderna. Estos sistemas contienen esencialmente dos maneras diferentes para transportar materiales entre estaciones de trabajo:
- Los transportadores solo pueden ser usados, si la ruta de transporte es fija y se conoce en tanto se avanza, o ,
- Si la ruta de transporte puede cambiar o hay varias tareas que realizar a lo largo de la ruta, entonces el uso del sistema para vehículos guiados automáticamente (AGU) es altamente recomendado.
18
El control de la ruta del sistema de vehículos guiados automáticamente en sistemas CIM es generalmente resuelta por el seguimiento de un alambre o hilo inductivo o por la determinación de la posición y orientación del vehículo mediante señales proporcionadas por transmisores montados en algunos puntos estratégicos de la ruta. Pero estos métodos tienen sus ventajas y desventajas.
Con el surgimiento de las redes neuronales celulares un nuevo método es propuesto para el “control de la ruta a seguir”, el cual combina la flexibilidad y la facilidad de instalación de métodos ópticos con la simplicidad y la robustez del método inductivo.
Con la utilización del nuevo paradigma de la computación, la CNN y un dispositivo relacionado (un chip de gran escala de integración para una CNN), una solución rápida puede ser obtenida a un costo menor que el de los métodos convencionales y sin perder sus ventajas. Este control de vehículos guiados automáticamente cumple con los requerimientos de los sistemas CIM, además existen otras ventajas del sistema propuesto y son las siguientes: Tolerancia de error, habilidad de dar instrucciones a lo largo de la ruta y el uso de un control local simple.
19
n el procesamiento de imágenes los programadores necesitan un método simple para obtener una imagen en un formato estándar. E Aldus, Microsoft y muchas otras compañías de computadoras y scanners decidieron
escribir un estándar para la comunicación de imágenes digitalizadas. Su colaboración conjunta produjo el formato TIFF ó Tag Image File Format. (Formato de archivos de imágenes por medio de rótulos o etiquetas).
La palabra Tag en “Tag Image File Format” se refiere a la estructura básica del archivo. Un Tag Ó rótulo (de un TIFF) provee información acerca de la imagen, tal como sus dimensiones (largo y ancho) y el número de pixeles de la que esta compuesta. Existe un Tag para cada valor que proporciona información de la imagen.
Los Tags Ó rótulos están organizados en directorios Ó IFD’s (Image File Directory). Cada directorio contiene el número de entradas que lo conforman, las entradas mismas y un apuntador al siguiente IFD Ó directorio.
Cada entrada contiene un Tag y los valores correspondientes al Tag. Este Tag indica el tipo de información que se esta guardando en la entrada correspondiente.
En resumen, cada IFD Ó directorio contiene un número determinado (por el mismo IFD) de entradas y cada entrada. contiene un tipo de información indicada por un Tag que corresponde a la imagen.
La siguiente lista indica los diferentes Tags y su correspondiente en hexadecimal que existen en el formato TIFF.
SubfileType : Tag = 255 (FF) Tipo Short Indica el tipo de dato en el subarchivo.
Image W idth: Tag = 256 (100) Tipo Short Indica el ancho de la imagen en pixeles.
IinageLength: Tag = 257 (101) Tipo Short Indica la longitud de la imagen en pixeles
RowPerS trip : Tag = 278 (1 16) Tipo Long Indica el número de renglones por tira. El default es la imagen entera en una tira.
Stripoffsets: Tag = 273 (1 1 1) Indica los bytes de defasamiento para cada tira.
Tipo Short ó Long
SamplesPerPixel: Tag = 277 (1 15) Tipo Short Indica el número de muestras por pixel.( 1 para imagenes monocromáticas y 3 para color)
StripByteCounts: Tag = 279 (1 17) Tipo Long Indica el número de bytes en cada tira.
BitsPerSample: Tag = 258 (102) Tipo Short
20
Indica el número de bits por pixel. 2** # de bits por pixel = # de niveles de gris. Una imagen TIFF consiste de un arreglo bidimencional de números. El color o nivel de
gris desplegado para un pixel esta relacionado con el número almacenado correspondiente a este pixel.
Podemos clasificar por complejidad las imágenes con formato TIFF en tres categorías. Listando de menor a mayor complejidad tenemos:
- Imágenes en blanco y negro.- Imagen binaria. Cada pixel es cero ó uno.
- Imágenes en escala de grises.- Cada pixel toma un valor entre cero y el número de escalas o niveles de grises. Estas imágenes tienen la apariencia de fotografías en
y negro. blanco
- Imágenes a color.- Estas imágenes son similares a las de escalas de grises excepto que hay tres bandas o canales correspondientes a la contribución de cada uno de los tres colores primarios (rojo, verde y azul). Por esta razón cada pixel tiene tres valores asociados.
La siguiente figura muestra la estructura del Formato TIFF
ENCABEZADO (primeros 8 bytes)
byte No. Contenido de la localidad. O I Orden de los bytes
2 Versión
Desplazamiento para el O-ésimo IFD 6 (Dirección del O-ésimo IFD) 7
ENTRADA DEL DIRECTOIUO byte No
x+ 1
Contenido de la localidad
'+* I 1 Tipo x+3
Valor
x+s u Dirección del valor
21
ó el valor mismo.
ESTRUCTURA DEL IFD (Image File Directory) Byte No.
A
A+2
A+14
A+26
A+2+B* 12
B
C
Contenido de la localidad B.- Número de entradas que
contiene el IFD. Entrada O del directorio.
Entrada 1 del directorio.
Entrada 2 del directorio.
C.- Dirección del siguiente IFD.
FORMATO TIFF
Los primeros ocho bytes del archivo son el encabezado. Estos ocho bytes tienen el mismo formato en todos los archivos TIFF. Los bytes restantes difieren de imagen a imagen.
El IFD contiene el número de entradas de directorio y las entradas mismas. En la figura 1 se muestra la estructura del IFD.
Cada entrada contiene un Tag que indica que tipo de información proporciona la entrada, el tipo de dato de la información, el tamaño de la información y un apuntador a la información ó la información misma.
La figura 2 muestra la parte inicial de un archivo TIFF. Las direcciones son localizadas del lado izquierdo en formato decimal, los números de bytes y sus valores se encuentran en hexadecimal.
Haciendo referencia a la figura 2, los bytes cero y uno nos dicen el orden de los bytes, es decir, si los números están almacenados en el archivo con el byte mas significativo (MSB) primero ó con el menos significativo (LSB) primero. Si el byte cero y uno son I1 (Ox4949), entonces el byte menos significativo es primero (esta manera de ordenar bytes es muy común en PC). Si el valor es MM ( O X ~ D ~ D ) , entonces el byte mas significativo es primero. (es muy común en el mundo Macintosh). Es muy importante saber el orden de los bytes para poder leer correctamente la información de la imagen. En el ejemplo de la figura se observa al LSB primero. Los bytes dos y tres proporcionan la versión la cual debe ser 42 (Ox2A) en todas las imágenes TIFF . Los bytes del cuatro al siete proporcionan el corrimiento Ó dirección (offset) del primer IFD. Note que todas las direcciones en TIFF son corrimientos con respecto al inicio del archivo. El primer byte en el archivo tiene
22
corrimiento cero. En el ejemplo el corrimiento de primer IFD es 8, por tanto el IFD empieza en el byte nueve del archivo.
CONTENIDO DE UN ARCHIVO TIFF
Dirección (decimal)
Encabezado O 2 4
8
10 12 14 18
22 24 26 30
34 36 38 42
IFD
O" entrada de directorio
1" entrada de directorio
2" entrada de directorio
Contenido (hex)
49 49 2A O0 08 O0 O0 O0
1B O0
FF O0 03 O0 o1 000000 o1 O0 O0 O0
O0 o1 03 O0 o1 000000 58 020000
o1 o1 03 O0 o1 000000 5A 02 O0 O0
Dirección del siguiente IFD 334 O0 O0 O0 O0
Dirección = O, indica que no hay mas IFDs
Tag = 255 Tipo = 3 (short) Tamaño = 1 Valor = 1
Tag = 256 Tipo = 3 (short) Tamaño = 1 Valor = 600
Tag = 257 Tipo = 3 (short) Tamaño = 1 Valor = 602
23
EL IFD El contenido de la dirección 8 (en el ejemplo) es 27 (OxlB) indicando que este archivo
tiene 27 entradas de directorio. Los primeros dos bytes de la entrada contienen el Tag. El cual nos dice el tipo de información que contiene la entrada. En el ejemplo, la entrada de directorio en la localidad cero contiene Tag = 255. Este Tag nos dice el tipo de archivo. Los siguientes dos bytes de la entrada proporcionan el tipo de dato de la información. La siguiente lista los posibles tipos de datos y sus tamaños.
TIPO 1.- Byte 2.- ASCII
3.- ShoiT 4.- Long 5.- Rational
TAMAÑO 8 bits unsigned integer 8 bits bytes que guardan el código ASCII (el último byte debe ser nulo) 16 bits (2 bytes) unsigned integer 32 bits (4 bytes) unsigned integer 2 Longs : El primero es el numerador y el segundo es el denominador.
La entrada cero del ejemplo es con tipo = 3 un short (2 bytes unsigned integer). Los siguientes cuatro bytes de la entrada dan el tamaño de la información. Este tamaño no es en bytes, sino en múltiplos del tipo de dato. Por ejemplo, si el tipo de dato es un short y el tamaño es 1, entonces el tamaño es un short Ó dos bytes. los Últimos cuatro bytes de la entrada nos proporcionan el valor de la información Ó un apuntador a la información en el caso de que la información este compuesta por mas de cuatro bytes. La información es de dos bytes para la entrada cero del ejemplo y tiene un valor de 1 (Este valor no tiene significado para el Tag especificado para la entrada).
Para la siguiente entrada el Tag es 256 , este es el ancho de la imagen en número de columnas. El tipo es short y el tamaño de la información es un short o dos bytes. El valor es 600, esto significa que hay 600 columnas en la imagen. La siguiente entrada tiene Tag=2 5 7. Este es la longitud de la imagen Ó la altura en número de renglones. El tipo es short , el tamaño es uno y el valor es 602, esto significa que la imagen tiene 602 renglones. Se puede continuar por la demás entradas hasta encontrar el apuntador al siguiente IFD. Si este apuntador Ó corrimiento es cero, como el del ejemplo, entonces no hay mas IFDs en el archivo.
24
UN EJEMPLO DE UNA CNN SENCILLA
P resentaremos un ejemplo sencillo que ilustra la manera en que opera una CNN con características de estructura descritas en el capítulo anterior. El tamaño de la red neuronal celular es de 4x4. Los parámetros que determinan los
elementos del circuito de la célula C(ij) se eligieron de la siguiente manera: Para cualquier C(k,l) E V,(ij) con r = 1, es decir, para cualquier sistema vecindario de
3x3:
A(i,j;i-l,j-l) = O A(i,j;i-l,j) = a-' A(i,j;i-l,j+l) = O A(i,j;i,j-l) = a-' A(i,j;i,j) = 2.0 x a-' A(ij;ij+l) = loT3 O-' A(i,j;i+l,j-l) = O A(i,j;i+l,j) = O-' A(i,j;i+l,j+l) = O
c = ~ o - ~ F , R ~ = 1 0 3 a , I = O
B(ij;k,l) = O para toda C(k,l) E V,(i j)
Dado que B(i,j;k,l) = O, solo los 3x3 coeficientes A(i,j;k,l) determinan el comportamiento transitorio de la red neuronal celular. Con frecuencia se especifican estos coeficientes en forma de un arreglo cuadrado como se muestra en la figura siguiente:
1:; 1 [O.O -0.25 0.0 1 -0.25 2.0 -0.25
0.0 1.0 1.0 0.0 -0.25 0.0
Template de un operador interactivo de célula. La unidad utilizada es 10" a-'.
25
A este arreglo que organiza la información de los operadores de “feedback” y de “control” se le denomina “cloning template”, el cual especifica las reglas dinámicas de la red neuronal celular.
Las ecuaciones dinámicas de la red neuronal celular correspondientes a los parámetros arriba especificados están dadas por:
Y
Vyij(t) = O S ( I Vxij(t) + 1 I - I V,ij(t) - 1 I ) , Para 1 I i I 4 ; 1 I j I 4
Es conveniente reescribir el lado derecho de la primera ecuación en “forma compacta”.
con la ayuda del operador convolución bidimencional “*” cuya definición es la siguiente:
Para cualquier cloning template T, el cual define la regla dinámica del circuito de la célula, definimos el operador convolución “*” por :
T * V.. ‘J T(k-i,l-j)Vkl C(k,l) E Vr(ij)
donde T(m,n) denota la entrada en el m-ésimo renglón y en la n-ésima columna del cloning template, m = - 1, O, 1 y n = - 1 ,O, 1, respectivamente.
Es importante notar que en la definición de arriba se hace la supoción de que A(i,j;k,l) es independiente de i y j para esta red neuronal celular. A esta propiedad se le llama invarianza ea el espacio la cual implica que A(iJ;k,l) puede ser expresado como A(k-i,l-j). En la mayoría de los casos se asume que las redes neuronales celulares poseen la propiedad de invarianza en el espacio esta propiedad nos permite especificar las reglas dinámicas de la red celular neuronal por medio de cloning templates.
Las diferentes aplicaciones de las redes neuronales celulares se pueden implementar por medio de las reglas dinámicas que describen a la red, de esta manera, con la misma
26
estructura de CNN se pueden tener diferentes aplicaciones con la utilización de diferentes cloning templates. A continuación se presentan algunos cloning templates utilizados en diferentes aplicaciones.
B =
CLONING TEMPLATE PARA ENBARNECIMIENTO O ENSANCHAMIENTO DE CARACTERES
1 1 1 1 - 1 1 1 1 1
TEMPLATE NO-LINEAL I. Utilizado para remarcar el contorno de los caracteres. Se puede expresar utilizando la notación usual de CNN como sigue:
A =
donde
I d 1 1
I d 1 1=9
d = %(Y(k,l))2 - (Y(k,l) Y(ij)).
Debido a esta regla el contorno de un caracter u objeto es incrementado por una célula en todas direcciones. Esto no requiere una inicialización especial y condiciones de frontera, es suficiente tomar la imagen misma como una condición inicial. El modo de operación toma algunas iteraciones en la simulación.
Demostración del template de ensanchamiento. Imagen de entrada y de salida
21
TEMPLATE NO-LINEAL II. Utilizado para dibujar el contorno de un objeto.
B = 4 4 4 1
4 4 4 1 4-30 4 I = - 5
donde dl = (Y(k,l))2 - %(Y(k,l) Y(ij))
d2 = -%(Y(i,j) Y(k,l)) Esta regla permite dibujar el contorno de un caracter u objeto dado. Este modo de
operación toma pocas iteraciones múltiples contornos de figuras.
Es posible utilizar esta regla varias veces para obtener
Demostración del template para dibujar contornos. Imágenes de entrada y salida.
TEMPLATE TIPO RETARDO. Utilizado para mejorar las imágenes captadas por un escanner de los caracteres escritos a mano.
1 0.0 0.25 0.0 A = 1 0.25 0.0 0.25 I 0.0 0.25 0.0
B = O I = O
El template mejora la calidad de los caracteres mediante la eliminación de ruido y el emparejamiento de los bordes como se observa en la figura siguiente.
28
Demostración del template que mejora la calidad de los caracteres capturados por un scanner.
La imagen misma es usada como condición inicial y todos los estados de las células
Este template opera en tres pasos. limítrofes son igual a -1.
- Paso 1. Seis iteraciones dela regla determinada por A, B e I;
- Paso 2. Tres iteraciones definidas por los operadores
A’ = A + At’ B7 = 0 1’ = I + It’
- Paso 3. Una secuencia de iteraciones obtenidas de la siguiente manera:
A77 = A, + At2 BY? = 0 1 3 9 = 1 7 + It2
Este cloning template puede ser modificado cambiando los retardos ti , t2 y los valores actuales. Incrementando los retardos tl y t2 amplía el embarnecimiento, como se observa en la siguiente figura.
efecto del engrosamiento o
t3 c d
Demostración del mejoramiento de la calidad de los caracteres escritos a mano. (a) Imagen de entrada. (b) Imagen de salida con tl = 6, t2 = 9. ( c ) Imagen de salida con ti = 8, t2 = 13. (d) Imagen de salida con ti =11,tZ=32.
29
El sistema que se desea desarrollar consiste de cinco etapas que se especifican a continuación:
I.- DESPLEGAR IMAGEN ORIGINAL EN LA PANTALLA
La primera etapa consiste en el manejo de la imagen original no procesada. Las imágenes
Se trabaja con el formato TIF por la razón de que este formato es muy conocido. La imagen con formato TIF consiste de datos de encabezamiento y datos de la imagen, o
que se manejan tienen que ser formato TIFF (TE).
sea un conjunto de valores que determinan la imagen.
Encabezamiento
El tamaAo de la parte del encabezamiento varía de acuerdo ai tamaño de la imagen
Imagen
30
11.- OBTENER EL CLONING TEMPLATE
Esta segunda etapa consiste en la obtención del cloning template, el cual normalmente es una matriz de 3x3. Los valores de cloning template son fijos para cada aplicación. Como se describe en “2.1.3.Templates” estos valores son obtenidos por diferentes experimentos.
En seguida se muestra una tabla con “cloning templates?’ para aplicaciones específicas conocidas.
O 0 0 O 0 0 O 0 0
O 0 0 0 4 0 O 0 0
-0.25 -0.25 -0.25 -0.25 2 -0.25 -3 -0.25 -0.25 -0.25
1 1 1 1-8 1 -2 1 1 1
O 0 0 O 0 0 O 0 0
31
111.- SELECCIONAR EL MÉTODO DE INTEGRACIÓN
En el procesamiento de imágenes por medio de CNN, se presentan problemas que pueden ser solucionados por medio de ecuaciones diferenciales. Dentro del sistema se implementan tres métodos de integración diferentes. Esta etapa consiste en seleccionar un método.
Q Explicit Euler
Q Predictor - Corrector
Q Runge - Kutta 4 O Orden
(Runge - Kutta 2’ Orden)
1V.- CÁLCULO DE CNN
Se aplican las ecuaciones de estado (2a) y de salida (2b) de “1.3 Arquitectura de una CNN” a todas la células (pixel) de la imagen, hasta que una gran cantidad de células ya hayan convergido.
1 .- Condición de convergencia para una célula no colocada en el borde de la imagen.
a) Valor absoluto de derivación de la célula <= Global-CNN.Tolerance b) Valor absoluto de la célula y de las células vecinas >=1 .O
2.- Condición de convergencia para una célula colocada en el borde.
a) Valor absoluto de derivación de la célula <= Global - CNN.Tolerance b) Valor absoluto de la célula >= 1.0
3.- Condición de convergencia del sistema CNN
a) Número de células convergidas >= 95 % ó
b) Número de iteraciones > 20
V.- DESPLEGAR IMAGEN PROCESADA EN LA PANTALLA
En esta etapa se muestra la imagen después de ser procesada por el sistema CNN
32
APÉNDICE A. Red de Hopfield
La red de Hopfield es normalmente utilizada con entradas binarias. Esta red es más apropiada cuando las representaciones binarias son exactas como imágenes en blanco y negro donde los elementos de entrada son valores de pixeles, o texto ASCII donde los valores de entrada pueden representar bits en la representación ASCII de 8 bits para cada caracter. La red de Hopfield es menos apropiada cuando los valores de entrada son continuos dado que se presenta el problema fundamental de representación que consiste en convertir las cantidades analógicas a valores binarios.
Hopfield vuelve a encender el interés en las redes neuronales por su trabajo extensivo en las diferentes versiones de la red de Hopfield. Esta red puede ser usada como una memoria asociativa o para resolver problemas de optimización. Existen algunas versiones de la red de Hopfield que pueden ser implementadas como memorias direccionables. Este tipo de redes tiene grandes limitaciones de linearidad y utilizan entradas binarias y sus salidas toman valores de +I y -1. La salida de cada nodo es retroalimentada hacia todos los otros nodos mediante la denotación de pesos ti. La operación de este tipo de redes se describe en el siguiente algoritmo:
ALGORITMO DE LA RED DE HOPFIELD
Asignación de los pesos de conexión
M- 1
c Xi s . $ Xj
s=o
Para i # j
O Para i = j O 5 (ij) I N - 1
En esta fórmula tij es el peso de conexión del nodo i al nodo j y xi2 el cual puede ser + 1 o - 1 es el elemento i del ejemplar para la clase S.
33
Inicializar con el patrón de entrada desconocido.
p,(O) = XI 7 O l i l N - 1
En esta fórmula p,(t) es la salida del nodo i al tiempo t y Xi el cual puede ser +1 o -1 es el elemento i del patrón de entrada.
Iterar hasta converger.
N - l
] = O
La función fi, es la gran limitante de no-linearidad. La relación expuesta es una relación de recurrencia que dada la inicialización y los pesos es posible obtener las subsecuentes salidas. El proceso anterior es repetido hasta que los nodos de salida permanezcan sin cambio con las iteraciones subsecuentes. Después de esto, los nodos de salida representan el patrón ejemplar que mejor igualan a la entrada desconocida.
Repetir desde el paso 2.
Primero, se establecen los pesos utilizando la fórmula dada y con los patrones ejemplares de todas las clases. Entonces el patrón desconocido es impuesto en la red al tiempo igual a cero (inicialización) forzando la salida de la red a que coincida con el patrón desconocido. Después de la inicialización, la red itera en pasos discretos de tiempo utilizando la fórmula dada. Se considera que la red ha convergido cuando las salidas no sufren grandes cambios en las iteraciones sucesivas. El patrón que esta especificado por los nodos de salida después de la convergencia es la salida de la red.
Hopfield ha probado que esta red cuando los pesos son simétricos (tij = tji) y cuando los nodos de salida son actualizados asincronamente utilizando la ecuación del algoritmo dado.
Cuando la red de Hopfield es utilizada como una memoria asociativa, la salida de la red después de converger es utilizada directamente como memoria restablecida completamente. Cuando la red de Hopfield es utilizada como un clasificador, la salida después de la convergencia debe ser comparada con los M ejemplares o patrones para determinar si este coincide exactamente con algún ejemplar. Si eso pasa la salida es de la clase cuyo ejemplar coincide con el patrón de salida. Y si no pasa esto entonces ocurre un resultado de no- convergencia.
34
El comportamiento de la red de Hopfield es ilustrado en la siguiente figura:
(A) Ocho patrones ejemplares.
(B) Patrones de salida para la entrada “3” con ruido aleatorio
Una red de Hopfield con 120 nodos (14,400 pesos) fue entrenada para reconocer los ocho patrones ejemplares mostrados en la parte superior de la figura anterior. Estos patrones de “dígitos” en blanco y negro contienen 120 pixeles cada uno. Los elementos introducidos en la red toman los valores +1 para pixeles en negro y -1 para pixeles en blanco. En el ejemplo anterior el patrón para el dígito “3” fue corrompido o distorsionado aleatoriamente cada bit independientemente cambiando de +1 a -1 y viceversa con una probabilidad de 0.25. Este patrón fue entonces aplicado a la red en el tiempo igual a cero.
35
Los patrones producidos en la salida de la red en las iteraciones de la cero a la siete son presentados en la figura anterior. El patrón de entrada distorsionado es presentado sin modificaciones en la iteración cero. Conforme la red itera la salida llega a ser más y más parecida al patrón ejemplar correcto hasta la iteración seis en la que la red ha convergido al patrón para el dígito “3”.
La red de Hopfield tiene dos grandes limitaciones cuando es utilizada como un contenido de memoria direccionable. Primero, el número de patrones que pueden ser almacenados ó identificados con precisión es muy limitado. Si son almacenados demasiados patrones, la red puede converger a un nuevo patrón diferente de todos los patrones ejemplares. Este nuevo patrón producirá una salida de “no-coincidencia” cuando la red es utilizada como un clasificador.
Hopfield mostró que esto no ocurre frecuentemente cuando los patrones ejemplares son generados aleatoriamente y el número de clase (M) es menor que 0.15 N. Por ejemplo, una red de Hopfield para solo 10 clases requiere mas de 70 nodos (M < 0.15N) y mas de 5000 pesos de conexión. Una segunda limitación de la red de Hopfield, es que un patrón ejemplar será inestable si comparte muchos bits en común con otro patrón ejemplar. Aquí un patrón es considerado inestable si al aplicarlo a la red en el tiempo cero la red converge a algún otro patrón ejemplar. Este problema puede ser eliminado utilizando un número de procedimientos de ortogonaiización.
36
APÉNDICE B CÓDIGO FUENTE
Archivo: CNN.cpp
kiiiclude "cnn li"
extern
void write-data(),
void
ciiii-t Global-ciiii,
image-info image,
void cnnP2D(char *nombre, char *nombrel, HDC hdc),
IiiitCNN(doub1e delta,double tol,double Porc,int Max,int Int-meto,int Inp)
/** General global variables **/ l i l t M, N, char simulation, integration; char iiiit-coiid; double slope = I .O ;
/** Global variables for Single-layer & Time-multiplexing CNN **/ double **iiipu-CNN, **CNN; l i l t **CNN-flag; double u[ I O], X[ I O], derivative, double a[iO], b[10]; double I ;
í*** Subroutine to write the preliminary info into data file ... ***/ void write-data() { }
/* Initializing the default CNN simulation at start-up */ void IiiitCNN(doub1e delta,double tol,double Porc,int Max,int Int-meto,int Inp) {
iiit i, j; Global-cnn simulation = SINGLE; Global-ciin layernurn = 3 ; Global_cnn.iiitegration = Int-meto; Global_ciin.init_cond = hip;
Global-ciin delta-t = delta; Global_ciiii tolerance = tol; Global-cimpercent-converge = Porc; Global_ciin.iiiax-iteration = Max;
Global_ciiii.timux-block_size = 1 O; Global_ciiii.timiix-overlap = 2 ;
Global_ciiii.disp_original = NO; Global-ciiii disp-layer = NO;
/* For time-multiplexing only */
1 void DispIinage() {
image width = 32; iiiiage.lieight = 32;
void cnn(double delta,double tol,double Porc,int Max,int Int-meto,
{ iiit Inp,char *nombre1 ,char *nombre2, HDC hdc)
iiit a m ,
37
IiiitCNN( delta,tol,Porc,Maw,Int-meto,Inp); DispIinage(), cnnP2D(nombre 1,nombre2,hdc);
Archivo: 2d.cpp
#include "cnn h" 4iiiclude <string h> #include <stdlib Ii>
/* fuiictions */ extern iii t readPC"(), exteni double **create-array(); exteni void free-array(doub1e **CNN, int M), exteni ii i t get-templates(). extern nit read-iinage(char *nombre); extern iiit write-image(char *nom-arch); extern iiit get-u(int i,int j); extern iiit get-x(int i,int j); extern double euler(); extern double pc(); exteni double rk4(); extern double stable(), derivo;
exteni double derivative;
exteni iiit M, N; extern double a[ 1 O], b[ 1 O], I ; exteni double **input-CNN, **CNN; extern double u[ 1 O], X[ I O]; exteni iiit * *CNN-flag; extern cnii-t Global-cnn; extern image-info image;
void ciiii_7D(char *nombrel, char *iioinbre2, HDC hdc)
double next-x, i i i t I , J. iteration=O, iii t ok-cell=O, goal-cell, total-cell; double start-time, end-time, time; double y, double cniax,cmin; iiit ind-inaw~x,ind-inaw_y,ind~min-x,ind_min~,dec,sign; char cadeiia[25]; M=iinage. height; N=iniage width;
read-image(nombre I ); read_CNN(); get-templates();
total-cell = M*N, SetTextColor(hdc, RGB( O, 0,O )); SetBkColor(hdc, RGB( 192,192,192));
Itoa(tota1-cell, cadena, 1 O), TextOut(lidc, 1 O, 120,"Total number of cells to be processed = ",39); TextOut(hdc. 280, 120, cadena, strlen(cadena));
clock(); start-time = OL; TextOiit(lidc, 1 O, 140, "Starting simulation at time ", 28), TextOut(lidc, 196, 140, fcvt(start-time, 5, &dec, &sign),strlen(fcvt(staa-time, 5, &dec, &sign)));
goalpcell = (iiit)(total-cell * Global-cnn.percent-converge/l 00.0);
38
while (ok-cell < goal-cell && iteration < Global-cnn.max-iteration) í
for (¡=I. i<=M; ¡++I*, fprintf(fp,"\n")*/)( for í j = i , j<=N; J++)
{ if (CNN_flag[i]fi]) continue;
get-xíi, j); get-Ni, 1).
switch (Global-cnn.integration) {
case EULER: next-x = euler(); break.
case PRED-CORR: next-x = pc(); break:
case RK4: next-x = rk4(); break;
I
/* convergence criteria for cells other than border cells */ if ((¡!=I) && (j!=i) && (i!=M) && (j!=N)) { if ( (fabs((doub1e)derivative) <= Global-cnn.tolerance) &&
(fabs((doub1e)next-x) >= 1 .O && (fabs((double)X[ l])>=i .O) && (fabs((doubie)X[2])>=l.O) && (fabs((doubie)X[3])>=1 .O) && (fabs((doubie)X[4])>=1 .O) && (fabs((double)X[6])>=1 .O) && (fabs((doubie)X[7])>=1 .O) && (fabs((doubie)X[S])>=l .O) && (fabs((double)X[9])>=1 .O))) (
CNN-flag[i]Lj]=l; ok-cell++; 1
I I* convergence criteria for border cells *I else
if ( (fabs((doub1e)derivative) <= Global-cnn.tolerance) &&
{
I
(fabs((doub1e)next-x) >= 1 .O) )
CNN-flag[i]Lj]=l; ok-cell++;
CNN[i]b]=next-x;
} l * j *l
} I* i *I iteration++:
TextOut(lidc, 1 O, 160, "Iteration ", 9); Itoa(iteration, cadena,l O); TextOut(hdc, 73, 160, cadena, strlen(cadena) ); TextOut(hdc, 1 I O , 160, "Number of converged cells ", 26); Itoa(ok-cell, cadena, 1 O); TextOut(hdc, 292, 160, cadena, strlen(cadena) );
1 I* while *I
TextOut(hdc, 1 O, 180, "Total Number of iterations: ", 27 );
39
itoa(iteration, cadena, 1 O), TextOut(hdc, 200, 180, cadena, strlen(cadeiia) ),
end-time = clock(). time = (eiid~tiine-starttiine)/CLOCKS_PER-SEC,
TextOut(hdc, 10, 200,"The simulation took ", 19 ), Itoa(iteration, cadena, lo), TextOut(hdc, 150, 200, fcvt(time,5, &dec, &sign), strlen(fcvt(time.5, &dec, &sign))), TextOut(hdc, 200, 200, "seconds to execute",l8),
write-image( nombre2), tree-array(input-CNN, M+2), fiee-array(CNN, M+2), free( CNN-flag),
40
Archivo: 2d-io.cpp
#iiiclude "cnn Ii"
?#include<conio h> #iiicliide<string h> #define Format-Size 266 #define Nun-X I6 #define Nun-Y 32 ddefiiie NuiiiEleni Num_X*Num_Y*2 #define MaxPix I5 #define POS-MAX RAND-MAX
/* Imagen es 32 X 32 */
i i i t read-image(), ii i t write-iiiiage(char *nombre-ach); i i i t read-CNN(); double **create-array(int M, int N); void freeparray(), l i l t get_teiiiplates(); iiit get_ii(). lilt get-x();
extern image-info image; exteni int M, N; extern double a[lO], b[lO], 1; extern double u[101, X[101; extern double **inputCNN, **CNN; extern ¡lit **CNN-flag; extern ciiii-t Global-cnn;
i int i j ; double iiiax,iniii; iiiax=miii=pix-inat[O] [O];
for(i= I ; i<M; ¡++) foríj=O, j<N; j++)( if(max < (doub1e)pix-mat[¡] fi]) max=(double)pix-mat[i]b]; if(min > (doubie)pix-mat[i]b]) min=(doubie)pix-mat[iJ~];
) for(i=O; i<M; i++) forCj=O; j<N; j++) image.dat[i]fiJ=((double)pixmat[i]fi]*2.0 -(max-min))/(max-min);
41
for(i=l, i<M, I++)
fOr(J=l, j", J++){ if(inax < CNN[i]b]) max=CNN[i]b], if(min > CNN[i]b]) min=CNN[i]b],
tliret=( iiiax+iiiiii)12.0,
for(i=O; i<M; i++) for(j=O; j<N, j++)
if(CNN[i+ I ] ti+ I ] > thret) pix-mat[i]fi]=OxOf; else pix-mat [i] U]=O;
iiit read-image(char *nombre){ FILE *arch; int x,y,ij; unsigned char pix-mat[Num-Y][Num-X*2]; /* datos originales (sin format TIF) */ unsigned char dat;
I****** abrir el archivo de imagen original *******I strcpy(nom-arc,nombre);
if ((arch = fopen(noin_arc,"rb"))==NULL) exit(1);
I** Ignorar datos de format TIF **I
for(i=O; i<Format-Size; i++) getc(arcl1);
/** leer datos de imagen a un matriz pix-mat **/ fo r (y0 ; y<Num-Y; y++) /* Num-Y = 32(pixels) */
for(x=O, x<Num-X; x++) /* N u m X = 1 ó(byte) o 32 pixel */ {
dat=getc(arch); pix-mat[y][x*2]=(dat&Oxfü)»4, pix-mat[y][x*2+ 1 ]=dat&OxOf;
1
norm(pix-mat); fclose(arch);
I* for(i=2; i<3; I++) forCj=O, j<N; j++)
priiitf(" %OX %if in",pix-mat[i]~],image.dat[i]Lj]); *I return O; }
f* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
int write-iiiiage(char *nombre-arch) {
FILE *arch I ,*arch2;
iilt x,y,ij; unsigned char pix-inat[Num-Y]~um_X*2]; /* datos procesados (sin format TIF) *I unsigned char dat;
I****** abrir el archivo de imagen original *******/
if ((arch 1 = fopen(nom-arc,"rb"))=NULL) {
42
exit( I) ;
if ((arch2 = fopen(nombre-arch,"wb"))=NULL) {
1 exit(1);
i** Escribir datos de format TIF **/
for(i=O; i<Format-Size; I++) putc(getc(arch I),arch2).
in-nonn(pix-rnat),
/** Escribir datos de CNN al archivo **/ for(i=O, i<M; i++)
forU=O; j<N; j+=2) { dat=((pix-mat[i]~]<<4)&OxfO)[(pix-mat[i]~+ I]&OxOf); putc(dat,arch2);
1
fclose(arcli 1 ); fclose(arch2);
return O; }
/* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
uit read-CNN() {
lilt I , J .
input-CNN = createParray((M+2),(N+2)); CNN = createParray((M+2).(N+2));
CNN-flag = (int **)cailoc( (M+2),sizeof(int*) ); for (i=O; i<(M+2); i++) { CNN-flag[i]=(int *)calloc(N+2, sizeof(int)); }
/* Get input image */
for (¡=O; i<(M+2); i++ /*,fprintf(stderr,"in")*/) for (j=O; j<(N+2); j++) {
if ((i!=O) && (j!=O) && (i!=(M+l)) && (j!=(N+l))) input-CNN[i]Lj] = irnage.dat[i-lllj-I];
else input-CNN [i] b]=O. O;
I* Set up the initial conditions for state variable */ for (¡=O; i<(M+2); i++)
switch (Global-cnn.init-cond) {
43
for O=O; j<0\1+2), CNN[i]li]=input-CNN[i]~], j++); break,
I* Initialize all convergence flags to zero ... */ for ( i = l ; i<=M; ¡++)for u=l ; j<=N; CNN-flag[i]Lj]=O, j++);
return O.
I* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
double **create-array(int rows, int cols) {
l i l t I ,
double **array, array = (double **)malloc(rows * sizeof(doub1e *)), for( i=O, i<rows, I++ )
array[i] = (double *)malloc(cols * sizeof(double)),
return (array) }
void free_array(double **array,iiit rows){ l i l t I ,
for( i=O, i<rows, I++ ) free(array[ I]),
free(array), I
#if o iiit * * create-array(rows, cok) i i i t rows, cok, {
iiit I ,
int **array, char *malloc(),
array = (iiit **)malloc(rows * sizeof(doub1e *)),
for( i=O, i<rowc, I++ ) array[i] = (int *)malloc(cols * sizeof(double)),
return (array),
#endif J* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */ int get-teinplates()
FILE 'arch, char noiii_arc[30], int I ,
a[ l ]=O O , a[2]=i O , a[3]=0 O , a[4]=1 O , a[5]=2 O, a[b]=l O. a[7]=0 O , a[8]=I O , a[9]=O O.
b[ I]=O O , b[2]=0 O , b[3]=0 O , 17[4]=0 O , b[5]=0 O , b[b]=O O,
44
b[7]=0 O. b[8]=0 O, b[9]=O O ,
1 = O, ietiirii O, I
/I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . */
l i l t get-Li( lilt 1,lllt J)
LI [ 1 ]=iiipiit-CNN [i- 1 3 b- 1 1, ~1[2]=11ipiit~CNN[i- i]ti]; ~1[3]=iiiptit~CNN[i- I ] ti+ I ] ; u[4]=iiiplit_C"[i]~-l];
u[7]=liiput_C"[i+l]Lj-l];
u[S]=Iiiput_CNN[i]Lj]; LI[ ó]=iiiput-CNN [ i] ti+ I ] ,
~1[8]=iiipiitCNN[i+l]Ljl; u[9]=Iiip~it-CNN[i+l]Lj+l];
retuni O; }
i i i t get-x(iiit i jn t j) { X[ I ]=CNN[i- 1 ]ti- I ] ; X[Z]=CNN[ I- 1 l b ] ; X[3]=CNN[I-I]b+I], X[4]=CNN [ ¡]ti- 1 1, X[S]=CNN [i] ti]; X[6]=CNN[i]Lj+ I];
X[8]=CNN [I+ 1 ]ti], X[9]=CNN[i+ I ]ti+ I ] ;
X[7]=CNN[i+ I lb - I];
retuni O; I
45
Archivo: Che1p.h
[OPTIONS] TITLE=C HELP Help CONTENTS=CONTENTS
[FILES] chelp rtf
[CONFIG] BrowseButtoiis()
Archivo: Che1pm.h
#define HELP-MENUITEMA OxlOO #define HELP-MENUITEMB OxlOl #define HELP-EXIT Oxl02
46
Archivo: Diff-eq.cpp
#iiiclude "cnii h"
extern double **create_array(), exteni void freeparray(),
exteni double I, derivative, extern double a[iO], b[10], extern double u[iO], X[lO]. exteni double slope, extern int layer-iium, extern ciiii-t Global-cnn,
double euler(), double pc(), double rk4(), double deriv(doub1e X[]);
double R = I O, double C = I O ,
/** Iiiipleineiits the "Explicit Euler Method" for the integration **/
double euler() {
double iiext=O.O;
derivative = deriv(X), next = X[5] + Global-cnn delta-t*derivative,
retuni(iiext): }
/** iinpleinents the "Predictor-Corrector Method" for the integration **/
double pc() {
double predict[ 1 O], euler-deriv, next=O O, l i l t I .
i* predict the next values by an "Explicit Euler" step */ euler-deriv = deriv(X); for (¡=I ; i<=9; ¡++)
predict[i] = X[i] + Global-cnn.deltat*euler-deriv;
/* calculate the next state variable value by Predictor-Corrector */ derivative = (euler-deriv + deriv(predict))R.O; next = X[5] + Global-cmdelta-t*derivative,
retuni(next); } / ** iinpleinents the "4th (rder Runge-Kutta Method" for the integration **/
double r k 4 0 { double k1[10], k2[10], k3[10], k4, new-x[lO]; double next=0.0, integral; lilt i , c;
47
for (I= I , i<=9; I++) { k I [i]=Global-cnn.delta-t*deriv(X): iiew-x[ i]=X[ i]+k 1 [ i]/2;
for (¡=I: i<=9. i++) { k2[i]=Global-ciin.deIta~t*deriv(new~x); new-x[ i]=X[ i]+k2 [i]/2,
} for ( i=i . i<=9; I++) {
k3[i]=Global-cnn. delta-t*deriv(new-x); iiew_x[i]=X[i]+k3 [i];
1
k4=Global-ciiii.delta-t*deriv(new-x);
integral = ((k 1 [S]+k4)/2+k2[S]+k3 [5])/3; derivative = iiitegral/Global-cnii delta-t,
/* iiext=X[S]+((k I [S]+k4)/2+k2[S]+k3[S])/3; */ next = S[5] + integral, return( next);
} /** function to calculate the derivative **/
double deriv(doub1e x[]) {
double ay=O, bu=O, dx, y; iilt i ;
for ( i = I ; i<=9; i++) {
/*y = (fabs((double)slope*x[i]+ 1 .O) - fabs((double)slope*x[i]- 1.0))/2.0;*/
y = (fabs((double)x[i]+l .O) - fabs((double)x[i]-l.0))/2.0;
ay += a[i]*y; bu += b[i]*u[i];
dx = -x[S] + ay + bu + I ,
/*dx = -x[S]/(R*C) + ay/C + bu/C + I/C;*/
returii(dx); 1 Archivo: LeeBmp.cpp
#iiiclude<stdio h> #iiiclude<wiiidows h> #iiiclude<stdlib h> #incliide<alloc h> void leeBnip(F1LE *archivo, HWND hwnd, HDC hdc, int left, int top, int right, int bottom) { COLORREF color1 ,color2,color3,
BITMAPINFOHEADER Info, BITMAPFILEHEADER Header,
POINT point, unsigned long offsett=O, //Variable auxiliar multi usos
register int i j , k, iiit mix-hi-I,
unsigned char pa1[256][3], //Paleta de l a imagen
//Variables auxiliares para poder realizar desplazamientos de bits aux-10-1, aux-10-2, aux-hi-2,
//de bfOff8its desplazaniiento=O, //Variable donde se guarda el desplazamiento de la imagen con respecto
offsett = fgetc(arcliivo), //Se extrae del archivo el tamaño del archivo bytes
48
Header.bfSize = offsett; offsett = fgetc(archiv0);
offsett = offsett << 8; Header.bfSize += offsett; offsett = fgetc(archiv0); offsett = offsett << 16; Header.bfSize += offsett, offsett = fgetc(archiv0); offsett = offsett << 24, Header.bfSize += offsett;
fgetc(archiv0); fgetc(archiv0); fgetc(archiv0); fgetc(archiv0);
offsett = fgetc(archiv0); // Se extrae la distancia en Bytes de la estructura Header.bfOffBits = offsett; // BITMAPFILEHEADER a la información del bitmap offsett = fgetc(archivo), offsett = offsett << 8; Header.bfOf€Bits += offsett; offsett = fgetc(archiv0); offsett = offsett << 16; Header.bfOf€B¡ts += offsett; offsett = fgetc(archiv0); offsett = offsett << 24; Header.bfOffBits += offsett;
fseek(archivo,Oxl2,SEEK-SET);//Se calcula el ancho y alto de la imagen //Si el tercero y cuarto bytes leidos aqui son cero, el
aiix-10-1 = fgetc(archivo), //alto de la imagen se encuentra dos bytes adelante aux-hi-l = fgetc(archivo), //de lo contrario esos dos bytes son el alto de la imagen
aux-10-2 = fgetc(archiv0); aux-hi-2=fgetc(arcliivo), if(aux-lop2=0 && aux-hi-2-0)
aux-lo-2=fgetc(archivo); aux-hi-2=fgetc(archivo); offsett=fgetc(archivo); offsett=fgetc(archivo); 1 1nfo.biWidth = aux-10-1; aux-hi-l = aux-hi-l << 8;
Info.biWidth += aux-h-I; Iiifo.biHeight = aux-10-2;
Info biHeight += aux-h2 ; fseek(archivo,28,SEEK_SET);
aux-hi2 = aux-hi-2 << 8;
//Se lee el tamaño en bits de cada punto en pantalla, offsett=fgetc(archivo); //Segun la teoria este valor solo puede ser 1,4,8,24,
if(offseW4 && offsett<8) offsett=4; / /sin embargo este valor puede estar en intervalos dentro else //de esos valores, es decir podria ser un 5, un 1 O o un 28
if(offsett>l&& offsett<24) offsett=8: //es por eso que se tiene que ajustar a los valores else //especificados
if(offsew24) offsett=24; Info.biBitCount = offsett;
offsett=fgetc(archivo); if(offsett!=O) offse-0; offsett = offsett << 8; Info. biBitCount+= offsett;
fseek(archivo,54,SEEK-SET); //Aqui se lee la paleta de colores que esta en tripletas //de Azul, verde y rojo RGB o RVA for (i = O; i<256; I++)
{ pal[¡] [2]=fgetc(arch¡vo); //AZUL pal[i][l]=fgetc(archivo); //VERDE pal[i][O]=fgetc(archivo); //ROJO fgetc( archivo); 1
hdc = GetDC(hwnd); fseek(archiv0,Header. bfOftBits,SEEK-SET);
if(liifo.biBitCount==8) {
//Si la imagen es de 256 colores
49
Header bfSize=((Header bfSize-Header bfOffBits)/lnfo biHeight),//Se ajusta el tamaño
desplazamiento-=Info biwidth, desplazamiento=(int)Header bfS ize, //de la imagen para evitar
//que la imagen salga desplazamiento=abs(desplazamiento) , //defazada
forQ=lnfo biHeight+ top + 2 p t o p + 2 J-) {
for( i=left+5 i<(lnfo biWidth+left+5+desplazamiento),i++) {
color I = fgetc(archiv0) , if0 < bottom && I <
right)
SetPixel(hdc,ij,RGB(pal[colorl][0],pal[colorl][ I],pal[colorl][2]));
1 1
else if(Info.biBitCount==4) //La imagen es de 4 bits por punto (16 colores)
{ desplazamiento=(int)((Header. bfSize-Header. bfOftBits)/lnfo. biHeight)*2;//Se
desplazamiento-=Info. bi Width; ajusta el desplazamiento
//de la imagen para evitar desplazamiento=abs( desplazamiento); //que se deforme
foríj=lnfo.biHeight+ top + 2j>top+2j--) {
for(i=left+5;i<(lnfo. biWidth+left+S+desplazarniento);i+=2) {
por punto
color 1 =fgetc(archivo), color2=color11
colorl=(colorl>>4),
color2=color2 & 15,
//Se extrae el primer color dado que la imagen es de 4 bits
//Se extrae el segundo col01 if0 < bottom && i < right) {
SetPixel(hdc,i j,RGB(pal[color 1 ][O],pal [color I ] [ 1 ],pal [color 1 ] [2])),
SetPixel(hdc,i+l j,RGB(pal[color2] [O],pal[color2] [ I],pal[color2][2])); 1
I 1
1 else
if(lnfo.biBitCount-24) //La imagen es de 24bits por punto (color real 16.7 millones de colores){ fseek(archivo,Header. bfOffBits,SEEK-SET);
//Aqui cada byte leido representa un valor de RGB es decir se necitan leer tres bytes //para conformar un punto, por lo cual la paleta no existe
foríj=Info.biHeight + top + 2 jXop+2j--) {
for(i=left+5;i<(lnfo. bi Width+left+S);i++) {
colorl =fgetc(archivo), color2=fgetc(archivo), color3=fgetc(archivo),
ifíj < bottom && i < right)
SetPixel(hdc,i j,RGB(color3, color2, colorl));
else if(lnfo.biBitCount==l) //La imagen es Blanco y negro {
fseek(archiv0,Header. bfOftBits,SEEK-SET);
foríj=lnfo.biHeight + top + 2j>top+2j--) //Aqui cada byte leido representa 8 puntos en la pantalla
{
50
for(i=left+5 $(Info. bi Width+left+ 5);1+=8) {
color2=(colorl & 1)*255, if0 < bottom && I > right)
SetPixel(hdc,i~,RGB(color2,color2,color2)), color2=((colorl & 2)>>1) * 255, if0 c bottom && I > right)
SetPixel(hdc,i+ 1 ~.RGB(color2,color2,color2)), color2=((colorl & 4)>>2) * 255, if0 bottom && i > right)
SetPixel(hdc.i+2~,RGB(color2,color2,color2)), color2=((colorl & 8)>>3) * 255, if0 bottom && I > right)
SetPixel(hdc.i+3 j,RGB(color2,color2,color2)),
if0 color2=((colorl & 16)>>4) * 255,
bottom && I > right)
SetPixel(hdc,i+4j,RGB(color2,color2,color2)); color2=((colorl & 32)>>5) *255; ifíj bottom && i > right)
SetPixel(hdc,i+5j,RGB(color2,color2,color2)); color2=((colorl & 64)>>6) * 255; if(j < bottom && i > right)
SetPixel(hdc,i+6j,RGB(color2,color2,color2)); color2=((colorl & 128)>>7) * 255;
< bottom && i > right)
SetPixel(hdc,i+7j,RGB(color2,color2,color2)); }
}
color1 =fgetc(archivo),
51
Archivo: NeuraLcpp
i*
Prograina para el procesamineeto de imagens, que utiliza un algoritmo de Redes Neuroiiales para eliminar el ruido de una imagen * I #include <edit h> diiiclude cstdio h> #include <bstatic h> #include <bclikbox h> #include <bradio h> #include <listbox h> #include <button h> #include "cips h" #include "ciiii h" #include <owl Ii>
HINSTANCE hliistance; // comandos de menu coiist ii i t IDM-FILEOPEN = 101; //Código de control para el item de Apertura del
coiist ii i t IDM-FILEEXIT = 102; //Código de control para el item de Terminación del
coiist int IDM-HELPABOUT = 103; //Código de control para el item de ayuda
coiist iiit IDM-HELPCNN = 105; coiist iiit IDM-CNN
I / Nuiiieros de ideiitificacion par los controles de la caja de dialogo coiist nit ID-FILENAME = 101; /Nombre del archivo coiist iiit ID-PATHNAME = 102; //Path completo del archivo coiist int ID-FILELIST = 103; //lista de archivos del directorio actual coiist nit ID-DIRLIST = 104; //Lista de directorios dentro del directorio actual coiist iiit ID-ALLFILES = 105; //Código de identificación para todos los archivos const iiit ID-TIFFFILES = 106; //Código de identificación para el boton de archivos .tif coiist iiit ID-BMPFILES = 107; //Código de identificación para el botón de archivos .bmp coiist iiit ID-HELP
//Numero de ideiitificacion para l a ventana de valores //Estos números sirven para controlar los controles //que identificarán los parametros que son necesarios //para el algoritmo de CNN coiist int ID-DELTA = 101; coiist iiit ID-CONV = 102; const iiit ID-MAXI = 150; coiist iiit ID-TOL = 104; //Tipos de integración núinerica const int ID-EULER = 105; coiist int ID-PC = 106; const iiit ID-RK4 = 107, //Tipo del Template coiist iiit ID-CEROS = 108, coiist ii i t ID-UNOS = 109; const iiit ID-INPU = 1 IO;
// Archivo en el menú principal
//programa
= 104, //Código de control para el item de CNN
= 998; //Código de identificación para el botón de ayuda
//Control del número de iteraciones, se utilizan en caso de que la red no converga //entonces se utiliza el criterio del número máximo de iteraciones para que el programa //termine noniialinente coiist int DELTASIZE = 6; coiist iiit CONVSIZE = 6; coiist iiit MAXISIZE = 6; coiist iiit TOLSIZE = 6;
52
ilBiifter para la transferencia de datos en el programa, i laqtii se aliiiacenan todo los datos correspondientes a las variables del //algoritmo de CNN struct {
char delta[DELTASIZE], char coiiv[CONVSIZE], char iiiax[MAXISlZE], char tol[TOLSIZE], WORD euler,pc,rk4, WORD ceros,unos,input,
} Data unsigned char cambio = O, //Nombres de archivo genericos char* ALL-FILES = "* *", char* TIFF-FILES = "* tif', char* BMP-FILES = "* bmp", //nombre de la imagen, tal vez seria mejor ponerlo como miembro de l a clase TProgramWindow static char nombre [120]=" ' I ,
static char nombre1 [l20]=" ", exteiii void leeBmp(F1LE *archivo, HWND hwiid, HDC hdc, int left int top, int right, int botorn), extern void ciin(doub1e delta,double tol,double Porc,int Max,iiit In-nieto,int Inp,char *nombre1 ,char *nombre, HDC hdc),
//Clase necesaria para la caja de dialogo about, //esta clase pertenece a l a biblioteca de objetos de borland, y es l a encargada de //la creacioii y niaiiipulacion de cajas de dialogo class TAboiitDialog public TDialog {
public
TAboutDialog(PTWindows0bject AParent)
}, //Clase necesaria para la caja de dialogo about
class TErrorDialog public TDialog {
public
TDialog(AParent, "DIALOG-ABOUT") { }
TErrorDialog(PTWindows0bject AParent) TDialog(AParent, "DIALOG-ERR") { 1
I. class TlntroDialog public TDialog {
public
TíiitroDialog(PTWindows0bject AParent) TDialog(AParent, "DIALOG-INTRO") { }
1.
//Clase para el manejo de la ventana de archivos en la caja de dialogo Openfile class TFileOpenListBox: public TListBox {
protected
iiit patliNanieId;
public
TFileOpeiiListBox(PTWindows0bject AParent, iiit Resourceld, int PathId);
virtiial int Fill(char*) = O; i i i t DirectorySelected(cliar*);
}.
53
/¡Ftiiicion que busca y despliega el nombre de los archivos existentes de extensión dada TFileOpeiiListBox TFileOpenListBox(PTWindows0bject AParent,
iiit Resourceld, int Pathid)
TListBox(AParent, Resourceldl {
patliNaineld = Pathld.
TFileOpeiiListBox DirectorySelected(char* path)
return DlgDirSelect(Parent->HWindow, path, Getld() ),
class TFileListBox public TFileOpenListBox {
public
TFileListBox(PTWindows0bJect AParent, iiit Resourceld, iiit Pathld)
TFileOpenListBox(AParent, Resourceld,
Pathld) { } iiit Fill(cliar*),
) >
iiit TFileListBox Fill(char* mask) {
returii DlgDirList(Parent->HWiiidow. mask, GetId(), patliNameld, O),
}
class TDirectoryListBox: public TFileOpenListBox {
p ti b I i c
TDirectoryListBox(PTWindows0bject AParent, i i i t Resourceld, int Pathld)
TFileOpeiiListBox( AParent, Resourceld, Pathld) { }
iiit Fill(char*), I9
iiit TDirectoryListBox::Fill(char*) I
return DlgDirList(Parent->HWindow, ALL-FILES. Getld(), pathNameld, OxCOl O);
/¡clase para el control de la caja de dialogo Open File
class TFileOpeiiDialog public TDialog {
char file-name [SO], char path @O],
TEdit* fileName, //ventana donde aparece el nombre del archivo TBStatic* pathName, //Nombre del path complento del directorio actual TFileListBox* TDirectoryListBox* dirlist, TBClieckBox* allFiles, //botan para All TBClieckBox* tiffFiles, //Botan para t i ff TBClieckBox* bmpFiles, //botan para bmp TButtoii* okBunon, //Botan de OK
filelist, //ventana donde aparecen los nombres de los archivos del directorio actual //ventana donde aparecen los nombres de los subdirectorios del directorio actual
54
TBuíton* helpButíon; /hoton de ayuda
iiit IsDirectoryOrDrive(cha*); iiit IsAnibiguousFilename(char*);
public:
TFileOpenDialog(PTWindows0bjed);
virtual void WMlnitDialog(TMessage&) = [WM-FIRST + WMpiNITDIALOG];
virtual void handleFileList(TMessage&) =
virtual void handlePathList(TMessage&) = [ID-FIRST + ID-FILELIST];
[ID-FIRST + ID-DIRLIST],
virtual void IiandleAlIFiles(TMessage&) =
virtual void IiandleCppFiles(TMessage&) =
virtual void IiandleHppFiles(TMessage&) =
[ID-FIRST + ID-ALLFILES],
[ID-FIRST + ID-TIFFFILES];
[ID-FIRST + ID-BMPFILES];
virtual void Ok(TMessage& msg) = [ID-FIRST + IDOK] { doOk(iiisg);}
void doOk(TMessage&),
// virtual -TFileOpenDialog(); // -TFileOpeiiDialog();
1, // Es necesario crear un objeto por cada elemento de la caja de dialogo, s i se desea que esta caja //devuelva algun tipo de valor especial
/*TFileOpeiiDialog: :-TFileOpenDialog()
delete IielpButton,
TFileOpeiiDialog::TFileOpenDialog(PTWindowsObject AParent)
{
) */
TDialog(AParent, "DIALOG-FILEOPEN") {
strcpy(file-name, ALL-FILES); strcpy(patli, ALL-FILES);
fileNaine = iiew TEdit(this, ID-FILENAME,
patliNaine = new TBStatic(this, ID-PATHNAME,
fileList = new TFileListBox(this, ID-FILELIST,
dirList = new TDirectoryListBox(this, ID-DIRLIST,
allFiles = new TBClieckBox(this, Ii-ALLFILES, O); tiftFiles = new TBCheckBox(this, ID-TiFFFILES, O); bmpFiles = new TBCheckBox(this, ID-BMPFILES, O);
okButton = new TButton(this, IDOK);
sizeof(file-name) ),
sizeof(path) );
ID-PATHNAME);
ID-PAT" AME);
void TFileOpenDialog WMlnitDialog(TMessage& mcg) {
TDialog WMlnitDialog(msg),
fileN ame->SetText(file-iianie), patliNaine->SetText(path),
fileList->Fill(file-iiiaine),
55
dirList->Fill(file-name),
allFiles->Check(); i
void TFileOpenDialog::handleFileList(TMessage& msg) {
switch (nisg.LP.Hi) {
case LBN-SELCHANGE: fileList->DirectorySelected(path); fileN ame->SetText(path); retuni.
case LBN-DBLCLK. fileList->DirectorySelected(path); fileNaiiie->SetText(path);
strcpy(nombre,path); Close Wiiidow(1 DOK);
return,
void TFileOpenDialog::handlePathList(TMessage& msg) {
switch (msg.LP.Hi) {
case LBN-DBLCLK: dirList->DirectorySelected(path);
strcat(nombre,path); // usarlo con el nombre del archivo anterior if (file-name [O] == '\Y)
else strcat(patli, &file-iiame [ I ] );
strcat(path, file-name);
filelist->Fill(path); dirlist->Fill(path); fileNaine->SetText(path);
void TFileOpenDialog handleAllFiles(TMessage& msg) {
fileNaine->SetText( ALL-FILES), doOk(msg),
}
void TFileOpenDialog::IiandleCppFiles(TMessage& msg) {
fileName->SetText(TIFF-FILES); doOk(msg);
void TFileOpeiiDialog::handleHppFiles(TMessage& msg)
fileNaiiie->SetText(BMP-FILES); doOk(insg);
}
void TFileOpenDialog doOk(TMessage&) {
I/ obtener el nuevo path seleccionado tileNaiiie->CetText(patli, sizeof(path) ),
ií Mantener una copia del path actual, enc caso /i de que se iiitroduzca el nombre completo de un archivo strcpy(iiombre, path),
56
11 ver si el nombre especificado es valido if (lsDirectoryOrDrive(path) ) { I1 no se especifico un directorio o un drive usar este // como un nuevo path, con la mascara del archivo anterior
I1 mostrar el nuevo directorio seleccionado - s i es que hay dirlist->Fill(path),
strcat(path, file-name),
1
if (IsAinbigiioucFilename(path) ) {
/ I Mantener una copia de la cadena introducida char originalgath [80], strcpy(original_path, path),
I1 llenar las ventanas de archivos y directorios I1 con la nueva inforamcion, si el path es valido if (fileList->Fill(path) ) { dirlist->Fill(path), // re-iiiostrar la antigua mascara del archivo strcpy(filename, originalgath), fileNaine->SetText(file-name),
} I1 direcorio o nombre de archivo invalid0 else MessageBeep (O), return,
}
I1 se introdujo un nuevo noinbre de archivo: agregarselo al I1 path actual strcat(path, "\Y); strcat(path, file-name);
I / actualizar las listas de archivos con el nuevo archivo especificado if (fileList->Fill(path) ) { I/ se introdujo un directorio valido strcpy(filename, path); fileNaine->SetText(file-name), retuni;
1
// se introdujo un nombre de archivo ambiguo: 11 procesarlo
/I regresar el nombre de del archivo original strcpy(path, nombre);
I1 Cerrar la caja de dialogo CloseWiiidow(lD0K);
I
i i i t TFileOpeiiDialog: .IsDirectoryOrDrive(char* name) {
int length = strlen(name); char last = name [length - I] ; if (last == '\Y) return TRUE; if (last == I . ' ) return TRUE; return FALSE;
i i i t TFileOpenDialog IsAmbiguousFilename(char* name) í
if (strchr(name, ' * I ) ) return TRUE, if (strchr(name, ' 7 ' ) ) return TRUE, return FALSE,
}
57
class TlmagenDialog public TDialog{ TEdit *Delta, TEdit *Cow, TEdit *Maxi, TEdit *Tol,
TBRadioButton* EulerButton, TBRadioButton* PCButton, TBRadioButton* RK4Button. TBRadioButton* CerosButton, TBRadioButton* UnosButton, TBRadioButton* InputButton,
TBtitton *YesBoton, public TliiiageiiDialog( PTWindowsObject),
I
TliiiagenDialog 7 ImagenDialog( PTWindowsObject AParent)
TDialog(AParent, "TAMA-IMAG") { Delta = new TEdit(this,ID-DELTA,DELTASIZE), Conv = new TEdit(this,ID-CONV,CONVSIZE), Maxi = new TEdit(this,lD-MAXl,MAXISIZE), To1 = new TEdit(this,lD-TOL,TOLSIZE), EiilerBiittoii = new TBRadioButton(this, ID-EULER,O), PCButton = new TBRadioButton(this, ID-PC,O), RK4Button = new TBRadioButton(this, ID-RK4,0), CerosButton = new TBRadioButton(this, 1D-CEROS,O), UiiosButton = new TBRadioButton(tliis, ID-üNOS,O), IiiptitButton = new TBRadioButton(this, ID-iNPU,O), YesBoton = new TButton(this,lDOK), TraiisferBuffer = (LPSTR) &Data,
/*Las clase TProgramWiiidow define el objeto que representa la pantalla del usuario, se definen I I
todos los inetodos con los que contara la ventana principal como son los que manejan los eventos asi como los metodos para el procesamiento de la imagen y los metodos de CNN*/
_CLASSDEF(TProgramWindow)
class TProgramWiiidow : public TMDlFrame { //class TPrograinWiiidow : public TWindow {
private POINT WindowSize,
HCURSOR CursorDown, CursorUp,CursorWait,
char message [SO], RECT statusLineRectangle,icono,
short the-image[ROWS][COLS],
HBITMAP TITULO-I ,WAIT,
HlCON DISK-INAC, DISK-ACT, CNN-I, CNN-2, HELP-I, HELP-2, CNNlcon,
H DC hdc, DC ,
public TProgramWiiidow( LPSTR ATitle, LPSTR MenuName )
TMDlFrame(ATitle, MenuName) { } ,
TPrograni Wiiidow(PTWiiidows0bject AParent, I*
LPSTR Title) TWiiidow(AParent, Title) { } */
LPSTR GetClassNameO {return "CNN application",} void GetWindowCIass(WNDCLASS&), virtual void Setupwindow( void ), virtual void FileOpen(TMessage&) = [CM-FIRST + IDMFILEOPEN], virtual void WMSize( TMessage& Message ) = [WMFIRST + WM-SIZE],
58
virtual void WMPaint( TMessage& Message ) = [WM-FIRST + WM-PAINT], virtual void Paint(HDC PaintDC, PAINTSTRUCT& Paintlnfo), virtual void WMLButtonDown(TMessage&) = [WM-FIRST + WM-LBUTTONDOWN], virtual void WMLBuaonUp(TMessage&) = [WM-FIRST + WM-LBUTTONUP], virtual void FileExit(TMessage&) = [CM-FIRST + IDM-FILEEXIT] {CloseWindow(),} virtual void HelpAbout(TMessage&) = [CM-FIRST + IDM-HELPABOUT]. virtual void HelpCNN(TMessage&) = [CM-FIRST + IDM-HELPCNN], virtual void CNN(TMessage&) = [CM-FIRST + IDM-CNN], void Message(char*), void DrawBMP( HDC DC, int X, int Y, HBITMAP BitMap ), nit Leer-linagen(HWND hwnd, char *nombre), int Lee-Imagen-Tiff(HWND hwnd,int x, int y,char *nom-titchar *nombre), void error(void), iiit Toiiia_Valores(void),
char* Message() {return message,} virtual void WMDestroy( TMessage& Message ) = [ WM-FIRST + WM-DESTROY 1,
void TProgramWindow::GetWindowClass(WNDCLASS& wndClass) { TWiiidow::GetWindowClass(wndClass);
// Se carga el cursor del martillo arriba
CNNlcoii = Loadlcon(GetApplication()->hlnstance, "CNb_ICON"), //Se carga el cursor del martillo abajo
wiidclass style = O,
CursorUp = Loadcursor( GetApplication()->hInstance, "CURSOR-UP" ),
//Se asigna como cursos por default al martillo hacia arriba wndClass hCursor = CursorUp, //Se le asigna al programa el icono de CNN
wiidClass Iilcon = CNNlcon, //Se le pega un menu a la ventana wndClass IpszMenuName = "MENUCNN", //color de fondo gris wndClass hbrBackground = (HBRUSH)GetStockObject(LTGRAY-BRUSH),
void TProgramWindow::SetupWindow( void ) {
CursorDown = Loadcursor( GetApplication()->hlnstance, "CURSOR-DOWN" ); CursorWait = LoadCursor(GetApplication()->hInstance, "CURSOR-WAIT"); TITULO-] = LoadBitmap( GetApplication()->hInstance, "TITULO-I ");
DISK-INAC = Loadlcon(GetApplication()->hlnstance,"DISK-INAC"); DISK-ACT = Loadlcon(GetApplication()->hlnstance,"DlSK-ACT"); CNN- I = Loadlcon(GetApplication()->hInstance,"CNN-I "); CNN-2 = Loadlcoii(GetApplicatioii()->hlnstance,"CNN_L"), HELP- I = Loadlcoii(GetApplication()->hlnstance,"HELP_ICO_I "), HELP-2 = Loadlcon(GetApplicat~oii()-~hliistaiice,"HELP~lCO~2");
strcpy(Data.delta,"O. 75"); strcpy(Data.tol,"O. 1 "); strcpy(Data.inax,"20"); strcpy(Data.conv,"95"); Data.euler = 1 ;
GetApplication()->ExecDialog( new TlntroDialog(this) );
WAIT = LoadBitmap( GetApplication()->hlnstance,"WAIT");
Data.iiiput= 1 ;
void TProgramWindow error(void) {
GetApplication()->ExecDialog( new TErrorDialog(this) ),
).
int TProgramWindow Toma-Valores()
59
{ int result, result = GetApplication()->ExecDialog(
new TlmagenDialog(this) ), //Aparece la ventana de dialogo para
//las dimensiones de la imagen retuni result.
//funcioii que lee imagenes tiff pequeñas, debido a la complejidad que tiene //el foniiato TIFF, se decidio unicamente incluir un un procedimiento que leyera iiiiiiagenes pequeñas (32 X 32) ya que las funciones necesarias para la lectura de imagenes //TIFF generales hubieran hecho que el programa fuera exagerademente extenso
int TPrograinWindow Lee-Imagen-Tiff(HWD hwnd,int x, int y,char *nomtif,char *mensaje) I >
iiit ie = 17, I 1 = o, le = 100, I I = 100,
struct tiff-header-struct image-header,
COLORREF color, RECT r, HBRUSH Iibr,
lilt I i JJ ,
readtiff-header(nomtif, &image-header), iifuncion que lee el encabezado de la imagen tiff (ancho, alto ) read-tiff-image(nom-tif, the-image, 11, ie, II, le), //lee los datos de la imagen
hdc = GetDC(hwnd), hbr = CreateSolidBrush(RGB(O,O,O)), SelectObject(hdc, hbr), Rectangle(hdc, x-3, y, x+32+16, y+32+27),
hbr = CreateSolidBrush(RGB(62,125,122)), SelectObject(hdc, hbr), Rectangle(hdc, x-5, y-2, x+32+14, y+32+25), SetTextColor(hdc, RGB(255,255,255)), SetBkColor(hdc, RGB(62,125,122)), TextOut(hdc, x+3,y+32+6, mensaje, strlen(mensaje) ),
for(ii=O ii<image-header image-length,ii++) { fOr í~ j=5 ,jJ<image-header image-width+5 jj++)
{ color = the-imageb][ii], if(color== 1 5) color=RGB(255,255,255), else if(color==O) color=RGB(O,O,O), else color = RGB(128,128-color,128-color), SetPixei(hdc,x+ii+~,y+jj,coior),
1
ReleaseDC(hwnd,hdc), DeleteObject(hbr),
return O, 1
//fuiicion que lee cualquier tipo de imagen BMP, con esta funcion se pueden //leer iniagenes BMP de cualquier tipo 2, 16, 256, 24-bit colores
iiit TPrograin Window Leer-Imagen(HWND Iiwnd, char *noni-arch)
COLORREF color 1 ,color2,color3, BITMAPFILEHEADER Header,
BITMAPINFOHEADER Info, FILE *archivo, //Puntero al archiv de la imagen POINT point, unsigned long offsett=O, //Variable auxiliar multi usos
60
archivo=fopen(noni-arch,"rb"); if (archivo==NULL)
{ error(); nombre[O]= ' ';
iiombre[l] = 'ko'; return O;
I else
{ offsett = fgetc(archiv0); //Se checa s i el tipo de la imagen es un Bitmap Header.bfType = offsett; offsett = fgetc(archiv0);
Header. bff pe+= offsett;
GetCursorPos( &point);
offsett = offsett << 8;
Setclassword( HWindow, GCW-HCURSOR, (W0RD)CursorWait ),
SetCursorPos( point.x, p0int.y); if(Header.bfí'ype = 19778) //Si si lo es Desplegar la imagen
{ leeBmp(archivo, hwnd, Iidc,icono.left, icono.bottom + 25, statusLineRectangle.right-2, statusLineRectangle.top - 5); 1
else if(Header.bffype==l8761)//Si la imagen no es bitmap entonces debe se tiff
{
} Lee-Imagen-Tiff(hwnd,icono. left+ I 5,icono. bottom+25,nom-arch,"input");
else I error(); nombre[O]= ' ';
iiombre[l] ='\XU; 1
1 if(cambio== 1 )
Setclassword( HWindow, GCW-HCURSOR, (W0RD)CursorUp );
SetCursorPos( point.x, p0int.y); fclose(archivo);
ModifyMenu( GetMenu( HWindow ), IDMCNN, MF-BYCOMMAND JDM-CNN, "C&NN2D );
GetCursorPos( &point);
cambio = O; return O;
} //fin Leer-Imagen
//ftincion que crea la caja de dialogo file open cundo se selecciona open del menu o se pica el icono void TProgram Window FileOpen(TMessage&) i
char ventana[ 120]="CELULAR NEURAL NETWORKS - ", iiit result, result = GetApplication()->ExecDialog(new TFileOpenDialog(this))
Set WiiidowText(H Window, (LPSTR)ventana), if (result == IDOK j j result =I )
strcat(ventana,nombre),
{ cambio = I ,
strcpy(nombre1," "). 1
else strcpy(nombre, " "),
return,
//Rutina de manejo de la funcion cnn para el procesamiento de la imagen //Rutina que actualiza el mensaje enviado a la barra de estado void TProgram Window Message(char* string) {
61
strncpy(rnessage, string, sizeof(message) ); IiivalidateRect(HWindow, &statusLineRectangle, O);
//Rutina de pinta un BMP en la pantalla, este Bh4P debe estar registrado en el archivo .res void TProgramWindow::DrawBMP( HDC DC, int X, int Y, HBITMAP BitMap )
HDC MemDC; BITMAP brn; BOOL MadeDC;
if ( DC = = O ) {
DC = GetDC( HWindow ); MadeDC = TRUE;
} else MadeDC = FALSE; MeinDC = CreateCompatibleDC( DC ); Selectobject( MemDC, BitMap ); Getobject( TITULO-I, sizeof( bm ), ( LPSTR ) &bm ); BitBlt( DC, X, Y, bm.bmWidth, bm.brnHeight, MemDC, O, O, SRCCOPY ); DeleteDC( MemDC ); if ( MadeDC ) ReleaseDC( HWindow, DC ); DeleteObject(BitMap);
}
// define un patron gris obscuro para el fondo de l a barra de estado #define STATUS-LINEBACKGROUND RGB(I 35,133, 143)
// define un color gris clar para el texto de la barra de estado #define STATUS-LINE-TEXT RGB(0, O, O)
void TPrograniWiiidow::CNN(TMessage&) i double delta,conv,tolerancia; int inetodo-integracion,datos-input,max-iter; i i i t i=O, result; static int num = 97;
RECT r. POINT point;
result = Toma-Valores(); if(result == IDOK)
1 delta = atof(Data.delta); conv = atof(Data.conv); inax-iter = atoi(Data.niax); tolerancia = atof(Data.to1); if(Data.euler)
inetodo-integracion = 1 ; if(Data.pc)
iiietodo-integracion = 2; if(Data.rk4)
inetodo-iiitegracion = 3; if(Data.ceros)
datos-input = O; if(Data.iinos)
datos-input = I ; if(Data. input)
datos-input = 2; SetClassWord( HWindow, GC W-HCURSOR, (W0RD)CursorWait ), GetCursorPos( &point); SetCursorPoc( point.^, p0int.y); GetClieiitRect(HWindow, &r); Iidc = GetDC(HWindow); SelectObject(hdc, CreateSolidBrush(RGB( O,O,O))),
62
Rectaiigle(lidc, (r.right-r.left- 160)/2, (r. bottom-r.top-60)/2+5,
DrawBMP(lidc,(r.right-r left-1 60)/2, (r.bottom-r top-60)/2, WAIT); do
(r right-r.left- 160)/2+165,(r.bottom-r.top-60)/2+55);
{ if(iionibre[i]==O && nombre[i+l]==O) break; nombre I [i]=noinbre[i]; I++;
}while(5==5); i=o,
do t
I++, }while(nombrel [i-l]l=' I ) ,
iiombrel [i-2]=0, iiombrel [i-2] = num++, noinbrel [ I - I ] = ' I ,
iioinbrel [I] = 't', noinbrel [ i+i] = Y, iiombrel[i+2] = 'f, Setclassword( HWindow, GCW-HCURSOR, (W0RD)CursorWait ), ciin(delta,tolerancia,conv,max-iter,metodo-integracion,datos-input,nombre,nonibre 1, hdc), SetClassWord( HWindow, GCW-HCURSOR, (W0RD)CursorUp ), GetCursorPos( &point), SetCtirsorPos( point x, point y), ReleaseDC(HWindow,hdc),
I }
//Rutina que controla el evento de Presionar el boton izquierdo del mouse
void TProgram Window:: WMLButtonDown(TMessage& msg)
POINT point; {
SetClassWord( HWindow, GCW-HCURSOR, (W0RD)CursorDown ); GetCursorPos( &point ); SetCursorPos(point.x, point y); point = MAKEPOINT(msg.LP); hdc = GetDC(HWindow); if(point.x+3>icono.left && poiiit.x+3<icono.right && point.y+2>icono.top
&& poiiit.y+2<icono. bottom) {
1
&& point y+2iicono.bottom) {
1
&& point.y+2<icono.bottom) {
1
Drawlcon( hdc, icono.lefi,icono.top, DISK-ACT );
if(point.x+3>icoiio.left+33 && point.x+3<icono left+64 && point.y+2>icoiio.top
Drawlcon( Iidc, icono.left + 32,icono.top, CNh-2 );
if(poiiit.x+3>icoiio.left+65 && point x+3<icono.right+ 128 && point.y+2>icono,top
Drawlcon( hdc, icono.lefi + 64,icono.top, HELD-2 ),
ReleaseDC(HWindow,hdc);
//Rutina que controla el evento de dejar de Presionar el boton izquierdo del mouse
void TProgramWindow::WMLButtonUp(TMessage& msg)
POINT point; {
SetClassWord( HWindow, GCW-HCURSOR, (W0RD)CursorUp ); GetCursorPos( &point );
63
SetCiirsorPos( poiiit.x, p0int.y ); point = MAKEPOlNT(msg.LP); hdc = GetDC(HWindow); Drawlcon( hdc, icono.left,icono.top. DISK-MAC ); Drawicon( hdc, icono.left+32,icono.top, CNN-1 ), Drawlcon( hdc, icono.left+64,icono.top, HELP-I ), if(point.x+3>icono.left && point.x+3<icono.right && point.y+2>icono,top
&& point.y+2<icono. bottom) { FileOpen(msg);
if(point.x+3>icono,right+ 1 && point.x+3<icono.right+22 && point.y+2>icono.top && poiiit.y+2<icono.bottom) {
if(strcmp(iiombre," ")) CNN(msg);
if(point x+3>icono.left+65 && point.x+3<icono.right+128 && point.y+2>icono.top && poiiit.y+2<icono bottom) { HelpCNN(msg); }
ReleaseDC(HWindow,hdc);
it Record the new size and stretch the background to it */ void TProgramWindow:: WMSize( TMessage& Message ) {
HDC HaiidleDC, MemDC; HANDLE Stretchobject, MemObject; HCURSOR OldCur; RECT r; T Window:: WMSizNMessage); WindowSize.x = Message.LP.Lo; WindowSize.y = Message.LP.Hi; GetCIieiitRect(HWindow, &r); InvalidateRect(HWindow, &r, TRUE); icono.left = def t ; icoiio.top = r.top, icono right = r .left +32; icoimbottoin = r.top + 32, statiisLiiieRectaiigle left = r.left; statiisLiiieRectaiigle.top = r.bottom - 24, ctatticLiiieRectaiigle right = r.right; stattisLiiieRectaiigle.bottom = r. bottom;
l.
void TProgramWindow::WMPaint( TMessagedt Message ) { RECT Rect;
Rect.top = icono.top, Rect.left = icoiio.left; Rect. bottom = statusLineRectangle,right; Rect right = statusLineRectangle.bottom; IiivalidateRect(HWindow, &Rect, FALSE); TWiiidow:: WMPaint(Message);
) ?
void TProgram Window Paint(HDC PaintDC, PAMTSTRUCT& Paintlnfo) i
TEXTMETRlC tm, int charHeight = tm tmHeight+4 + tm tmExtemalLeading, RECT r,
HBRUSH oldBrush, POINT point,
64
BeginPaint(HWindow, &Paintlnfo); Setclassword( HWindow, GCWHCURSOR, (W0RD)CursorUp ); GetCursorPos( &point ), SetCursorPos( point.x, p0int.y ); GetTextMetrics(hdc, &tm),
strcpy(iiiessage,"Seleccione un Comando"); InvalidateRect(HWindow, &r, TRUE), GetClientRect(HWindow, &r); oldBrush = (HBRUSH)SelectObject(PaintDC, CreateSolidBrush(RGB( 192, I92 , I 92))); Rectangle(PaintDC, r left,r.top, r.right,r. bottom), // update the coordinates o f the status line area statusLineRectangle.left = r.left - I ; statusLineRectang1e.top = r.bottom - 22; statusLineRectangle.right = r.right + I ; statusLineRectangle. bottom = r bottom;
//pinta la linea de esta inferior //actualizar las coordenadas del icono icono.left = r.left; icono.top = r.top + 3; icono.right = r.left+32;
oldBrush = (HBRUSH)SelectObject(PaintDC, CreateSolidBrush(RGB(242,242,242) ));
Rectangle(PaintDC, statusLineRectangle left, statusLineRectangle. top,
oldBrusli = (HBRUSH)SelectObject(PaintDC, CreateSolidBrush(RGB( 188, 188, 188) )); Rectangle(PaintDC, r.left+2, r top+2, r.right-2,r.top + 36);
Rectangle(PaintDC, statusLineRectangle. left+3, statusLineRectangle.top+3, statusLineRectangle.right-3,
icono.bottom = r.top+32;
Rectangle(PaintDC, r.left, r.top, r.right,r.top + 38);
statusLineRectangle.right, StatusLineRectangle. bottom),
statusLineRectangle. bottom-3); //Muestra la linea de estado
SetTextColor(l1dc. STATUS-LINE-TEXT); SetBkColor(hdc, RGB(I88,188,188)); TextOut(hdc, 3, statusLineRectangle.bottom - charHeight ,
DeleteObject(SelectObject(PaintDC, oldBrush)); Drawlcon(PaintDC, icono. left, icono.top, DISK-INAC); Drawlcon(PaintDC, icono. left+32, icono.top, CNN-I); Drawlcon(PaintDC, icono. left+64, icono.top, HELP-I); if(strcmp(nombre," "))
message, strlen(message) );
{
if(strcmp(nombre1 , I ' ")) Leer-lmagen(HWindow,nombre);
Lee-Imagen-Tiff(HWindow,(r.right - r.left) / 2 , icono. bottom+25,nombrel ,"Output");
} EiidPaiiit(HWindow, &PaintInfo);
} /*Rutina que permite desplegar la ayuda general del programa*/ void TPrograni Window:: HelpCNN(TMessage&)
WiiiHelp(HWindow, "chelp.hlp", HELPCONTENTS, OL); 1 /*Muestra la ventana de dialogo referente a la version del programa*/ void TProgram Window: :HelpAbout(TMessage&) {
GetApplication()->ExecDiaiog( new TAboutDialog(this) );
} /*Libera la memoria y destruye todos los objetos que fueron abiertos durante el programa*/
void TProgramWindow::WMDestroy( TMessage& Message )
Deleteobject( DISK-iNAC ); Deleteobject( DISK-ACT );
65
Deleteobject( CNN-I ), Deleteobject( C N N 2 ),
DeleteObj ect( TlTU LO- I ) , Deleteobject( WAIT ),
TWindow WMDestroy( Message ), )
-C LASSDEF(TUserApp1ication) class TUserApplication public TApplication {
public
TUserApplicatioii(LPSTR AName, HINSTANCE Anlnstance, HINSTANCE APrevlnstaiice
LPSTR ACmdLine, nit ACnidShow)
TApplication(AName, Anlnstance, APrevlnstance, ACmdLine, ACmdShow) { }
virtual void InitMainWindow(), 1.
LPSTR APPLlCATlONNAME = “CELULAR NEURAL NETWORKS”,
void TUserApplication InitMainWindow() í
Mainwindow = new TProgramWindowíJWLL, APPLICATIONNAME);
iiit PASCAL WinMain(HíNSTANCE Aninstance, HINSTANCE APrevlnstance, LPSTR ACmdLine, int ACmdShow)
i TUserApplication Application(APPLICATIONNAME,
Aiilnstance, APrevlnstance, ACmdLiiie. ACindSliow),
Iilnstance = Anlnstance, Application iiCmdShow = SW-SHOWMAXIMIZED, Application Run(), return Application Starus,
1
66
Archivo: Rti&cpp
................................................. * * file d \cipsbtiff c
* Functions This file contains * readtiff-image * read-line * seekto-first-line * seek-to-end-of-line
* Purpose * These functions read a TlFF image and insert * the data into a ROWSxCOLS array of short
* NOTE The fseek constants are
*
*
*
* O=SEEK-SET = beginning of file
2=SEEK_END = end of file * I=SEEK-CUR = current offset * * * External Calls * tiff c - readtiff-header
* Modifications * * * * seek, etc
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
25 June 1990 - created 27 March 1993 - use fopen, fread, fseek
instead of the earlier open, read,
*
#iiiclude "cips h"
ceekto-~rst_liile(FILE *iinage-file,struct tiff-header-struct * image-header.int ¡I) { long offset; int position;
offset = (ii- I )*image-header->image-width/ (8/image-header->bitsjer-p¡xel);
/* seek from current position */ position = fseek(image-file, offset, SEEK-CUR); retiini(positioii);
} I* ends seek-to-first-line * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* seekto-endof-line( ...
*++***+*****+*t**********t***********+*f*******/
*
*
seekto-end-of-line(F1LE *image-file,int le,struct tiff-header-struct *image-header)
long offset, nit position;
offset = (image-header->image-width-le)/
position = fseek(image-file, offset, SEEK-CUR); return(positi0n); /* ends seek-to-end-of-line */
(8/irnage-header->bitsjerjixel);
I
67
l**am************t*r***+***********I***********
* read-line( ...
* This function reads bytes from the TIFF * file into a buffer, extracts the numbers * from that buffer, and puts them into a * ROWSxCOLS array of shorts. The process * depends on the number of bits per pixel used * in the file (4 or 8)
*
* t**+**C+***m***********************t**********/
read-line(FILE *image-file,sliort array[ROWS][COLS],int line-number, struct tiff-header-struct *image-header,int ie,int le)
{ char buffer[COLS], first, second;
int bytes-read, i ; unsigned int bytes-to-read; union short-chw-union scu;
for(i=O, i<COLS; i++) buffer[¡] = '\O';
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* Use the number of bits per pixel to * calculate how many bytes to read.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
*
bytes-to-read = (le-ie)/
bytes-read = fread(buffer, 1, bytesto-read, (S/imageheader-> b i t s g e r g ixel);
image-file);
for(i=O; i<bytes-read; ¡++){
* * Use unions defined in cips.h to stuff bytes * into shorts.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . *
¡f(iiiiage-header->bits-pergixel = 8){ SCLI s n u n i = O;
array[l iiie-n umber] [i] = scu. s-num; } /* ends if bits-pergixel= 8 */
if( image-header->bitsgergixel == 4){
scu.s_alpha[O] = buffer[¡];
scti s n u m = o; second = bufferti] & OXOOOF; scu.s-aIpha[O] = second; array[line-number][i*2+1] = scu.s-num;
scu.s~nunl = o; first
first = first & OxOOOF, scu s-alplia[O] = first; array[liiie~nuinber][i*2] = scu s-num;
} I* ends if bi tsgergixel == 4 * I
= buffer[¡] >> 4;
68
} I* endsloopoveri * I retum(bytes-read);
} í* ends read-line */
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* seekpto-first-line(,
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
*
void read-tiff-iinage(char *image-file-name, short array[ROWS][COLS],
{ int iI,int ie,int Il,int le)
int bytes-read, closed, position, 1,
FILE *image-file; long offset;
struct tiff-header-struct image-header;
read-tiff-header(image-file-name, &image-header);
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* Procedure: * Seek to the strip offset where the data begins * Seek to the first line you want. * Loop over the lines you want to read: * Seek to the first element of the line. * Read the line. * Seek to the end of the data in that line.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
*
image-file = fopen(image-file-name, "rb"); if(iniage-file I = NULL){
position = fseek(image-file, image-header. strip-offset, SEEK-SET);
position = seek-to-first-line(image_file, &image-header, ii);
for(i=O; i<( l l - i l ) ; I++){
offset = (ie-l)/
position = fseek(image-file, offset,
bytes-read = read-line(image-file, array,
(8hmage-header. bitsgerpixel);
SEEK-CUR);
i , &image-header, ie, le);
le, &image-header); position = seek-to-end-of-line(image-tile,
position = fseek(iinage-file, I , SEEK-CUR);
} /* ends loop over i */
closed = fclose(image-file); } /* ends if file opened ok *I else(
priiitf("\nRTIFF.C> ERROR - cannot open " "tiff file"),
1 position=position; closed=closed; b ytes-read= bytes-read; } I* ends readt i - image */
69
Archivo: TifC.cpp
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* file d \cips\tiff c
* Functions This file contains * read-tiff-header * extract-long-from-buffer * extract-short-froin-buffer
* Purpose * *
* External Calls * none
* Modifications * * *
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
*
*
This file contains the subroutcnes that read the tiff files header information
*
*
23 June 1990 - created 28 March 1993 - using fopen, fread, fseek
instead of my-open, my-read, iseek *
#include "cips.li"
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
extract-long-from-buffer(. . .
This takes a four byte long out of a buffer of characters.
It is important to know the byte order LSB or MSB.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void extract-long-frombuffer(char buffer[],int Isb,int start,long *number) {
int i ; union long-char-union Icu;
if(lsb == I ) { Icu.l-alpha[O] = buffer[start+O]; 1cu.l-alpha[ I ] = buffer[start+l]; Icu I-alplia[2] = buffer[start+2]; Icu.i-alpha[3] = buffer[start+3];
} I* ends if Isb = I */
if(lsb == O){ lcu I-alpha[O] = buffer[start+3], Icu I-alpha[ I ] = buffer[start+2], icu l-alpiia[2] = buffer[start+l], Icu lalpha[3] = buffer[start+O],
} /* ends if Isb = O */
*number = icu.l-num;
70
} I* ends extract-long-from-buffer *I
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* extractsliort-frombuffer~
* This takes a two byte short out of a * buffer of characters.
* it is important to know the byte order * LSBorMSB.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
*
*
*
void extract-short-from-buffer(char buffer[],int Isbjnt start,long *number) {
inti; union short-char-union Icu;
if(lsb = I){ Icti.s-alpha[O] = buffer[start+O]; 1cu.s-alpha[ I ] = buffer[start+l];
] I* ends if lsb = 1 */
if(lsb == O){ lcii s_alplia[O] = buffer[start+l]; 1cu.s-alpha[ I] = buffer[start+O];
} /*ends if Isb= O *I
*number = Icu.s-num;
} I* ends extract-short-from-buffer *I
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* readtiff-header(. . .
* This function reads the header of a TIFF * file and places the needed information into * the struct tiff-header-struct.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
*
*
void read-tiff-lieader(char *file-name,struct tiff-header-struct *image-header) Í
char buffer[ 121, response[80]
FILE *image-file,
int bytes-read, closed, 1 .
J, Isb, not-finished, position,
long bitsgerpixel , image-length, image-width, length-of-field, offsetto-ifd, strip-offset, stibfile,
71
value,
long entry-count, field-type, s-bitsgerpixel, s-image-length. s-iiiiagewidth, s-strip-offset, tag- tw.
image-file = fopen(file-name, " r b ) , if(image-file I = NüLL){
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* Determine if the file uses MSB * first or LSB first
**+************+*********************I
*
*
bytecread = fread(buffer, 1, 8, image-file),
if(buffer[O] == 0x49)
else Isb = I ;
Isb = O;
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* Read the offset to the IFD
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
*
extract-long-from-buffer(buffer, Isb, 4, &offset-to-ifd);
not-finished = I ; while(not-finished){
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . * * Seek to the 1FD and read the * entry-count, ¡.e. the number of * entries in the IFD. *
***+*******+****t******************t*/
position = fseek(image-file, offset-to-ifd, SEEK SET);
bytes-read = fread(buffer, 1,2, image-file); extract-short-from-buffer(buffer, Isb, O,
&entry-count);
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
* Now loop over the directory entries. * Look only for the tags we need. These * are: * LniageLength * Imagewidth * BitsPerPixel(BitsPerSamp1e) * Stripoffset
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
*
*
for(i=O; ¡<entrycount, i++){ bytes-read = fread(buffer, I , 12, image-file); extract-short-from-buffer(buffer, Isb, O,
7 2
&tag-type),
switch(tag-type){
case 255 I* Subfile Type *I extract-short-from-buffer(buffer, Isb, 2,
extract-short-from-buffer(buffer, Isb, 4, &field-type),
&length-of-field), extract-long-from_buffer(buffer, Isb, 8,
&subfile), break.
case 256: I* Imagewidth *I extract-short-frombuffer(buffer, Isb, 2,
extract-short-from-buffer(buffer, Isb, 4,
if(field-type == 3){ extract-short-from-buffer(buffer, Isb, 8,
iniage-width = s-image-width; 1 else extract-long-from-buffer(buffer, Isb, 8,
break;
&field-type);
&length-of-field);
&s-image-width);
&image-width);
case 257: I* ImageLength *I extract-short-from-buffer(buffer, Isb, 2,
extract-short-from-buffer(buffer, Isb, 4,
if(field-type == 3)( extract-short-froin-buffer(buffer, Isb, 8,
&s-image-length); image-length = s-image-length;
1 else extract-loiig-from-buffer(buffer, Isb, 8,
&field-type);
&length-of-field);
&image-length); break:
case 258: /* BitsPerSample */ extract-short-frombuffer(buffer, Isb, 2,
extract-short-from-buffer(buffer, Isb, 4, &field-iype);
&lengthof-field); if(field-type == 3){
extract-short-from_buffer(buffer, Isb, 8,
bits-per-pixel = s-bitsgergixel; } else extract-loiig-from-buffer(buffer, Isb, 8,
break:
&s-bitsgergixel);
&bitsgergixel);
case 273: I* Stripoffset *I extract-short-from-buffer(buffer, Isb, 2,
extract-short-from-buffer(buffer, Isb, 4,
if(field-type == 3){ extract-short-from-buffer(buffer, Isb, 8,
stripoffset = sst r ipoffset ; 1
&field-type);
&length-of-field);
&s-stripoffset);
73
else extract-long-from-buffer(buffer, Isb, 8,
break, &strip-offset),
default- break;
} /* ends switch tag-type */
} /* ends loop over i directory entries */
bytes-read = fread(buffer, 1,4, image-file); extract-loiig-from-buffer(buffer, Isb, O,
if(offset-to-ifd == O) not-finished = O; &offset-to-ifd);
} /* ends while not-finished *I
iniage-lieader->lsb = Isb; iiiiage-lieader->bitsgergixel= bitsgergixel ; image-header->image-length = image-length; iiiiage-header->image-width = image-width; image-header->strip-offset = strip-offset;
closed = fclose(image-file); } /* ends if file opened ok */ else{
priiitf("\nhiTlFF.C> ERROR - could not open " "tiff file"),
position=position; closed=closed; bytes-read=bytes-read; } /* ends read-tiff-header */
}
74
APÉNDICE c MANUAL DE USAURlO
I propósito de este apéndice es el de servir como una guía de referencia para el usuario, en la interacción con el sistema de “Procesamiento Digital E de Imágenes”
La fig. 1. nos muestra la pantalla de presentación que aparece inmediatamente después de haber iniciado la ejecución del programa, para continuar se debe dar clic al cuadro de “OK.
fig. 1.
La fig. 2. podemos llamara la inicialización del sistema, ya que cuando aparece la misma nos muestra todo un menú de opciones disponibles par ala correcta ejecución del programa, en esta figura podemos observar que aparecen también unos iconos “barra de herramientas”, que ayudan a simplificar la labor para el usuario.
75
fig. 2.
fig. 2a.
En la figura 3. podemos observar el sub-menu que contiene la opción de “FILE” (archivo), la cual Únicamente cuenta con la opción de “OPEN” (abrir) esto es porque la aplicación Únicamente hace uso de esta operación al utilizar los archivos. Esta opción también se puede accesar presionando con el Mouse en el icono que tiene la forma de un disco.
76
fig. 3a.
La figura 4 muestra la ventana de selección del archivo que se desea abrir, aquí se puede seleccionar entre imágenes TIFF (Las cuales se utilizaran para el procesamiento de la imagen con CNN, la imagen debe tener un tamaño máximo de 32 x 32 pixeles), y BMP (Las cuales no podrán procesarse, pero sirve para poder visualizar cualquier tipo de imágenes del formato BMP).
77
fig. 4.
Si no se ha abierto ninguna imagen (TIFF) el menú de CNN permanece desactivado. Como se muestra en la fi ura 5.
dlswftm-
fig. 5.
Una vez abierta una imagen TIFF, es posible procesar la imagen mediante el menú de CNN, o presionando el Mouse en el icono del “BICHO”, al hacerlo se presentara una ventana en donde se deberá introducir los parámetros de procesamiento.
78
fig. 6.
Parámetros: DELTA: MAX: Numero máximo de iteraciones que se realizaran. %CONV: El porcentaje mínimo de convergencia del algoritmo. Tol.:
Euler: Utiliza el método de Euler, es el más rápido pero el menos preciso. PC: Predictor Corrector. RK4: Runge Kutta de orden 4.
Ceros: Realiza los cálculos utilizando únicamente ceros. Unos: Realiza los cálculos utilizando únicamente unos. Input: Realiza los cálculos utilizando los datos de la imagen abierta.
Métodos de integración:
Datos:
La imagen 7 muestra la imagen abierta antes de procesar, y a su derecha la imagen ya procesada.
79
fig. 7
La figura 8 muestra el menú de “HELP” (ayuda) el cual contiene dos sub-menus que son: “ABOUT ( acerca de ) el cual muestra una ventana en donde se pueden ver el nombre del programa, y la versión; “Sobre CNN” donde se muestra la ayuda general del sistema (aun no implementada).
80
fig. a.
fig. 8a.
81
IEEE ASSP MAGAZINE Abril 1987.
Image Processing in C. Phillips
CNNA ‘92 “Second International Workshop on Celular Neural Networks and their Applications” Technical University Munich Munich, Germany Octubre 14-16 1992.
IEEE TRANSACTIONS ON CIRCUITS AND SYSTEMS, VOL. 35 No 10 Octubre 1988. “Cellular Neural Networks: APLICATIONS”, LEON O. CHUA, (Fellow IEEE) LIN YANG (Student member, IEEE)
IEEE TRANSACTIONS ON CIRCUITS AND SYSTEMS, VOL. 35 No 10 Octubre 1988. “Cellular Neural Networks: THEORY”, LEON O. CHUA, (Fellow IEEE) LIN YANG (Student member, IEEE)
Fundamentals of Neural Networks Architectures, algorithms and applications Laurene Fausett Prentice Hall, 1994
Artificial Neural Networks: Concept and Theory Pankaj Mehmand Benjamin W. Wah IEEE Computer Society Press, 1992.
82
