UNIVERSIDAD DE GUAYAQUIL -...
Transcript of 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
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
SILVA MUÑOZ ANDRÉS MIGUEL
TUTOR: ING. EDUARDO ALVARADO
GUAYAQUIL – ECUADOR
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:
CONTACTO DE LA INSTITUCIÓN:
UNIVERSIDAD DE GUAYAQUIL
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
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 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
Tutor: Ing. Eduardo Alvarado
Guayaquil, Mayo de 2015
IX
UNIVERSIDAD DE GUAYAQUIL
FACULTAD DE CIENCIAS MATEMÁTICAS Y FÍSICAS
CARRERA DE INGENIERÍA EN SISTEMAS
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
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
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
Tutor: Ing. Eduardo Alvarado
XV
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
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
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
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.
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
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.
Fuente: Tesis doctoral de Erick Argüello.
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.
Fuente: Tesis doctoral de Erick Argüello.
25
Figura 5: Esquema del Neuroide.
Fuente: Tesis doctoral de Erick Argüello.
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.
Fuente: Sitio web de National Instrumentas (NI)
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
Fuente: Sitio web de National Instrumentas (NI)
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.
Fuente: Sitio web de National Instrumentas (NI)
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.
Fuente: Sitio web de Mathworks (MathWorks)
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.
Fuente: Sitio web de Mathworks (MathWorks)
Figura 15: Visualización de gráficos en MATLAB.
Fuente: Sitio web de Mathworks (MathWorks)
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
Autor: Andrés Silva Muñoz
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.
Autor: Andrés Silva Muñoz
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
software propio para simular la creación de redes neuroidales?
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.
Autor: Andrés Silva Muñoz
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.
Autor: Andrés Silva Muñoz
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
software propio para simular la creación de redes neuroidales?
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
software propio para simular la creación de redes neuroidales?
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
UNIVERSIDAD DE GUAYAQUIL
FACULTAD DE MATEMÁTICAS Y FÍSICAS
CARRERA DE INGENIERÍA EN SISTEMAS
COMPUTACIONALES
“DESARROLLO DE UN SOFTWARE PARA LA
CONSTRUCCIÓN DE REDES NEUROIDALES”
MANUAL DE TÉCNICO
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
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
Fuente:Andrés Silva Muñoz.
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.
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") )
{ UIManager.setLookAndFeel
("com.sun.java.swing.plaf.motif.MotifLookAndFeel" );
SwingUtilities.
updateComponentTreeUI(SwingUtilities.getRoot(MainFrame ) );
} else if( rb.isSelected() &&
rb.getText().equals("Metal") )
{ UIManager.setLookAndFeel
("javax.swing.plaf.metal.MetalLookAndFeel" );
SwingUtilities.
12
updateComponentTreeUI(SwingUtilities.getRoot(MainFrame ) );
}
else if( rb.isSelected() &&
rb.getText().equals("Nimbus") )
{ UIManager.setLookAndFeel
("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel" );
SwingUtilities.
updateComponentTreeUI(SwingUtilities.getRoot(MainFrame ) );
}
else if(rb.isSelected()&&rb.getText().equals("Windows Classic"))
{ UIManager.setLookAndFeel
("com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel");
SwingUtilities.
updateComponentTreeUI(SwingUtilities.getRoot(MainFrame ) );
}
} 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
{ private static final long serialVersionUID = 1L;
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
{ private static final long serialVersionUID = 1L;
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
{ private static final long serialVersionUID = 1L;
public ActionLoad()
{ super("Open", "Open Graph", "open", "ctrl O");
}
public void actionPerformed(ActionEvent ae)
{ //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
{ private static final long serialVersionUID = 1L;
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
{ private static final long serialVersionUID = 1L;
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
{ private static final long serialVersionUID = 1L;
public ActionQuit()
{ super("Exit", "Exit Program", "exit", "");
}
public void actionPerformed(ActionEvent ae)
{ //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
{ private static final long serialVersionUID = 1L;
public ActionUndo()
{ super("Undo", "Undo", "undo", "ctrl Z");
setEnabled(false);
}
public boolean isEnabled()
{ return gc_EditNetwork.canUndo();
}
public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
public ActionRedo()
{ super("Redo", "Redo", "redo", "ctrl Y");
setEnabled(false);
}
public boolean isEnabled()
{ return gc_EditNetwork.canRedo();
} public void actionPerformed(ActionEvent ae)
{ String ls_msg = gc_EditNetwork.redo();
//Actualizacion de la acción en la barra de estado statusBar.setText("Redo action performed: " + ls_msg);
lc_Selection.clear();
updateStatus();
repaint();
}
} // ActionRedo
//Clase que realiza la acción de seleccionar todos los elementos (Select All)
class ActionSelectAll extends MyAction
{ private static final long serialVersionUID = 1L;
public ActionSelectAll()
{ super("Select All", "Select All", "selectall", "ctrl A");
}
19
public void actionPerformed(ActionEvent ae)
{
lc_Selection.selectAll();
repaint();
} } // class ActionSelectAll
//Clase que realiza la acción de eliminar algun elemento (Delete)
class ActionDelete extends MyAction
{ private static final long serialVersionUID = 1L;
public ActionDelete()
{ super("Delete", "Delete", "delneuroide", "DELETE");
}
public void actionPerformed(ActionEvent ae)
{ if (lc_Selection.getSelected().size() > 0)
{ gc_EditNetwork.deleteSelection(lc_Selection.getSelected()); statusBar.setText(gc_EditNetwork.lastActionMsg());
lc_Selection.clear();
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
{ private static final long serialVersionUID = 1L;
public ActionCut()
{ super("Cut", "Cut", "cut", "ctrl X");
}
public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
public ActionPaste()
{ super("Paste", "Paste", "paste", "ctrl V");
} public void actionPerformed(ActionEvent ae)
{
try { gc_EditNetwork.paste(lc_Clipboard.getText());
updateStatus(); statusBar.setText(gc_EditNetwork.lastActionMsg());
} catch (Exception e) { e.printStackTrace(); }
}
public boolean isEnabled()
{ 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
{ private static final long serialVersionUID = 1L;
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()
{ public void keyTyped(KeyEvent e)
{ char c = e.getKeyChar();
if (((c<'0')||(c>'9'))&&(c!=KeyEvent.VK_BACK_SPACE)&&(c!='.'))
e.consume();
if (c=='.'&&txtValorFinal.getText().contains("."))
e.consume();
} }); txtPeriodo.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 == '.' && txtPeriodo.getText().contains("."))
e.consume();
} });
txtRetardo.addKeyListener(new KeyAdapter()
{ public void keyTyped(KeyEvent e)
{ char c = e.getKeyChar();
if (((c<'0')||(c>'9'))&&(c!=KeyEvent.VK_BACK_SPACE)&&(c!='.'))
22
e.consume();
if (c == '.' && txtRetardo.getText().contains("."))
e.consume();
}
}); JButton jBtOk;
jBtOk = new JButton("Ok");
jBtOk.setMnemonic('O');
jBtOk.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ 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);
} catch (Exception e)
{ e.printStackTrace();
} repaint();
dialog.setVisible(false);
}
}); JButton jBtCancel;
jBtCancel = new JButton("Cancel");
jBtCancel.setMnemonic('C');
jBtCancel.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ 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.anchor = GridBagConstraints.NORTHWEST;
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jLbValorInicio, gridBC); gridBC.gridwidth = GridBagConstraints.REMAINDER;
lc_container.add(txtValorInicio, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jLbValorFinal, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtValorFinal, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jLbPeriodo, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER;
lc_container.add(txtPeriodo, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
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);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
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();
}
public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
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_posX = Integer.MAX_VALUE;
int ln_posY;
public void addNeuroide(int pn_posX, int pn_posY)
{ ln_posX = pn_posX; ln_posY = pn_posY;
addNeuroide();
}
public void addNeuroide()
{ if (dialog == null)
{ dialog = new JDialog();
//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()
{ public void keyTyped(KeyEvent e)
{ char c = e.getKeyChar();
if (((c<'0')||(c>'9'))&&(c!=KeyEvent.VK_BACK_SPACE)&&(c!='.')) e.consume();
if (c == '.' && txtNeuroideUmbr.getText().contains(".")) e.consume();
}
});
txtNeuroidePend.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=='.'&& txtNeuroidePend.getText().contains("."))
e.consume();
} });
//Boton Ok JButton jBtOk = new JButton("Ok");
jBtOk.setMnemonic('O');
jBtOk.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ 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);
statusBar.setText(gc_EditNetwork.lastActionMsg());
a_undo.setEnabled(true); a_redo.setEnabled(false);
} catch (Exception e)
{ e.printStackTrace(); }
repaint();
dialog.setVisible(false);
}
26
});
//Boton cancelar
JButton jBtCancel; jBtCancel = new JButton("Cancel");
jBtCancel.setMnemonic('C');
jBtCancel.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ 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);
gridBC.anchor = GridBagConstraints.NORTHWEST;
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jLbNeuroideName, gridBC); gridBC.gridwidth = GridBagConstraints.REMAINDER;
lc_container.add(txtNeuroideName, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jLbNeuroideUmbr, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtNeuroideUmbr, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jLbNeuroidePend, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER;
lc_container.add(txtNeuroidePend, gridBC);
gridBC.fill = GridBagConstraints.HORIZONTAL;
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jBtOk, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jBtCancel, gridBC);
dialog.add(lc_container, gridBC);
}
if (gc_EditNetwork.getNrOfElements() > 0)
{ 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(false);
dialog.setVisible(true); dialog.repaint();
} public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
public ActionRunNetwork()
{ super("Run Network", "Run Network", "network", "");
} public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
public ActionZoomIn()
{ super("Zoom in", "Zoom in", "zoomin", "+");
} public void actionPerformed(ActionEvent ae)
{ 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())
a_zoomout.setEnabled(true);
txtZoom.setText(gn_zoomPercents[i + 1] + "%");
gf_scale = gn_zoomPercents[i + 1] / 100D;
}
else
{ if (!a_zoomout.isEnabled())
a_zoomout.setEnabled(true);
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
private static final long serialVersionUID = 1L;
public ActionZoomOut()
{ super("Zoom out", "Zoom out", "zoomout", "-");
} public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
public ActionViewStatusbar()
{ super("View statusbar", "View statusbar", "statusbar", "");
}
public void actionPerformed(ActionEvent ae)
{ 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
{
private static final long serialVersionUID = 1L;
public ActionViewToolbar()
{ super("View toolbar", "View toolbar", "toolbar", "");
}
public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
public ActionHelp()
{ super("Help", "Neuroid Network Help", "help", "");
}
public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
public ActionAbout()
{ super("About", "Help about", "about", "");
} public void actionPerformed(ActionEvent ae)
{ 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
{ private static final long serialVersionUID = 1L;
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,
ln_posY + gn_graph_height / 2 + fm.getHeight() / 2 - 2);
}
31
if (pn_mode == HIGHLIGHTED) { pc_Graph.setXORMode(Color.green); }
pc_Graph.setColor(Color.black);
} else
{ pc_Graph.setColor(this.getBackground().darker().BLUE);
if (pn_mode == HIGHLIGHTED) { pc_Graph.setXORMode(Color.green); }
//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,
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,
ln_posY + gn_graph_height / 2 + fm.getHeight() / 2 - 2);
}
if (pn_mode == HIGHLIGHTED) { pc_Graph.setXORMode(Color.green); }
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));
if (gc_EditNetwork.getNrOfElements() > 0)
{ 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());
} catch (Exception e) { e.printStackTrace(); }
} // handleRightInputBlockClick
//Menú que se visualiza al dar click derecho sobre el neuroide
void handleRightNeuroideClick(MouseEvent me)
{ lc_Selection.clear();
repaint();
ActionListener EditParamsAction = 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"))
{ ((ActionParametersNeuroid) a_parameterN).editParameters(ln_posX, ln_posY, gn_current_graph);
return; } repaint();
} };
ActionListener addAxonAction = new ActionListener()
{
36
public void actionPerformed(ActionEvent ae)
{
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));
statusBar.setText(gc_EditNetwork.lastActionMsg());
updateStatus();
} catch (Exception e) { e.printStackTrace(); }
}
};
ActionListener delAxonAction = new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ deleteAxon(gn_current_graph, ae.getActionCommand());
}
}; ActionListener delChildAction = new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ deleteChild(ae.getActionCommand(), gn_current_graph);
} };
ActionListener delNeuroide = new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ 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());
} catch (Exception e) { e.printStackTrace(); }
} // 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
{ lc_Selection.clear();
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());
a_undo.setEnabled(true); a_redo.setEnabled(false);
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
{ private static final long serialVersionUID = 1L;
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_posX = pn_posX; ln_posY = pn_posY;
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()
{ if (dialog == null)
{ dialog = new JDialog();
//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()
{ 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()
{ public void keyTyped(KeyEvent e)
{ char c = e.getKeyChar();
if (((c<'0')||(c>'9'))&&(c!=KeyEvent.VK_BACK_SPACE)&&(c!='.'))
e.consume();
if (c == '.' && txtValorFinal.getText().contains("."))
e.consume();
} });
txtPeriodo.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();
41
if (c == '.' && txtPeriodo.getText().contains("."))
e.consume();
} });
txtRetardo.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 == '.' && txtRetardo.getText().contains(".")) e.consume();
}
});
//Boton Ok
JButton jBtOk = new JButton("Ok"); jBtOk.setMnemonic('O');
jBtOk.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ 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());
statusBar.setText(gc_EditNetwork.lastActionMsg());
} catch (Exception e)
{ e.printStackTrace(); }
repaint();
dialog.setVisible(false);
}
}); //Boton cancelar
JButton jBtCancel;
jBtCancel = new JButton("Cancel"); jBtCancel.setMnemonic('C');
jBtCancel.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ dialog.setVisible(false); }
});
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.anchor = GridBagConstraints.NORTHWEST;
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jLbValorInicio, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtValorInicio, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jLbValorFinal, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtValorFinal, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jLbPeriodo, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER;
lc_container.add(txtPeriodo, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
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);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jBtCancel, gridBC);
43
dialog.add(lc_container, gridBC);
}
txtValorInicio.setText(ls_valor_ini); txtValorFinal.setText(ls_valor_fin);
txtPeriodo.setText(ls_periodo);
txtRetardo.setText(ls_retardo);
dialog.setLocation(200, 200);
dialog.setVisible(true); dialog.setSize(dialog.getPreferredSize());
dialog.setVisible(false);
dialog.setVisible(true); dialog.repaint();
} public void actionPerformed(ActionEvent ae)
{ ln_posX = Integer.MAX_VALUE; editParameters();
} } // class ActionParametersBlock
//Clase para modificar los valores ingresados en el neuroide
class ActionParametersNeuroid extends MyAction
{ private static final long serialVersionUID = 1L;
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_posX = Integer.MAX_VALUE;
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()
{ if (dialog == null)
{ dialog = new JDialog();
//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()
{ public void keyTyped(KeyEvent e)
{ char c = e.getKeyChar();
if (((c<'0')||(c>'9'))&&(c!=KeyEvent.VK_BACK_SPACE)&&(c!='.'))
e.consume();
if (c == '.' && txtNeuroideUmbr.getText().contains("."))
e.consume();
}
}); txtNeuroideSlope.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 == '.' && txtNeuroideSlope.getText().contains("."))
e.consume();
} });
//Boton Ok JButton jBtOk = new JButton("Ok");
jBtOk.setMnemonic('O');
jBtOk.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent ae)
{ 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());
statusBar.setText(gc_EditNetwork.lastActionMsg());
} catch (Exception e)
{ e.printStackTrace(); }
repaint();
dialog.setVisible(false);
} });
//Boton cancelar JButton jBtCancel;
jBtCancel = new JButton("Cancel");
jBtCancel.setMnemonic('C'); jBtCancel.addActionListener(new ActionListener()
{ public void actionPerformed(ActionEvent ae) { dialog.setVisible(false); }
});
GridBagConstraints gridBC = new GridBagConstraints();
dialog.setLayout(new GridBagLayout());
Container lc_container = new Container();
lc_container.setLayout(new GridBagLayout());
gridBC.gridwidth = 1;
//Definimos espacios entre los objetos de la ventana (nort,izq,sur,der)
gridBC.insets = new Insets(10, 10, 5, 10); gridBC.anchor = GridBagConstraints.NORTHWEST;
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jLbNeuroideName, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER; lc_container.add(txtNeuroideName, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jLbNeuroideUmbr, gridBC);
gridBC.gridwidth = GridBagConstraints.REMAINDER;
lc_container.add(txtNeuroideUmbr, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jLbNeuroideSlope, gridBC); gridBC.gridwidth = GridBagConstraints.REMAINDER;
lc_container.add(txtNeuroideSlope, gridBC);
gridBC.fill = GridBagConstraints.HORIZONTAL;
gridBC.gridwidth = GridBagConstraints.RELATIVE; lc_container.add(jBtOk, gridBC);
gridBC.gridwidth = GridBagConstraints.RELATIVE;
lc_container.add(jBtCancel, gridBC);
46
dialog.add(lc_container, gridBC);
}
txtNeuroideName.setText(ls_name); txtNeuroideUmbr.setText(ls_umbr);
txtNeuroideSlope.setText(ls_slope);
dialog.setLocation(200, 200);
dialog.setVisible(true);
dialog.setSize(dialog.getPreferredSize()); dialog.setVisible(false);
dialog.setVisible(true);
dialog.repaint();
}
public void actionPerformed(ActionEvent ae)
{ 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);
statusBar.setText(gc_EditNetwork.lastActionMsg());
} catch (Exception e)
{ e.printStackTrace(); }
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));
statusBar.setText(gc_EditNetwork.lastActionMsg());
} catch (Exception e)
{ e.printStackTrace(); }
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);
statusBar.setText(gc_EditNetwork.lastActionMsg());
} catch (Exception e)
{ e.printStackTrace(); }
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);
statusBar.setText(gc_EditNetwork.lastActionMsg());
} catch (Exception e)
{ e.printStackTrace(); }
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 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.
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();
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 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_Distributions = lc_Distributions;
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();
Estimator[][] lc_Distributions = new Estimator[ln_atts][];
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
gc_Distributions = lc_Distributions;
ParentSet[] lc_ParentSets = new ParentSet[ln_atts];
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;
}
gc_ParentSets = lc_ParentSets;
//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();
Estimator[][] lc_Distributions = new Estimator[ln_atts][];
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;
}
gc_Distributions = lc_Distributions;
ParentSet[] lc_ParentSets = new ParentSet[ln_atts];
for (int iParentSet = 0; iParentSet < ln_atts; iParentSet++)
{
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;
}
gc_ParentSets = lc_ParentSets;
//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));
} catch (Exception e)
{ e.printStackTrace(); }
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;
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.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];
for (int iValue = 0; iValue < ln_values; iValue++)
{ String ls_weight = st.nextToken();
lc_DiscreteEstimator.addValue(iValue, new Double(ls_weight).doubleValue());
}
}
}
if (pn_mode == EXECUTE)
{ gc_Distributions = lc_Distributions;
gc_ParentSets = lc_ParentSets;
}
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)
{ if (gb_needs_undo_action)
{ 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)
{ if (gb_needs_undo_action)
{ 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)
{
if (gb_needs_undo_action)
{ 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);
if (gb_needs_undo_action)
{ 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 ("<!--No model built yet-->");
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
{ static final long serialVersionUID = 1L;
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
{ static final long serialVersionUID = 1L;
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)
{ e.printStackTrace(); }
} // 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
{ static final long serialVersionUID = 1L;
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
catch (Exception e) { e.printStackTrace(); }
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;
for (int iParentSet = 0; iParentSet < ln_atts; iParentSet++)
{ 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);
}
}
}
gc_ParentSets = lc_ParentSets;
Estimator[][] lc_Distributions = new Estimator[ln_atts][];
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];
}
gc_Distributions = lc_Distributions;
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
catch (Exception e) { e.printStackTrace(); }
} // undo
public void redo()
{
try { deleteInputBlock(ln_target_block); }
catch (Exception e)
{ e.printStackTrace(); } } // redo
} // class DeleteInputBlockAction
class AddNeuroideAction extends UndoAction
{ static final long serialVersionUID = 1L;
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)
{ e.printStackTrace(); }
} // redo } // class AddNeuroideAction
class DeleteNeuroideAction extends UndoAction
{ static final long serialVersionUID = 1L;
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
} catch (Exception e)
{ e.printStackTrace(); }
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);
} public void undo()
{
try { gc_Instances.insertAttributeAt(lc_Attrib, ln_target_neuroide);
int ln_atts = gc_Instances.numAttributes();
ParentSet[] lc_ParentSets = new ParentSet[ln_atts];
int ln_X = 0;
for (int iParentSet = 0; iParentSet < ln_atts; iParentSet++)
{ 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];
for (int iParent = 0; iParent < lc_ParentSets[iParentSet].getNrOfParents(); iParent++)
{ 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);
lc_DelAction.undo();
}
gc_VectorPosX.insertElementAt(ln_posX, ln_target_neuroide); gc_VectorPosY.insertElementAt(ln_posY, ln_target_neuroide);
66
} catch (Exception e)
{ e.printStackTrace(); }
} // undo
public void redo()
{ try { deleteNeuroide(ln_target_neuroide); }
catch (Exception e) { e.printStackTrace(); }
} // redo
} // class DeleteNeuroideAction
class DeleteSelectionAction extends UndoAction
{ static final long serialVersionUID = 1L;
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();
} catch (Exception e) { e.printStackTrace(); }
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
int ln_atts = gc_Instances.numAttributes();
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;
for (int iParentSet = 0; iParentSet < ln_atts; iParentSet++)
{ 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];
for (int iParent = 0; iParent < lc_ParentSets[iParentSet].getNrOfParents(); iParent++)
{ int nParent = lc_ParentSets[iParentSet].getParent(iParent); lc_ParentSets[iParentSet].SetParent(iParent, ln_offset[nParent]);
}
} }
gc_ParentSets = lc_ParentSets;
Estimator[][] lc_Distributions = new Estimator[ln_atts][];
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];
}
gc_Distributions = lc_Distributions;
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);
lc_DelAction.undo();
}
} catch (Exception e) { e.printStackTrace(); }
} // 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);
}
} catch (Exception e) { e.printStackTrace(); }
} // redo
} // class DeleteSelectionAction
class AddAxonAction extends UndoAction
{ static final long serialVersionUID = 1L;
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();
} catch (Exception e)
{ e.printStackTrace(); }
}
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();
}
} catch (Exception e) { e.printStackTrace(); }
} // 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);
}
} catch (Exception e) { e.printStackTrace(); }
} // redo
} // class AddArcAction
class DeleteAxonAction extends UndoAction
{ static final long serialVersionUID = 1L;
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();
} catch (Exception e)
{ e.printStackTrace(); }
}
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;
} catch (Exception e)
{ e.printStackTrace(); }
} // undo
public void redo()
{ try { deleteAxon(ln_parent, ln_child); }
catch (Exception e)
{ e.printStackTrace(); }
} // redo
} // class DeleteAxonAction
class EditInputBlockAction extends UndoAction
{ static final long serialVersionUID = 1L;
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
{ static final long serialVersionUID = 1L;
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
{ static final long serialVersionUID = 1L;
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
{ static final long serialVersionUID = 1L;
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;
} public void undo()
{ 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
{ static final long serialVersionUID = 1L;
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--;
}
} catch (Exception e) { e.printStackTrace(); }
} // 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
{ static final long serialVersionUID = 1L;
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("<!-- DTD for the XMLBIF 0.3 format -->\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.
*/ package promeinfo.net;
75
import promeinfo.core.Attribute;
import promeinfo.core.DiscreteEstimatorElement;
import promeinfo.core.Estimator; import promeinfo.core.NeuroidVector;
import promeinfo.core.Instances;
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
{ static final long serialVersionUID = 1L;
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
for (int iValue = 0; iValue < ln_values; iValue++)
{
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);
for (int iValue = 0; iValue < ln_values; iValue++)
{ 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();
for (int iValue = 0; iValue < ln_values; iValue++)
{ 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
/* * 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.
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.
*/ package promeinfo.net;
import promeinfo.core.Instances;
import java.io.Serializable;
public class ParentSet implements Serializable
{ static final long serialVersionUID = 1L;
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
UNIVERSIDAD DE GUAYAQUIL
FACULTAD DE MATEMÁTICAS Y FÍSICAS
CARRERA DE INGENIERÍA EN SISTEMAS
COMPUTACIONALES
“DESARROLLO DE UN SOFTWARE PARA LA
CONSTRUCCIÓN DE REDES NEUROIDALES”
MANUAL DE USUARIO
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
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
Autor: Andrés Silva Muñoz
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
Fuente: Neuroidal Network Editor
Opción Descripción
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
Autor: Andrés Silva Muñoz
4
Figura 3: Menú Edit
Fuente: Neuroidal Network Editor
Opción Descripción
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
Autor: Andrés Silva Muñoz
5
Figura 4: Menú View
Fuente: Neuroidal Network Editor
Opción Descripción
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
Autor: Andrés Silva Muñoz
6
Figura 5: Menú Windows
Fuente: Neuroidal Network Editor
Opción Descripción
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
Autor: Andrés Silva Muñoz
7
Figura 6: Menú Help
Fuente: Neuroidal Network Editor
Opción Descripción
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
Autor: Andrés Silva Muñoz
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.
Opción Descripció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
Autor: Andrés Silva Muñoz
9
Figura 7: Opción New
Fuente: Neuroidal Network Editor
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
Autor: Andrés Silva Muñoz
10
Figura 8: Submenú del área de edición
Fuente: Neuroidal Network Editor
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
Autor: Andrés Silva Muñoz
11
Figura 9: Opción Add Input Block
Fuente: Neuroidal Network Editor
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:
4. Haga clic en el icono
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
Autor: Andrés Silva Muñoz
12
Figura 10: Creación de bloque de entrada
Fuente: Neuroidal Network Editor
Figura 11: Submenú del bloque de entrada
Fuente: Neuroidal Network Editor
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
Autor: Andrés Silva Muñoz
13
Figura 12: Opción Add Neuroide
Fuente: Neuroidal Network Editor
Nombre de Campo Descripción de Campo
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:
1. Haga clic en el icono
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
Autor: Andrés Silva Muñoz
14
Figura 13: Creación de neuroide
Fuente: Neuroidal Network Editor
Figura 14: Submenú del neuroide
Fuente: Neuroidal Network Editor
Nombre de Campo Descripción de Campo
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
Autor: Andrés Silva Muñoz
15
Figura 15: Ingreso del peso del axón
Fuente: Neuroidal Network Editor
Figura 16: Creación del axón
Fuente: Neuroidal Network Editor
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
Autor: Andrés Silva Muñoz
16
Figura 17: Opción Undo
Fuente: Neuroidal Network Editor
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:
1. Haga clic en el icono
2. Haga clic en Edit > Undo
3. Utilizando las combinaciones Ctrl + Z
Tabla 15: Opción Undo
Autor: Andrés Silva Muñoz
17
Figura 18: Opción Redo
Fuente: Neuroidal Network Editor
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:
1. Haga clic en el icono
2. Haga clic en Edit > Redo
3. Utilizando las combinaciones Ctrl + Y
Tabla 16: Opción Redo
Autor: Andrés Silva Muñoz
18
Figura 19: Opción Zoom in
Fuente: Neuroidal Network Editor
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:
1. Haga clic en el icono
2. Haga clic en View > Zoom In
Tabla 17: Opción Zoom in
Autor: Andrés Silva Muñoz
19
Figura 20: Opción Zoom Out
Fuente: Neuroidal Network Editor
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:
1. Haga clic en el icono
2. Haga clic en View > Zoom Out
Tabla 18: Opción Zoom Out
Autor: Andrés Silva Muñoz
20
Figura 21: Opción Save As
Fuente: Neuroidal Network Editor
Nombre de Campo Descripción de Campo
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
Autor: Andrés Silva Muñoz
21
Figura 22: Opción Save
Fuente: Neuroidal Network Editor
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:
6. Haga clic en el icono
7. Haga clic en File > Save
8. Utilizando las combinaciones Ctrl + S
Tabla 20: Opción Save
Autor: Andrés Silva Muñoz
22
Figura 23: Opción Open
Fuente: Neuroidal Network Editor
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:
3. Haga clic en el icono
4. Haga clic en File > Open
5. Utilizando las combinaciones Ctrl + O
Tabla 21: Opción Open
Autor: Andrés Silva Muñoz
23
Figura 24: Lectura de archivo
Fuente: Neuroidal Network Editor
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
Autor: Andrés Silva Muñoz
24
Figura 25: Opción View Toolbar
Fuente: Neuroidal Network Editor
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
Autor: Andrés Silva Muñoz
25
Figura 26: Opción View Statusbar
Fuente: Neuroidal Network Editor
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
Autor: Andrés Silva Muñoz
26
Figura 27: Opción Select All
Fuente: Neuroidal Network Editor
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
Autor: Andrés Silva Muñoz
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
Fuente: Neuroidal Network Editor
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)
Fuente: Neuroidal Network Editor
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)
Fuente: Neuroidal Network Editor
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
Fuente: Neuroidal Network Editor
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
Fuente: Neuroidal Network Editor
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.