universidad de guayaquil -...

UNIVERSIDAD DE GUAYAQUIL

FACULTAD DE CIENCIAS MATEMÁTICAS Y FÍSICAS

CARRERA DE INGENIERÍA EN SISTEMAS

COMPUTACIONALES

“DESARROLLO DE UN SOFTWARE PARA LA

CONSTRUCCIÓN DE REDES NEUROIDALES”

TESIS DE GRADO

Previa a la obtención del Título de:

INGENIERO EN SISTEMAS COMPUTACIONALES

AUTOR:

SILVA MUÑOZ ANDRÉS MIGUEL

TUTOR:

ING. EDUARDO ALVARADO

GUAYAQUIL – ECUADOR

2015

2




COMPUTACIONALES

DESARROLLO DE UN SOFTWARE PARA LA

CONSTRUCCIÓN DE REDES NEUROIDALES

TESIS DE GRADO




TUTOR: ING. EDUARDO ALVARADO


2015

REPOSITORIO NACIONAL EN CIENCIAS Y TECNOLOGÍA

FICHA DE REGISTRO DE TESIS

TÍTULO:"DESARROLLO DE UN SOFWARE PARA LA CONSTRUCCIÓN DE REDES

NEUROIDALES"

AUTOR: ANDRÉS MIGUEL SILVA MUÑOZ REVISORES:

INSTITUCIÓN: UNIVERSIDAD DE GUAYAQUIL FACULTAD: CIENCIAS MATEMÁTICAS Y

FÍSICAS

CARRERA: INGENIERÍA EN SISTEMAS COMPUTACIONALES

FECHA DE PUBLICACIÓN: 8 de Mayo de 2015 N° DE PÁGS.: 91

ÁREA TEMÁTICA: Desarrollo de Software.

PALABRAS CLAVES: Bioinformática, Neurociencias. Redes Neuroidales, desarrollo de software.

RESUMEN: Este trabajo presenta el desarrollo de la interfaz gráfica de un software para simular la

construcción de redes neuroidales. Antes de realizar el desarrollo fue necesario conocer las

herramientas de software que han sido utilizadas para implementar las redes neuroidales, para ello se

establece un marco teórico que describe las herramientas de simulación más importantes para el

desarrollo de modelos matemáticos computacionales entre las cuales tenemos LabView, MATLAB y

HP-VEE. El principal objetivo del proyecto es, El desarrollo de la interfaz gráfica de un software que

permita construir redes neuroidales. La población está representada por el director del programa

PROMEINFO, al cual se le realizo una entrevista. Como hipótesis a probar, se planteó, con el 70% del

desarrollo del software para simular la creación de redes neuroidales, se cumple con los requisitos

esperados por los usuarios finales. Otra de las hipótesis a responder es, si los parámetros utilizados

en este software son los adecuados para poder simular la creación de una red neuroidal. Las variables

de la investigación son, desarrollo de software, simulación de redes neuroidales y herramientas de

desarrollo de software Open Source. La propuesta de desarrollar un software libre estará dirigido para

la comunidad educativa que estén interesadas en estudiar Inteligencia Artificial, Robótica,

Neurociencias, etc. Se considera que el desarrollo de este software será la base para futuras

versiones en el mismo para obtener una herramienta más potente. La Universidad de Guayaquil saldrá

beneficiada con la culminación de este proyecto porque contara con un software gratuito para simular

neuroides reales a través del software de redes neuroidales y de esta manera promover otras ramas

de estudio no tradicionales.

N° DE REGISTRO(en base de datos): N° DE CLASIFICACIÓN: Nº

DIRECCIÓN URL (tesis en la web):

ADJUNTO PDF x SI NO

CONTACTO CON AUTOR:

ANDRÉS MIGUEL SILVA MUÑOZ

Teléfono: 0985823047

E-mail:

[email protected]

CONTACTO DE LA INSTITUCIÓN:


Nombre: Ab. Juan Chávez Atocha

Teléfono: 042307729

APROBACIÓN DEL TUTOR

En mi calidad de Tutor del trabajo de investigación, “DESARROLLO DE UN

SOFTWARE PARA LA CONSTRUCCIÓN DE REDES NEUROIDALES“,

elaborado por el Sr. ANDRÉS MIGUEL SILVA MUÑOZ, egresado de la Carrera

de Ingeniería en Sistemas Computacionales, Facultad de Ciencias

Matemáticas y Físicas de la Universidad de Guayaquil, previo a la obtención

del Título de Ingeniero en Sistemas, me permito declarar que luego de haber

orientado, estudiado y revisado, la Apruebo en todas sus partes.

Atentamente

Ing. Eduardo Alvarado

TUTOR

II

DEDICATORIA

Este proyecto se lo dedico en primer lugar

a Dios por haberme dado la fuerza

necesaria para continuar, a mis padres

Luis Eduardo Silva Tumbaco y María

Luisa Muñoz Fuentes, por su cariño y

comprensión durante todos estos años de

estudio y gracias a su apoyo incondicional

he podido dar un gran paso.

A mis hermanos Raúl, Luis, y María que

siempre han estado apoyándome en

buenos y malos momentos.

Andrés Silva Muñoz.

III

AGRADECIMIENTO

Le agradezco a Dios, por haberme ayudado a

cumplir una de mis metas, a mi familia que con

sus consejos y apoyo incondicional he llegado

a concluir esta etapa de mis estudios. A mis

compañeros que siempre estuvieron para

apoyarme en los buenos y malos momentos.

Andrés Silva Muñoz.

IV

TRIBUNAL DE GRADO

Ing. Eduardo Santos Baquerizo, M.Sc.

DECANO DE LA FACULTAD

CIENCIAS MATEMATICAS Y

FISICAS

Ing. Harry Luna Aveiga, M.Sc.

DIRECTOR (E)

CISC, CIN

Ing. Eduardo Alvarado

DIRECTOR DE TESIS

Ing. Pablo Echeverría

PROFESOR DEL ÁREA -

TRIBUNAL

Ing. Mary Cabanilla Ab. Juan Chávez A.

PROFESOR DEL ÁREA – SECRETARIO

TRIBUNAL

VI

DECLARACIÓN EXPRESA

“La responsabilidad del contenido de esta

Tesis de Grado, me corresponden

exclusivamente; y el patrimonio intelectual de

la misma a la UNIVERSIDAD DE

GUAYAQUIL”

ANDRÉS MIGUEL SILVA MUÑOZ

VII




COMPUTACIONALES

DESARROLLO DE UN SOFTWARE

PARA LA CONSTRUCCIÓN DE

REDES NEUROIDALES

Tesis de Grado que se presenta como requisito para optar por el título de

INGENIERO en SISTEMAS COMPUTACIONALES

Autor/a: Andrés Miguel Silva Muñoz

C.I. 0921436556

Tutor: Ing. Eduardo Alvarado

Guayaquil, Mayo de 2015

VIII

CERTIFICADO DE ACEPTACIÓN DEL TUTOR

En mi calidad de Tutor de Tesis de Grado, nombrado por el Consejo

Directivo de la Facultad de Ciencias Matemáticas y Físicas de la Universidad

de Guayaquil.

CERTIFICO:

Que he analizado el proyecto de grado presentado por el/la

estudiante ANDRÉS MIGUEL SILVA MUÑOZ, como requisito previo para

optar por el título de Ingeniero en Sistemas Computacionales cuyo problema

es:

DESARROLLO DE UN SOFTWARE PARA LA CONSTRUCCIÓN DE

REDES NEUROIDALES

Considero aprobado el trabajo en su totalidad.

Presentado por:

Silva Muñoz Andrés Miguel C.I: 0921436556


Guayaquil, Mayo de 2015

IX




COMPUTACIONALES

Autorización para Publicación de Tesis en Formato Digital

1. Identificación de la Tesis

Nombre Alumno: ANDRÉS MIGUEL SILVA MUÑOZ

Dirección: Colinas de la alborada Mz. 786 sol. 21

Teléfono: 0985823047 E-mail: [email protected]

Facultad: Ciencias Matemáticas y Físicas

Carrera: Ingeniería en Sistemas Computacionales

Título al que opta: Ingeniero en Sistemas Computacionales

Profesor guía: Ing. Eduardo Alvarado Unamuno

Título de la Tesis: Desarrollo de un software para la construcción de redes

neuroidales.

Temas Tesis: Bioinformática, Neurociencias, Redes Neuroidales

2. Autorización de Publicación de Versión Electrónica de la Tesis

A través de este medio autorizo a la Biblioteca de la Universidad de Guayaquil y a la

Facultad de Ciencias Matemáticas y Físicas a publicar la versión electrónica de esta

tesis.

Publicación electrónica:

Inmediata X Después de 1 año

Firma Alumno:

3. Forma de envío:

El texto de la Tesis debe ser enviado en formato Word, como archivo .Doc. O .RTF y

.Puf para PC. Las imágenes que la acompañen pueden ser: .gis, .pg. O .TIFF.

DVD ROM CD-ROM X

X

ÍNDICE GENERAL

APROBACIÓN DEL TUTOR .......................................................................... I

DEDICATORIA .............................................................................................. II

AGRADECIMIENTO ..................................................................................... III

CERTIFICADO DE ACEPTACIÓN DEL TUTOR ....................................... VIII

ÍNDICE GENERAL ........................................................................................ X

ÍNDICE DE TABLAS ................................................................................... XII

ÍNDICE DE FIGURAS ................................................................................. XIII

RESUMEN ................................................................................................... XV

ABSTRACT ................................................................................................ XVI

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

CAPÍTULO I................................................................................................... 3

EL PROBLEMA .......................................................................................... 3 1.1. PLANTEAMIENTO DEL PROBLEMA .............................................. 3

1.1.1. UBICACIÓN DEL PROBLEMA EN UN CONTEXTO ................... 3 1.1.2. SITUACIÓN CONFLICTO NUDOS CRÍTICOS ............................ 4 1.1.3. CAUSAS Y CONSECUENCIAS DEL PROBLEMA ...................... 4 1.1.4. DELIMITACIÓN DEL PROBLEMA ............................................... 5 1.1.5. FORMULACIÓN DEL PROBLEMA .............................................. 6 1.1.6. EVALUACIÓN DEL PROBLEMA ................................................. 6

1.2. OBJETIVOS .................................................................................... 7 1.2.1. OBJETIVO GENERAL ................................................................. 7 1.2.2. OBJETIVOS ESPECÍFICOS ........................................................ 7

1.3. ALCANCES DEL PROBLEMA ......................................................... 8 1.4. JUSTIFICACIÓN E IMPORTANCIA ................................................. 8

CAPÍTULO II .................................................................................................. 9

MARCO TEÓRICO ..................................................................................... 9 2.1 ANTECEDENTES DEL ESTUDIO ....................................................... 9 2.2 FUNDAMENTACIÓNTEÓRICA ........................................................ 11

2.2.1 EL DOLOR ................................................................................. 11 2.2.2 ALGUNAS TEORÍAS SOBRE EL DOLOR ................................. 13 2.2.3 LAS VÍAS DEL DOLOR ............................................................. 17 2.2.4 IMPLEMENTACIÓN DEL MODELO NEUROIDAL..................... 24 2.2.5 DEFINICIÓN DE SOFTWARE ................................................... 25 2.2.6 TIPOS DE SOFTWARE ............................................................. 27 2.2.7 LICENCIA PÚBLICA GENERAL GNU ....................................... 31 2.2.8 HERRAMIENTAS DE SOFTWARE PARA CREAR REDES NEUROIDALES .................................................................................... 32 2.2.8.1 LABVIEW (Laboratory Virtual Instrumentation Engineering workbench) ........................................................................................... 33 2.2.8.2 HP VEE (Hewlett-Packard Visual Engineering Environment) . 36

XI

2.2.8.3 MATLAB (Matrix Laboratory) .................................................. 37 2.2.9 PLATAFORMA PARA DESARROLLOS DE APLICACIONES EN JAVA 40 2.2.9.1 ECLIPSE ................................................................................ 40

2.3 FUNDAMENTACIÓN LEGAL ............................................................ 42 2.3.1 De la ciencia y tecnología .......................................................... 42 2.3.2 Ciencia, tecnología, innovación y saberes ancestrales .............. 43 2.3.3 Decreto presidencial No 1014 .................................................... 44

2.4 HIPÓTESIS PREGUNTAS A CONTESTARSE ................................. 44 2.5 VARIABLES DE LA INVESTIGACIÓN............................................... 45 2.6 DEFINICIONES CONCEPTUALES ................................................... 45

CAPÍTULO III ............................................................................................... 46

METODOLOGÍA ....................................................................................... 46 3.1 DISEÑO DE LA INVESTIGACIÓN ..................................................... 46 3.2 MODALIDAD DE LA INVESTIGACIÓN ............................................. 46 3.3 TIPO DE INVESTIGACIÓN ............................................................... 46 3.4 POBLACIÓN Y MUESTRA ................................................................ 46

3.4.1 POBLACIÓN .............................................................................. 46 3.4.2 MUESTRA ................................................................................. 47

3.5 OPERACIONALIZACIÓN DE VARIABLES ....................................... 47 3.6 INSTRUMENTOS DERECOLECCIÓN DE DATOS ........................... 48

3.6.1 TÉCNICAS E INSTRUMENTOS DE LA INVESTIGACIÓN ........ 48 3.7 VALIDACIÓN .................................................................................... 48 3.8 PROCEDIMIENTOS DE LA INVESTIGACIÓN .................................. 49 3.9 RECOLECCIÓN DE LA INFORMACIÓN ........................................... 50 3.10 PROCESAMIENTO Y ANÁLISIS ................................................... 50

CAPÍTULO IV .............................................................................................. 54

MARCO ADMINISTRATIVO ..................................................................... 54 4.1 CRONOGRAMA DE ACTIVIDADES ................................................. 54 4.2 RECURSOS ...................................................................................... 54 4.3 PRESUPUESTO ............................................................................... 55

CAPÍTULO V ............................................................................................... 56

CONCLUSIONES Y RECOMENDACIONES ............................................ 56 6.1 CONCLUSIONES ............................................................................. 56 6.2 RECOMENDACIONES ..................................................................... 57

BIBLIOGRAFÍA ........................................................................................... 58

ANEXOS ...................................................................................................... 69

LA ENTREVISTA ...................................................................................... 69 CRONOGRAMA ....................................................................................... 72

XII

ÍNDICE DE TABLAS

Tabla 1: Causas y consecuencias del problema. ................................................. 5

Tabla 2: Delimitación del problema. ....................................................................... 5

Tabla 3: Receptores cutáneos y axones asociados. ......................................... 19

Tabla 4: Versiones de ECLIPSE ........................................................................... 41

Tabla 5: Tabla de muestra ..................................................................................... 47

Tabla 6: Matriz de operacionalización de variables. .......................................... 47

Tabla 7: Cronograma .............................................................................................. 54

Tabla 8: Detalles de egresos del proyecto. ......................................................... 55

Tabla 9: Detalles de ingresos del proyecto. ........................................................ 55

XIII

ÍNDICE DE FIGURAS

Figura 1: Etapas de la nocicepción y estructuras neuroanatómicas

asociadas. ................................................................................................................. 12

Figura 2: Esquemas del sistemas de la puerta de control. ............................... 16

Figura 3: Representación esquemática del asta dorsal de la medula espinal.

.................................................................................................................................... 23

Figura 4: Formula de tren de impulsos de frecuencia modulada. ................... 24

Figura 5: Esquema del Neuroide. ......................................................................... 25

Figura 6: Logo de LabView. ................................................................................... 33

Figura 7: Menú de controles de LabView. ........................................................... 34

Figura 8: Menú de funciones de LabView ........................................................... 34

Figura 9: Ejecución de un programa en LabView. ............................................. 35

Figura 10: Logo de HP-VEE. ................................................................................. 36

Figura 11: Interfaz del software HP-VEE. ........................................................... 37

Figura 12: Logo de MATLAB. ................................................................................ 37

Figura 13: Interfaz del software MATLAB. .......................................................... 38

Figura 14: Importación de archivos en MATLAB. .............................................. 39

Figura 15: Visualización de gráficos en MATLAB. ............................................. 39

Figura 16: Logo de ECLIPSE. ............................................................................... 40

Figura 17: Interfaz de usuario de ECLIPSE. ....................................................... 42

Figura 18: Detalles de actividades del proyecto. ............................................... 72

Figura 19: Diagrama de Gantt del proyecto. ....................................................... 73

XIV



CARRERA DE INGENIERÍA EN SISTEMAS COMPUTACIONALES

DESARROLLO DE UN SOFTWARE

PARA LA CONSTRUCCIÓN DE

REDES NEUROIDALES

Resumen

El siguiente trabajo presenta el desarrollo de la interfaz gráfica de un

software para simular la construcción de redes neuroidales. Antes de realizar

el desarrollo fue necesario conocer las herramientas de software que han

sido utilizadas para implementar las redes neuroidales, para ello se

establece un marco teórico que describe las herramientas de simulación más

importantes para el desarrollo de modelos matemáticos computacionales

entre las cuales tenemos LabView, MATLAB y HP-VEE. El principal objetivo

del proyecto es, El desarrollo de la interfaz gráfica de un software que

permita construir redes neuroidales. La población está representada por el

director del programa PROMEINFO, al cual se le realizo una entrevista.

Como hipótesis a probar, se planteó, con el 70% del desarrollo del software

para simular la creación de redes neuroidales, se cumple con los requisitos

esperados por los usuarios finales. Otra de las hipótesis a responder es, si

los parámetros utilizados en este software son los adecuados para poder

simular la creación de una red neuroidal. Las variables de la investigación

son, desarrollo de software, simulación de redes neuroidales y herramientas

de desarrollo de software Open Source. La propuesta de desarrollar un

software libre estará dirigido para la comunidad educativa que estén

interesadas en estudiar Inteligencia Artificial, Robótica, Neurociencias, etc.

Se considera que el desarrollo de este software será la base para futuras

versiones en el mismo para obtener una herramienta más potente. La

Universidad de Guayaquil saldrá beneficiada con la culminación de este

proyecto porque contara con un software gratuito para simular neuroides

reales a través del software de redes neuroidales y de esta manera

promover otras ramas de estudio no tradicionales.

Autor: Andrés Silva Muñoz


XV






Autor/a: Andrés Miguel Silva Muñoz

Tutor/a: Ing. Eduardo Alvarado

Se desarrollará la interfaz gráfica de un software en el cual se podrá simular gráficamente la creación de una red neuroidal.

RESUMEN

El siguiente trabajo presenta el desarrollo de la interfaz gráfica de un software para simular la construcción de redes neuroidales. Antes de realizar el desarrollo fue necesario conocer las herramientas de software que han sido utilizadas para implementar las redes neuroidales, para ello se establece un marco teórico que describe las herramientas de simulación más importantes para el desarrollo de modelos matemáticos computacionales entre las cuales tenemos LabView, MATLAB y HP-VEE. El principal objetivo del proyecto es, El desarrollo de la interfaz gráfica de un software que permita construir redes neuroidales. La población está representada por el director del programa PROMEINFO, al cual se le realizo una entrevista. Como hipótesis a probar, se planteó, con el 70% del desarrollo del software para simular la creación de redes neuroidales, se cumple con los requisitos esperados por los usuarios finales. Otra de las hipótesis a responder es, si los parámetros utilizados en este software son los adecuados para poder simular la creación de una red neuroidal. Las variables de la investigación son, desarrollo de software, simulación de redes neuroidales y herramientas de desarrollo de software Open Source. La propuesta de desarrollar un software libre estará dirigido para la comunidad educativa que estén interesadas en estudiar Inteligencia Artificial, Robótica, Neurociencias, etc. Se considera que el desarrollo de este software será la base para futuras versiones en el mismo para obtener una herramienta más potente. La Universidad de Guayaquil saldrá beneficiada con la culminación de este proyecto porque contara con un software gratuito para simular neuroides reales a través del software de redes neuroidales y de esta manera promover otras ramas de estudio no tradicionales.

XVI






ABSTRACT

This work presents the development of GUI software to simulate the

construction of networks neuroidales. Before making the development was

necessary to know the software tools that have been used to implement

neuroidales networks, to do a theoretical framework that describes the most

important simulation tools for the development of computational

mathematical models among which are set LabView, MATLAB and HP-VEE.

The main objective of the project is development of the graphical interface of

a software that can build networks neuroidales. The population is

represented by the director of PROMEINFO program, which underwent an

interview. As a hypothesis to be tested, was raised with 70% of software

development for networking simulate neuroidales, it meets the requirements

expected by end users. Another hypothesis to be answered is whether the

parameters used in this software are adequate to simulate the creation of a

network neuroidal. The research variables are software development,

network simulation tools neuroidales and development of Open Source

software. The proposal to develop a free software will be directed to the

educational community who are interested in studying Artificial Intelligence,

Robotics, Neuroscience, etc. It is considered that the development of this

software will be the basis for future versions of the same for a more powerful

tool. The University of Guayaquil will benefit with the completion of this

project because it will feature a free software to simulate real neuroides

through neuroidales network software and thus promote other branches of

non-traditional study.

1

INTRODUCCIÓN El programa continuo de investigaciones médico informáticas PROMEINFO,

de la Universidad de Guayaquil es un programa que contempla una

multiplicidad de trabajos de investigación y desarrollo en los campos de la

informática médica, bioinformática, telemedicina, etc.

El programa PROMEINFO busca integrar las ciencias de la salud, con la

ingeniería y computación para optimizar el funcionamiento del sistema

sanitario y aportar nuevas soluciones e instrumentos al tratamiento de la

salud promoviendo la investigación tecnológica y social en el marco del

cambio de la matriz productiva y de la construcción de la sociedad del

conocimiento.

Entre estos trabajos de investigación existe un gran interés en desarrollar

modelos de resolución de problemas que no pueden ser descritos fácilmente

mediante un enfoque de algoritmos tradicionales. Estos modelos tienen su

origen a la emulación de sistemas nerviosos biológicos.

El uso de sistemas inteligentes que puedan aprender de la experiencia se

hace necesario en algunos problemas donde los métodos convencionales no

ofrecen resultados satisfactorios. Entre las alternativas técnicas disponibles,

las redes neuronales artificiales (RNA) se utilizan cada vez más en el campo

de la medicina.

La creciente evolución de tecnologías para el desarrollo de herramientas de

software de bajo costo que estén orientadas a simular procesos hace posible

tener a disposición potentes herramientas para el desarrollo de sistemas

expertos, frameworks que permiten el desarrollo de plataformas de

aprendizaje de temas relacionados con Instrumentación, adquisición de

datos, sistemas de regulación y control, etc.

http://www.promeinfo.hol.es/

2

En el campo de la electrónica o para automatizar procesos a nivel

profesional, se utiliza una serie de herramientas como MATLAB, LabView,

HP VEE, C++, MATRIXx, etc. pero para adquirir alguna de estas

herramientas se debe invertir en algunos de los casos mucho dinero, y se

requiere de conocimientos de matemáticas para que no se dificulte el

entendimiento de dichos programas al momento de ingresar parámetros.

Estas herramientas han sido diseñada bajo la misma filosofía, en la cuales

mediante un entorno gráfico se pueden realizar conexiones de distintos

bloques parametrizables para lograr obtener un modelo matemático

deseado.

Los lenguajes de programación orientados a objetos como Java por ejemplo,

son herramientas que permiten integrar bloques de código en nuestra

aplicación con lo cual se multiplica su potencia.

En este proyecto realizaremos el diseño de un software libre que permitirá

simular la creación de una red neuroidal mediante un entorno gráfico

desarrollado con herramientas Open Source con la finalidad de contar con

un software que esté disponible para la comunidad.

3

CAPÍTULO I

EL PROBLEMA

1.1. PLANTEAMIENTO DEL PROBLEMA

1.1.1. UBICACIÓN DEL PROBLEMA EN UN CONTEXTO

El uso de modelos matemáticos-computacionales para el estudio de

fenómenos biológicos en su mayoría se han basado en el Sistema de la

Puerta de Control (SPC) (Melzack & Wall, 1965) con el fin de representar la

circuitería neuronal que participa en el procesamiento de la información

sensorial. Como resultado, los estudios sobre modelaje computacional del

dolor basado en este esquema, han heredado un conjunto de imprecisiones

anatómicas y funcionales que les resta veracidad y limita su aplicación.

El novedoso modelo implementado por Erick Argüello, denominado neuroide

(Arguello, 2012), fue desarrollado para realizar operaciones básicas que

simulen el comportamiento de las células nerviosas en especial las que

están asociadas a la percepción del dolor para crear una versión más

realista del SPC. Para el desarrollo de este modelo, el autor (Argüello Prada,

2013) indica que utilizo el software LabView 10.0 con la finalidad de asignar

en bloques de ejecución cada una de las operaciones que realiza el neuroide

obteniendo resultados de un comportamiento muy similar al mostrado por las

neuronas reales.

La inexistencia de un de software propio de libre distribución para poder

realizar pruebas experimentales de este nuevo modelo computacional, es un

motivo para que La Dirección de Investigaciones y Proyectos Académicos

(DIPA) proponga en su programa PROMEINFO, desarrollar un software para

construir redes neuroidales basándose en el modelo computacional del dolor

implementado por Erick Argüello.

PROMEINFO es el Programa Continuo de Investigaciones Médico

Informáticas de la Universidad de Guayaquil. Es un programa

multidisciplinario, multifacultades y multiinstitucional, que contempla una

http://www.promeinfo.hol.es/

4

multiplicidad de trabajos de investigación, desarrollo e innovación en los

campos de informática médica, bioinformática y telemedicina.

Este programa forma parte de los proyectos emblemáticos de la Dirección de

Investigaciones y Proyectos Académicos (DIPA) de la Universidad de

Guayaquil. El objeto de dicho programa es la integración de las ciencias de

la salud, con la ingeniería y computación para optimizar el funcionamiento

del sistema sanitario y aportar nuevas soluciones e instrumentos al

tratamiento de la salud.

El presente proyecto de tesis estará enfocado completamente en la

programación de la interfaz gráfica del software, y la programación de cada

uno de los elementos principales que representarán una red neuroidal.

1.1.2. SITUACIÓN CONFLICTO NUDOS CRÍTICOS

La herramienta que se utilizó para la implementación de este modelo

matemático-computacional es el software LabView (Versión 10.0), que

puede ser adquirido por un precio aproximado de $2750. Otras herramientas

utilizadas por el autor para implementar su modelo neuroidal (Argüello

Prada, 2013) son MATLAB de MathWorks, HP-VEE de Hewlett Packard, y

Visual C++.

El costo por licencia de las herramientas informáticas antes mencionadas es

muy elevado, por lo que resulta casi imposible para alguna persona o

institución adquirir este tipo de software ya sea para propósitos investigativos

o aprendizaje.

1.1.3. CAUSAS Y CONSECUENCIAS DEL PROBLEMA

A continuación se describen causas y efectos del problema mencionado.

5

CAUSA EFECTO

Las redes neuroidales son un

nuevo modelo computacional del

sistema nervioso.

Inexistencia de un software

gratuito para crear redes

neuroidales.

Pocos conocimientos de

programación para desarrollar un

software para simular las redes

neuroidales.

El desarrollo de un software propio

se vuelve complejo.

El software que se utilizó para la

implementación del modelo

computacional tiene un costo

muy elevado.

No se podrán realizar las pruebas

para fines educativos o futuras

investigaciones.

Falta de presupuesto para

adquirir un software

especializado para realizar

pruebas del modelo neuroidal.

Los interesados desisten en

realizar las pruebas del modelo

neuronal.

Escaso material bibliográfico. Se dificulta a los desarrolladores

encontrar material de referencia

para la implementación de los

programas de simulación.

Algoritmos y funciones

complejas.

Tiende a confundir a los

desarrolladores de software.

Tabla 1: Causas y consecuencias del problema.

Autor: Andrés Silva Muñoz.

1.1.4. DELIMITACIÓN DEL PROBLEMA

Campo Informática.

Área Desarrollo de software

Aspecto Bioingeniería, Biofísica, Neurociencias

Tema Desarrollo de un software para la creación de redes neuroidales.

Tabla 2: Delimitación del problema.

Autor: Andrés Silva Muñoz.

6

1.1.5. FORMULACIÓN DEL PROBLEMA

¿El desarrollo de un aplicativo de simulación de redes neuroidales utilizando

software libre, ayudará a promover la investigación en esta rama de la

Bioingeniería?

1.1.6. EVALUACIÓN DEL PROBLEMA

Los aspectos generales de evaluación son:

Delimitado:

El presente problema se delimitará a la entrega de un prototipo para simular

gráficamente la creación de una red neuroidal.

Claro:

El presente proyecto se enfoca en presentar una interfaz gráfica que

consiste en representar gráficamente los neuroides y sus conexiones.

Evidente:

El problema tiene esta característica por qué no existe un software gratuito

para simular la creación de redes neuroidales.

Relevante:

El problema tiene esta característica porque es de gran importancia para la

comunidad educativa que se dedica a realizar estudios del comportamiento

de las neuronas pero no cuentan con una herramienta tecnológica de fácil

acceso y costo.

Original:

El planteamiento del desarrollo de un software para crear redes neuroidales

es novedoso para el área de investigación del DIPA, por el motivo que no se

ha implementado un software con esté enfoque.

7

Factible:

El desarrollo de la primera entrega del software para crear redes neuroidales

será de fácil uso para las personas que deseen utilizarlo.

Identifica los productos esperados:

El producto final que se espera es una solución tecnológica que le permita

simular la creación de redes neuroidales.

1.2. OBJETIVOS

1.2.1. OBJETIVO GENERAL

Desarrollar la interfaz gráfica para un software que permita construir redes

neuroidales, basado en el modelo computacional para el estudio del dolor

implementado por Erick Argüello (Argüello Prada, 2013).

1.2.2. OBJETIVOS ESPECÍFICOS

Una vez definido nuestro objetivo general es necesario alcanzarlo mediante

los siguientes objetivos específicos:

Analizar la funcionalidad del software que fue utilizado en la

implementación del modelo computacional para el estudio del dolor.

Identificar cuáles serán los gráficos que representarán a los circuitos

neuronales en el software a desarrollar.

Definir cuáles serán las opciones que presentará nuestro software:

barra de menú, barra de herramientas, barra de estado, etc.

Desarrollar el entorno gráfico del software.

Simular la creación de los elementos definidos anteriormente para

representar la construcción de una red neuroidal.

8

1.3. ALCANCES DEL PROBLEMA

El presente proyecto estará delimitado por los siguientes alcances:

Desarrollar en Java una aplicación de escritorio para construir redes

neuroidales.

La generación de un neuroide debe ser parametrizable.

Representar gráficamente una red neuroidal.

1.4. JUSTIFICACIÓN E IMPORTANCIA

La implementación de un nuevo modelo neuronal para el estudio del dolor

consiste en crear una red cuya topología refleja los patrones de conectividad

que exhiben los circuitos neuronales encargados de procesar la información

sensorial.

El desarrollo e implementación de un modelo neuronal novedoso y

especialmente enfocado en las propiedades funcionales de las células

nerviosas, tales como el umbral de activación y la función estímulo-

respuesta, haría posible, no sólo incluir elementos adicionales en el

esquema propuesto por Melzack y Wall, y así crear una versión más realista

del SPC, sino también formular algunas hipótesis sobre la influencia que

podría ejercer la heterogeneidad de los circuitos sensoriales en la

modulación del umbral doloroso.

La presente propuesta consiste en el desarrollo de un software que permitirá

simular gráficamente la construcción de una red neuroidal que podría

conducir a una mejor comprensión de cómo trabaja el sistema nervioso.

Este trabajo servirá de base para futuras mejoras o adaptaciones a los

procesos implementados. De esta forma, sería posible ampliar el

conocimiento que se tiene en lo que concierne a estos fenómenos.

9

CAPÍTULO II

MARCO TEÓRICO

2.1 ANTECEDENTES DEL ESTUDIO

La mayoría de modelos computacionales para el estudio del dolor se han

apoyado en la teoría de la puerta de control (TPC) (Melzack & Wall, 1965)

para explicar de qué forma se procesa la información asociada a los

estímulos nocivos. Algunos de estos trabajos (Britton, Chaplain, &

Skevington, 1996) (Prince, Campbell, Picton, & Turner, 2004) (Zhu & Lu,

2010) emplean de manera explícita las ecuaciones matemáticas planteadas

por Britton y Skevington (Britton & Skevington, 1989), mientras que otros

(Agi, Ozgen, & Purali, 2010) se enfocan más en preservar la circuitería

neuronal que conforma el SPC. Incluso, existen modelos basados en RNA

(de Sousa & de Jesus Torres, 2013) (Haeri, Asemani, & Gharibzadeh, 2003)

(Minamitami & Hagita, 1981) que utilizan los postulados de Melzack y Wall

como criterios de entrenamiento, para luego predecir la aparición del dolor

ante un patrón específico de estimulación.

Parte de la complejidad inherente al fenómeno del dolor, radica en la

elevada heterogeneidad de la circuitería presente en el asta dorsal de la

médula espinal. En base a esto, varios esfuerzos se han llevado a cabo por

esclarecer los patrones de conectividad de las neuronas que residen,

específicamente, en la región superficial del asta dorsal (RSAD), puesto que

es allí donde mayormente convergen las terminaciones de los aferentes

primarios nociceptivos (Todd, Neuronal circuitry for pain processing in the

dorsal horn, 2010) (Wu, Wang, Li, Wang, Feng, & Li, 2010).Trabajos

recientes (Zeilhofer, Wildner, & Yévenes, 2012) (Zheng, Lu, & Perl, 2010)

han propuesto nuevos esquemas circuítales, en virtud de la importancia de

este aspecto en el procesamiento de la información vinculada a la

experiencia dolorosa (Zheng, Lu, & Perl, 2010). Sin embargo, no había

estudios sobre modelaje computacional del dolor que ofrezcan una

representación más realista de la circuitería del asta dorsal; por el contrario,

casi todos los estudios de este tipo recurren al SPC. En consecuencia, estas

10

implementaciones heredan las imprecisiones funcionales del esquema de

SPC propuesto por Melzack y Wall, lo que al mismo tiempo, les resta

veracidad y limita su aplicación.

Otro enfoque consistía en la utilización de modelos neuronales

computacionalmente más eficientes, como el de McCulloch y Pitts

(McCulloch & Pitts, 1943), para incluir un mayor número de unidades y así

construir una red mucho más compleja (de Sousa & de Jesus Torres, 2013)

(Haeri, Asemani, & Gharibzadeh, 2003) (Minamitami & Hagita, 1981). Por

otra parte, un modelo neuronal tan simple no permite la adecuada

caracterización de las diferentes neuronas que codifican, transmiten y

modulan los impulsos nociceptivos, específicamente, en lo que se refiere a

sus aspectos funcionales, tales como el umbral de activación y la función

estímulo-respuesta. Adicionalmente, estas redes tampoco reflejan las

conexiones que existen entre estas células, algunas de las cuales ya han

sido identificadas experimentalmente (Lu & Perl, 2003) (Lu & Perl, 2005)

(Yasaka, Tiong, Hughes, Ridell, & Todd, 2010) (Zheng, Lu, & Perl, 2010).

La implementación de redes neuroidales se basó, al igual que estudios

previos, en el SPC, pero sin utilizar estímulos diseñados específicamente

para cada tipo de aferente (nociceptivo y no nociceptivo); en su lugar, ambos

tipos de aferente fueron estimulados simultáneamente con una señal cuya

amplitud se incrementaba en forma progresiva. Por otro lado, la aparente

ausencia de registros experimentales que permitiesen comparar las curvas

FI, pertenecientes a los aferentes nociceptivos y no nociceptivos, hizo

posible formular algunas hipótesis sobre la apariencia que tendrían estas

curvas en el caso de las fibras Aβ y, eventualmente, emplear neuroides para

construir dos modelos de este tipo de fibra: uno cuya curva FI tuviese una

pendiente mucho más pronunciada que la observada en curvas de fibras C,

y otro con una curva FI capaz de alcanzar un plateau, o meseta, para

elevadas intensidades de estimulación. Se tomaron valores medios de

umbral y curvas FI experimentales, reportados por otros autores. A partir de

las simulaciones, se concluyó que la experiencia dolorosa únicamente es

11

posible si la respuesta de los mecanorreceptores se satura al incrementarse

la intensidad de la estimulación, sugiriendo que las variaciones en el umbral

de percepción del dolor podrían estar vinculadas a las alteraciones de las

curvas FI que exhiben los aferentes primarios. Asimismo, se observó que no

existe una relación estricta entre la activación de los nociceptores y la

sensación dolorosa, y que las fibras Aβ no sólo inhiben la transmisión de los

impulsos nociceptivos, sino que también actúan a favor de la misma para

cierto rango de intensidades, un par de aspectos para los cuales existe

evidencia experimental y que, aun así, han sido descartados por estudios

previos sobre modelaje computacional del dolor.

En los últimos años el software libre se ha convertido en un tema recurrente

en la educación. Quizá la razón más plausible es la decisión de las

autoridades educativas de varias comunidades autónomas de implantar de

manera progresiva el software libre en el sistema educativo y de crear sus

propias distribuciones Linux para centros de Primaria y Secundaria

2.2 FUNDAMENTACIÓNTEÓRICA

2.2.1 EL DOLOR

El dolor se define como "una experiencia sensorial y emocional

desagradable, asociada a un daño tisular real o potencial, o descrita en

términos de ese daño" (Merskey & Bogduk, 1994). Según el evento o

mecanismo desencadenante, esta experiencia puede clasificarse en varios

tipos (Cervero & Laird, 1991) (Costigan, Scholz, & Woolf, 2009). Por

ejemplo, el dolor nociceptivo es aquel que cumple con una función protectora

y que, en general, no persiste más allá de la duración del estímulo nocivo,

como el que surge a raíz de un leve pinchazo. Esta clase de dolor es

consecuencia de la nocicepción, un proceso neurobiológico cuyas etapas se

resumen en la Figura No1 y que implica la activación de receptores capaces

de detectar los estímulos nocivos, llamados nociceptores (Basbaum,

Bautista, Scherrer, & Julius, 2009). Sin embargo, la activación de los

12

nociceptores no conduce necesariamente a la percepción del dolor, aun

cuando ambos fenómenos pueden ser provocados por aquellos estímulos

que representan una amenaza.

Si se produce una lesión tisular, ocurre entonces una sensibilización en el

área afectada y sus adyacencias, lo que se traduce en una respuesta

amplificada ante estímulos de intensidad leve o moderada. En este caso, la

experiencia dolorosa está relacionada con los procesos de reparación que

se están llevando a cabo y se le conoce como dolor inflamatorio (Cervero &

Laird, 1991) (Costigan, Scholz, & Woolf, 2009). Normalmente, este tipo de

dolor desaparece una vez que el tejido ha sanado. No obstante, si el daño

tuvo lugar a nivel del sistema somatosensorial, la estructura y función de

éste se alteran en respuesta a la agresión, tal que el dolor es capaz de

manifestarse en ausencia de estimulación y sus cualidades discriminativo-

sensitivas, tales como intensidad y duración, se ven patológicamente

distorsionadas. Cuando esto ocurre, se habla entonces de dolor neuropático

(Cervero & Laird, 1991) (Costigan, Scholz, & Woolf, 2009).

Figura 1: Etapas de la nocicepción y estructuras neuroanatómicas asociadas.

Fuente: Tesis doctoral de Erick Argüello.

13

2.2.2 ALGUNAS TEORÍAS SOBRE EL DOLOR

Son muchas las teorías que se han formulado con el propósito de explicar

los mecanismos subyacentes a la aparición del dolor (Moayedi & Davis,

2013) (Perl, 2007). A continuación serán revisadas, específicamente,

aquellas que fueron concebidas a partir del siglo XIX, aun cuando los

intentos por conceptualizar la experiencia dolorosa datan desde hace siglos,

e incluso, milenios.

2.2.2.1 Teoría de la Intensidad

Inicialmente propuesta por el neurólogo alemán, Wilhelm Erb (Erb, 1874),

esta teoría sostiene que el dolor es resultado de la estimulación vigorosa y

excesiva de los mismos receptores que generan otras sensaciones (Moayedi

& Davis, 2013) (Perl, 2007). Años atrás se habían realizado experimentos

con pacientes sifilíticos, quienes reportaron sufrir un dolor insoportable en

respuesta a una estimulación táctil repetitiva (60-600 veces/s), cuya

intensidad era inferior al umbral de percepción (Moayedi & Davis, 2013).

Tales resultados fueron reproducidos empleando diferentes tipos de estímulo

(mecánico, térmico y químico), incluida la estimulación eléctrica. Valiéndose

de esta evidencia, Arthur Goldscheider (Goldscheider, 1894) sugirió que

múltiples estímulos podían converger sobre la materia gris de la médula

espinal, y así evocar la experiencia dolorosa. De esta forma, la hipótesis que

concebía al dolor como una modalidad sensorial específica fue descartada,

lo cual a su vez, permitió cuestionar la existencia de una subdivisión del

sistema nervioso, capaz de codificar, transmitir y procesar los estímulos

lesivos.

2.2.2.2 Teoría de la Especificidad

Durante las últimas dos décadas del siglo XIX, varios experimentos llevados

a cabo por Max von Frey (von Frey, 1894), Arthur Goldscheider

(Goldscheider, 1884) y Magnus Blix (Blix, 1884), demostraron que las

sensaciones de calor, frío, presión y dolor, eran evocadas a partir de la

estimulación de ciertos puntos sobre la piel, distribuidos a modo de mosaico,

y llamados hot spots (o centros activos). Al estimular cada uno de estos

puntos mediante el uso de pequeñas probetas, fue posible generar

14

diferentes experiencias sensoriales en los sujetos de prueba. Estos

resultados sugerían la existencia de varios tipos de terminaciones nerviosas

estructuralmente definidas y específicas para cada sensación. Aun así, hubo

objeción en reconocer al dolor como una modalidad sensorial, ya que el

mismo era evocado por distintos tipos de estímulo (mecánico, térmico y

químico).

A principios del siglo XX, Charles Scott Sherrington observó que la

experiencia dolorosa solía estar asociada a las lesiones tisulares, y

consideró que un estímulo capaz de infligir daño merecía ser distinguido de

los demás, sin importar su carácter físico (Perl, 2007). Basándose en la

función protectora del arco reflejo, Sherrington propuso la existencia de un

grupo específico de células nerviosas, cuya activación podía provocar dolor,

y a las que llamó nociceptores (Sherrington, 1906). Este término sería

eventualmente asignado a todos aquellos receptores sensoriales, capaces

de codificar estímulos catalogados como nocivos (Loeser & Treede, 2008).

Varias décadas después, tanto los descubrimientos de aferentes primarios

mielinizados que sólo respondían a estímulos mecánicos nocivos (Burgess &

Perl, 1967), como de nociceptores polimodales y mecanorreceptores con un

elevado umbral de activación (Bessou & Perl, 1969), consolidaron la teoría

de la especificidad, la cual, en contraposición a la teoría de la intensidad,

coloca al dolor a la par de las demás modalidades sensoriales (calor, frío y

presión) y establece que la misma especificidad que se observa en el

sistema nervioso periférico, se mantiene a nivel central.

2.2.2.3 Teoría de los Patrones

A mediados de la década de 1920, Edgar Douglas Adrian e Yngve

Zotterman obtuvieron registros de los potenciales de acción emitidos por

fibras aferentes, en repuesta a eventos como estiramiento/torsión de la piel y

cambios leves de temperatura (Perl, 2007). Tales registros exhibieron

diferencias significativas según el tipo de estímulo, sugiriendo que diferentes

grupos de fibra sólo responden a una forma particular de estimulación

(Adrian & Zotterman, 1926), lo que ciertamente contribuyó con el concepto

15

de especificidad periférica. Sin embargo, John Paul Nafe, fisiólogo

americano, interpretó estos resultados de otra forma, atribuyendo los

cambios en el patrón de disparo al tipo de estímulo y argumentando que la

sensación resultante, era consecuencia de cómo el cerebro decodificaba

cada uno de estos patrones (Nafe, 1929).

2.2.2.4 Teoría de la Puerta de Control (TPC)

Lejos de desacreditar a las dos teorías más dominantes de la época (teoría

de la especificidad y teoría de los patrones), Ronald Melzack y Patrick David

Wall sintetizaron la evidencia experimental de cada una, con el fin de

proponer un modelo que pudiese explicar un conjunto de hallazgos

aparentemente contradictorios (Moayedi & Davis, 2013). De acuerdo a este

modelo, la experiencia dolorosa se encuentra modulada por un mecanismo

de compuerta que se ubica en la sustancia gelatinosa de la médula espinal,

y cuya activación está condicionada, tanto por el balance de la información

proveniente de aferentes primarios nociceptivos (fibras delgadas) y no

nociceptivos (fibras gruesas), como por los tractos descendentes que se

originan en las estructuras supraespinales y se proyectan hacia el asta

dorsal (Melzack & Wall, 1965). De esta forma, la transmisión de los impulsos

provocados por estímulos nocivos es inhibida (aunque en ciertas

circunstancias, también es facilitada) por la activación de las fibras de mayor

calibre, tal que la sensación de dolor que finalmente se percibe puede

disminuir (o aumentar) en intensidad, e incluso desaparecer.

El esquema original del SPC (Figura 2.a) fue reformulado años después

(Melzack & Wall, 1982) para incluir los elementos excitatorios e inhibitorios,

presentes en la sustancia gelatinosa, y el control inhibitorio descendente que

proviene de estructuras supraespinales, según se ilustra en la (Figura2.b).

No obstante, el modelo propuesto por Melzack y Wall representa una versión

extremadamente simplificada de la circuitería involucrada en el

procesamiento de la información vinculada a la percepción del dolor, lo que

trae consigo una serie de imprecisiones, no sólo a nivel anatómico, sino

también desde el punto de vista funcional, ya que no se explica en detalle el

mecanismo subyacente a la modulación de la información transmitida por los

16

aferentes de poco calibre (Moayedi & Davis, 2013). Del mismo modo, la TPC

resulta insuficiente para describir los procesos implicados en la cronificación

del dolor (Picton, Campbell, & Turner, 2001). Aun así, esta teoría ha sido la

única en reconocer la dualidad fisiológica-psicológica de la experiencia

dolorosa, y la que justifica el uso de la estimulación eléctrica, ya sea

transcutánea o vía columna dorsal (Miles, 1984), de un grupo selecto de

fibras nerviosas, como alternativa terapéutica para el alivio del dolor.

Figura 2: Esquemas del sistemas de la puerta de control.


Esquema original del Sistema de la Puerta de Control (a) y su versión reformulada (b). Aβ: fibra gruesa, C: fibra delgada, SG: neurona de la sustancia gelatinosa, SGE: neurona excitatoria de la sustancia gelatinosa, SGI: neurona inhibitoria de la sustancia gelatinosa, T: neurona de transmisión, ●: sinapsis excitatoria, ○: sinapsis inhibitoria. Adaptado de (Melzack & Wall, 1965) y (Melzack & Wall, 1982).

2.2.2.5 Teoría de la codificación poblacional de las sensaciones

somáticas

Frente al debate acerca de cómo el sistema nervioso codifica las distintas

modalidades sensoriales, varios autores (Green, 2004) (Ross, 2011) han

señalado que tanto especificidad como convergencia actúan de forma

sinérgica para determinar la sensación resultante. Surge entonces la teoría

17

de la codificación poblacional de las sensaciones somáticas, la cual

establece que, si bien existen receptores y vías específicas para diferentes

intensidades y modalidades de estimulación, muchas de estas rutas

convergen e interactúan a nivel espinal y supraespinal. Así, el balance de

fuerzas que faciliten o inhiban la transmisión de información asociada a una

modalidad sensorial en particular, será lo que determine si se percibe, o no,

la sensación correspondiente (Ma, 2010). Por otro lado, la especificidad a

nivel periférico es fundamental, ya que sería imposible calcular la activación

relativa de las distintas vías sensoriales si la población aferente fuese

totalmente homogénea (Prescott & Ratté, 2012).

2.2.3 LAS VÍAS DEL DOLOR

Dícese del sustrato neuroanatómico capaz de interactuar con otras vías

sensoriales y cuya función es la de codificar y transmitir, de manera

específica, los impulsos evocados por los estímulos lesivos, desde la

periferia hasta el sistema nervioso central.

2.2.3.1 Aferentes primarios

Esta subdivisión del sistema nervioso periférico comprende a todos aquellos

axones cuyas terminaciones captan la información sensorial proveniente,

tanto del entorno como de los órganos internos, para luego transmitirla hacia

el sistema nervioso central en forma de potenciales de acción (Purves,

Augustine, Fitzpatrick, Hall, Lamantia, & Williams, 2007). En particular, los

aferentes cutáneos poseen receptores específicos para cada tipo de

estímulo y sus cuerpos celulares se encuentran localizados en los ganglios

de la raíz dorsal (GRD) y el ganglio trigémino (Purves, Augustine, Fitzpatrick,

Hall, Lamantia, & Williams, 2007). Asimismo, estas neuronas pueden ser

clasificadas según sus aspectos morfológicos (diámetro y grado de

mielinización), funcionales (la velocidad a la cual viajan los potenciales de

acción, la modalidad sensorial y la intensidad de estimulación necesaria para

activarlas) y electrofisiológicos (amplitud y duración de los potenciales de

acción).

18

Los receptores cutáneos que codifican diferentes aspectos de los estímulos

táctiles, denominados mecanorreceptores, provienen generalmente de

axones con diámetros que oscilan entre 5 y 15 µm, y que están

generosamente recubiertos de mielina. Estas fibras transmiten el impulso

nervioso a velocidades comprendidas entre los 30 y 70 m/s, y pertenecen al

tipo Aβ (véase tablaNo 3) (Boulais & Misery, 2008) (Muriel, 2007). Por su

parte, los nociceptores se distinguen de los mecanorreceptores por su

elevado umbral de activación y su carácter polimodal (capacidad de

responder a más de un tipo de estímulo) (Ringkamp & Meyer, 2009). Los

axones vinculados a los nociceptores suelen subdividirse en dos grupos:

aquellos con un recubrimiento muy delgado de mielina y cuyas velocidades

de conducción van desde los 12 a los 30 m/s, y los axones amielínicos que

transmiten los potenciales de acción a velocidades por debajo de los 1.5

m/s, correspondientes a los tipos Aδ y C, respectivamente (Muriel, 2007). Sin

embargo, no existe una relación estricta entre las propiedades funcionales

del receptor y los aspectos morfológicos del axón asociado (Boulais &

Misery, 2008), ya que se han descubierto aferentes que codifican estímulos

catalogados como nocivos, y que a su vez, poseen velocidades de

conducción similares a las que exhiben los axones Aβ (Djouhri & Lawson,

2004) (Lawson, 2002). Más aun, existen subgrupos de fibras amielínicas

especializadas, capaces de transmitir información relativa a una sola

modalidad sensorial (Cavanaugh, y otros, 2009). Tal es el caso de las

neuronas histaminérgicas, cuya activación está vinculada al prurito

(Schmelz, Schmidt, Bickel, Handwerker, & Torebjörk, 1997).

19

Tipo de receptor

Estímulo

Fibra asociada

Aβ Aδ C

(D = 5 − 15 μm

Mielina abundanteVC = 30 − 70 m/s

) (D = 2 − 5 μmPoca mielina

VC = 12 − 30 m/s) (

D = < 0.2 μmSin mielina

VC = 0.5 − 12 m/s)

Mecanorreceptor

Bordes, textura gruesa

Contacto Vibración, textura fina

Presión leve

Termorreceptor

Frío (˂ 30 °C)

Calor (32-48 °C)

Nociceptor

Presión significativa

, mediadore

s inflamatorio

s e isquémicos

Mediadores

inflamatorios

Pruriceptor

Histamina, mediadore

s inflamatorio

s

D: Diámetro; VC: Velocidad de conducción

Adaptado de (Boulais & Misery, 2008) y (Muriel, 2007).

Tabla 3: Receptores cutáneos y axones asociados.

Autor: Tesis doctoral de Erick Argüello.

2.2.3.2 El asta dorsal de la médula espinal

Es en esta región donde ocurre la primera etapa de integración de la

información transmitida por los aferentes primarios, y que al igual que el

resto de la materia gris de la médula espinal, está subdividida en diferentes

zonas dispuestas a modo de capas, conocidas como láminas de Rexed

(Rexed, 1952). La descripción de los elementos neuronales básicos que

conforman el asta dorsal será presentada, a continuación, con sumo énfasis

en la RSAD (láminas I y II), ya que, por un lado, el conocimiento que se tiene

acerca de esta región es considerablemente mayor al que se tiene sobre las

capas más profundas (láminas III-V) (Todd, Neuronal circuitry for pain

processing in the dorsal horn, 2010) (Wu, Wang, Li, Wang, Feng, & Li, 2010),

20

y por el otro, es esta región la que recibe en su mayoría inervaciones de los

aferentes que transmiten los impulsos nociceptivos (Millán, 1999)

2.2.3.3 Lámina I

También llamada zona marginal, constituye la delgada capa que se ubica en

la región más externa de la materia gris y contiene, tanto numerosas

interneuronas excitatorias e inhibitorias, como neuronas de proyección que

alcanzan las estructuras supraespinales, incluidas la sustancia gris

periacueductal (SGPA) y el tálamo (Todd, Neuronal circuitry for pain

processing in the dorsal horn, 2010). Estas últimas reciben información

proveniente de aferentes nociceptivos de los tipos Aδ y C (Dahlaus,

Ruscheweyh, & Sandkuhler, 2005), así como también de las interneuronas

excitatorias e inhibitorias (Dahlaus, Ruscheweyh, & Sandkuhler, 2005)

(Polgár, Al-Khater, Shehab, Watanabe, & Todd, 2008), y de algunos tractos

descendentes (Polgár, Puskár, Watt, Matesz, & Todd, 2002). Las neuronas

de proyección localizadas en la lámina I han sido catalogadas como

neuronas específicamente nociceptivas, dado que las mismas normalmente

no reciben información de los aferentes táctiles, pertenecientes al tipo Aβ

(Millán, 1999).

No ha sido fácil establecer una correlación entre la morfología y el fenotipo

neuroquímico (neurotransmisor asociado) de las interneuronas que se

encuentran en la lámina I, las cuales, de acuerdo con su árbol dendrítico, se

han clasificado en piramidales, fusiformesy multipolares, (Zhang, Han, &

Craig, 1996). No obstante, algunos estudios (Prescott & De Konink, 2002)

han demostrado que cada una de estas células exhibe un patrón de disparo

diferente, sugiriendo que la geometría dendrítica de estas neuronas influye

en cómo las mismas procesan los impulsos que provienen de las células

presinápticas.

2.2.3.4 Lámina II

Esta capa se encuentra inmediatamente después de la lámina I y carece de

inervación proveniente de fibras mielinizadas (Rexed, 1952), lo que le

21

confiere una apariencia transparente, y de allí, el nombre de sustancia

gelatinosa. Contiene principalmente interneuronas excitatorias e inhibitorias

que utilizan, respectivamente, glutamato y ácido-γ-aminobutírico (GABA)

como neurotransmisor (Maxwell et al, 2007; Yasaka et al, 2010), y se

encuentra densamente inervada por aferentes amielínicos nociceptivos (tipo

C) (Todd, Neuronal circuitry for pain processing in the dorsal horn, 2010)

(Wu, Wang, Li, Wang, Feng, & Li, 2010). La región más externa de la lámina

II (IIo) recibe terminaciones de fibras amielínicas capaces de sintetizar

neuropéptidos (peptidérgicas), tales como la sustancia P, mientras que la

región más cercana a la lámina III (IIi), alberga a los terminales de las fibras

amielinicas no peptidérgicas (Todd, Neuronal circuitry for pain processing in

the dorsal horn, 2010), y a ciertas neuronas excitatorias que expresan la

isoforma γ de la proteína kinasa C (Mori, Kose, Tsujino, & Tanaka, 1990)

(Polgár, Fowler, McGill, & Todd, 1999), las cuales podrían estar involucradas

en rutas polisinápticas que comunican a las fibras Aβ con las neuronas de

proyección de la lámina I (Miracourt, Dallel, & Vosin, 2007).

De acuerdo al aspecto de su árbol dendrítico, las interneuronas presentes en

la lámina II han sido clasificadas en cuatro tipos fundamentales (Grudt &

Perl, 2002): insulares, verticales, centrales y radiales. Las células del tipo

insular se ubican cerca de la línea que separa a la lámina IIi de la lámina III,

y emplean GABA para ejercer una influencia inhibitoria sobre sus blancos

postsinápticos (Maxwell, Belle, Cheunsuang, Stewart, & Morris, 2007)

(Yasaka, Tiong, Hughes, Ridell, & Todd, 2010). Evidencia experimental

sostiene que estas interneuronas reciben inervaciones de aferentes

amielínicos (tipo C) con una velocidad de conducción relativamente mayor a

la que comúnmente exhiben estas fibras (Lu & Perl, 2003). Por otro lado, las

neuronas del tipo vertical se localizan en la lámina IIo y utilizan glutamato

como neurotransmisor, es decir, son excitatorias (Yasaka, Tiong, Hughes,

Ridell, & Todd, 2010). Estas células son blanco de aferentes mielinizados

nociceptivos (tipo Aδ) así como también de otras interneuronas, e inervan a

muchas de las células que residen en la lámina I, entre éstas, las neuronas

de proyección específicamente nociceptivas (Lu & Perl, 2005). Por su parte,

las interneuronas centrales ocupan la franja que subdivide a la sustancia

22

gelatinosa (láminas IIi y IIo), y pueden ser tanto excitatorias como inhibitorias

(Yasaka, Tiong, Hughes, Ridell, & Todd, 2010). Finalmente, las células

radiales poseen arborizaciones dendríticas que alcanzan las láminas I y III, y

en su mayoría emplean glutamato como neurotransmisor, aunque también

se han reportado neuronas GABA-érgicas de este tipo (Maxwell, Belle,

Cheunsuang, Stewart, & Morris, 2007).

2.2.3.5 Láminas III-V

Si bien las regiones más profundas del asta dorsal (láminas III-V), que a su

vez constituyen el núcleo propio (Rexed, 1952), reciben terminaciones de las

fibras mielinizadas, generalmente del tipo Aβ (Shortland & Woolf, 1997),

también son inervadas por los aferentes nociceptivos (Ritz & Greenspan,

1985). El núcleo propio contiene, esencialmente, neuronas de proyección de

amplio rango dinámico, así como interneuronas inhibitorias que utilizan

GABA y glicina (Todd, 1991). Estas neuronas de proyección, a diferencia de

aquellas que residen en la lámina I, transmiten los impulsos provenientes de

aferentes nociceptivos y no nociceptivos, y poseen un árbol dendrítico

mucho más extenso (Ritz & Greenspan, 1985).

23

Figura 3: Representación esquemática del asta dorsal de la medula espinal.

Fuente: Tesis doctoral de Erick Argüello. Adaptado de (Millán, 1999).

2.2.3.6 Control descendente

Sería razonable afirmar que fueron Melzack y Wall los primeros en sugerir la

participación de estructuras supraespinales en la modulación de la

información transmitida por aferentes nociceptivos (Melzack & Wall, 1965)

(Melzack & Wall, 1982). Esta hipótesis sería confirmada pocos años

después, al observar el poderoso efecto analgésico inducido por

estimulación eléctrica de la SPAG, durante un procedimiento quirúrgico

(Reynolds, 1969). La SPAG está compuesta por una población heterogénea

de neuronas que rodean el acueducto del cerebro, y recibe terminaciones

nerviosas que provienen principalmente de la corteza somatosensorial, la

amígdala y el hipotálamo (Heinricher & Ingram, 2008) (Purves, Augustine,

Fitzpatrick, Hall, Lamantia, & Williams, 2007). No obstante, la acción

inhibitoria que se ejerce sobre los impulsos nociceptivos que ingresan al asta

dorsal no se lleva a cabo directamente, sino a través de otra estructura

supraespinal denominada médula rostroventromedial (MRV), cuyas

proyecciones descendentes que van a lo largo del funículodorsolateral, sí

alcanzan el asta dorsal de la médula espinal (Heinricher & Ingram, 2008).

24

2.2.4 IMPLEMENTACIÓN DEL MODELO NEUROIDAL

El neuroide se basa en tres operaciones básicas que se llevan a cabo por

las células nerviosas para procesar la información entrante, como

comparación, y la frecuencia modulación por impulsos-demodulación.

El modelo fue implementado utilizando el software de LabView en su versión

10.0, con el fin de asignar a cada uno de estas operaciones, un bloque de

ejecución (instrumentos virtuales). Los resultados de su ejecución mostraron

un comportamiento muy similar a la exhibida por las neuronas reales.

Además, debido a su simplicidad y bajo coste computacionales, se espera

que el neuroide se pueda utilizar para crear varios modelos de software de

los sistemas neuronales biológicos, ya sea con propósitos para la

investigación o la enseñanza.

En un trabajo reciente, un modelo de neurona en base a la descripción

matemática de la señal transmitida a lo largo del axón de la neurona (es

decir, el tren de potenciales de acción), el neuroide, fue desarrollado

(Arguello, 2012). Vamos δ(t) una sola espiga, si la despolarización resultante

s(t) supera el umbral de activación umbr, entonces la señal que se propaga a

lo largo del axón, y(t), viene dada por:

𝑦(𝑡) = ∑ 𝛿 (𝑡 −𝑛𝛽𝑇

𝑠(𝑡) − 𝑢𝑚𝑏𝑟)

∞

𝑛=0

Figura 4: Formula de tren de impulsos de frecuencia modulada.


25

Figura 5: Esquema del Neuroide.


Donde T es el intervalo de tiempo que debe transcurrir entre un impulso y el

siguiente, umbr es el umbral de activación, y β es un constante de

proporcionalidad. Para consistencia, s(t), β y umbr, son adimensionales. Se

requirió de un bloque capaz de demodular el tren de impulsos. Este tren de

impulsos de frecuencia modulada se "demodula" en una señal graduada,

nt_out (t), que se asemeja a la señal de entrada, s(t), pero prolonga durante

un período finito de tiempo después de la última espiga, para modelar de

alguna manera el temporal y perfiles de concentración de neurotransmisor

en la hendidura sináptica (nt_out (t) ≈ s (t)). Según lo descrito por (Arguello,

2012), se requerían otros dos parámetros para ajustar la amplitud de la señal

de salida (Kr), y prevenir el crecimiento indefinido (MaxCount).

2.2.5 DEFINICIÓN DE SOFTWARE

La definición más formal de software es la atribuida a la IEEE (Instituto de

Ingenieros Eléctricos y Electrónicos), en su estándar 729: la suma total de

los programas de cómputo, procedimientos, reglas, documentación y datos

asociados que forman parte de las operaciones de un sistema de cómputo

(IEEE Computer Society, 1993). Bajo esta definición el concepto de software

va más allá de los programas de cómputo en sus distintas formas: código

fuente, binario o código ejecutable, además de su documentación. Es decir,

el software es todo lo intangible.

26

El Software es también conocido como programática o equipamiento lógico,

esto es el conjunto de programas que puede ejecutar el hardware para la

realización de las tareas de computación a las que se destina. Se trata del

conjunto de instrucciones que permite la utilización del ordenador o

computador (pc, personal computer). El software es la parte intangible de la

computadora, es decir, programas, aplicaciones, etc.

El software se puede dividir en software de sistema, software de desarrollo o

programación y software de aplicaciones.

2.2.5.1 SOFTWARE DE SISTEMA

Son todos los programas que administran los recursos de una computadora,

como el ratón, el teclado, las bocinas, la impresora, el disco duro (HDD), la

memoria principal (RAM), el tiempo que debe durar un proceso, etc. El

software de sistema le procura al usuario y programador adecuadas

interfaces de alto nivel, controladores, herramientas y utilidades e apoyo que

permiten el mantenimiento del sistema global.

El software de sistemas por excelencia son los sistemas operativos, entre los

que se encuentran:

Microsoft Windows

UNIX

Mac OS

Solaris

Linux.

2.2.5.2 SOFTWARE DE DESARROLLO O PROGRAMACIÓN

Son los programas, mejor conocidos como lenguajes de programación, que

se usan para crear nuevos programas. El software de desarrollo comprende

los lenguajes de programación, compiladores, intérpretes, ligadores y

ensambladores. Algunos ejemplos de lenguajes de programación son Basic,

Pascal, C/C++, PHP, Fortran, Java, Prolog, etc. Existe una gran variedad de

lenguajes de programación para cada propósito.

27

2.2.5.3 SOFTWARE DE APLICACIONES

El software de aplicaciones se divide en dos grupos. El primero se refiere a

los programas que usan las personas para escribir un documento, hacer un

presupuesto o preparar la presentación gráfica de un producto o tema. Se

conoce también como software de aplicaciones generales. El segundo grupo

lo conforman los diversos tipos de software de aplicaciones específicas

dirigidos a áreas más específicas como la ingeniería (CAD/CAM), la

contabilidad, la medicina y el diseño gráfico.

2.2.6 TIPOS DE SOFTWARE

2.2.6.1 SOFTWARE PROPIETARIO

El software propietario también se lo conoce como software no libre, o

software privado. Cuando hablamos de este tipo de software nos referimos a

los programas informáticos que no dan la posibilidad de modificarlo, o que su

código fuente no está disponible o el acceso a este se encuentra restringido.

En el software propietario una persona natural o jurídica posee los derechos

de autor sobre un software negando o no otorgando, al mismo tiempo, los

derechos de usar el programa con cualquier propósito; de estudiar cómo

funciona el programa y adaptarlo a las propias necesidades (donde el

acceso al código fuente es una condición previa); de distribuir copias; o de

mejorar el programa y hacer públicas las mejoras (para esto el acceso al

código fuente es un requisito previo). De esta manera, un software sigue

siendo no libre aun si el código fuente es hecho público, cuando se mantiene

la reserva de derechos sobre el uso, modificación o distribución (por

ejemplo, el programa de licencias shared source de Microsoft). No existe

consenso sobre el término a utilizar para referirse al opuesto del software

libre. Entre los términos más usados, en orden de frecuencia de uso.

2.2.6.2 SOFTWARE LIBRE

El software libre es aquel que puede ser distribuido, modificado, copiado y

usado; por lo tanto, debe venir acompañado del código fuente para hacer

efectivas las libertades que lo caracterizan. Dentro de software libre hay, a

28

su vez, matices que es necesario tener en cuenta. Por ejemplo, el software

ve dominio público significa que no está protegido por el copyright, por lo

tanto, podrían generarse versiones no libres del mismo, en cambio el

software libre protegido con copyleft impide a los redistribuidores incluir

algún tipo de restricción a las libertades propias del software así concebido,

es decir, garantiza que las modificaciones seguirán siendo software libre.

También es conveniente no confundir el software libre con el software

gratuito, este no cuesta nada, hecho que no lo convierte en software libre,

porque no es una cuestión de precio, sino de libertad. Para Richard Stallman

el software libre es una cuestión de libertad, no de precio. Para comprender

este concepto, debemos pensar en la acepción de libre como en “libertad de

expresión”. En términos del citado autor el software libre se refiere a la

libertad de los usuarios para ejecutar, copiar, distribuir, estudiar, cambiar y

mejorar el software. Y se refiere especialmente a cuatro clases de libertad

para los usuarios de software:

1. Libertad 0: la libertad para ejecutar el programa sea cual sea nuestro

propósito.

2. Libertad 1: la libertad para estudiar el funcionamiento del programa y

adaptarlo a tus necesidades -el acceso al código fuente es condición

indispensable para esto.

3. Libertad 2: la libertad para redistribuir copias y ayudar así a tu vecino.

4. Libertad 3: la libertad para mejorar el programa y luego publicarlo para

el bien de toda la comunidad -el acceso al código fuente es condición

indispensable para esto.

Software libre es cualquier programa cuyos usuarios gocen de estas

libertades. De modo que deberías ser libre de redistribuir copias con o sin

modificaciones, de forma gratuita o cobrando por su distribución, a

cualquiera y en cualquier lugar. Gozar de esta libertad significa, entre otras

cosas, no tener que pedir permiso ni pagar para ello. Asimismo, debería ser

libre para introducir modificaciones y utilizarlas de forma privada, ya sea en

tu trabajo o en tu tiempo libre, sin siquiera tener que mencionar su

29

existencia. Si se decidiera publicar estos cambios, no se debería estar

obligado a notificárselo a ninguna persona ni de ninguna forma en particular.

La libertad para utilizar un programa significa que cualquier individuo u

organización podrán ejecutarlo desde cualquier sistema informático, con

cualquier fin y sin la obligación de comunicárselo subsiguientemente ni al

desarrollador ni a ninguna entidad en concreto.

La libertad para redistribuir copias supone incluir las formas binarias o

ejecutables del programa y el código fuente tanto de las versiones

modificadas, como de las originales -la distribución de programas en formato

ejecutable es necesaria para su adecuada instalación en sistemas

operativos libres. No pasa nada si no se puede producir una forma

ejecutable o binaria - dado que no todos pueden soportarlo-, ya que

debemos tener la libertad para redistribuir tales formas si se encuentra el

modo de hacerlo.

Para que las libertades 2 y 4 adquieran significado, debemos disponer del

código fuente del programa. Por consiguiente, la accesibilidad del código

fuente es una condición necesaria para el software libre.

Para materializar estas libertades, deberán ser irrevocables siempre que no

cometamos ningún error; si el desarrollador del software pudiera revocar la

licencia sin motivo, ese software dejaría de ser libre. Sin embargo, ciertas

normas sobre la distribución de software libre nos parecen aceptables

siempre que no planteen un conflicto con las libertades centrales. Por

ejemplo, el copyleft, es la norma que establece que, al redistribuir el

programa, no pueden añadirse restricciones que nieguen a los demás sus

libertades centrales. Esta norma no viola dichas libertades, sino que las

protege.

De modo que puedes pagar o no por obtener copias de software libre, pero

independientemente de la manera en que las obtengas, siempre tendrás

libertad para copiar, modificar e incluso vender estas copias.

El software libre no significa que sea «no comercial». Cualquier programa

libre estará disponible para su uso, desarrollo y distribución comercial. El

desarrollo comercial del software libre ha dejado de ser excepcional y de

hecho ese software libre comercial es muy importante.

30

Las normas sobre el empaquetamiento de una versión modificada son

perfectamente aceptables siempre que no restrinjan efectivamente tu libertad

para publicar versiones modificadas. Por la misma razón, serán igualmente

aceptables aquellas normas que establezcan que «si distribuyo el programa

de esta forma, deberás distribuirlo de la misma manera» —cabe destacar

que esta norma te permite decidir si publicar o no el programa. También

admitimos la posibilidad de que una licencia exija enviar una copia

modificada y distribuida de un programa a su desarrollador original.

En el proyecto GNU, se utiliza el «copyleft» para proteger legalmente estas

libertades. Pero también existe software libre sin copyleft. Creemos que hay

razones de peso para recurrir al copyleft, pero si tu programa, software libre,

carece de él, todavía tendremos la opción de seguir utilizándolo.

A veces la normativa gubernamental de control de las exportaciones y las

sanciones comerciales puede constreñir tu libertad para distribuir copias a

nivel internacional. Los desarrolladores de software no tienen el poder para

eliminar o invalidar estas restricciones, pero lo que sí pueden y deben hacer

es negarse a imponer estas condiciones de uso al programa. De este modo,

las restricciones no afectarán a las actividades y a los individuos fuera de la

jurisdicción de estos gobiernos.

Cuando hablamos de software libre, es preferible evitar expresiones como

«regalar» o «gratis», porque entonces caeremos en el error de interpretarlo

como una mera cuestión de precio y no de libertad. Términos de uso

frecuente como el de «piratería» encarnan opiniones que esperamos no

compartas. Por último, señalaremos que los criterios descritos para definir el

software libre requieren una profunda reflexión antes de interpretarlos. Para

decidir si una licencia de software específica puede calificarse de licencia de

software libre, nos basaremos en dichos criterios y así determinaremos si se

ajusta al espíritu y a la terminología precisa. Si una licencia incluye

restricciones desmedidas, la rechazamos aun cuando nunca predijimos esta

cuestión al establecer nuestros criterios. En ocasiones, ciertas condiciones

en una licencia pueden plantear un problema que requiera un análisis

exhaustivo, lo que significa incluso debatir el tema con un abogado, antes de

decidir si dichas condiciones son aceptables.

31

2.2.7 LICENCIA PÚBLICA GENERAL GNU

Las licencias que cubren la mayor parte del software están diseñadas para

despojarle de la libertad para compartirlo y para modificarlo. Por el contrario,

la Licencia Pública General de GNU pretende garantizar la libertad de

compartir y modificar software libre —para asegurar que el software es libre

para todos sus usuarios. Esta Licencia Pública General se aplica a la mayor

parte del software de la Free Software Foundation y a cualquier otro

programa si sus autores se comprometen a utilizarla. También puedes

aplicarla a sus propios programas.

La Licencia Pública General está diseñada para asegurar que se tenga la

libertad de distribuir copias de software libre —y cobrar por ese servicio si

quiere—, de que reciba el código fuente o de que pueda conseguirlo si así lo

desea, de que pueda modificar el software o utilizar fragmentos del mismo

en nuevos programas libres, y de que sepa que puede hacer todas estas

cosas.

Para proteger los derechos, se necesitan algunas restricciones que prohíban

negarle estos derechos o pedirle que renuncie a ellos. Estas restricciones se

traducen en ciertas obligaciones que le afectan si distribuye copias del

software, o si modifica software. Por ejemplo, si distribuye copias de uno de

estos programas, ya sea gratuitamente, o a cambio de unos honorarios,

debe dar a los receptores todos los derechos que posee. Debe asegurarse

de que ellos también reciben, o pueden conseguir, el código fuente. Y debe

mostrarles estas condiciones de forma que conozcan sus derechos.

Protegemos los derechos por medio de la combinación de dos medidas: (1)

ponemos el software bajo copyright y (2) le ofrecemos esta licencia, que le

da permiso legal para copiar, distribuir y/o modificar el software.

También, para proteger a cada autor y a nosotros mismos, queremos

asegurarnos de que todo el mundo comprende que no se proporciona

ninguna garantía para este software libre. Si el software es modificado y

distribuido, queremos que sus receptores sepan que lo que tienen no es el

original, de forma que cualquier problema introducido por otros no afecte a la

reputación de los autores originales.

Por último, cualquier programa libre está constantemente amenazado por las

patentes de software. Queremos evitar el peligro de que los distribuidores de

32

un programa libre lo patenten por su cuenta, convirtiendo así el programa en

propietario. Para evitar esto, hemos dejado claro que cualquier patente debe

ser registrada para el libre uso, o no ser registrada de ninguna manera.

Si usted desarrolla un nuevo programa, y quiere que sea del mayor uso

posible para el público en general, la mejor forma de conseguirlo es

convirtiéndolo en software libre que cualquiera pueda redistribuir y cambiar

según estos términos. Para hacerlo, añada las siguientes cláusulas al

programa. Lo más seguro es añadirlas al principio de cada fichero fuente

para transmitir lo más efectivamente posible la ausencia de garantía.

Además, cada fichero debería tener al menos la línea de «copyright» y un

indicador de dónde puede encontrarse el anuncio completo.

<Una línea para indicar el nombre del programa y una breve idea de qué hace>

Copyright (C) 19aa <nombre del autor>

Este programa es software libre. Puede redistribuirlo y/o

modificarlo bajo los términos de la Licencia Pública General

de GNU según es publicada por la Free Software Foundation,

bien de la versión 2 de dicha Licencia o bien --según su

elección-- de cualquier versión posterior. Este programa se

distribuye con la esperanza de que sea útil, pero SIN

NINGUNA GARANTÍA, incluso sin la garantía MERCANTIL

implícita o sin garantizar la CONVENIENCIA PARA UN PROPÓSITO

PARTICULAR. Para más detalles, véase la Licencia Pública

General de GNU.

Debería haber recibido una copia de la Licencia Pública

General junto con este programa. En caso contrario, escriba

a la Free Software Foundation, Inc., en 675 Mass Ave,

Cambridge, MA 02139, EEUU.

2.2.8 HERRAMIENTAS DE SOFTWARE PARA CREAR REDES

NEUROIDALES

Las herramientas de simulación son aquellas que incorporan tecnologías

orientadas a la programación gráfica. Se trata de poder elaborar un proyecto

de simulación utilizando objetos gráficos (bloques) que puedan enlazarse

configurando un esquema de bloques perfectamente jerarquizado por

categorías que normalmente tendrá asociado una o varias pantallas de

objetos gráficos que mostraran la información en la fase de simulación. Entre

las herramientas utilizadas para implementar el modelo neuroidal tenemos

las siguientes:

33

2.2.8.1 LABVIEW (Laboratory Virtual Instrumentation Engineering workbench)

El software de diseño de sistemas LabView es el entorno de desarrollo ideal

para construir cualquier aplicación de medida o control. LabView es el

corazón de la plataforma de diseño de National Instruments, proporciona

extensas herramientas que los ingenieros y científicos necesitan para

construir una amplia variedad de aplicaciones en mucho menos tiempo,

LabView es un entorno de desarrollo para resolver problemas, productividad

acelerada y constante innovación.

Los productos del software de LabView de National Instruments ofrecen una

variedad de opciones para asegurarse que está usando la edición más

apropiada de acuerdo a sus necesidades.

\

Figura 6: Logo de LabView.

Fuente: Sitio web de National Instrumentas (NI)

¿Qué es LabView?

LabView es una plataforma de programación gráfica que ayuda a ingenieros

a escalar desde el diseño hasta pruebas, y desde sistemas pequeños hasta

grandes sistemas. Ofrece integración sin precedentes con software

existente, IP y hardware al aprovechar las últimas tecnologías de cómputo.

LabView ofrece herramientas para resolver los problemas de hoy en día y la

capacidad para la futura innovación, más rápido y de manera más eficiente.

Los programas desarrollados en LabView se denominan Instrumentos

Virtuales (VIs), porque su apariencia y operación imitan los de un

instrumento real. LabView contiene completas herramientas para

adquisición, control, análisis y presentación de datos, así como herramientas

que facilitan la depuración de los programas.

34

Figura 7: Menú de controles de LabView.


LabView utiliza programación gráfica o lenguaje G para crear programas

basados en diagramas de bloques (S. Sumathi, P. Surekha, 2007).

Figura 8: Menú de funciones de LabView


35

Ingenieros y científicos en todo el mundo prefieren LabView por su

naturaleza gráfica e intuitiva. Con este potente software se pueden realizar

cosas increíbles aprovechando una integración positiva entre software y

hardware.

Figura 9: Ejecución de un programa en LabView.


Ventajas de LabView

Reduce el tiempo de desarrollo de las aplicaciones.

Dota de gran flexibilidad al sistema.

Permite al usuario crear soluciones completas y complejas.

Con un único desarrollo se integran las funciones de adquisición,

análisis y presentación de datos.

El sistema tiene un compilador gráfico para lograr la máxima

velocidad en la ejecución.

Da la posibilidad de incorporar aplicaciones escritas en otros

lenguajes.

36

2.2.8.2 HP VEE (Hewlett-Packard Visual Engineering Environment)

Es un potente lenguaje de programación visual que simplifica el desarrollo

de ingeniería de software, prueba y medición. HP VEE es una nueva

herramienta de propósito general, está dirigido a ingenieros y científicos

involucrados en la investigación, creación de prototipos, o recolección de

datos, análisis y visualización.

Figura 10: Logo de HP-VEE.

Fuente: Sitio web de HP (Hewlett Packard Company, 1998)

Para desarrollar programas en HP VEE se deben conectar gráficos "objetos"

en lugar de estar escribiendo líneas de código. Este programa hace fácil el

entendimiento de los diagramas de bloque.

Características principales:-

Apoyo para las matemáticas y la ingeniería.

Control de instrumentos

Gestión de datos

Soporte GUI

Secuenciación de prueba

Desarrollo interactivo y entorno de depuración

A partir de la versión 4.0, HP VEE utiliza un compilador para mejorar la

ejecución de la velocidad de los programas.

37

El compilador de 4.0 HP VEE aumenta el rendimiento intensivo

computacional de los programas por alrededor de 40 veces respecto a las

versiones anteriores de HP VEE en aplicaciones donde la velocidad de

ejecución está limitada por instrumentos de entrada y salida de archivos.

Figura 11: Interfaz del software HP-VEE.

Fuente: Sitio web de HP (Hewlett Packard Company, 1998)

2.2.8.3 MATLAB (Matrix Laboratory)

Es un lenguaje de alto nivel y entorno interactivo para el cálculo numérico,

visualización y programación. Usando MATLAB, puede analizar datos,

desarrollar algoritmos y crear modelos y aplicaciones. El lenguaje, las

herramientas y funciones integradas de matemáticas le permiten explorar

múltiples enfoques y llegar a una solución más rápida que con hojas de

cálculo o lenguajes de programación tradicionales como C/C++ o Java.

Figura 12: Logo de MATLAB.

Fuente: Sitio web de Mathworks (MathWorks)

38

Usted puede utilizar MATLAB para una gama de aplicaciones, incluyendo el

procesamiento de señales y comunicaciones, procesamiento de imágenes y

de video, sistemas de control, prueba y medición, finanzas computacionales,

y la biología computacional. Más de un millón de ingenieros y científicos en

la industria y el mundo académico usan MATLAB, el lenguaje de cálculo

técnico.

Figura 13: Interfaz del software MATLAB.


Características principales.-

Lenguaje de alto nivel para cálculo numérico, visualización y

desarrollo de aplicaciones.

Funciones matemáticas para álgebra lineal, estadística, análisis de

Fourier, filtrado, optimización, integración numérica, y la resolución de

ecuaciones diferenciales ordinarias.

Capacidad de la gráfica para la visualización de datos y herramientas

para la creación de parcelas personalizadas.

Herramientas de desarrollo para mejorar la calidad del código y

facilidad de mantenimiento y maximizar el rendimiento.

39

Herramientas para la creación de aplicaciones con interfaces gráficas

personalizadas.

Funciones para integrar los algoritmos basados en MATLAB con

aplicaciones externas y lenguajes como C, Java, .NET, y Microsoft

Excel.

Figura 14: Importación de archivos en MATLAB.


Figura 15: Visualización de gráficos en MATLAB.


40

2.2.9 PLATAFORMA PARA DESARROLLOS DE APLICACIONES EN

JAVA

2.2.9.1 ECLIPSE

El proyecto Eclipse fue creado por IBM en el 2001 y la Fundación Eclipse fue

creada en enero del 2004 como una corporación sin fines de lucro, la cual es

una comunidad de personas y organizaciones que deseen colaborar en la

comercialización del uso de software de código abierto.

Eclipse es famoso por su entorno de desarrollo integrado (IDE) para

desarrollar aplicaciones utilizando el lenguaje de programación Java y

también proporciona herramientas de desarrollo para otros lenguajes como

C / C++, Python, Perl, Ruby, etc.

Figura 16: Logo de ECLIPSE.

Fuente: The Eclipse Foundation (Eclipse)

Plataforma Eclipse y otros plug-ins de Eclipse Foundation es liberado bajo la

Licencia Pública Eclipse (EPL). EPL asegura que Eclipse es libre de

descargar e instalar. También permite a Eclipse para ser modificado y

distribuido.

Esta plataforma está compuesta por plug-ins que le permitirán a Eclipse ser

utilizado para cierto tipo de lenguaje de programación. Puede usarse para

desarrollar aplicaciones de cliente, entornos de desarrollo integrados y otras

herramientas.

Versiones de Eclipse

Desde el 2006, la fundación Eclipse libera la plataforma Eclipse bajo la

Licencia Pública Eclipse (EPL) y un número de otros plug-ins en Junio. La

EPL asegura que Eclipse es libre de descargar e instalar y también le

permite a Eclipse ser modificado y distribuido.

41

Nombre Año Versión

Eclipse 3.0 2004 3.0

Eclipse 3.1 2005 3.1

Callisto 2006 3.2

Europa 2007 3.3

Ganymede 2008 3.4

Galileo 2009 3.5

Helios 2010 3.6

Indigo 2011 3.7

Juno 2012 3.8 and 4.2

Kepler 2013 4.3

Luna 2014 4.4

Mars 2015 (planeado) 4.5

Tabla 4: Versiones de ECLIPSE

Autor: Datos de la investigación

42

Figura 17: Interfaz de usuario de ECLIPSE.

Fuente: The Eclipse Foundation (Eclipse)

2.3 FUNDAMENTACIÓN LEGAL

2.3.1 De la ciencia y tecnología

Art. 80.- El Estado fomentará la ciencia y la tecnología, especialmente en

todos los niveles educativos, dirigidas a mejorar la productividad, la

competitividad, el manejo sustentable de los recursos naturales, y a

satisfacer las necesidades básicas de la población.

Garantizará la libertad de las actividades científicas y tecnológicas y la

protección legal de sus resultados, así como el conocimiento ancestral

colectivo.

La investigación científica y tecnológica se llevará a cabo en las

universidades, escuelas politécnicas, institutos superiores técnicos y

tecnológicos y centros de investigación científica, en coordinación con los

sectores productivos cuando sea pertinente, y con el organismo público que

43

establezca la ley, la que regulará también el estatuto del investigador

científico.

2.3.2 Ciencia, tecnología, innovación y saberes ancestrales

Art. 385.- El sistema nacional de ciencia, tecnología, innovación y saberes

ancestrales, en el marco del respeto al ambiente, la naturaleza, la vida, las

culturas y la soberanía, tendrá como finalidad:

1. Generar, adaptar y difundir conocimientos científicos y tecnológicos.

2. Recuperar, fortalecer y potenciar los saberes ancestrales.

3. Desarrollar tecnologías e innovaciones que impulsen la producción

nacional, eleven la eficiencia y productividad, mejoren la calidad de vida y

contribuyan a la realización del buen vivir.

Art. 386.- El sistema comprenderá programas, políticas, recursos, acciones,

e incorporará a instituciones del Estado, universidades y escuelas

politécnicas, institutos de investigación públicos y particulares, empresas

públicas y privadas, organismos no gubernamentales y personas naturales o

jurídicas, en tanto realizan actividades de investigación, desarrollo

tecnológico, innovación y aquellas ligadas a los saberes ancestrales.

El Estado, a través del organismo competente, coordinará el sistema,

establecerá los objetivos y políticas, de conformidad con el Plan Nacional de

Desarrollo, con la participación de los actores que lo conforman.

Art. 387.- Será responsabilidad del Estado:

1. Facilitar e impulsar la incorporación a la sociedad del conocimiento para

alcanzar los objetivos del régimen de desarrollo.

2. Promover la generación y producción de conocimiento, fomentar la

investigación científica y tecnológica, y potenciar los saberes ancestrales,

para así contribuir a la realización del buen vivir, al sumak kawsay.

44

3. Asegurar la difusión y el acceso a los conocimientos científicos y

tecnológicos, el usufructo de sus descubrimientos y hallazgos en el marco de

lo establecido en la Constitución y la Ley.

4. Garantizar la libertad de creación e investigación en el marco del respeto

a la ética, la naturaleza, el ambiente, y el rescate de los conocimientos

ancestrales.

5. Reconocer la condición de investigador de acuerdo con la Ley.

2.3.3 Decreto presidencial No 1014

El 10 de abril de 2008, el Presidente de la República de Ecuador, Rafael

Correa Delgado, mediante decreto No. 1014 establece como política para las

entidades de la Administración Pública Central, el uso de software libre en

sus sistemas y equipamientos informáticos.

De acuerdo a lo anterior el software va a ser una aplicación de escritorio y de

acuerdo a la norma decretada, la aplicación será desarrollada con software

libre.

2.4 HIPÓTESIS PREGUNTAS A CONTESTARSE

¿El 70% del desarrollo del software para simular la creación de redes

neuroidales, cumplirá con los requisitos esperados por los usuarios?

¿Los parámetros utilizados en este software son los adecuados para poder

simular la creación de una red neuroidal?

¿Con el desarrollo de este software para simular la creación de redes

neuroidales, se fomentara el estudio de la bioingeniería?

¿El desarrollo de este software libre podrá ser una alternativa válida para el

software LabView que se utilizó para simular la creación de redes

neuroidales?

45

2.5 VARIABLES DE LA INVESTIGACIÓN

Variable dependiente.- Desarrollo de software.

Variable dependiente.- Simulación de redes neuroidales.

Variable independiente.- Herramienta de desarrollo software Open Source.

2.6 DEFINICIONES CONCEPTUALES

Neuroide

El neuroide es un emulador neuronal que, a diferencia de los modelos

clásicos, es capaz de generar pulsos con un mínimo coste

computacional en virtud de su estructura algorítmica.

Perceptrón

Es una de las primeras arquitecturas neuronales, el cual representa a

una neurona artificial. Es el modelo matemático más simple de una

neurona. La unión de varios perceptrones forma una red neuronal

artificial.

Framework

Un Framework es un conjunto de bibliotecas, herramientas y normas

a seguir que ayudan a desarrollar aplicaciones.

IDE

Entorno de desarrollo integrado, es una herramienta para que los

programadores puedan escribir, compilar, depurar y ejecutar

programas.

Copyleft

Es un método para convertir un programa en software libre y exigir

que todas las versiones del mismo, modificadas o ampliadas, también

lo sean.

46

CAPÍTULO III

METODOLOGÍA

3.1 DISEÑO DE LA INVESTIGACIÓN

3.2 MODALIDAD DE LA INVESTIGACIÓN

De acuerdo a las características del proyecto “Desarrollo de un software

para la construcción de redes neuroidales” se ha definido que la modalidad

del presente trabajo de tesis es de proyecto factible por ser una solución

posible ante una necesidad evidente en el DIPA, y lo que se busca es

satisfacer los requerimientos de contar con un software propio para poder

realizar estudios del nuevo modelo matemático computacional denominado

neuroide.

3.3 TIPO DE INVESTIGACIÓN

El tipo de investigación que se utiliza es de proyecto factible, descriptiva y

explicativa ya que da una solución a un problema al igual que se

proporcionara manuales que indican la configuración y la implementación del

proyecto antes planteado. También es de comprobación ya que

comprobamos que no es necesario contar con licencias de software para

desarrollar software de calidad empleando el uso de software libre como se

menciona en el capítulo II.

3.4 POBLACIÓN Y MUESTRA

3.4.1 POBLACIÓN

La población que hemos elegido para el análisis de nuestro trabajo es el

director del Programa continuo de investigaciones medico informáticas

PROMEINFO de la Universidad de Guayaquil.

47

3.4.2 MUESTRA

Los especialistas que se consideraron son los siguientes:

Ph.D Ricardo Silva Bustillos

POBLACIÓN NÚMERO

Especialista 1

TOTAL 1

Tabla 5: Tabla de muestra


3.5 OPERACIONALIZACIÓN DE VARIABLES

Las variables del presente trabajo son:

Variable independiente: Herramienta de desarrollo Software Open Source.

Variable dependiente 1: Desarrollo de software.

Variable dependiente 2: Simulación de redes neuroidales.

Variables Dimensiones Indicadores Técnicas y/o Instrumentos

Herramientas

Open Source

- Java - Metodología de

programación

Internet,

Bibliografías

Desarrollo de

Software

- Análisis - Interfaz de

usuario.

- Estándares de

programación.

Internet,

Foros,

Bibliografías. - Diseño

- Implementación

Simulación de

Redes

Neuroidales

- LabView

- MATLAB

- HP VEE

- Metodología de

simulación de

Redes

Neuroidales

Internet,

Foros,

Revistas,

Bibliografías

Tabla 6: Matriz de operacionalización de variables.


48

3.6 INSTRUMENTOS DERECOLECCIÓN DE DATOS

3.6.1 TÉCNICAS E INSTRUMENTOS DE LA INVESTIGACIÓN

La técnica que se va a utilizar para la recolección de información es la

entrevista y el instrumento fue el cuestionario que se realizara a

especialistas en redes neuroidales del programa PROMEINFO.

Ver anexo para ver las preguntas utilizadas en la entrevista ().

La entrevista: Se entiende por entrevista al proceso de interrogar o hacer

preguntas a una persona con el fin de captar sus conocimientos y opiniones

acerca de algo, con la finalidad de realizar alguna labor específica con la

información captada. Hay diferentes formas de realizar esta tarea: vía

telefónica que es la más frecuente, por entrevistas personales, cara a cara, o

por correo.

La entrevista presentada en este proyecto, expone una serie de

interrogantes acerca la implementación del modelo neuroidal en el desarrollo

de software.

El cuestionario: El cuestionario empleado está dirigido a dos especialistas

en el tema de redes neuroidales. Se utilizaran preguntas claras y concretas,

con la finalidad de obtener datos para tener conocimiento de que

metodología se usó para simular la creación de redes neuroidales.

3.7 VALIDACIÓN

Para validar el desarrollo del software se realizaron pruebas con el Ph.D

Ricardo Silva Bustillos las cuales cumplieron con sus expectativas y aprobó

el desarrollo.

Se adjunta documento de aprobación en anexo ().

49

3.8 PROCEDIMIENTOS DE LA INVESTIGACIÓN

El problema:

Planteamiento del Problema

Ubicación del Problema en un contexto

Situación Conflicto Nudos Críticos

Causas y Consecuencias del Problema

Delimitación del Problema

Formulación del Problema

Evaluación del Problema

Objetivos de la Investigación

Alcance del Problema

Justificación e Importancia

Marco teórico:

Antecedentes del estudio

Fundamentación teórica

Fundamentación legal

Hipótesis Preguntas a contestarse

Variables de la investigación

Definiciones conceptuales

Justificación de la Metodología y Herramientas

Justificación de la Herramienta

Metodología:

Diseño de Investigación

Modalidad de la Investigación

Tipo de investigación

Población y Muestra

Operacionalización de las variables

Instrumentos de recolección de datos

Instrumentos de la investigación

Procedimientos de la investigación

Recolección de información

50

Entrevista

Conclusiones y recomendaciones

3.9 RECOLECCIÓN DE LA INFORMACIÓN

La técnica utilizada para el presente proyecto de tesis es la entrevista, a

continuación mencionaremos las actividades que se realizaron para la

recolección de la información:

Realizar entrevista al director del programa PROMEINFO.

Identificar a los participantes del proyecto.

Contactar al director del programa PROMEINFO a través del correo

electrónico, para definir la fecha y horario para realizar la entrevista.

Elaboración de cronograma para realizar la entrevista.

Contactar al docente especialista en el tema de redes neuroidales a

través del correo electrónico, para envío y resolución del cuestionario.

3.10 PROCESAMIENTO Y ANÁLISIS

Esta etapa se cumple posterior a la aplicación de los instrumentos. En este

punto, se realizará un análisis de la información resultante de la entrevista

realizada.

¿Qué herramientas de software conoce para simular la creación de

redes neuroidales?

Respuesta:

Hasta el momento en lo único que se ha implementado es en LabView, no

existen herramientas de software para redes neuroidales. El desarrollo de

este software sería la primera herramienta que se está creando

específicamente para redes neuroidales. Lo único que se ha hecho de redes

neuroidales es la tesis doctoral de Erick Argüello en Venezuela para la cual

utilizo como herramienta de programación gráfica el software LabView de

National Instruments, cuyo software es un lenguaje de programación gráfica

donde se puede desarrollar varios programas.

51

Análisis:

El desarrollo de este software para simular la creación de redes neuroidales

sería un aporte muy valioso para futuras investigaciones y se ahorraría

tiempo en desarrollo y dinero, ya que en la única plataforma que se ha

implementado el modelo del neuroide es en LabView cuya licencia está entre

los $3000.

¿Cuáles son las expectativas que Ud. tiene con el desarrollo de un

software propio para simular la creación de redes neuroidales?

Respuesta:

La expectativa es promover el uso y la investigación de las redes

neuroidales. En Inteligencia Artificial para el procesamiento de imágenes,

etc. se utilizan las redes neuronales, donde el elemento de cálculo es un

perceptrón que fue desarrollado por McCulloch y Pitts, donde el perceptrón

es una compuerta muy sencilla que equivale básicamente a la primera etapa

del neuroide a la cual llamamos etapa de sinapsis, es decir, el perceptrón

corresponde a una tercera parte de lo que es el neuroide. En conclusión si

con un perceptrón se ha podido hacer varias cosas, entonces que no se

podría hacer con el neuroide. Por eso es importante el desarrollo de este

software para que las personas comiencen a utilizar el neuroide.

Análisis:

La elaboración de este software es muy importante por el motivo que es el

primer desarrollo que va a trabajar específicamente con las redes

neuroidales y de esta manera se promueve el uso del modelo neuroidal.

¿En que se beneficiaría el programa PROMEINFO en contar con un


Respuesta:

PROMEINFO particularmente parte:

1.- El primer desarrollo universitario nacional de un software de

programación gráfica orientada a procesamiento de señales. Este sería el

primer desarrollo propio de una herramienta de programación con una

interfaz completamente novedosa. La Universidad de Guayaquil en su

52

programa PROMEINFO estaría brindando una nueva herramienta que

serviría para ayudar a todo el planeta.

2.- Da la posibilidad para que nuevos estudiantes puedan continuar con el

desarrollo. Parte de la idea del desarrollo de esta herramienta es que quede

bien documentada para que después otros estudiantes puedan seguir

agregándole funcionalidad.

3.- Estudiantes profesionales de neurociencia puedan emular redes

neuronales fisiológicas y ver cómo funcionan, y por medio de la informática

poder experimentar el uso de las redes neuroidales en el campo de la

inteligencia artificial para hacer pruebas de lo que se ha hecho hasta ahora

con los perceptrones.

Análisis:

La Universidad de Guayaquil a través de su programa PROMEINFO sería la

primera universidad en el mundo en contar con un software para realizar

investigaciones del modelo neuroidal. La importancia de contar con este tipo

de programas como PROMEINFO es que les da la posibilidad a estudiantes

a culminar su carrera universitaria a través de alguna implementación

novedosa que servirá para la comunidad.

¿Cuáles serían los usuarios finales que usarían el software propuesto?

Respuesta:

Por un lado hay personas que están trabajando en el campo de la

inteligencia artificial en el procesamiento de señales, procesamiento de

imágenes y por el otro lado tenemos a las personas que están en el camino

de las neurociencias que quieren entender cómo funcionan las redes

neuronales fisiológicas. También existe una serie de disciplinas derivadas a

personas que estudian robótica, cibernética, etc. todas estas personas

podrían ser los usuarios finales del software.

Análisis:

El presente software va dirigido a la comunidad científica que realiza

estudios de Inteligencia Artificial, robótica, cibernética, etc.

53

¿El desarrollo de este software libre podrá ser una alternativa válida

para el software LabView que se utilizó para simular la creación de

redes neuroidales?

Respuesta:

Por supuesto, el costo de licencia del software LabView está alrededor de

los $3000, este software permite colocar bloques que cuentan con funciones

matemáticas muy complejas por tal motivo es caro.

Ahora queremos desvincularnos de la enorme plataforma de LabView con el

desarrollo de un software propio enfocado única y exclusivamente a las

redes neuroidales, y el hecho de que sea una interfaz gráfica y sencilla,

serviría de ayuda a personas que no saben nada de programación como

neurólogos, psiquiatras, psicólogos, van a poder utilizar la herramienta como

parte de su estudio.

Análisis:

La idea principal de contar con este software es que sea gratis para que

cualquier persona lo pueda utilizar, por esta razón si es una alternativa válida

con relación a la poderosa herramienta de LabView. Entre la ventaja que no

tenemos que programar nada, simplemente se ingresan los requerimientos

para crear

54

CAPÍTULO IV

MARCO ADMINISTRATIVO

Con la finalidad de definir las tareas que se llevaran a cabo para tener un

mejor control del proyecto, se determina el siguiente cronograma.

4.1 CRONOGRAMA DE ACTIVIDADES

En este punto se detallaran las actividades que se realizaran en el proyecto

y el tiempo que se empleará en el desarrollo de las mismas.

Fases Tiempo/ Días

Fase I – Análisis 30

Fase II- Diseño 60

Fase III- Implementación 25

Fase IV - Pruebas 5

Fase V- Depuración de código 5

Entrega de documentos finales 1

Entrega de Prototipo 1

Total/Días 125

Tabla 7: Cronograma

Autor: Andrés Silva Muñoz Para más detalles de las actividades ver anexo ().

4.2 RECURSOS

Entre los equipos físicos y lógicos que se utilizaron en el desarrollo del

proyecto se incluyeron:

HARDWARE

Las especificaciones tecnológicas con las que contó nuestro equipo para la

implementación del proyecto son las siguientes:

Memoria RAM 6 GB.

700 GB disco duro.

Procesador Intel Core I7.

55

SOFTWARE

Para esta parte se propone las siguientes especificaciones:

Eclipse Luna

JDK 8

4.3 PRESUPUESTO

Se realiza un resumen de los gastos que se incurrirán en el proceso de

desarrollo de la tesis, durante el tiempo que durará su ejecución. También se

especifica el origen de los recursos económicos

EGRESOS DÓLARES

Acceso a servicio de Internet 125,00

Útiles de oficina y computación 25,00

Empastado anillado de tesis 50,00

Transporte 25,00

Refrigerios 50,00

Laptop 700,00

TOTAL…………………………………… $ 975.00

Tabla 8: Detalles de egresos del proyecto.


A continuación se detallan los ingresos que involucran la elaboración del

software para construir redes neuroidales.

INGRESOS DÓLARES

Aportación Andrés Silva Muñoz $ 1000.00

TOTAL $

1000.00

Tabla 9: Detalles de ingresos del proyecto.


56

CAPÍTULO V

CONCLUSIONES Y RECOMENDACIONES

6.1 CONCLUSIONES

A continuación detallamos las principales conclusiones del proyecto:

La escasa información relacionada a las redes neuroidales o al

neuroide nos lleva a la conclusión de que con la culminación de este

desarrollo se podrá contar con una guía que estará en los repositorios

de la Carrera de Ingeniería en Sistemas de la Universidad de

Guayaquil, la cual estará al alcance de cualquier persona que le

interese el tema de neurociencias.

Finalizada la elaboración de la interfaz del software para simular la

construcción de redes neuroidales podemos concluir que se cuenta

con una herramienta que sirve como un instrumento para simular la

creación de una red neuroidal de manera gráfica.

Durante la fase de Diseño e Implementación para el desarrollo del

software se escogió a Java como lenguaje de programación, y el IDE

de Eclipse Luna como entorno de desarrollo. En este punto podemos

concluir que para la implementación de la interfaz de usuario, el IDE

que habíamos escogido no el ideal para desarrollar aplicaciones de

escritorio en cuanto a tiempo de desarrollo porque se debe tener

muchos conocimientos de como programar por código fuente una

barra de menús, la barra de herramientas, como ubicar los elementos

en la ventana, etc. Para minimizar estos tiempos se pudo utilizar el

IDE de NetBeans porque en su editor presenta herramientas para

arrastrar y soltar objetos lo cual nos hubiera ahorrado inclusive

muchas líneas de código.

57

6.2 RECOMENDACIONES

De todas las conclusiones se toman dos grandes grupos para unificar la

apreciación crítica y señalar los aspectos que sean generadores de actitudes

y/o procedimientos.

Es importante señalar que la implementación de este software es de

gran importancia porque el modelo neuroidal fue concebido partiendo

de conceptos básicos de las redes neuronales en la cual un

perceptrón ha logrado resultados satisfactorios en el campo de la

neurobiología, el mismo que corresponde a la tercera parte de un

neuroide, por tal motivo, el desarrollo de este software libre es una

base para incentivar a los estudiantes o investigadores a rediseñar

algoritmos y adaptarlos al software.

Se recomienda proponer mejoras al prototipo de este proyecto ya sea

para realizar un aplicativo web con la idea de poder abrir la aplicación

desde cualquier computador a través de un navegador, y realizar

pruebas utilizando como referencia el modelo del Dolor por el motivo

que este modelo es el único que hasta ahora ha sido validado por el

autor.

El desarrollo este software queda como base para una siguiente fase

que sería la implementación de los algoritmos matemáticos

necesarios para agregarle funcionalidad a los neuroides para que

puedan procesar los datos que se ingresan desde la interfaz gráfica

ya sean por medio de los bloques de entrada o por un neuroide. De

esta manera se estaría emulando el comportamiento de una neurona

artificial.

58

BIBLIOGRAFÍA

Abe, K., Kato, G., Katafuchi, T., Tamae, A., Furue, H., & Yoshimura, M.

(2009). Responses to 5-HT in morphologically identified neurons in the rat

substantia gelatinosa in vitro. Neuroscience, 316-324.

Adrian, E. D., & Zotterman, Y. (1926). The impulses produced by sensory

nerve endings. Part 2. The response of a single end-organ. J Physiol, 11-

171.

Agi, E., Ozgen, C., & Purali, N. (2010). Modeling of Gate Control Neuronal

Circuitry including Morphologies and Physiologies of Component Neurons

and Fibres. 9th International Symposium on Dynamics and Control of

Process Systems (DYCOPS 2010) (págs. 857-862). Leuven, Belgium:

International Federation of Automatic Control.

Ahlgren, S. C., Wang, J. F., & Levine, J. D. (1997). C-fiber mechanical

stimulus-response functions are different in inflammatory versus neuropathic

hyperalgesia in the rat. Neuroscience, 285-290.

Aicher, S. A., Hermes, S. M., Whittier, K. L., & Hegarty, D. M. (2012).

Descending projections from the rostral ventromedial medulla (RVM) to

trigeminal and spinal dorsal horns are morphologically and neurochemically

distinct. J Chem Neuroanat, 103-111.

Amaya, J. A. (2010). Sistemas de información gerenciales: hardware,

software, redes, Internet, diseño (SIL). Bogota: Ecoe Ediciones.

Andrew, D., & Greenspan, J. D. (1999). Mechanical and Heat Sensitization of

Cutaneous Nociceptors after Peripheral Inflammation in the Rat. J

Neurophysiol, 2649-2655.

Antal, M., Petko, M., Polgár, E., Heizmann, C. W., & Storm-Mathisen, J.

(1996). Direct evidence of an extensive GABAergic innervation of the spinal

dorsal horn by fibres descending from the rostral ventromedial medulla.

Neuroscience, 509-518.

Argüello Prada, E. J. (2013). The implementation of the Neuroid in the Gate

Control System leads to new ideas about pain processing. Revista Brasileira

de Engenharia Biomédica, 29(3), 254-261.

Arguello, E. S. (2012). The neuroid: a novel and simplified neuron-model.

Engineering in Medicine and Biology Society (EMBC), 2012 Annual

International Conference of the IEEE, 1234-1237.

59

Basbaum, A. I., Bautista, D. M., Scherrer, G., & Julius, D. (2009). Cellular

and molecular mechanisms of pain. Cell, 267-284.

Beard, D. A., Bassingthwaighte, J. B., & Greene, A. S. (2005). Computational

modeling of physiological systems. Physiol Genomics, 1-3.

Bessou, P., & Perl, E. R. (1969). Response of cutaneous sensory units with

unmyelinated fibers to noxious stimuli. J Neurophysiol, 1025-1043.

Blix, M. (1884). Experimentelle Beitrag zur Lösung der Frage uber die

spezifische Energie der Hautnerven. Z Biol, 141-156.

Boulais, N., & Misery, L. (2008). The epidermis: a sensory tissue. Eur J

Dermatol, 119-27.

Braun, H. A., Huber, M. T., Anthes, N., Voigt, K., Neiman, A., Pei, X., &

Moss, F. (2001). Noise-induced impulse pattern modifications at different

dynamical period-one situations in a computer model of temperature

encoding. Biosystems, 99-112.

Brette, R., Rudolph, M., Carnevale, T., Hines, M., Beeman, D., Bower, J. M.,

. . . Vieville, T. (2007). Simulation of networks of spiking neurons: A review of

tools and strategies. J Comput Neurosci, 349-398.

Britton, N. F., & Skevington, S. M. (1989). A mathematical model of the gate

control theory of pain. J Theor Biol, 91-105.

Britton, N. F., & Skevington, S. M. (1996). On the mathematical modelling of

pain. Neurochem Res, 1133-40.

Britton, N. F., Chaplain, M. A., & Skevington, S. M. (1996). The role of N-

methyl-D-aspartate (NMDA) receptors in wind-up: A mathematical model.

Math Med Biol, 193-205.

Burgess, P. R., & Perl, E. R. (1967). Myelinated afferent fibres responding

specifically to noxious stimulation of the skin. J Physiol, 541-562.

Cain, D. M., Khasabov, S. G., & Simone, D. A. (2001). Response properties

of mechanoreceptors and nociceptors in mouse glabrous skin: an in vivo

study. J Neurophysiol, 1561-1574.

Cavanaugh, D. J., Lee, H., Lo, L., Shields, S. D., Zylka, M. J., Basbaum, A. I.,

& Anderson, D. J. (2009). Distinct subsets of unmyelinated primary sensory

60

fibers mediate behavioral responses to noxious thermal and mechanical

stimuli. PNAS, 9075-9080.

Cervero, F., & Laird, J. M. (1991). One pain or many pains? A new look at

pain mechanisms. News Physiol Sci, 268-273.

Costigan, M., Scholz, J., & Woolf, C. J. (2009). Neuropathic Pain: A

Maladaptive Response of the Nervous System to Damage. Annu Rev

Neurosci, 1-32.

Cui, M., Feng, Y., McAdoo, D. J., & Willis, W. D. (1999). Periaqueductal gray

stimulation-induced inhibition of nociceptive dorsal horn neurons in rats is

associated with the release of norepinephrine, serotonin, and amino acids. J

Pharmacol Exp Ther, 868–876.

Dahlaus, A., Ruscheweyh, R., & Sandkuhler, J. (2005). Synaptic input of rat

spinal lamina I projection and unidentified neurons in vitro. J Physiol, 355-

368.

de Sousa, M. A., & de Jesus Torres, T. F. (2013). Modeling of pain on a

FPGA-based neural network. IASTED International Conference Artificial

Intelligence and Aplications (págs. 64-69). Innsbruck, Austria: Actapress.

Decosterd, I., Ji, R. R., Abdi, S., Tate, S., & Woolf, C. J. (2002). The pattern

of expression of the voltage-gated sodium channels Na(v), 1.8 and Na(v), 1.9

does not change in uninjured primary sensory neurons in experimental

neuropathic pain models. Pain, 857-872.

Djhouri, L., Fang, X., Okuse, K., Wood, J. N., Berry, C. M., & Lawson, S.

(2003). The TTX-resistant sodium channel Nav1.8 (SNS/PN3): expression

and correlation with membrane properties in rat nociceptive primary afferent

neurons. J Physiol, 739-752.

Djouhri, L., & Lawson, S. N. (2004). Abeta-fiber nociceptive primary afferen

neurons: a review of incidence and properties in relation to other afferent A-

fiber neurons in mammals. Brain Res Brain Res Rev, 131-45.

Dogrul, L., Ossipov, M. H., & Porreca, F. (2009). Differential mediation of

descending pain facilitation and inhibition by spinal 5HT-3 and 5HT-7

receptors. Brain Res, 52-59.

Doly, S., Fischer, J., Brisorgueil, M. J., Verge, D., & Conrath, M. (2005). Pre-

and postsynaptic localization of the 5-HT7 receptor in rat dorsal spinal cord:

immunocytochemical evidence,. J Comp Neurol, 256-269.

61

Eclipse. (s.f.). Eclipse org. Obtenido de Eclipse org: https://eclipse.org

Erb, W. (1874). Handbuch der Krankheiten des Nervensystems II. Leipzig,

Germany: F. C. W. Vogel.

Fang, X., McMullan, S., Lawson, S. N., & Djouhri, L. (2005).

Electrophysiological differences between nociceptive and non-nociceptive

dorsal root ganglion neurons in the rat in vivo. J Physiol, 927-943.

Faradijavar, A., Towhidkhah, F., Mirhashemi, A., Gharibzadeh, S., &

Behbehani, K. (2006). Computational modeling of A fiber wind-up. 28th IEEE

Annu Int Conf Engineering in Medicine and Biology Society, (págs. 4975-

4978). New York, USA.

Farajidavar, A., Saeb, S., & Behbehani, K. (2008). Incorporating synaptic

time-dependent plasticity and dynamic synapse into a computational model

of wind-up. Neural Networks, 241-249.

Fields, H. L., & Basbaum, A. I. (1999). Central nervous system mechanisms

of pain modulation. En P. D. Wall, & R. Melzack, Textbook of Pain (págs.

309-329). London, UK: Churchill Livingstone.

Fields, H. L., Bry, J., Bentall, I., & Zorman, G. (1983). The activity of neurons

in the rostral medulla of the rat during withdrawal from noxious heat. J

Neurosci, 2545-2552.

Garcia, L. (2012). Slideshare - cableado Estructurado. Obtenido de

http://es.slideshare.net/luisgarcia0517/cableado-estructurado-6399720.

Gerstner, W., & Kistler, W. M. (2002). Spiking Neuron Models: Single

Neurons, Populations, Plasticity. Cambridge, UK: Cambridge University

Press.

Goldscheider, A. (1884). Die specifische energie der gefühlsnerven der haut.

Mh Prak Derm, 283.

Goldscheider, A. (1894). Goldscheider, Ueber den Schmerz in

Physiologischer und Klinischer Hinsicht: Nach einem Vortrage in der Berliner

Militärärztlichen Gesellschaft. Ann Arbor, MI: University of Michigan Library.

Golowash, J., Goldman, M. S., Abbott, L. F., & Marder, E. (2001). Failure of

averaging in th construction of a conductance-based neuron model. J

Neurophysiol, 1129-1131.

Green, B. G. (2004). Temperature perception and nociception. J Theor Biol,

13-29.

62

Grudt, T. J., & Perl, E. R. (2002). Correlations between neuronal morphology

and electrophysiological features in the rodent superficial dorsal horn. J

Physiol, 189-207.

Haeri, M., Asemani, D., & Gharibzadeh, S. (2003). Modeling of pain using

artificial neural networks. J Theor Biol, 277-284.

Harrington, M. G., Chekmenev, E. Y., Schepkin, V., Fonteh, A. N., & Arakaki,

X. (2011). Sodium MRI in a rat migraine model and a NEURON simulation

study support a role for sodium in migraine. Cephalalgia, 1254-1265.

Haykin, S. (1999). Neural Networks: A Comprehensive Foundation.

Englewood Cliffs, NJ: Prentice Hall.

Heinricher, M. M., & Ingram, S. L. (2008). The brainstem and nociceptive

modulation. En B. M. C., & A. I. Basbaum, The senses, a comprehensive

reference (págs. 593-626). San Diego, CA: Pain Academic Press.

Henderson, L. A., Peck, C. C., Petersen, E. T., Rae, C. D., Youssef, A. M.,

Reeves, J. M., . . . Gustin, S. M. (2013). Chronic Pain: Lost Inhibition? J

Neurosci, 7574 –7582.

Herz, A. V., Gollish, T., Machens, C. K., & Jaeger, D. (2006). Modeling

Single-Neuron Dynamics and Computations: A Balance of Detail and

Abstraction. Science, 80-85.

Hewlett Packard Company. (1998). hp. Obtenido de hp:

www.hp.com/go/HPVEE

Hines, M., & Carnevale, N. T. (1997). The NEURON simulation environment.

Neural Computation, 1179-1209.

Hodgkin, A. L., & Huxley, A. F. (1952). A quantitative description of

membrane current and its application to conduction and excitation nerve. J

Physiol, 500-44.

Hopfield, J. J. (1982). Neural networks and physical systems with emergent

collective computational abilities. Proc Natl Acad Sci USA, 2554-2558.

Hopfield, J. J. (1984). Neurons with graded response have collective

computational properties like those of two-state neurons. Proc Natl Acad Sci

USA, 3088-3092.

63

IEEE Computer Society. (1993). IEEE Software Engineering Standard 729-

1993: Glossary of Software Engineering Terminology. California: IEEE

Computer Society Press.

Izhikevich, E. M. (2003). Simple Model of Spiking Neuron. IEEE Transaction

on Neural Networks, 1569-1572.

Kato, G., Katafuchi, T., Furue, H., Mizuno, M., Iwamoto, Y., & Yoshimura, M.

(2006). Direct GABAergic and glycinergic inhibition of the substantia

gelatinosa from the rostral ventromedial medulla revealed by in vivo patch-

clamp analysis in rats. J Neurosci, 1787-1794.

Kostyuk, P. G., Veselovsky, N. S., & Tsyandryenko, A. Y. (1981). Ionic

currents in the somatic membrane of rat dorsal root gnalglion neurons. I.

Sodium currents. Neuroscience, 2423-2440.

Lapicque, L. (1907). Recherches quantitatives sur l’excitation e´lectrique des

nerfs traite´e comme une polarization. J Physiol Patol Gen, 620–635.

Lawson, S. N. (2002). Phenotype & function of somatic primary afferent

nociceptive neurons with C-, Aδ or Aα/β-fibres. J Exp Physiol, 239-244.

Loeser, J. D., & Treede, R. -D. (2008). The Kyoto protocol of IASP Basic

Pain Terminology. Pain, 473-477.

Lu, Y., & Perl, E. R. (2003). A specific inhibitory pathway between substantia

gelatinosa neurons receiving direct C-fiber input. J Neurosci, 8752–8758.

Lu, Y., & Perl, E. R. (2005). Modular organization of excitatory circuits

between neurons of the spinal superficial dorsal horn (laminae I and II). J

Neurosci, 3900–3907.

Lu, Y., & Perl, E. R. (2007). Selective action of noradrenaline and serotonin

on neurones of the spinal superficial dorsal horn in the rat. J Physiol, 127-

136.

Lv, Y. G., & Liu, J. (2005). Interpretation on thermal comfort mechanisms of

human bodies by combining Hodgkin–Huxley neuron model and Pennes

bioheat equation. Forschung Ing, 101-114.

Ma, Q. (2010). Labeled lines meet and talk: population coding of somatic

sensations. J Clin Invest, 3773-3778.

64

MathWorks. (s.f.). MathWorks. Recuperado el marzo de 2015, de

MathWorks: http://www.mathworks.com/videos/?s_tid=hp_ff_a_videos

Maxwell, D. J., Belle, M. D., Cheunsuang, O., Stewart, A., & Morris, R.

(2007). Morphology of inhibitory and excitatory interneurons in superficial

laminae of the rat dorsal horn. J Physiol, 521–533.

McCulloch, W. S., & Pitts, W. H. (1943). A logical calculus of the ideas

immanent in nervous activity. Bull. Math. Biophysics, 115–133.

Melzack, R., & Wall, P. D. (1965). Pain mechanisms: a new theory. Science,

971-9.

Melzack, R., & Wall, P. D. (1982). The challenge of pain. Harmondsworth,

UK: Penguin Books.

Merskey, H., & Bogduk, N. (1994). Classification of Chronic Pain. Part III:

Pain terms, a current list with definitions and notes on usage. IASP task force

on taxonomy (págs. 209-14). Seattle, USA: IASP Press.

Miles, J. (1984). Electrical stimulation for the relief of pain. Ann R Coll Surg

Engl, 108-112.

Millán, M. (1999). The induction of pain: an integrative review. Progress in

Neurobiology, 1-164.

Minamitami, H., & Hagita, N. (1981). A neural network model of pain

mechanisms: computer simulation of the central neural activities essential for

the pain and touch sensations. IEEE Transactions on Systems, Man and

Cybernetics, 481-493.

Miracourt, L. S., Dallel, R., & Vosin, D. L. (2007). Gycine inhibitory

disnfunction turns touch into pain through PKCgamma interneurons. PLoS

ONE, 1111-1115.

Moayedi, M., & Davis, K. D. (2013). Theories of pain: from specificity to gate

control. J Neurophysiol, 5-12.

Moore, R. Y. (1981). The anatomy of central serotonin neuron systems in the

rat brain. En B. L. Jacobs, & A. Gelperin, Serotonin Neurotransmission And

Behavior (págs. 35-71). Cambridge, MA: MIT Press.

65

Mori, M., Kose, A., Tsujino, T., & Tanaka, C. (1990). Immunocytochemical

localization of protein kinase C subspecies in the rat spinal cord: light and

electron microscopic study. J Comp Neurol, 167-177.

Muriel, C. (2007). Dolor Crónico. Madrid: Arán Ediciones.

Nafe, J. P. (1929). A quantitative theory of feeling. J Gen Psychol, 199-211.

NI. (s.f.). National Instruments. Obtenido de National Instruments:

http://www.ni.com/labview/esa/

Packard, H. (s.f.). hp. Obtenido de hp.

Perl, E. (2007). Ideas about pain, a historical view. Nature Review

Neuroscience, 71-80.

Picton, P. D., Campbell, J. A., & Turner, S. J. (2001). Modelling Chronic Pain:

An Initial Survey. Eight International Conference on Neural Information

Processing (págs. 1267-1270). Shangai, China: Fudan University Press.

Polgár, E., Al-Khater, K. M., Shehab, S., Watanabe, M., & Todd, A. J. (2008).

Large Projection Neurons in Lamina I of the Rat Spinal Cord That Lack the

Neurokinin 1 Receptor Are Densely Innervated by VGLUT2-Containing

Axons and Possess GluR4-Containing AMPA Receptors. J Neurosci, 13150-

13160.

Polgár, E., Fowler, J. H., McGill, M. M., & Todd, A. J. (1999). The types of

neuron which contain protein kinase C ganna in rat spinal cord. Brain Res,

71-80.

Polgár, E., Puskár, Z., Watt, C., Matesz, C., & Todd, A. J. (2002). Selective

innervation of laimna I projection neurones that possess the neurokinin 1

receptor by serotonin-containing axons in the rat spinal cord. Neuroscience,

799-809.

Prescott, S. A., & De Konink, Y. (2002). Four cell types with distinctive

membrane properties and morphologies in lamina I of the spinal dorsal horn

of the adult rat. J Physiol, 817-836.

Prescott, S., & Ratté, S. (2012). Pain processing by spinal microcircuits:

afferent combinatorics. Curr Opin Neurobiol, 631-639.

Prince, K., Campbell, J., Picton, P., & Turner, S. J. (2004). A computational

model of acute pain. 18th European Simulation Multiconference (ESM2004):

66

Networked Simulations and Simulated Networks (págs. 117-122).

Magdeburg, Germany: SCS Publishing.

Purves, D., Augustine, G. J., Fitzpatrick, D., Hall, W. C., Lamantia, A. S., &

Williams, S. M. (2007). Neurociencia. Madrid: Editorial Médica

Panamericana.

Rall, W. (1989). Cable theory for dendritic neurons. En C. Koch, & I. Segev,

Methods in Neuronal Modeling (págs. 8-62). Cambridge, MA: MIT Press.

Rexed, B. (1952). The cytoarchitectonic organization of the spinal cord in the

cat. J Comp Neurol, 414-495.

Reynolds, D. V. (1969). Surgery in th rat during electrical analgesia induced

by focal brain stimuation. Science, 444-445.

Ringkamp, M., & Meyer, R. A. (2009). Physiology of Nociceptors. En A. I.

Basbaum, & M. C. Bushnell, Science of Pain (págs. 723-762). San Diego,

CA: Academic Press.

Ritz, L. A., & Greenspan, J. D. (1985). Morphological features of lamina V

neurons receiving nociceptive input in a cat sacrocaudal spinal cord. J Comp

Neurol, 440-52.

Ross, S. E. (2011). Pain and itch: insights into the neural circuits of aversive

somatosensation in health and disease. Curr Opin Neurobiol, 880-887.

S. Sumathi, P. Surekha. (2007). Labview-based Advanced Instrumentation

Systems. Springer Science & Business Media.

Schmelz, M., Schmidt, R., Bickel, A., Handwerker, H. O., & Torebjörk. (1997).

Specific C-receptors for itch in human skin. J Neurosci, 8003-8008.

Sherrington, C. S. (1906). The integrative action of the nervous system. New

Haven, CT: Yale University Press.

Shortland, P., & Woolf, C. J. (1997). Morphology and somatotopy of the

central arborizations of rapidly adapting glabrous skin afferents in the rat

lumbar spinal cord. J Comp Neurol, 491-511.

Slugg, R. M., Campbell, J. N., & Meyer, R. A. (2004). The population

response of A- and C-fiber nociceptors in monkey encodes high intensity

mechanical stimuli. J Neurosci, 4649-4656.

67

Slugg, R. M., Meyer, R. A., & Campbell, J. N. (2000). Response of

Cutaneous A- and C-Fiber Nociceptors in the Monkey to Controlled-Force

Stimuli. J Neurophysiol, 2179-2191.

Takeuchi, E., Yamanobe, T., Pakdaman, K., & Sato, S. (2001). Analysis of

models for crustacean stretch receptors. Biol Cybernet, 349-363.

Tan, A. M., Stamboulian, S., Chang, Y. -W., Zhao, P., Hains, A. B., Waxman,

S. G., & Hains, B. C. (2008). Neuropathic pain memory is maintained by

Rac1-regulated dendritic spine remodeling after spinal cord injury. J

Neurosci, 13173-13183.

Todd, A. J. (1991). Immunohistochemical evidence that acetylcholine and

glycine exist in different populations of GABAergic neurons in lamina III of rat

spinal dorsal horn. Neuroscience, 741-6.

Todd, A. J. (2010). Neuronal circuitry for pain processing in the dorsal horn.

Nat Rev Neurosci, 823-826.

Torkkeli, P. H., & French, S. A. (2002). Simulation of different firing patterns

in paired spider mechanoreceptor neurons: the role of Na(+) channel

inactivation. J Neurophysiol, 1363-1368.

Van Hees, J., & Gybels, J. (1981). C nociceptor activity in human nerve

during painful and non painful skin stimulation. J Neurol Neurosurg

Psychiatry, 600-607.

von Frey, M. (1894). Beiträge zur physiologie des schmerzsinns. Königl

Sächs Ges Wiss, Math Phys Classe, pp. 185–196.

Wu, S. -X., Wang, W., Li, H., Wang, Y. -Y., Feng, Y. -P., & Li, Y. -Q. (2010).

The synaptic connectivity that underlies the noxious transmission and

modulation within the superficial dorsal horn of the spinal cord. Progress in

Neurobiology, 38-54.

Yasaka, T., Tiong, S. Y., Hughes, D. I., Ridell, J. S., & Todd, A. J. (2010).

Populations of inhibitory and excitatory interneurons in lamina II of the adult

rat spinal dorsal horn revealed by a combined electrophysiological and

anatomical approach. Pain, 475–488.

Zeilhofer, H. U., Wildner, H., & Yévenes, G. E. (2012). Fast synaptic

inhibition in spinal sensory processing and pain control. Physiol Rev, 193-

235.

68

Zeitz, K. P., Guy, N., Malmberg, A. B., Dirajlal, S., Martin, W. J., Sun, L., . . .

Basbaum, A. I. (2002). The 5-HT3 subtype of serotonin receptor contributes

to nociceptive processing via a novel subset of myelinated and unmyelinated

nociceptors. J Neurosci, 1010-9.

Zhang, E. T., Han, Z. S., & Craig, A. D. (1996). Morphological classes of

spinothalamic lamina I neurons in the cat. J Comp Neurol, 537–549.

Zheng, J., Lu, Y., & Perl, E. R. (2010). Inhibitory neurones of the spinal

substantia gelatinosa mediate interaction of signals from primary afferents. J

Physiol, 2065-2075.

Zhu, Y. J., & Lu, T. J. (2010). A multi-scale view of skin thermal pain: from

nociception to pain sensation. Philosophical Transactions of the Royal

Society A: Mathematical, Physical and Engineering Sciences, 521-559.

69

ANEXOS

LA ENTREVISTA

¿Qué herramientas de software conoce para simular la creación de

redes neuroidales?

Hasta el momento en lo único que se ha implementado es en LabView, no

existen herramientas de software para redes neuroidales. El desarrollo de

este software sería la primera herramienta que se está creando

específicamente parar redes neuroidales. Lo único que se ha hecho de

redes neuroidales es la tesis doctoral de Erick Argüello en Venezuela para

la cual utilizo como herramienta de programación gráfica el software

LabView de National Instruments, cuyo software es un lenguaje de

programación gráfica donde se puede desarrollar varios programas.

¿Le gustaría disponer de un software propio para simular la creación

de redes neuroidales?(Marque con una X su respuesta)

SI NO

¿Cuáles son las expectativas que Ud. tiene con el desarrollo de un


La expectativa es promover el uso y la investigación de las redes

neuroidales. En Inteligencia Artificial para el procesamiento de imágenes,

etc. se utilizan las redes neuronales, donde el elemento de cálculo básico

es un perceptrón que fue desarrollado por McCulloch y Pitts, el cual es

una compuerta muy sencilla que equivales básicamente a la primera

etapa del neuroide a la cual llamamos etapa de sinapsis, es decir, el

perceptrón corresponde a una tercera parte de lo que es el neuroide. En

conclusión si con un perceptrón se ha podido hacer varias cosas,

entonces que no se podría hacer con el neuroide. Por eso es importante

el desarrollo de este software para que las personas comiencen a utilizar

el neuroide.

X

70

¿En que se beneficiaría el programa PROMEINFO en contar con un


PROMEINFO particularmente parte:

1.- El primer desarrollo universitario nacional de un software de

programación gráfica orientada a procesamiento de señales. Este sería el

primer desarrollo propio de una herramienta de programación con una

interfaz completamente novedosa. La Universidad de Guayaquil en su

programa PROMEINFO estaría brindando una nueva herramienta que

serviría para ayudar a todo el planeta.

2.- Da la posibilidad para que nuevos estudiantes o nuevos tesistas, por

un lado puedan continuar con el desarrollo. Parte de la idea del desarrollo

de esta herramienta es que quede bien documentada para que después

otros estudiantes puedan seguir agregándole funcionalidad.

3.- Estudiantes profesionales de neurociencia puedan emular redes

neuronales fisiológicas y ver cómo funcionan, y por medio de la

informática poder experimentar el uso de las redes neuroidales en el

campo de la inteligencia artificial para hacer pruebas de lo que se ha

hecho hasta ahora con los perceptrones.

¿Cuáles serían los usuarios finales que usarían el software

propuesto?

Por un lado hay personas que están trabajando en el campo de la

inteligencia artificial en el procesamiento de señales, procesamiento de

imágenes y por el otro lado tenemos a las personas que están en el

camino de las neurociencias que quieren entender cómo funcionan las

redes neuronales fisiológicas. También existe una serie de disciplinas

derivadas a personas que estudian robótica, cibernética, etc. todas estas

personas podrían ser los usuarios finales del software.

¿Cree usted que el prototipo propuesto tiene una interfaz amigable

para el usuario? (Marque con una X su respuesta)

SI NO

X

71

¿Existe la posibilidad que el desarrollo de este software sea

publicado en algún artículo de las revistas IEEE?

Claro que sí, de hecho me gustaría publicar un artículo, del cual tenemos

hasta el seis de marzo del 2015 para enviar la documentación para el

congreso mundial.

¿El 70% del desarrollo del software para simular la creación de redes

neuroidales, cumplirá con los requisitos esperados por los

usuarios? (Marque con una X su respuesta)

SI NO

¿El desarrollo de este software libre podrá ser una alternativa válida

para el software LabView que se utilizó para simular la creación de

redes neuroidales?

Por supuesto, el costo de licencia del software LabView está alrededor de

los $3000, este software permite colocar bloques que cuentan con

funciones matemáticas muy complejas por tal motivo es caro.

Ahora queremos desvincularnos de la enorme plataforma de LabView con

el desarrollo de un software propio enfocado única y exclusivamente a las

redes neuroidales, y el hecho de que sea una interfaz gráfica y sencilla,

serviría de ayuda a personas que no saben nada de programación como

neurólogos, psiquiatras, psicólogos, van a poder utilizar la herramienta

como parte de su estudio.

Elaborado por: Andrés Silva Muñoz

Fuente: Ph.D. Ricardo Silva Bustillos

X

72

CRONOGRAMA

El presente cronograma describe todas las actividades que se llevarán a

cabo en el proyecto, desde su inicio, hasta su finalización.

Figura 18: Detalles de actividades del proyecto.

Fuente: Andrés Silva Muñoz

73

Figura 19: Diagrama de Gantt del proyecto.

Fuente: Andrés Silva Muñoz


FACULTAD DE MATEMÁTICAS Y FÍSICAS


COMPUTACIONALES



MANUAL DE TÉCNICO



AUTOR:


TUTOR:



2015

II

ÍNDICE GENERAL

ÍNDICE GENERAL ........................................................................................ II

ÍNDICE DE TABLAS .................................................................................... III

ÍNDICE DE FIGURAS ................................................................................... III

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

2. ESPECIFICACIONES TÉCNICAS ......................................................... 1

3. MODELO DE DISEÑO ........................................................................... 2

3.1. ESTANDARES PARA FORMATO DE VARIABLES:......................... 2

3.1.1. Nombres de las Variables. ..................................................... 3

3.2. DIAGRAMA DE CASOS DE USO ...................................................... 3

3.2.1. Descripción de los Actores ................................................... 3

3.2.2. Casos de Uso .......................................................................... 4

3.3. DIAGRAMA DE PROCESOS ............................................................. 4

4. DICCIONARIO DE DATOS .................................................................... 7

4.1. CLASES Y OBJETOS ........................................................................ 7

III

ÍNDICE DE TABLAS

Tabla 1: Tipos de variables de la aplicación ........................................................ 2

Tabla 2: Tipos de datos de las variables de la aplicación .................................. 2

ÍNDICE DE FIGURAS

Figura 1: Caso de uso del especialista ................................................................. 4

Figura 2: Proceso de creación de bloque de entrada ........................................ 5

Figura 3: Proceso de creación de neuroide ......................................................... 6

1

1. Introducción

Los lenguajes de programación orientados a objetos como Java, son

herramientas que permiten integrar bloques de código en nuestra aplicación

con lo cual se multiplica su potencia.

En este proyecto realizaremos el diseño de un software que permita simular

la creación de una red neuroidal mediante un entorno gráfico desarrollado

con herramientas Open Source con la finalidad de contar con un software

que esté disponible para la comunidad.

El presente documento describe la estructura de las clases utilizadas para el

desarrollo de la interfaz gráfica del software para tener una visión global,

además de los diagramas de casos de uso y clases y la correcta instalación

de las herramientas para el funcionamiento del sistema.

2. Especificaciones Técnicas

Requerimientos mínimos del PC en el que se ejecutará la aplicación:

JRE (Java Runtime Enviroment) Versión 1.5 de 64 bits.

JDK (Java Development Kit) 1.5 de 64 bits.

Sistema Operativo: Microsoft Windows 7

Memoria RAM 2GB

Procesador Dual Core 1.6 Ghz

Duro de 500 GB

2

3. Modelo de Diseño

3.1. Estandares para formato de variables:

Para asignar nombres descriptivos a lasvariables, se antepondrán letras en

número de dos, de esta forma identificariamos el tipo de variable seguido del

tipo dato de la variable.

prefijo Descripcion

g Para definir variables globales

l Para definir variables locales.

p Para definir que son parámetros de un método.

Tabla 1: Tipos de variables de la aplicación

Autor:Andrés Silva Muñoz.

Prefijo Descripcion

s Para definir variables de tipo String

n Para definir variables de tipo numerico (Integer)

d Para definir variables de tipo Double

f Para definir variables de tipo Float

b Para definir variables de tipo Boolean

c Para definir que la variable es de tipo object

Tabla 2: Tipos de datos de las variables de la aplicación

Fuente:Andrés Silva Muñoz.

3

3.1.1. Nombres de las Variables.

Las variables de nuestra aplicación utilizarán cualquiera de los prefijos antes

mencionados.

Ejemplos:

ln_umbral, ps_archivo, lc_Neuroide

3.2. Diagrama de Casos de Uso

Los Diagramas de Casos de Uso (DCU) sirven para documentar el

comportamiento del sistema desde el punto de vista de los usuarios. Por tal

motivo se los utilizará para representar las funciones que se pueden realizar

en el sistema.

3.2.1. Descripción de los Actores

Los actores son los que representan un tipo de usuario. Se entiende como

usuario a un agente externo que interactúa con el sistema. No tiene qué ser

necesariamente un humano, puede ser otro sistema informático o empresas,

etc.

Para la interacción con el Sistema Neuroidal Netwok Editor se distinguen los

siguientes actores:

Usuarios o Actores primarios:

• Especialista

Se refiere al usuario encargado de crear los gráficos representativos de las

redes neuroidales e ingresar los parámetros necesarios para su creación.

Actores secundarios:

•El Sistema

Se refiere a la lógica de programación que se esta ejecutando detrás dela

aplicacióny se encarga de manejar todos los eventos que ocurren.

4

3.2.2. Casos de Uso

A continuación se detallan las tareas que pueden llevarse a cabo en el

sistema desarrollado.

Figura 1: Caso de uso del especialista


3.3. Diagrama de Procesos

Los diagramas de procesos son los que constituyen la representación gráfica

de los procesos que se deben realizar durante el desarrollo de la aplicación.

A continuación se presenta el diagrama de procesos relacionado a la

aplicación a desarrollar.

5

Figura 2: Proceso de creación de bloque de entrada


6

Figura 3: Proceso de creación de neuroide


7

4. Diccionario de Datos

4.1. Clases y Objetos

Una clase es una colección de variables y de funciones que acceden a esas

variables. Un objeto es una instanciación particular de una clase. Las clases

son abstracciónes de los objetos que va a utilizar nuestro programa, a

continuación se detallan las principales clases de nuestro proyecto:

Clase GUI

/* * This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or * (at your option) any later version.

*

* This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details. *

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

package promeinfo.gui;

import promeinfo.net.BIFReader;

import promeinfo.net.EditableNetwork; import promeinfo.core.ExtensionFileFilter;

import promeinfo.core.NeuroidVector;

import promeinfo.process.Programa; import java.awt.Rectangle;

import java.awt.RenderingHints;

import java.awt.Toolkit; import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyAdapter; import java.awt.event.KeyEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent; import java.awt.event.MouseMotionAdapter;

import java.awt.image.BufferedImage;

import java.io.File; import java.io.FileWriter;

import java.io.IOException;

import javax.swing.AbstractAction;

import javax.swing.Action; import javax.swing.ButtonGroup;

import javax.swing.ImageIcon;

import javax.swing.JButton; import javax.swing.JDialog;

import javax.swing.JFileChooser;

import javax.swing.JFrame; import javax.swing.JLabel;

import javax.swing.JMenu;

import javax.swing.JMenuBar; import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import javax.swing.JPanel; import javax.swing.JPopupMenu;

import javax.swing.JRadioButtonMenuItem;

import javax.swing.JScrollPane; import javax.swing.JTextField;

import javax.swing.JToolBar;

8

import javax.swing.KeyStroke; import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.UnsupportedLookAndFeelException;

public class GUI extends JPanel

{ private static final long serialVersionUID = 1L;

private static GUI gui; public static GUI MainFrame;

protected GraphPanel gc_GraphPanel; protected String gs_fileName = "";

EditableNetwork gc_EditNetwork = new EditableNetwork(true);

private JMenuBar menuBar;

final JTextField txtZoom; final JToolBar toolBar;

final JLabel statusBar;

public JScrollPane scrollPane; private ButtonGroup grupoLaf;

private JRadioButtonMenuItem opciónLaf;

//Ruta de los iconos

private final String ICONPATH = "promeinfo/neuroid/icons/";

public final static int DEFAULT_GRAPH_WIDTH = 50;

public final static int PADDING = 10;

private double gf_scale = 1;

private int gn_graph_height = 2 * getFontMetrics(getFont()).getHeight();

private int gn_graph_width = DEFAULT_GRAPH_WIDTH; private int gn_graph_padded = DEFAULT_GRAPH_WIDTH + PADDING;

private int gn_input_blocks = 1; private int gn_neuroids = 1;

private int gn_current_graph = -1;

Rectangle gc_SelectedRect = null;

//Porcentajes que se utilizan para el zoom

private int [] gn_zoomPercents =

{10, 25, 50, 75, 100, 125, 150, 175, 200, 225, 250, 275,

300, 350, 400, 450, 500, 550, 600, 650, 700, 800, 900, 999};

//Acciónes de los eventos de la barra de menú

Action a_new = new ActionNew(); Action a_load = new ActionLoad();

Action a_save = new ActionSave();

Action a_saveas = new ActionSaveAs(); Action a_quit = new ActionQuit();

// Action a_undo = new ActionUndo();

Action a_redo = new ActionRedo();

Action a_selectall = new ActionSelectAll(); Action a_delete = new ActionDelete();

Action a_cut = new ActionCut();

Action a_copy = new ActionCopy(); Action a_paste = new ActionPaste();

//

Action a_addinputblock = new ActionAddInputBlock(); Action a_addneuroide = new ActionAddNeuroide();

Action a_runnetwork = new ActionRunNetwork();

Action a_parameterN = new ActionParametersNeuroid();

Action a_parameterB = new ActionParametersBlock();

// Action a_zoomin = new ActionZoomIn();

Action a_zoomout = new ActionZoomOut();

Action a_viewtoolbar = new ActionViewToolbar(); Action a_viewstatusbar = new ActionViewStatusbar();

//

Action a_help = new ActionHelp(); Action a_about = new ActionAbout();

9

//Constructor de la clase

public GUI()

{ gc_GraphPanel = new GraphPanel();

scrollPane = new JScrollPane(gc_GraphPanel);

txtZoom = new JTextField("100%");

txtZoom.setMinimumSize(txtZoom.getPreferredSize());

txtZoom.setHorizontalAlignment(JTextField.CENTER); txtZoom.setToolTipText("Zoom");

//Action que se dispara el ingresar en la caja de texto la cantidad del zoom txtZoom.addActionListener(new ActionListener()

{ public void actionPerformed(ActionEvent ae)

{ JTextField jtxtField = (JTextField) ae.getSource();

try

{ int i = -1; i = jtxtField.getText().indexOf('%');

if (i == -1) i = Integer.parseInt(jtxtField.getText());

else i = Integer.parseInt(jtxtField.getText().substring(0, i));

if (i <= 999) gf_scale = i / 100D;

jtxtField.setText((int) (gf_scale * 100) + "%");

if (gf_scale > 0.1)

{ if (!a_zoomout.isEnabled())

a_zoomout.setEnabled(true);

}

else a_zoomout.setEnabled(false);

if (gf_scale < 9.99)

{ if (!a_zoomin.isEnabled())

a_zoomin.setEnabled(true);

}

else a_zoomin.setEnabled(false);

gc_GraphPanel.repaint(); gc_GraphPanel.invalidate();

scrollPane.revalidate();

} catch (NumberFormatException ne)

{ //Error en caso de que se ingrese un valor incorrecto para el zoom

JOptionPane.showMessageDialog(GUI.this.getParent(), "Invalid integer entered for zoom.", "Error",

JOptionPane.ERROR_MESSAGE);

jtxtField.setText((gf_scale * 100) + "%");

}

} });

GridBagConstraints gridBC = new GridBagConstraints();

final JPanel p = new JPanel(new GridBagLayout());

//Barra de herramientas

toolBar = new JToolBar();

toolBar.setFloatable(false); toolBar.setLayout(new GridBagLayout());

10

gridBC.anchor = GridBagConstraints.NORTHWEST;

gridBC.gridwidth = GridBagConstraints.REMAINDER;

gridBC.insets = new Insets(0, 0, 0, 0); toolBar.add(p, gridBC);

gridBC.gridwidth = 1;

//Agregamos los botones a la barra de herramientas

toolBar.add(a_new);

toolBar.add(a_save); toolBar.add(a_load);

toolBar.addSeparator(new Dimension(2, 2));

toolBar.add(a_cut); toolBar.add(a_copy);

toolBar.add(a_paste);

toolBar.addSeparator(new Dimension(2, 2)); toolBar.add(a_undo);

toolBar.add(a_redo);

toolBar.addSeparator(new Dimension(2, 2)); toolBar.add(a_addinputblock);

toolBar.add(a_addneuroide);

toolBar.add(a_runnetwork); toolBar.addSeparator(new Dimension(2, 2));

toolBar.add(a_zoomin);

toolBar.add(a_zoomout);

gridBC.weighty = 1;

gridBC.fill = GridBagConstraints.VERTICAL;

JPanel p2 = new JPanel(new BorderLayout());

p2.setPreferredSize(txtZoom.getPreferredSize()); p2.setMinimumSize(txtZoom.getPreferredSize());

p2.add(txtZoom, BorderLayout.CENTER);

toolBar.add(p2, gridBC);

gridBC.weighty = 0; gridBC.fill = GridBagConstraints.NONE;

gridBC.weightx = 1;

gridBC.fill = GridBagConstraints.BOTH;

//Barra de estado

statusBar = new JLabel("Status bar");

this.setLayout(new BorderLayout());

this.add(toolBar, BorderLayout.NORTH); this.add(scrollPane,BorderLayout.CENTER);

this.add(statusBar, BorderLayout.SOUTH);

updateStatus();

//Invocamos el Método que construye la barra de menú makeMenuBar();

}

//Método para obtener los elementos de la barra de menú

public JMenuBar getMenuBar() { return menuBar; }

//Método para crear la barra de menú

private void makeMenuBar()

{ menuBar = new JMenuBar();

//Menú File

JMenu fileMenu = new JMenu("File");

fileMenu.setMnemonic('F'); menuBar.add(fileMenu);

fileMenu.add(a_new);

fileMenu.add(a_load); fileMenu.add(a_save);

fileMenu.add(a_saveas);

fileMenu.addSeparator(); fileMenu.add(a_quit);

//Menú Edit JMenu editMenu = new JMenu("Edit");

11

editMenu.setMnemonic('E'); menuBar.add(editMenu);

editMenu.add(a_undo);

editMenu.add(a_redo); editMenu.addSeparator();

editMenu.add(a_selectall);

editMenu.add(a_delete); editMenu.add(a_cut);

editMenu.add(a_copy);

editMenu.add(a_paste); editMenu.addSeparator();

editMenu.add(a_addinputblock);

editMenu.add(a_addneuroide);

//Menú View

JMenu viewMenu = new JMenu("View"); viewMenu.setMnemonic('V');

menuBar.add(viewMenu);

viewMenu.add(a_zoomin); viewMenu.add(a_zoomout);

viewMenu.addSeparator();

viewMenu.add(a_viewtoolbar); viewMenu.add(a_viewstatusbar);

//Menú Windows JMenu windowsMenu = new JMenu("Windows");

windowsMenu.setMnemonic('W');

menuBar.add(windowsMenu);

JMenu menuLookAndFeel = new JMenu("Look And Feel");

grupoLaf = new ButtonGroup();

//Se crean las opciónes correspondientes a los look&feels UIManager.LookAndFeelInfo laf[] = UIManager.getInstalledLookAndFeels();

for(int i = 0; i < laf.length; i++ )

{ opciónLaf = new JRadioButtonMenuItem(laf[i].getName());

opciónLaf.addActionListener(new ActionListener()

{ public void actionPerformed(ActionEvent evt)

{ //cambio de look and feel en general

if(evt.getSource() instanceof JRadioButtonMenuItem )

{ JRadioButtonMenuItem rb =

(JRadioButtonMenuItem)evt.getSource();

try

{ if( rb.isSelected() && rb.getText().equals("Windows") )

{ UIManager.setLookAndFeel

("com.sun.java.swing.plaf.windows.WindowsLookAndFeel" );

SwingUtilities.

updateComponentTreeUI(SwingUtilities.getRoot(MainFrame ) );

} else if( rb.isSelected() &&

rb.getText().equals("CDE/Motif") )


("com.sun.java.swing.plaf.motif.MotifLookAndFeel" );

SwingUtilities.


} else if( rb.isSelected() &&

rb.getText().equals("Metal") )


("javax.swing.plaf.metal.MetalLookAndFeel" );

SwingUtilities.

12


}

else if( rb.isSelected() &&

rb.getText().equals("Nimbus") )


("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel" );

SwingUtilities.


}

else if(rb.isSelected()&&rb.getText().equals("Windows Classic"))


("com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel");

SwingUtilities.


}

} catch(UnsupportedLookAndFeelException e) { // Si no está soportado el Look&Feel

System.err.println("LookAndFeel no soportado:

"+ rb.getText()); rb.setEnabled( false );

} catch(Exception e) { // Si no puede cargar el Look&Feel

System.err.println("LookAndFeel no cargado:

"+rb.getText());

}

}

} });

if(i == 0) opciónLaf.setSelected(true);

grupoLaf.add(opciónLaf); menuLookAndFeel.add(opciónLaf);

}

windowsMenu.add(menuLookAndFeel);

//Menú Help JMenu helpMenu = new JMenu("Help");

helpMenu.setMnemonic('H');

menuBar.add(helpMenu); helpMenu.add(a_help);

helpMenu.add(a_about);

}

//Método para cargar archivos guardados anteriormente public void readBIFFile(String ps_file_name) throws IOException

{ gs_fileName = ps_file_name;

try

{ BIFReader lc_ReadNeuroidNet = new BIFReader();

lc_ReadNeuroidNet.processFile(ps_file_name);

gc_EditNetwork = new EditableNetwork(lc_ReadNeuroidNet);

updateStatus();

gc_EditNetwork.clearUndoStack();

} catch (Exception ex)

{ ex.printStackTrace();

return;

} } // readBIFFile

13

Selection lc_Selection = new Selection();

//Clase que sirve para realizar la acción de selección de elementos

class Selection

{ NeuroidVector lc_Selected;

public Selection() { lc_Selected = new NeuroidVector(); }

public NeuroidVector getSelected() { return lc_Selected; }

void updateGUI()

{ if (lc_Selected.size() > 0)

{ a_cut.setEnabled(true); a_copy.setEnabled(true);

}

else { a_cut.setEnabled(false);

a_copy.setEnabled(false);

}

} // updateGUI

public void addToSelection(int pn_element)

{ for (int iElement = 0; iElement < lc_Selected.size(); iElement++)

{ if (pn_element == (Integer) lc_Selected.elementAt(iElement))

return; }

lc_Selected.addElement(pn_element); updateGUI();

} // addToSelection

public void addToSelection(Rectangle pc_SelectedRect)

{ for (int iElement=0; iElement<gc_EditNetwork.getNrOfElements();iElement++)

{ if (contains(pc_SelectedRect, iElement))

addToSelection(iElement);

} } // addToSelection

public void selectAll()

{ lc_Selected.removeAllElements();

for (int iElement=0; iElement<gc_EditNetwork.getNrOfElements();iElement++)

lc_Selected.addElement(iElement);

updateGUI(); } // selectAll

boolean contains(Rectangle pc_Rect, int pn_element)

{ return pc_Rect.intersects((gc_EditNetwork.getPositionX(pn_element)) * gf_scale,

(gc_EditNetwork.getPositionY(pn_element)) * gf_scale, gn_graph_padded*gf_scale, gn_graph_height* gf_scale);

} // contains

public void toggleSelection(int pn_element)

{ for (int iElement = 0; iElement < lc_Selected.size(); iElement++)

{ if (pn_element == (Integer) lc_Selected.elementAt(iElement))

{ lc_Selected.removeElementAt(iElement);

updateGUI();

return; }

} addToSelection(pn_element); } // toggleSelection

14

public void toggleSelection(Rectangle pc_SelectedRect)

{ for (int iElement=0; iElement < gc_EditNetwork.getNrOfElements();iElement++)

{ if (contains(pc_SelectedRect, iElement))

toggleSelection(iElement);

} } // toggleSelection

public void clear()

{ lc_Selected.removeAllElements(); updateGUI();

} public void draw(Graphics pc_Graphic)

{ if (lc_Selected.size() == 0) { return; }

for (int iGraphic = 0; iGraphic < lc_Selected.size(); iGraphic++)

{ int ln_node = (Integer) lc_Selected.elementAt(iGraphic);

int ln_posX = gc_EditNetwork.getPositionX(ln_node);

int ln_posY = gc_EditNetwork.getPositionY(ln_node);

pc_Graphic.setColor(Color.BLACK);

int ln_XRC = ln_posX + gn_graph_padded - gn_graph_width -

(gn_graph_padded - gn_graph_width) / 2;

int ln_YRC = ln_posY;

int ln_d = 5;

pc_Graphic.fillRect(ln_XRC,ln_YRC, ln_d, ln_d);

pc_Graphic.fillRect(ln_XRC,ln_YRC + gn_graph_height,ln_d,ln_d);

pc_Graphic.fillRect(ln_XRC+gn_graph_width,ln_YRC,ln_d,ln_d);

pc_Graphic.fillRect(ln_XRC+gn_graph_width,ln_YRC+gn_graph_height,ln_d,ln_d);

} } // draw

} // Selection

ClipBoard lc_Clipboard = new ClipBoard();

//Clase que realiza la acción de portapapeles class ClipBoard

{ String ls_text = null;

public ClipBoard()

{ if (a_paste != null)

a_paste.setEnabled(false);

}

public boolean hasText() { return ls_text != null; }

public String getText() { return ls_text; }

public void setText(String ps_txt)

{ ls_text = ps_txt; a_paste.setEnabled(true);

} } // class ClipBoard

class MyAction extends AbstractAction


public MyAction(String ps_name,String ps_tool_tip,String ps_icon,String ps_acc_key)

{ super(ps_name);

//Seteamos el texto de ayuda de las opciónes

15

setToolTipText(ps_tool_tip); putValue(Action.SHORT_DESCRIPTION, ps_tool_tip);

putValue(Action.LONG_DESCRIPTION, ps_tool_tip);

if (ps_acc_key.length() > 0)

{ //Seteamos la combinación de teclas para realizar una acción

KeyStroke lc_KeyStroke = KeyStroke.getKeyStroke(ps_acc_key); putValue(Action.ACCELERATOR_KEY, lc_KeyStroke);

} putValue(Action.MNEMONIC_KEY, (int) ps_name.charAt(0));

//Obtenemos la ruta del icono java.net.URL lc_TempURL =

ClassLoader.getSystemResource(ICONPATH + ps_icon + ".png");

//Verificamos si se cargo la imagen para colocarla

if (lc_TempURL != null)

putValue(Action.SMALL_ICON, new ImageIcon(lc_TempURL));

else putValue(Action.SMALL_ICON, new ImageIcon(

new BufferedImage( 20,20, BufferedImage.TYPE_4BYTE_ABGR)));

}

public void actionPerformed(ActionEvent ae) { }

} // class MyAction

//FILE

//Clase que realiza la acción de crear un nuevo proyecto (New)

class ActionNew extends MyAction


public ActionNew()

{ super("New", "New Network", "new", "ctrl N");

}

public void actionPerformed(ActionEvent ae)

{ gs_fileName = ""; //Nombre del archivo en blanco

gn_input_blocks = 1; //Reinicio de contador de bloques de entrada

gn_neuroids = 1; //Reinicio de contador de neuroides

gc_EditNetwork = new EditableNetwork(true);

updateStatus();

gc_EditNetwork.clearUndoStack();

statusBar.setText("New Network"); //Actualiza la barra de estado

lc_Selection = new Selection();

repaint();

} } // class ActionNew

//Clase que realiza la acción de cargar un proyecto guardado anteriormente (Open)

class ActionLoad extends MyAction


public ActionLoad()

{ super("Open", "Open Graph", "open", "ctrl O");

}


{ //Obtengo la ruta para abrir una ventana de dialogo para cargar un gráfico

JFileChooser fileChooser = new JFileChooser(System.getProperty("user.dir"));

//Defino la extensión del tipo de archivo que voy a abrir

ExtensionFileFilter ef1 = new ExtensionFileFilter(".xml", "XML file");

16

fileChooser.addChoosableFileFilter(ef1);

//Título que llevara la ventana

fileChooser.setDialogTitle("Open");

//Verifica si seleccionamos algún archivo

if (fileChooser.showOpenDialog(GUI.this) == JFileChooser.APPROVE_OPTION)

{ String ls_file_name = fileChooser.getSelectedFile().toString();

//Verifica si la extensión del archivo seleccionado es .xml

if (ls_file_name.endsWith(ef1.getExtensions()[0]))

{ try

{ readBIFFile(ls_file_name);

} catch (Exception e)

{ e.printStackTrace(); }

//Actualizacion de la barra de estado

statusBar.setText("Loaded " + ls_file_name);

}

else statusBar.setText("Error loading file");//Actualiza la barra de estado

updateStatus();

} } } // class ActionLoad

//Clase que realiza la acción de guardar un proyecto (Save)

class ActionSave extends MyAction


public ActionSave()

{ super("Save", "Save Graph", "save", "ctrl S");

}

public ActionSave(String ps_name, String ps_tool_tip_text, String ps_icon, String ps_acceleratorKey)

{ super(ps_name, ps_tool_tip_text, ps_icon, ps_acceleratorKey);

} public void actionPerformed(ActionEvent ae)

{ //Si el archivo ya existe lo guarda automaticamente

if (!gs_fileName.equals(""))

{ saveFile(gs_fileName);

gc_EditNetwork.isSaved();

statusBar.setText("Saved as " + gs_fileName);//Actualiza la barra de estado

}

else { //Si el archivo es nuevo se abre la ventana de dialogo Save As if (saveAs())

{ gc_EditNetwork.isSaved();

statusBar.setText("Saved as " + gs_fileName);

} }

} ExtensionFileFilter lc_Ext_filter = new ExtensionFileFilter(".xml", "XML file");

boolean saveAs()

{ //Creamos selector JFileChooser lc_fileChooser = new JFileChooser(System.getProperty("user.dir"));

lc_fileChooser.addChoosableFileFilter(lc_Ext_filter);

//Título que llevará la ventana de dialogo

lc_fileChooser.setDialogTitle("Save As");

if (!gs_fileName.equals(""))

17

lc_fileChooser.setSelectedFile(new File(gs_fileName));

//Verifica si seleccionamos algún archivo

if (lc_fileChooser.showSaveDialog(GUI.this) == JFileChooser.APPROVE_OPTION)

{ String ls_file_name = lc_fileChooser.getSelectedFile().toString();

//Si el nombre del archivo no termina con .xml, concatenamos la extensión.

if (!ls_file_name.endsWith(".xml"))

ls_file_name = ls_file_name.concat(".xml");

//Invocamos el método para guardar el archivo

saveFile(ls_file_name);

return true;

} return false;

} protected void saveFile(String ps_file_name)

{

try {

FileWriter outfile = new FileWriter(ps_file_name);

outfile.write(gc_EditNetwork.toXMLBIF03()); outfile.close();

gs_fileName = ps_file_name;

statusBar.setText("Saved as " + gs_fileName);//Actualiza la barra de estado

} catch(IOException e) { e.printStackTrace(); }

}

} //class ActionSave

//Clase que realiza la acción de guardar un proyecto asigando un nombre (Save As)

class ActionSaveAs extends ActionSave


public ActionSaveAs()

{ super("Save As", "Save Graph As", "saveas", "");

}

public void actionPerformed(ActionEvent ae) { saveAs(); } } //class ActionSaveAs

//Clase que realiza la acción de salir de la aplicación (Quit) class ActionQuit extends ActionSave


public ActionQuit()

{ super("Exit", "Exit Program", "exit", "");

}


{ //Verifico si se produjeron cambios en el editor

if (gc_EditNetwork.isChanged())

{ //Ventana de dialogo indicando si desea guardar los cambios. int ln_result = JOptionPane.showConfirmDialog(null,

"Network changed. Do you want to save it?",

"Save before closing?", JOptionPane.YES_NO_CANCEL_OPTION);

//Si escoge la opción cancelar if (ln_result == JOptionPane.CANCEL_OPTION) { return; }

//Si escoge la opción si, abre la ventana de dialogo para guardar if (ln_result == JOptionPane.YES_OPTION)

if (!saveAs()) { return; }

} System.exit(0);

18

} } // class ActionQuit

//EDIT //Clase que realiza la acción de deshacer (Undo)

class ActionUndo extends MyAction


public ActionUndo()

{ super("Undo", "Undo", "undo", "ctrl Z");

setEnabled(false);

}

public boolean isEnabled()

{ return gc_EditNetwork.canUndo();

}


{ String ls_msg = gc_EditNetwork.undo();

//Actualizacion de la acción en la barra de estado statusBar.setText("Undo action performed: " + ls_msg);

a_redo.setEnabled(gc_EditNetwork.canRedo()); a_undo.setEnabled(gc_EditNetwork.canUndo());

lc_Selection.clear();

updateStatus();

repaint();

} } // ActionUndo

//Clase que realiza la acción de rehacer (Redo) class ActionRedo extends MyAction


public ActionRedo()

{ super("Redo", "Redo", "redo", "ctrl Y");

setEnabled(false);

}


{ return gc_EditNetwork.canRedo();


{ String ls_msg = gc_EditNetwork.redo();

//Actualizacion de la acción en la barra de estado statusBar.setText("Redo action performed: " + ls_msg);


updateStatus();

repaint();

}

} // ActionRedo

//Clase que realiza la acción de seleccionar todos los elementos (Select All)

class ActionSelectAll extends MyAction


public ActionSelectAll()

{ super("Select All", "Select All", "selectall", "ctrl A");

}

19


{

lc_Selection.selectAll();

repaint();

} } // class ActionSelectAll

//Clase que realiza la acción de eliminar algun elemento (Delete)

class ActionDelete extends MyAction


public ActionDelete()

{ super("Delete", "Delete", "delneuroide", "DELETE");

}


{ if (lc_Selection.getSelected().size() > 0)

{ gc_EditNetwork.deleteSelection(lc_Selection.getSelected()); statusBar.setText(gc_EditNetwork.lastActionMsg());


updateStatus();

repaint();

} else

{ String[] ls_options = new String[gc_EditNetwork.getNrOfElements()];

for (int i = 0; i < ls_options.length; i++)

ls_options[i] = gc_EditNetwork.getTargetName(i);

String ls_result=(String) JOptionPane.showInputDialog(null, "Select Element to delete", "Element", 0,

null, ls_options, ls_options[0]);

if (ls_result != null && !ls_result.equals(""))

{ int ln_neuroide = gc_EditNetwork.getNeuroide2(ls_result);

deleteNeuroide(ln_neuroide);

}

} } } // class ActionDelete

//Clase que realiza la acción de cortar algun elemento del area de edicion (Cut)

class ActionCut extends ActionCopy


public ActionCut()

{ super("Cut", "Cut", "cut", "ctrl X");

}


{ copy();

gc_EditNetwork.deleteSelection(lc_Selection.getSelected());

statusBar.setText("Cut element");

lc_Selection.clear(); a_undo.setEnabled(true);

a_redo.setEnabled(false);

repaint();

} } // class ActionCut

//Clase que realiza la acción de copiar algun elemento (Copy)

class ActionCopy extends MyAction

{

20

private static final long serialVersionUID = 1L;

public ActionCopy()

{ super("Copy", "Copy", "copy", "ctrl C");

} public ActionCopy(String ps_name,String ps_tool_tip,String ps_icon,String ps_acc_key)

{ super(ps_name, ps_tool_tip, ps_icon, ps_acc_key);

}

public void actionPerformed(ActionEvent ae) { copy(); }

public void copy()

{ String ls_xml = gc_EditNetwork.toXMLBIF03(lc_Selection.getSelected());

lc_Clipboard.setText(ls_xml);

} } // class ActionCopy

//Clase que realiza la acción de pegar algun elemento (Paste) class ActionPaste extends MyAction


public ActionPaste()

{ super("Paste", "Paste", "paste", "ctrl V");


{

try { gc_EditNetwork.paste(lc_Clipboard.getText());

updateStatus(); statusBar.setText(gc_EditNetwork.lastActionMsg());

} catch (Exception e) { e.printStackTrace(); }

}


{ return lc_Clipboard.hasText();

} } // class ActionPaste

//Clase que realiza la acción de añadir un bloque de entrada (Add Input Block)

class ActionAddInputBlock extends MyAction


public ActionAddInputBlock()

{ super("Add Input Block", "Add Input Block", "addinputblock", "");

}

JDialog dialog = null; JTextField txtBlockName = new JTextField(5);

JTextField txtValorInicio = new JTextField(5);

JTextField txtValorFinal = new JTextField(5); JTextField txtPeriodo = new JTextField(5);

JTextField txtRetardo = new JTextField(5);

int ln_posX = Integer.MAX_VALUE;

int ln_posY;

public void addInputBlock(int pn_posX, int pn_posY)

{ ln_posX = pn_posX; ln_posY = pn_posY;

addInputBlock();

}

21

public void addInputBlock()

{

if (dialog == null)

{ dialog = new JDialog();

//Titulo del cuadro de dialogo dialog.setTitle("Add Input Block");

//Opciones que se presentan para crear el bloque de entrada final JLabel jLbValorInicio = new JLabel("Initial Value");

final JLabel jLbValorFinal = new JLabel("End Value");

final JLabel jLbPeriodo = new JLabel("Periodo"); final JLabel jLbRetardo = new JLabel("Retardo");

//Colocamos el cursor en la izquierda txtValorInicio.setHorizontalAlignment(JTextField.LEFT);

txtValorInicio.setText("");

txtValorFinal.setHorizontalAlignment(JTextField.LEFT); txtValorFinal.setText("");

txtPeriodo.setHorizontalAlignment(JTextField.LEFT);

txtPeriodo.setText(""); txtRetardo.setHorizontalAlignment(JTextField.LEFT);

txtRetardo.setText("");

//Validaciónes para que las cajas de texto solo acepten numeros y el "."

txtValorInicio.addKeyListener(new KeyAdapter()

{ public void keyTyped(KeyEvent e)

{ char c = e.getKeyChar();

if (((c<'0')||(c>'9'))&&(c!=KeyEvent.VK_BACK_SPACE)&&(c!='.'))

e.consume();

if (c == '.' && txtValorInicio.getText().contains("."))

e.consume();

}

}); txtValorFinal.addKeyListener(new KeyAdapter()




e.consume();

if (c=='.'&&txtValorFinal.getText().contains("."))

e.consume();

} }); txtPeriodo.addKeyListener(new KeyAdapter()




e.consume();

if (c == '.' && txtPeriodo.getText().contains("."))

e.consume();

} });

txtRetardo.addKeyListener(new KeyAdapter()




22

e.consume();

if (c == '.' && txtRetardo.getText().contains("."))

e.consume();

}

}); JButton jBtOk;

jBtOk = new JButton("Ok");

jBtOk.setMnemonic('O');

jBtOk.addActionListener(new ActionListener()


{ String ls_name = txtBlockName.getText();

//Verifico si ingreso todos los parámetros

if (txtValorInicio.getText().length() == 0 || txtValorFinal.getText().length() == 0 ||

txtPeriodo.getText().length() == 0 ||

txtRetardo.getText().length() == 0)

{

JOptionPane.showMessageDialog(null,"Incomplete parameters");

return;

} double lf_ini_value = new

Double(txtValorInicio.getText()).doubleValue();

double lf_end_value = new Double(txtValorFinal.getText()).doubleValue();

double lf_periodo = new

Double(txtPeriodo.getText()).doubleValue(); double lf_retardo = new

Double(txtRetardo.getText()).doubleValue();

//Verifico si no esta vacia la caja de texto

try { //si la creación se dara dando click derecho sobre el editor

if (ln_posX < Integer.MAX_VALUE)

gc_EditNetwork.addInputBlock(ls_name, 4, lf_ini_value, lf_end_value, lf_periodo, lf_retardo, ln_posX, ln_posY);

else gc_EditNetwork.addInputBlock(ls_name, 4, lf_ini_value, lf_end_value, lf_periodo, lf_retardo);

statusBar.setText(gc_EditNetwork.lastActionMsg());

a_undo.setEnabled(true); a_redo.setEnabled(false);


{ e.printStackTrace();

} repaint();

dialog.setVisible(false);

}

}); JButton jBtCancel;

jBtCancel = new JButton("Cancel");

jBtCancel.setMnemonic('C');

jBtCancel.addActionListener(new ActionListener()


{ dialog.setVisible(false); gn_input_blocks--;

}

});

23

GridBagConstraints gridBC = new GridBagConstraints(); dialog.setLayout(new GridBagLayout());

Container lc_container = new Container(); lc_container.setLayout(new GridBagLayout());

gridBC.gridwidth = 1; //Definimos los espacios entre los objetos de la ventana (nort,izq,sur,der)

gridBC.insets = new Insets(10, 10, 5, 10);


gridBC.gridwidth = GridBagConstraints.RELATIVE;

lc_container.add(jLbValorInicio, gridBC); gridBC.gridwidth = GridBagConstraints.REMAINDER;

lc_container.add(txtValorInicio, gridBC);


lc_container.add(jLbValorFinal, gridBC);

gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtValorFinal, gridBC);

gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jLbPeriodo, gridBC);


lc_container.add(txtPeriodo, gridBC);


lc_container.add(jLbRetardo, gridBC); gridBC.gridwidth = GridBagConstraints.REMAINDER;

lc_container.add(txtRetardo, gridBC);

gridBC.fill = GridBagConstraints.HORIZONTAL;

gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jBtOk, gridBC);


lc_container.add(jBtCancel, gridBC);

dialog.add(lc_container, gridBC);

}

if (gc_EditNetwork.getNrOfElements() > 0)

{ for (int x=0; x < gc_EditNetwork.getNrOfElements(); x++)

{ if (gc_EditNetwork.getTargetName(x).substring(0, 1).equals("E"))

{ gn_input_blocks = (int) new Double(gc_EditNetwork.getTargetName(x).substring(1, 2)).doubleValue();

gn_input_blocks++;

}

} txtBlockName.setText("E" + gn_input_blocks);

}

else { txtBlockName.setText("E" + (gc_EditNetwork.getNrOfElements() + gn_input_blocks));

gn_input_blocks++;

} //Definimos la ubicación de la ventana

dialog.setLocation(200, 200); dialog.setVisible(true);

dialog.setSize(dialog.getPreferredSize());

dialog.setVisible(false); dialog.setVisible(true);

dialog.repaint();

}


{ ln_posX = Integer.MAX_VALUE;

addInputBlock();

} } // class ActionAddInputBlock

//Clase que realiza la acción de añadir un neuroide (Add Neuroide) class ActionAddNeuroide extends MyAction

24


public ActionAddNeuroide()

{ super("Add Neuroide", "Add Neuroide", "addneuroide", "");

}

JDialog dialog = null;

JTextField txtNeuroideName = new JTextField(5); JTextField txtNeuroideUmbr = new JTextField(5);

JTextField txtNeuroidePend = new JTextField(5);


int ln_posY;

public void addNeuroide(int pn_posX, int pn_posY)


addNeuroide();

}

public void addNeuroide()

{ if (dialog == null)


//Título del cuadro de dialogo

dialog.setTitle("Add neuroide");

//Opciónes que se presentan en el cuadro de dialogo

final JLabel jLbNeuroideName = new JLabel("Name"); final JLabel jLbNeuroideUmbr = new JLabel("Umbral");

final JLabel jLbNeuroidePend = new JLabel("Slope");

//Validaciónes para que las cajas de texto solo acepten números y el "."

txtNeuroideUmbr.addKeyListener(new KeyAdapter()



if (((c<'0')||(c>'9'))&&(c!=KeyEvent.VK_BACK_SPACE)&&(c!='.')) e.consume();

if (c == '.' && txtNeuroideUmbr.getText().contains(".")) e.consume();

}

});

txtNeuroidePend.addKeyListener(new KeyAdapter()




e.consume();

if (c=='.'&& txtNeuroidePend.getText().contains("."))

e.consume();

} });

//Boton Ok JButton jBtOk = new JButton("Ok");




{ String ls_name = txtNeuroideName.getText();

25

double lf_umbr = 0; double lf_slope = 0;

if (txtNeuroideUmbr.getText().length() > 0)

{ if (txtNeuroideUmbr.getText().endsWith("."))

lf_umbr = 0;

else lf_umbr=new

Double(txtNeuroideUmbr.getText()).doubleValue();

}

else lf_umbr = 0;

if (txtNeuroidePend.getText().length() > 0)

{ if (txtNeuroidePend.getText().endsWith("."))

lf_slope = 0;

else lf_slope=new

Double(txtNeuroidePend.getText()).doubleValue();

}

else lf_slope = 0;

//Verifico si no esta vacia la caja de texto if (ls_name.length() <= 0)

{//se indica que deberia ingresar por lo menos un caracter

JOptionPane.showMessageDialog(null, "Name should have at least one character");

return; }

//Verifico que el valor del umbral, tiene que estar entre 0 y 1 if ((lf_umbr <= 0 || lf_umbr >= 1))

{//mensaje indicando que deberia ingresar una cantidad > 1

JOptionPane.showMessageDialog(null, "The Umbral should be larger than 0 and less than 1");

return;

}

//Verifico que el valor de la pendiente, tiene que ser un numero if (lf_slope <= 0)

{//se indica que deberia ingresar una cantidad mayor a uno

JOptionPane.showMessageDialog(null, "The Slope should be larger than 1");

return; }

try

{ if (ln_posX < Integer.MAX_VALUE) gc_EditNetwork.addNeuroide(ls_name, 2, lf_umbr, lf_slope, ln_posX, ln_posY);

else gc_EditNetwork.addNeuroide(ls_name, 2, lf_umbr, lf_slope);





repaint();


}

26

});

//Boton cancelar

JButton jBtCancel; jBtCancel = new JButton("Cancel");

jBtCancel.setMnemonic('C');



{ dialog.setVisible(false);

gn_neuroids--;

} });

GridBagConstraints gridBC = new GridBagConstraints(); dialog.setLayout(new GridBagLayout());

Container lc_container = new Container(); lc_container.setLayout(new GridBagLayout());

gridBC.gridwidth = 1; //Definimos los espacios entre los objetos de la ventana (nort,izq,sur,der)

gridBC.insets = new Insets(10, 10, 5, 10);



lc_container.add(jLbNeuroideName, gridBC); gridBC.gridwidth = GridBagConstraints.REMAINDER;

lc_container.add(txtNeuroideName, gridBC);


lc_container.add(jLbNeuroideUmbr, gridBC);

gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtNeuroideUmbr, gridBC);

gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jLbNeuroidePend, gridBC);


lc_container.add(txtNeuroidePend, gridBC);



lc_container.add(jBtOk, gridBC);

gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jBtCancel, gridBC);


}


{ txtNeuroideName.setText("N");

}

else

{ txtNeuroideName.setText("N" + (gc_EditNetwork.getNrOfNeuroides() + gn_neuroids));

gn_neuroids++;

}

dialog.setLocation(200, 200);

dialog.setVisible(true); dialog.setSize(dialog.getPreferredSize());


dialog.setVisible(true); dialog.repaint();


{ ln_posX = Integer.MAX_VALUE; addNeuroide();

} } // class ActionAddNeuroide

27

//Clase que realiza la acción de ejecutar la red neuroidal construida (Run Network) class ActionRunNetwork extends MyAction


public ActionRunNetwork()

{ super("Run Network", "Run Network", "network", "");


{ new Programa("");

} } // class ActionRunNetwork

//VIEW

//Clase que realiza la acción de aumento de tamaño de los elementos (Zoom In) class ActionZoomIn extends MyAction


public ActionZoomIn()

{ super("Zoom in", "Zoom in", "zoomin", "+");


{ int i = 0, s = (int) (gf_scale * 100);

if (s < 300)

i = s / 25; else if (s < 700)

i = 6 + s / 50;

else i = 13 + s / 100;

if (s >= 999)

{ setEnabled(false);

return;

} else if (s >= 10)

{ if (i >= 22) { setEnabled(false); }

if (s == 10 && !a_zoomout.isEnabled())


txtZoom.setText(gn_zoomPercents[i + 1] + "%");

gf_scale = gn_zoomPercents[i + 1] / 100D;

}

else

{ if (!a_zoomout.isEnabled())


txtZoom.setText(gn_zoomPercents[0] + "%");

gf_scale = gn_zoomPercents[0] / 100D;

}

gc_GraphPanel.repaint();

gc_GraphPanel.invalidate(); scrollPane.revalidate();

//Actualizacion de la acción en la barra de estado statusBar.setText("Zooming in");

} } // class ActionZoomIn

//Clase que realiza la acción de disminuir de tamaño de los elementos (Zoom Out)

class ActionZoomOut extends MyAction

{

28


public ActionZoomOut()

{ super("Zoom out", "Zoom out", "zoomout", "-");


{ int i = 0, s = (int) (gf_scale * 100);

if (s < 300)

i = (int) Math.ceil(s / 25D); else if (s < 700)

i = 6 + (int) Math.ceil(s / 50D);

else i = 13 + (int) Math.ceil(s / 100D);

if (s <= 10)

setEnabled(false);

else if (s < 999)

{

if (i <= 1) { setEnabled(false); }

txtZoom.setText(gn_zoomPercents[i - 1] + "%");

gf_scale = gn_zoomPercents[i - 1] / 100D;

} else

{ if (!a_zoomin.isEnabled()) { a_zoomin.setEnabled(true); }

txtZoom.setText(gn_zoomPercents[22] + "%");

gf_scale = gn_zoomPercents[22] / 100D;

}

gc_GraphPanel.repaint(); gc_GraphPanel.invalidate();

scrollPane.revalidate();

//Actualiza la barra de estado

statusBar.setText("Zooming out");

} } // class ActionZoomOut

//Clase que realiza la acción de visualizar o no la barra de estado (View Statusbar) class ActionViewStatusbar extends MyAction


public ActionViewStatusbar()

{ super("View statusbar", "View statusbar", "statusbar", "");

}


{ statusBar.setVisible(!statusBar.isVisible());

} } // class ActionViewStatusbar

//Clase que realiza la acción de visualizar o no la barra de herramientas (View Toolbar)

class ActionViewToolbar extends MyAction

{


public ActionViewToolbar()

{ super("View toolbar", "View toolbar", "toolbar", "");

}


{ toolBar.setVisible(!toolBar.isVisible());

} } // class ActionViewToolbar

29

//HELP

//Clase que realiza la acción de visualizar un mensaje de ayuda (Help)

class ActionHelp extends MyAction


public ActionHelp()

{ super("Help", "Neuroid Network Help", "help", "");

}


{ String ls_help1 = new String("This application allows the user "

+ "to draw images for build a neuroidal network.");

String ls_help2 = new String("Read the user guide to learn how"

+ " to use this app.");

JOptionPane.showMessageDialog(null,ls_help1+"\n"+ ls_help2, "Help Message", JOptionPane.PLAIN_MESSAGE);

} } // class ActionHelp

//Clase que realiza la acción de mostrar version de la aplicación (About) class ActionAbout extends MyAction


public ActionAbout()

{ super("About", "Help about", "about", "");


{ JOptionPane.showMessageDialog(null, "Appication: Neuroidal Network Editor\n" +

"Version: 1.0\n" +

"Developed By: Promeinfo\n" + "Build: 25-11-2014",

"About Message", JOptionPane.PLAIN_MESSAGE);

} } // class ActionAbout

// private class GraphPanel extends PrintablePanel


final static int HIGHLIGHTED = 1;

final static int NORMAL = 0;

public GraphPanel()

{

super(); this.addMouseListener(new GraphVisualizerMouseListener()); this.addMouseMotionListener(new GraphVisualizerMouseMotionListener());

this.setToolTipText("");

}

//Método que muestra un texto de ayuda o una descripcion

public String getToolTipText(MouseEvent me)

{

int x, y;

Rectangle r; x = y = 0;

r = new Rectangle(0, 0, (int) (gn_graph_padded * gf_scale), (int) (gn_graph_height * gf_scale));

x += me.getX();

y += me.getY();

for (int iElement=0; iElement<gc_EditNetwork.getNrOfElements();iElement++)

{ r.x = (int) (gc_EditNetwork.getPositionX(iElement) * gf_scale);

30

r.y = (int) (gc_EditNetwork.getPositionY(iElement) * gf_scale);

if (r.contains(x, y))

return gc_EditNetwork.getTargetName(iElement) + " (right click to manipulate this Graph)";

}

return null; } // getToolTipText

//Método que se invoca cada vez que se realiza una acción en la pantalla

public void paintComponent(Graphics pc_Graph)

{ Graphics2D lc_Graphics = (Graphics2D) pc_Graph;

RenderingHints lc_rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

lc_rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);

lc_Graphics.setRenderingHints(lc_rh); lc_Graphics.scale(gf_scale, gf_scale);

Rectangle lc_Rect = lc_Graphics.getClipBounds();

lc_Graphics.clearRect(lc_Rect.x, lc_Rect.y, lc_Rect.width, lc_Rect.height);

for (int iElement = 0; iElement < gc_EditNetwork.getNrOfElements(); iElement++)

drawGraph(lc_Graphics, iElement, NORMAL);

lc_Selection.draw(lc_Graphics);

if (gc_SelectedRect != null)

{ lc_Graphics.drawRect((int)(gc_SelectedRect.x/ gf_scale),

(int)(gc_SelectedRect.y/ gf_scale),

(int)(gc_SelectedRect.width/ gf_scale), (int)(gc_SelectedRect.height/ gf_scale));

} } // paintComponent

@SuppressWarnings("static-access")

protected void drawGraph(Graphics pc_Graph, int pn_pos_targ, int pn_mode) { //Obtenemos la ubicacion del elemento

int ln_posX = gc_EditNetwork.getPositionX(pn_pos_targ);

int ln_posY = gc_EditNetwork.getPositionY(pn_pos_targ);

FontMetrics fm = getFontMetrics(getFont());

if (gc_EditNetwork.getTargetName(pn_pos_targ).substring(0, 1).equals("E"))

{ pc_Graph.setColor(this.getBackground().darker().darker());

if (pn_mode == HIGHLIGHTED){ pc_Graph.setXORMode(Color.blue); }

//Graficamos el bloque de entrada como rectangulo

pc_Graph.fillRect( ln_posX+gn_graph_padded-gn_graph_width-(gn_graph_padded-gn_graph_width)/2,

ln_posY, gn_graph_width, gn_graph_height);

pc_Graph.setColor(Color.white);

if (pn_mode == HIGHLIGHTED){ pc_Graph.setXORMode(Color.white); }

ar

if(fm.stringWidth(gc_EditNetwork.getTargetName(pn_pos_targ))<=gn_graph_width) { //Obtengo el nombre

pc_Graph.drawString(gc_EditNetwork.getTargetName(pn_pos_targ),

ln_posX + gn_graph_padded / 2 - fm.stringWidth(gc_EditNetwork.getTargetName(pn_pos_targ)) / 2,

ln_posY + gn_graph_height / 2 + fm.getHeight() / 2 - 2);

} else if (fm.stringWidth("" + pn_pos_targ) <= gn_graph_width)

{ pc_Graph.drawString("" + pn_pos_targ, ln_posX + gn_graph_padded / 2 - fm.stringWidth("" + pn_pos_targ) / 2,


}

31

if (pn_mode == HIGHLIGHTED) { pc_Graph.setXORMode(Color.green); }

pc_Graph.setColor(Color.black);

} else

{ pc_Graph.setColor(this.getBackground().darker().BLUE);


//Graficamos el neuroide como ovalo

pc_Graph.fillOval(

ln_posX + gn_graph_padded-gn_graph_width-(gn_graph_padded-

gn_graph_width)/2,

ln_posY, gn_graph_width, gn_graph_height);

pc_Graph.setColor(Color.white);

if (pn_mode == HIGHLIGHTED) { pc_Graph.setXORMode(Color.white); }

if(fm.stringWidth(gc_EditNetwork.getTargetName(pn_pos_targ))<=gn_graph_width) { //Obtengo el nombre que se ingreso para el neuroide

pc_Graph.drawString(gc_EditNetwork.getTargetName(pn_pos_targ),

ln_posX + gn_graph_padded / 2 - fm.stringWidth(gc_EditNetwork.getTargetName(pn_pos_targ)) / 2,


} else if (fm.stringWidth("" + pn_pos_targ) <= gn_graph_width)

{ pc_Graph.drawString("" + pn_pos_targ, ln_posX + gn_graph_padded / 2 - fm.stringWidth("" + pn_pos_targ) / 2,


}


pc_Graph.setColor(Color.black);

for(int i=0;i<gc_EditNetwork.getNrOfParents(pn_pos_targ);i++)

{ int ln_parent = gc_EditNetwork.getParent(pn_pos_targ, i);

int ln_posX1 = ln_posX + gn_graph_padded / 2;

int ln_posY1 = ln_posY + gn_graph_height;

int ln_posX2 = gc_EditNetwork.getPositionX(ln_parent);

int ln_posY2 = gc_EditNetwork.getPositionY(ln_parent); int ln_posX2b = ln_posX2 + gn_graph_padded / 2;

int ln_posY2b = ln_posY2;

double lf_pi = Math.atan2((ln_posX2b-ln_posX1+0.0) *

gn_graph_height, (ln_posY2b - ln_posY1 + 0.0) * gn_graph_width);

ln_posX1 =

(int)(ln_posX + gn_graph_padded/2 + Math.sin(lf_pi)*gn_graph_width/2);

ln_posY1 = (int)(ln_posY + gn_graph_height/2 +

Math.cos(lf_pi)*gn_graph_height/2);

ln_posX2b =

(int)(ln_posX2 + gn_graph_padded/2 -

Math.sin(lf_pi)*gn_graph_width/2);

ln_posY2b =

(int)(ln_posY2 + gn_graph_height/2 - Math.cos(lf_pi)*gn_graph_height/2);

//Dibujo la linea para enlazar el neuroide drawArrow(pc_Graph, ln_posX2b, ln_posY2b, ln_posX1, ln_posY1);

} if (pn_mode == HIGHLIGHTED)

{ NeuroidVector children = gc_EditNetwork.getChildren(pn_pos_targ);

32

for (int iChild = 0; iChild < children.size(); iChild++)

{

int ln_child = (Integer) children.elementAt(iChild);

int ln_posX1 = ln_posX + gn_graph_padded / 2; int ln_posY1 = ln_posY;

int ln_posX2 = gc_EditNetwork.getPositionX(ln_child);

int ln_posY2 = gc_EditNetwork.getPositionY(ln_child); int ln_posX2b = ln_posX2 + gn_graph_padded / 2;

int ln_posY2b = ln_posY2 + gn_graph_height;

double lf_pi = Math.atan2((ln_posX2b - ln_posX1 + 0.0) *

gn_graph_height, (ln_posY2b - ln_posY1 + 0.0) *

gn_graph_width);

ln_posX1 = (int)(ln_posX+gn_graph_padded/2+Math.sin(lf_pi)*gn_graph_width/2);

ln_posY1 = (int)(ln_posY+gn_graph_height/2+Math.cos(lf_pi)*gn_graph_height/2);

ln_posX2b = (int)(ln_posX2+gn_graph_padded/2-Math.sin(lf_pi)*gn_graph_width/2);

ln_posY2b = (int)(ln_posY2+gn_graph_height/2-Math.cos(lf_pi)*gn_graph_height/2);

drawArrow(pc_Graph, ln_posX1, ln_posY1, ln_posX2b, ln_posY2b);

}

}

} } // drawGraph

protected void drawArrow(Graphics pc_Graph, int pn_posX1, int pn_posY1, int pn_posX2, int pn_posY2)

{ pc_Graph.drawLine(pn_posX1, pn_posY1, pn_posX2, pn_posY2);

if (pn_posX1 == pn_posX2)

{ if (pn_posY1 < pn_posY2)

{ pc_Graph.drawLine(pn_posX2, pn_posY2, pn_posX2 + 4, pn_posY2 - 8);

pc_Graph.drawLine(pn_posX2, pn_posY2, pn_posX2 - 4, pn_posY2 - 8);

}

else

{ pc_Graph.drawLine(pn_posX2, pn_posY2, pn_posX2 + 4, pn_posY2 + 8);

pc_Graph.drawLine(pn_posX2, pn_posY2, pn_posX2 - 4, pn_posY2 + 8);

}

}

else

{ double lf_hyp = 0, lf_base = 0, lf_perp = 0, lf_theta, lf_beta;

int ln_posX3 = 0, ln_posY3 = 0;

if (pn_posX2 < pn_posX1)

{ lf_base = pn_posX1 - pn_posX2; lf_hyp = Math.sqrt((pn_posX2 - pn_posX1) * (pn_posX2 - pn_posX1) + (pn_posY2 - pn_posY1) * (pn_posY2 - pn_posY1));

lf_theta = Math.acos(lf_base / lf_hyp);

}

else

{ lf_base = pn_posX1 - pn_posX2;

lf_hyp = Math.sqrt((pn_posX2 - pn_posX1) * (pn_posX2 - pn_posX1) + (pn_posY2 - pn_posY1) * (pn_posY2 - pn_posY1));

lf_theta = Math.acos(lf_base / lf_hyp);

} lf_beta = 30 * Math.PI / 180;

lf_hyp = 8;

lf_base = Math.cos(lf_theta - lf_beta) * lf_hyp;

lf_perp = Math.sin(lf_theta - lf_beta) * lf_hyp;

ln_posX3 = (int) (pn_posX2 + lf_base);

if (pn_posY1 < pn_posY2)

ln_posY3 = (int) (pn_posY2 - lf_perp);

else ln_posY3 = (int) (pn_posY2 + lf_perp);

pc_Graph.drawLine(pn_posX2, pn_posY2, ln_posX3, ln_posY3);

33

lf_base = Math.cos(lf_theta + lf_beta) * lf_hyp; lf_perp = Math.sin(lf_theta + lf_beta) * lf_hyp;

ln_posX3 = (int) (pn_posX2 + lf_base);

if (pn_posY1 < pn_posY2)

ln_posY3 = (int) (pn_posY2 - lf_perp);

else ln_posY3 = (int) (pn_posY2 + lf_perp);

pc_Graph.drawLine(pn_posX2, pn_posY2, ln_posX3, ln_posY3);

} } // drawArrow

public void highLight(int pn_object)

{ Graphics2D lc_Graph = (Graphics2D) this.getGraphics();

RenderingHints lc_rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

lc_rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);

lc_Graph.setRenderingHints(lc_rh); lc_Graph.setPaintMode();

lc_Graph.scale(gf_scale, gf_scale);

drawGraph(lc_Graph, pn_object, HIGHLIGHTED);

} // highlight

} // class GraphPanel

//Clase que contiene la programación de eventos al realizar un click

private class GraphVisualizerMouseListener extends MouseAdapter

{ public void mouseClicked(MouseEvent me)

{ int ln_posX, ln_posY;

ln_posX = me.getX(); ln_posY = me.getY();

Rectangle lc_r1 = new Rectangle(0, 0, (int) (gn_graph_padded * gf_scale),

(int) (gn_graph_height * gf_scale));


{ for (int iElement=0;iElement<gc_EditNetwork.getNrOfElements();iElement++)

{ lc_r1.x = (int) (gc_EditNetwork.getPositionX(iElement) * gf_scale);

lc_r1.y = (int) (gc_EditNetwork.getPositionY(iElement) * gf_scale);

if (lc_r1.contains(ln_posX, ln_posY))

{ gn_current_graph = iElement;

if (me.getButton() == MouseEvent.BUTTON3)

{ if (gc_EditNetwork.getTargetName(iElement).substring(0, 1).equals("E")) handleRightInputBlockClick(me);

else handleRightNeuroideClick(me);

}

if (me.getButton() == MouseEvent.BUTTON1)

{

if ((me.getModifiersEx() &

MouseEvent.CTRL_DOWN_MASK) != 0)

lc_Selection.toggleSelection(gn_current_graph);

else if ((me.getModifiersEx() & MouseEvent.SHIFT_DOWN_MASK)!=0)

lc_Selection.addToSelection(gn_current_graph);

else

{ lc_Selection.clear();

34

lc_Selection.addToSelection(gn_current_graph);

}

repaint();

} return;

}

} }

//Validación para verificar si esta haciendo click derecho con el mouse if (me.getButton() == MouseEvent.BUTTON3)

handleRightClick(me, (int)(ln_posX/gf_scale), (int)(ln_posY/gf_scale));

} // mouseClicked

public void mouseReleased(MouseEvent me)

{ if (gc_SelectedRect != null)

{ if ((me.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) != 0) lc_Selection.toggleSelection(gc_SelectedRect);

else if ((me.getModifiersEx() & MouseEvent.SHIFT_DOWN_MASK) != 0)

lc_Selection.addToSelection(gc_SelectedRect);

else

{ lc_Selection.clear(); lc_Selection.addToSelection(gc_SelectedRect);

} gc_SelectedRect = null; repaint();

} } // mouseReleased

int ln_posX = 0, ln_posY = 0;

//Menú que se visualiza al dar click derecho sobre el editor

void handleRightClick(MouseEvent me, int pn_posX, int pn_posY)

{ ActionListener act = new ActionListener()

{ public void actionPerformed(ActionEvent ae) { //si la acción que se desea ejecutar es agregar un neuroide

if (ae.getActionCommand().equals("Add Neuroide"))

{ ((ActionAddNeuroide) a_addneuroide).addNeuroide(ln_posX, ln_posY);

return;

}

//si la acción que se desea ejecutar es agregar un bloque de entrada

if (ae.getActionCommand().equals("Add Input Block"))

{ ((ActionAddInputBlock) a_addinputblock).addInputBlock(ln_posX, ln_posY);

return; } repaint();

}

}; //Construyo el menú secundario

JPopupMenu popupMenu = new JPopupMenu("Choose a value");

//Items que se presentaran en el menú

JMenuItem addInputBlockItem = new JMenuItem("Add Input Block");

JMenuItem addNeuroideItem = new JMenuItem("Add Neuroide");

//funcionalidades para crear el bloque de entrada y el neuroide

addInputBlockItem.addActionListener(act); addNeuroideItem.addActionListener(act);

//Agrego el item al menú popupMenu.add(addInputBlockItem);

popupMenu.add(addNeuroideItem);

//Capturo la posicion donde se esta haciendo click derecho con el mouse

ln_posX = pn_posX;

ln_posY = pn_posY;

35

//Seteo la localizancion en el menú popupMenu.setLocation(me.getX(), me.getY());

//Presento el menu en la localizacion donde se esta realizando el evento popupMenu.show(gc_GraphPanel, me.getX(), me.getY());

} // handleRightClick

//Menú que se visualiza al dar click derecho sobre el bloque de entrada

void handleRightInputBlockClick(MouseEvent me)

{ gc_EditNetwork.clearUndoStack();

repaint();

ActionListener act = new ActionListener()

{ public void actionPerformed(ActionEvent ae) { //si la acción a ejecutar es editar los parámetros del neuroide

if (ae.getActionCommand().equals("Edit Parameters"))

{ ((ActionParametersBlock) a_parameterB).editParameters(ln_posX, ln_posY, gn_current_graph);

return;

}

if (ae.getActionCommand().equals("Delete Input Block"))

{ deleteInputBlock(gn_current_graph);

return;

} repaint();

}

};

try { //Construye el menú secundario al hacer click derecho sobre el neuroide JPopupMenu popupMenu = new JPopupMenu("Choose a value");

//Construyo el Item para editar el valor inicial del bloque de entrada JMenuItem EditParametersItem = new JMenuItem("Edit Parameters");

EditParametersItem.addActionListener(act);

//Construyo el Item para borrar el bloque de entrada

JMenuItem delInputBlockItem = new JMenuItem("Delete Input Block");

delInputBlockItem.addActionListener(act);

//Agrego los items al menú

popupMenu.add(EditParametersItem); popupMenu.add(delInputBlockItem);

popupMenu.setLocation(me.getX(), me.getY()); popupMenu.show(gc_GraphPanel, me.getX(), me.getY());


} // handleRightInputBlockClick

//Menú que se visualiza al dar click derecho sobre el neuroide

void handleRightNeuroideClick(MouseEvent me)


repaint();

ActionListener EditParamsAction = new ActionListener()


{ //si la acción a ejecutar es editar los parámetros del neuroide

if (ae.getActionCommand().equals("Edit Parameters"))

{ ((ActionParametersNeuroid) a_parameterN).editParameters(ln_posX, ln_posY, gn_current_graph);

return; } repaint();

} };

ActionListener addAxonAction = new ActionListener()

{

36


{

try

{ String ls_value_axon =

(String)

JOptionPane.showInputDialog(null, "Enter value for the weight ", "Axon ",

JOptionPane.OK_CANCEL_OPTION);

if (ls_value_axon == null || ls_value_axon.equals(""))

return;

gc_EditNetwork.addAxon(ae.getActionCommand(),

gc_EditNetwork.getTargetName(gn_current_graph));


updateStatus();


}

};

ActionListener delAxonAction = new ActionListener()


{ deleteAxon(gn_current_graph, ae.getActionCommand());

}

}; ActionListener delChildAction = new ActionListener()


{ deleteChild(ae.getActionCommand(), gn_current_graph);

} };

ActionListener delNeuroide = new ActionListener()


{ deleteNeuroide(gn_current_graph);

return;

} };

try { //Construye el menú secundario al hacer click derecho sobre el neuroide JPopupMenu popupMenu = new JPopupMenu("Menu");

JMenuItem item = new JMenuItem("Sub Menu");

//Construyo el Item para borrar el neuroide

JMenuItem delNeuroideItem = new JMenuItem("Delete Neuroide");

delNeuroideItem.addActionListener(delNeuroide);

//Construyo el menú para hacer los enlaces con los demas neuroides

JMenu addArcMenu = new JMenu("Add Axon");

int ln_elements = gc_EditNetwork.getNrOfElements();

boolean[] lb_is_parent = new boolean[ln_elements];

//Para prevenir que sea un nodo padre de el mismo lb_is_parent[gn_current_graph] = true;

for (int i = 0; i < ln_elements; i++)

{ for (int iNeuroide = 0; iNeuroide < ln_elements; iNeuroide++)

{ //Verifico si el neuroide ya tiene un nodo padre

37

for (int iParent = 0; iParent < gc_EditNetwork.getNrOfParents(iNeuroide); iParent++)

{

if (lb_is_parent[gc_EditNetwork.getParent(iNeuroide, iParent)])

lb_is_parent[iNeuroide] = true;

} }

} for (int iParent = 0; iParent < gc_EditNetwork.getNrOfParents(gn_current_graph); iParent++)

lb_is_parent[gc_EditNetwork.getParent(gn_current_graph, iParent)] = true;

//Contador para verificar los candidatos para cada nodo

int ln_candidates = 0;

//Recorro los nodos para verificar si tienen candidatos para enlazarlos

for (int i = 0; i < ln_elements; i++)

{ if (!lb_is_parent[i])

{ item = new JMenuItem(gc_EditNetwork.getTargetName(i)); item.addActionListener(addAxonAction);

addArcMenu.add(item);

ln_candidates++;

}

} //Si cantidad de neuroides es 1 (0),deshabilito la opción de agregar axon

if (ln_candidates == 0)

addArcMenu.setEnabled(false);

//Construyo el item para borrar un enlace entre neuroides

JMenu delArcMenu = new JMenu("Delete Axon");

//Si cantidad de enlaces es 0, deshabilito la opción de eliminar axon

if (gc_EditNetwork.getNrOfParents(gn_current_graph) == 0) delArcMenu.setEnabled(false);

for (int iParent = 0; iParent < gc_EditNetwork.getNrOfParents(gn_current_graph); iParent++)

{ item = new JMenuItem(gc_EditNetwork.getTargetName(gc_EditNetwork.getParent(gn_current_graph, iParent)));

item.addActionListener(delAxonAction);

delArcMenu.add(item);

}

//Construyo el item para borrar enlaces entre un nodo padre y un nodo hijo

JMenu delChildMenu = new JMenu("Delete child");

NeuroidVector lc_Children = gc_EditNetwork.getChildren(gn_current_graph);

if (lc_Children.size() == 0)

delChildMenu.setEnabled(false);

for (int iChild = 0; iChild < lc_Children.size(); iChild++)

{ item = new JMenuItem(gc_EditNetwork.getTargetName((Integer)

lc_Children.elementAt(iChild))); item.addActionListener(delChildAction);

delChildMenu.add(item);

}

//Construyo el item para modificar los parámetros del neuroide

JMenuItem EditParameters = new JMenuItem("Edit Parameters"); EditParameters.addActionListener(EditParamsAction);

//Agrego los items al menú popupMenu.add(EditParameters);

popupMenu.add(delNeuroideItem);

popupMenu.addSeparator(); popupMenu.add(addArcMenu);

popupMenu.add(delArcMenu);

popupMenu.add(delChildMenu);

38

popupMenu.setLocation(me.getX(), me.getY()); popupMenu.show(gc_GraphPanel, me.getX(), me.getY());


} // handleRightNeuroideClick

} // class GraphVisualizerMouseListener

//Clase que programa los movimientos del mouse private class GraphVisualizerMouseMotionListener extends MouseMotionAdapter

{ int ln_last_element = -1; int ln_posX, ln_posY;

public int getGraphElement(MouseEvent me)

{ ln_posX = ln_posY = 0;

Rectangle r = new Rectangle(0, 0, (int) (gn_graph_padded * gf_scale),

(int) (gn_graph_height * gf_scale));

ln_posX += me.getX(); ln_posY += me.getY();

for (int iElement = 0; iElement < gc_EditNetwork.getNrOfElements(); iElement++)

{ r.x = (int) (gc_EditNetwork.getPositionX(iElement) * gf_scale);

r.y = (int) (gc_EditNetwork.getPositionY(iElement) * gf_scale);

if (r.contains(ln_posX, ln_posY)) { return iElement; }

} return -1;

} // getGraphElement

//Método para poder mover los objetos

public void mouseDragged(MouseEvent me)

{ if (gc_SelectedRect != null)

{ gc_SelectedRect.width = me.getPoint().x - gc_SelectedRect.x; gc_SelectedRect.height = me.getPoint().y - gc_SelectedRect.y;

repaint();

return;

}

int ln_element = getGraphElement(me);

if (ln_element >= 0)

{ if (lc_Selection.getSelected().size() > 0)

{ if (lc_Selection.getSelected().contains(ln_element))

{ gc_EditNetwork.setPosition(ln_element, (int) ((ln_posX/gf_scale - gn_graph_padded/2)),

(int) ((ln_posY/gf_scale - gn_graph_height/2)),

lc_Selection.getSelected());

}

else


gc_EditNetwork.setPosition(ln_element,

(int) ((ln_posX/gf_scale - gn_graph_padded/2)), (int) ((ln_posY/gf_scale - gn_graph_height/2)));

} repaint();

}

else

{ gc_EditNetwork.setPosition(ln_element,

(int) ((ln_posX/gf_scale - gn_graph_padded/2)),

(int) ((ln_posY/gf_scale - gn_graph_height/2)));

} statusBar.setText(gc_EditNetwork.lastActionMsg());


39

gc_GraphPanel.highLight(ln_element);

}

else

{ if (ln_last_element >= 0)

{ gc_GraphPanel.repaint(); ln_last_element = -1;

}

else { gc_SelectedRect = new Rectangle(me.getPoint().x, me.getPoint().y, 1, 1);

gc_GraphPanel.repaint();

}

} } // mouseDragged

//Método que se ejecuta cuando se mueve el mouse en la pantalla

public void mouseMoved(MouseEvent me)

{ int ln_element = getGraphElement(me);

if (ln_element >= 0)

{ if (ln_element != ln_last_element)

{ gc_GraphPanel.highLight(ln_element);

if (ln_last_element >= 0)

gc_GraphPanel.highLight(ln_last_element);

ln_last_element = ln_element;

}

}

if (ln_element < 0 && ln_last_element >= 0)

{ gc_GraphPanel.repaint();

ln_last_element = -1;

} } // mouseMoved

} // class GraphVisualizerMouseMotionListener

//Clase para modificar los valores ingresados en el bloque de entrada

class ActionParametersBlock extends MyAction


public ActionParametersBlock()

{ super("Parameters Input Block","Parameters Input Block","parametersblock", "");

}

JDialog dialog = null; JTextField txtValorInicio = new JTextField(5);

JTextField txtValorFinal = new JTextField(5);

JTextField txtPeriodo = new JTextField(5); JTextField txtRetardo = new JTextField(5);

int ln_posX = Integer.MAX_VALUE; int ln_posY;

int ln_target;

String ls_valor_ini;

String ls_valor_fin;

String ls_periodo; String ls_retardo;

String ls_name;

public void editParameters(int pn_posX, int pn_posY, int pn_target)


ln_target = pn_target;

ls_name = gc_EditNetwork.getTargetName(pn_target);

40

String [] outcomes = gc_EditNetwork.getValues(pn_target);

//Obtenemos los valores del bloque de entrada

for (int iValue = 0; iValue < outcomes.length; iValue++)

{ if (outcomes[iValue].substring(0, 2).equals("vi"))

ls_valor_ini = outcomes[iValue].substring(3, 6);

if (outcomes[iValue].substring(0, 2).equals("vf")) ls_valor_fin = outcomes[iValue].substring(3, 6);

if (outcomes[iValue].substring(0, 2).equals("pe"))

ls_periodo = outcomes[iValue].substring(3, 6);

if (outcomes[iValue].substring(0, 2).equals("re"))

ls_retardo = outcomes[iValue].substring(3, 6);

}

editParameters();

}

public void editParameters()



//Titulo del cuadro de dialogo dialog.setTitle("Edit Parameters");

//Parámetros para crear el bloque de entrada final JLabel jLbValorInicio = new JLabel("Initial Value");

final JLabel jLbValorFinal = new JLabel("End Value");

final JLabel jLbPeriodo = new JLabel("Periodo"); final JLabel jLbRetardo = new JLabel("Retardo");

//Validación para que las cajas de texto solo acepten numeros y el "." txtValorInicio.addKeyListener(new KeyAdapter()




e.consume();

if (c == '.' && txtValorInicio.getText().contains("."))

e.consume();

} }); txtValorFinal.addKeyListener(new KeyAdapter()




e.consume();

if (c == '.' && txtValorFinal.getText().contains("."))

e.consume();

} });

txtPeriodo.addKeyListener(new KeyAdapter()




41

if (c == '.' && txtPeriodo.getText().contains("."))

e.consume();

} });

txtRetardo.addKeyListener(new KeyAdapter()




if (c == '.' && txtRetardo.getText().contains(".")) e.consume();

}

});

//Boton Ok

JButton jBtOk = new JButton("Ok"); jBtOk.setMnemonic('O');



{ double lf_ini_value = new Double(txtValorInicio.getText()).doubleValue();

double lf_end_value = new Double(txtValorFinal.getText()).doubleValue();

double lf_periodo = new Double(txtPeriodo.getText()).doubleValue();

double lf_retardo = new Double(txtRetardo.getText()).doubleValue();

if (txtValorInicio.getText().length() > 0)

{ if (txtValorInicio.getText().endsWith("."))

lf_ini_value=0;

else lf_ini_value=

new Double(txtValorInicio.getText()).doubleValue();

}

else lf_ini_value = 0;

if (txtValorFinal.getText().length() > 0)

{ if (txtValorFinal.getText().endsWith(".")) lf_end_value=0;

else lf_end_value= new Double(txtValorFinal.getText()).doubleValue();

}

else lf_end_value = 0;

if (txtPeriodo.getText().length() > 0)

{ if (txtPeriodo.getText().endsWith(".")) lf_periodo=0;

else lf_periodo=new Double(txtPeriodo.getText()).doubleValue();

}

else lf_periodo = 0;

if (txtRetardo.getText().length() > 0)

{

42

if (txtRetardo.getText().endsWith(".")) lf_retardo=0;

else lf_retardo=new Double(txtRetardo.getText()).doubleValue();

}

else lf_retardo = 0;

try

{

gc_EditNetwork.editParameterInputBloc(ln_target, ls_name,

lf_ini_value, new Double(ls_valor_ini).doubleValue(), lf_end_value, new Double(ls_valor_fin).doubleValue(),

lf_periodo, new Double(ls_periodo).doubleValue(),

lf_retardo, new Double(ls_retardo).doubleValue());




repaint();


}

}); //Boton cancelar

JButton jBtCancel;

jBtCancel = new JButton("Cancel"); jBtCancel.setMnemonic('C');



{ dialog.setVisible(false); }

});


dialog.setLayout(new GridBagLayout());

Container lc_container = new Container();

lc_container.setLayout(new GridBagLayout());


//Definimos los espacios entre los objetos de la ventana (nort,izq,sur,der) gridBC.insets = new Insets(10, 10, 5, 10);



lc_container.add(jLbValorInicio, gridBC);

gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtValorInicio, gridBC);


lc_container.add(jLbValorFinal, gridBC);

gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtValorFinal, gridBC);

gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jLbPeriodo, gridBC);


lc_container.add(txtPeriodo, gridBC);


lc_container.add(jLbRetardo, gridBC); gridBC.gridwidth = GridBagConstraints.REMAINDER;

lc_container.add(txtRetardo, gridBC);





43


}

txtValorInicio.setText(ls_valor_ini); txtValorFinal.setText(ls_valor_fin);

txtPeriodo.setText(ls_periodo);

txtRetardo.setText(ls_retardo);


dialog.setVisible(true); dialog.setSize(dialog.getPreferredSize());


dialog.setVisible(true); dialog.repaint();


{ ln_posX = Integer.MAX_VALUE; editParameters();

} } // class ActionParametersBlock

//Clase para modificar los valores ingresados en el neuroide

class ActionParametersNeuroid extends MyAction


public ActionParametersNeuroid()

{ super("Parameters Neuroid", "Parameters Neuroid", "parametersneuroid", "");

}

JDialog dialog = null; JTextField txtNeuroideName = new JTextField(5);

JTextField txtNeuroideUmbr = new JTextField(5);

JTextField txtNeuroideSlope = new JTextField(5);


int ln_posY; int ln_target;

String ls_umbr;

String ls_slope;

String ls_name;

public void editParameters(int pn_posX, int pn_posY, int pn_target)

{ ln_posX = pn_posX;

ln_posY = pn_posY; ln_target = pn_target;

ls_name = gc_EditNetwork.getTargetName(pn_target);

String [] outcomes = gc_EditNetwork.getValues(pn_target);

//Obtenemos los valores del umbral y la pendiente

for (int iValue = 0; iValue < outcomes.length; iValue++)

{ if (outcomes[iValue].substring(0, 6).equals("Umbral"))

ls_umbr = outcomes[iValue].substring(7, 10);

if (outcomes[iValue].substring(0, 5).equals("Slope"))

ls_slope = outcomes[iValue].substring(6, 9);

} editParameters();

} public void editParameters()



//Titulo del cuadro de dialogo

dialog.setTitle("Edit Parameters");

//Opciónes que se presentan en el cuadro de dialogo

44

final JLabel jLbNeuroideName = new JLabel("Name"); final JLabel jLbNeuroideUmbr = new JLabel("Umbral");

final JLabel jLbNeuroideSlope = new JLabel("Slope");

//Validación para que las cajas de texto solo acepten numeros y el "."

txtNeuroideUmbr.addKeyListener(new KeyAdapter()




e.consume();

if (c == '.' && txtNeuroideUmbr.getText().contains("."))

e.consume();

}

}); txtNeuroideSlope.addKeyListener(new KeyAdapter()


{

char c = e.getKeyChar();


e.consume();

if (c == '.' && txtNeuroideSlope.getText().contains("."))

e.consume();

} });

//Boton Ok JButton jBtOk = new JButton("Ok");




{ String ls_new_name = txtNeuroideName.getText();

double lf_new_umbr = 0;

double lf_new_slope = 0;

if (txtNeuroideUmbr.getText().length() > 0)

{ if (txtNeuroideUmbr.getText().endsWith("."))

lf_new_umbr=0;

else lf_new_umbr=new Double(txtNeuroideUmbr.getText()).doubleValue();

}

else lf_new_umbr = 0;

if (txtNeuroideSlope.getText().length() > 0)

{ if (txtNeuroideSlope.getText().endsWith("."))

lf_new_slope=0;

else lf_new_slope=new Double(txtNeuroideSlope.getText()).doubleValue();

}

else lf_new_slope = 0;

if (ls_new_name.length() <= 0)

{//se indica que deberia ingresar por lo menos un caracter

JOptionPane.showMessageDialog(null, "Name should have at least one character");

return; }

//Verifico que el valor del umbral, este entre el rango de 0 y 1 if ((lf_new_umbr <= 0 || lf_new_umbr >= 1))

45

{//se indica que deberia ingresar una cantidad entre 0 y 1 JOptionPane.showMessageDialog(null,

"The Umbral should be larger than 0 and less than 1");

return;

} //Verifico que el valor de la pendiente, tiene que ser un numero > 1

if (lf_new_slope <= 0)

{//se indica que deberia ingresar una cantidad mayor a uno JOptionPane.showMessageDialog(null,

"The Slope should be larger than 1");

return;

}

try

{ gc_EditNetwork.editParameterNeuroide(ln_target, ls_new_name, lf_new_umbr, new Double(ls_umbr).doubleValue(),

lf_new_slope, new Double(ls_slope).doubleValue());




repaint();


} });

//Boton cancelar JButton jBtCancel;

jBtCancel = new JButton("Cancel");

jBtCancel.setMnemonic('C'); jBtCancel.addActionListener(new ActionListener()

{ public void actionPerformed(ActionEvent ae) { dialog.setVisible(false); }

});


dialog.setLayout(new GridBagLayout());

Container lc_container = new Container();

lc_container.setLayout(new GridBagLayout());


//Definimos espacios entre los objetos de la ventana (nort,izq,sur,der)

gridBC.insets = new Insets(10, 10, 5, 10); gridBC.anchor = GridBagConstraints.NORTHWEST;


lc_container.add(jLbNeuroideName, gridBC);

gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtNeuroideName, gridBC);

gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jLbNeuroideUmbr, gridBC);


lc_container.add(txtNeuroideUmbr, gridBC);


lc_container.add(jLbNeuroideSlope, gridBC); gridBC.gridwidth = GridBagConstraints.REMAINDER;

lc_container.add(txtNeuroideSlope, gridBC);





46


}

txtNeuroideName.setText(ls_name); txtNeuroideUmbr.setText(ls_umbr);

txtNeuroideSlope.setText(ls_slope);


dialog.setVisible(true);

dialog.setSize(dialog.getPreferredSize()); dialog.setVisible(false);

dialog.setVisible(true);

dialog.repaint();

}


{ ln_posX = Integer.MAX_VALUE;

editParameters();

} } // class ActionParametersNeuroid

void updateStatus()

{ a_undo.setEnabled(gc_EditNetwork.canUndo()); a_redo.setEnabled(gc_EditNetwork.canRedo());

repaint(); } // updateStatus

//Método que realiza la acción de eliminar enlace (Delete Axon) void deleteAxon(int pn_child, String ps_parent)

{

try { gc_EditNetwork.deleteAxon(gc_EditNetwork.getNeuroide(ps_parent), pn_child);




updateStatus();

} // deleteAxon

//Método que realiza la acción de eliminar enlace (Delete Axon)

void deleteChild(String ps_child, int pn_parent)

{

try

{ gc_EditNetwork.deleteAxon(pn_parent, gc_EditNetwork.getNeuroide(ps_child));




updateStatus();

} // deleteAxon

//Método que realiza la acción de eliminar un enlace (Delete Neuroide)

void deleteNeuroide(int pn_neuroide)

{

try

{ gc_EditNetwork.deleteNeuroide(pn_neuroide);




updateStatus();

} // deleteNeuroide

//Método que realiza la acción de eliminar un enlace (Delete Input Block)

void deleteInputBlock(int pn_block)

{ try

47

{ gc_EditNetwork.deleteInputBlock(pn_block);




updateStatus();

} // deleteInputBlock

//Método principal de la clase

public static void main(String[] args)

{ Image lc_Icon;

//Carga imagen de incio de la aplicación SplashWindow.splash

(ClassLoader.getSystemResource("promeinfo/neuroid/images/promeinfo_splash.gif"));

//Defino el nomble de la aplicación

JFrame jf = new JFrame("Neuroidal Network Editor");

//Icono de la aplicación

lc_Icon = Toolkit.getDefaultToolkit().getImage(GUI.class.getClassLoader().

getResource("promeinfo/neuroid/icons/Neuroidal Network.png"));

//Coloco el icono en el frame

jf.setIconImage(lc_Icon);

if (gui == null)

{ gui = new GUI();

MainFrame = gui;

}

//Obtengo el menu JMenuBar menuBar = gui.getMenuBar();

//Coloco el menu en el frame jf.setJMenuBar(menuBar);

jf.getContentPane().add(gui);

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

jf.setSize(800, 600);

jf.setVisible(true); gui.lc_Selection.updateGUI();

//Cierra la imagen que se carga al inicio de la aplicación SplashWindow.disposeSplash();

} // main

} //

Clase EditableNetwork




*

* This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details. *

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

48

*/ package promeinfo.net;

import java.io.Serializable; import java.io.StringReader;

import java.util.StringTokenizer;

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.CharacterData; import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node; import org.w3c.dom.NodeList;

import promeinfo.core.Attribute; import promeinfo.core.DiscreteEstimatorElement;

import promeinfo.core.Estimator;

import promeinfo.core.NeuroidVector; import promeinfo.core.Instances;

import promeinfo.core.SerializedObject;

public class EditableNetwork extends NeuroidNet

{ static final long serialVersionUID = 1L;

protected NeuroidVector gc_VectorPosX;

protected NeuroidVector gc_VectorPosY;

public NeuroidVector gc_UndoStack = new NeuroidVector();

int gn_current_edit_action = -1;

int gn_saved_pointer = -1;

boolean gb_needs_undo_action = true;

//Método constructor de la clase

public EditableNetwork(BIFReader lc_Other)

{ gc_Instances = lc_Other.gc_Instances;

gc_ParentSets = lc_Other.getParentSets(); gc_Distributions = lc_Other.getDistributions();

int ln_neuroide = getNrOfNeuroides();

gc_VectorPosX = new NeuroidVector(ln_neuroide);

gc_VectorPosY = new NeuroidVector(ln_neuroide);

for (int i = 0; i < ln_neuroide; i++)

{ gc_VectorPosX.addElement(lc_Other.gn_positionX[i]);

gc_VectorPosY.addElement(lc_Other.gn_positionY[i]);

} clearUndoStack();

}

//Método constructor de la clase

public EditableNetwork(boolean pb_setInstances)

{

super(); gc_VectorPosX = new NeuroidVector();

gc_VectorPosY = new NeuroidVector();

clearUndoStack();

if (pb_setInstances) gc_Instances = new Instances("New Network", new NeuroidVector(0), 0);

} //Método para validar que no se repitan los nombres de los neuroides

public int getNeuroide2(String ps_neuroide_name)

{ int ln_neuroide = 0;

while (ln_neuroide < gc_Instances.numAttributes())

{

49

if (gc_Instances.attribute(ln_neuroide).name().equals(ps_neuroide_name)) return ln_neuroide;

ln_neuroide++;

} return -1;

} // getNeuroide2

//Método para buscar un neuroide

public int getNeuroide(String ps_neuroide_name) throws Exception

{ int ln_neuroide = getNeuroide2(ps_neuroide_name);

if (ln_neuroide < 0)

throw new Exception("Could not find neuroide [[" + ps_neuroide_name + "]]");

return ln_neuroide;

} // getNeuroide

//Método para crear neuroides

public void addNeuroide(String ps_name, int pn_parameters, double pf_umbr, double pf_slope) throws Exception

{ addNeuroide(ps_name, pn_parameters, pf_umbr, pf_slope, 100 + getNrOfNeuroides() * 10, 100 + getNrOfNeuroides() * 10);

} // addNeuroide

//Método para crear neuroides

public void addNeuroide(String ps_name, int pn_parameters, double pf_umbr, double pf_slope, int pn_posX, int pn_posY)

throws Exception

{ //Verifico si el nombre del neuroide esta repetido, en caso estar repetido le concatenamos una 'X'

if (getNeuroide2(ps_name) >= 0)

{ addNeuroide(ps_name + "x", pn_parameters, pf_umbr, pf_slope);

return ; }

NeuroidVector lc_Values = new NeuroidVector(pn_parameters);

lc_Values.addElement("Umbral:"+pf_umbr);

lc_Values.addElement("Slope:"+pf_slope);

Attribute lc_Att = new Attribute(ps_name, lc_Values);

gc_Instances.insertAttributeAt(lc_Att, gc_Instances.numAttributes());

int ln_atts = gc_Instances.numAttributes();

ParentSet[] lc_ParentSets = new ParentSet[ln_atts];

for (int iParentSet = 0; iParentSet < ln_atts - 1; iParentSet++) lc_ParentSets[iParentSet] = gc_ParentSets[iParentSet];

lc_ParentSets[ln_atts - 1] = new ParentSet(); gc_ParentSets = lc_ParentSets;

Estimator[][] lc_Distributions = new Estimator[ln_atts][];

for (int iNeuroide = 0; iNeuroide < ln_atts - 1; iNeuroide++) lc_Distributions[iNeuroide] = gc_Distributions[iNeuroide];

lc_Distributions[ln_atts - 1] = new Estimator[1]; lc_Distributions[ln_atts - 1][0] = new DiscreteEstimatorElement(pn_parameters, 0.5);

gc_Distributions = lc_Distributions;

gc_VectorPosX.addElement(pn_posX); gc_VectorPosY.addElement(pn_posY);

if (gb_needs_undo_action) addUndoAction(new AddNeuroideAction(ps_name, pn_parameters, pf_umbr, pf_slope, pn_posX, pn_posY));

} // addNeuroide

//Método para crear bloques de entrada

public void addInputBlock(String ps_name, int pn_parameter, double pf_ini_value, double pf_end_value, double

pf_periodo, double pf_retardo) throws Exception

{ addInputBlock(ps_name, pn_parameter, pf_ini_value, pf_end_value, pf_periodo, pf_retardo, 50 +

getNrOfInputBlocks() * 10, 50 + getNrOfInputBlocks() * 10); } // addInputBlock

50

//Método para crear bloques de entrada

//vi: valor inicial; vf: valor final; pe: periodo; re: retardo

public void addInputBlock(String ps_name, int pn_parameter, double pf_ini_value, double pf_end_value, double pf_periodo, double pf_retardo, int pn_posX, int pn_posY) throws Exception

{ NeuroidVector lc_Values = new NeuroidVector(pn_parameter);

lc_Values.addElement("vi:"+pf_ini_value);

lc_Values.addElement("vf:"+pf_end_value); lc_Values.addElement("pe:"+pf_periodo);

lc_Values.addElement("re:"+pf_retardo);

Attribute lc_Att = new Attribute(ps_name, lc_Values);

gc_Instances.insertAttributeAt(lc_Att, gc_Instances.numAttributes()); int ln_atts = gc_Instances.numAttributes();


for (int iParentSet = 0; iParentSet < ln_atts - 1; iParentSet++)

lc_ParentSets[iParentSet] = gc_ParentSets[iParentSet];

lc_ParentSets[ln_atts - 1] = new ParentSet();

gc_ParentSets = lc_ParentSets;


for (int iBlock = 0; iBlock < ln_atts - 1; iBlock++)

lc_Distributions[iBlock] = gc_Distributions[iBlock];

lc_Distributions[ln_atts - 1] = new Estimator[1];

lc_Distributions[ln_atts - 1][0] = new DiscreteEstimatorElement(pn_parameter, 0.5);


gc_VectorPosX.addElement(pn_posX);

gc_VectorPosY.addElement(pn_posY);

if (gb_needs_undo_action)

addUndoAction(new AddInputBlockAction(ps_name, pn_parameter, pf_ini_value, pf_end_value, pn_posX, pn_posY)); } // addInputBlock

//Método para eliminar bloques de entrada

public void deleteInputBlock(int pn_target_block) throws Exception

{ if (gb_needs_undo_action) addUndoAction(new DeleteInputBlockAction(pn_target_block));

int ln_atts = gc_Instances.numAttributes() - 1; int ln_target = gc_Instances.attribute(pn_target_block).numValues();


for (int iBlock = 0; iBlock < ln_atts; iBlock++)

{ int ln_block2 = iBlock;

if (iBlock >= pn_target_block)

ln_block2++;

Estimator[] lc_Distribution = gc_Distributions[ln_block2];

if (gc_ParentSets[ln_block2].contains(pn_target_block))

{

int ln_parent = gc_ParentSets[ln_block2].getValueOfParents();

ln_parent = ln_parent / ln_target; Estimator[] lc_Distribution2 = new Estimator[ln_parent];

for (int iParent = 0; iParent < ln_parent; iParent++) lc_Distribution2[iParent] = lc_Distribution[iParent];

lc_Distribution = lc_Distribution2;

} lc_Distributions[iBlock] = lc_Distribution;

}

51



for (int iParentSet = 0; iParentSet < ln_atts; iParentSet++)

{ int ln_parentSet2 = iParentSet;

if (iParentSet >= pn_target_block)

ln_parentSet2++;

ParentSet lc_Parentset = gc_ParentSets[ln_parentSet2];

lc_Parentset.deleteParent(pn_target_block, gc_Instances);

for (int iParent = 0; iParent < lc_Parentset.getNrOfParents(); iParent++)

{ int ln_parent = lc_Parentset.getParent(iParent);

if (ln_parent > pn_target_block) lc_Parentset.SetParent(iParent, ln_parent - 1);

} lc_ParentSets[iParentSet] = lc_Parentset;

}


//Actualizo instancias

gc_Instances.setClassIndex(-1); gc_Instances.deleteAttributeAt(pn_target_block);

gc_Instances.setClassIndex(ln_atts - 1);

//Actualizo posiciones

gc_VectorPosX.removeElementAt(pn_target_block);

gc_VectorPosY.removeElementAt(pn_target_block); } // deleteInputBlock

//Método para eliminar neuroides public void deleteNeuroide(int pn_target_neuroide) throws Exception

{ if (gb_needs_undo_action) addUndoAction(new DeleteNeuroideAction(pn_target_neuroide));

int ln_atts = gc_Instances.numAttributes() - 1;

int ln_target = gc_Instances.attribute(pn_target_neuroide).numValues();


for (int iNeuroide = 0; iNeuroide < ln_atts; iNeuroide++)

{ int ln_neuroide2 = iNeuroide;

if (iNeuroide >= pn_target_neuroide) ln_neuroide2++;

Estimator[] lc_Distribution = gc_Distributions[ln_neuroide2];

if (gc_ParentSets[ln_neuroide2].contains(pn_target_neuroide))

{ int ln_parent = gc_ParentSets[ln_neuroide2].getValueOfParents();

ln_parent = ln_parent / ln_target; Estimator[] lc_Distribution2 = new Estimator[ln_parent];

for (int iParent = 0; iParent < ln_parent; iParent++) lc_Distribution2[iParent] = lc_Distribution[iParent];

lc_Distribution = lc_Distribution2;

} lc_Distributions[iNeuroide] = lc_Distribution;

}




{

52

int ln_parentSet2 = iParentSet;

if (iParentSet >= pn_target_neuroide)

ln_parentSet2++;

ParentSet lc_Parentset = gc_ParentSets[ln_parentSet2];

lc_Parentset.deleteParent(pn_target_neuroide, gc_Instances);

for (int iParent = 0; iParent < lc_Parentset.getNrOfParents(); iParent++)

{ int ln_parent = lc_Parentset.getParent(iParent);

if (ln_parent > pn_target_neuroide) lc_Parentset.SetParent(iParent, ln_parent - 1);

} lc_ParentSets[iParentSet] = lc_Parentset;

}


//Actualizo instancias

gc_Instances.setClassIndex(-1); gc_Instances.deleteAttributeAt(pn_target_neuroide);

gc_Instances.setClassIndex(ln_atts - 1);

//Actualizo posiciones

gc_VectorPosX.removeElementAt(pn_target_neuroide);

gc_VectorPosY.removeElementAt(pn_target_neuroide); } // deleteNeuroide

//Método para eliminar un elemento seleccionado public void deleteSelection(NeuroidVector pc_Target)

{ for (int i = 0; i < pc_Target.size(); i++)

{ for (int j = i + 1; j < pc_Target.size(); j++)

{ if ((Integer) pc_Target.elementAt(i) > (Integer) pc_Target.elementAt(j))

{ int h = (Integer) pc_Target.elementAt(i); pc_Target.setElementAt(pc_Target.elementAt(j), i);

pc_Target.setElementAt(h, j);

}

}

} if (gb_needs_undo_action)

addUndoAction(new DeleteSelectionAction(pc_Target));

boolean lb_NeedsUndoAction = gb_needs_undo_action;

gb_needs_undo_action = false;

try

{ for (int i = pc_Target.size() - 1; i >= 0; i--)

deleteNeuroide((Integer) pc_Target.elementAt(i));



gb_needs_undo_action = lb_NeedsUndoAction;

} // deleteSelection

//Método para la acción de selección de un elemento

NeuroidVector selectElements(Node pc_Item, String ps_element) throws Exception

{ NodeList lc_Children = pc_Item.getChildNodes();

NeuroidVector lc_Codelist = new NeuroidVector();

for (int i = 0; i < lc_Children.getLength(); i++)

{ Node lc_Neuroide = lc_Children.item(i);

if ((lc_Neuroide.getNodeType() == Node.ELEMENT_NODE) && lc_Neuroide.getNodeName().equals(ps_element))

lc_Codelist.addElement(lc_Neuroide);

}

53

return lc_Codelist; } // selectElements

public String getContent(Element pc_Element)

{ NodeList lc_List;

Node lc_Item; int i;

String ls_result;

ls_result = "";

lc_List = pc_Element.getChildNodes();

for (i = 0; i < lc_List.getLength(); i++)

{ lc_Item = lc_List.item(i);

if (lc_Item.getNodeType() == Node.TEXT_NODE)

ls_result += "\n" + lc_Item.getNodeValue();

} return ls_result;

}

Element getDefinition(Document pc_Doc, String ps_name) throws Exception

{ NodeList lc_NodeList = pc_Doc.getElementsByTagName("DEFINITION");

for (int i = 0; i < lc_NodeList.getLength(); i++)

{ Node lc_Neuroide = lc_NodeList.item(i);

NeuroidVector lc_List = selectElements(lc_Neuroide, "FOR");

if (lc_List.size() > 0)

{ Node lc_ForNode = (Node) lc_List.elementAt(0);

if (getContent((Element) lc_ForNode).trim().equals(ps_name)) return (Element) lc_Neuroide;

}

}

throw new Exception("Could not find definition for ((" + ps_name + "))");

} // getDefinition

final static int TEST = 0;

final static int EXECUTE = 1;

//Método que realiza la acción de pegar un elemento que este en el portapapeles

public void paste(String ps_xml) throws Exception

{

try { paste(ps_xml, TEST); } catch (Exception e)

{ throw e; }

paste(ps_xml, EXECUTE);

} // paste

//Método que realiza la acción de pegar un elemento que este en el portapapeles

void paste(String ps_xml, int pn_mode) throws Exception

{ DocumentBuilderFactory lc_Factory = DocumentBuilderFactory.newInstance();

lc_Factory.setValidating(true); Document lc_Doc = lc_Factory.newDocumentBuilder().parse(new org.xml.sax.InputSource(new StringReader(ps_xml)));

lc_Doc.normalize();

NodeList lc_NodeList = lc_Doc.getElementsByTagName("VARIABLE");

NeuroidVector lc_BaseNames = new NeuroidVector();

Instances lc_Instances = new Instances(gc_Instances, 0); int ln_base = lc_Instances.numAttributes();

for (int iNeuroide = 0; iNeuroide < lc_NodeList.getLength(); iNeuroide++)

{ NeuroidVector lc_ValuesList;

lc_ValuesList = selectElements(lc_NodeList.item(iNeuroide), "OUTCOME");

54

int ln_values = lc_ValuesList.size(); NeuroidVector lc_NomStrings = new NeuroidVector(ln_values + 1);

for (int iValue = 0; iValue < ln_values; iValue++)

{ Node lc_Node = ((Node) lc_ValuesList.elementAt(iValue)).getFirstChild();

String ls_value = ((CharacterData) (lc_Node)).getData();

if (ls_value == null)

ls_value = "Value" + (iValue + 1);

lc_NomStrings.addElement(ls_value);

}

NeuroidVector lc_NodeList2;

lc_NodeList2 = selectElements(lc_NodeList.item(iNeuroide), "NAME");

if (lc_NodeList2.size() == 0)

throw new Exception("No name specified for variable");

String ls_base_name = ((CharacterData) (((Node) lc_NodeList2.elementAt(0)).getFirstChild())).getData();

lc_BaseNames.addElement(ls_base_name); String ls_node_name = ls_base_name;

if (getNeuroide2(ls_node_name) >= 0) ls_node_name = "Copy of " + ls_base_name;

int ln_attempt = 2;

while (getNeuroide2(ls_node_name) >= 0)

{ ls_node_name = "Copy (" + ln_attempt + ") of " + ls_base_name;

ln_attempt++;

}

Attribute lc_Att = new Attribute(ls_node_name, lc_NomStrings);

lc_Instances.insertAttributeAt(lc_Att, lc_Instances.numAttributes());

lc_ValuesList = selectElements(lc_NodeList.item(iNeuroide), "PROPERTY");

ln_values = lc_ValuesList.size();

int ln_posX = ln_attempt * 10;

int ln_posY = ln_attempt * 10;


{ Node lc_Node = ((Node) lc_ValuesList.elementAt(iValue)).getFirstChild();

String ls_value = ((CharacterData) (lc_Node)).getData();

if (ls_value.startsWith("position"))

{ int i0 = ls_value.indexOf('('); int i1 = ls_value.indexOf(',');

int i2 = ls_value.indexOf(')'); String ls_X = ls_value.substring(i0 + 1, i1).trim();

String ls_Y = ls_value.substring(i1 + 1, i2).trim();

try

{ ln_posX = (Integer.parseInt(ls_X) + ln_attempt * 10); ln_posY = (Integer.parseInt(ls_Y) + ln_attempt * 10);

} catch (NumberFormatException e)

{

System.err.println("Wrong number format in position :(" + ls_X + "," + ls_Y + ")");

} }

} if (pn_mode == EXECUTE)

{ gc_VectorPosX.addElement(ln_posX); gc_VectorPosY.addElement(ln_posY);

}

}

55

NeuroidVector lc_NodeList2; Estimator[][] lc_Distributions = new Estimator[ln_base + lc_BaseNames.size()][];

ParentSet[] lc_ParentSets = new ParentSet[ln_base + lc_BaseNames.size()];

for (int iNode = 0; iNode < ln_base; iNode++)

{ lc_Distributions[iNode] = gc_Distributions[iNode]; lc_ParentSets[iNode] = gc_ParentSets[iNode];

} if (pn_mode == EXECUTE)

gc_Instances = lc_Instances;

for (int iNode = 0; iNode < lc_BaseNames.size(); iNode++)

{ String ls_name = (String) lc_BaseNames.elementAt(iNode); Element lc_Definition = getDefinition(lc_Doc, ls_name);

lc_ParentSets[ln_base + iNode] = new ParentSet();

lc_NodeList2 = selectElements(lc_Definition, "GIVEN");

for (int iParent = 0; iParent < lc_NodeList2.size(); iParent++)

{

Node lc_ParentName = ((Node) lc_NodeList2.elementAt(iParent)).getFirstChild();

String ls_parent_name = ((CharacterData) (lc_ParentName)).getData(); int ln_parent = -1;

for (int iBase = 0; iBase < lc_BaseNames.size(); iBase++)

{ if (ls_parent_name.equals((String) lc_BaseNames.elementAt(iBase)))

ln_parent = ln_base + iBase;

}

if (ln_parent < 0) ln_parent = getNeuroide(ls_parent_name);

lc_ParentSets[ln_base + iNode].addParent(ln_parent, lc_Instances);

}

int ln_cardinality = lc_ParentSets[ln_base + iNode].getValueOfParents(); int ln_values = lc_Instances.attribute(ln_base + iNode).numValues();

lc_Distributions[ln_base + iNode] = new Estimator[ln_cardinality];

for (int i = 0; i < ln_cardinality; i++)

lc_Distributions[ln_base + iNode][i] = new DiscreteEstimatorElement(ln_values, 0.0f);

String ls_table = getContent((Element) selectElements(lc_Definition, "TABLE").elementAt(0));

ls_table = ls_table.replaceAll("\\n", " ");

StringTokenizer st = new StringTokenizer(ls_table.toString());

for (int i = 0; i < ln_cardinality; i++)

{ DiscreteEstimatorElement lc_DiscreteEstimator = (DiscreteEstimatorElement) lc_Distributions[ln_base + iNode][i];


{ String ls_weight = st.nextToken();

lc_DiscreteEstimator.addValue(iValue, new Double(ls_weight).doubleValue());

}

}

}

if (pn_mode == EXECUTE)

{ gc_Distributions = lc_Distributions;


}

if (pn_mode == EXECUTE && gb_needs_undo_action)

addUndoAction(new PasteAction(ps_xml, ln_base)); } // paste

//Método que agrega un enlace entre elementos public void addAxon(String ps_parent, String ps_child) throws Exception

56

{ int ln_parent = getNeuroide(ps_parent);

int ln_child = getNeuroide(ps_child);

addAxon(ln_parent, ln_child);

} // addAxon

//Método que agrega un enlace entre elementos

public void addAxon(int pn_parent, int pn_child) throws Exception

{ if (gb_needs_undo_action)

addUndoAction(new AddAxonAction(pn_parent, pn_child));

int ln_old_card = gc_ParentSets[pn_child].getValueOfParents();

gc_ParentSets[pn_child].addParent(pn_parent, gc_Instances);

int ln_new_card = gc_ParentSets[pn_child].getValueOfParents(); Estimator[] lc_Estimate = new Estimator[ln_new_card];

for (int iParent = 0; iParent < ln_new_card; iParent++) lc_Estimate[iParent] = Estimator.clone(gc_Distributions[pn_child][iParent % ln_old_card]);

gc_Distributions[pn_child] = lc_Estimate; } // addAxon

//Método que elimina un axon (enlace) public void deleteAxon(int pn_parent, int pn_child) throws Exception

{ if (gb_needs_undo_action) addUndoAction(new DeleteAxonAction(pn_parent, pn_child));

int ln_parent_card = gc_ParentSets[pn_child].getValueOfParents(); int ln_target_card = gc_Instances.attribute(pn_child).numValues();

ln_parent_card = ln_parent_card / ln_target_card; Estimator[] lc_Distribution2 = new Estimator[ln_parent_card];

for (int iParent = 0; iParent < ln_parent_card; iParent++) lc_Distribution2[iParent] = gc_Distributions[pn_child][iParent];

gc_Distributions[pn_child] = lc_Distribution2;

gc_ParentSets[pn_child].deleteParent(pn_parent, gc_Instances);

} // deleteAxon

//Método que retorna los valores que contiene un elemento

public String[] getValues(int pn_target)

{ String[] values = new String[getCardinality(pn_target)];

for (int iValue = 0; iValue < values.length; iValue++)

values[iValue] = gc_Instances.attribute(pn_target).value(iValue);

return values;

} // getValues

//Método para editar los parámetros del neuroide

public void editParameterNeuroide(int pn_target, String ps_new_name, double pf_new_umbr, double pf_old_umbr,

double pf_new_slope, double pf_old_slope)


{ addUndoAction(new EditNeuroideAction(pn_target, getTargetName(pn_target), ps_new_name,

pf_old_umbr, pf_new_umbr,

pf_old_slope,pf_new_slope));

} Attribute lc_Att = gc_Instances.attribute(pn_target);

int ln_value = lc_Att.numValues();

NeuroidVector lc_Values = new NeuroidVector(ln_value);

lc_Values.addElement("Umbral:"+pf_new_umbr); lc_Values.addElement("Slope:"+pf_new_slope);

57

Attribute lc_NewAtt = new Attribute(ps_new_name, lc_Values);

if (gc_Instances.classIndex() == pn_target)

{ gc_Instances.setClassIndex(-1);

gc_Instances.deleteAttributeAt(pn_target);

gc_Instances.insertAttributeAt(lc_NewAtt, pn_target);

gc_Instances.setClassIndex(pn_target);

}

else

{ gc_Instances.deleteAttributeAt(pn_target);

gc_Instances.insertAttributeAt(lc_NewAtt, pn_target);

} } // setNeuroideName

//Método para editar los parámetros del bloque de entrada public void editParameterInputBloc(int pn_target, String ps_name,

double pf_new_vi, double pf_old_vi,

double pf_new_vf, double pf_old_vf, double pf_new_pe, double pf_old_pe,

double pf_new_re, double pf_old_re)


{ addUndoAction(new EditInputBlockAction(pn_target, ps_name, pf_old_vi, pf_new_vi,

pf_old_vf, pf_new_vf,

pf_old_pe, pf_new_pe, pf_old_re, pf_new_re));

} Attribute lc_Att = gc_Instances.attribute(pn_target);

int ln_value = lc_Att.numValues();

NeuroidVector lc_Values = new NeuroidVector(ln_value);

lc_Values.addElement("vi:"+pf_new_vi); lc_Values.addElement("vf:"+pf_new_vf);

lc_Values.addElement("pe:"+pf_new_pe);

lc_Values.addElement("re:"+pf_new_re);

Attribute lc_NewAtt = new Attribute(ps_name, lc_Values);

if (gc_Instances.classIndex() == pn_target)

{ gc_Instances.setClassIndex(-1);

gc_Instances.deleteAttributeAt(pn_target);

gc_Instances.insertAttributeAt(lc_NewAtt, pn_target); gc_Instances.setClassIndex(pn_target);

} else

{ gc_Instances.deleteAttributeAt(pn_target); gc_Instances.insertAttributeAt(lc_NewAtt, pn_target);

} } // editParameterInputBloc

//Método que realiza la acción de posicionar un elemento

public void setPosition(int pn_element, int pn_posX, int pn_posY)

{


{ boolean lb_is_update = false;

UndoAction lc_UndoAction = null;

try

{ if (gc_UndoStack.size() > 0)

{ lc_UndoAction=(UndoAction) gc_UndoStack.elementAt(gc_UndoStack.size()-1);

SetPositionAction posAction = (SetPositionAction) lc_UndoAction;

58

if (posAction.ln_target == pn_element)

{

lb_is_update = true;

posAction.setUndoPosition(pn_posX, pn_posY);

}

}

} catch (Exception e) { }

if (!lb_is_update) addUndoAction(new SetPositionAction(pn_element, pn_posX, pn_posY));

} gc_VectorPosX.setElementAt(pn_posX, pn_element); gc_VectorPosY.setElementAt(pn_posY, pn_element);

} // setPosition

//Método que realiza la acción de posicionar un elemento

public void setPosition(int pn_element, int pn_posX, int pn_posY, NeuroidVector pc_Elements)

{ int ln_posX = pn_posX - getPositionX(pn_element);

int ln_posY = pn_posY - getPositionY(pn_element);


{ boolean lb_is_update = false;

try

{ UndoAction lc_UndoAction = null;

if (gc_UndoStack.size() > 0)

{ lc_UndoAction = (UndoAction) gc_UndoStack.elementAt(gc_UndoStack.size() - 1);

SetGroupPositionAction lc_PosAction = (SetGroupPositionAction) lc_UndoAction; lb_is_update = true;

int ln_element = 0;

while (lb_is_update && ln_element < lc_PosAction.lc_Element.size())

{ if ((Integer)lc_PosAction.lc_Element.elementAt(ln_element) != (Integer) pc_Elements.elementAt(ln_element)) lb_is_update = false;

ln_element++;

}

if (lb_is_update == true) lc_PosAction.setUndoPosition(ln_posX, ln_posY);

}

} catch (Exception e) { }

if (!lb_is_update) addUndoAction(new SetGroupPositionAction(pc_Elements, ln_posX, ln_posY));

}

for (int i = 0; i < pc_Elements.size(); i++)

{ pn_element = (Integer) pc_Elements.elementAt(i);

gc_VectorPosX.setElementAt(getPositionX(pn_element) + ln_posX, pn_element);

gc_VectorPosY.setElementAt(getPositionY(pn_element) + ln_posY, pn_element);

} } // setPosition

//Método que realiza la acción obtener la posición del eje X de un elemento

public int getPositionX(int pn_target)

{ return (Integer) (gc_VectorPosX.elementAt(pn_target));

} //Método que realiza la acción obtener la posición del eje Y de un elemento

public int getPositionY(int pn_target)

{ return (Integer) (gc_VectorPosY.elementAt(pn_target));

} //Método para verificar si un neuroide es hijo de otro nodo

59

public NeuroidVector getChildren(int pn_target)

{

NeuroidVector lc_Children = new NeuroidVector();

for (int i = 0; i < getNrOfNeuroides(); i++)

{ if (gc_ParentSets[i].contains(pn_target)) lc_Children.addElement(i);

} return lc_Children; } // getChildren

//Método para construir el XML cuando se guarda la red neuroidal public String toXMLBIF03()

{ if (gc_Instances == null) return ("");

StringBuffer ls_text = new StringBuffer(); ls_text.append(getBIFHeader());

ls_text.append("\n");

ls_text.append("\n"); ls_text.append("<BIF VERSION=\"0.3\">\n");

ls_text.append("<NETWORK>\n");

ls_text.append("<NAME>" + XMLNormalize(gc_Instances.relationName()) + "</NAME>\n");

for (int iAttribute = 0; iAttribute < gc_Instances.numAttributes(); iAttribute++)

{ ls_text.append("<VARIABLE TYPE=\"nature\">\n");

ls_text.append("<NAME>" + XMLNormalize(gc_Instances.attribute(iAttribute).name()) + "</NAME>\n");

for (int iValue = 0; iValue < gc_Instances.attribute(iAttribute).numValues(); iValue++)

ls_text.append("<OUTCOME>" + XMLNormalize(gc_Instances.attribute(iAttribute).value(iValue)) + "</OUTCOME>\n");

ls_text.append("<PROPERTY>position = (" + getPositionX(iAttribute) + "," + getPositionY(iAttribute) +

")</PROPERTY>\n");

ls_text.append("</VARIABLE>\n");

}

for (int iAttribute = 0; iAttribute < gc_Instances.numAttributes(); iAttribute++)

{ ls_text.append("<DEFINITION>\n");

ls_text.append("<FOR>" + XMLNormalize(gc_Instances.attribute(iAttribute).name()) + "</FOR>\n");

for (int iParent = 0; iParent < gc_ParentSets[iAttribute].getNrOfParents(); iParent++)

ls_text.append("<GIVEN>" + XMLNormalize(gc_Instances.attribute(gc_ParentSets[iAttribute].getParent(iParent)).name())+ "</GIVEN>\n");

ls_text.append("<TABLE>\n");

for (int iParent = 0; iParent < gc_ParentSets[iAttribute].getValueOfParents(); iParent++)

{ for (int iValue = 0; iValue < gc_Instances.attribute(iAttribute).numValues(); iValue++)

{ ls_text.append(gc_Distributions[iAttribute][iParent].getProbability(iValue));

ls_text.append(' ');

} ls_text.append('\n');

} ls_text.append("</TABLE>\n"); ls_text.append("</DEFINITION>\n");

} ls_text.append("</NETWORK>\n"); ls_text.append("</BIF>\n");

return ls_text.toString(); } // toXMLBIF03

//Método para construir el XML cuando se copia un elemento de la red neuroidal public String toXMLBIF03(NeuroidVector pc_Elements)

{ StringBuffer ls_text = new StringBuffer(); ls_text.append(getBIFHeader());

ls_text.append("\n");

ls_text.append("\n"); ls_text.append("<BIF VERSION=\"0.3\">\n");

60

ls_text.append("<NETWORK>\n"); ls_text.append("<NAME>" + XMLNormalize(gc_Instances.relationName()) + "</NAME>\n");

for (int iElement = 0; iElement < pc_Elements.size(); iElement++)

{ int ln_element = (Integer) pc_Elements.elementAt(iElement);

ls_text.append("<VARIABLE TYPE=\"nature\">\n"); ls_text.append("<NAME>" + XMLNormalize(gc_Instances.attribute(ln_element).name()) + "</NAME>\n");

for (int iValue = 0; iValue < gc_Instances.attribute(ln_element).numValues(); iValue++) ls_text.append("<OUTCOME>" + XMLNormalize(gc_Instances.attribute(ln_element).value(iValue)) + "</OUTCOME>\n");

ls_text.append("<PROPERTY>position = (" + getPositionX(ln_element) + "," + getPositionY(ln_element) + ")</PROPERTY>\n");

ls_text.append("</VARIABLE>\n");

}

for (int iElement = 0; iElement < pc_Elements.size(); iElement++)

{ int ln_element = (Integer) pc_Elements.elementAt(iElement);

ls_text.append("<DEFINITION>\n");

ls_text.append("<FOR>" + XMLNormalize(gc_Instances.attribute(ln_element).name()) + "</FOR>\n");

for (int iParent = 0; iParent < gc_ParentSets[ln_element].getNrOfParents(); iParent++)

{ ls_text.append("<GIVEN>" + XMLNormalize(gc_Instances.attribute(gc_ParentSets[ln_element].getParent(iParent)).name())

+ "</GIVEN>\n");

} ls_text.append("<TABLE>\n");

for (int iParent = 0; iParent < gc_ParentSets[ln_element].getValueOfParents(); iParent++)

{ for (int iValue = 0; iValue < gc_Instances.attribute(ln_element).numValues(); iValue++)

{ ls_text.append(gc_Distributions[ln_element][iParent].getProbability(iValue));

ls_text.append(' ');

} ls_text.append('\n');

} ls_text.append("</TABLE>\n"); ls_text.append("</DEFINITION>\n");

} ls_text.append("</NETWORK>\n");

ls_text.append("</BIF>\n");

return ls_text.toString(); } // toXMLBIF03

//Método para verificar si se puede realizar la acción deshacer public boolean canUndo()

{ return gn_current_edit_action >= 0;

} //Método para verificar si se puede realizar la acción rehacer

public boolean canRedo()

{ return gn_current_edit_action < gc_UndoStack.size() - 1;

} //Método para verificar si se produjeron cambios en el editor

public boolean isChanged()

{ return gn_current_edit_action != gn_saved_pointer;

} //Método para verificar si se grabo

public void isSaved()

{ gn_saved_pointer = gn_current_edit_action;

} //Método para obtener la última acción

public String lastActionMsg()

{ if (gc_UndoStack.size() == 0) { return ""; }

61

return ((UndoAction) gc_UndoStack.lastElement()).getRedoMsg();

} // lastActionMsg

//Método para realizar la acción deshacer

public String undo()

{ if (!canUndo()) { return ""; }

UndoAction lc_UndoAction = (UndoAction) gc_UndoStack.elementAt(gn_current_edit_action); gb_needs_undo_action = false;

lc_UndoAction.undo();

gb_needs_undo_action = true; gn_current_edit_action--;

return lc_UndoAction.getUndoMsg(); } // undo

//Método para realizar la acción rehacer public String redo()

{ if (!canRedo()) { return ""; }

gn_current_edit_action++;

UndoAction lc_UndoAction = (UndoAction) gc_UndoStack.elementAt(gn_current_edit_action); gb_needs_undo_action = false;

lc_UndoAction.redo();

gb_needs_undo_action = true;

return lc_UndoAction.getRedoMsg();

} // redo

//Método para realizar la acción rehacer

void addUndoAction(UndoAction pc_Action)

{ int ln_action = gc_UndoStack.size() - 1;

while (ln_action > gn_current_edit_action)

gc_UndoStack.removeElementAt(ln_action--);

if (gn_saved_pointer > gn_current_edit_action)

gn_saved_pointer = -2;

gc_UndoStack.addElement(pc_Action);

gn_current_edit_action++; } // addUndoAction

public void clearUndoStack()

{ gc_UndoStack = new NeuroidVector();

gn_current_edit_action = -1; gn_saved_pointer = -1;

} // clearUndoStack

class UndoAction implements Serializable


public void undo() { }

public void redo() { }

public String getUndoMsg() { return getMsg(); }

public String getRedoMsg() { return getMsg(); }

public String getMsg()

{ String ls_str = toString();

int ln_start = ls_str.indexOf('$');

int ln_end = ls_str.indexOf('@'); StringBuffer ls_buffer = new StringBuffer();

for(int i= ln_start + 1; i < ln_end; i++)

{

62

char c = ls_str.charAt(i);

if (Character.isUpperCase(c))

ls_buffer.append(' ');

ls_buffer.append(ls_str.charAt(i));

} return ls_buffer.toString();

} // getMsg

} // class UndoAction

class AddInputBlockAction extends UndoAction


String ls_name; int ls_posX;

int ls_posY;

int ls_param; double lf_ini;

double lf_end;

AddInputBlockAction(String ps_name, int pn_parameter, double pf_ini_value, double pf_end_value, int pn_posX, int

pn_posY)

{ ls_name = ps_name;

ls_param = pn_parameter;

lf_ini = pf_ini_value; lf_end = pf_end_value;

ls_posX = pn_posX;

ls_posY = pn_posY;

}

public void undo()

{

try { deleteInputBlock(getNrOfInputBlocks() - 1); } catch (Exception e)


} // undo

public void redo()

{

try { addInputBlock(ls_name, ls_param, lf_ini, lf_end, ls_posX, ls_posY); }

catch (Exception e) { e.printStackTrace(); }

} // redo

} // class AddInputBlockAction

class DeleteInputBlockAction extends UndoAction


int ln_target_block;

int ln_posX;

int ln_posY;

Attribute lc_Attrib;

Estimator[] lc_CPT; ParentSet lc_ParentSet;

NeuroidVector lc_DeleteAxonActions;

DeleteInputBlockAction(int pn_target_block)

{ ln_target_block = pn_target_block; lc_Attrib = gc_Instances.attribute(pn_target_block);

try { SerializedObject so = new SerializedObject(gc_Distributions[pn_target_block]);

lc_CPT = (Estimator[]) so.getObject();

so = new SerializedObject(gc_ParentSets[pn_target_block]);

lc_ParentSet = (ParentSet) so.getObject();

}

63


lc_DeleteAxonActions = new NeuroidVector();

for (int iBlock = 0; iBlock < getNrOfInputBlocks(); iBlock++)

{ if (gc_ParentSets[iBlock].contains(pn_target_block))

lc_DeleteAxonActions.addElement(new DeleteAxonAction(pn_target_block, iBlock));

} ln_posX = getPositionX(ln_target_block);

ln_posY = getPositionY(ln_target_block);

}

public void undo()

{ try

{ gc_Instances.insertAttributeAt(lc_Attrib, ln_target_block); int ln_atts = gc_Instances.numAttributes();

ParentSet[] lc_ParentSets = new ParentSet[ln_atts]; int ln_X = 0;


{ if (iParentSet == ln_target_block)

{ SerializedObject so = new SerializedObject(lc_ParentSet);

lc_ParentSets[iParentSet] = (ParentSet) so.getObject();

ln_X = 1;

}

else

{ lc_ParentSets[iParentSet] = gc_ParentSets[iParentSet - ln_X];

for (int iParent = 0; iParent < lc_ParentSets[iParentSet].getNrOfParents(); iParent++)

{ int ln_parent = lc_ParentSets[iParentSet].getParent(iParent);

if (ln_parent >= ln_target_block)

lc_ParentSets[iParentSet].SetParent(iParent, ln_parent + 1);

}

}

}



ln_X = 0;

for (int iBlock = 0; iBlock < ln_atts; iBlock++)

{ if (iBlock == ln_target_block)

{ SerializedObject so = new SerializedObject(lc_CPT); lc_Distributions[iBlock] = (Estimator[]) so.getObject();

ln_X = 1;

} else lc_Distributions[iBlock] = gc_Distributions[iBlock - ln_X];

}


for (int i = 0; i < lc_DeleteAxonActions.size(); i++)

{ DeleteAxonAction lc_DelAction = (DeleteAxonAction) lc_DeleteAxonActions.elementAt(i);

lc_DelAction.undo();

}

gc_VectorPosX.insertElementAt(ln_posX, ln_target_block);

gc_VectorPosY.insertElementAt(ln_posY, ln_target_block);

}

64


} // undo

public void redo()

{

try { deleteInputBlock(ln_target_block); }

catch (Exception e)

{ e.printStackTrace(); } } // redo

} // class DeleteInputBlockAction

class AddNeuroideAction extends UndoAction


String ls_name;

int ls_posX; int ls_posY;

int ln_param;

double lf_umbr; double lf_slope;

AddNeuroideAction(String ps_name, int pn_parameters, double pf_umbr, double pf_slope, int pn_posX, int pn_posY)

{ ls_name = ps_name;

ln_param = pn_parameters; lf_umbr = pf_umbr;

lf_slope = pf_slope;

ls_posX = pn_posX; ls_posY = pn_posY;

} public void undo()

{

try { deleteNeuroide(getNrOfNeuroides() - 1); }

catch (Exception e)

{ e.printStackTrace(); } } // undo

public void redo()

{

try { addNeuroide(ls_name, ln_param, lf_umbr, lf_slope, ls_posX, ls_posY); } catch (Exception e)


} // redo } // class AddNeuroideAction

class DeleteNeuroideAction extends UndoAction


int ln_target_neuroide;

int ln_posX; int ln_posY;

Attribute lc_Attrib; Estimator[] lc_CPT;

ParentSet lc_ParentSet;

NeuroidVector lc_deleteAxonActions;

DeleteNeuroideAction(int pn_target_neuroide)

{ ln_target_neuroide = pn_target_neuroide;

lc_Attrib = gc_Instances.attribute(pn_target_neuroide);

try

{ SerializedObject so = new SerializedObject(gc_Distributions[pn_target_neuroide]); lc_CPT = (Estimator[]) so.getObject();

so = new SerializedObject(gc_ParentSets[pn_target_neuroide]); lc_ParentSet = (ParentSet) so.getObject();

65



lc_deleteAxonActions = new NeuroidVector();

for (int iNeuroide = 0; iNeuroide < getNrOfNeuroides(); iNeuroide++)

{ if (gc_ParentSets[iNeuroide].contains(pn_target_neuroide))

lc_deleteAxonActions.addElement(new DeleteAxonAction(pn_target_neuroide, iNeuroide));

}

ln_posX = getPositionX(ln_target_neuroide); ln_posY = getPositionY(ln_target_neuroide);


{

try { gc_Instances.insertAttributeAt(lc_Attrib, ln_target_neuroide);



int ln_X = 0;


{ if (iParentSet == ln_target_neuroide)

{ SerializedObject so = new SerializedObject(lc_ParentSet); lc_ParentSets[iParentSet] = (ParentSet) so.getObject();

ln_X = 1;

} else

{ lc_ParentSets[iParentSet] = gc_ParentSets[iParentSet - ln_X];


{ int ln_parent = lc_ParentSets[iParentSet].getParent(iParent);

if (ln_parent >= ln_target_neuroide)

lc_ParentSets[iParentSet].SetParent(iParent, ln_parent + 1);

} }

} gc_ParentSets = lc_ParentSets;

Estimator[][] lc_Distributions = new Estimator[ln_atts][]; ln_X = 0;

for (int iNeuroide = 0; iNeuroide < ln_atts; iNeuroide++)

{ if (iNeuroide == ln_target_neuroide)

{ SerializedObject so = new SerializedObject(lc_CPT);

lc_Distributions[iNeuroide] = (Estimator[]) so.getObject(); ln_X = 1;

}

else lc_Distributions[iNeuroide] = gc_Distributions[iNeuroide - ln_X];

} gc_Distributions = lc_Distributions;

for (int i = 0; i < lc_deleteAxonActions.size(); i++)

{ DeleteAxonAction lc_DelAction = (DeleteAxonAction) lc_deleteAxonActions.elementAt(i);


}

gc_VectorPosX.insertElementAt(ln_posX, ln_target_neuroide); gc_VectorPosY.insertElementAt(ln_posY, ln_target_neuroide);

66



} // undo

public void redo()

{ try { deleteNeuroide(ln_target_neuroide); }


} // redo

} // class DeleteNeuroideAction

class DeleteSelectionAction extends UndoAction


NeuroidVector lc_Elements; Attribute[] lc_Att;

Estimator[][] lc_CPT;

ParentSet[] lc_ParentSet; NeuroidVector lc_DeleteArcActions;

int[] ln_posX; int[] ln_posY;

public DeleteSelectionAction(NeuroidVector pc_Elements)

{ int ln_neuroides = pc_Elements.size();

lc_Elements = new NeuroidVector();

lc_Att = new Attribute[ln_neuroides];

lc_CPT = new Estimator[ln_neuroides][]; lc_ParentSet = new ParentSet[ln_neuroides];

ln_posX = new int[ln_neuroides];

ln_posY = new int[ln_neuroides]; lc_DeleteArcActions = new NeuroidVector();

for (int i = 0; i < pc_Elements.size(); i++)

{ int ln_target_neuroide = (Integer) pc_Elements.elementAt(i);

lc_Elements.addElement(ln_target_neuroide);

lc_Att[i] = gc_Instances.attribute(ln_target_neuroide);

try { SerializedObject so = new SerializedObject(gc_Distributions[ln_target_neuroide]);

lc_CPT[i] = (Estimator[]) so.getObject();

so = new SerializedObject(gc_ParentSets[ln_target_neuroide]);

lc_ParentSet[i] = (ParentSet) so.getObject();


ln_posX[i] = getPositionX(ln_target_neuroide); ln_posY[i] = getPositionY(ln_target_neuroide);

for (int iElement2 = 0; iElement2 < getNrOfNeuroides(); iElement2++)

{ if (!pc_Elements.contains(iElement2) && gc_ParentSets[iElement2].contains(ln_target_neuroide))

lc_DeleteArcActions.addElement(new DeleteAxonAction(ln_target_neuroide, iElement2));

}

}

}

public void undo()

{ try

{ for (int i = 0; i < lc_Elements.size(); i++)

{ int ln_target_neuroide = (Integer) lc_Elements.elementAt(i);

gc_Instances.insertAttributeAt(lc_Att[i], ln_target_neuroide);

}

67


ParentSet[] lc_ParentSets = new ParentSet[ln_atts]; int[] ln_offset = new int[ln_atts];

for (int iElement = 0; iElement < ln_atts; iElement++) ln_offset[iElement] = iElement;

for (int iElement = lc_Elements.size() - 1; iElement >= 0; iElement--)

{ int ln_target = (Integer) lc_Elements.elementAt(iElement);

for (int i = ln_target; i < ln_atts - 1; i++)

ln_offset[i] = ln_offset[i + 1];

}

int ln_targetElement = 0;


{ if (ln_targetElement < lc_Elements.size() && (Integer) lc_Elements.elementAt(ln_targetElement) == (Integer) iParentSet)

{

SerializedObject so = new SerializedObject(lc_ParentSet[ln_targetElement]);

lc_ParentSets[iParentSet] = (ParentSet) so.getObject(); ln_targetElement++;

}

else { lc_ParentSets[iParentSet] = gc_ParentSets[iParentSet - ln_targetElement];


{ int nParent = lc_ParentSets[iParentSet].getParent(iParent); lc_ParentSets[iParentSet].SetParent(iParent, ln_offset[nParent]);

}

} }



ln_targetElement = 0;

for (int iElement = 0; iElement < ln_atts; iElement++)

{ if (ln_targetElement < lc_Elements.size() && (Integer) lc_Elements.elementAt(ln_targetElement) == (Integer) iElement)

{ SerializedObject so = new SerializedObject(lc_CPT[ln_targetElement]); lc_Distributions[iElement] = (Estimator[]) so.getObject();

ln_targetElement++;

} else lc_Distributions[iElement] = gc_Distributions[iElement - ln_targetElement];

}


for (int i = 0; i < lc_Elements.size(); i++)

{ int ln_target_neuroide = (Integer) lc_Elements.elementAt(i);

gc_VectorPosX.insertElementAt(ln_posX[i], ln_target_neuroide);

gc_VectorPosY.insertElementAt(ln_posY[i], ln_target_neuroide);

}

for (int deletedArc = 0; deletedArc < lc_DeleteArcActions.size(); deletedArc++)

{ DeleteAxonAction lc_DelAction = (DeleteAxonAction) lc_DeleteArcActions.elementAt(deletedArc);


}


} // undo

public void redo()

68

{ try

{ for (int i = lc_Elements.size() - 1; i >= 0; i--)

{ int ln_element = (Integer) lc_Elements.elementAt(i);

deleteNeuroide(ln_element);

}


} // redo

} // class DeleteSelectionAction

class AddAxonAction extends UndoAction


NeuroidVector lc_Children; Estimator[][] lc_CPT;

int ln_parent;

AddAxonAction(int pn_parent, int pn_child)

{ try

{ ln_parent = pn_parent; lc_Children = new NeuroidVector();

lc_Children.addElement(pn_child);

SerializedObject so = new SerializedObject(gc_Distributions[pn_child]);

lc_CPT = new Estimator[1][];

lc_CPT[0] = (Estimator[]) so.getObject();



}

public void undo()

{

try

{ for (int i = 0; i < lc_Children.size(); i++)

{ int ln_child = (Integer) lc_Children.elementAt(i); deleteAxon(ln_parent, ln_child);

SerializedObject so = new SerializedObject(lc_CPT[i]);

gc_Distributions[ln_child] = (Estimator[]) so.getObject();

}


} // undo

public void redo()

{ try

{ for (int i = 0; i < lc_Children.size(); i++)

{ int ln_child = (Integer) lc_Children.elementAt(i);

addAxon(ln_parent, ln_child);

}


} // redo

} // class AddArcAction

class DeleteAxonAction extends UndoAction


int[] ln_parents; int ln_child;

69

int ln_parent; Estimator[] lc_CPT;

DeleteAxonAction(int pn_parent, int pn_child)

{

try

{ ln_child = pn_child;

ln_parent = pn_parent;

ln_parents = new int[getNrOfParents(pn_child)];

for (int iParent = 0; iParent < ln_parents.length; iParent++)

ln_parents[iParent] = getParent(pn_child, iParent);

SerializedObject so = new SerializedObject(gc_Distributions[pn_child]);

lc_CPT = (Estimator[]) so.getObject();



}

public void undo()

{

try

{ SerializedObject so = new SerializedObject(lc_CPT);

gc_Distributions[ln_child] = (Estimator[]) so.getObject();

ParentSet lc_ParentSet = new ParentSet();

for (int i = 0; i < ln_parents.length; i++)

lc_ParentSet.addParent(ln_parents[i], gc_Instances);

gc_ParentSets[ln_child] = lc_ParentSet;



} // undo

public void redo()

{ try { deleteAxon(ln_parent, ln_child); }

catch (Exception e)


} // redo

} // class DeleteAxonAction

class EditInputBlockAction extends UndoAction


int ln_target; String ls_name;

double lf_new_vi; double lf_old_vi;

double lf_new_vf;

double lf_old_vf; double lf_new_pe;

double lf_old_pe;

double lf_new_re; double lf_old_re;

EditInputBlockAction(int pn_target, String ps_name, double ps_old_vi, double ps_new_vi,

double pf_old_vf, double pf_new_vf,

double pf_old_pe, double pf_new_pe, double pf_old_re, double pf_new_re)

{ ln_target = pn_target; ls_name = ps_name;

lf_new_vi = ps_new_vi; lf_old_vi = ps_old_vi;

lf_new_vf = pf_new_vf; lf_old_vf = pf_old_vf;

70

lf_new_pe = pf_new_pe;

lf_old_pe = pf_old_pe;

lf_new_re = pf_new_re;

lf_old_re = pf_old_re;

}

public void undo()

{ editParameterInputBloc(ln_target, ls_name,

lf_old_vi, lf_new_vi,

lf_old_vf, lf_new_vf, lf_old_pe, lf_new_pe,

lf_old_re, lf_new_re);

} // undo

public void redo()

{ editParameterInputBloc(ln_target, ls_name,

lf_new_vi, lf_old_vi,

lf_new_vf, lf_old_vf, lf_new_pe, lf_old_pe,

lf_new_re, lf_old_re);

} // redo } // class EditInputBlockAction

class EditNeuroideAction extends UndoAction


int ln_target;

String ls_new_name;

String ls_old_name; double lf_new_umbr;

double lf_new_slope;

double lf_old_umbr; double lf_old_slope;

EditNeuroideAction(int pn_target, String ps_old_name, String ps_new_name,

double pf_old_umbr, double pf_new_umbr,

double pf_old_slope, double pf_new_slope)

{ ln_target = pn_target;

ls_new_name = ps_new_name; ls_old_name = ps_old_name;

lf_new_umbr = pf_new_umbr;

lf_old_umbr = pf_old_umbr; lf_new_slope= pf_new_slope;

lf_old_slope= pf_old_slope;

}

public void undo()

{ editParameterNeuroide(ln_target, ls_old_name,

lf_old_umbr, lf_new_umbr, lf_old_slope, lf_new_slope);

} // undo

public void redo()

{ editParameterNeuroide(ln_target, ls_new_name, lf_new_umbr, lf_old_umbr,

lf_new_slope, lf_old_slope);

} // redo } // class EditNeuroideAction

class SetPositionAction extends UndoAction


int ln_target;

int ln_posX; int ln_posY;

71

int ln_posX2; int ln_posY2;

SetPositionAction(int pn_target, int pn_posX, int pn_posY)

{ ln_target = pn_target;

ln_posX2 = pn_posX; ln_posY2 = pn_posY;

ln_posX = getPositionX(pn_target);

ln_posY = getPositionY(pn_target);

}

public void undo()

{ setPosition(ln_target, ln_posX, ln_posY);

} // undo

public void redo()

{ setPosition(ln_target, ln_posX2, ln_posY2);

} // redo

public void setUndoPosition(int pn_posX, int pn_posY)

{ ln_posX2 = pn_posX; ln_posY2 = pn_posY;

} // setPosition

} // class SetPositionAction

class SetGroupPositionAction extends UndoAction


NeuroidVector lc_Element;

int ln_posX;

int ln_posY;

SetGroupPositionAction(NeuroidVector pc_element, int pn_posX, int pn_posY)

{ lc_Element = new NeuroidVector(pc_element.size());

for (int i = 0; i < pc_element.size(); i++)

lc_Element.addElement(pc_element.elementAt(i));

ln_posX = pn_posX; ln_posY = pn_posY;


{ for (int i = 0; i < lc_Element.size(); i++)

{ int ln_neuroide = (Integer) lc_Element.elementAt(i); setPosition(ln_neuroide, getPositionX(ln_neuroide) - ln_posX, getPositionY(ln_neuroide) - ln_posY);

} } // undo

public void redo()

{ for (int i = 0; i < lc_Element.size(); i++)

{ int ln_neuroide = (Integer) lc_Element.elementAt(i); setPosition(ln_neuroide, getPositionX(ln_neuroide) + ln_posX, getPositionY(ln_neuroide) + ln_posY);

} } // redo

public void setUndoPosition(int pn_posX, int pn_posY)

{ ln_posX += pn_posX;

ln_posY += pn_posY;

} // setPosition } // class SetGroupPositionAction

class PasteAction extends UndoAction

72


int ln_base; String ls_XML;

PasteAction(String ps_XML, int pn_base)

{ ls_XML = ps_XML;

ln_base = pn_base;

}

public void undo()

{

try

{ int ln_neuroide = getNrOfNeuroides() - 1;

while (ln_neuroide >= ln_base)

{ deleteNeuroide(ln_neuroide);

ln_neuroide--;

}


} // undo

public void redo()

{

try { paste(ls_XML, EXECUTE); }

catch (Exception e)

{ e.printStackTrace(); } } // redo

} // class PasteAction

}

Clase NeuroidNet

/*

* This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version. *

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* * You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

73

package promeinfo.net;

import promeinfo.core.Estimator;

import promeinfo.core.Instances;

public class NeuroidNet


public Estimator[][] gc_Distributions; public Instances gc_Instances;

protected ParentSet[] gc_ParentSets; protected BIFReader gc_otherNeuroidNet = null;

public void initStructure() throws Exception

{ int ln_attribute = 0;

for (int i = 1; i < gc_Instances.numAttributes(); i++)

{ if (ln_attribute == gc_Instances.classIndex()) ln_attribute++;

} //reserva de memoria gc_ParentSets = new ParentSet[gc_Instances.numAttributes()];

for (int iAttribute=0; iAttribute < gc_Instances.numAttributes();iAttribute++) gc_ParentSets[iAttribute] = new ParentSet(gc_Instances.numAttributes());

} // initStructure

public String getBIFHeader()

{ StringBuffer ls_text = new StringBuffer(); ls_text.append("<?xml version=\"1.0\"?>\n");

ls_text.append("\n");

ls_text.append("<!DOCTYPE BIF [\n"); ls_text.append(" <!ELEMENT BIF ( NETWORK )*>\n");

ls_text.append(" <!ATTLIST BIF VERSION CDATA #REQUIRED>\n");

ls_text.append(" <!ELEMENT NETWORK ( NAME, ( PROPERTY | VARIABLE | DEFINITION )* )>\n"); ls_text.append(" <!ELEMENT NAME (#PCDATA)>\n");

ls_text.append(" <!ELEMENT VARIABLE ( NAME, ( OUTCOME | PROPERTY )* ) >\n");

ls_text.append(" <!ATTLIST VARIABLE TYPE (nature|decision|utility) \"nature\">\n");

ls_text.append(" <!ELEMENT OUTCOME (#PCDATA)>\n");

ls_text.append(" <!ELEMENT DEFINITION ( FOR | GIVEN | TABLE | PROPERTY )* >\n");

ls_text.append(" <!ELEMENT FOR (#PCDATA)>\n"); ls_text.append(" <!ELEMENT GIVEN (#PCDATA)>\n");

ls_text.append(" <!ELEMENT TABLE (#PCDATA)>\n");

ls_text.append(" <!ELEMENT PROPERTY (#PCDATA)>\n"); ls_text.append("]>\n");

return ls_text.toString(); } // getBIFHeader

protected String XMLNormalize(String ps_str)

{ StringBuffer ls_str2 = new StringBuffer();

for (int i = 0; i < ps_str.length(); i++)

{ char ls_char = ps_str.charAt(i);

switch (ls_char)

{

case '&' : ls_str2.append("&"); break;

case '\'': ls_str2.append("'"); break; case '\"': ls_str2.append("""); break;

case '<' : ls_str2.append("<"); break;

case '>' : ls_str2.append(">"); break;

default: ls_str2.append(ls_char);

} } return ls_str2.toString();

} // XMLNormalize

74

public int getNrOfInputBlocks()

{

return gc_Instances.numAttributes();

}

public int getNrOfNeuroides()

{ return gc_Instances.numAttributes();

} public int getNrOfElements()

{ return gc_Instances.numAttributes();

}

public String getTargetName(int pn_target)

{ return gc_Instances.attribute(pn_target).name();

}

public int getCardinality(int pn_target)

{ return gc_Instances.attribute(pn_target).numValues();

} public int getNrOfParents(int pn_element)

{ return gc_ParentSets[pn_element].getNrOfParents();

}

public int getParent(int pn_element, int pn_parent)

{ return gc_ParentSets[pn_element].getParent(pn_parent);

}

public ParentSet[] getParentSets()

{ return gc_ParentSets;

} public Estimator[][] getDistributions()

{ return gc_Distributions;

}

public ParentSet getParentSet(int pn_node)

{ return gc_ParentSets[pn_node];

} }

Clase BIFReader

/*

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* * This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software

* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.


75

import promeinfo.core.Attribute;

import promeinfo.core.DiscreteEstimatorElement;

import promeinfo.core.Estimator; import promeinfo.core.NeuroidVector;


import java.io.File;

import java.util.StringTokenizer;

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.CharacterData; import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node; import org.w3c.dom.NodeList;

public class BIFReader extends NeuroidNet


protected int [] gn_positionX;

protected int [] gn_positionY;

public String gs_file;

//Método para procesar el archivo que va a cargar public BIFReader processFile(String ps_file) throws Exception

{ gs_file = ps_file; DocumentBuilderFactory lc_Factory = DocumentBuilderFactory.newInstance();

lc_Factory.setValidating(true);

Document lc_Doc = lc_Factory.newDocumentBuilder().parse(new File(ps_file)); lc_Doc.normalize();

buildInstances(lc_Doc, ps_file); buildStructure(lc_Doc);

return this; } // processFile

//Método que construye la estructura en base al archivo a cargar

void buildStructure(Document pc_Doc) throws Exception

{ gc_Distributions = new Estimator[gc_Instances.numAttributes()][];

for (int iElement = 0; iElement < gc_Instances.numAttributes(); iElement++)

{ String ls_name = gc_Instances.attribute(iElement).name(); Element lc_Definition = getDefinition(pc_Doc, ls_name);

NeuroidVector lc_NeuroideList = getParentNeuroides(lc_Definition);

for (int iParent = 0; iParent < lc_NeuroideList.size(); iParent++)

{ Node lc_ParentName = ((Node) lc_NeuroideList.elementAt(iParent)).getFirstChild();

String ls_parentName = ((CharacterData) (lc_ParentName)).getData(); int ln_parent = getNeuroide(ls_parentName);

gc_ParentSets[iElement].addParent(ln_parent, gc_Instances);

}

int ln_value = gc_ParentSets[iElement].getValueOfParents();

int ln_values = gc_Instances.attribute(iElement).numValues(); gc_Distributions[iElement] = new Estimator[ln_value];

for (int i = 0; i < ln_value; i++) gc_Distributions[iElement][i] = new DiscreteEstimatorElement(ln_values, 0.0f);

String ls_table = getTable(lc_Definition);

StringTokenizer st = new StringTokenizer(ls_table.toString());

for (int i = 0; i < ln_value; i++)

{ DiscreteEstimatorElement d = (DiscreteEstimatorElement) gc_Distributions[iElement][i];

76


{

String ls_weight = st.nextToken();

d.addValue(iValue, new Double(ls_weight).doubleValue());

}

}

} } // buildStructure

//Método que captura el contenido de un elemento public String getContent(Element pc_Element)

{ NodeList lc_List; Node lc_Item;

int i;

String ls_result;

ls_result = "";

lc_List = pc_Element.getChildNodes();

for (i = 0; i < lc_List.getLength(); i++)

{ lc_Item = lc_List.item(i);

if (lc_Item.getNodeType() == Node.TEXT_NODE) ls_result += "\n" + lc_Item.getNodeValue();

} return ls_result;

}

void buildInstances(Document pc_Doc, String ps_name) throws Exception

{ NodeList lc_NodeList;

lc_NodeList = selectAllNames(pc_Doc);

if (lc_NodeList.getLength() > 0) ps_name = ((CharacterData) (lc_NodeList.item(0).getFirstChild())).getData();

lc_NodeList = selectAllVariables(pc_Doc); int ln_nodes = lc_NodeList.getLength();

NeuroidVector lc_AttInfo = new NeuroidVector(ln_nodes);

gn_positionX = new int[lc_NodeList.getLength()];

gn_positionY = new int[lc_NodeList.getLength()];

for (int i = 0; i < lc_NodeList.getLength(); i++)

{ NeuroidVector lc_Valueslist;

lc_Valueslist = selectOutCome(lc_NodeList.item(i));

int ln_values = lc_Valueslist.size();

NeuroidVector lc_NomStrings = new NeuroidVector(ln_values + 1);


{ Node lc_Neuroide = ((Node) lc_Valueslist.elementAt(iValue)).getFirstChild(); String ls_value = ((CharacterData) (lc_Neuroide)).getData();

if (ls_value == null) ls_value = "Value" + (iValue + 1);

lc_NomStrings.addElement(ls_value);

}

NeuroidVector lc_NeuroideList2;

lc_NeuroideList2 = selectName(lc_NodeList.item(i));

if (lc_NeuroideList2.size() == 0)

throw new Exception ("No name specified for variable");

String ls_neuroide_name = ((CharacterData) (((Node) lc_NeuroideList2.elementAt(0)).getFirstChild())).getData();

77

Attribute lc_Att = new Attribute(ls_neuroide_name, lc_NomStrings);

lc_AttInfo.addElement(lc_Att);

lc_Valueslist = selectProperty(lc_NodeList.item(i));

ln_values = lc_Valueslist.size();


{ Node lc_Neuroide = ((Node)lc_Valueslist.elementAt(iValue)).getFirstChild(); String ls_value = ((CharacterData) (lc_Neuroide)).getData();

if (ls_value.startsWith("position"))

{ int i0 = ls_value.indexOf('(');

int i1 = ls_value.indexOf(','); int i2 = ls_value.indexOf(')');

String sX = ls_value.substring(i0 + 1, i1).trim();

String sY = ls_value.substring(i1 + 1, i2).trim();

try

{ gn_positionX[i] = (int) Integer.parseInt(sX);

gn_positionY[i] = (int) Integer.parseInt(sY);

} catch (NumberFormatException e)

{ System.err.println("Wrong number format in position :(" + sX + "," + sY +")"); gn_positionX[i] = 0;

gn_positionY[i] = 0;

} }

}

} gc_Instances = new Instances(ps_name, lc_AttInfo, 100);

gc_Instances.setClassIndex(ln_nodes - 1);

initStructure();

} // buildInstances

NodeList selectAllNames(Document pc_Doc) throws Exception

{ NodeList lc_Nodelist = pc_Doc.getElementsByTagName("NAME");

return lc_Nodelist;

} // selectAllNames

NodeList selectAllVariables(Document pc_Doc) throws Exception

{ NodeList lc_Nodelist = pc_Doc.getElementsByTagName("VARIABLE"); return lc_Nodelist;

} // selectAllVariables

Element getDefinition(Document pc_Doc, String ps_name) throws Exception

{ NodeList lc_Nodelist = pc_Doc.getElementsByTagName("DEFINITION");

for (int i = 0; i < lc_Nodelist.getLength(); i++)

{ Node lc_Node = lc_Nodelist.item(i);

NeuroidVector lc_List = selectElements(lc_Node, "FOR");

if (lc_List.size() > 0)

{ Node lc_forNode = (Node) lc_List.elementAt(0);

if (getContent((Element) lc_forNode).trim().equals(ps_name)) return (Element) lc_Node;

}

} throw new Exception("Could not find definition for ((" + ps_name + "))");

} // getDefinition

NeuroidVector getParentNeuroides(Node pc_Definition) throws Exception

{ NeuroidVector lc_Nodelist = selectElements(pc_Definition, "GIVEN"); return lc_Nodelist;

78

} // getParentNodes

String getTable(Node pc_Definition) throws Exception

{ NeuroidVector lc_Nodelist = selectElements(pc_Definition, "TABLE");

String ls_table = getContent((Element) lc_Nodelist.elementAt(0));

ls_table = ls_table.replaceAll("\\n"," "); return ls_table;

} // getTable

NeuroidVector selectOutCome(Node pc_Item) throws Exception

{ NeuroidVector lc_Nodelist = selectElements(pc_Item, "OUTCOME"); return lc_Nodelist;

} // selectOutCome

NeuroidVector selectName(Node pc_Item) throws Exception

{ NeuroidVector lc_Nodelist = selectElements(pc_Item, "NAME"); return lc_Nodelist;

} // selectName

NeuroidVector selectProperty(Node pc_Item) throws Exception

{ NeuroidVector lc_Nodelist = selectElements(pc_Item, "PROPERTY"); return lc_Nodelist;

} // selectProperty

NeuroidVector selectElements(Node pc_Item, String ps_element) throws Exception

{ NodeList lc_Children = pc_Item.getChildNodes(); NeuroidVector lc_Nodelist = new NeuroidVector();

for (int i = 0; i < lc_Children.getLength(); i++)

{ Node lc_Node = lc_Children.item(i);

if ((lc_Node.getNodeType() == Node.ELEMENT_NODE) && lc_Node.getNodeName().equals(ps_element))

lc_Nodelist.addElement(lc_Node);

}

return lc_Nodelist;

} // selectElements

//Método que me retorna el id del neuroide

public int getNeuroide(String ps_neuroide_name) throws Exception

{ int ln_neuroide = 0;

while (ln_neuroide < gc_Instances.numAttributes())

{ if (gc_Instances.attribute(ln_neuroide).name().equals(ps_neuroide_name)) return ln_neuroide;

ln_neuroide++;

} throw new Exception("Could not find node [[" + ps_neuroide_name + "]]");

} // getNeuroide

//Método constructor

public BIFReader() { }

} // class BIFReader

Clase ParentSet




79

* * This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software

* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.



import java.io.Serializable;

public class ParentSet implements Serializable


private int[] gn_parents;

private int gn_NrOfParents = 0; private int gn_ValueOfParents = 1;

public ParentSet()

{ gn_parents = new int[10];

gn_NrOfParents = 0; gn_ValueOfParents = 1;

} // ParentSet

public ParentSet(int pn_maxNrOfParents)

{ gn_parents = new int[pn_maxNrOfParents]; gn_NrOfParents = 0;

gn_ValueOfParents = 1;

} // ParentSet

public int getParent(int pn_parent)

{ return gn_parents[pn_parent];

}

public void SetParent(int pn_parent, int pn_element)

{ gn_parents[pn_parent] = pn_element; } // SetParent

public int[] getParents()

{ return gn_parents;

}

public int getNrOfParents()

{ return gn_NrOfParents;

}

public boolean contains(int pn_element)

{ for (int iParent = 0; iParent < gn_NrOfParents; iParent++)

{ if (gn_parents[iParent] == pn_element)

return true;

}

return false; }

public int getValueOfParents()

{ return gn_ValueOfParents;

}

public void addParent(int pn_parent, Instances pc_Instances)

{ if (gn_NrOfParents == gn_parents.length)

80

{ int[] ln_parents = new int[2 * gn_parents.length];

for (int i = 0; i < gn_NrOfParents; i++) ln_parents[i] = gn_parents[i];

gn_parents = ln_parents;

}

gn_parents[gn_NrOfParents] = pn_parent; gn_NrOfParents++;

gn_ValueOfParents *= pc_Instances.attribute(pn_parent).numValues();

} // AddParent

public int deleteParent(int pn_parent, Instances pc_Instances)

{ int ln_parent = 0;

while ((gn_parents[ln_parent] != pn_parent) && (ln_parent < gn_NrOfParents)) {

ln_parent++;

}

int ln_parent2 = -1;

if (ln_parent < gn_NrOfParents)

ln_parent2 = ln_parent;

if (ln_parent < gn_NrOfParents)

{ while (ln_parent < gn_NrOfParents - 1)

{ gn_parents[ln_parent] = gn_parents[ln_parent + 1];

ln_parent++;

}

gn_NrOfParents--; gn_ValueOfParents /= pc_Instances.attribute(pn_parent).numValues();

} return ln_parent2; } // DeleteParent

} // class ParentSet


FACULTAD DE MATEMÁTICAS Y FÍSICAS


COMPUTACIONALES



MANUAL DE USUARIO



AUTOR:


TUTOR:



2015

II

ÍNDICE GENERAL

ÍNDICE GENERAL ........................................................................................ II

ÍNDICE DE TABLAS .................................................................................... III

ÍNDICE DE FIGURAS ................................................................................... IV

1.1 INTRODUCCIÓN. ................................................................................... 1

1.2 DESCRIPCIÓN DE PANTALLA ............................................................. 1

1.3 DESCRIPCIÓN DE LA BARRA DE MENÚS ......................................... 3

1.4 DESCRIPCIÓN DE BARRA DE HERRAMIENTAS ............................... 8

1.5 MENSAJES DE LA APLICACIÓN ....................................................... 27

III

ÍNDICE DE TABLAS

Tabla 1: Pantalla de inicio ........................................................................................ 2

Tabla 2: Menú File ..................................................................................................... 3

Tabla 3: Menú Edit .................................................................................................... 4

Tabla 4: Menú View .................................................................................................. 5

Tabla 5: Menú Windows ........................................................................................... 6

Tabla 6: Menú Help ................................................................................................... 7

Tabla 7: Toolbar ......................................................................................................... 8

Tabla 8: Opción New ................................................................................................ 9

Tabla 9: Submenú del área de edición ................................................................ 10

Tabla 10: Opción Add Input Block ........................................................................ 11

Tabla 11: Submenú del bloque de entrada ......................................................... 12

Tabla 12: Opción Add Neuroide ............................................................................ 13

Tabla 13: Submenú del neuroide .......................................................................... 14

Tabla 14: Creación del axón .................................................................................. 15

Tabla 15: Opción Undo ........................................................................................... 16

Tabla 16: Opción Redo ........................................................................................... 17

Tabla 17: Opción Zoom in ...................................................................................... 18

Tabla 18: Opción Zoom Out .................................................................................. 19

Tabla 19: Opción Save As ..................................................................................... 20

Tabla 20: Opción Save ........................................................................................... 21

Tabla 21: Opción Open .......................................................................................... 22

Tabla 22: Lectura de Archivo ................................................................................. 23

Tabla 23: Opción View Toolbar ............................................................................. 24

Tabla 24: Opción View Statusbar ......................................................................... 25

Tabla 25: Opción Select All ................................................................................... 26

IV

ÍNDICE DE FIGURAS

Figura 1: Pantalla de inicio ....................................................................................... 2

Figura 2: Menú File ................................................................................................... 3

Figura 3: Menú Edit ................................................................................................... 4

Figura 4: Menú View ................................................................................................. 5

Figura 5: Menú Windows ......................................................................................... 6

Figura 6: Menú Help ................................................................................................. 7

Figura 7: Opción New ............................................................................................... 9

Figura 8: Submenú del área de edición ............................................................... 10

Figura 9: Opción Add Input Block ......................................................................... 11

Figura 10: Creación de bloque de entrada .......................................................... 12

Figura 11: Submenú del bloque de entrada ........................................................ 12

Figura 12: Opción Add Neuroide .......................................................................... 13

Figura 12: Creación de neuroide .......................................................................... 14

Figura 14: Submenú del neuroide ........................................................................ 14

Figura 15: Ingreso del peso del axón ................................................................... 15

Figura 16: Creación del axón ................................................................................ 15

Figura 17: Opción Undo ......................................................................................... 16

Figura 18: Opción Redo ......................................................................................... 17

Figura 19: Opción Zoom in .................................................................................... 18

Figura 20: Opción Zoom Out ................................................................................. 19

Figura 21: Opción Save As .................................................................................... 20

Figura 22: Opción Save .......................................................................................... 21

Figura 23: Opción Open ......................................................................................... 22

Figura 24: Lectura de archivo ................................................................................ 23

Figura 25: Opción View Toolbar ........................................................................... 24

Figura 26: Opción View Statusbar ........................................................................ 25

Figura 27: Opción Select All .................................................................................. 26

Figura 28: Salir de la aplicación ............................................................................ 27

Figura 29: Mensaje de validación de umbral (Add Neuroide) .......................... 27

Figura 30: Mensaje de validación de pendiente (Add Neuroide)..................... 27

Figura 31: Mensaje del menú Help ....................................................................... 28

Figura 32: Mensaje del menú About .................................................................... 28

1

1.1 Introducción.

La aplicación denominada “Neuroidal Network Editor” es una herramienta de

software que nos ofrece una interfaz de usuario (UI) que nos ayudará a

simular la construcción de redes neuroidales de una manera gráfica de tal

manera que permita identificar cada uno de los elementos que conforman la

red neuroidal.

El presente documento tiene como objetivo detallar la funcionalidad de la UI

del software Neuroidal Network Editor, cuales son todas las opciones que

brinda el software; los pasos que deben seguir los usuarios para un correcto

funcionamiento del software.

1.2 Descripción de Pantalla

A continuación se detalla la funcionalidad de la pantalla principal de la

aplicación.

2

Figura 1: Pantalla de inicio

Fuente: Neuroidal Network Editor

Opción Descripción

Barra de menú Presenta las opciones o herramientas de la aplicación.

Barra de herramientas Permitirá activar ciertas funciones de la aplicación al presionar cualquiera de los iconos.

Área de edición Permitirá crear los objetos gráficos para representar la red neuroidal.

Barra de estado Permitirá visualizar las acciones que se realicen en el editor gráfico.

Característica:

Esta es la pantalla principal al ingresar al sistema, donde el usuario tiene todas las herramientas necesarias para simular la construcción de una red neuroidal.

Tabla 1: Pantalla de inicio


http://es.wikipedia.org/wiki/Aplicaci%C3%B3n_inform%C3%A1tica

3

1.3 Descripción de la Barra de Menús

A continuación se detalla la funcionalidad de las opciones de la barra de

menú que presentamos en nuestra aplicación.

Figura 2: Menú File



New Crea un lienzo nuevo.

Open Localiza los archivos del aplicativo previamente guardados.

Save

Guarda automáticamente la red neuroidal construida. En el caso de ser la primera vez que se va a guardar el archivo se abrirá una ventana de dialogo para asignarle un nombre a nuestro proyecto.

Save as Permite guardar los cambios de nuestro proyecto con la característica de poder cambiarle el nombre.

Exit Salir de la aplicación.

Característica:

El menú File contiene las funciones básicas para administrar nuestro proyecto.

Tabla 2: Menú File


4

Figura 3: Menú Edit



Undo Deshacer la acción más reciente que se haya realizado en el editor.

Redo Rehacer la acción más reciente que se haya realizado en el editor

Select All Permite seleccionar todos los elementos en el editor.

Delete Permite borrar uno o varios objetos seleccionados.

Cut Permite cortar uno o varios objetos seleccionados en el editor.

Copy Permite copiar uno o varios objetos seleccionados.

Paste Permite pegar una o varias veces los objetos previamente cortados o copiados.

Add Input block Agrega un bloque de entrada.

Add Neuroide Agregar un neuroide.

Característica:

El menú Edit contiene las funciones primordiales para el manejo de los gráficos que se construyen en el área de edición.

Tabla 3: Menú Edit


5

Figura 4: Menú View



Zoom in Permitirá aumentar el tamaño de los gráficos que se encuentren en el editor.

Zoom out Permitirá disminuir el tamaño de los gráficos que se encuentren en el editor.

View toolbar Permitirá visualizar o no la barra de herramientas.

View statusbar Permitirá visualizar o no la barra de estado.

Característica:

El menú View agrupa herramientas de visualización de la aplicación. Proporciona opciones relacionadas para mostrar diversos elementos de nuestra aplicación.

Tabla 4: Menú View


6

Figura 5: Menú Windows



Look and Feel Submenú que contiene propiedades y características que le darán una identidad visual única.

Característica:

El menú Windows contiene las opciones para cambiar la perspectiva de la aplicación.

Tabla 5: Menú Windows


7

Figura 6: Menú Help



Help Presenta un mensaje indicando cual es el uso que se le puede dar a la aplicación.

About Este comando muestra información de la aplicación.

Característica:

El menú Help contiene las opciones de ayuda de nuestro aplicativo.

Tabla 6: Menú Help


8

1.4 Descripción de Barra de Herramientas

A continuación se detalla la funcionalidad de los iconos que contiene la barra

de herramientas de la aplicación.


New, botón que permite crear un nuevo documento para editar redes neuroidales.

Save, botón que permite guardar los cambios realizados en el editor.

Open, botón que permite abrir documentos previamente guardados en la aplicación.

Cut, permite cortar uno o varios objetos seleccionados en el editor.

Copy, permite copiar uno o varios objetos seleccionados.

Paste, permite pegar una o varias veces los objetos previamente cortados o copiados.

Undo, deshacer la acción más reciente que se haya realizado en el editor.

Redo, rehacer la acción más reciente que se haya realizado en el editor

Add Input Block, botón que permitirá agregar un bloque de entrada.

Add Neuroide, botón que permitirá agregar un neuroide.

Run Network, botón que permitirá ejecutarla red neuroidal, presentando los resultados en una nueva ventana.

Zoom In, botón que permitirá aumentar el tamaño de los gráficos en el editor.

Zoom Out, botón que permitirá disminuir el tamaño de los gráficos el editor.

Característica:

Barra de herramientas que contiene botones de las funciones primordiales para el manejo de los gráficos que se construyen en el área de edición.

Tabla 7: Toolbar


9

Figura 7: Opción New


Característica:

La opción New (Nuevo) permite crear una área de edición para construir las redes neuroidales. Se puede verificar en la barra de estado que se haya efectuado la acción. Para crear el nuevo lienzo lo puede hacer de la siguiente manera:

1. Haga clic en el icono

2. Haga clic en File > New

3. Utilizando las combinaciones Ctrl + N.

Tabla 8: Opción New


10

Figura 8: Submenú del área de edición


Característica:

Haga clic derecho sobre el área de edición y se presenta la opción para agregar un bloque de entrada o un neuroide. Las opciones indicadas anteriormente también se encuentran en la barra de menú y barra de herramientas las cuales detallarán a continuación.

Tabla 9: Submenú del área de edición


11

Figura 9: Opción Add Input Block


Nombre de Campo Descripción de Campo

Initial Value Campo numérico que indica el valor inicial máximo que alcanzara el neuroide

End Value Campo numérico que indica el valor final mínimo que alcanzara el neuroide

Periodo Campo numérico que indica el periodo del neuroide

Retardo Campo numérico que indica el retraso de tiempo que tendrá el neuroide.

Característica:

Pantalla para ingresar los parámetros para crear un bloque de entrada. Para realizar la acción de Add Input Block (Agregar bloque de entrada), se lo puede hacer de las siguientes maneras:


5. Haga clic en Edit > Add Input Block

6. Haga clic derecho sobre el área de edición y seleccione la opción Add

Input Block (Ver Figura 7).

Tabla 10: Opción Add Input Block


12

Figura 10: Creación de bloque de entrada


Figura 11: Submenú del bloque de entrada


Opción Descripción de Opción

Edit Parameters Submenú que permitirá editar los parámetros ingresados cuando se creó el bloque de entrada

Delete Input Block Submenú que permitirá borrar el gráfico del bloque de entrada.

Característica:

Submenú que se presenta haciendo clic derecho sobre el gráfico del bloque de entrada.

Tabla 11: Submenú del bloque de entrada


13

Figura 12: Opción Add Neuroide



Name Campo alfanumérico que sirve para asignarle un nombre al neuroide

Umbral Campo numérico que comprende números decimales entre 0–1.

Slope Campo numérico que sirve para indicar que el neuroide este activo.

Característica:

Pantalla para ingresar los parámetros para crear un neuroide. Para realizar la acción de Add Neuroide (Agregar Neuroide), se lo puede hacer de las siguientes maneras:


2. Haga clic en Edit > Add Neuroide

3. Haga clic derecho sobre el área de edición y seleccione la opción Add

Neuroide (Ver Figura 7).

Tabla 12: Opción Add Neuroide


14

Figura 13: Creación de neuroide


Figura 14: Submenú del neuroide



Edit Parameters Submenú que permitirá editar los parámetros ingresados al momento de crear el neuroide

Delete Neuroide Submenú que permitirá borrar el gráfico del neuroide.

Add Axon Agrega el enlace entre dos elementos.

Delete Axon Elimina el enlace entre elementos.

Delete Child Elimina el enlace del elemento que está considerado como nodo hijo.

Característica:

Submenú que se presenta haciendo clic derecho sobre el gráfico del neuroide.

Tabla 13: Submenú del neuroide


15

Figura 15: Ingreso del peso del axón


Figura 16: Creación del axón


Característica:

La opción para ingresar el peso de un axón (enlace) se encuentra en el submenú de un neuroide (Figura 13). Los enlaces se los puede realizar entre un neuroide y un bloque de entrada o entre dos neuroides y el valor del axón debe ser un valor numérico.

Tabla 14: Creación del axón


16

Figura 17: Opción Undo


Característica:

La opción Undo le permite deshacer la última acción realizada en el área de edición. Se puede verificar en la barra de estado que se haya efectuado la acción. Para realizar esta acción se lo puede hacer de las siguientes maneras:


2. Haga clic en Edit > Undo

3. Utilizando las combinaciones Ctrl + Z

Tabla 15: Opción Undo


17

Figura 18: Opción Redo


Característica:

La opción Redo le permite rehacer la última acción realizada en el área de edición. Se puede verificar en la barra de estado que se haya efectuado la acción. Para realizar esta acción se lo puede hacer de las siguientes maneras:


2. Haga clic en Edit > Redo

3. Utilizando las combinaciones Ctrl + Y

Tabla 16: Opción Redo


18

Figura 19: Opción Zoom in


Característica:

La opción Zomm in le permite aumentar el tamaño de los elementos que se encuentran en el área de edición. Se puede verificar en la barra de estado que se haya efectuado la acción. Para realizar esta acción se lo puede hacer de las siguientes maneras:


2. Haga clic en View > Zoom In

Tabla 17: Opción Zoom in


19

Figura 20: Opción Zoom Out


Característica:

La opción Zoom Out le permite disminuir el tamaño de los elementos que se encuentran en el área de edición. Se puede verificar en la barra de estado que se haya efectuado la acción. Para realizar esta acción se lo puede hacer de las siguientes maneras:


2. Haga clic en View > Zoom Out

Tabla 18: Opción Zoom Out


20

Figura 21: Opción Save As



File Name Campo alfanumérico para asignar el nombre de cómo se guardará nuestro proyecto.

Característica:

La opción Save As (guardar como) le permitirá guardar su proyecto con la característica que puede elegir la ubicación en donde quiera guardarlo. Para realizar esta acción se lo puede hacer de las siguientes maneras:

4. Haga clic en el icono (En caso de ser la primera vez que se guarda)

5. Haga clic en File > Save As

Tabla 19: Opción Save As


21

Figura 22: Opción Save


Característica:

Esta opción le permitirá guardar automáticamente su proyecto. Si es la primera vez que se va a realizar la acción de guardar se abre la ventana de Save As (Ver Figura 16). Para verificar que se haya guardado correctamente el proyecto, se puede observar en la barra de estado una actualización que indica la acción que se ha realizado y la ruta donde se encuentra el proyecto con su respectivo nombre. Para realizar la acción de Save (guardar) se lo puede hacer de tres maneras:


7. Haga clic en File > Save

8. Utilizando las combinaciones Ctrl + S

Tabla 20: Opción Save


22

Figura 23: Opción Open


Característica:

Esta opción le permitirá abrir proyectos que haya guardado previamente. Para realizar la acción de Open (abrir) se lo puede hacer de tres maneras:


4. Haga clic en File > Open

5. Utilizando las combinaciones Ctrl + O

Tabla 21: Opción Open


23

Figura 24: Lectura de archivo


Característica:

Después de ejecutar la acción de Open (Abrir), si el archivo que se seleccionó es correcto, en el área de edición se cargan las imágenes del proyecto guardado anteriormente (Ver Figura 17). Podemos verificar la lectura del archivo por medio de la actualización en la barra de estado la cual me indica la acción que se ha realizado y la ruta de donde se está leyendo el archivo con su respectivo nombre.

Tabla 22: Lectura de Archivo


24

Figura 25: Opción View Toolbar


Característica:

La opción View Toolbar le permite habilitar o deshabilitar la barra de herramientas. Para realizar esta acción se la puede hacer de la siguiente manera:

1. Haga clic en View > View toolbar

Tabla 23: Opción View Toolbar


25

Figura 26: Opción View Statusbar


Característica:

La opción View Statusbar le permite habilitar o deshabilitar la barra de estados. Para realizar esta acción se la puede hacer de la siguiente manera:

1. Haga clic en View > View Statusbar

Tabla 24: Opción View Statusbar


26

Figura 27: Opción Select All


Característica:

La opción Select All le permite seleccionar todos los elementos que se encuentran en el área de edición. Para realizar esta acción se la puede hacer de las siguientes maneras:

2. Haga clic en Edit > Select All

3. Utilizando las combinaciones Ctrl + A

Tabla 25: Opción Select All


27

1.5 Mensajes de la aplicación

A continuación se detallan los mensajes que se presentan la aplicación

desarrollada.

Figura 28: Salir de la aplicación


En el menú FILE cuando el usuario selecciona la opción Quit y se han

producido algún cambio en el editor se presenta este mensaje para que el

usuario tenga la opción de guardar la red neuroidal construida.

Figura 29: Mensaje de validación de umbral (Add Neuroide)


Mensaje que se presenta cuando el usuario escoge la opción para agregar

un neuroide e ingresa en el campo umbral un número que este fuera de los

rangos entre 0 y 1.

Figura 30: Mensaje de validación de pendiente (Add Neuroide)


28

Mensaje que se presenta cuando el usuario escoge la opción para agregar

un neuroide e ingresa en el campo Slope (pendiente) un número que no sea

mayor que 1.

Figura 31: Mensaje del menú Help


En el menú HELP cuando el usuario selecciona la opción Help (Ayuda), se

presenta este mensaje indicando brevemente que hace nuestra aplicación.

Figura 32: Mensaje del menú About


En el menú HELP cuando el usuario selecciona la opción About (Acerca), se

presenta este mensaje indicando información básica de nuestra aplicación.

universidad de guayaquil -...

Documents