FECHA

20-06-2011

NMERO RAE
PROGRAMA
AUTOR
TTULO

Ingeniera de Sonido Universidad de San Buenaventura

GONZLEZ Daz, Sebastin
Diseo De Un Sistema Que Genera Animacin A Partir De
Secuencias Musicales MIDI

PALABRAS CLAVES animacin, msica, secuencia, midi, anlisis, imagen,

visual, acadmica, clsica, apreciacin, programacin,
python, pure data, gem
DESCRIPCIN El presente Trabajo de Grado logra generar un sencillo lenguaje
grfico que traduce la msica en imgenes sincrnicas; parte de
las expresiones musicales acadmicas traducidas al protocolo
de comunicacin MIDI, para ser transformada la informacin
haciendo uso del software libre, en rdenes de entorno grfico,
para estructurar dicha animacin bajo los parmetros de la teora
musical, generando as una experiencia visual de la msica
controlada mediante una interfaz. El lenguaje visual creado
puede dirigirse entre otras cosas a la enseanza de la
apreciacin musical en todas las edades.

FUENTES
Bibliografa Sobre Lenguajes De Desarrollo De
BIBLIOGRFICAS Programacin, Midi Y Software
ELEANOR SELFRIDGE-FIELD BEYOND
MIDI, The Handbook Of Musical Codes
GEM ENTORNO GRFICO PARA MULTIMEDIA
(PAGINA OFFICIAL)
http://www.iua.upf.edu/~csora/gmv/index.php
GONZALEZ DUQUE RAUL
Python para todos
JOHANNES KREIDLER
Loadbang: Programming Electronic Music in Pure Data
PURE DATA (PAGINA OFFICIAL)
http://puredata.info/

 Python PROGRAMMING
OFFICIAL)
http://www.Python.org

LANGUAGE

(PAGINA

Bibliografa Sobre Imagen

D. A. DONDIS
La Sintaxis de la Imagen
DE MORENTIN JUAN MAGARIOS
Lo que explica la semntica visual
JOS M GONZLEZ-SERNA SNCHEZ
Sintaxis
de
la
Imagen
[en
lnea]
<http://www.auladeletras.net/mat_med.html#>
Semntica de la Imagen
[en lnea] <
http://www.auladeletras.net/mat_med.html#>
MAGARIOS DE MORENTIN, J
La(s) semitica(s) de la imagen visual.,Cuadernos 17,
Revista de la Facultad de Humanidades y Ciencias
Sociales de la Universidad Nacional de Jujuy;
noviembre,
PEP ALSINA, FREDERIC SES
El rea de educacin musical
Historia de la msica con propuestas didcticas y 49
audiciones
KANDINSKY
Punto y lnea sobre el plano
De lo Espiritual en el Arte

Bibliografa Sobre Visualization Musical Y Teora

Musical
ALVIRA RODRGUEZ JOS
Teora
Musical;
Aprendizaje
[en
lnea].
http://teoria.com/aprendizaje/lectura/15-armaduras.htm
ANIMUSIC
Pagina Oficial [en lnea] http://www.animusic.com/
BACH, J. S.

Inventions & Sinfonies BWV 772-801 Clavierbchlein

vor Wilhelm Friedemann Bach
Clave bien temperado BWV 846-869 y BWV 870-893
DRA. ANA MARA SEDEO VALDELLS
Artculo publicado en Julio del 2007 en la revista n
0004 de Sinfona Virtual, Espaa
DR. H. RIEMANN
Analysis of J. S. Bachs Wohltemperirtes Clavier
HELEN L. KAUFMANN
The Home Book of Music Appreciation
KLAUS EIDAM
La verdadera vida de Johann Sebastian Bach
LLOYD ULTAN
Music theory: problems and practices in the Middle
Ages and Renaissance
MUSIC ANIMATION MACHINE
Pgina
Oficial
[en
http://www.musanim.com/mam/mamhist.htm

lnea]

ROSEN, CHARLES:
Bach y Hndel, La Msica para Teclado
STEPHEN ANTHONY MALINOWSKI
Computer-Assisted Performance music animation
machine http://www.musanim.com (pagina official)
THOMAS WHITNEY SURETTE
The Appreciation of Music
WILLI APEL
Harvard dictionary of music

NMERO RAE
PROGRAMA

Ingeniera de Sonido Universidad de San Buenaventura

CONTENIDOS

Descompilado de archivos MIDI en python

Filtrado de tipos de mensajes MIDI
Construccin de herramienta de anlisis y mtodos
musicales para una secuencia MIDI haciendo uso de
matrices concatenadas
Anlisis de alteraciones y bsqueda de la tonalidad
Uso de la tonalidad para la bsqueda de notas triadas y
pertenecientes a los grados de la escala en la secuencia
Lista de ordenes con el protocolo Qlist para Pure Data
Mover archivos entre directorios de Windows
El secuenciador Qlist
El protocolo MIDI en Pure Data
Animacin en Gem
Programacin haciendo uso de la funcin curve3d para la
creacin del escenario
Programacin de color y de luces con la funcin spot light
Programacin de las esferas animadas
Programacin de la interfaz grfica en Tkinter

METODOLOGA

Enfoque De La Investigacin
El enfoque para este proyecto es emprico-analtico
porque su fin est hallado en el hacer como creacin
donde la principal pregunta para su realizacin es el
cmo, y puede llegar a ser diseado, cuyo producto (el
sistema) proviene de una estructura en particular a la
metodologa de investigacin orientando el trabajo a la
contrastacin permanente de las aseveraciones teoras
como aseveraciones tericas musicales, la semiologa y la
semntica de la imagen trasformadas a travs de mtodos
tecnolgicos hallados en los lenguajes de programacin
dando como fin un sistema que transforma los procesos
musicales, en procesos visuales.
El ncleo problmico de este proyecto est desarrollado
dentro del ncleo de Anlisis y Procesamiento de
Seales, ya que el sistema consiste en tomar una seal
lineal (informacin MIDI en cdigo binario) y transformarla
en una seal bidimensional (imagen) que vara en el
tiempo. En detalle, se est diseando una herramienta
mediante la programacin que, vinculando varios
software, logra crear un mtodo de anlisis para el
protocolo MIDI, que a su vez genera informacin
necesaria para que un software de animacin acte
respecto de dicho anlisis. Todo es controlado por una
interfaz grfica que enlaza la herramienta de anlisis con
el software que genera la animacin y un secuenciador
MIDI.
La lnea de investigacin de la facultad en este proyecto
que, como ya se mencion, se desarrolla dentro del
campo de Anlisis y Procesamiento de Seales (APS),
busca, a travs de los mtodos y la conceptualizacin del
campo de la ingeniera de sonido, instrumentar el
desarrollo de nuevas tecnologas encaminadas al apoyo
de la composicin y la enseanza de la apreciacin
musical, creando un sistema novedoso de automatizacin
de la animacin, mediante la construccin, anlisis y
enlace de programas, a partir de la informacin musical
encontrada en el protocolo MIDI.
La lnea de investigacin de la universidad dentro de las
lneas de investigacin de la Universidad de San

Buenaventura y de acuerdo con el Consejo de

Investigacin Bonaventuriano (CIB), ste proyecto se
inscribe en la lnea Tecnologas actuales y sociedad, ya
que busca desarrollar una interfaz interactiva, a travs de
la actualizacin constante de los conocimientos
tecnolgicos y por medio de software libre, relacionando
de una forma directa la estructura y la teora musical con
un lenguaje visual sincrnico, generando animaciones,
para el apoyo y desarrollo de la composicin y de la
apreciacin musical, facilitando la enseanza del
contrapunto musical y contribuyendo al desarrollo de la
educacin musical en la sociedad.

Hiptesis
Utilizando software libre, disear un sistema que permita
relacionar la teora musical y la expresin grfica con el fin
de crear un mtodo dirigido hacia la enseanza de la
apreciacin musical.

Variables
Variables Independientes
-

Elementos la teora musical hallados en las

Invenciones y Sinfonas, y el Clave Bien
Temperado.
Secuencias con el protocolo de comunicacin MIDI
Programacin y edicin del color
Programacin y edicin de la luz
Programacin y edicin del plano
Programacin y edicin de las esferas

Variables Dependientes
-

Descompilado de archivos MIDI

Filtrado de tipos de mensajes MIDI
Anlisis y mtodos haciendo uso de matrices
concatenadas
Anlisis de alteraciones, tonalidad, grados de notas
y triadas en la secuencia
Lista de eventos generada en protocolo Qlist
Secuenciador Qlist para la animacin y para el

sintetizador o muestreador
Accin de la animacin para el conjunto de
elementos desarrollados en GEM
Interfaz Grfica

Proceso
Para el desarrollo del sistema se ha creado una estructura
metodolgica que desglosa cada una de las etapas de la
siguiente manera:

Generar un protocolo de informacin que haga uso

de la secuencia MIDI para que Pure Data sea capaz de
enviar informacin MIDI hacia un instrumento virtual, en
tiempo real.

Generar un programa para que el software de

animacin GEM entienda la informacin recibida y la
ejecute en tiempo real.

Crear un lenguaje visual sencillo para representar

varios elementos de la estructura musical.

Crear la comunicacin necesaria para que Pure

Data entienda las rdenes generadas por el programa de
anlisis y genere la animacin.

Hacer una interfaz grfica que permita manipular y

enlazar los programas que deben ser usados.
Para ste proyecto se ha escogido el contrapunto, que es
una rama de la teora musical que estudia la composicin
de msica polifnica, mediante el enlace de dos o ms
melodas. Sin embargo, como este campo es bastante
amplio en toda la msica acadmica y sera muy
ambicioso cubrir todo el contrapunto, se han escogido las
Invenciones y Sinfonas BWV 772-801, de Johann
Sebastian Bach, que son 30 breves piezas para piano,
que sirven tradicionalmente al aprendizaje del contrapunto
y que tuvieron el fin de ensear al hijo del compositor;
Friedman, la polifona . Las Invenciones son 15 piezas a
dos voces y las Sinfonas son 15 piezas a tres voces.
Bach, al componerlas, us las escalas ms sencillas,

haciendo un pequeo clave bien temperado didctico para

sus hijos . Luego se tomaron los dos libros de El Clave
Bien Temperado BWV 846-869 y BWV 870-893, que son
un conjunto grande de partituras usadas para el estudio
de la interpretacin polifnica, como tambin un referente
cumbre para el estudio de la forma musical del periodo
barroco en cuanto al preludio y la fuga . Cada libro posee
24 grupos constituidos por un preludio y una fuga en
todas las tonalidades mayores y menores de la gama
cromtica completando toda la escala cromtica de mayor
a menor. Es, por tanto, una coleccin enorme que
comprende 48 preludios y 48 fugas cuyo contenido es a la
vez musical, terico y didctico.
Este trabajo est inicialmente dirigido hacia nios que ya
tengan conocimientos musicales y nociones de armona y
contrapunto , as como tambin a jvenes que tengan la
capacidad o estn cerca de interpretar las obras de El
Clave Bien Temperado. Entonces, la interfaz mostrar a
los usuarios, por medio de dos canales de comunicacin:
auditivo y visual, la forma cmo la msica ha sido escrita y
estudiada, con lo cual las obras podrn ser entendidas
mucho ms didcticamente, introducindolos en el
significado y las estructuras en las cuales se escribieron.

CONCLUSIONES

El concepto de sinestesia para aquellas personas que no

la poseen (non-sinestsicos), les puede hacer pensar en
cules seran las posibilidades, si en ellas existiera esta
singularidad (como problema o virtud) generando otros
panoramas de percepcin y por ende reacciones
psicofsicas, ampliando su capacidad de concepcin de la
realidad. Hacer visual la msica es la meta que nace con
este proyecto en donde a la final y de cualquier manera va
a existir un arte que va a germinar en otro arte.
En este proyecto logra crear una base para futuros
desarrollos tecnolgicos relacionando con la msica, la
programacin y la animacin. Dicha base ampla el
conocimiento de los sistemas exponiendo claramente
diferentes rutas para analizar, procesar y transformar la
informacin, mediante el desarrollo de los recursos de
software libre. Ofrece un variado panorama de
posibilidades a quienes busquen en el tema ampliar el

conocimiento
y
crecimiento
de
la
tecnologa,
especialmente para el software que es de todos y para
todos (Open Source).
Para que el programa fuera capaz de hallar los resultados
esperados, es decir, que procesara la estructura musical,
se tuvo que partir de informacin binaria hallada en el
protocolo de comunicacin y haciendo uso de pequeos
programas, disear mtodos de anlisis que vayan
descifrando la informacin numrica hasta lograr
informaciones bsicas sobre la estructura musical,
teniendo en cuenta que dicho protocolo no se ha diseado
en si para la escritura musical sino ms bien fue creado
para la comunicacin musical; los archivos MIDI estn
diseados para reproducir msica, y no para la notacin
musical o impresin; en otras palabras, los archivos no
incluyen informacin sobre la notacin como ligaduras,
articulaciones y/o maquetacin. Tampoco puede discernir
la escritura enarmnica (como la diferencia entre Fa# y
Solb) . Es decir,
el proyecto logr desarrollar un
programa capaz de interpretar la informacin musical de
un protocolo de comunicacin estndar y espera llegar a
descifrar procesos ms complejos de la teora musical,
como las funciones armnicas y las formas musicales.
Es un objetivo logrado haber creado las herramientas para
que el desarrollador interesado pueda, haciendo uso de la
programacin, reconocer los procesos musicales,
mediante un solo sistema que analiza innumerables
posibilidades de escritura en archivos MIDI. Una de estas
herramientas consiste en tomar la secuencia y diferenciar
las notas alteradas de la misma, continuar con la
aclaracin de la informacin enarmnica y descubrir si las
notas alteradas son sostenidos o bemoles hasta,
finalmente, dar con la tonalidad mayor o menor en la que
fue compuesta la pieza. Otra herramienta lograda que
parte de la anterior, es la que genera la visualizacin de
un flujo de eventos de manera matricial sin perder de vista
las propiedades armnicas musicales de la secuencia; y
que est bastante cerca de poder discernir las lneas
meldicas de una pieza polifnica; adems, ya es un
recurso que facilita el anlisis de las funciones armnicas.
Como instrumento de enseanza, el programa puede

expresar de manera visual conceptos como ritmo, altura,

intensidad, consonancia y disonancia; notas nicas o
simultneas; tonalidades mayores y menores; grados de
la escala y triadas pertenecientes a los grados del a
escala. Logra intuir la polifona musical aproximndose a
la separacin de lneas musicales y tambin ayuda a
discernir diferencias musicales como tipos de piezas,
compositores, periodos musicales con simplemente
visualizar la animacin. De esta manera cumple el objetivo
de convertirse en una herramienta para la enseanza de
la apreciacin musical. Faltara solamente evidenciarlo y
demostrarlo mediante disciplinas inherentes a la
comprobacin y el desarrollo de pruebas educativas,
psicofsicas y otras disciplinas relacionadas.
Para llegar a los resultados visuales, el proyecto, tuvo que
experimentar variadas relaciones grficas, unidas a los
conceptos musicales, convocando as al nacimiento
intrnseco de un nuevo lenguaje de comunicacin
musical. Este sistema est ms cerca de alcanzar un tipo
de experiencia sinestsica, provocando tambin una base
para la creacin ms acertada del fenmeno sincrnico
visual-musical.
Otro logro es instrumentar la relacin del protocolo MIDI
con el secuenciador Qlist de Pure Data, convirtindolo en
un medio de transformacin del lenguaje binario de un
archivo MIDI a un archivo con el protocolo Qlist. La
ventaja es que cualquier programador en Python puede
valerse de este desarrollo y aprovechar el sistema para
extraer informacin del protocolo MIDI para emplearlo en
su propio beneficio. Otro beneficio es haber logrado la
entrada de una secuencia MIDI a Pure Data obteniendo
variables fciles de manejar.
En el campo de la animacin, la posibilidad de usar la
curva 3d (el plano) fue implementada de manera sencilla,
al desarrollar un sistema que permite la variacin de
valores en los tres ejes cartesianos, de manera que se
pueden desplazar de una manera ordenada y cmoda.
Mediante esta creacin se pueden experimentar muchas
formas y unir stas variables controladas creando
movimiento del plano en tiempo real. Otro desarrollo que
facilit el proceso de animacin fue la creacin de un

control simple para transformar rpidamente los valores

RGB, logrando tener todas las gamas de color en un
simple control, as mismo para esta aplicacin se diseo
otro control con el que se puede degradar u oxidar el color
sin perder la tonalidad de color original. Una aplicacin
ms consisti en hacer un centro de mando para
manipular las propiedades de las luces y a la cual se le
aadi la aplicacin de color; es decir, que para
posteriores desarrollos en GEM ya no sera necesario
programar cada luz sino que al utilizar sta estructura se
tiene acceso a grandes posibilidades para la luz y su
color.
En conclusin los programas creados en Pure Data fueron
desarrollos para hacer posible la rpida manipulacin de
las animaciones en tiempo real del entorno grfico GEM,
mediante estructuras diseadas, facilitando el uso de las
propiedades y de los objetos de animacin.
Los recursos y las posibilidades encontrados en el
software libre son poderosas y suficientes para desarrollos
posteriores del sistema. Adems, la comunidad que rodea
el cdigo abierto es supremamente bondadosa en facilitar
el aprendizaje de las herramientas Open Source.

DISEO DE UN SISTEMA QUE GENERA ANIMACIN

A PARTIR DE SECUENCIAS MUSICALES MIDI

SEBASTIN GONZLEZ DAZ

20043167068

UNIVERSIDAD DE SAN BUENAVENTURA

FACULTAD DE INGENIERA
PROGRAMA DE SONIDO
BOGOT
2011

DISEO DE UN SISTEMA QUE GENERA ANIMACIN

A PARTIR DE SECUENCIAS MUSICALES MIDI

SEBASTIN GONZLEZ DAZ

20043167068

Proyecto de Grado

UNIVERSIDAD DE SAN BUENAVENTURA

FACULTAD DE INGENIERA
PROGRAMA DE SONIDO
BOGOT
2011

Nota de aceptacin

______________________________
______________________________
______________________________
______________________________
______________________________

______________________________
Jurado

______________________________
Jurado

Bogot, 30 de mayo de 2011

AGRADECIMIENTO

Primero que nada doy gracias a l Todo, de quien nace y se crea la primera
causa, por la cual todos provenimos y existe la unidad, es por l que puedo ser y
tengo la fortuna de poder modificar la materia y la energa para crear.
No podra faltar mi madre, Mara Fernanda Daz, gracias a su ejemplo y su gran
valenta he salido adelante, su fuerza y coraje que nos ha impulsado a m y a toda
la familia por ser cada da mejores.
A mi padre, Jos Luis Gonzlez, su sabidura y consejos aunque a veces necios,
me dieron la visin para el desarrollo de este proyecto, gracias por toda su ayuda;
el cario de mi abuelita, la paciencia de Santiago, el apoyo de Natalia y la
compaa de Simn.
Son muchas ms las personas a las que debo y quiero agradecer, todas y cada
una de ellas que me prestaron atencin y contribuyeron a esta idea, entre ellos
quiero destacar a:
Ingeniero Carlos Andrs Cabas
El Seor Hernn Espinoza
Doctor Jaime Durn
Maestro Jaime Morn
Ingeniero Luis Andrs Murcia
Fsico Luis Jorge Herrera
Ingeniero Manuel Dvila
Ingeniero Miljail Posada
Diseador Oscar Mauricio Reyes
La Seorita Roxana Puente
Por ltimo agradezco la maravillosa contribucin de los desarrolladores en cdigo
abierto, creadores de programas que hicieron posible la construccin de ste
sistema como MIDICSV, Python, Pure Data y GEM, Rose Garden; para ellos mi
ms profunda admiracin por su trabajo.

RESUMEN

El presente Trabajo de Grado logra generar un sencillo lenguaje grfico que

traduce la msica en imgenes sincrnicas; parte de las expresiones musicales
acadmicas traducidas al protocolo de comunicacin MIDI, para ser transformada
la informacin haciendo uso del software libre, en rdenes de entorno grfico, para
estructurar dicha animacin bajo los parmetros de la teora musical, generando
as una experiencia visual de la msica controlada mediante una interfaz. El
lenguaje visual creado puede dirigirse entre otras cosas a la enseanza de la
apreciacin musical en todas las edades.

TABLA DE CONTENIDO

INTRODUCCIN ..............................................................................................................................7
PLANTEAMIENTO DEL PROBLEMA ..............................................................................8

1.
1.1.

ANTECEDENTES .............................................................................................................8

1.2.

DESCRIPCIN Y FORMULACIN DEL PROBLEMA ........................................... 13

1.3.

JUSTIFICACIN ............................................................................................................ 14

1.4.

OBJETIVOS DE LA INVESTIGACIN ...................................................................... 17

1.4.1.

OBJETIVO GENERAL ........................................................................................................ 17

1.4.2.

OBJETIVOS ESPECFICOS .............................................................................................. 17

1.5.

ALCANCES Y LIMITACIONES DEL PROYECTO .................................................. 18

1.5.1.

ALCANCES .......................................................................................................................... 18

1.5.2.

LIMITACIONES .................................................................................................................... 19

METODOLOGA ................................................................................................................ 20

2.
2.2.

HIPTESIS ..................................................................................................................... 25

3.
NUCLEOS PROBLMICOS / LNEA DE INVESTIGACIN DE LA FACULTAD /
LNEA DE INVESTIGACIN DE LA UNIVERSIDAD .............................................................. 25
3.1.

NCLEOS PROBLMICOS ........................................................................................ 25

3.2.

LNEA DE INVESTIGACIN DE LA FACULTAD ................................................... 25

3.3.

LNEA DE INVESTIGACIN DE LA UNIVERSIDAD .............................................. 26

MARCO DE REFERENCIA .............................................................................................. 26

4.
4.1.

MARCO TERICO CONCEPTUAL ........................................................................ 26

4.1.1.

PYTHON ................................................................................................................................ 26

4.1.2.

TKINTER ............................................................................................................................... 28

4.1.3.

MIDICSV ................................................................................................................................ 28

4.1.4.

COMUNICACIN OPEN SOUND CONTROL ................................................................ 29

4.1.5.

PURE DATA ......................................................................................................................... 30

4.1.6.

MIDI ........................................................................................................................................ 31

4.1.7.

TEORA MUSICAL .............................................................................................................. 32

4.1.8.

SIGNIFICADO DE LA APRECIACIN MUSICAL ......................................................... 32

4.1.9.

LA IMAGEN .......................................................................................................................... 34

4.2.

MARCO LEGAL O NORMATIVO ............................................................................... 34

4.2.1.

LICENCIA DE MIDICSV ..................................................................................................... 34

4.2.2.

LICENCIA DE Python Y TKINTER .................................................................................. 35

4.2.3.

LICENCIA DE PURE DATA Y GEM ................................................................................. 35

DESARROLLO INGENIERIL ........................................................................................... 37

5.
5.1.

ESTRUCTURA DEL PROGRAMA ............................................................................. 37

5.2.

DESCOMPILADO DE ARCHIVOS MIDI EN PYTHON ........................................... 39

5.3.

CONTEO DE EVENTOS ON Y OFF ........................................................................... 40

5.4.

FILTRADO, LISTAS, Y EVENTOS IMPORTANTES ............................................... 41

5.5.

HERRAMIENTA DE ANLISIS ................................................................................... 43

5.6.

MTODO DE ANLISIS MSICAL PARA UNA SECUENCIA MIDI ................... 51

5.6.1.
MATRIZ CONCATENADA evnt=[ ] DE NOTAS SIMULTANEAS POR
DURACION ............................................................................................................................................. 53

5.7.

ANLISIS - SECUENCIA MIDI - TEORA MUSICAL ............................................. 56

5.7.1.

DICCIONARIOS REQUERIDOS PARA EL ANLISIS ................................................. 57

5.7.2.

ANLISIS DE ALTERACIONES Y BSQUEDA DE LA TONALIDAD ...................... 59

5.7.3.

DEFINIENDO LA TONALIDAD ......................................................................................... 66

5.7.4.

USO DE LA TONALIDAD .................................................................................................. 71

5.7.5.

TRIADAS Y FUNCIONES ARMNICAS DE LA SECUENCIA ................................... 75

5.7.6.

LISTA DE ORDENES PARA PURE DATA ..................................................................... 77

5.8.

MOVER ARCHIVOS GENERADOS AL DIRECTORIO GEM ................................ 88

5.9.

PROGRAMACIN EN PURE DATA .......................................................................... 88

5.9.1.

QLIST, PYPD, SECUENCIA DE EVENTOS ................................................................... 89

5.9.2.

PROTOCOLO MIDI EN PURE DATA .............................................................................. 92

5.9.3.

VENTANA DE ANIMACIN GEM .................................................................................... 93

5.9.4.

PROGAMACION DEL PLANO CURVE3D ...................................................................... 94

5.9.5.

PROGRAMACIN DE COLOR Y DE LUCES SPOT LIGHT ....................................... 96

5.9.6.

PROGAMACIN DE LAS ESFERAS ............................................................................ 109

5.9.7.

PROGRAMACIN DEL COLOR DE NOTAS PARA .................................................. 115

5.9.8.

MONITOR............................................................................................................................ 118

5.10.

PROGRAMACIN DE LA INTERFAZ GRFICA EN TKINTER ..................... 119

5.10.1.

ESTRUCTURA DE LA INTERFAZ ................................................................................. 120

5.10.2.

INICIANDO EL PROGRAMA ........................................................................................... 121

5.10.3.

LA FUNCIN __INIT__ ((( MUSIC ))) ((( GARDEN ))) .............................................. 122

5.10.4.

LA FUNCIN INICIO ......................................................................................................... 123

5.10.5.

LA FUNCIN BUSCAR .................................................................................................... 125

5.10.6.

LA FUNCIN AUXSLCTON ............................................................................................ 130

5.10.7.

LA FUNCIN SLCTON .................................................................................................... 132

5.10.8.

LA FUNCIN AXMG ......................................................................................................... 133

5.10.9.

LA FUNCIN MG .............................................................................................................. 134

5.10.10.

LA FUNCIN AUXABRIRPD ...................................................................................... 135

5.10.11.

LA FUNCIN ABRIRPD .............................................................................................. 136

5.10.12.

LA FUNCIN AUXVENTANA ..................................................................................... 137

5.10.13.

LA FUNCIN VENTANA ............................................................................................. 138

5.10.14.

LAS FUNCIONES TEST 1 ,2, 3, 4 .............................................................................. 139

5.10.15.

LA FUNCIN AUXPLAYSTOP................................................................................... 140

5.10.16.

LA FUNCIN PLAY ...................................................................................................... 141

5.10.17.

LA FUNCIN STOP...................................................................................................... 141

5.10.18.

LA FUNCIN SALIR .................................................................................................... 142

PRESENTACIN Y ANLISIS DE RESULTADOS .................................................. 142

6.
6.1.

REQUISITOS PARA LA EJECUCION DE MUSIC GARDEN .............................. 142

6.2.

INICIO DE LA INTERFAZ GRFICA ....................................................................... 143

6.3.

ANIMACIN ................................................................................................................. 150

6.3.1.

ALTURA Y PALETA DE COLORES POR TONALIDAD ............................................ 150

6.3.2.

TONALIDADES MAYORES Y MENORES .................................................................... 151

6.3.3.

VELOCIDAD DE NOTA PIANO-FORTE........................................................................ 152

6.3.4.

NOTAS SIMULTNEAS CONSONANCIAS Y DISONANCIAS ................................ 152

6.3.5.

GRADOS DE LA ESCALA Y TRIADAS ........................................................................ 153

6.4.

CONCLUSIONES Y RECOMENDACIONES .............................................................. 158

7.

8.

DETRS DE LA INTERFAZ Y LA ANIMACIN .................................................... 155

7.1.

CONCLUSIONES ........................................................................................................ 158

7.2.

RECOMENDACIONES ............................................................................................... 161

BIBLIOGRAFA ................................................................................................................. 163

GLOSARIO.................................................................................................................................... 166

INTRODUCCIN

En la dcada de los 60s Stephen Anthony Malinowski, compositor americano e

ingeniero de software, tuvo la idea de usar las nuevas tecnologas de la
informacin para ver la msica. Grafic mediante software las lneas meldicas de
una sonata de Bach para violn, donde hizo que dichas lneas siguieran la msica.
As, empez a disear y a construir una mquina de animacin musical, que
finalmente se convirti en un programa que representa las voces musicales
mediante imgenes abstractas y logra un fuerte vnculo entre la msica y la
imagen. A partir de estos primeros logros poco a poco surge la idea de generar
animaciones a partir de los principios de la msica, cuya estructura, establecida
mediante el anlisis de programacin de sistemas, es llevada hacia el control de
la animacin. Para facilitar dicho anlisis se usa el protocolo MIDI.

El Proyecto de Grado es una alternativa para el procesamiento de la informacin

musical hallada en una secuencia MIDI, que establece, a travs de la
programacin, mtodos de anlisis que posibilitan la exploracin musical de
dichos eventos. Crea un enlace entre msica e imagen en movimiento en tiempo
real que permite la exploracin de nuevas secuencias.

Uno de los aportes ms significativos de este Proyecto es el uso de software libre,

de uso y distribucin gratuita, lo que hace que el producto sea accesible a todo el
pblico y que no requiera de mayores recursos. Por lo tanto el Proyecto es firme
en el propsito de que los desarrollos logrados compartan la filosofa de software
libre y que su cdigo fuente est abierto para quienes deseen modificarlo de
acuerdo con la Licencia Pblica General de GNU Opening Service, llamada
comnmente GPL de GNU1.
1

GNU Operating System [en lnea]. < http://www.gnu.org/licenses/quick-guide-gplv3.html > [citado en

06/04/11 de 2011]

1. PLANTEAMIENTO DEL PROBLEMA

1.1.

ANTECEDENTES

La visualizacin de la msica puede rastrearse desde las primeras intenciones del

hombre de plasmar con grafismos su estructura. La manera fundamental de
visualizar la msica es la propia escritura musical y una parte de la paleografa
(ciencia que estudia las escrituras antiguas) que se centra en la escritura musical,
se refiere a la notacin, del latn notatione-notationis, que se refiere a la
representacin de la msica por medio de signos convencionales. Draffkorn-Kilmer
encontr una tablilla datada hacia el 1500 a.C. que habla del Himno a la Creacin;
en Grecia el fragmento ms antiguo es un papiro que contiene un pasaje coral de
una comedia de Orestes. s. I a.C. Siglos ms tarde aparecen las notaciones
neumticas latinas como una manera ms evolucionada de visualizacin de la
msica, que relativamente aparece entre el s. VIII y el s. IX, junto con el uso de
puntos o marcas, donde cada uno de esos puntos representa una nota.
Posteriormente hacia el s. X en la notacin diastemtica los neumas estn
cuidadosamente situados distancindose segn su altura en relacin a una lnea;
despus aparece la notacin cuadrada y para el s. XI al s. XII se puede decir que
aparece la notacin polifnica primitiva y la idea de tono y semitono. Este sistema
funciona con tetracordos pero que no parten del de abajo sino del central
(re,mi,fa,sol)2.

En el s. XI aproximadamente entre los aos 992 al 1050, el monje benedictino

Guido de Arezzo desarrollo de la notacin absoluta de las alturas (en la que cada
nota ocupa una posicin en la pauta de acuerdo con la nota deseada), fue el
idealizador del solfeo, sistema de enseanza que permite al estudiante cantar los
2

HISTORIA DE LA NOTACIN: Dra. Beatriz Montes [en lnea].

<http://www.juntadeandalucia.es/averroes/iesmateoaleman/musica/lenguajemusica0l.htm > [citado en 07-042011]:

nombres de las notas, los nombres fueron sacados de las primeras slabas
iniciales de un Himno a San Juan Bautista, llamado Ut queant Laxis, escritas por el
historiador lombardo Pablo el Dicono, en el Siglo VIII. Posteriormente, en el siglo
XVII, Giovanni Battista Doni sustituy la nota ut por do, que facilitaba el solfeo por
terminar en vocal y creando as el sistema de notacin con pautas de cinco lneas
que se convirti en el patrn para toda la msica occidental mantenindose as
hasta el da de hoy3.
Ut queant laxis

Para que puedan

Resonare fibris

Con toda su voz

Mira gestorum

Cantar tus maravillosas

Famuli tuorum

Hazaas estos tus siervos,

Solve polluti

Deshaz el reato de

Labii reatum

Nuestros manchados labios

Sancte Ioannes

Oh, bendito San Juan!4

Otro de los grandes hechos que contribuyen a la visualizacin de la msica es la

pera, obra teatral cuyo texto se canta, total o parcialmente, con acompaamiento
de orquesta5 y que aparece entre las dcadas de 1570 y 1580, desarrollado por
artistas y profesores llamados la Camerata Florentina en torno al conde Giovanni
Bardicon con el fin de dar vida nuevamente al arte dramtico de la antigua
Grecia6.

La historia de los primeros pasos de sincronizacin de la imagen y el sonido,

aparece en el cine sonoro. Los hermanos Lumire, en 1897, contrataron un
cuarteto de saxofones para que acompaase a sus sesiones de cinematgrafo en
su local de Pars y hubo compositores de vala, como Saint-Sans que
3

Ibd. (HISTORIA DE LA NOTACIN: Dr. Beatriz Montes [en lnea]).

Lloyd Ultan: Music theory: problems and practices in the Middle Ages and Renaissance (pag 32)
5
Diccionario De La Lengua Espaola RAE [en lnea].
>http://buscon.rae.es/draeI/SrvltConsulta?TIPO_BUS=3&LEMA=cultura > [citado en 07-04-2011]
6
Historia de la pera desde sus orgenes hasta los Musicales: Rojas Zeledn Ivette [en lnea].
<http://www.filomusica.com/opera.html> [citado en 07-04-2011]
4

compusieron partituras para acompaar la proyeccin de una pelcula. En 1877

usando el fongrafo y el cinematgrafo y gracias a los inventos de Thomas Alba
Edison, se echan las bases de la sincronizacin imagen-audio. En el ao 1893, el
fsico francs Dmeny invent lo que se llam fotografa parlante y en 1922 Jo
Engel, Hans Vogt y Joseph Massole presentan el primer film, Der branstifer
incorporando las aportaciones del ingeniero norteamericano Lee de Forest, dando
lugar al Movietone, entonces Lee de Forest presenta su invento llamado Phonofilm
que grababa el audio encima de la pelcula. Nuevamente Lee de Forest en 1926,
por medio de la Warner Brothers, logra un producto mejorado llamado el
Vitaphone de sincronizacin disco-imagen con la que graba una pieza interpretada
por la New York Philarmonic Orchestra, una pieza de violn tocada por Mischa
Elman, una audicin de la cantante Anna Case y la pelcula de Alan Crosland, Don
Juan. Finalmente Iwan Serrurier en 1924 crea la Moviola como una gran
innovacin en la edicin de pelculas en film7.

La imagen construida a partir de la msica puede hallar una referencia directa en

la pelcula Fantasa De Walt Disney en 1940. Su caracterstica principal es que
se trata de una animacin con msica acadmica y casi no hay dilogos. Fue
grabada bajo la direccin de Leopold Stokowski y siete de las ocho piezas fueron
interpretadas por la Orquesta de Filadelfia. El arte animado posee diferentes
grados de abstraccin o de la literalidad utilizada con el fin de ilustrar y acompaar
el concierto de varias formas visuales8.

Tambin como antecedente existe el Videoarte que naci con la creacin

magnetoscopio portapack- que Sony enva a EE.UU., a Nueva York
concretamente, y que compra el msico Nam June Paik y que dio lugar a un
extenso conjunto de acciones y tipos de obras artsticas entre las que se
encuentran las videoinstalaciones, las videoperformances, los videoambientes y
7

Enrique Martnez-Salanova Snchez: EL Cine Sonoro [en lnea].

<http://www.uhu.es/cine.educacion/cineyeducacion/cinesonoro.htm > [citado en 07-04-2011]
8
Tomlinson Holman: Surround Sound Up And Runnig (pag 4, 16)

las videoesculturas. Durante los primeros aos del vdeo se produjo una frecuente
y fructfera colaboracin entre los artistas de la msica y los artistas de la imagen.
Paik proceda de la msica electrnica y John Cage era, a travs de Paik, el
msico de vanguardia que ms cerca estuvo de la creacin videogrfica. Por su
parte, Gary Hill investig las relaciones entre sonido e imagen hasta conseguir
visualizar sus vibraciones y reproducir la estructura de la materia sonora en la
gama de grises de la imagen en blanco y negro, como sucede en Elements
(1978), Sums & Differences (1978) y Soundings (1979). Consigue, en esta ltima
cinta, convertir el sonido en movimientos y sensaciones tctiles, a travs de las
imgenes del altavoz que modifica los materiales con los que entra en contacto9.

Un fuerte referente nace en 1989 donde Wayne Lytle funda la Animusic con el fin
de animar la msica de instrumentos. Este artista ha ganado premios y se ha
presentado en diversos contextos electro-acsticos a nivel mundial. En 1991 Lytle
recibi un premio de IBM para su primer trabajo en la animacin de la msica. En
1995 Lytle trabaj con el artista David Crognale, creando una animacin
estereoscpica para VRex, la premiada versin llamada Concierto en 3D, y la
versin normal llamada Ms all de los Muros, despus public

Animusic:

Special Edition en DVD con sonido envolvente 5.1, despus public Animusic 2
y ya anunci la publicacin de Animusic 3.10 Sin embargo las visualizaciones en
tiempo real a partir de una seal solo se dan cuando aparecen los reproductores
de audio en los computadores personales. Es as como en 1985 con un software
llamado Sound to Light Generator, muy usando para mediados y finales de los
noventas, se implementaron programas como Winamp, Audion, y el SoundJam.
Luego aparece Cthugha en 1994 para DOS y despus, en 1999, ya haba varias
docenas de software que se distribuan libremente para la visualizacin musical.
En particular el MiljDrop creado por Ryan Geiss, G-Force por Andy O'Meara, y
Advanced Visualization Studio (AVS) por Nullsoft, fueron grandes visualizadores
9

Dra. Ana Mara Sedeo Valdells: Artculo publicado en Julio del 2007 en la revista n 0004 de Sinfona
Virtual, Espaa (pag 4).
10
Animusic: (pgina oficial) [en lnea]. <http://www.animusic.com/> [citado en 07-04-2011]

de msica, AVS ahora es parte de Winamp y public su cdigo fuente para libres
desarrollos (open-sourced); G-Force un producto de la compaa de Andy
O'Meara (creadora del SoundSpectrum), fue aprobada para su uso en iTunes, y en
Windows Media Player11.

Otras opciones que han crecido con el pasar de los tiempos son software que se
utilizan para mezclar videos en tiempo real, fenmeno al que se le ha llamado
videojockey o VJ y que consiste en la actividad de proyectar visuales sobre la
performance musical de un discjockey;

su antecedente originario est en la

Factory de Andy Warhol, donde haba personajes que sincronizaban imgenes

proyectadas como fondo a las bandas que tocaban all. Otros maestros son Lucky
People Centre o Exploding Cinema. Ms tarde, en los ochenta, se da el auge de
ciertas bandas y artistas como Kevin Godley & Lol Creme y sus videoclips y el
fenmeno de la msica dance. Su desarrollo se ha acelerado desde la aparicin
de ciertas condiciones tecnolgicas que han ampliado el nmero de posibilidades
y han hecho ms accesible el acceso a esta actividad12.

Finalmente quien ms se ha acercado al propsito de generar imgenes a partir

de la msica como apreciacin musical en tiempo real es el mencionado Stephen
Anthony Malinowski, quien en 1981 decide escribir un programa mediante una
maquina llamada ATARI 800 (BASIC, FORTH, 6502 Assembler); en 1983 con la
aparicin de MIDI Malinowski fue puliendo cada vez ms su proyecto hasta lograr
la Music Animation Machine que existe hoy en da13.

11

PRIETO, Daro: Imgenes de recorta y pega: Msica de colores en La Luna del Siglo XX, n. 230, 11 de
julio de 2003
12
Dra. Ana Mara Sedeo Valdells: Artculo publicado en Julio del 2007 en la revista n 0004 de Sinfona
Virtual, Espaa.
13
Music Animation Machine (pgina official) [en linea]. <http://www.musanim.com/mam/mamhist.htm >
[citado en 16/10/09 de 2009]

1.2.

DESCRIPCIN Y FORMULACIN DEL PROBLEMA

A lo largo de la historia el ser humano busc visualizar la msica y representarla

de forma grfica, desde la primitiva notacin musical, pasando por el arte
opertico y el cine, hasta las ltimas interfaces digitales; de tal manera que, cada
vez ms, los ltimos desarrollos tecnolgicos e industriales han logrado traducir la
creacin auditiva en una creacin visual que corresponda con el sentido del arte
musical. Sin embargo, a pesar de los numerosos intentos de representar la msica
visualmente, no se ha aprovechado suficientemente las nuevas tecnologas
digitales para convertir la informacin musical en un lenguaje grfico coherente
con su estructura terica en tiempo real y en aplicar estos logros a la enseanza
musical. An no se ha desarrollado, a travs de la ingeniera, un algoritmo que
permita transformar la msica, mediante el protocolo MIDI, en rdenes que
vayan dirigidas a la animacin de un entorno grfico, creando, mediante la
programacin, una interfaz grfica que enlace los programas necesarios para tal
propsito, brindando la posibilidad de interactuar con el usuario. Por ello surge la
siguiente pregunta:

Cmo disear un sistema que permita relacionar la teora musical y la expresin

grfica con el fin de crear un mtodo dirigido hacia la enseanza de la apreciacin
musical utilizando software libre?

1.3.

JUSTIFICACIN

El ingeniero de sonido puede aliar la parte ingenieril con la parte artstica. Este
Proyecto toma en cuenta factores artsticos que son posibles de analizar a travs
de la abstraccin y los conocimientos de carcter ingenieril, con el propsito de
crear algoritmos que logren la transformacin de la informacin musical en
imgenes coherentes y sincrnicas. Por esta razn, la ingeniera de sonido es un
campo propicio para la creacin de este tipo de interfaz.

La importancia de este trabajo radica en presentar a las personas interesadas una

experiencia que pueda caber en la categora de sinestesia14 consistente en lograr
ver la msica, mediante el uso del software libre y la programacin,
desarrollando un sistema que pueda analizar la msica de una secuencia MIDI y
generar rdenes enviadas hacia una animacin, para que sta se ejecute en
tiempo real. Se proyecta, as, un enlace entre la imagen y la msica con miras a
instrumentar la enseanza de la apreciacin musical, para que las personas
puedan entender la msica, no como un complejo tonal, es decir, una mezcla de
sonidos en presente, sino enmarcada en un espacio visual, temporalmente ms
tranquilo y con ms oportunidades didcticas. As mismo este Proyecto es una
aproximacin al aprendizaje de la comprensin terico-musical de quienes, al
visualizar la msica , podrn ver su arquitectura y establecer una relacin entre
varios parmetros musicales como tonalidad, altura, ritmo, escalas, acordes,
intensidad, consonancia, disonancia y parte de las funciones armnicas, as como
un acercamiento a la polifona.
Para visualizar la msica usando las nuevas tecnologas de la computacin, es
necesario cumplir con varias etapas como, primero, establecer el enlace en tiempo
real de un lenguaje de programacin con un secuenciador de eventos MIDI y un
motor de animacin dispuesto a actuar mediante rdenes; segundo, realizar el
14

SYNAESTHESIA.COM: [en lnea]. < http://www.synaesthesia.com/ > [citado en 17/04/04 de 2011]

anlisis de secuencias MIDI a travs de un lenguaje de programacin basado en

la teora musical, para generar ordenes de animacin; tercero, crear la relacin
entre msica y lenguaje visual frente a los distintos conceptos tericos tanto de la
msica como del lenguaje grfico, para aplicarla a los elementos extrados de una
secuencia MIDI; cuarto, disear la animacin; y

quinto, disear una interfaz

grafica capaz de reunir y acoplar todos los elementos descritos en las etapas
anteriores.

Algunas de estas etapas han llegado a ser grandes proyectos de la teora del arte
como los de Alexander Scriabin, Olivier Messiaen15 y Vassily Kandinsky16, que
establecieron la relacin entre la msica y el color; en el campo de la
programacin, los que establecieron la comunicacin entre distintos programas
para que funcionen en tiempo real como el OSC (Open Sound Control); o el
proyecto de la pianista Carmen Paz17, que relaciona nuevamente los colores y la
msica tratando de crear su propia sinestesia; o el proyecto Audiogames18 que
consiste en crear un espacio sonificado interactivo en donde la etapa de
sincronizacin es vital para su desarrollo. As pues, apoyar efectivamente la
composicin o la enseanza de la apreciacin musical, por medio de un programa,
es un trabajo bastante amplio que requerir el trabajo de diferentes disciplinas
como la ingeniera de sistemas, la msica, el diseo grfico aplicado a la
multimedia, entre otras. Por eso este proyecto es una aproximacin dirigida a la
enseanza de la apreciacin musical buscando caminos para desarrollar todas las
etapas y dejando este conocimiento para su posterior contribucin proyectndose
en el campo de la visualizacin musical.
15

LOS COLORES, VEO LA MSICA. EL COMPOSITOR SINESTSICO OLIVIER MESSIAEN: Prez

Navarro, Daniel [en lnea]. < http://www.filomusica.com/filo48/sinestesia.html > [citado en 17/04/04 de
2011]
16
DE LO ESPIRITUAL EN EL ARTE: Kandinsky, Vassily (1952).
17

COLORES/PROYECTO

DE

FINAL

DE

CARRERA:

Carmen

Paz

[en

lnea].

<http://carmenpaz.lacoctelera.net/categoria/colores-proyecto-final> [citado en 17/04/04 de 2011].

18

AUDIOGAMES: [en lnea]. < http://wiki.medialab-prado.es/index.php/Audiogames> [citado en 17/04/04 de

2011]

Hay una gran variedad de formas de representar la msica visualmente, que van
desde las comunes visualizaciones que usan los reproductores de multimedia, o
los programas que mezclan loops de videos e imgenes y que son usados por
los software llamados VideoJockeys (VJ), como el Arkaos VJ o el Resolume VJ,
entre muchos otros; hasta las animaciones diseadas para la msica, como las
msic machines, que construyen imgenes que corresponden a la msica. El
referente csico es la pelcula Fantasa de Walt Disney. Pero son muy pocos los
que realmente se interesan por representar la estructura terica musical, como lo
hace la Music Animation Machine. El propsito de este proyecto es ir ms all,
con una interfaz grfica que convierta la estructura musical en un lenguaje grfico
coherente y sincrnico que pueda llegar a establecer una fuerte relacin entre la
msica y la imagen, teniendo en cuenta que las interfaces en tiempo real que
permiten al usuario ver cierta correspondencia entre la msica y lo visual, son an
aplicaciones bsicas y sin el componente didcticos.

Se hace uso del protocolo MIDI, porque es el protocolo en que est escrita la
msica en el lenguaje de digital; por lo tanto es la forma ms directa de manipular
la informacin musical en el entorno de las nuevas tecnologas de la informacin y
de la comunicacin.

Este proyecto ha sido completamente factible porque se cuenta con recursos

tericos de programacin, adems de que el software utilizado es libre, gratuito,
amplio y abierto para realizar ste tipo de proyectos y no se requiere ms recursos
que el computador personal e Internet.

1.4.

OBJETIVOS DE LA INVESTIGACIN

1.4.1. OBJETIVO GENERAL

Crear un sistema que genere animacin a partir de secuencias musicales MIDI

como la base para crear una herramienta dirigida hacia la enseanza de la
apreciacin musical, utilizando software libre.

1.4.2. OBJETIVOS ESPECFICOS

Transformar y analizar el protocolo MIDI a travs de un lenguaje de

programacin, para convertir la informacin en rdenes de entorno grfico.

Estructurar los parmetros que permitan relacionar la msica con la animacin

grfica a travs del protocolo MIDI usando un entorno de desarrollo de
programacin como Pure Data.

Desarrollar una interfaz grfica que permita al usuario interactuar enlazando las
herramientas visuales con el protocolo MIDI.

1.5.

ALCANCES Y LIMITACIONES DEL PROYECTO

1.5.1. ALCANCES

Crear un sistema suficientemente amplio que apoye la composicin y enseanza

de la apreciacin musical, de tal manera que pueda abarcar aspectos
fundamentales de la estructura musical como las funciones armnicas y las formas
musicales, logrando de esta manera un programa de anlisis musical exhaustivo y
profundo.

Instrumentar el desarrollo de imgenes animadas en Blender, dotndolas de una

narrativa acorde con el anlisis y adems de caractersticas visuales de la
animacin en 3D, incluso haciendo uso de estereoscopa. Este anlisis se puede
lograr implementando el cdigo de Python en el motor de juegos Blender Game
Engin.

El Proyecto podra convertirse en un objeto de estudio e investigacin para

disciplinas como la musicologa, la psicologa, la educacin y la msica. Puede
utilizarse como un recurso para las personas con limitaciones auditivas para que
puedan llegar a visualizar imgenes que representan la msica.

Lograr un espacio interactivo entre msica y lenguaje visual en tiempo real, en el

que la animacin acompaa al intrprete a travs de la obra.

Desarrollar una herramienta que permita manipular los parmetros de la imagen

de forma interactiva y tener la posibilidad de desarrollar animaciones, por ejemplo,
un programa inteligente que aprenda la estructura musical y que, al volver a repetir
la pieza, le agregue ms formas a la animacin, pidiendo al usuario confirmacin
entre los pasos de repeticin.

Usar este sistema como una herramienta para el aprendizaje musical y para la
composicin musical.

Usar el programa en otras plataformas como Linux y Macintosh.

Lograr, a travs de la automatizacin de objetos animados en Pure Data, controlar

loops de video, luces, mquinas en tiempo real o tambin a partir del anlisis de
una secuencia musical MIDI.

1.5.2. LIMITACIONES

Pure Data es una herramienta poderosa con variadas aplicaciones, pero presenta
dificultad al no disponer de una herramienta directa para programar objetos de una
manera simple, utilizando condicionales, ciclos o vectores, como en la
programacin convencional, a menos que se desee entender el cdigo fuente y
desarrollar la aplicacin (objeto) que se necesita.

2. METODOLOGA

Para el desarrollo del sistema se ha creado una estructura metodolgica que

desglosa cada una de las etapas de la siguiente manera:

Generar un protocolo de informacin que haga uso de la secuencia MIDI

para que Pure Data sea capaz de enviar informacin MIDI hacia un
instrumento virtual, en tiempo real.

Generar un programa para que el software de animacin GEM entienda la

informacin recibida y la ejecute en tiempo real.

Crear un lenguaje visual sencillo para representar varios elementos de la

estructura musical.

Crear la comunicacin necesaria para que Pure Data entienda las rdenes
generadas por el programa de anlisis y genere la animacin.

Hacer una interfaz grfica que permita manipular y enlazar los programas
que deben ser usados.

Para ste proyecto se ha escogido el contrapunto, que es una rama de la teora

musical que estudia la composicin de msica polifnica, mediante el enlace de
dos o ms melodas. Sin embargo, como este campo es bastante amplio en toda
la msica acadmica y sera muy ambicioso cubrir todo el contrapunto, se han
escogido las Invenciones y Sinfonas BWV 772-801, de Johann Sebastian Bach,
que son 30 breves piezas para piano, que sirven tradicionalmente al aprendizaje
del contrapunto y que tuvieron el fin de ensear al hijo del compositor; Friedman,

la polifona19. Las Invenciones son 15 piezas a dos voces y las Sinfonas son 15
piezas a tres voces. Bach, al componerlas, us las escalas ms sencillas,
haciendo un pequeo clave bien temperado didctico para sus hijos 20. Luego se
tomaron los dos libros de El Clave Bien Temperado BWV 846-869 y BWV 870893, que son un conjunto grande de partituras usadas para el estudio de la
interpretacin polifnica, como tambin un referente cumbre para el estudio de la
forma musical del periodo barroco en cuanto al preludio y la fuga 21. Cada libro
posee 24 grupos constituidos por un preludio y una fuga en todas las tonalidades
mayores y menores de la gama cromtica completando toda la escala cromtica
de mayor a menor. Es, por tanto, una coleccin enorme que comprende 48
preludios y 48 fugas cuyo contenido es a la vez musical, terico y didctico.22

Este trabajo est inicialmente dirigido hacia nios que ya tengan conocimientos
musicales y nociones de armona y contrapunto23, as como tambin a jvenes que
tengan la capacidad o estn cerca de interpretar las obras de El Clave Bien
Temperado. Entonces, la interfaz mostrar a los usuarios, por medio de dos
canales de comunicacin: auditivo y visual, la forma cmo la msica ha sido
escrita y estudiada, con lo cual las obras podrn ser entendidas mucho ms
didcticamente, introducindolos en el significado y las estructuras en las cuales
se escribieron.

19

Klaus Eidam: La verdadera vida de Johann Sebastian Bach (pag 117)

BACH, J. S.: Inventions & Sinfonies BWV 772-801.
21
Clave bien temperado, Enciclopedia Microsoft Encarta 2009
22
Rosen, Charles: Bach y Hndel, La Msica para Teclado (Keyboard Music) (pag 26)
23
Dr. H. Riemann: Analysis of J. S. Bachs Wohltemperirtes Clavier (pag 11)
20

2.1.

DIAGRAMA DE FLUJO

Ilustracin 1: Diagrama de flujo general del sistema

Se escoge a Python 2.7 como lenguaje de programacin por la compatibilidad que

existe con los programas que se quieren controlar, adems, el uso de su sintaxis
es amable con el usuario y tambin porque uno de los alcances de este proyecto
es implementar el cdigo desarrollado en Blender. La estructura del cdigo del
sistema est dada por programacin orientada a objetos con el fin de facilitar el
uso de cada uno del los sub programas que se van a desarrollar.

Los archivos MIDI con extensiones *.mid o *.midi son archivos que se encuentran
almacenados en formato binario y para su lectura se us el programa gratuito
MIDICSV, que toma el archivo y lo transforma en una lista de eventos con el

formato CSV (valores separados por comas). Es un tipo de programa denominado

parsing (analizador). Luego, haciendo uso de Python, se analiza la secuencia MIDI
entrante, ejecutando MIDICSV y capturando su resultado en un archivo de texto.
Nuevamente con Python se toma la lista de eventos en texto y se procesa filtrando
los valores relevantes para ser guardados en variables de tipo listas (matrices); los
datos de inters hallados en el protocolo MIDI son la informacin relacionada a la
parte musical.

En algunos archivos MIDI la msica aparece dispersa en diferentes tracks,

entonces se resuelve unir todos los canales un uno solo ya que este proyecto est
limitado a piezas para piano. Otra caracterstica importante que debe tener en
cuenta para el anlisis, es la organizacin de los eventos de menor a mayor en
cuanto a duracin y las notas tambin de menor a mayor, cuando son
simultneas, puesto que en una secuencia dichas notas suelen aparecer
dispersas. Cabe decir que este tipo de organizacin de la informacin digital no
altera la obra musical. Una vez obtenida la informacin dentro de listas en Python,
se debe crear un programa para descifrar la informacin guardada y crear archivos
MIDI de prueba para experimentar los procesos que se van elaborando. Como se
va a analizar un flujo de informacin, los valores resultantes deben ser de fcil
manipulacin, para ello se crean programas que establecen relaciones numricas
ms cmodas para su entendimiento.

Otro proceso importante es definir la duracin de las notas en una secuencia por
su valor individual y no por el orden de activacin y desactivacin referido a toda la
secuencia, como un tiempo marcado con cronmetro (time). Para poder analizar la
msica no basta con tener una lista de eventos MIDI. Se opta por crear un mtodo
para poder visualizar la msica dentro de los eventos; para ello hay que filtrar
nuevamente la informacin despreciando las notas de apagado y tomando las
notas de encendido. Como las notas simultneas vienen una detrs de otra, es
necesario poder verlas al tiempo, como en una partitura, as las notas simultneas

pueden ser visualizadas verticalmente de una manera armnica. Entonces se

puede crear una matriz concatenada para que las notas que suceden al mismo
tiempo sean guardadas en un mismo vector por el tiempo o duracin al que
corresponde y as visualizar la msica de una manera similar a una partitura.

Tericamente en un archivo MIDI, para saber a qu tonalidad pertenece una

secuencia, se utiliza el evento KEY_SIGNATURE, pero no todos los archivos MIDI
poseen este evento. Se debe crear un mtodo para encontrar la tonalidad y
establecer diccionarios acordes con la informacin pertinente, como los grados de
la escala y, dependiendo de si es mayor o menor, agregarle las alteraciones
correspondientes a los eventos para volver a analizar la secuencia, logrando el
verdadero nombre de las notas y de las alteraciones. Ms adelante se establecen
las notas importantes de acuerdo con las funciones armnicas, as como las
triadas en la secuencia, logrando deducirlas aunque estn invertidas.

La documentacin de Pure Data respecto a Qlist no es suficiente para su uso, por

lo tanto hay que deducir cul es el proceso para lograr leer cada evento y
comunicrselo a la funcin que enva la informacin MIDI al sintetizador. Una vez
es encontrada la manera de utilizar esta herramienta se va a utilizar no solo como
un comunicador de eventos MIDI sino tambin como un receptor de otras
informaciones tiles para generar ordenes a la animacin.

La animacin debe tener relacin con la msica en diferentes aspectos, los

objetos a representar como notas son esferas, el primer aspecto musical a
representar ser la altura dada por los valores de nota, entonces las esferas se
desplazarn de acuerdo a una relacin matemtica en el eje horizontal, al activar
una nota la esfera va a encenderse y rebotar, la velocidad de nota define su
desplazamiento en el eje z es decir que a medida que aumenta la intensidad del
sonido, las esferas se irn acercando y si la intensidad es suave las esferas se
desplazarn hacia atrs, en el caso de que hayan notas simultaneas, habrn ms

esferas una detrs de otra representando las notas segunda, tercera, cuarta etc.
las esferas pueden tener un rastro que visualmente refiera a sta y de donde a
donde se est desplazando; por ltimo las esferas van a adquirir un color y ste va
a depender de la relacin que se establecer entre la msica y la imagen.

2.2.

HIPTESIS

Utilizando software libre, disear un sistema que permita relacionar la teora

musical y la expresin grfica con el fin de crear un mtodo dirigido hacia la
enseanza de la apreciacin musical.

3. NUCLEOS PROBLMICOS / LNEA DE INVESTIGACIN DE LA

FACULTAD / LNEA DE INVESTIGACIN DE LA UNIVERSIDAD

3.1.

NCLEOS PROBLMICOS

Este proyecto est desarrollado dentro del ncleo de Anlisis y Procesamiento de

Seales, ya que el sistema consiste en tomar una seal lineal (informacin MIDI
en cdigo binario) y transformarla en una seal bidimensional (imagen) que vara
en el tiempo. En detalle, se est diseando una herramienta mediante la
programacin que, vinculando varios software, logra crear un mtodo de anlisis
para el protocolo MIDI, que a su vez genera informacin necesaria para que un
software de animacin acte respecto de dicho anlisis. Todo es controlado por
una interfaz grfica que enlaza la herramienta de anlisis con el software que
genera la animacin y un secuenciador MIDI.

3.2.

LNEA DE INVESTIGACIN DE LA FACULTAD

Este proyecto que, como ya se mencion, se desarrolla dentro del campo de

Anlisis y Procesamiento de Seales (APS), busca, a travs de los mtodos y la

conceptualizacin del campo de la ingeniera de sonido, instrumentar el desarrollo

de nuevas tecnologas encaminadas al apoyo de la composicin y la enseanza
de la apreciacin musical, creando un sistema novedoso de automatizacin de la
animacin, mediante la construccin, anlisis y enlace de programas, a partir de la
informacin musical encontrada en el protocolo MIDI.

3.3.

LNEA DE INVESTIGACIN DE LA UNIVERSIDAD

Dentro de las lneas de investigacin de la Universidad de San Buenaventura y de

acuerdo con el Consejo de Investigacin Bonaventuriano (CIB), ste proyecto se
inscribe en la lnea Tecnologas actuales y sociedad, ya que busca desarrollar
una interfaz interactiva, a travs de la actualizacin constante de los
conocimientos tecnolgicos y por medio de software libre, relacionando de una
forma directa la estructura y la teora musical con un lenguaje visual sincrnico,
generando animaciones, para el apoyo y desarrollo de la composicin y de la
apreciacin musical, facilitando la enseanza del contrapunto musical y
contribuyendo al desarrollo de la educacin musical en la sociedad.

4. MARCO DE REFERENCIA

En este captulo se va a dar una mirada global de las herramientas importantes

para el desarrollo que has sido necesarias para la creacin del sistema.

4.1.

MARCO TERICO CONCEPTUAL

4.1.1. PYTHON

Python es un lenguaje de programacin de alto nivel de sintaxis limpia, cdigo

legible y abierto; fue escogido para la generacin del programa y lo tanto es

importante conocer algunas de sus propiedades y de las estructuras que pueden

llegar a ser indispensables para la creacin del sistema.
La primera propiedad a considerar son las funciones24 que son un fragmento de
cdigo con un nombre que le identifica y que realiza una serie de tareas para
devolver un valor. Si no devuelven un valor se le llaman procedimientos.25 Las
funciones se elaboran en innumerables programas para analizar la informacin,
hay bastantes ejemplos que pueden ser encontrados en Internet y en libros gratis
subidos en la red. Las funciones son la base para la programacin orientada a
objetos donde se utilizarn las clases y los objetos. Un objeto es una entidad que
agrupa un estado y una funcionalidad relacionados. El estado del objeto se define
a travs de variables llamadas atributos, mientras que la funcionalidad se modela
a travs de funciones a las que se les conoce con el nombre de mtodos del
objeto. Una clase, es una plantilla con la que se organiza los objetos, en esta
plantilla se definen los atributos y mtodos que tendrn los objetos.26

Muchos de los procesos que se van a realizar, se hacen usando listas que son
vectores dentro de Python, una variable en donde se pueden almacenar varios
datos de una sola vez; para lo cual hay que tener en cuenta las propiedades27,
tiles para el manejo de listas como el mtodo para definirlas, citar rpidamente su
informacin usando atajos, aadir o quitar elementos, buscar dentro de una lista y
usar listas concatenadas. Otro elemento vital son los diccionarios, que definen una
relacin uno a uno entre claves y valores tiles para citar rpidamente informacin
o generar, mediante la clave, valores correspondientes en grandes procesos como
introducir el valor de nota MIDI, obtener su nombre y su octava. Tambin tiene
propiedades como definir un diccionario, mezcla de tipos de datos en un
diccionario, eliminacin de elementos de un diccionario.
24

Francisco Callejo Gimnez: Inmersin en PYTHON (pag 3)

Ral Gonzlez Duque: PYTHON para Todos: (pag 36)
26
PYTHON Para Todos: Ral Gonzlez Duque: (pag 42)
27
Francisco Callejo Gimnez: Inmersin en PYTHON (pag 9-12)
25

Tambin se hace necesario manipular la informacin entre los directorios de

trabajo. Generalmente cuando se empieza a trabajar en Python el directorio en el
que se est trabajando es el mismo donde se est guardando el proyecto, pero
tambin se puede cambiar este directorio, o generar archivos en un lugar y luego
pasar a otro donde tambin se van a crear archivos. Por ltimo una de las
aplicaciones importantes de Python para el proyecto, es que logra ejecutar un
programa abriendo un archivo creado en el mismo programa y al finalizar el
proceso cerrarlo.

4.1.2. TKINTER

El mdulo Tkinter (Tk) es la interfaz estndar de Python con un gran conjunto de

herramientas GUI. Tkinter est disponible en la mayora de plataformas Unix, as
como en los sistemas Windows y Macintosh. Tkinter consiste en una serie de
mdulos. La interfaz Tk se encuentra en un mdulo binario denominado _tkinter,
este mdulo contiene la interfaz de bajo nivel de Tk; Tkinter que incluye una serie
amplia de mdulos de Python.

Para la organizacin de el flujo de eventos, se va a utilizar el mtodo de

ordenamiento por sacudida28 que es una optimizacin del mtodo de intercambio
directo o burbuja; en este algoritmo cada pasada tiene dos etapas: de derecha a
izquierda se trasladan los elementos ms pequeos hacia la parte izquierda del
arreglo, en la segunda etapa de izquierda a derecha se trasladan los elementos
ms grandes hacia la parte derecha del arreglo, el algoritmo termina cuando en
una etapa no se producen intercambios.

4.1.3. MIDICSV
28

Estudiantes de la UTN-FRSF: Tutorial-PYTHON.com.ar (http://tutorial-PYTHON.com.ar/?p=67 vista el

09/04/11)

Entre las herramientas externas que se van a utilizar esta MIDICSV29 que es un
programa con el que se toma un archivo MIDI y lo transforma en una lista de
eventos con el formato CSV (valores separados por comas) cuyas siglas
provienen de Comma Separated Values. A este tipo de programas se le llaman
parsing (analizador). Al pedirle a MIDICSV que analice un archivo, ste va a
generar una lista sujeta a una estructura de registro la cual indica cada uno de los
eventos que el archivo tiene, dentro de esta los parmetros que se van a utilizar
son 0, 0, HEADER, FORMAT, NTRACKS, DIVISIN que es el registro de
cabecera del archivo MIDI, TRACK, TIME, TIME_SIGNATURE, NUM, DENOM,
CLICK, NOTESQ El comps, la tasa de clic del metrnomo, el TRACK, TIME,
KEY_SIGNATURE, KEY, MAJOR/MINOR, donde especifica el valor numrico de
la clave, mayor / menor TRACK, TIME, TEMPO, NUMBER que contiene el tempo
y los eventos de activacin de nota TRACK, TIME, NOTE_ON_C, CHANNEL,
NOTE,
4.1.4. COMUNICACIN OPEN SOUND CONTROL

Hay comunicaciones que no se pueden lograr directamente y por esto se va a usar

Open Sound Control (OSC) que es un protocolo para la comunicacin entre
sistemas, computadores, sintetizadores y otros dispositivos multimedia optimizada
para la tecnologa de redes modernas. Este protocolo proporciona lo necesario
para el control en tiempo real de los medios de procesamiento de sonido y otros,
sin dejar de ser flexible y fcil de implementar30; Para enviar informacin desde
Python haciendo uso de OSC hay que tener la librera pyOSC31 Hallada en la
direccin http://opensoundcontrol.org/implementation/Python-simple-osc, luego tomar el
archivo OSC.py y guardarlo en el directorio de Python, en la carpeta Lib y la
subcarpeta site-packages, para este caso la direccin es C:\Python27\Lib\site29

Walker John: MIDICSV [en linea]. < http://www.fourmilab.ch/webtools/midicsv/ > [citado en 08-04-2011]
Open Sound Control: pgina oficial [en linea]<http://opensoundcontrol.org/introduction-osc >[ citado en
04-05-2011]
31
Librera OSC para PYTHON: pyOSC: [en linea]< https://trac.v2.nl/wiki/pyOSC>[ citado en 04-05-2011]
30

packages. Luego estructurar el envi de informacin por medio de este protocolo

(se encuentra ms en detalle en el apndice). Para recibir la informacin OSC en
Pure

Data

debe

tener

(http://puredata.info/community/projects/software)

la
que

versin
ya

cuenta

extendida
con

este

protocolo de comunicacin por defecto.

4.1.5. PURE DATA

La animacin y el secuenciador MIDI se van a trabajar con Pure Data (PD) que es
un entorno grfico de programacin en tiempo real diseado para aplicaciones de
audio, vdeo y procesamiento de grficos32, Pure Data cuenta con la ayuda que
gua a el usuario facilitando de gran manera el trabajo mediante ejemplos
mostrndole las posibilidades que tiene en cuanto a la programacin de cada
objeto, adicionalmente recomienda otros objetos relacionados con l mismo.

Una de las herramientas indispensables de Pure Data es Qlist que en realidad es

un secuenciador basado en texto, el objeto Qlist lee archivos de texto que
contienen mensajes en diferentes tiempos. Se tuvo que descubrir la manera en
que funciona ste protocolo ya que en el manual de Pd no se especifica de una
manera clara la forma de construir o usar una secuencia MIDI y si est tomada
de un archivo, interpretarla y enviarla a travs de los puertos de salida (MIDI) en
Pure Data. (En el apndice se encuentra dicha deduccin).

Para hacer uso del protocolo MIDI es necesario direccionar las entradas y salidas
en Pure Data, tambin hay que manejar la estructura para la entrada y salida de
informacin MIDI, se utilizara tambin el objeto acorde chord que va a ser til
para la ejecucin en tiempo real de la animacin con un controlador.

32

Pure Data: Pagina Oficial (www.puredata.org el 24/10/09)

La herramienta de animacin en Pure Data se llama Gem33 (Graphics Environment

for Multimedia) y es un entorno de programacin visual para generar, procesar y
manipular grficos (imgenes, vdeos, cmara) en tiempo real. Es una librera que
forma parte del entorno Pure Data. Para poder utilizar Gem hay que usar la
versin extendida de Pure Data.

4.1.6. MIDI

MIDI, un acrnimo de Musical Instrument Digital Interface. MIDI ha asumido

mltiples significados y puede referirse a una interfaz de hardware, a un formato
de archivo, a los datos en un archivo MIDI estndar, o a las especificaciones de
simulacin instrumental de General MIDI. La ubicuidad del trmino no
necesariamente corresponde a la uniformidad de procesos, ni a la capacidad de
intercambio de datos sin prdida alguna de informacin, ni a las solicitudes sin una
cierta limitacin de la capacidad.

MIDI se origin como un protocolo en tiempo real para permitir la comunicacin

entre los dispositivos de hardware independiente (por ejemplo, entre dos teclados
electrnicos, o entre un teclado electrnico y una computadora personal).
Concretamente, la intencin era hacer que la onda de sonido, frecuencia y la
duracin de presin de informacin obtenida para un controlador se interpretara a
travs diversos dispositivos. Lo primero fue identificar la duracin de tecla
presionada y luego grabar su encendido y apagado on and off durante ese
tiempo. La especificacin del protocolo se public en 1988 y est disponible sin
costo en muchas redes electrnicas y en los apndices de muchas referencias
estndar en MIDI. Como un hardware de interface, MIDI busca la forma de hacer
procesos en tiempo real, en el lenguaje MIDI, la msica consiste en una cadena
de eventos que suceden uno a la vez y momento a momento, procesos de flujos
33

Generacin Musical y Visual: GEM - Pure Data: [en line] < http://www.dtic.upf.edu/~csora/gmv/index.php
> [ citado en 04-05-2011]

de eventos que a veces deben estar en constante movimiento controlados por un

reloj34.

El Standard MIDI File (SMF) es un formato estandarizado para guardar

secuencias, o sea series ordenadas de eventos MIDI determinados en su
ubicacin temporal en trminos de compases y tiempos. Hay diversos tipos de
secuenciadores tanto de software como de hardware. Cada secuenciador tiene su
propio formato de secuencias y el MIDI File es una forma de guardar la
informacin bsica en un formato estandarizado para poder transferir y leer
archivos de un secuenciador a otro.

4.1.7. TEORA MUSICAL

Para analizar las piezas propuestas por ste proyecto (Invenciones y Sinfonas, y
el Clave Bien Temperado) se deber tener claro los conceptos de la teora
musical35 como: armaduras de clave, intervalos, las escalas, los tipos de escalas,
las triadas, los grados de las escalas y, en menor medida, las funciones
armnicas; con el fin de poder hacer anlisis armnico. Tambin es importante
entender aspectos como las texturas musicales de las sinfonas e invenciones de
J. S. Bach, as como qu es una invencin o qu es una sinfona, qu es el clave
bien temperado, donde se encuentran trminos como: preludio y fuga. Toda esta
informacin se encuentra en el apndice

4.1.8. SIGNIFICADO DE LA APRECIACIN MUSICAL

Apreciacin musical es un tipo de formacin musical destinado a desarrollar la
habilidad de escuchar inteligentemente la msica. El oyente aficionado a menudo
34

Eleanor Selfridge-Field Beyond: MIDI, The Handbook Of Musical Codes (pg. 43)
Alvira Rodrguez Jos: Teora Musical; Aprendizaje [en lnea]. <http://teoria.com/aprendizaje/lectura/15armaduras.htm> [citado en 29/10/09 de 2009]
35

ha demostrado una facultad analtica y crtica bastante igual a la de muchos

intrpretes profesionales, el arte de escuchar como una actividad del pensamiento
es el objetivo de los cursos de apreciacin, que puede ser tan exigente y tan
satisfactoria como la interpretacin. Para entender la msica, es importante
conocer los diferentes aspectos que la componen, desde su parte terica hasta la
misma historia; cmo el compositor hace uso de todos y cada uno de los
elementos que sta le brinda y cmo el escucha accede e interacta con ella.

La percepcin, la valoracin afectiva y la toma de conciencia intelectual de

cualquier producto artstico forman el tercer eslabn de la cadena al que en pocas
ocasiones, y menos an en el terreno musical se ha dedicado la debida atencin.
Tradicionalmente y hasta el momento actual, casi todo el tiempo y los recursos
empleados en la formacin musical se han dedicado a dos aspectos de evidente
importancia como son la creacin musical, aspecto centrado en la figura del
compositor y la interpretacin, centrada en la figura del intrprete, pero se ha
eludido, en cambio, la dedicacin necesaria a un tercer aspecto de trascendencia
ltima en cualquier manifestacin artstica: se est refiriendo a la apreciacin de la
obra, aspecto centrado en el oyente. Lgicamente toda persona que escucha se
convierte en un oyente. Pero hay muchas formas de escuchar, y en esto van a
intervenir factores tan importantes como la capacidad de atencin y la formacin
musical de quien escucha. Muchas personas tienen un gran conocimiento auditivo
de numerosas grandes obras de la msica, aunque no sepan leer ni interpretar
una partitura; en muchos casos, sus opiniones y sus gustos son excelentes, pero
no saben expresarlo con un lenguaje apropiado, lo que les puede producir una
sensacin de frustracin e inseguridad que les impida comunicar sus opiniones
ante los msicos.

As pues, la importancia de dotar al oyente de las herramientas precisas para la

captacin plena de las obras musicales, se constituye en una necesidad
cuantitativa, dada la superioridad numrica de los auditores frente a los

compositores e intrpretes, adems de constituir el tercero de los grandes mbitos

que como eslabones inseparables de una misma cadena completan el proceso
artstico: compositor, intrprete y oyente36.

4.1.9. LA IMAGEN

Para el desarrollo de la animacin es importante estudiar algo sobre la imagen, en

este caso, estudiar conceptos como la sintaxis de la imagen; la forma, la luz, la
sombra, la simbologa del color, los principios de la composicin (claridad,
contraste, armona); tambin temas como la semntica visual de la imagen, y
temas afines. Los detalles de esta informacin se encuentran en el apndice.

4.2.

MARCO LEGAL O NORMATIVO

Este proyecto est trabajando con software no privatizado y por ello es importante
distinguir entre los diversos tipos de licencias que pueden existir: La informacin
en detalle se encuentra en el apndice, donde se desarrollan conceptos como las
licencias de software libre, la definicin de software libre37, la licencia pblica
general de GNU, la licencia pblica general reducida de GNU, licencia pblica
general de affero de GNU, licencia de documentacin libre de GNU, copyleft38.

4.2.1. LICENCIA DE MIDICSV

Este software es de dominio pblico. Tiene el permiso para usar, copiar, modificar
y distribuir este software y su documentacin con cualquier propsito y sin cargo a
la presente se otorga, sin ningn tipo de condiciones o restricciones. Este software

36

Thomas Whitney Surette: The Appreciation of Music (pag 15)

GNU Operating System (http://www.gnu.org/philosophy/free-sw.es.html vista el 13/10/09)
38
GNU Operating System (http://www.gnu.org/licenses/licenses.es.html vista el 13/10/09)
37

se otorga sin ninguna garanta implcita o explcita39. Por John Walker, Febrero,
2004, Revisado Enero de 2008

4.2.2. LICENCIA DE Python Y TKINTER

La Python Software Foundation License, o PSFL por sus siglas en ingls, es una
licencia de software libre permisiva, al estilo de la licencia BSD, es decir, que
cumple con los requisitos OSI para ser declarada licencia de software libre;
adems, es compatible con la licencia GPL. A diferencia de la licencia GPL, y
como la mayora de licencias tipo BSD, la licencia PSFL no es una licencia
copyleft, y permite modificaciones del cdigo fuente, as como la creacin de
trabajos derivados, sin requerir que ni las modificaciones ni los trabajos derivados
tengan que ser a su vez de cdigo abierto. La licencia PSFL est dentro de las
listas de licencias aprobadas tanto por la Free Software Foundation como por la
Open Source Initiative.40
4.2.3. LICENCIA DE PURE DATA Y GEM41

Pd es un proyecto de cdigo abierto y tiene una gran base de desarrolladores

trabajando en nuevas extensiones al programa; est publicado bajo una licencia
similar a la licencia BSD. La licencia BSD es la licencia de software otorgada
principalmente para los sistemas BSD (Berkeley Software Distribution). Es una
licencia de software libre permisiva como la licencia de OpenSSL o la MIT License.
Esta licencia tiene menos restricciones en comparacin con otras como la GPL

39

John Walker : MIDICSV [en linea] < http://www.fourmilab.ch/webtools/midicsv/ > [ citado en 04-05-2011]
PYTHON 2.7 licencia: [en linea] < http://www.PYTHON.org/download/releases/2.7/license/> [ citado en
04-05-2011]
41
Pure Data licencia: [en linea] <http://wiki.puredata.info/en/Pd_license> [ citado en 04-05-2011]
40

estando muy cercana al dominio pblico. La licencia BSD al contrario que la GPL
permite el uso del cdigo fuente en software no libre.

5.

DESARROLLO INGENIERIL

En este captulo del desarrollo ingenieril se van a explicar uno a uno los procesos
que fueron necesarios para la creacin del sistema. Ntese que para la redaccin
y la ejemplificacin del cdigo se ha respetado la sangra correspondiente al
proceso, tal como se escribe el cdigo en Python con el fin de que se tenga un
mayor entendimiento.

5.1.

ESTRUCTURA DEL PROGRAMA

La versin de Python 2.7 no acepta letras con tildes, caracteres como , o

similares, por esto hay que usar una funcin que permite que se interpreten estos
caracteres de la siguiente manera:
#!/usr/bin/env Python
# Este archivo usa el encoding: utf-8

Para saber cul es el directorio en el cual se est trabajando se usa:

import os
print(os.getcwd())

Para cambiar de directorio con import os se nombra la direccin por ej.

os.chdir('H:\\MG\\()(MG)()') #Directorio

Para comenzar a desarrollar todo el programa se har uso de la programacin

orientada a objetos y la estructura resumida del programa para el anlisis de los
eventos MIDI va a ser de la siguiente manera:

class MusicGarden:
def __init__(self,nmid,fin):
def Termcsv(self):#programa que recoge la informacin de midicsv
def Nummat(self):#Cuanta el numero de notas on y off
def Eventmidi(self):#Filtra las notas on y off, los cambios de tempo, Header o PPQN
def Vermatriz(self):#Ordena tracks en uno solo y los organiza los eventos de menor a mayor
def MtrzAnls(self):#Matriz concatenada de notas on simultaneas
def Analisis(self):# Anlisis Musical

El nombre de la clase se llamar MusicGarden usando dos variables iniciales

nmid=nombre del archivo midi y fin=numero de eventos para analizar (fin=-1
significa toda la secuencia). Dentro de esta clase existen varias funciones (sub
programas) que se van a describir en detalle ms adelante; la seal y los procesos
estn enmarcados por el siguiente diagrama de flujo:

Ilustracin 2: Diagrama de flujo de los procesos creados en Python

5.2.

DESCOMPILADO DE ARCHIVOS MIDI EN PYTHON

La manera lograda para ejecutar MIDICSV y poder recoger la informacin

procesada de un archivo de texto se explica en el siguiente diagrama de flujo:

Ilustracin 3: Diagrama de flujo de la funcin Termcsv

El cdigo es el siguiente:
def Termcsv(self):
def csvlist():
import subprocess
outfd = open('Out', 'w+')
errfd = open('Err', 'w+')
subprocess.call(['midicsv','-v',nmid], stdout=outfd, stderr=errfd)
outfd.close()
errfd.close()
csvlist()

Se cre, por conveniencia, una funcin def csvlist():, luego se import la biblioteca
subprocess, creando dos archivos para la salida de datos y otra funcin para los
mensajes de error. Out y Err, a los que se les asigna las variables outfd y errfd;
w+, significa que abre los archivos Out y Err en modo escritura y si no existen
entonces estos se crean; luego subprocess.call llama a midicsv.exe, lo ejecuta con
el comando -v que sirve para descompilar y llamar el nombre del archivo MIDI; con
esto logra generar una lista de eventos ejecutados en MS-DOS pero, como no se
quiere que solo se impriman en MS-DOS, sino que los guarde entre los ficheros
Out y Err, se logra con stdout. Finalmente se cierran los ficheros. Para ejecutar la
subsuncin def csvlist(): se hace agregndole csvlist() al final. Hay que tener en
cuenta que el archivo MIDI debe estar dentro de la carpeta que contiene los
archivos de MIDICSV; otra cosa muy importante es que siempre en Python las
jerarquas estn notadas por la sangra y as se sabr el orden de los procesos,
por eso csvlist() debe tener la misma sangra que def csvlist(): para ejecutarse.

5.3.

CONTEO DE EVENTOS ON Y OFF

Ilustracin 4: Diagrama de Flujo para la funcin Nummat

Va a ser necesario ms adelante el conteo de eventos MIDI para otros procesos,

adems de que tambin se quiere tener una referencia del nmero de eventos que
se van analizar por secuencia.
def Nummat(self):
global nev
nev=0
n = open('Out','r+')
while True:
linea = n.readline()
if not linea: break
cdn='';a=[]
for num in linea:
if num != ' ' and num != ',' and num != '\n':
cdn=str(cdn)+str(num)
if num == ',' or num == '\n' and cdn != '\n' and cdn != '':
a=a+[cdn]
cdn=''
if a[2]=='Note_on_c' or a[2]=='Note_off_c':
nev=nev+1
print 'El numero de eventos para analizar es',nev;print

Con global nev se hace para que la variable nev pueda ser llamada con el mismo
valor en cualquier clase o funcin; en n se abre el archivo Out y r+ para leerlo, en
el ciclo while tomo lnea a lnea cada evento dentro del texto Out; luego se va a
filtrar la informacin de cada lnea con el ciclo for mediante los condicionales if.
Ms adelante el contador nev va a registrar cada vez que una lnea con el nombre
Note_on_c o Note_off_c aparezca.

5.4.

FILTRADO, LISTAS, Y EVENTOS IMPORTANTES

Ilustracin 5: Diagrama de Flujo para la funcin Eventmidi

El cdigo es el siguiente:
def Eventmidi(self):
global sos,tmp
sos=[];tmp=[]
n = open('Out','r+')
while True:
linea = n.readline()#toma cada linea del texto
if not linea: break
cdn='';a=[]
for num in linea:#quita caracteres no deseados
if num != ' ' and num != ',' and num != '\n':
cdn=str(cdn)+str(num)
if num == ',' or num == '\n' and cdn != '\n' and cdn != '':
a=a+[cdn]
cdn=''
#print a

Como ya se mencion en el tem anterior, se abre el texto, se toma lnea a linea y

se quita los caracteres coma y espacio creando una lista a que contiene en cada
una las de posiciones (vector) de los valores por cada lnea, es decir; los valores
por cada lnea est ahora en a que contiene un vector (lista) y este representan
un evento; si imprimo a la lista de eventos que contiene la secuencia MIDI. Ahora
se seguir explicando el cdigo; note que la sangra an sigue dentro del ciclo
while:

global sgndo,tcom
if a[2]=='Header':
sgndo=a[5]
if a[2]=='Time_signature':
tcom=[int(a[3]),int(a[4])]
if a[2]=='Tempo':
tmp.append([a[1],a[3]])
if a[2]=='Note_on_c':
a=[a[3],a[5],a[4],a[1]]
ro=+1
sos=sos+[a]

if a[2]=='Note_off_c':
a[5]=0
a=[a[3],a[5],a[4],a[1]]
sos=sos+[a]

Se van a tomar los elementos de la lista a y mediante condicionales se toman

los eventos que para este proyecto van a ser tiles; note que el valor a[2] es el que
contiene el nombre del tipo de evento pero no siempre es as. El primer valor que
se toma es el valor a[5] (DIVISIN) del evento HEADER

(0, 0, HEADER,

FORMAT, NTRACKS, DIVISIN) que representa el nmero de pulsos por negra

guardndolo en la variable global sgndo y es un factor que sirve para convertir las
duraciones de acuerdo a la necesidad que se mencionar ms adelante; Para el
evento Time_signature (TRACK, TIME, TIME_SIGNATURE, NUM, DENOM,
CLICK, NOTESQ) se toman los valores a[3] y a[4] (NUM, DENOM) guardndolos
en la variable tcom y que podrn ser usados para la parte rtmica del anlisis de la
secuencia.

Los siguientes valores a tomar son los valores a[1] y a[3] del Tempo (TRACK,
TIME, TEMPO, NUMBER) guardados en la lista tmp, a[1] es la duracin donde va
a existir el cambio de tempo, en a[3] va a estar el valor del tempo. Ms adelante se
toman los valores ms importantes que son Note On y Note Off (TRACK, TIME,
NOTE_ON_C, CHANNEL, NOTE, VELOCITY y TRACK, TIME, NOTE_OFF_C,
CHANNEL,

NOTE,

VELOCITY).

Al

hacer

a=[a[3],a[5],a[4],a[1]]

se

est

reorganizando los valores de la lista a debido a que ese es el orden de los

valores para el protocolo de eventos en Pure Data adems que tambin son de
ayudan para el entendimiento; de aqu se toman los valores: a[3], el canal; a[5], la
velocidad; a[4], valor de la nota y a[1]], la duracin; esta nueva lista ser guardada
en sos que ira almacenando cada una de las pequeas listas a y as se tendr
una lista que contiene todas las notas de la secuencia MIDI; note que el valor a[5]
de una nota apagada debe ser 0 aunque dentro de los MIDI nunca se sabe con lo
que uno se puede encontrar.

5.5.

HERRAMIENTA DE ANLISIS

Ilustracin 6: Diagrama de flujo para la funcin Vermatriz

Bajo la influencia del protocolo Qlist, cuando se empez a experimentar con las
secuencias musicales MIDI para piano, se encontr que as como existan
secuencias con tres canales (por ejemplo, representando el nmero de voces),
tambin existan secuencias que podan tener siete canales para la misma pieza
musical, bajando la misma secuencia desde dos fuentes distintas, entonces como
este proyecto estaba enfocado hacia piezas para piano, se tom la decisin de
unir todos los canales en un solo canal MIDI.

El primer paso es tomar los valores numricos de la lista sos y pasarlos a enteros
as:
for i in range(len(sos)):
for j in range(4):
sos[i][j]=int(sos[i][j])

El segundo paso es contar el nmero de canales que en teora debera aparecer

NTRACKS de HEADER pero no siempre es as por lo tanto se hace este proceso
que es simplemente tomar el mayor valor de nmero de canales:
for i in range(len(sos)):
if i>0:
noch=sos[i][0]
else:
noch=sos[i][0]

Hay que tener en cuenta que si una secuencia tiene varios canales, entonces va a
aparecer una lista de eventos por cada canal, hasta llegar al ltimo canal, es decir;
la primera lista tendr el canal cero, la siguiente lista el canal uno y as
sucesivamente; pero la clave est en que las duraciones son las que tienen el
orden de todas las notas de la secuencia as que se van a organizar de menor a
mayor todos los eventos de la secuencias de acuerdo a los valores de las
duraciones. Para ordenar los eventos se usa el mtodo de la sacudida que
proviene del mtodo de la burbuja as:
for i in range(1 , len(sos)-1): #Ordena sos[3] DURACION
for j in range(0, len(sos)-i):
if sos[j][3] > sos[j+1][3]:
sos[j],sos[j+1] = sos[j+1],sos[j]
izq = 1
der = len(sos)-1
j = len(sos)-1
while izq <= der : #Ordena sos[3] DURACION
for i in range(der,izq-1,-1) :
if sos[i-1][3] > sos[i][3]:
sos[i],sos[i-1] = sos[i-1],sos[i]
j=i

izq = j+1
for i in range(izq,der+1):
if sos[i-1][3] > sos[i][3]:
sos[i],sos[i-1] = sos[i-1],sos[i]
j=i
der = j-1

Es bueno notar que la forma de cambiar de posicin a dos elementos en una lista
se logra fcilmente con sos[j],sos[j+1] = sos[j+1],sos[j]; para entender ms sobre el
mtodo de la sacudir puede remitirse al tem titulado Ordenamiento por
Sacudida en Python del marco terico.

Cuando hay notas simultaneas, stas para encenderse deben tener el mismo valor
de duracin, por ejemplo, si hay siete notas simultaneas, van a existir siete
eventos con la misma duracin de encendido, pero no siempre la organizacin del
valor de las notas estn ordenados de menor a mayor; por ello se usar
nuevamente el mtodo de organizacin anterior para ordenar dichos valores de
nota de la siguiente manera.
izq = 1
der = len(sos)-1
j = len(sos)-1
while izq <= der : #Ordena [2] VALOR NOTA para cada duracin
for i in range(der,izq-1,-1) :
if sos[i][2] < sos[i-1][2] and sos[i][3] == sos[i-1][3] and sos[i][1] == sos[i-1][1]:
sos[i],sos[i-1] = sos[i-1],sos[i]
j=i
izq = j+1
for i in range(izq,der+1):
if sos[i][2] < sos[i-1][2] and sos[i][3] == sos[i-1][3] and sos[i][1] == sos[i-1][1]:
sos[i],sos[i-1] = sos[i-1],sos[i]
j=i
der = j-1

Por alguna razn despus de este proceso no funcion totalmente este mtodo
as que se us el mismo una segunda vez para cerciorarse de que todos los
eventos que tuvieran la misma duracin estuvieran organizados de menor a
mayor.

Las duraciones para una secuencia MIDI estn dadas como un cronometro
contabilizando en qu momento est sucediendo un evento, en cambio para el
protocolo Qlist de Pure Data, las duraciones estn dadas para cada evento, por
ejemplo: para una secuencia MIDI donde los eventos tienen la misma duracin y
uno va detrs de otro, sera: evento 0 y duracin 0, evento 1 y duracin 1, evento
2 y duracin 2, evento 3 y duracin 3; en cambio para el protocolo de Qlist sera:
evento 0 y duracin 1, evento 1 y duracin 1, evento 2 y duracin 1, evento 3 y
duracin 1. Para esto se ha creado el siguiente cdigo:
for i in range(len(sos)):
if i < len(sos)-1:# and sos[i][0]==sos[i+1][0]:
sos[i]=sos[i]+[sos[i+1][3]-sos[i][3]]
sos[i]=[sos[i][0],sos[i][1],sos[i][2],sos[i][4],sos[i][3]]
else:
sos[i]=sos[i]+[0]
sos[i]=[sos[i][0],sos[i][1],sos[i][2],sos[i][4],sos[i][3]]

Entonces el valor de duracin para cada evento es la resta de las duraciones del
evento posterior al anterior sos[i]=sos[i]+[sos[i+1][3]-sos[i][3]]; lo que sucede en
este cdigo es crear una nueva columna con los valores de duracin para cada
evento que se est organizando (sos[i]=[sos[i][0],sos[i][1],sos[i][2],sos[i][4],sos[i][3]])
una columna antes que las duraciones de la secuencia; a continuacin un ejemplo
de los resultados del cdigo antes de proceso:
0
0
0
0
0
0
0
0
0
0
0
0
0
0

100
100
100
100
100
100
100
0
0
0
0
0
0
0

60
64
67
72
76
79
84
60
64
67
72
76
79
84

0
0
0
0
0
0
0
480
480
480
480
480
480
480

Luego del proceso:

0
0
0
0
0
0
0
0
0
0
0
0
0
0

100
100
100
100
100
100
100
0
0
0
0
0
0
0

60
64
67
72
76
79
84
60
64
67
72
76
79
84

0
0
0
0
0
0
480
0
0
0
0
0
0
0

0
0
0
0
0
0
0
480
480
480
480
480
480
480

La siguiente etapa es adecuar las duraciones de cada evento a los valores para el
protocolo de Qlist en el que si una nota dura un segundo, la duracin para Qlist
sea un segundo es decir mil milisegundos de la siguiente manera:

sgndo2=1000/float(sgndo)
for i in range(len(sos)):
sos[i][3]=float(sos[i][3]);sos[i][4]=float(sos[i][4])
if sos[i][3] != 0:
sos[i][3]=sos[i][3]*(sgndo2)
if sos[i][4] != 0:
sos[i][4]=sos[i][4]*(sgndo2)
El proceso consiste en que se toma el valor de la variable sgndo que contiene el
nmero de pulsos por negra y se crea una relacin para la conversin de las
duraciones que ser aplicada a las dos columnas que se tiene de duracin.

Un ejemplo procesando el ejemplo anterior seria:

0
0
0
0
0
0
0
0

100
100
100
100
100
100
100
0

60
64
67
72
76
79
84
60

0.0
0.0
0.0
0.0
0.0
0.0
1000.0
0.0

0.0
0.0
0.0
0.0
0.0
0.0
0.0
1000.0

0
0
0
0
0
0

0
0
0
0
0
0

64
67
72
76
79
84

0.0
0.0
0.0
0.0
0.0
0.0

1000.0
1000.0
1000.0
1000.0
1000.0
1000.0

Las duraciones de los cambios de tempo tambin deben ser transformado para
que Qlist los entienda, por ello se aplica el mismo proceso; as mismo se debe
tener en cuenta que los tempos deben estar de acuerdo a una relacin ya que
para Pure Data donde un tempo de tempo 60 = 1 segundo = 1 en Pd, y tempo 120
= 1/2 segundo = 2 en Pd. Estos dos procesos se hacen de la siguiente manera:

Pasar duracin de los tempos con factor de sgndo con la misma relacin del
proceso anterior:
for i in range(len(tmp)):
tmp[i][0]=float(tmp[i][0]);tmp[i][1]=float(tmp[i][1])
if tmp[i][0] != 0:
tmp[i][0]=round((tmp[i][0]*(sgndo2)), -1)

Convertir tempo en un factor valido para Pure Data:

for i in range(len(tmp)):
tmp[i][1]=round((1000000/(tmp[i][1])), 2)
tmp[i]=[tmp[i][1],tmp[i][0]]

Los pasos siguientes son pequeos procesos donde algunos se deben hacer para
el correcto funcionamiento en Pure Data y otros que son ayudas para el anlisis
musical:

Creacin de listas con los 128 valores donde tenga el nombre del valor de la nota,
la octava a la que pertenece y el valor nota;

n=['C','C#','D','D#','E','F','F#','G','G#','A','A#','B']
vn=[];vo=[];vv=[];num=-1;note=-1
for i in range(128):
vv=vv+[i]
if i%12==0:
num+=1
note+=1
vo=vo+[num-1]
vn=vn+[n[note]]
if note==11:
note=-1
#print vn # Nombre de la nota
#print vo # Valor Octava
#print vv # Valor de la nota

Con esta tabla se va asignar el nombre y octava a cada valor de nota de la

secuencia de la matriz sos:
for i in range(len(sos)):
for j in range(128):
if sos[i][2]==vv[j]:
if sos[i][2]!=0:
sos[i]=sos[i]+[str(vo[j])+vn[j]]
for i in range(len(sos)): #cambia columnas
sos[i]=[sos[i][5],sos[i][0],sos[i][1],sos[i][2],sos[i][3],sos[i][4]]

Si en la secuencia haba varios canales, entonces hay que dejarlos todos en 0:

if noch != 0:
for i in range(len(sos)): # dejar [1] CANAL = 0
chh=sos[i][1]
sos[i]=sos[i]+[chh]
sos[i][1]=0

Como se tuvo que establecer una relacin para todas las duraciones, existen
valores que tienen varios decimales y que con el siguiente cdigo se redondean a
un decimal:
for i in sos:

i[4]=round(i[4], -1)
i[5]=round(i[5], -1)

Finalmente este es un condicional puesto convenientemente creado para hacer

pruebas y no tomar las secuencias completas sino un pequeo nmero de eventos
que se quiera probar.
if fin != -1:
for i in range(len(sos)-1 ,fin-1,-1):
sos.remove(sos[i])

Ac un ejemplo del resultado de los ltimos procesos frente al ejemplo anterior:

nom

ch

vel

not

drpd

dr

4C
4E
4G
5C
5E
5G
6C
4C
4E
4G
5C
5E
5G
6C

0
0
0
0
0
0
0
0
0
0
0
0
0
0

100
100
100
100
100
100
100
0
0
0
0
0
0
0

60
64
67
72
76
79
84
60
64
67
72
76
79
84

0.0
0.0
0.0
0.0
0.0
0.0
1000.
0.0
0.0
0.0
0.0
0.0
0.0
0.0

0.0
0.0
0.0
0.0
0.0
0.0
0.0
1000.0
1000.0
1000.0
1000.0
1000.0
1000.0
1000.0

5.6.

MTODO DE ANLISIS MUSICAL PARA UNA SECUENCIA MIDI

Hasta el momento, se ha logrado ubicar dentro de una lista, la informacin de los

eventos de nota on y off, si se activan 5 notas simultneamente, el desarrollador
ver una lista como el siguiente ejemplo:
Matriz sos:
5C
5E
5G
6C
5C
5E
5G
6C

0
0
0
0
0
0
0
0

100
100
100
100
0
0
0
0

72
76
79
84
72
76
79
84

0.0
0.0
0.0
1000.0
1000.0
2000.0
4000.0
0.0

0.0
0.0
0.0
0.0
1000.0
2000.0
4000.0
8000.0

En este caso es muy difcil comprender de una manera prctica qu es lo que est
sucediendo con las notas simultneas dentro de la secuencia. En realidad las
notas de desactivacin no ayudan a entender lo que sucede con la secuencia, y el
sentido vertical del flujo de datos resultantes, tampoco muestra claramente cmo
ests sucediendo dentro de la secuencia; entonces hay que construir un mtodo
no solo para asimilar la msica en el flujo de datos generados sino que adems,
ste mtodo debe ser prctico para transformarlo mediante la programacin.

Para aplicar el anlisis de la teora musical a una secuencia se necesita disear un

mtodo prctico, para que se pueda vislumbrar lo que est sucediendo con la
secuencia. El primer intento fue crear una matriz con los eventos encendidos por
cada variacin de tiempo. Para ilustrar sta idea se muestra el siguiente ejemplo:

Ilustracin 7: Ejemplo matriz concatenada para el anlisis musical

Los valores de la tabla anterior son arbitrarios y estn tomados como ejemplo. Se
trata de una tabla ideal en la que cada color representa una meloda, por lo tanto
habra 4 melodas distintas. En las columnas de la derecha, los valores presentan
la secuencia de llegada de cada conjunto de eventos, es decir, los eventos
encendidos en dicho tiempo. Por ejemplo en el evento con la duracin 19, la nota
encendida es 94 mientras que para el evento con la duracin 21, las notas
simultneas son 44 - 65 - 33. El ejemplo sirve, entonces, para ver que la armona
queda establecida en el sentido horizontal y que las melodas aparecen en el
sentido vertical, contrario, a como se expresaran en una partitura (armona
vertical, meloda horizontal).

Por lo tanto al convertir el flujo de eventos de nota encendida en una matriz

concatenada donde las notas simultaneas aparecen horizontalmente, son la clave
para empezar a analizar las propiedades musicales armnicas y las propiedades
musicales meldicas haciendo uso de la programacin. En el siguiente tem se
explicar la construccin de dicho mtodo.
5.6.1. MATRIZ CONCATENADA evnt=[ ] DE NOTAS SIMULTANEAS POR
DURACION

Para poder explicar mejor el proceso de la creacin de ste mtodo se toma el

siguiente ejemplo:
Matriz sos:
5C
5E
5G
6C
5C
5E
5G
6C

0
0
0
0
0
0
0
0

100
100
100
100
0
0
0
0

72
76
79
84
72
76
79
84

0.0
0.0
0.0
1000.0
1000.0
2000.0
4000.0
0.0

0.0
0.0
0.0
0.0
1000.0
2000.0
4000.0
8000.0

Matiz evnt:
1000.0
1000.0
2000.0
4000.0

0.0
1000.0
2000.0
4000.0

[72, 76, 79, 84]

[76, 79, 84]
[79, 84]
[84]

El proceso se explica mediante el siguiente diagrama de flujo:

Ilustracin 8: Diagrama de flujo para la funcin MtrzAnls

El proceso para lograr la matriz evnt est dado por el siguiente cdigo:
io=0;n1=0;n0=0;sim=[];evnt=[];time=[];rtime=[]
self.ev=[];self.txt=''
for i in range(len(sos)):
if i < len(sos)-1 and sos[i][5] == sos[i+1][5]:
if sos[i][2] != 0:
sim.append(sos[i][3])
else:
if sos[i][3] in sim:
sim.remove(sos[i][3])

En primer lugar, se abre un ciclo for que va a finalizar con el numero de eventos
(notas on y off) que tiene la secuencia; el propsito del primer condicional es
evaluar si las duraciones (ltima columna) anterior y posterior son iguales; los
siguientes condicionales verifican que estos valores iguales pertenezcan o no, a
una nota que se enciende con vel (columna 2) diferente de cero; entonces se
agregan el valor-nota a la lista sim si cumple la condicin.
else:
if sos[i][2] != 0:
sim.append(sos[i][3])
izq = 1
der = len(sim)-1
j = len(sim)-1
while izq <= der :
for x in range(der,izq-1,-1) :
if sim[x] < sim[x-1]:
sim[x],sim[x-1] = sim[x-1],sim[x]
j=x
izq = j+1
for x in range(izq,der+1):
if sim[x] < sim[x-1]:
sim[x],sim[x-1] = sim[x-1],sim[x]
j=x
der = j-1
aux=[]
for k in sim:
aux.append(k)
evnt.append(aux)
time.append(sos[i][5])

rtime.append(sos[i][4])

A continuacin, teniendo en cuenta que las duraciones (ltima columna) anterior y

posterior no son iguales: se evalan estos datos mediante otro condicional que
verifica si an el evento es una nota encendida, entonces si cumple con la
condicin nuevamente se agrega el valor de la nota a la lista sim y como para
llegar hasta este condicional deben haber al menos dos valores en la lista,
entonces se organizan de mayor a menor por el mtodo de la sacudida.
Finalmente los valores de sim son guardados en una nueva lista aux que a su vez
son guardados como lista en evnt a la que corresponder los valores de duracin
asignados a time y rtime. Evnt es la matriz concatenada con filas de distintas
dimensiones.
else:
if sos[i][3] in sim:
sim.remove(sos[i][3])
if len(sim) != 0:
izq = 1
der = len(sim)-1
j = len(sim)-1
while izq <= der :
for x in range(der,izq-1,-1) :
if sim[x] < sim[x-1]:
sim[x],sim[x-1] = sim[x-1],sim[x]
j=x
izq = j+1
for x in range(izq,der+1):
if sim[x] < sim[x-1]:
sim[x],sim[x-1] = sim[x-1],sim[x]
j=x
der = j-1
aux=[]
for k in sim:
aux.append(k)
evnt.append(aux)
time.append(sos[i][5])
rtime.append(sos[i][4])

Si el evento es una nota apagada, entonces sta es quitada de la lista sim y sta
es la razn por la cual se utiliza la variable aux; luego, mientras que el nmero de

valores en la matriz sim sea diferente de cero, se van a organizar nuevamente los
elementos dentro de ella de menor a mayor y finalmente se va agregar una nueva
lista sim a la lista evnt a la que corresponder los valores de duracin asignados a
time y rtime.
'''for i in range(len(evnt)):
print rtime[i],'\t',time[i],'\t',evnt[i]#,i'''
self.evnt=evnt
self.time=time
self.rtime=rtime

Por ltimo con self se toman las matrices y los valores de duracin time y rtime
para ser usados los procesos de anlisis.

5.7.

ANLISIS - SECUENCIA MIDI - TEORA MUSICAL

En esta gran etapa, se va a crear una subclase llamada Teoria_musical que

contiene las siguientes funciones:
class Teoria_musical:
def __init__(self, evnt,time,rtime):
def diccionarios(self):#Para hacer referencia en las siguientes fusiones
def alteraciones(self):#Analiza si existen bemoles o sostenidos
def tonalidad(self): Analiza la tonalidad de la secuencia MIDI
def TONalidad(self):#Usa la tonalidad hallada para otros anlisis musicales
def armonia(self):#Analiza triadas en de la secuencia
def Ordenes(self):#Genera un archivo con las ordenes para Pure Data
def PYPD(self):#Mueve archivos generados a otras carpets.

El proceso es el siguiente:

Ilustracin 9: Diagrama de flujo para la sub clase Teoria_musical

5.7.1. DICCIONARIOS REQUERIDOS PARA EL ANLISIS

Como ya se mencion en el marco terico, los diccionarios devuelven un valor de

acuerdo a una clave, el primer diccionario cuyas claves son los nombres de todas
las notas con sostenidos y bemoles incluidos, devuelve el valor numrico al que
corresponde desde 0 hasta 11, con el fin de saber qu nota puede ser por medio
del modulo que se explicar ms adelante.
def diccionarios(self):
vlnt={}
vlnt['C']=0
vlnt['B#']=0
vlnt['C#']=1
vlnt['Db']=1
vlnt['D']=2
vlnt['D#']=3
vlnt['Eb']=3
vlnt['E']=4
vlnt['Fb']=4
vlnt['E#']=5

vlnt['F']=5
vlnt['F#']=6
vlnt['Gb']=6
vlnt['G']=7
vlnt['G#']=8
vlnt['Ab']=8
vlnt['A']=9
vlnt['A#']=10
vlnt['Bb']=10
vlnt['B']=11
vlnt['Cb']=11
self.vlnt=vlnt

El diccionario vlnt es el que contiene el valor de la nota, luego se agrega a self

para usarlo fcilmente en las dems funciones. El diccionario que se tiene ms
adelante es un diccionario con los nombres desde do hasta si incluyendo las
notas sostenidas donde la clave ser el nmero desde 0 a 126 y el valor ser

aquel nombre y finalmente se guarda la lista como self de nts de las notas) y el
diccionario dccnts de la siguiente forma:
nts=['C','C#','D','D#','E','F','F#','G','G#','A','A#','B']
dccnts={}
n=0
for i in range(128):
dccnts[i]=nts[n]
n+=1
if n==12:
n=0
self.nts=nts
self.dccnts=dccnts0

El prximo diccionario sirve para hallar la tonalidad mediante las notas con
nombres que tienen sostenidos, pero como una tonalidad que tiene una relativa
menor tiene el mismo nmero de alteraciones, entonces el valor devuelto a la
clave es el nombre de la tonalidad ms y su relativa menor:
dccaltr={}
dccaltr['']=['CM','Am']
#Tonalidades con Sostenidos
dccaltr['F#',]=['GM','Em']
dccaltr['F#','C#']=['DM','Bm']
dccaltr['F#','C#','G#']=['AM','F#m']
dccaltr['F#','C#','G#','D#']=['EM','C#m']
dccaltr['F#','C#','G#','D#','A#']=['BM','G#m']
dccaltr['F#','C#','G#','D#','A#','F']=['F#M','D#m']
dccaltr['F#','C#','G#','D#','A#','F','C']=['C#M','A#m']
#Tonalidades con Bemoles
dccaltr['A#',]=['FM','Dm']
dccaltr['A#','D#']=['BbM','Gm']
dccaltr['A#','D#','G#']=['EbM','Cm']
dccaltr['A#','D#','G#','C#']=['AbM','Fm']
dccaltr['A#','D#','G#','C#','F#']=['DbM','Bbm']
dccaltr['A#','D#','G#','C#','F#','B']=['GbM','Ebm']
dccaltr['A#','D#','G#','C#','F#','B','E']=['CbM','Abm']
self.dccaltr=dccaltr

El ltimo diccionario toma las tonalidades enarmnicas como clave, y arroja la

enarmnica ms usada.

dccenar={}
dccenar['BM','CbM']=['BM']
dccenar['G#m','Abm']=['G#m']
dccenar['F#M','GbM']=['F#M']
dccenar['C#M','DbM']=['C#M']
dccenar['A#m','Bbm']=['Bbm']
dccenar['D#m','Ebm']=['Ebm']
self.dccenar=dccenar

El diagrama de flujo sobre el proceso para hallar la tonalidad y que involucran los
dos tems siguientes estn dados as:

Ilustracin 10: Diagrama de flujo para hallar la tonalidad

5.7.2. ANLISIS DE ALTERACIONES Y BSQUEDA DE LA TONALIDAD

El punto de partida, es poder visualizar las alteraciones dentro de la secuencia,

pero en la informacin MIDI un do sostenido tiene el mismo valor que un re

bemol cosa que en la estructura musical no es as, pero, para llegar a tener
resultados, hay que tomar esta comparacin como verdadera, un do sostenido
equivale a un re bemol y as suceder para todas las notas alteradas. Ahora
cmo saber si las alteraciones dentro de una secuencia cualquiera, son
sostenidos o bemoles?

La respuesta comienza por saber cules notas estn siendo alteradas dentro de la
secuencia y para ello es vital hacer un conteo de cada una de las notas. Ahora,
qu pasa si hay un nmero significativo para una nota como el do sostenido o re
bemol?. Como esta alteracin puede ser parte de una tonalidad con do sostenidos
o tambin puede ser parte de una tonalidad con re bemoles, entonces habr que
comparar cada una de las notas con la anterior o posterior, es decir; si do tiene el
valor 0 do sostenido es 1 y re es 2, hay que comparar 1 versus 0 y 1 versus 2 as
podr intuirse con mayor certeza a qu nota se inclina la alteracin y sta es la
base para encontrar las alteraciones analizando todas las 12 notas de 0 a 11 en
los valores MIDI. Para contarlas solo hay que tomar el valor de la nota y calcular el
mdulo 12 as se sabe rpidamente a que nota pertenece.

El proceso en detalle para encontrar las alteraciones consiste en evaluar la nota

anterior y posterior, por ejemplo: la nota a evaluar es A#, los resultados al contar
cuantas veces aparecen cada nota en la secuencia donde A aparece 426 veces,
A# aparece 392 veces y B aparece 126 veces, entonces como la nota a examinar
es A# se compara, entre A y A# es mayor A# por lo que A posiblemente es la
alteracin (no es una alteracin, solo se busca descartar A), luego comparando
entre A# y B, donde es mayor A#; entonces se tiene 2 posibilidades A y A# pero
como la nota a evaluar es A# y aparece dentro de las posibilidades, entonces A#
si es una alteracin dentro de la secuencia. Si en las dos

posibilidades no

aparece la nota a evaluar, esta nota no ser una alteracin ni una nota importante
en la secuencia MIDI.

Ms adelante despus de haberse extrado las notas que pueden ser alteradas, se
cotejan con las estructuras de bemoles y sostenidos mediante el uso de
diccionarios, entonces as se sabr con exactitud si son bemoles o sostenidos. En
seguida el problema es saber si es una tonalidad mayor o menor, entonces se
evalan las notas iniciales y finales como tambin las triadas respectivas a las
posibles tonalidades y se sabr la tonalidad a la que pertenece la secuencia;
ahora como pueden existir tonalidades enarmnicas, entonces usando como
referente El Clave Bien Temperado de Juan Sebastin Bach se deja la
enarmnica que Bach us.

Al poder deducir la tonalidad, se establecen diccionarios acordes a sta con la

informacin pertinente como los grados de la escala dependiendo si es mayor o
menor, agregarle las alteraciones correspondientes a los eventos para as analizar
la secuencia logrando ver sus notas con su verdadero nombre y alteraciones; ms
adelante averiguar las notas importantes de acuerdo a los grados de la tonalidad
as como tambin las triadas en la secuencia logrando deducirlas aunque estn
invertidas.

La clave para encontrar la tonalidad es conocer sus alteraciones, por ello el primer
procesos es contar el nmero de veces que se repite cada nota dentro de una
secuencia:
def alteraciones(self):
dccnt={}
prm=[[0]*2,[0]*2,[0]*2,[0]*2,[0]*2,[0]*2,[0]*2,[0]*2,[0]*2,[0]*2,[0]*2,[0]*2]
nm=['C','C#','D','D#','E','F','F#','G','G#','A','A#','B']
for i in range(12):
dccnt[i]=nm[i]
for i in range(12):
prm[i][0]=nm[i]
for i in range(len(sos)):
if sos[i][3]%12==0:
prm[0][1]+=1
elif sos[i][3]%12==1:
prm[1][1]+=1
elif sos[i][3]%12==2:

prm[2][1]+=1
elif sos[i][3]%12==3:
prm[3][1]+=1
elif sos[i][3]%12==4:
prm[4][1]+=1
elif sos[i][3]%12==5:
prm[5][1]+=1
elif sos[i][3]%12==6:
prm[6][1]+=1
elif sos[i][3]%12==7:
prm[7][1]+=1
elif sos[i][3]%12==8:
prm[8][1]+=1
elif sos[i][3]%12==9:
prm[9][1]+=1
elif sos[i][3]%12==10:
prm[10][1]+=1
elif sos[i][3]%12==11:
prm[11][1]+=1

Lo primero es crear un diccionario que referencia el valor de 0 a 11 con el nombre

de la nota, el siguiente paso es crear una lista bidimensional en donde se tenga en
una columna el nombre de las notas de do a si y en la segunda columna el
nmero de cada una de las notas que aparece dentro de la secuencia. Luego con
un ciclo se analiza toda la secuencia tomando los valores de nota y calculando el
mdulo 12 haciendo el conteo del valor que corresponde para cada nota de 0
hasta 11; en el ejemplo siguiente se puede tener una mejor idea del resultado de
este proceso:
0
1
2
3
4
5
6
7
8
9
10
11

C
C#
D
D#
E
F
F#
G
G#
A
A#
B

184
0
170
156
12
174
6
148
40
108
180
6

Ahora se crea un pequeo diccionario con los valores de 1 a 11 y sus valores

correspondientes por cada nota:

v={}
for i in range(12):
v[i]=prm[i][1]
0
1
2
3
4
5
6
7
8
9
10
11

184
0
170
156
12
174
6
148
40
108
180
6

El proceso siguiente es uno de los ms importantes para descubrir si las

alteraciones son bemoles o si son sostenidos y tambin poder encontrar la
tonalidad; el proceso consiste en analizar las posibles notas alteradas empezando
por los sostenidos y paralelamente los bemoles de acuerdo a

las siguientes

tablas:

Entonces la primera nota para analizar es fa#=6 (Sol Mayor), despus do#=1 (Re
Mayor) luego sol#=8 (La Mayor) y as analizando todas las notas que pueden ser
alteradas dentro de los sostenidos y los bemoles (sib=8 (Fa Mayor), reb=1 (Si
Bemol Mayor), lab=6 (Mi Bemol Mayor)). Para analizar cada nota hay que saber
qu nota tiene un valor de veces mayor comparando entre la nota que est atrs y
la nota que est adelante, el cdigo para desarrollar este proceso es:

dccst={}
dccst[0]=6,5,7
dccst[1]=1,0,2
dccst[2]=8,7,9
dccst[3]=3,2,4
dccst[4]=10,9,11
dccst[5]=5,4,6
dccst[6]=0,11,1
dccbe={}
dccbe[0]=10,9,11
dccbe[1]=3,2,4
dccbe[2]=8,7,9
dccbe[3]=1,0,2
dccbe[4]=6,5,7
dccbe[5]=11,10,0
dccbe[6]=4,3,5
als=[]
for i in dccst:
u=0;d=0
if v[dccst[i][0]]>v[dccst[i][1]]:
u=v[dccst[i][0]]
else:
u=v[dccst[i][1]]
if v[dccst[i][0]]>v[dccst[i][2]]:
d=v[dccst[i][0]]
else:
d=v[dccst[i][2]]
if u==v[dccst[i][0]] or d==v[dccst[i][0]]:
als.append([dccnt[dccst[i][0]],dccst[i][0]])
else:
als.append(['X','X'])
alb=[]
for i in dccbe:
u=0;d=0
if v[dccbe[i][0]]>v[dccbe[i][1]]:
u=v[dccbe[i][0]]
else:
u=v[dccbe[i][1]]
if v[dccbe[i][0]]>v[dccbe[i][2]]:
d=v[dccbe[i][0]]
else:
d=v[dccbe[i][2]]
if u==v[dccbe[i][0]] or d==v[dccbe[i][0]]:
alb.append([dccnt[dccbe[i][0]],dccbe[i][0]])
else:
alb.append(['X','X'])

Se crean dos diccionarios, las claves y valores estn organizadas de esta manera
porque el anlisis depende del orden de las armaduras desde Sol Mayor hasta

Do# Mayor para los sostenidos y desde Fa Mayor hasta Do Bemol Mayor para los
bemoles; los tres valores por cada clave corresponde a: el primer valor ser
evaluado por el siguiente y por el anterior por medio de los condicionales, ej. En
dccst[0]=6,5,7

6 ser evaluado por 5 y por 7. Un ejemplo tomando como

referencia el ejemplo anterior, en donde se evala la nota 6=6 veces, entonces

5=174 veces y 7=148 veces, entre 6 y 5 es mayor 5 y entre 6 y 7 es mayor 7 por lo
tanto la nota 6 no es una nota que est constantemente alterada en la secuencia,
pero si se evalua respecto a los bemoles, dccbe[0]=10,9,11; entonces 10=180,
9=108 y 11=6, por lo que 10 es mayor que 9 y 10 es mayor que 11 entonces 10 si
es una nota alterada constantemente en la secuencia. Por medio de los ciclos el
programa compara cada una de las notas sostenidos y bemoles y estos son
guardados en variables u (up) y d (down) si en el ltimo se cumple con la
condicin de que u y d son iguales al valor a evaluar, entonces este valor es
guardado en una nueva lista (nombre y valor) als alb de lo contrario la sern
agregadas unas X, un ejemplo para ilustrar esta ida es:
0
1
2
3
4
5
6
7
8
9
10
11

184
0
170
156
12
174
6
148
40
108
180
195

dccst[0]=6,5,7 entonces 6<5 d=5 y 6<7 u=7,u=6 o d=6? NO, entonces als =['X', 'X']
dccst[1]=1,0,2 entonces 1<0 d=0 y 1<2 u=2,u=1 o d=1? NO, entonces als =['X', 'X'], ['X', 'X']
dccst[2]=8,7,9
dccst[3]=3,2,4
dccst[4]=10,9,11
dccst[5]=5,4,6
dccst[6]=0,11,1
dccbe[0]=10,9,11 entonces 10>9 d=10 y 10<11 u=11,u=10 o d=10? SI, entonces alb = ['A#', 10]
dccbe[1]=3,2,4 entonces 3>2 d=3 y 3<4 u=3,u=3 o d=3? SI, entonces alb = ['A#', 10], ['D#', 3]
dccbe[2]=8,7,9
dccbe[3]=1,0,2
dccbe[4]=6,5,7

dccbe[5]=11,10,0
dccbe[6]=4,3,5

Tngase en cuenta que se ha colocado el valor 11 mayor a 10 para que se note

que el condicional if u==v[dccbe[i][0]] or d==v[dccbe[i][0]]: ser vlido si alguna de
las dos condiciones es verdadera; as sucesivamente con cada uno de los
elementos del diccionario para los sostenidos y bemoles, entonces el resultado en
general de als y alb ser:

als =[['X', 'X'], ['X', 'X'], ['X', 'X'], ['D#', 3], ['A#', 10], ['F', 5], ['C', 0]]
bls= [['A#', 10], ['D#', 3], ['X', 'X'], ['X', 'X'], ['X', 'X'], ['X', 'X'], ['X', 'X']]

El siguiente proceso elimina los elementos de als y alb con x y sern nombradas
con sus y fla (sustained y flat):
i=0;sus=[]
while i < 7 and als[i][0] != 'X':
sus.append(als[i][0])
i+=1
i=0;fla=[]
while i < 7 and alb[i][0] != 'X':
fla.append(alb[i][0])
i+=1
self.sus=sus
self.fla=fla

Cuyo resultado es:

sus = als = []
fla = bls= ['A#', 'D#']

Por lo que las alteraciones dentro de la secuencia son bemoles y las notas A# y
D# es decir Bb y Eb.
5.7.3. DEFINIENDO LA TONALIDAD

Como ya se tienen las alteraciones, en realidad se est muy cerca de definir la

tonalidad, el problema que ahora se enfrenta, es saber si la tonalidad es mayor o

menor y lo que va a suceder con las tonalidades enarmnicas; estos problemas

sern resueltos de la siguiente manera:

El primer paso es buscar como claves las alteraciones conseguidas en el tem

anterior en el diccionario dccaltr creado en la funcin diccionarios as:
def tonalidad(self):
tn=[];io1=0;io2=0
if len(sus)>0:
tn.append(dccaltr[tuple(sus)])
else:
io2=1
if len(fla)>0:
tn.append(dccaltr[tuple(fla)])
else:
io1=1
if io1 == 1 and io2 == 1:
tn.append(dccaltr[''])

Las alteraciones halladas en sus y fla son buscadas en el diccionario dccaltr como
claves y mientras contengan informacin, si ninguna de las dos tiene informacin,
se cumplir la ltima condicin, es decir que la secuencia no posee alteraciones
por lo que puede ser C Mayor o A menor. Observe que en los tres casos se
agregar informacin a la lista tn.

Por conveniencia se crea la lista psb donde se separan los caracteres de los
nombres de las tonalidades, si el nombre de la escala no tiene ninguna alteracin
se le agrega n indicando que es natural:
psb=[]
for j in range(len(tn)):
for i in tn[j]:
if len(i)==3:
psb.append([i[0],i[1],i[2]])
else:
psb.append([i[0],'n',i[1]])

Por ejemplo:
tn [['BbM', 'Gm']]
psb [['B', 'b', 'M'], ['G', 'n', 'm']]

Ahora se va a realizar un proceso un poco largo que se va a describir por etapas:

tk='';tp='';resul=[]
for i in psb:
tp=i[2]
if i[1]!='n':
tk=i[0]+i[1]
else:
tk=i[0]

La variable tp toma el carcter M o m para cada caso, en tk se almacena el

nombre de la nota para ser buscado el valor en el diccionario vlnt:
Por ejemplo:
psb [['B', 'b', 'M'], ['G', 'n', 'm']]
tk,vlnt[tk],tpBb 10 M
tk,vlnt[tk],tpG 7 m

Despus se crea una lista tri donde se almacenar a tp de la siguiente manera: si

tp es Mayor, se guardan ah las notas que corresponden a la tnica, una tercera
mayor de la tnica, (+ 4 semitonos) y una tercera menor de la tnica (+ 3
semitonos), y si tp es menor, se almacenar en tri una tercera menor de la tnica
(+ 3 semitonos) y una tercera mayor de la tnica, (+ 4 semitonos); note que an
contina dentro del ciclo for.

Luego se agrega una nueva lista a la lista tri con valores [0,0,0]; entonces se
revisa si en la primera nota de la secuencia se halla alguna de las notas le la
primera lista de tri y mientras se cumpla la condicin ser agregada en la segunda
lista de tri. En el siguiente ciclo se revisa si existen estas notas en la ltima nota de
la secuencia; y lo mismo va a suceder para la tonalidad menor despus del
siguiente else (si tp es menor). Estos datos son almacenados en resul.
tri=[]

if tp=='M':
tri.append([vlnt[tk],(vlnt[tk]+4)%12,(vlnt[tk]+3)%12])
tri.append([0,0,0])
for j in evnt[0]:
if j%12==vlnt[tk]:
tri[1][0]+=1
elif j%12==(vlnt[tk]+4)%12:
tri[1][1]+=1
elif j%12==(vlnt[tk]+3)%12:
tri[1][2]+=1
for j in evnt[len(evnt)-1]:
if j%12==vlnt[tk]:
tri[1][0]+=1
elif j%12==(vlnt[tk]+4)%12:
tri[1][1]+=1
elif j%12==(vlnt[tk]+3)%12:
tri[1][2]+=1
else:
tri.append([vlnt[tk]%12,(vlnt[tk]+3)%12,(vlnt[tk]+4)%12])
tri.append([0,0,0])
for j in evnt[0]:
if j%12==vlnt[tk]:
tri[1][0]+=1
elif j%12==(vlnt[tk]+3)%12:
tri[1][1]+=1
elif j%12==(vlnt[tk]+4)%12:
tri[1][2]+=1
for j in evnt[len(evnt)-1]:
if j%12==vlnt[tk]:
tri[1][0]+=1
elif j%12==(vlnt[tk]+3)%12:
tri[1][1]+=1
elif j%12==(vlnt[tk]+4)%12:
tri[1][2]+=1
resul.append(tri)

Ntese que ac termina el ciclo for.

Por ejemplo:
psb [['B', 'b', 'M'], ['G', 'n', 'm']]
tk,vlnt[tk],tpBb 10 M
tri [[10, 2, 1], [3, 0, 0]]
tk,vlnt[tk],tpG 7 m
tri [[7, 10, 11], [0, 3, 0]]
resul [[[10, 2, 1], [3, 0, 0]], [[7, 10, 11], [0, 3, 0]]]

La lista tonal va a guardar el valor de la nota a la que corresponde la tonalidad, y

en seguida la suma de las veces que apareci cada una de las triadas para las
tonalidades mayores y menores, el cdigo se realiza de la siguiente manera:
tonal=[]
for i in range(len(resul)):
for j in range(len(resul[i])):
if j==1:
tt=0
for y in resul[i][j]:
tt=tt+y
tonal.append([resul[i][0][0],tt])
Por ejemplo:
resul [[[10, 2, 1], [3, 0, 0]], [[7, 10, 11], [0, 3, 0]]]
tonal [[10, 3], [7, 3]]

El siguiente paso es ordenar las listas dentro de tonal de mayor a menor dejando
la que tiene el mayor nmero triadas al inicio y la que tiene menor nmero al final.
intercambios=1
pasada=1
while pasada<len(tonal) and intercambios==1:
intercambios=0
for i in range(0,len(tonal)-pasada):
if tonal[i][1] < tonal[i+1][1]:
tonal[i], tonal[i+1] = tonal[i+1], tonal[i]
intercambios=1
pasada += 1

Ahora se va a comparar el valor de las notas de las tonalidades en psb con el

resultado en tonal y si son iguales se ha logrado deducir la tonalidad guardada en
la lista EN.
TN='';TI='';EN=[]
for i in psb:
TI=i[2]
if i[1]!='n':
TN= i[0]+i[1]
else:
TN= i[0]
if vlnt[TN]==tonal[0][0]:
EN.append(TN+TI)

Por ejemplo:
psb [['B', 'b', 'M'], ['G', 'n', 'm']]
tonal [[10, 3], [7, 3]]
vlnt[TN],tonal[0][0] 10 = 10
TN,TI,EN Bb M ['BbM']

Finalmente se imprimen los resultados y se guardan en TON, como puede

suceder que haya ms de una tonalidad por ser enarmnica en la lista EN,
entonces est es buscada en el diccionario dccenar y se elige la tonalidad
conveniente de acuerdo a las tonalidades que Bach us para El Clave Bien
Temperado.
TON=''
if len(EN)==1:
print 'LA TONALIDAD ES',EN[0]
TON=EN[0]
elif len(EN)==2:
print 'LA TONALIDAD ES',EN[0],'O',EN[1]
if tuple(EN) in dccenar:
print
'BACH
PREFIERE
USAR
ENARMONICA',dccenar[tuple(EN)][0]
TON=dccenar[tuple(EN)][0]
else:
print 'TONALIDAD INDEFINIDA SE TOMA',EN[0]
TON=EN[0]

LA

self.TON=TON

Por ltimo se guarda TON con Self para ser usado en las siguientes funciones.
5.7.4. USO DE LA TONALIDAD

En esta funcin se van a crear pequeos programas para usar la tonalidad hallada
y as analizar la secuencia MIDI de acuerdo a sta, el proceso es el siguiente:

Ilustracin 11: Diagrama de flujo para establecer diccionarios en la funcin TONalidad

La primera parte del cdigo que se explica a continuacin es el siguiente:

def TONalidad(self):
ton=self.TON
vlnt=self.vlnt
dccnts=self.dccnts
nt='';al='';ti=''
if len(ton)==3:
nt=ton[0];al=ton[1];ti=ton[2]
else:
nt=ton[0];al='n';ti=ton[1]

Ac se toman nuevamente los caracteres guardados en self.TON=ton por las

variables no (mota), al (alteracin), ti (Mayor o menor).
Ejemplo:
nt,al,ti B b M
self.ti=ti
tone=[]
ecl=['C','D','E','F','G','A','B']
pos=ecl.index(nt)
for i in range(8):
tone.append([ecl[pos]])
pos+=1
if pos == 7:
pos=0
self.TONN=nt+al+ti

Ahora se crea una lista tone con las notas que debe haber para la tonalidad
encontrada de esta manera:

ton=['BbM']
nt,al,ti B b M
tone = [['B'], ['C'], ['D'], ['E'], ['F'], ['G'], ['A'], ['B']] y se guarda nt+al+ti en self.TONN.

Entonces se agregan las alteraciones que corresponden a la tonalidad de la lista

tone:
if al!='n':
vl=vlnt[nt+al]
else:
vl=vlnt[nt]
EM=[2,2,1,2,2,2,1]
Em=[2,1,2,2,1,2,2]
for i in range(len(tone)):
if vlnt[tone[i][0]] - vl%12==-1 or vlnt[tone[i][0]] - vl%12==11:
tone[i][0]=tone[i][0]+'#'
if vlnt[tone[i][0]] - vl%12==1 or vlnt[tone[i][0]] - vl%12==-11:
tone[i][0]=tone[i][0]+'b'
if i < len(tone)-1 and ti=='M':
vl+= EM[i]
if i < len(tone)-1 and ti=='m':
vl+= Em[i]
self.tone=tone
Ejemplo:
tone = [['Bb'], ['C'], ['D'], ['Eb'], ['F'], ['G'], ['A'], ['Bb']]

El siguiente cdigo sirve para crear un diccionario llamado auxton que contiene los
grados de la tonalidad:
auxton={}
grad=['I','II','III','IV','V','VI','VII']
for i in range(7):
#print tone[i][0],vlnt[tone[i][0]],grad[i]
auxton[vlnt[tone[i][0]]]=tone[i][0],grad[i]
self.auxton=auxton
Ejemplo de auxton:

('C', 'II') 0
('D', 'III') 2
('Eb', 'IV') 3
('F', 'V') 5

('G', 'VI') 7
('A', 'VII') 9
('Bb', 'I') 10

El siguiente programa crea un diccionario dccvlton con todos los valores de 0 a

127 y los nombres correspondientes a la tonalidad de la siguiente manera:
qal=''
i=0
while i<7:
if len(tone[i][0])==2:
if tone[i][0][1]=='b':
qal='b'
if tone[i][0][1]=='#':
qal='#'
i=6
i+=1
be=['C','Db','D','Eb','E','F','Gb','G','Ab','A','Bb','B']
so=['C','C#','D','D#','E','F','F#','G','G#','A','A#','B']
n=0
dccvlton={}
for i in range(128):
if qal == 'b':
if n%12 in auxton and auxton[n]!=be[n]:
dccvlton[i]=auxton[n][0]
else:
dccvlton[i]=be[n]
elif qal == '#':
if n%12 in auxton and auxton[n]!=so[n]:
dccvlton[i]=auxton[n][0]
else:
dccvlton[i]=so[n]
else:
dccvlton[i]=dccnts[i]
n+=1
if n==12:
n=0
self.dccvlton=dccvlton

5.7.5. TRIADAS Y FUNCIONES ARMNICAS DE LA SECUENCIA

En esta funcin se analizarn las triadas que pertenecen a las funciones

armnicas de la secuencia MIDI:

Ilustracin 12: Diagrama de flujo para la funcin armonia

La programacin es la siguiente:
def armonia(self):
dccnts=self.dccnts
ti=self.ti
dccvlton=self.dccvlton
auxton=self.auxton
tone=self.tone
#print tone
vlnt=self.vlnt
trM=[[4,3],[3,4],[3,4],[4,3],[4,3],[3,4],[3,3]]
trm=[[3,4],[3,3],[4,3],[3,4],[4,3],[4,3],[3,3]]
grad=['1','2','3','4','5','6','7']
CA={};FA1={}
for i in range(7):
FA1[vlnt[tone[i][0]]%12]=grad[i]
if ti=='M':
CA[(vlnt[tone[i][0]])%12,(vlnt[tone[i][0]]+trM[i][0])%12,(vlnt[tone[i][0]]
+trM[i][0]+trM[i][1])%12]=grad[i]
elif ti=='m':
CA[(vlnt[tone[i][0]])%12,(vlnt[tone[i][0]]+trM[i][0])%12,(vlnt[tone[i][0]]
+trM[i][0]+trM[i][1])%12]=grad[i]

En el cdigo anterior se encuentra los acordes que le pertenecen a una escala

mayor o menor dependiendo del caso. En primer lugar, el diccionario FA1
almacena los valores en mod 12 de la escala y usando las listas trM y trn (cuyo
contenido son intervalos de las triadas correspondientes) se calcula la triada para
cada nota de la escala guardada en el diccionario CA.
Ejemplo:
FA1 1 = 10
FA1 2 = 0
FA1 3 = 2
FA1 4 = 3
FA1 5 = 5
FA1 6 = 7
FA1 7 = 9
CA
1 (10, 2, 5) Bb D F
2 (0, 3, 7) C Eb G
3 (2, 5, 9) D F A
4 (3, 7, 10) Eb G Bb
5 (5, 9, 0) F A C
6 (7, 10, 2) G Bb D
7 (9, 0, 3) A C Eb

A continuacin:

modnt=[];fnarm=[]
for i in evnt:
comp2=[]
for j in i:
comp2.append(j%12)
nn=list(comp2)

En ste punto del cdigo se toma lista por lista de la matriz evnt y a cada valor de
nota se le calcul el mdulo 12, luego se guarda la lista en nn como una lista.
if len(nn)==1 and nn[0] in FA1:
modnt.append(nn)
fnarm.append(['m',FA1[nn[0]]])
elif len(nn)==1:
modnt.append(nn)
fnarm.append([])

elif len(nn)>1:
io=0
for k in range(len(nn)):
comp=[]
for l in range(k,len(nn)+k):
comp.append(nn[l%len(nn)])
if tuple(comp) in CA:
modnt.append(comp)
fnarm.append(['p',CA[tuple(comp)]])
io=1
if io==0:
modnt.append(comp)
fnarm.append([])
self.modnt=modnt
self.fnarm=fnarm

Entonces se compara los valores de la lista nn: si nn es slo un valor y este valor
pertenece a una del las notas en FA1 entonces se almacena en modnt y fnarm, si
el valor es nuevamente uno solo pero no pertenece a FA1 entonces no se guarda
nada en fnarm. En el ltimo si nn es mayor a uno, se crean todas las
confinaciones posibles en los acordes con el fin de verificar si alguna combinacin
le pertenece a CA, que en dado caso ser parte de las funciones armnicas y ser
guardado nuevamente en las listas modnt y Fnarm que sern tiles ms adelante.

5.7.6. LISTA DE ORDENES PARA PURE DATA

Como Qlist recibe un archivo de texto con instrucciones, entonces hay que crear
las instrucciones necesarias para cubrir todos los parmetros audibles y de video,
por ello hay que crear una lista (matriz) en Python para cada aspecto; la primera
orden que precede a la primera lista puede ser la tonalidad definida como mayor o
menor, luego la lista de rdenes a tener en cuenta es aquella que ser necesaria
para ser comunicada la informacin MIDI hacia la salida de Pure Data esperando
para ser recibida por un sintetizador o un sampling, teniendo en cuenta el tempo y
sus cambios eventuales. La siguiente lista debe estar relacionada con el
movimiento de la animacin donde cada valor de nota representa una posicin y
desplazamiento, una parte muy importante de esta lista es asignar una posicin
para cada una de las notas que estn siendo activadas simultneamente; as

mismo es importante relacionar estos cambios de posicin con cambios de color

para las notas simples como tambin las notas simultaneas; la siguiente lista va a
contener las ordenes referidas al anlisis de los grados en la tonalidad como los
acordes pertenecientes a sta misma y, finalmente, las duraciones de cada una de
estas ordenes que sern ejecutadas por la funcin Qlist.

De acuerdo al protocolo Qlist de Pure Data, esta funcin va a crear una lista con
rdenes para que Pure Data las entienda y es con la que va a funcionar como
secuenciador de eventos MIDI y a su vez va a dar rdenes a GEM para que acte
la animacin; se van a crear paquetes de informacin con ordenes por tipo, as
ser ms fcil poder generar organizadamente la lista de rdenes. Esta funcin va
a tener varias etapas de la siguiente manera:

Ilustracin 13: diagrama de flujo para la funcin Ordenes

El primer paso es crear un archivo que va a leer Pure Data llamado pypd:
def Ordenes(self):
pev = open('pypd', 'w')
pev.write('')
pev.close()

El siguiente paso es crear un diccionario cuya clave sea la tonalidad y devuelva un

valor numrico relacionado con el nombre de la nota (de 0 a 11). Como van a
existir tonalidades mayores se crearn dos diccionarios llamados ToneM y Tonem:
ToneM={};Tonem={}
ToneM['DnM'],ToneM['GnM'],ToneM['CnM'],ToneM['FnM'],ToneM['BbM'],ToneM['Eb
M'],ToneM['AbM'],ToneM['C#M'],ToneM['DbM'],ToneM['F#M'],ToneM['GbM'],ToneM[
'BnM'],ToneM['CbM'],ToneM['EnM'],ToneM['AnM']='0','1','2','3','4','5','6','7','7','8','8','9',
'9','10','11'
Tonem['Dnm'],Tonem['Gnm'],Tonem['Cnm'],Tonem['Fnm'],Tonem['Bbm'],Tonem['A#
m'],Tonem['Ebm'],Tonem['D#m'],Tonem['Abm'],Tonem['G#m'],Tonem['C#m'],Tonem
['F#m'],Tonem['Bnm'],Tonem['Enm'],Tonem['Anm']='0','1','2','3','4','4','5','5','6','6','7','8'
,'9','10','11'
El resultado de ToneM={};Tonem={} es:
EnM 10 BbM 4 DbM 7 DnM 0 EbM 5 GbM 8 AbM 6 CbM 9 C#M 7 BnM 9 AnM 11 FnM 3 CnM 2
F#M 8 GnM 1 Bbm 4 D#m 5 Dnm 0 Ebm 5 G#m 6 Abm 6 A#m 4 Enm 10 C#m 7 Bnm 9 Anm 11
Fnm 3 Cnm 2 F#m 8 Gnm 1

Ahora se va a crear una variable llamada Tln en donde se guardar el valor a que
la tonalidad (self.TONN) pertenece:
Tnl=0;Mm=0
if self.TONN in ToneM:
Tnl=ToneM[self.TONN]
Mm=0
elif self.TONN in Tonem:
Tnl=Tonem[self.TONN]
Mm=1
else:
Tnl=2
Mm=0
Ejemplo:

self.TONN,Tnl,MmBbM 4 0

Para la siguiente etapa, se va a generar un valor que ser el valor de color para
cada nota; la lista clnot va a guardar dos valores, el primer valor es cero y el
segundo, el valor de la tonalidad de la siguiente manera:
clnot=[]
if self.TONN[1:2]=='n' and self.TONN[:1] in self.vlnt:
clnot.append([0,self.vlnt[self.TONN[:1]]])
elif self.TONN[1:2]!='n' and self.TONN[:2] in self.vlnt:
clnot.append([0,self.vlnt[self.TONN[:2]]])
else:
print 'error en self.TONN[x:x]'
Ejemplo:
self.TONN,Tnl,MmBbM 4 0
clnot [[0, 10]]

De acuerdo a la siguiente ilustracin se va asignar un color a cada tonalidad; la

primera fila contiene el nombre de la tonalidad, la segunda el valor de la nota y la
ltima el valor del color para Pure Data

Bb Eb Ab C#

F#

10

11

600

650

700

750

800

850

900

950 1000 1050 1100 1150

Ilustracin 14: Tabla con los valores de nota y valores de color para cada tonalidad

Lton=[2,7,0,5,10,3,8,1,6,11,4,9]
colorTN={};con=600
for i in range(12):
colorTN[Lton[i]]=con
con+=50
CN=clnot[0][1]
global COLORNOTA
COLORNOTA=colorTN[CN]
print 'El Color de la Tonalidad es',COLORNOTA;print
Ejemplo:
clnot [[0, 10]]
El Color de la Tonalidad es 800

Cada tonalidad tendr una paleta de colores y su nota cero (nota de la tonalidad)
es la que se ha encontrado con el diccionario colorTN[CN], la siguiente tabla es un
ejemplo para la tonalidad de Re Mayor:

Consonancias perfectas

Consonancias imperfectas

F#

A#

Disonancias absolutas

Smicns

G#

C#

D#

10

11

8,33

16,7

25

33,3

41,7

50

150

175

200

225

250

600

592

583

575

567

558

550

450

425

400

375

350

Ilustracin 15: Tabla de ejemplificacin de paleta con colores creados para la tonalidad de Re (mayor o menor)

De acuerdo a la anterior ilustracin, la primera fila indica la nota, la siguiente es el

nmero de semitonos que hay a partir de Re, la tercera es el valor de relacin
sustrado al valor de Re = 600 y la cuarta fila son los valores que daran de
acuerdo a la relacin; el cdigo para asignar un valor a cada nota es el siguiente:

La programacin es la siguiente:
con=clnot[0][1]
for i in range(11):
clnot.append([i+1,con+i+1])
for i in range(len(clnot)):
clnot[i].append(clnot[i][1]%12)

En este momento se crea una tabla que consta de tres columnas: La primera de 0
a 11 la segunda toma el valor de la nota de la tonalidad y se le suma 10 valores
ms y la tercera son estos valores calculados con el modulo 12.
Ejemplo:
Tonalidad DM
El Color de la Tonalidad es 600
clnot[0][1] = 2
clnot
[0, 2, 2]
[1, 3, 3]
[2, 4, 4]
[3, 5, 5]
[4, 6, 6]

[5, 7, 7]
[6, 8, 8]
[7, 9, 9]
[8, 10, 10]
[9, 11, 11]
[10, 12, 0]
[11, 13, 1]

El siguiente paso es crear una lista con los valores de los intervalos Lton y con
ayuda de la lista anterior clnot se establecen las relaciones para el color as:
De intervalos
colorNot={}
RLCNINTV={}
Lton=[0,5,7,4,8,3,9,6,10,2,11,1]
ivtest=Lton
con1=colorTN[clnot[0][1]]
con2=colorTN[clnot[0][1]]-150
rcon1=0
rcon2=150
for i in range(12):
if i <=6:
colorNot[(Lton[i]+CN)%12]=con1
RLCNINTV[Lton[i]]=rcon1
con1-=(50/6)
rcon1+=(50/6)
else:
colorNot[(Lton[i]+CN)%12]=con2
RLCNINTV[Lton[i]]=rcon2
con2-=25
rcon2+=25

El diccionario que va a contener los valores es colorNot. Se asigna a con1 el valor

de la tonalidad, y con 2 este mismo sustrayndole 150 al valor colorNot. Tambin
se va a crear un diccionario paralelo que va a contener los valores de la relacin
COLORNOTA es decir y es por ello que rcon1=0 y rcon2=150; Finalmente se toma
cada valor de Lton y se le asigna un valor. La relacin es de 50/6 para las
consonancias y de 25 para las disonancias en relacin el valor de la nota de la
tonalidad.
Ejemplo:
Tonalidad DM
El Color de la Tonalidad es 600
Clnot
colorNot
RLCNINTV

2
3
4
5
6
7
8
9
10
11
0
1

600
350
400
560
576
592
450
584
568
552
425
375

0
250
200
40
24
8
150
16
32
48
175
225

Ahora ya que se tiene un diccionario (colorNot) con el valor de color para cada
nota; entonces se va asignar dicho valor a todas las notas encendidas de la
secuencia; ac se crear el primer paquete de informacin respecto al color:
pclax=[]
PNOT=0
for i in evnt:
aux=[]
for j in range(len(i)):
if j==0:
PNOT=colorNot[i[j]%12]
aux.append(colorNot[i[j]%12])
if j<len(i)-1:
aux.append((PNOT+RLCNINTV[(i[j+1]-i[j])%12]))
PNOT=PNOT+RLCNINTV[(i[j+1]-i[j])%12]
pclax.append(aux)#

La lista pclax va a contener los valores de color, se toma la lista evnt as como
tambin cada lista que puede estar dentro de s misma y por esto se usan dos
siclos for; a cada valor de nota se le calcula el mdulo 12 e inmediatamente se
ingresa como clave en el diccionario colorNot para saber su valor de color que es
aadindolo en la lista pclax que ser usada ms adelante.

El siguiente paquete de informacin sirve para guardar la informacin de las notas

que tienen que ver con las funciones armnicas:
notax={}
Tonl=colorTN[clnot[0][1]]
notax['1'],notax['2'],notax['3'],notax['4'],notax['5'],notax['6'],notax['7']=0,2,4,5,7,9,11

FM=[0,1,1,0,0,1,2]
Fm=[1,2,0,1,0,0,2]
pfaaux=[]
for i in self.fnarm:
if len(i)!=0 and i[0]=='p':
if Mm==0:
pfaaux.append([i[0],colorTN[(notax[i[1]]+clnot[0][1])%12],F
M[int(i[1])-1]])
elif Mm==1:
pfaaux.append([i[0],colorTN[(notax[i[1]]+clnot[0][1])%12],F
m[int(i[1])-1]])
elif len(i)!=0 and i[0]=='m':
if Mm==0:
pfaaux.append([i[0],colorTN[(notax[i[1]]+clnot[0][1])%12],F
M[int(i[1])-1]])
elif Mm==1:
pfaaux.append([i[0],colorTN[(notax[i[1]]+clnot[0][1])%12],F
m[int(i[1])-1]])
else:
pfaaux.append([])

La lista self.fnarm que se haba creado dentro de la funcin def armonia(self),

contienen informacin revisando las notas simples (m) y simultaneas (p) buscando
si son parte de los grados de las tonalidad o si son triadas pertenecientes a las
funciones armnicas. Los condicionales importantes verifican si son simultneas o
no, en caso de que no se cumpla ninguna de las dos, se agregara una sub lista
vaca a la lista pfaaux donde se van a guardar los resultados de proceso. Notax es
un diccionario con la posicin de las notas importantes de la tonalidad, FM y Fm
indican si la triada es Mayor 0, menor 1 o disminuida (2); La finalidad de este
proceso es dar el valor de color a cada triada o nota encontrada que est
vinculada a las funciones armnicas de acuerdo a su tonalidad.

La secuencia se compone de notas encendidas y apagadas como se puede

encontrar en la lista sos mientras que en la lista evnt se han organizado los
eventos encendidos y simultaneas cada uno con su respectiva duracin. El
proceso siguiente consiste en hacer que todos los paquetes de informacin (listas)
tengan el mismo nmero de listas (sub-listas); su nmero de listas total debe ser

igual al de sos; de esta manera se organizar toda la informacin y estar lista

para crear el archivo que controlar las rdenes:
A manera de representarles con un nombre, en este punto se tienen paquetes de
informacin, ahora con cada uno de estos paquetes se crean cajas de
informacin organizada que se agregar en las siguientes listas:
prt=[]#eventros protocolo pd ch,vel,not
pdr=[]# duraciones
pol=[]#notas polifonicas en la duracion time
pcl=[]#color notas polifonicas en la duracion time
ptm=[]#cambios de tempo
pvl=[]#vel sin ceros para el eje Z##
pfa=[]#color funciones armonicas

j=0
t=0
for i in range(len(sos)):
prt.append([sos[i][1],sos[i][2],sos[i][3]])# pd ch,vel,not
pdr.append(sos[i][4])# duraciones
pvl.append(sos[i][2])# vel sin ceros
if sos[i][5]==time[j]:
pol.append(evnt[j])#notas polifonicas en la duracin time
pcl.append(pclax[j])#color notas polifonicas
pfa.append(pfaaux[j])#color funciones armonicas
if t<len(tmp) and tmp[t][1]==time[j]:
ptm.append([tmp[t][0]])
t+=1
elif i>0 and j>0 and t<len(tmp) and tmp[t][1]<time[j] and
tmp[t][1]<time[j-1]:#cuadra cambios de tempo
ptm.append([tmp[t][0]])
t+=1
else:
ptm.append([])#cuadra cambios de tempo
if j<len(time)-1:
j+=1
else:
pol.append([])
ptm.append([])
pcl.append([])
pfa.append([])

Se arranca con un ciclo for en un rango que contiene toda la secuencia y se

guarda en prt todas los eventos con canal, velocidad y valor de la nota; en pdr se
guardan nicamente las duraciones y tambin pvl que contiene las velocidades
para cada evento; el primer condicional sirve para equiparar las duraciones de los
eventos en relacin a las duraciones de la secuencia, entonces se agrega la
informaciones a pol con las notas simultaneas, pcl con los colores del cada nota
de evnt y pfa con los colores de las funciones armnicas, si en algn momento las
duraciones no son iguales a las listas mencionadas anteriormente, se les asigna
una sub-lista vaca. Finalmente se hace lo mismo con las duraciones de los
cambios de tempo. Ahora se agregar la toda la informacin en el archivo pypd
por medio de pev.write:

Gua para tener una referencia

##tonalidad M o m
##ptm=[]#cambios de tempo
##prt=[]#eventros protocolo pd ch,vel,not
##pvl=[]#vel sin ceros para el eje Z##
##pol=[]#notas polifonicas en la duracion time
##pcl=[]#color notas polifonicas en la duracion time
##pfa=[]#color Funciones Armnica en la duracion time
##pdr=[]#duraciones

Se abre el archivo con ab+ para ir agregando informacin:

pev = open('pypd', 'ab+')

El primer elemento a agregar es si la tonalidad, Tonl que es un valor de color, Mm

si es Mayor (0) o menor (1) con una duracin 0.0, adicionalmente se agreg un
contador que llevar el nombre de nev. El cdigo es de la siguiente forma:
pev.write (str('Tnl %s; Mm %s; 0.0\n' % (Tonl,Mm)))
for i in range(len(prt)):
pev.write (str('nev %s; ' % (i)))

Ahora el siguiente elemento a agregar con los cambios de tempo tmp, el

condicional hace que solo se agreguen las listas que no estn vacas:

if len(ptm[i]) != 0:
pev.write (str('tmp %s; ' % (ptm[i][0])))#'''

En seguida los eventos como canal ch, velocidad vel y el valor de la nota note
desacuerdo al protocolo de Pure Data:
pev.write (str('ch %s; vel %s; note %s;' % (prt[i][0],prt[i][1],prt[i][2])))

Se agregan las velocidades de nota diferente de cero vlz, por ello el condicional:
if pvl[i] != 0:
pev.write (str(' vlz %s;' % (pvl[i])))#'''

Ahora el color de las notas simultaneas sim, en donde hay que usar un ciclo para
aquellas notas mayores a una nota:
if len(pol[i]) != 0:
for j in range(len(pol[i])):
pev.write (str(' sim%s %s;' % (j,pol[i][j])))#'''

As mismo como se hizo anteriormente pero con el color de las notas simultaneas
clr, en donde hay que usar un ciclo para aquellas notas mayores a una nota:
if len(pcl[i]) != 0:
for j in range(len(pcl[i])):
pev.write (str(' clr%s %s;' % (j,pcl[i][j])))#'''

Los siguientes son los valores de color dependiendo de si son para tonalidades
Mayores faclm y o tonalidades menores faclp en relacin a las funciones
armnicas:
if len(pfa[i]) != 0 and pfa[i][0] == 'm':
pev.write (str('faclm %s; fadom %s;' % (pfa[i][1],pfa[i][2])))#'''
if len(pfa[i]) != 0 and pfa[i][0] == 'p':
pev.write (str('faclp %s; fadop %s;' % (pfa[i][1],pfa[i][2])))#'''

Por ltimo las duraciones para cada fila de eventos aadiendo un salto de lnea:
pev.write (str(' %s' % (pdr[i]))) #'''
pev.write('\n')
pev.close()

Al finalizar el ciclo, se cierra el archivo pev que se haba abierto.

5.8.

MOVER ARCHIVOS GENERADOS AL DIRECTORIO GEM

Como el sistema se ha dispuesto en varias carpetas de la siguiente manera:

((MG))
Archivo MIDI
Archivos MIDI para ser analizados.
Interfaz
Se encuentra el programa MIDICSV y el archivo con el cdigo de todo el programa
incluyendo la programacin de la interfaz grfica.
PdGem
El archivo pypd y el archivo de la programacin hecha en pure data (PyPdGem)

Entonces se va a copiar el archivo pypd desde la carpeta Interfaz hasta la carpeta

PdGem de la siguiente manera:
def PYPD(self):
sourceFile=DirP+'\\pypd'
destinationFile=DirP[:-8]+'PdGem'
shutil.copy(sourceFile, destinationFile)

La variable sourceFile contiene el directorio y el nombre del archivo, la variable

destinationFile la direccin de destino y shutil.copy(sourceFile, destinationFile) es
la orden para que se ejecute el proceso de copiado.

5.9.

PROGRAMACIN EN PURE DATA

La programacin en Pure Data tiene varias etapas de la siguiente manera:

Ilustracin 16: Estructura general de la programacin en Pure Data

En general los elementos ms importantes son: pd gemwin que es donde se crea

una ventana lista para que se ejecute el renderizado de la animacin, pd QLIST,
es el que recibe las ordenes de la lista pypd y se ejecutan a un tempo dado, pd
PLANO, pd ESFERAS, pd LUZ, pd COLOR NOTAS, es donde se le asigna un
color a las notas esferas cuando funciona con un controlador en tiempo real, pd
MIDI recibe y enva la informacin que entra y sale de Pure Data, y pd MONITOR
es til para ver lo que est entrando desde Qlist.

Ilustracin 17: Diagrama de flujo de la programacin general en Pure Pata

5.9.1. QLIST, PYPD, SECUENCIA DE EVENTOS

El programa en Pure Data est destinado a leer con Qlist la lista de ordenes pypd,
tambin va a enviar la informacin MIDI a un sintetizador y mediante la aplicacin
GEM se programar la animacin que despus ser controlada por la lectura de
Qlist extrada del la informacin del archivo pypd. Todos estos procesos sern
programados y ordenados dependiendo de su funcionalidad.

Ilustracin 18: Estructura del programa Qlist

El objeto Qlist puede ser usado para leer mensajes ordenados con diferentes
duraciones cronolgicamente, estos mensajes son enviados a Objetos receive
que deben ser nombrados con unas variables; el mensaje con el nombre read
pypd toma el archivo guardando en la misma carpeta que se encuentra la orden
Qlist del archivo programado de Pure Data PyPdGem.pd, el activador o pulsador
es el botn (bang) verde que a su vez activa tambin al mensaje rewind, bang
ejecutando a Qlist, entonces va a leer los eventos lnea a lnea dependiendo de la
duracin; otro elemento importante es el mensaje tempo, bang que va a recibir

valores una vez ejecutado Qlist y que cambiar el tempo de acuerdo a los masajes
en la lista, si no existiera el mensaje tempo, Qlis toma el tempo a 1 segundo por
pulso = 120 tempo musical. Si se est ejecutando una lista de mensajes en Qlist y
se le da la orden de que ejecute otra lista, Qlist detiene el proceso que tena y
pone en marcha la nueva orden; existen varios archivos que se van a reproducir
como el archivo offall cuyo contenido son todas las notas de 0 a 127 con vel=0 y
con esto se desactivan todas las notas parando la ejecucin de Qlist; as mismo
hay otros archivos que pueden ser ejecutados por Qlist como los test 1,2,3,4; cuyo
mensaje Ntese que hay un objeto con el nombre de r nev ste objeto va indicar
el evento que est ejecutando.

Este programa tambin posee unos objetos con el nombre de pd OSC de 2-7, su
programacin est dada as:

Ilustracin 19: Estructura para la llegada de mensajes por el por protocolo OSC

EL objeto import mrpeach importa las libreras de Pure Data, el objeto udpreceive
9002 es el que contiene el nmero de canal por el cual va a entrar la informacin,
el objeto unpackOSC decodifica la informacin entrante y el objeto routeOSC
/print, recibe la informacin que lleva la variable /print. Entonces de esta manera
Pure Data recibe las rdenes que sern enviadas desde Python. Los botones de
colores en la parte superior bang reciben la informacin mediante OSC por
diferentes canales (de 9001 9007) enviando la seal de pulsado, estos a su vez
enva la orden de pulsado por medio de send a un botn receive con el mismo
color que recibir la informacin y ejecutar la orden a Qlist; send y receive son
propiedades que tienen los objetos pulsadores bang.

5.9.2. PROTOCOLO MIDI EN PURE DATA

En Pure Data existe la posibilidad de controlar las entradas y salidas MIDI, as

mismo existen las funciones de programacin tiles para envar y recibir la
informacin como valores controlables que se pueden manipular. Para estas
propiedades se debe encontrar la manera de que Pure Data reciba la informacin
de un controlador as como tambin un sintetizador o sampling pueda recibir la
informacin de Pure Data.

El programa en Pure Data est destinado a leer con Qlist la lista de ordenes pypd,
tambin va a enviar la informacin MIDI a un sintetizador y mediante la aplicacin
GEM se programar la animacin que despus ser controlada por la lectura de
Qlist extrada del la informacin del archivo pypd. Todos estos procesos sern
programados y ordenados dependiendo de su funcionalidad.

En el paquete pd MIDI se encuentra el siguiente programa:

Ilustracin 20: Estructura de entrada y salida de la informacin MIDI en Pure Data

Los mensajes ledos por Qlist son enviados como mensajes send, por ello para
recibirlos se antepone en la escritura de los objetos la variable con la letra r (r ch,
r vel, r note); El objeto noteout es el programa que se encarga de traducir los
valores en informaciones MIDI envindolos al dispositivo MIDI (sintetizador,
sampling, etc.). De la misma manera sucede para la informacin MIDI de entrada

mediante los objetos notein que decodifica la informacin MIDI entrante en

valores del entorno Pure Data.
5.9.3. VENTANA DE ANIMACIN GEM

Para programar en la herramienta de animacin GEM de Pure Data se deben

conocer bien las funciones reconociendo los alcances y limitaciones de animacin.
GEM no es un software de animacin sino una aplicacin que requiere de
bastante conocimiento para poder crear imgenes; es decir que no es un
programa como Flash o Blender donde las herramientas de animacin son
tremendamente amables con el usuario, en cambio GEM debe ser programado
desde su desarrollo grfico de programacin y cada objeto tendr una estructura
para que ste pueda visualizarse en el cuadro de animacin.

Ilustracin 21: Estructura del programa para la creacin de la ventana de animacin GEM

El primer objeto (pd OSC1) es el que tiene la funcin de recibir informacin

mediante el protocolo OSC como ya se explic anteriormente cuyo trabajo es
activar un pulsador de color amarillo, este pulsador ejecuta un pequeo programa
pd gemwin (create/destroy) que cumple con la funcin de abrir y cerrar la ventana
de animacin; sta ser la ventana en donde se hace la renderizacin de todos los
objetos programados que se explicarn ms adelante. Adicionalmente existen un
pulsador sin color que acta una vez creada la ventana, enviando informacin de
partida a la programacin de los objetos y un conmutador (toggle) que activa o
desactiva la representacin visual de las luces que se explicarn ms adelante.

Ilustracin 22: Ventana de animacin

5.9.4. PROGAMACION DEL PLANO CURVE3D

Ilustracin 23: Ejemplo de maneras para graficar un mismo plano

La curva 3D es una matriz de puntos al que se le puede asignar varias

propiedades como traslacin, rotacin, color, tipos de renderizado, grilla y
modificar sus puntos movindolos en el espacio. El plano se us con el fin de
representar un escenario al que se le van a proyectar varias luces.

Ilustracin 24: Ejemplo del plano vista de frente y rotado en el eje z

La programacin del plano es la siguiente:

Ilustracin 25: Estructura de programacin general del plano

El primer objeto es la cabeza gemhead que al ser unido con el objeto curve3d
crean la curva (plano); despus de la cabeza se le une a la propiedad de
translacin (en los ejes x, y, z), y ms adelante la propiedad de rotacin (para los
ejes, x, y, z), finalmente se le aade el objeto de color, al que le se asignan los
valores RGB. Hay un objeto receive con el nombre de r curve3d, este objeto es
el puerto de llegada para propiedades como draw con propiedades como fill poin
line y la grilla grid cuya definicin podr ir variando. Por ltimo hay un objeto res
con la propiedad resolucin fija de 5 por 5.
El ltimo objeto creado es pd MatrizPlano que contiene la programacin para la
posicin de cada uno de los puntos de la curva en los ejes x, y, z de la siguiente
manera:

Ilustracin 26: Estructura de programacin para controlar en una grilla de 5x5 en los 3 ejes del plano

Este es el mtodo que se ha desarrollado para sujetar y manipular cada punto en

el plano cuya grilla costa de 5 por 5 y por ello existen subprogramas llamados pd
XYZ00 hasta pd XYZ44 que envan la informacin de su ubicacin al objeto r
curve3d de la siguiente forma:

Ilustracin 27: Estructura para cada punto de la grilla en el plano

Luego para tener un control ms preciso sobre los ejes del plano se usan variables
de nmero con el cual pueda editar los ejes de la grilla como filas y columnas
adems del eje de profundidad. Finalmente los valores constantes son valores que
se activan una vez inicia la animacin y son aquellos los que le dan la forma
simulando un escenario.

5.9.5. PROGRAMACIN DE COLOR Y DE LUCES SPOT LIGHT

Cada tonalidad va a tener un color de acuerdo a la propuesta del seor Llus

Pujals i Carretero42 (msico y pintor) de la siguiente manera:

Ilustracin 28: Propuesta de color para cada tonalidad del seor Llus Pujals i Carretero

Los colores basados en esta figura, sern aproximados a valores RGB con el fin
de facilitar la utilizacin de la programacin del color; los colores aproximados son
representados por sus correspondientes letras as:

C
G

Bb

Ab

Eb
B

C#
F#

Ilustracin 29: Propuesta de color para cada tonalidad en RGB

Para facilitar el uso del color RGB en Pure Data se crea un sistema que relaciona
valores sencillos con la combinacin de los 3 valores RGB, por ejemplo el rojo que
equivaldra en RGB a 255-0-0, ser igual a el valor 0; el amarillo que en RGB es
255-128-0, equivale a 100 y el verde que es 0-255-0 ser igual a 200; es decir que
la relacin entre los colores de todas las tonalidades varan de 50 en 50. Como se
van a realizar operaciones matemticas con sustracciones, entonces para facilitar
42

Llus Pujals i Carretero: Las notas musicales y sus colores [en lnea]. <
http://www.lluispujals.com/escucha_la_musica_disfruta_de_sus_colores_013.htm > [citado en 02-05-2011]

el manejo de estos valores, el programa que relaciona RGB con los valores se
extiende de 0 a 1200 repitindose la gama de colores a partir del 600.

Bb Eb Ab C#

F#

11

10

600

650

700

750

800

850

900

950 1000 1050 1100 1150

Ilustracin 30: Tabla que relaciones colores, tonalidades valor de nota y valor de color correspondiente

Ahora, cada tonalidad tendr una paleta de colores creada a partir de una tabla de
intervalos desde los ms consonantes hasta los ms disonantes donde la
consonancia est representada por los colores adyacentes y la disonancia por
colores contrastes; En seguida una tabla de referencia para ubicar los colores
primarios (P) segundarios (S) y terciarios (T).

Ilustracin 31: 18: Referencia de colores primarios (P) segundarios (S) y terciarios (T).

A continuacin un ejemplo para la creacin de la paleta de colores en base a la

tonalidad de Re con el cifrado de las notas, en la segunda fila se encuentra el
valor de intervalo al que corresponde; la tercera fila contiene la relacin de color
para los valores de los intervalos que est dada en 50/6 entre la primera nota
hasta la ltima de las consonancias perfectas, luego para la semi-consonancia y
las disonancias absolutas, la relacin va desde 150 respecto a la primera nota, y
va disminuyendo de 25 en 25 hasta la ms disonante; la ltima fila es un ejemplo
numrico.

Consonancias perfectas

Consonancias imperfectas

Disonancias absolutas

Smicns

F#

A#

G#

C#

D#

10

11

8,33

16,7

25

33,3

41,7

50

150

175

200

225

250

600

592

583

575

567

558

550

450

425

400

375

350

Ilustracin 32: Tabla de ejemplificacin de paleta con colores creados para la tonalidad de Re (mayor o menor)

La tabla, sobre una escala desde el intervalo ms consonante al ms disonante,

ha sido creada correlacionando la informacin de varias fuentes como la
teoria.com43, suscita.es44, y una fuente cuya informacin (versin en ingls) est
muy completa sobre este tema encontrada en wikipedia.org45, entre otros. En
realidad no existe claramente una tabla pero si unas pautas que contribuyeron a
deducirla; los intervalos para generar los colores estn sujetos a la consideracin
de si son consonantes o disonantes basados en el periodo de la prctica comn
de la historia para la msica occidental.

Consonancias imperfectas

C o nso nanci as p er f ect as

Smicns

Disonancias absolutas

10

11

4J

5J

3M 6m 3m 6M

4A

7m 2M 7M 2m

3A

6d

4d

5d

6A

5A

2A

7d

3d

Ilustracin 33: Tabla de intervalos del ms consonante al ms disonante relacionado al nmero de semitonos y sus
posibles nombres correspondientes

Tabla de referencia.

43

Jos Rodrguez Alvira: Consonancias y Disonancias [en lnea]. <

http://www.teoria.com/referencia/c/consonancia.htm > [citado en 03-05-2011]
44
Bases de Matemtica y Fsica Musical [en lnea]. < http://www.suscita.es/basemate.htm > [citado en 0305-2011]
45
Interval (music): [en lnea]. < http://es.wikipedia.org/wiki/Intervalo_%28m%C3%BAsica%29 > [citado en
03-05-2011]

II

III

IV

VI

VII

2m 2M

3d

4
5
6
7

10

11

12

7m 7M

7A

2A
3m 3M

3A

4d

4J

4A
5d

5J

5A

6d

6m 6M
7d

6A

Ilustracin 34: Tabla de referencia, relacin valor de intervalo en semitonos y nombre

Al haber creado esta relacin de color se puede creer que ya est resuelta pero
an no logra resolver el estado de color para varias notas simultneas; es decir la
intencin de representar las notas consonantes o disonantes con colores
adyacentes o contrastes, an no se logra porque la nota solo dependera de la
escala de colores, es decir que si la tonalidad de Do mayor, se activa la nota C-FG, la relacin visual de color entre C y F es congruente, entre C y G es congruente
pero entre F y G no lo es porque de acuerdo a la tabla anterior las notas C-F-G
tiene colores adyacentes, pero F y G son notas disonantes con un intervalo de
segunda mayor igual a 2 semitonos; entonces se plantea la posibilidad de asignar
un color a la primera nota, es decir que si existe una meloda, est va a tener los
colores de la paleta mencionada, pero si existen ms de una nota, el color de la
segunda nota depender del intervalo, entonces la primera nota tiene un valor
correspondiente a la paleta de colores por tonalidad y para la segunda nota se
calcula el intervalo y dependiendo de est (consonante o disonante), asignar un
valor de color (adyacente o contraste); si existe una tercera nota, se calcula el
intervalo entre la segunda y la tercera y se asigna un color y as se resuelve la
visualizacin para la consonancia o disonancia de las notas.

Las esferas se van a encontrar en un escenario iluminado, que se grafica creando

un plano que se doble mostrndose como un piso y una pared, ahora las esferas y
el plano solo, no tendran sentido visual si no existe la luz. Pure Data cuenta con
un objeto luz que adems de proyectar una luz, se puede rotar, trasladar, y se
pueden editar parmetros como el color proyectado. Al mezclar los colores de la

luz con el color de las esferas el resultado queda combinado, por ello hay que
tener cuidado en no variar demasiado el color de las esferas.

Alguna de las luces pueden iluminar con luz blanca las esferas para que stas no
pierdan su color original, otras luces pueden ser proyectadas en la pared del
escenario con colores relacionados a el anlisis que se hizo para los grados de las
escalas y las triadas, encontradas en la secuencia. Entonces el producto final de
color ir alrededor de la paleta de colores de acuerdo con la tonalidad, logrando
experimentar matices que dependern de la estructura musical.

Las luces se programaron posicionndolas en el espacio con el fin de que stas

sean proyectadas en el plano. La estructura para construir cada luz (pd LUZ00) se
compone de la siguiente programacin:

Ilustracin 35: Estructura del programa para la creacin de una luz

La cabeza como todo objeto a ser construido debe ir conectado a la funcin que
es el elemento a graficar, en este caso se llama spot_light, que es un elemento al
que se le pueden asignar varias propiedades como la rotacin rotateXYZ -120 120 -120 y la propiedad de translacin translateXYZ 0 0 0; se le aade tambin
un elemento llamado debug $1 til para visualizar la luz en el espacio de la
animacin, adicionalmente a la cabeza existen dos puertos de entrada en
spot_light tiles para asignarle el color RGB y el siguiente que contiene tres
valores, la intensidad de la luz, el degradado sobre las paredes y cono de ngulo

de corte de la luz. Para el control de este elemento en la animacin se cre un

mtodo

(pd Crtl) que permite la fcil manipulacin de todas las propiedades

mencionadas cuya informacin ser comunicada mediante los elementos

inlet/outlet desde el programa pd Crtl al programa pd LUZ00; el programa pd
Crtl posee los siguientes elementos:

Ilustracin 36: Estructura para el control de color y movimiento de rotacin y traslacin para las luces

El primer objeto comunica la orden de encendido o apagado de la luz, el objeto r

faclm, recibe la orden generada por la funcin armonia programada en Python;
un valor que define el color de la luz, el objeto pack f 50 unido a objeto line
logran generar un recorrido cuyo movimiento se incrementa o decremento en un
tiempo (en este caso son 50 ms), es decir el Hslider que est en la parte superior
y recibe un valor de r faclm, el segundo Hslider tardar la posicin actual hasta
llegar al valor del Hslider anterior 50 ms generando as un recorrido y no un
cambio abrupto como si fuese con un delay.

El objeto r Mm recibe 0 si la tonalidad e mayor y 1 si la tonalidad es menor,

entonces entra en un pequeo programa llamado pd if_Mm que genera un valor
dependiendo si es Mayor (0) o menor (88) de la siguiente manera:

Ilustracin 37: Estructura condicional para asignar un valor de intensidad a la luz

Siguiendo la programacin de la figura anterior, este valor se proyecta en un

Vslider y entra al programa pd COLOR as como tambin el valor que se ha
producido por r faclm.
El subprograma pd COLOR es un desarrollo para facilitar el uso de valores
versus colores RGB de GEM as:

Ilustracin 38: Estructura programa para traducir 3 variables RGB en un solo control, programa que oxida y
degrada el color

Su funcin es tomar un valor que puede variar desde 0 hasta 1200 y transformarlo
en 3 valores RGB (255 255 255) que varan a su vez de 0 a 255 y definen el color
para ser enviados al objeto luz spot_light; la idea es que al desplazar la barra en
Hslider el color vaya en gamas pasando desde los rojos hasta los violetas. Esta
estructura comienza con obtener un valor (0-1200) luego entra nuevamente a un
subprograma llamado pd RGB_linea as:

Ilustracin 39: Estructura Sub programa para toma un valor de entrada y traducirlo en tres valores para RGB

Al tomar el valor mediante condicionales verifica que el valor est dentro de los
rangos 0-100-200-3001200 y dependiendo de ste incrementa o decremento el
valores de 0 a 100, en seguida mediante una relacin los valores se traducen en
los 3 valores RGB de 0 a 255. En el siguiente ejemplo se puede ver como las 3
barras (Vslider) cambian a medida que vara el valor numrico debajo de Hslider
(tenga en cuenta que el valor que se va variando es el objeto nmero de 50 en 50
que se encuentra debajo de Hslider)

Ilustracin 40: Ejemplo de gamas de color respecto al programa de transformacin en colores RGB

Al tomar el valor 600 llega de nuevo al color rojo y comienza de nuevo la gama
hasta llegar al valor 1200; estos valores se distribuyeron de 100 en 100 para
facilitar su uso y crear la paleta de colores a partir de valores diseados en la
funcin de Ordenes por medio de la tabla que distingue intervalos desde los
consonantes hasta los ms disonantes.

Retomando la estructura que controla las propiedades del color, la segunda barra
Vslider, es la que degrada el color o lo oxida, su rango est entre -255 y 255 y lo
que hace esta variable dentro del programa pd COLOR es sumar el valor por un
factor agregndoles o sustrayndoles el mismo valor a todos los valores RGB
ejemplo:

Ilustracin 41: Estructura detalle del programa para oxidar y degradar el color

Tenga en cuenta las barras ubicacin de las barras Vslider que representan a
RGB respecto a la barra Vslider que oxida o degrada el color.

Ilustracin 42: Ejemplo para degradacin y oxidacin del color

Las siguientes propiedades que se han estado describiendo en el programa pd

Crtl se dividen en 3 grupos que son: el primero, que contiene tres valores como la
intensidad de la luz, el cono de ngulo de corte de la luz y el degradado sobre las
paredes. El siguiente grupo consiste en la rotacin de los 3 ejes, y el ltimo grupo
es la traslacin de los 3 ejes; por cada grupo hay un programa como pd
AT_AC_DE, pd Rotate, pd Traslate que simplemente son relaciones numricas
para facilitar el uso de estos valores dentro del espacio de la imagen.

Ilustracin 43: Estructura del programa control de propiedades de la luz

Para cada uno de los grupos hay un pulsador que activa valores preestablecidos
para la ejecucin de la animacin organizando a cada una de las luces en sus
propiedades de inicio.

Ejemplo de propiedades de una luz (activado debug $1):

Ilustracin 44: Ejemplo de propiedades de una luz (activado debug $1):

Ilustracin 45: Ejemplo del control de: radiacin, rotacin y traslacin de la luz

El programa general de las luces pd LUZ contiene 7 luces distribuidas en el

espacio dispuestas a recibir rdenes de la lista Qlist distribuidas de la siguiente
manera:

Ilustracin 46: Estructura general de los programas de las luces pd LUZ

Su resultado se puede observar en las siguientes imgenes, en algunas se puede

observar la propiedad debug mientras que los otros se salen de los lmites de la
visualizacin:

Ilustracin 47: Ejemplo de todas las luces en conjunto con la propiedad debug activada

Para una de las luces centrales se utiliz una variable con el contenido de la
velocidad de nota logrando proyectarse como ms intensa o ms suave
hacindose ms evidente la fuerza con que se activan las notas de la siguiente
manera:

Ilustracin 48: Estructura y sub-estructura del programa para la orden de velocidad en nota traducida en
intensidad de luz

El objeto r vlz recibe el valor de la velocidad de nota y ste es enviado a un

programa llamado pd Vlz que lo que hace es variar la intensidad mediante una
relacin para la propiedad de intensidad, adicionalmente se encuentra un pack f

500 unido a un line que retarda la intensidad de la luz desde su posicin inicial
hasta la posicin final haciendo mucho ms agradable y entendible el concepto de
fuerza en la secuencia.

Ilustracin 49: Ejemplos de intensidades de luz

5.9.6. PROGAMACIN DE LAS ESFERAS

Cada nota es representada por un conjunto de esferas; como inicialmente este

proyecto estaba dedicado a piezas para piano, se decidi tener un conjunto de
esferas para cada nota es decir que mximo seran 10 conjuntos de esferas para
10 notas simultaneas, es decir 10 dedos tocando a la vez. Ms adelante fue difcil
ejecutar 10 notas simultaneas debido a que la maquina en donde se desarrollo
esta animacin (Sony Vaio con 4GB de RAM, procesador CORE i3 y una tarjeta
de video ATI Mobility Radeon HD 5145) no era capaz de renderizar tal informacin
por lo tanto se fueron eliminando grupos de esferas hasta establecerse 6 grupos
como mximo. El diseo de la programacin de las esferas est dada de la
siguiente forma:

Ilustracin 50: Estructura general para la programacin de esferas

El primer pulsador ejecuta el valor que va a tardar cada grupo de esferas en

apagarse y ste valor entra en el programa diseado para apagar las esferas
llamado pd apaga; en seguida hay un conmutador por cada grupo que activa o
desactiva de acuerdo a la orden dada por pd apaga, hay otro pulsador que activa

un valor diseado para posicionar las esferas a una determinada altura, y hay dos
programas por cada conjunto; uno donde se programa cada grupo de esferas pd
Esfera, y el otro un programa de control para manipular las propiedades de las
mismas pd Control.
El primer programa pd apaga para prender o apagar un grupo de esferas est
dado por la siguiente estructura:

Ilustracin 51: Programacin de encendido y apagado para las esferas

El objeto r sim0 activa un conmutador que durar encendido 13 pulsos con un

intervalo de 100 ms de principio a fin logrando que las esferas duren encendidas
dicho tiempo, si antes de que se termine la duracin de esta nota encendida se
activa otra, entonces el programa reinicia su conteo.
El diseo de un grupo de esferas (programa pd Esfera) posee la siguiente
estructura:

Ilustracin 52: Estructura para la creacin de un grupo de esferas

El primer elemento es un conmutador con la informacin de encendido y apagado,

seguido por los programas pd E1 - pd E5 que son la programacin de las 5

esferas, los programas pd Eje_X, pd Eje_YJ, pd Eje_Y, pd Eje_Z, y pd COLOR,

son parte del control de las propiedades de las esferas.

La programacin de las esferas (pd E1 - pd E5 ) est dada as:

Ilustracin 53: Estructura para cada una de las esferas

Ilustracin 54: Ejemplificacin posibilidades para el objeto sphere

A la cabeza est un conmutador de encendido y apagado conectado al objeto

sphere para graficar la esfera, a este proceso se la aaden las propiedades de
traslacin en los 3 ejes, el color RGB y finalmente el tamao y el nmero de
segmentos que se han preestablecido y activados por un pulsador. Cada nota es
representada por 5 de stas esferas.
El programa pd Eje_X se ha creado con el fin de no solo mover una esfera, sino
que tambin generar la sensacin de que sta deja un rastro en el desplazamiento
en el eje X, la manera de lograrlo consiste en recibir le valor de la nota r sim(n) y
luego enva la orden de traslacin en X a la esfera 1 (pd E1) luego genera un
recorrido mediante pack f (n) y line para el movimiento de la esfera 2 (pd E2)
que va a tardar unos milisegundos de tiempo antes de llegar a la posicin de pd
E1, lo mismo sucede para las esferas 3, 4 y 5, la estructura es la siguiente:

Ilustracin 55: Estructura y ejemplo para el movimiento en el eje horizontal

El programa pd Eje_YJ funciona de la misma manera que el programa pd Eje_X

pero en el sentido vertical:

Ilustracin 56: Estructura para el movimiento en el eje Vertical

La diferencia consiste en que existe un pequeo programa pd EJE_Y que genera

un pequeo salto; un programa que al activase inicia un desplazamiento al
incrementarse un valor hasta llegar a un tope y luego decrece su valor
desplazando la esfera hasta su valor inicial, este programa est dado por el
siguiente diseo:

Ilustracin 57: Programa que genera el recorrido vertical

El programa pd Eje_Y ha sido construido para cambiar el nivel de las esferas en

el sentido vertical, multiplica la posicin de cada una de ellas por un factor y as
sube o baja el nivel de su altura, el programa es el siguiente:

Ilustracin 58: Programa y ejemplo del desplazamiento de la posicin vertical

El programa pd Eje_Z, es construido para representar la velocidad de nota, recibe

un valor de 0-127 y mediante relaciones logra ubicar las esferas en el espacio,
como cada grupo tiene 5 esferas, tambin se le asigna el proceso de recorrido
similar a los programas anteriores, salvo que ste acta en el eje z. su estructura
es as:

Ilustracin 59: Programa y ejemplo del desplazamiento de las esferas en el eje Z

Por ltimo se le es aadido el programa de color pd COLOR que va asignando un

color a al grupo de esferas de acuerdo a las rdenes provenientes de Qlist, este
programa de color es el mismo que se us para en el programa de las luces cuya
pequea diferencia est en que en el mismo programa se incluye un objeto que
recibe la los valores, si la tonalidad si es mayor o menor e inmediatamente, oxida
o degrada el color.

Ilustracin 60: Programa y ejemplo para de color para las esferas

El programa de pd Control que se usa en todos los grupos de esferas, recibe

varios elementos como: r sim(n) que recibe el valor de la nota, hay una entrada
que recibe el nivel al que se van a posicionar las esferas, r vlz que es la velocidad
de nota y que har que acte en el desplazamiento del eje z, r clr(n) que recibe el
valor de color para cada grupo de esferas, su programacin es la siguiente:

Ilustracin 61: Estructura de controlo para las propiedades de las esferas

5.9.7. PROGRAMACIN DEL COLOR DE NOTAS PARA

La programacin del color pd COLOR NOTAS de las notas ejecutadas en tiempo
real a travs de un controlador, deben ser configuradas mediante la interfaz
grafica indicando la tonalidad Mayor o menor, entonces a travs del protocolo
OSC se recibir un valor que ser enviado a toda la animacin con s Tnl y s Mm;
y as mismo se ha agregado variables de llegada con r Tnl y r Mm para confirmar
los valores; ms adelante hay dos programas, pd POLY que asigna y enva los
valores de color a cada una de las notas y pd EJE Z que asigna y enva los
valores de velocidad de nota recibidos por el controlador as:

Ilustracin 62: Programa general para la ejecucin de la animacin a partir de una entrada en tiempo real

El programa pd POLY toma los valores de llegada del controlador con el objeto
notein luego pasa esta informacin al objeto llamado chord 128, donde 128
significa que el rango a tomar es de 0-127 y mediante el objeto unpack f f f f f f
divide los valores de las notas que se estn presionando simultneamente, as se
pueden obtener las notas simultaneas independientes. Luego se envan estos
valores mediante send para ser recibidos por las esferas como s sim0 hasta s
sim5.

Ilustracin 63: Estructura para el reconocimiento y asignacin de notas simultaneas

Ms adelante luego de tener el valor de las notas, hay que asignarle un valor de
color a cada una de ellas de una manera similar como la programacin hecha en
Python; para ello existen los programas llamados pd COLOR el primer programa
asigna un valor de color a la primera nota relacionndolo con la tonalidad que se
haya elegido as:

Ilustracin 64: Estructura que recibe un valor de nota y genera un valor para el color

Este programa posee un subprograma que toma el valor, y toma el resultado del
mdulo 12 entonces mediante la relacion que se estableci en la funcin rdenes,
se crea una paleta de colores con la que se asigna un valor de color a cada una
de las primeras notas tocadas de la siguiente manera:

Ilustracin 65: Estructura que identifica una nota y genera un valor de color

En los siguientes programas pd COLOR a partir de la segunda nota, se calculan

el intervalo entre una nota y la siguiente y dependiendo del grado de consonancia
o disonancia genera un valor de color de acuerdo a la misma tabla mencionado en
la funcin ordenes.

Ilustracin 66: Programa que identifica el intervalo a partir de la primera y genera un valor de color para la
segunda nota

La asignacin de colores cambia un poco usando la misma estructura, sumndole

valores al valor antecesor, es decir; se toma el valor de la primera nota, luego a
partir de esta, se calcula el intervalo y de acuerdo a ste se le suma un valor
dando como resultado un color adyacente o contraste dependiendo de si es una
consonante o un disonante. Igual a la programacin en Python pero realizado en
Pure Data.

Ilustracin 67: Ilustracin 56: Programa que toma el valor de la segunda nota y asigna un valor de color

El programa pd EJE Z simplemente toma el valor diferente de cero en las

velocidades de notas y lo enva como s vlz a toda la animacin as:

Ilustracin 68: Estructura que toma los valores de velocidad de nota diferentes a cero

5.9.8. MONITOR
El ltimo programa pd MONITOR es una de ayuda para visualizar las variables
que est recibiendo Qlist de la lista as como tambin los valores recibidos por el
controlador y la interfaz grfica:

Ilustracin 69: Programa para visualizar los eventos recibidos desde la lista de ordenes o el controlador MIDI

5.10. PROGRAMACIN DE LA INTERFAZ GRFICA EN TKINTER

Como la creacin de la interfaz grafica se elabora mediante cdigo de

programacin y no por medio de un GUI como en MatLab o un entorno similar; hay
que establecer una nueva estructura de cdigo en donde se van a introducir todos
los programas ya realizados como el de anlisis musical o la creacin de nuevos
programas que enviarn informacin desde la interfaz mediante el protocolo OSC
a Pure Data entre otros, que sern explicados ms adelante. Por ello se va a
explicar paso a paso la construccin y nuevos programas creados adems de
mencionar el lugar donde iran los programas que rodean el proceso de anlisis de
la informacin MIDI.

El mtodo en que se quiere dar a mostrar la interfaz consiste en crear los botones
a partir de la activacin de ellos mismos, es decir; que la interfaz arranca con un
botn y al presionar ste aparecer nuevos botones y opciones guiando al usuario
en el uso de la interfaz de principio a fin.

El proceso en general de la programacin est dado as:

Ilustracin 70: Diagrama de flujo para la interfaz grfica

5.10.1.

ESTRUCTURA DE LA INTERFAZ

En general la estructura de la interfaz se compone del siguiente cdigo:

#!/usr/bin/env Python
# Este archivo usa el encoding: utf-8
import os
import shutil
DirP=str((os.getcwd())) #Directorio principal
from Tkinter import *
from tkFileDialog import askopenfilename
class Interfaz:
def __init__(self, master):
def Inicio(self):
def buscar(self):
def auxslcton(self):
def slcton(self,btsel):
def axMG(self):

def MG(self):
def auxabrirpd(self):
def abrirpd(self):
def auxventana(self):
def ventana(self):
def test1(self):
def test2(self):
def test3(self):
def test4(self):
def auxplaystop(self):
def Play(self, event):
def Stop(self, event):
def salir(self):
root = Tk()
Interfaz = Interfaz(root)

root.mainloop()
Dentro de esta estructura se encontrar la programacin de los botones, la
manipulacin de algunas operaciones como las ubicaciones dentro de Windows 7,
abrir un archivo de Pure Data desde Python, mover o copiar archivos entre
directorios, comunicacin mediante el protocolo OSC, etc. Todo esto enmarcado
nuevamente dentro de la programacin orientada a objetos.

5.10.2.

INICIANDO EL PROGRAMA

Al inicio se usa el encoding: utf-8 para poder utilizar caracteres como tildes o ees
aunque se busc escribir el cdigo sin este tipo de caracteres para no toparnos
con problemas al compilar, sin embargo se usa para prevenir la utilizacin de
variables que tengan dichos caracteres y que sea inevitable eliminar como por
ejemplo caracteres dentro de los eventos de la informacin MIDI, import os y
import sutil, son unas libreras que sirven para comunicarnos con el sistema
operativo y poder manipular archivos, DirP=str((os.getcwd())) guarda en una
variable el directorio donde se est trabajando la programacin, from Tkinter
import *, y from tkFileDialog import askopenfilename, son libreras importantes
para el uso de tkinter; a continuacin se crea la clase, class Interfaz donde se
desarrollarn las funciones del programa y finalmente se utiliza root = Tk(), Interfaz

= Interfaz(root), root.mainloop() que son parte de tkinter para ejecutar y mantener

activo el programa.
#!/usr/bin/env Python
# Este archivo usa el encoding: utf-8
import os
import shutil
DirP=str((os.getcwd())) #Directorio principal
from Tkinter import *
from tkFileDialog import askopenfilename
class Interfaz:
root = Tk()
Interfaz = Interfaz(root)
root.mainloop()

5.10.3.

LA FUNCIN __INIT__ ((( MUSIC ))) ((( GARDEN )))

Ilustracin 71: Primera imagen de la interfaz y botn de inicio.

El cdigo es el siguiente:
def __init__(self, master):
global ioSLCTON;ioSLCTON=0
self.DirP=DirP
self.io1=1;self.io2=1;self.io3=1;self.io4=1;self.io5=1;self.io6=1;self.io7=1
self.frame = Frame(root, width=300, height=200, bg=#FFFFFF)
self.frame.pack()
self.titulo = Button(self.frame, text='((( MUSIC ))) ((( GARDEN )))', fg=white,
background=black, width=30, command=self.Inicio)
self.titulo.config(bg='black', fg='#FFFF00', bd=10, font=('Tempus Sans ITC', 20,
'bold'));self.titulo.pack(side=LEFT, padx=5, pady=5)

La primera parte inicia como global la variable ioSLCTON que servir como un
conmutador ms adelante, luego otros conmutadores sern nombrados como
selft.io(n) que tambin sern usados como conmutadores. Ac se crea la

programacin del primer botn, width=300, height=200 son las dimensiones de

ancho y alto, self.titulo es la variable que contiene el botn con ttulo y fondo
negro, la operacin importante es command=self.Inicio que dar comienzo a la
funcin inicio una vez es activado el botn. self.titulo.config es la manera de
configurar las propiedades del botn self.titulo como, bg='black' el color de fondo,
fg='#FFFF00' el color de la letra, bd=10 el tamao del marco del botn,
font=('Tempus

Sans

ITC',

20,

'bold')

la

fuente

de

la

letra

self.titulo.pack(side=LEFT, padx=5, pady=5) que especifica colocar los botones

que estn en la misma posicin a la derecha de ste y padx=5, pady=5 son el
tamao del marco blanco que cubre el marco negro del botn.

5.10.4.

LA FUNCIN INICIO

Al crear botones dentro de las funcione se puede lograr que a medida que se
vayan presionando los botones vayan apareciendo nuevos botones, por eso con el
botn de la funcin anterior se crea un nuevo botn.

Ilustracin 72: Botones de abrir archivo MIDI y ttulo antes de ser importado el archivo

Para empezar se crea la funcin y se usa el protocolo para crear un botn

def Inicio(self):
if self.io1==1:
self.frame = Frame(root, width=1000, height=1000, bg=black)
self.frame.pack(side=TOP, padx=5, pady=5, expand=YES, fill=BOTH)

Ahora se crea el botn con el texto 'ABRIR ARCHIVO MIDI' guardado en la

variable self.bmidi, con propiedades como el fondo negro, el tamao de los
marcos, la fuente del texto igual al anterior, y que activar la funcin buscar
mediante command=self.buscar.
self.bmidi = Button(self.frame, text='ABRIR ARCHIVO MIDI', fg=white,
background=black,

width=0,

font=('Tempus

command=self.buscar).pack(side=LEFT,
command=self.buscar);self.bmidi.pack()

Sans
padx=0,

ITC',10,

'bold'),

pady=0)#,

Self.narch es la variable que contiene un texto que se va a imprimir en pantalla

con la propiedad de cambiar el texto una vez se le d esta instruccin, se edita la
propiedad del tamao de la letra; tambin se editan sus propiedades logrando el
fondo negro, el color anaranjado para darle la instruccin en color RGB mediante
la instruccin fg='#FF6600', la fuente, el espacio que ocupa el fondo y la ubicacin.
Todo esto contenido en un conmutador para que la creacin de este botn y este
texto sean una sola vez y que no suceda que cada vez que presione el botn de
inicio se cree varios botones de abrir archivo y varios textos nombre de archivo
MIDI.
self.narch = Label(self.frame, text='Nombre del Archivo MIDI', fg=white,
background=black, width=20)
self.narch.config(bg='black', fg='#FF6600', bd=0, font=('Tempus

Sans

ITC',10, 'bold'))#;self.titulo.pack(side=LEFT, padx=0, pady=0)

self.narch.pack(side=TOP, padx=0, pady=0, expand=YES, fill=BOTH)
self.io1=0

5.10.5.

LA FUNCIN BUSCAR

Al activar el botn de abrir archivo MIDI aparecer una ventana de Windows con la
cual se podr buscar un archivo dentro de los directorios que tenga el computador,
una vez encontrado en donde apareca el texto Nombre del Archivo MIDI
aparecer el nombre del archivo seleccionado y arrancar una nueva funcin que
contiene nuevos botones.

Adicionalmente en esta funcin se ejecutan otros procesos que se explican

haciendo uso del cdigo a continuacin:
def buscar(self):
global ioSLCTON

ioSLCTON=0
os.chdir(str(DirP[:-9])) #Directorio
self.DirM=str(askopenfilename()) #Directorio del archivo MIDI
self.nmid=''
for i in self.DirM:
self.nmid+=i
if i == '/':
self.nmid=''

Primero se llama como global a la variable ioSLCTON

que se usa como

conmutador, luego recordando el orden donde se guardan los archivos de MG:

((MG))
Archivo MIDI
Interfaz
PdGem

Haciendo uso de os.chdir(str(DirP[:-9])) se hace que Python trabaje en el directorio

((MG)) visualizando las carpetas Archivo MIDI, Interfaz, PdGem; entonces en el
momento de darle la orden de abrir un directorio Python se ubicar en esta
direccin. Ms adelante se usa self.DirM=str(askopenfilename()) abriendo la
ventana de Windows en donde se podr elegir el archivo, y guardando la direccin
en la que se encuentra el archivo MIDI, luego en self.nmid se guardar el nombre
del archivo midi mas su respectiva extensin filtrando ste del resto de la
direccin, por ejemplo self.DirM H:/((MG))/crom.mid y self.nmid crom.mid.

Ilustracin 73: Ventana emergente al activar el botn para abrir un archivo MIDI

Ms adelante contina con el siguiente cdigo:

sourceFile = self.DirM
destinationFile = self.DirP

Como el archivo MIDI debe estar en el directorio donde se encuentra MIDICSV se

va a copiar el archivo MIDI a dicha carpeta y es por ello que es necesaria para
tener las dos direcciones a las que se han llamado self.DirM y self.DirP.
auxM=''
for i in range(len(sourceFile)):
if i>2 and sourceFile[i] != '/' and sourceFile[i] != '\\':
auxM+=sourceFile[i]

auxP=''
for i in range(len(destinationFile)):
if i>2 and destinationFile[i] != '/' and destinationFile[i] != '\\':
auxP+=destinationFile[i]

Ahora, como el nombre de los archivos puede venir con formas diferentes de
escritura, por ejemplo sourceFile = H:/((MG))/crom.mid y destinationFile =
h:\((MG))\Interfaz el siguiente proceso prepara los nombres de las variables
mediante auxM y auxP as:
sourceFile H:/((MG))/crom.mid
destinationFile h:\((MG))\Interfaz
auxM ((MG))crom.mid
auxP ((MG))Interfaz

Como la extensin del formato midi puede variar escribindose como *.midi, *.mid,
*.Midi, *.Mid, *.MIDI, *.MID etc. entonces se decide dejar todos los archivos midi
con una misma extensin, por ello con el siguiente cdigo se transforman los
caracteres en maysculas por minsculas guardado en la variable aux y ms
adelante se modifica de nuevo.
auxP+=self.nmid
auxL={}
auxL['M'],auxL['I'],auxL['D']='m','i','d'
con=len(self.nmid)-1
aux=''

while self.nmid[con]!='.':
if self.nmid[con] in auxL:
aux=str(auxL[self.nmid[con]])+aux
else:
aux=str(self.nmid[con])+aux
con-=1

El siguiente proceso es comparar los nombres auxM y auxP y as podr saber si el

archivo que se va a copiar, ya existen en el directorio Interfaz o no as como
tambin verificar que el archivo que se est escogiendo es o no un archivo con la

extensin MIDI, si el archivo posee la extensin MIDI y es o no, copiado a la

carpeta interfaz activa la siguiente funcin llamada auxslcton:
if auxM != auxP:
if aux=='mid' or aux=='midi':
shutil.copy(sourceFile, destinationFile)
print;print

'SE

HA

COPIADO

EL

MIDI','<<',self.nmid,'>>','\nEN
DIRECTORIO',destinationFile;print
self.narch['text']=self.nmid
self.auxslcton()

if auxM == auxP:
if aux=='mid' or aux=='midi':
print;print 'ARCHIVO NO COPIADO';print
print 'EL ARCHIVO','<<',self.nmid,'>>','YA EXISTE'
self.narch['text']=self.nmid
##self.axMG()
self.auxslcton()

if aux!='mid' and aux!='midi':

print;print 'ARCHIVO NO COPIADO'
print '<<',self.nmid,'>>','NO ES UN ARCHIVO MIDI';print
self.narch['text']=self.nmid+str(' => NO ES UN ARCHIVO MIDI')

os.chdir(str(DirP[:-9])+'\\Interfaz') #Directorio

ARCHIVO
EL

5.10.6.

LA FUNCIN AUXSLCTON

El cdigo es el siguiente:
def auxslcton(self):
if self.io7==1:
self.frame = Menubutton(text='SELECCIONAR TONALIDAD?')
picks = Menu(self.frame)
self.frame.config(menu=picks)

En la primera parte del cdigo se usa la variable conmutador self.io7 para no crear
ms botones iguales, luego se crea un submen con el nombre de
SELECCIONAR TONALIDAD?, que contiene varios botones con los nombres
de las tonalidades as:
picks.add_command(label='CM', command=(lambda btsel='CM': self.slcton(btsel)))
picks.add_command(label='Cm', command=(lambda btsel='Cm': self.slcton(btsel)))
picks.add_command(label='C#M', command=(lambda btsel='C#M': self.slcton(btsel)))
picks.add_command(label='C#m', command=(lambda btsel='C#m': self.slcton(btsel)))
picks.add_command(label='DM', command=(lambda btsel='DM': self.slcton(btsel)))
picks.add_command(label='Dm', command=(lambda btsel='Dm': self.slcton(btsel)))
picks.add_command(label='EbM', command=(lambda btsel='EbM': self.slcton(btsel)))
picks.add_command(label='Ebm', command=(lambda btsel='Ebm': self.slcton(btsel)))
picks.add_command(label='EM', command=(lambda btsel='EM': self.slcton(btsel)))
picks.add_command(label='Em', command=(lambda btsel='Em': self.slcton(btsel)))
picks.add_command(label='FM', command=(lambda btsel='FM': self.slcton(btsel)))
picks.add_command(label='Fm', command=(lambda btsel='Fm': self.slcton(btsel)))
picks.add_command(label='F#M', command=(lambda btsel='F#M': self.slcton(btsel)))
picks.add_command(label='F#m', command=(lambda btsel='F#m': self.slcton(btsel)))
picks.add_command(label='GM', command=(lambda btsel='GM': self.slcton(btsel)))
picks.add_command(label='Gm', command=(lambda btsel='Gm': self.slcton(btsel)))
picks.add_command(label='AbM', command=(lambda btsel='AbM': self.slcton(btsel)))
picks.add_command(label='G#m', command=(lambda btsel='G#m': self.slcton(btsel)))
picks.add_command(label='AM', command=(lambda btsel='AM': self.slcton(btsel)))
picks.add_command(label='Am', command=(lambda btsel='Am': self.slcton(btsel)))
picks.add_command(label='BbM', command=(lambda btsel='BbM': self.slcton(btsel)))
picks.add_command(label='Bbm', command=(lambda btsel='Bbm': self.slcton(btsel)))
picks.add_command(label='BM', command=(lambda btsel='BM': self.slcton(btsel)))

picks.add_command(label='Bm', command=(lambda btsel='Bm': self.slcton(btsel)))

Ms adelante se editan las propiedades del sub men como fondo letra y en fin:
self.frame.pack(side=TOP, padx=5, pady=5, expand=NO, fill=BOTH)
self.frame.config(bg='black', fg='#6666FF', bd=0, font=('Tempus Sans ITC',10, 'bold'))
picks.config(bg='black', fg='#FFFFFF', bd=5, font=('Tempus Sans ITC',10, 'bold'))

Luego es creado un botn llamado 'OMITIR' que da paso a la funcin axMG pero
en el caso de haber seleccionado una tonalidad del submen se activa la funcin
slcton; el botn 'OMITIR' es programado con sus respectivas propiedades
teniendo en cuenta que su color rojo en RGB es fg=#FF6666.
self.bmg = Button(self.frame, text='OMITIR', fg=#FF6666, background=black,
width=0, font=('Tempus Sans ITC',10, 'bold'), command=self.axMG)
self.bmg.pack(side=LEFT, padx=0, pady=0)#'''
self.io7=0

Ilustracin 74: Men emergente diseado para seleccionar una tonalidad activando el botn SELECCIONAR
TONALIDAD?

5.10.7.

LA FUNCIN SLCTON

El primer paso es llamar como globales las variables ioSLCTON y SLCTON, note
que al entrar en esta funcin ya es activada la siguiente funcin llamada axMG; en
la variable es guardada el nombre de la tonalidad seleccionada como
SLCTON=btsel. Luego es creado un diccionario tn={} que contiene los nombres de
las tonalidades y los valores de color a los que corresponde cada uno.
def slcton(self,btsel):
global ioSLCTON,SLCTON
ioSLCTON=1
self.axMG()
SLCTON=btsel
print;print 'SELECCIONASTE LA TONALIDAD DE', SLCTON;print

tn={}
tn['DM'],tn['Dm'],tn['GM'],tn['Gm'],tn['CM'],tn['Cm'],tn['FM'],tn['Fm'],tn['BbM'],tn['Bbm'],
tn['EbM'],tn['Ebm'],tn['AbM'],tn['G#m'],tn['C#M'],tn['C#m'],tn['F#M'],tn['F#m'],tn['BM'],t
n['Bm'],tn['EM'],tn['Em'],tn['AM'],tn['Am']=600,600,650,650,700,700,750,750,800,800
,850,850,900,900,950,950,1000,1000,1050,1050,1100,1100,1150,1150

El siguiente paso es mandar la informacin de color mediante le protocolo OSC a

Pure Data as como tambin si la tonalidad es mayor o menor mediante el
siguiente cdigo:
import OSC
client = OSC.OSCClient()
msg = OSC.OSCMessage()
msg.setAddress(/print)
msg.append(tn[SLCTON])
client.sendto(msg, ('127.0.0.1', 9008))

if SLCTON[-1]=='M':
import OSC
client = OSC.OSCClient()
msg = OSC.OSCMessage()
msg.setAddress(/print)
msg.append(0)
client.sendto(msg, ('127.0.0.1', 9009))

else:
import OSC
client = OSC.OSCClient()
msg = OSC.OSCMessage()
msg.setAddress(/print)
msg.append(1)
client.sendto(msg, ('127.0.0.1', 9009))

5.10.8.

LA FUNCIN AXMG

Ilustracin 75: Muestra de la interfaz hasta el botn para analizar secuencia MIDI

Esta funcin comienza como se ha visto con un conmutador para no repetir este
botn, ms adelante se crea el botn self.bmg con el mensaje ANALIZAR
SECUENCIA MIDI, y un cuadro de mensaje self.mton sin texto que va a cambiar
cuando el anlisis del programa MG encuentre la tonalidad. El botn self.bmg al
ser activado ejecuta el programa de anlisis MG que al finalizar correctamente
arranca la siguiente funcin llamada auxabrirpd; el cdigo de sta funcin es:

def axMG(self):
if self.io2==1:
self.frame = Frame(root, width=1000, height=1000, bg=black)
self.frame.pack(side=TOP, padx=5, pady=5, expand=YES,
fill=BOTH)#()#(side=TOP, expand=NO, fill=NONE)
self.bmg = Button(self.frame, text='ANALIZAR SECUENCIA MIDI', fg=white,
background=black, width=0, font=('Tempus Sans ITC',10, 'bold'),
command=self.MG).pack(side=LEFT, padx=0, pady=0)#,
command=self.buscar);self.bmg.pack()
self.mton = Label(self.frame, text='', fg=white, background=black, width=20)
self.mton.config(bg='black', fg='#FFFF00', bd=0, font=('Tempus Sans ITC',10,
'bold'))#;self.titulo.pack(side=LEFT, padx=0, pady=0)
self.mton.pack(side=LEFT, padx=5, pady=5, expand=YES, fill=BOTH)
self.io2=0

5.10.9.

LA FUNCIN MG

Ilustracin 76: Interfaz analizando una secuencia

Esta funcin es el corazn de todo el proyecto y ya se explic su contenido

esencial desde el comienzo del desarrollo ingenieril, ahora s explicarn otros
procesos adicionales que se hicieron para relacionarlo como pieza de la interfaz
de la siguiente manera:

El primer paso es ubicara a Python dentro del la carpeta Interfaz donde se va a

trabajar con os.chdir, luego se inserta el texto '...Analizando...' en el cuadro de la
funcin anterior, ms adelante se nombra a nmid con el nombre de la secuencia
MIDI entonces se da comienzo a la clase MusicGarden:

def MG(self):
os.chdir(str(DirP[:-9])+'\\Interfaz')
self.mton['text']='...Analizando...'
self.mton['fg']='#99FFFF'
print;print self.mton['text'];print
nmid=self.nmid
class MusicGarden:
Ahora se crea un diccionario para asignarle un color al texto de dialogo cambiarlo
por el texto '...Analizando...', luego aplica el nombre de la tonalidad y el color
correspondiente a la tonalidad, finalmente se da la orden para que sea ejecutada
la funcin auxabrirpd.
rfeRGB={}
rfeRGB[600],rfeRGB[650],rfeRGB[700],rfeRGB[750],rfeRGB[800],rfe
RGB[850],rfeRGB[900],rfeRGB[950],rfeRGB[1000],rfeRGB[1050],rfe
RGB[1100],rfeRGB[1150]='#FF0000','#FF6600','#FFFF00','#66FF00','
#00FF00','#00FF66','#00FFFF','#0066FF','#0000FF','#6600FF','#FF0
0FF','#FF0066',
self.mton['text']=TONALIDAD
self.mton['fg']=rfeRGB[COLORNOTA]
self.auxabrirpd()
5.10.10.

LA FUNCIN AUXABRIRPD

Esta funcin es simplemente un nuevo botn para activar la funcin abrirpd su

cdigo est dado por:
def auxabrirpd(self):
if self.io3==1:
self.frame = Frame(root, width=1000, height=1000, bg=black)
self.frame.pack(side=TOP,
padx=5,
pady=5,
expand=YES,
fill=BOTH)#()#(side=TOP, expand=NO, fill=NONE)
self.bpd = Button(self.frame, text='INICIAR PD', fg=white,
background=black, width=0, font=('Tempus Sans ITC',10, 'bold'),
command=self.abrirpd).pack(side=BOTTOM, padx=0, pady=0)
self.io3=0

Ilustracin 77: Interfaz cuando aparece la tonalidad analizada con el color correspondiente a la misma y el botn
para iniciar Pure Data

5.10.11.

LA FUNCIN ABRIRPD

La programacin de esta funcin comienza con self.io4 como conmutador, se

cambia el directorio de trabajo a la carpeta Pdgem haciendo uso de
destinationFile=DirP[:-8]+'PdGem', para abrir pure data hay que importar las
libreras con import os e import subprocess para poder ejecutarlo, luego mediante
el uso de la variable global abrirpuredata y usando subprocess.Popen se arranca
el archivo 'PyPdGem.pd' llamando antes el ejecutable en donde se ha instalado
Pure Data como 'C:\\Program Files (x86)\\pd\\bin\\pd.exe', finalmente se ejecuta la
funcin auxventana:
def abrirpd(self):
if self.io4==1:
destinationFile=DirP[:-8]+'PdGem'
import os
import subprocess
os.chdir(destinationFile) #Directorio
global abrirpuredata
abrirpuredata=subprocess.Popen
(x86)\\pd\\bin\\pd.exe','PyPdGem.pd'])
self.auxventana()
self.io4=0

(['C:\\Program

Files

Ilustracin 78: Interfaz una vez iniciado Pure Data

5.10.12.

LA FUNCIN AUXVENTANA

Para esta etapa, se prepara la mayora de botones para enviar informacin

mediante OSC; primero se crea el botn ventana que ejecuta la funcin ventana y
que abrir la ventana GEM de animacin, y luego los botones TEST 1-4 abriendo
las funciones TEST 1-4 respectivamente y el botn ((SALIR)) abriendo la funcin
salir con la siguiente programacin:
def auxventana(self):
self.frame = Frame(root, width=1000, height=1000, bg=black)
self.frame.pack(side=TOP, padx=5, pady=5, expand=YES, fill=BOTH)
self.bpd
=
Button(self.frame,
text='VENTANA
(ON
OFF)',
fg=#FFFF00,
background=black,
width=0,
font=('Tempus
Sans
ITC',10,
'bold'),
command=self.ventana).pack(side=TOP, expand=YES, padx=0, pady=0)
self.frame = Frame(root, width=1000, height=1000, bg=black)
self.frame.pack(side=TOP, padx=5, pady=5, expand=YES, fill=BOTH)
self.btst1 = Button(self.frame, text='TEST 1', fg=white, background=black, width=0,
font=('Tempus Sans ITC',8, 'bold'), command=self.test1).pack(side=LEFT, expand=YES,
padx=0, pady=0)
self.btst1 = Button(self.frame, text='TEST 2', fg=white, background=black, width=0,
font=('Tempus Sans ITC',8, 'bold'), command=self.test2).pack(side=LEFT, expand=YES,
padx=0, pady=0)

self.btst3 = Button(self.frame, text='((SALIR))', fg=#CC66FF, background=black, width=0,

font=('Tempus Sans ITC',8, 'bold'), command=self.salir).pack(side=LEFT, expand=YES,
padx=0, pady=0)
self.btst2 = Button(self.frame, text='TEST 3', fg=white, background=black, width=0,
font=('Tempus Sans ITC',8, 'bold'), command=self.test3).pack(side=LEFT, expand=YES,
padx=0, pady=0)
self.btst2 = Button(self.frame, text='TEST 4', fg=white, background=black, width=0,
font=('Tempus Sans ITC',8, 'bold'), command=self.test4).pack(side=RIGHT, expand=YES,
padx=0, pady=0)
self.io5=1

Ilustracin 79: Programa principal en Pure Data e Interfaz donde aparecen los botones para inicial la ventana de
animacin, los botones de test y el botn de salir.

5.10.13.

LA FUNCIN VENTANA

La funcin ventana cumple con la orden de envar un mensaje OSC importando la

biblioteca OSC con import OSC y enviando por los canales 9004 el valor 1 que
activa el primer TEST que ejecuta todas las esferas desde 0 a 127 para fijar los
colores de cada una de estas en la ventana de animacin GEM, el segundo
mensaje OSC es enviado a travs del canal 9001 nuevamente con el valor 1 pero
mediante un ciclo que ejecuta tres veces est misma operacin con el fin de
arrancar la ventana de animacin GEM e igualmente fijar los colores en la ventana

de animacin de Pure Data, al activar este botn automticamente se ejecuta la

funcin auxplaystop que tambin usa un conmutador para que no crear ms
botones iguales.
El cdigo es el siguiente:

def ventana(self):
import OSC
client = OSC.OSCClient()
msg = OSC.OSCMessage()
msg.setAddress(/print)
msg.append(1)
client.sendto(msg, ('127.0.0.1', 9004))
for i in range(3):
import OSC
client = OSC.OSCClient()
msg = OSC.OSCMessage()
msg.setAddress(/print)
msg.append(1)
client.sendto(msg, ('127.0.0.1', 9001))
if self.io5==1:
self.auxplaystop()
self.io5=0

Ilustracin 80: Interfaz grfica con la aparicin de los botones iniciar y parar la animacin y la ventana activada
de animacin

5.10.14.

LAS FUNCIONES TEST 1 ,2, 3, 4

AL presionar los botones TEST son ejecutadas las funciones test(1-4) y cada una
de ellas enva un mensaje OSC con el valor 1 por diferentes canales; test1 por

9004, test2 9005, test3 9006, test3 9003 y test4 9007. La programacin para estas
funciones es as:
def test(n)(self):
import OSC
client = OSC.OSCClient()
msg = OSC.OSCMessage()
msg.setAddress(/print)
msg.append(1)
client.sendto(msg, ('127.0.0.1', 900(n)))

5.10.15.

LA FUNCIN AUXPLAYSTOP

Ilustracin 81: Botones de arranque y parada sin haber sido utilizados

En esta funcin crea los botones INICIAR ANIMACIN y PARAR ANIMACIN

con el fin de ser editados dependiendo de la orden dada el cdigo as:
def auxplaystop(self):
self.fPS = Frame(root, width=1000, height=1000, bg=black)
self.fPS.pack(side=LEFT, padx=5, pady=5, expand=YES, fill=BOTH)
self.bPS1 = Button(self.fPS)
self.bPS1.configure(text=' INICIAR ANIMACIN ', bg='black', fg='#99FF99', bd=5,
font=('Tempus Sans ITC',12, 'bold'))
self.bPS1.pack(side=BOTTOM, expand=YES)
self.bPS1.bind(<Button-1>, self.Play)
self.fPS = Frame(root, width=1000, height=1000, bg=black)
self.fPS.pack(side=TOP, padx=5, pady=5, expand=YES, fill=BOTH)
self.bPS2 = Button(self.fPS)
self.bPS2.configure(text=' PARAR ANIMACIN ', bg='black', fg='#FFCC66', bd=5,
font=('Tempus Sans ITC',12, 'bold'))
self.bPS2.pack(side=BOTTOM, expand=YES)
self.bPS2.bind(<Button-1>, self.Stop)
self.cont=0

5.10.16.

LA FUNCIN PLAY

Ilustracin 82: Botn activado para iniciar la animacin

Si es activado el botn PLAY se enva el mensaje con el valor 1 por el canal

9002, y es activado el texto (( INICIAR ANIMACIN )) cambiando el color
verde por un color ms intenso, as mismo cambia el botn (( PARAR
ANIMACIN )) (si esta activo) por PARAR ANIMACIN

con un rojo ms

plido:
def Play(self, event):
import OSC
self.bPS1[fg] = #00FF00
self.bPS1[text] = ' (( INICIAR ANIMACIN )) '
self.bPS2[fg] = #FFCC66
self.bPS2[text] = ' PARAR ANIMACIN '
client = OSC.OSCClient()
msg = OSC.OSCMessage()
msg.setAddress(/print)
msg.append(1)
client.sendto(msg, ('127.0.0.1', 9002))

5.10.17.

LA FUNCIN STOP

Ilustracin 83: Botn activado para parar la animacin

Si es activado el botn STOP se enva el mensaje con el valor 1 por el canal

9003, y es activado el texto (( PARAR ANIMACIN )) cambiando el color rojo
por un color ms intenso cambiando al botn (( INICIAR ANIMACIN )) con
PARAR ANIMACIN y un color verde ms plido:
def Stop(self, event):
import OSC
self.bPS1[fg] = #99FF99
self.bPS1[text] =' INICIAR ANIMACIN '
self.bPS2[fg] = #FF6600
self.bPS2[text] = ' (( PARAR ANIMACIN )) '

client = OSC.OSCClient()
msg = OSC.OSCMessage()
msg.setAddress(/print)
msg.append(1)
client.sendto(msg, ('127.0.0.1', 9003))

5.10.18.
Esta

LA FUNCIN SALIR

funcin

logra

cerrar

el

programa

Pure

Data

haciendo

uso

de

abrirpuredata.kill() y luego cierra la interfaz.

def salir(self):
os.chdir(DirP)
print(os.getcwd())
abrirpuredata.kill()
root.destroy()

Ilustracin 84: Botn activado para salir

6. PRESENTACIN Y ANLISIS DE RESULTADOS

6.1.

REQUISITOS PARA LA EJECUCION DE MUSIC GARDEN

Este sistema fue desarrollado en Windows 7 por lo tanto la presentacin est

dirigida hacia ste sistema operativo no obstante se sugerir maneras para ser
iniciado en Windows XP.

Poner en funcionamiento el sistema requiere de la instalacin de Python 2.7.1. que

puede ser descargado en http://www.Python.org/download/, as mismo es
necesario tener instalada la versin extendida de Pure Data hallada en
http://puredata.info/community/projects/software/pd-extended y por ltimo hay que
descargar y descomprimir la librera OSC para Python encontrada en
https://trac.v2.nl/wiki/pyOSC; entonces hay que tomar el archivo OSC.py y copiarlo
o moverlo a la carpeta site-packages encontrada en la carpeta Lib de la direccin
donde est instalado Python (Generalmente el directorio por defecto es
C:\Python27\Lib\site-packages). Ser til saber cul es la direccin donde ha sido
instalado Pure Data, para Windows XP la direccin por defecto ser C:\Archivos
de programa\pd\bin\pd.exe y para Windows 7 la direccin por defecto es
C:\Program Files (x86)\pd\bin\pd.exe.

Ms adelante hay que copiar la carpeta ((MG)) en cualquier directorio (se

recomienda guardarla en el escritorio); entonces hay que entrar en la carpeta
Interfaz

y localizar un archivo llamado InterfazW7.py (para Windows 7) e

InterfazXP.py (para Windows XP); se recomienda abrirlo con el IDE que viene por
defecto con la instalacin de Python y revisar si en la funcin def abrir(self):, la
variable abrirpuredata = subprocess.Popen(['C:\\ProgramFiles (x86) \\ pd \\ bin \\
pd.exe', 'PyPdGem.pd']), contiene correctamente la direccin donde est
instalado Pure Data como se mencion anteriormente de acuerdo a sus sistema
operativo.

6.2.

INICIO DE LA INTERFAZ GRFICA

El diagrama de flujo para el manejo de la interfaz grafica es el siguiente:

Ilustracin 85: Diagrama de flujo interfaz grfica

Para iniciar la interfaz se debe dar doble clic en el archivo InterfazW7.py (para
Windows 7) e InterfazXP.py (para Windows XP) y se abrir una ventana de
comandos MS-DOS y un botn con el ttulo de la interfaz:

Ilustracin 86: Ejemplo, inicio de la interfaz grfica

Luego hay que darle clic al ttulo y entonces aparecer un nuevo botn con la
etiqueta ABRIR ARCHIVO MIDI y al lado derecho una etiqueta con Nombre del
Archivo MIDI:

Ilustracin 87: Ejemplo, botn para abrir el archivo y el ttulo del archivo

Al pulsar de abrir, aparece una ventana emergente donde se puede escoger un

archivo MIDI entre los directorios de su disco; por defecto l se ubicar en la
carpeta ((MG)) el usuario puede encontrar varios archivos en la carpeta Archivo
MIDI.
Al pulsar el botn ABRIR ARCHIVO MIDI, aparece una ventana emergente
donde se puede escoger un archivo MIDI entre los directorios de su disco; por
defecto l se ubicar en la carpeta ((MG)) y se podr encontrar varios archivos
MIDI en la carpeta Archivo MIDI.

Ilustracin 88: Ejemplo, carpeta donde se encuentran los archivos MIDI en el directorio ((MG)), y el cuadro de
dialogo cuando se ha logrado copiar un archivo para ser analizado

Una vez haya seleccionado un archivo MIDI la etiqueta cambiar por el nombre
del archivo seleccionado y en seguida aparecern dos nuevos botones, uno para
seleccionar una tonalidad, y otro para omitir este paso.

Ilustracin 89: Ejemplo, ttulo del archivo, botones omitir y seleccionar tonalidad

Si presiona el botn para seleccionar una tonalidad, aparecer un men con los
nombres de las tonalidades que podr seleccionar, entonces el cuadro de dialogo
notifica la tonalidad seleccionada.

Ilustracin 90: Ejemplo, botn activado para seleccionar la tonalidad, men de tonalidades disponibles, y dialogo
de la tonalidad seleccionada

Al omitir o seleccionar una tonalidad, aparece un nuevo botn para comenzar el

anlisis de la secuencia MIDI. El programa puede tardar en el anlisis
dependiendo de la complejidad polifnica de la misma.

Ilustracin 91: Ejemplo, botn para analizar la secuencia

Despus de haber analizado la secuencia MIDI, el programa genera el archivo

pypd con la secuencia de ordenes lista para ser leda por Qlist en Pure Data; si en
el momento de seleccionar una tonalidad se ha omitido este paso, el programa
analiza la secuencia y sugiere la tonalidad, por el contrario, si se ha seleccionado
una tonalidad en el cuadro de dialogo se advierte que la tonalidad que se encontr
en anlisis ha sido cambiada por la tonalidad elegida; tambin notifica el nmero
de eventos (activacin y desactivacin de nota) analizados en la secuencia.

Ilustracin 92: Ejemplo, cuadro de dialogo indicando la tonalidad seleccionada, en nmero de eventos analizados,
la tonalidad por la que se ha cambiado o la encontrada y el color numrico de la tonalidad

600

650

700

750

Bb Eb Ab C#
800

850

900

F#

950 1000 1050 1100 1150

Ilustracin 93: Tabla de referencia con los nombres de las tonalidades, sus valores y colores correspondientes

El cuadro de dialogo notifica el valor de color a la cual pertenece la secuencia y

adems el nombre de la tonalidad aparece en la etiqueta de la interfaz con el color
que corresponde acorde a la tabla de color versus tonalidad.

Ilustracin 94: Ejemplo, titulo con la tonalidad encontrada y botn para iniciar Pure Data

Entonces aparece el botn para iniciar Pure Data; al ser activado ste botn,
aparecen dos ventanas emergentes de Pure Data, una que es la ventana de
comentarios del programa, y la otra, la ventana donde est programada toda la
animacin. Aparecen nuevos botones para iniciar la ventana de animacin, los test
para ejecutar unas secuencias preestablecidas de demostracin y el botn para
salir:

Ilustracin 95: Ventana principal de la programacin en Pure Data

Ilustracin 96: Ventana de mensaje, Sell o consola de Pure Data

Al aparecer las ventanas de Pure Data, hay que configurar los dispositivos de
entrada y salida dando clic en Media-MIDI settings de la barra de mens:

Ilustracin 97: Ejemplo, configurando propiedades de entrada y salida MIDI

Ilustracin 98: 86: Ejemplo, ventana y ejemplo de asignaciones entradas y salidas MIDI

Ahora hay que activar la ventana animacin (VENTANA (ON - OFF)).

Ilustracin 99: Ejemplo, ventana de animacin

Ilustracin 100: Ejemplo, botn para iniciar la ventana de animacin

Una vez creada la ventana aparecen los botones para iniciar o parar la animacin;
el botn de la accin es sealado con parntesis.

Ilustracin 101: Ejemplo, botones de para arrancar y detener la animacin

Ilustracin 102: Ejemplo, animacin iniciada

Ilustracin 103: Ejemplos, botn activado en inicio y en parar la animacin

6.3.

ANIMACIN

Teniendo en cuenta que el fin de este proyecto es disear un sistema como la

base para lograr el desarrollo de la relacin entre la teora musical con la imagen
en movimiento y que la relacin msico-visual no deja de ser an un alcance, el
sistema logra manejar distintas propiedades musicales analizadas que se pueden
visualizar.

Ilustracin 104: Ejemplo, animacin en ejecucin

6.3.1. ALTURA Y PALETA DE COLORES POR TONALIDAD

El primer parametro es la altura representada en el eje x como tambin en la

creacin de una paleta de colores dependientes de la tonalidad:

Ilustracin 105: Tonalidades, circulo de quintas en RGB

Ilustracin 106: Ejemplo, tabla paleta de colores para Re mayor o menor

Ejemplo de altura:

Ilustracin 107: Ejemplos de altura de notas grabes a notas agudas

Ejemplo de color tonalidad en Re Mayor:

Ilustracin 108: Ejemplo de color tonalidad en Re Mayor

6.3.2. TONALIDADES MAYORES Y MENORES

Las tonalidades mayores o menores son representadas al degradar los colores

(mezcla con blanco) para las tonalidades mayores, y oxidndolos (mezcla con
negro) para las tonalidades menores; y son facilmente de detectar en el nivel de
luz en todo el espacio as como en el color de las esferas.

Ejemplo de tonalidad Mayor y Menor:

Ilustracin 109: Ejemplo de tonalidad mayor y menor

6.3.3. VELOCIDAD DE NOTA PIANO-FORTE

La velocidad de nota est representada en el eje z por las esferas como tambin
en la intencidad del la luz reflejada en el plano, los rangos de velocidad estan
ralacionados como: 0 a 127 como evento MIDI, de 0 a 2 para la intencidad de la
luz y de -100 hasta 100 dentro del espacio de la animacin en el eje z para las
esferas.

Ejemplo de velocidad de nota:

Ilustracin 110: Ejemplo de velocidad de nota

6.3.4. NOTAS SIMULTNEAS CONSONANCIAS Y DISONANCIAS

El Programa logra renderizar en tiempo real hasta seis esferas independientes con
todas sus diferentes caractersticas como color, posiscin en los tres ejes, luz; el
programa al detectar ms de una nota, calcla el intervalo entre cada una de ellas
y dependiendo de esto cambi el color generando colores opuestos para las
disonancias o colores dayacentes para las consonancias.

Ejemplo de disonancia o consonancia:

Ilustracin 111: Ejemplo de consonancia o disonancia

Ejemplo de varias notas notas simultaneas disonantes o consonantes:

6.3.5. GRADOS DE LA ESCALA Y TRIADAS

Ilustracin 112: Ejemplo de varias notas simultaneas consonantes o disonantes

Cuando el programa obtiene la tonalidad, ste analiza la secuencia descubriendo

qu notas pertenecen a los grados de la tonalidad, lo mismo sucede con las
triadas que son evaluadas sin importar si estn invertidas o no y si son triadas que
pertenecen a los grados de la tonalidad, con lo que ya se podra empezar a hablar
de un anlisis armnico; todos estos resultados son representados por el color de
las luces en el espacio.

Ilustracin 113: Ejemplo de grados importantes de la escala

Ilustracin 114:Ejemplo, triadas de una escala

Ejemplos:

Ilustracin 115: Ejemplo, colores que corresponden a los grados y a las triadas halladas en la secuencia MIDI

6.4.

DETRS DE LA INTERFAZ Y LA ANIMACIN

Ilustracin 116: Ejemplo, lista de eventos MIDI en texto

Detrs del toda la parte interactiva o visual, existen productos con informacin que
el programa va generando a medida que va sucediendo ste proceso. El primer
producto es una lista de todos los eventos de la Secuencia MIDI descompilados
por el programa MIDICSV cuyos datos son capturados por Python desde MS-DOS
en una lista de texto ubicada en la carpeta Interfaz con el nombre de Out.

Ilustracin 117: Directorio Interfaz y PdGem

La otra lista de informacin y por la que el programa de anlisis se tarda tiempo en

procesar y que es donde se encuentra toda la informacin que Pure Data debe
leer, est en el archivo pypd hallado en la carpeta PdGem, ah encontrar todas
las rdenes para la animacin:

Ilustracin 118: Ejemplo, lista de eventos para ser ledos por el secuenciador Qlist

En la parte de programacin, el cdigo est organizado y documentado para que

el desarrollador tenga la facilidad de entender el cdigo.

Ilustracin 119: Ejemplo, detalle de la organizacin del cdigo para la clase general del programa

Ilustracin 120: Ejemplo, detalle documentado de la organizacin del cdigo para una sub-clase

Se sugieren encabezados en el cdigo inactivo como una gua ubicando al

programador dentro de un comienzo y un fin de acuerdo a los procesos.

Se colocan formas de impresin desactivadas luego de procesos importantes

(cdigo en verde) como una ayuda para el desarrollo de pruebas:

Ilustracin 121: Ejemplo, cdigo para imprimir resultados luego de haber un proceso

7.

CONCLUSIONES Y RECOMENDACIONES
7.1.

CONCLUSIONES

El concepto de sinestesia para aquellas personas que no la poseen (nonsinestsicos), les puede hacer pensar en cules seran las posibilidades, si en
ellas existiera esta singularidad (como problema o virtud) generando otros
panoramas de percepcin y por ende reacciones psicofsicas, ampliando su
capacidad de concepcin de la realidad. Hacer visual la msica es la meta que
nace con este proyecto en donde a la final y de cualquier manera va a existir un
arte que va a germinar en otro arte.

En este proyecto logra crear una base para futuros desarrollos tecnolgicos
relacionando con la msica, la programacin y la animacin. Dicha base ampla el
conocimiento de los sistemas exponiendo claramente diferentes rutas para
analizar, procesar y transformar la informacin, mediante el desarrollo de los
recursos de software libre. Ofrece un variado panorama de posibilidades a quienes
busquen en el tema ampliar el conocimiento y crecimiento de la tecnologa,
especialmente para el software que es de todos y para todos (Open Source).

Para que el programa fuera capaz de hallar los resultados esperados, es decir,
que procesara la estructura musical, se tuvo que partir de informacin binaria
hallada en el protocolo de comunicacin y haciendo uso de pequeos programas,
disear mtodos de anlisis que vayan descifrando la informacin numrica hasta
lograr informaciones bsicas sobre la estructura musical, teniendo en cuenta que
dicho protocolo no se ha diseado en si para la escritura musical sino ms bien
fue creado para la comunicacin musical; los archivos MIDI estn diseados para
reproducir msica, y no para la notacin musical o impresin; en otras palabras,
los archivos no incluyen informacin sobre la notacin como ligaduras,
articulaciones y/o maquetacin. Tampoco puede discernir la escritura enarmnica

(como la diferencia entre Fa# y Solb)46. Es decir, el proyecto logr desarrollar un

programa capaz de interpretar la informacin musical de un protocolo de
comunicacin estndar y espera llegar a descifrar procesos ms complejos de la
teora musical, como las funciones armnicas y las formas musicales.

Es un objetivo logrado haber creado las herramientas para que el desarrollador

interesado pueda, haciendo uso de la programacin, reconocer los procesos
musicales, mediante un solo sistema que analiza innumerables posibilidades de
escritura en archivos MIDI. Una de estas herramientas consiste en tomar la
secuencia y diferenciar las notas alteradas de la misma, continuar con la
aclaracin de la informacin enarmnica y descubrir si las notas alteradas son
sostenidos o bemoles hasta, finalmente, dar con la tonalidad mayor o menor en la
que fue compuesta la pieza. Otra herramienta lograda que parte de la anterior, es
la que genera la visualizacin de un flujo de eventos de manera matricial sin
perder de vista las propiedades armnicas musicales de la secuencia; y que est
bastante cerca de poder discernir las lneas meldicas de una pieza polifnica;
adems, ya es un recurso que facilita el anlisis de las funciones armnicas.

Como instrumento de enseanza, el programa puede expresar de manera visual

conceptos como ritmo, altura, intensidad, consonancia y disonancia; notas nicas
o simultneas; tonalidades mayores y menores; grados de la escala y triadas
pertenecientes a los grados del a escala. Logra intuir la polifona musical
aproximndose a la separacin de lneas musicales y tambin ayuda a discernir
diferencias musicales como tipos de piezas, compositores, periodos musicales con
simplemente visualizar la animacin. De esta manera cumple el objetivo de
convertirse en una herramienta para la enseanza de la apreciacin musical.
Faltara solamente evidenciarlo y demostrarlo mediante disciplinas inherentes a la
comprobacin y el desarrollo de pruebas educativas, psicofsicas y otras
disciplinas relacionadas.
46

GUA DE REFERENCIA: Sibelius Software versin 6.1 (pag 396)

Para llegar a los resultados visuales, el proyecto, tuvo que experimentar variadas
relaciones grficas, unidas a los conceptos musicales, convocando as al
nacimiento intrnseco de un nuevo lenguaje de comunicacin musical. Este
sistema est ms cerca de alcanzar un tipo de experiencia sinestsica,
provocando tambin una base para la creacin ms acertada del fenmeno
sincrnico visual-musical.

Otro logro es instrumentar la relacin del protocolo MIDI con el secuenciador Qlist
de Pure Data, convirtindolo en un medio de transformacin del lenguaje binario
de un archivo MIDI a un archivo con el protocolo Qlist. La ventaja es que cualquier
programador en Python puede valerse de este desarrollo y aprovechar el sistema
para extraer informacin del protocolo MIDI para emplearlo en su propio beneficio.
Otro beneficio es haber logrado la entrada de una secuencia MIDI a Pure Data
obteniendo variables fciles de manejar.

En el campo de la animacin, la posibilidad de usar la curva 3d (el plano) fue

implementada de manera sencilla, al desarrollar un sistema que permite la
variacin de valores en los tres ejes cartesianos, de manera que se pueden
desplazar de una manera ordenada y cmoda. Mediante esta creacin se pueden
experimentar muchas formas y unir stas variables controladas creando
movimiento del plano en tiempo real. Otro desarrollo que facilit el proceso de
animacin fue la creacin de un control simple para transformar rpidamente los
valores RGB, logrando tener todas las gamas de color en un simple control, as
mismo para esta aplicacin se diseo otro control con el que se puede degradar u
oxidar el color sin perder la tonalidad de color original. Una aplicacin ms
consisti en hacer un centro de mando para manipular las propiedades de las
luces y a la cual se le aadi la aplicacin de color; es decir, que para posteriores
desarrollos en GEM ya no sera necesario programar cada luz sino que al utilizar
sta estructura se tiene acceso a grandes posibilidades para la luz y su color.

En conclusin los programas creados en Pure Data fueron desarrollos para hacer
posible la rpida manipulacin de las animaciones en tiempo real del entorno
grfico GEM, mediante estructuras diseadas, facilitando el uso de las
propiedades y de los objetos de animacin.

Los recursos y las posibilidades encontrados en el software libre son poderosas y

suficientes para desarrollos posteriores del sistema. Adems, la comunidad que
rodea el cdigo abierto es supremamente bondadosa en facilitar el aprendizaje de
las herramientas Open Source.

7.2.

RECOMENDACIONES

Algunas sugerencias van encaminadas a evaluar esta herramienta para medir la

capacidad de comprensin que se puede generar mediante este sistema de
animacin musical y as poder describir el impacto social que podra llegar a tener.

El posterior desarrollo de ste proyecto puede lograrse con la contribucin de

personas de diferentes disciplinas, ya que cada proceso en este sistema puede
ser rpidamente alcanzado, llenando lagunas de conocimiento y supliendo la falta
de experiencia al abordar los distintos problemas que se presentan en su
desarrollo. Las personas adecuadas deben tener conocimientos de sistemas y el
deseo de ahondar en sistemas de computacin y software libre, programacin en
Python, Blender como modelado en 3D y animacin; uso del motor grfico en
tiempo real Blender Game Engine, conocimientos en diseo y creacin de
imagen manejando temas como semiologa y semntica de la imagen, manejo a
profundidad de la teora musical, y psicologa orientada a la psicofsica para
evaluar el producto.

Se espera desarrollar la animacin en un programa construido especialmente para

realizar modelado, animacin y creacin de grficos tridimensionales adems de
un motor de animacin en tiempo real como es Blender; para lograr la
implementacin del cdigo de este proyecto. La sugerencia tambin va dirigida a
explorar las posibilidades MIDI en Blender y Python como secuenciador y la
sincronizacin con la imagen en tiempo real.

Es importante revisar y pulir el funcionamiento del cdigo a un nivel ms avanzado

de programacin, minimizando el tiempo de los procesos del anlisis de la
secuencia MIDI. La etapa que consume ms tiempo es la organizacin de las
listas de eventos. Se recomienda encontrar alternativas para un mayor
rendimiento, revisar los mtodos para el ordenamiento de duraciones y notas
mediante estructuras mejoradas que son ms complejas y pueden reducir el
tiempo de proceso de cada secuencia MIDI que se quiere analizar.

8. BIBLIOGRAFA
8.1.

BIBLIOGRAFA SOBRE LENGUAJES DE DESARROLLO DE

PROGRAMACIN, MIDI Y SOFTWARE

ELEANOR SELFRIDGE-FIELD BEYOND

MIDI, The Handbook Of Musical Codes
GEM ENTORNO GRFICO PARA MULTIMEDIA (PAGINA OFFICIAL)
http://www.iua.upf.edu/~csora/gmv/index.php
GONZALEZ DUQUE RAUL
Python para todos
JOHANNES KREIDLER
Loadbang: Programming Electronic Music in Pure Data
PURE DATA (PAGINA OFFICIAL)
http://puredata.info/
Python PROGRAMMING LANGUAGE (PAGINA OFFICIAL)
http://www.Python.org

BIBLIOGRAFA SOBRE IMAGEN

D. A. DONDIS
La Sintaxis de la Imagen
DE MORENTIN JUAN MAGARIOS
Lo que explica la semntica visual
JOS M GONZLEZ-SERNA SNCHEZ
Sintaxis de la Imagen [en lnea] <http://www.auladeletras.net/mat_med.html#>
Semntica de la Imagen [en lnea] < http://www.auladeletras.net/mat_med.html#>
MAGARIOS DE MORENTIN, J
La(s) semitica(s) de la imagen visual.,Cuadernos 17, Revista de la Facultad de
Humanidades y Ciencias Sociales de la Universidad Nacional de Jujuy; noviembre,
PEP ALSINA, FREDERIC SES
El rea de educacin musical
Historia de la msica con propuestas didcticas y 49 audiciones

KANDINSKY
Punto y lnea sobre el plano
De lo Espiritual en el Arte

BIBLIOGRAFA SOBRE VISUALIZATION MUSICAL Y TEORA MUSICAL

ALVIRA RODRGUEZ JOS

Teora Musical; Aprendizaje [en lnea]. http://teoria.com/aprendizaje/lectura/15armaduras.htm
ANIMUSIC
Pagina Oficial [en lnea] http://www.animusic.com/
BACH, J. S.
Inventions & Sinfonies BWV 772-801 Clavierbchlein vor Wilhelm Friedemann
Bach
Clave bien temperado BWV 846-869 y BWV 870-893
DRA. ANA MARA SEDEO VALDELLS
Artculo publicado en Julio del 2007 en la revista n 0004 de Sinfona Virtual,
Espaa
DR. H. RIEMANN
Analysis of J. S. Bachs Wohltemperirtes Clavier
HELEN L. KAUFMANN
The Home Book of Music Appreciation
KLAUS EIDAM
La verdadera vida de Johann Sebastian Bach
LLOYD ULTAN
Music theory: problems and practices in the Middle Ages and Renaissance
MUSIC ANIMATION MACHINE
Pagina Oficial [en lnea] http://www.musanim.com/mam/mamhist.htm
ROSEN, CHARLES:
Bach y Hndel, La Msica para Teclado
ANA MAGDALENA BACH
Diario de Ana Magdalena Bach

STEPHEN ANTHONY MALINOWSKI

Computer-Assisted Performance

music animation machine http://www.musanim.com (pagina official)

THOMAS WHITNEY SURETTE
The Appreciation of Music
WILLI APEL
Harvard dictionary of music

GLOSARIO
Apreciacin Musical: Es un tipo de formacin musical destinado a desarrollar la
habilidad

de escuchar inteligentemente la msica, El arte de escuchar con

actividad del pensamiento, es el objetivo de los cursos de apreciacin.

BWV:

Wolfgang

Schmieder,

Thematisch-systcmatisches

Verzeichnis

der

musikalischen Werke vori Johann Sebastian Bach: Bacb-Werke-Verzeichnis

(Thematic catalogue of Bach's music)47

Contrapunto: una rama de la teora musical que estudia la tcnica que se utiliza
para componer msica polifnica mediante el enlace de dos o ms melodas. Un
tipo especial de polifona es el contrapunto.

Correlacin: 1 Relacin recproca o mutua entre dos o ms cosas, 2 Conjunto de

dos series de fonemas opuestos por un mismo rasgo distintivo, 3 Existencia de
mayor o menor dependencia mutua entre diversas variables, 4 En probabilidad y
estadstica, la correlacin indica la fuerza y la direccin de una relacin lineal entre
dos variables aleatorias. Se considera que dos variables cuantitativas estn
correlacionadas cuando los valores de una de ellas varan sistemticamente con
respecto a los valores homnimos de la otra: si tiene dos variables (A y B) existe
correlacin si al aumentar los valores de A lo hacen tambin los de B y viceversa.

Interfaz: Es el sistema que permite a los usuarios dialogar (comunicarse e

interactuar) con el ordenador y el software que ste tiene instalado. A su vez, este
software (programas) se comunica mediante un sistema de interfaz con el
hardware del ordenador.

47

Daniel R. Melamed,Michael Marissen : An introduction to Bach studies (pag 11)

Licencia Pblica General de GNU: La Licencia Pblica General de GNU, llamada

comnmente GPL de GNU, la usan la mayora de los programas de GNU y ms
de la mitad de los paquetes de software libre. La ltima versin es la 3

MIDI: Musical Instrument Digital Interface, protocolo en tiempo real para permitir la
comunicacin entre los dispositivos de hardware independiente.

Msica Acadmica: Es el nombre habitual de la msica culta, clsica, docta y

otros. El trmino que se refiere a la msica producida o arraigada en la tradicin
del arte europeo u occidental, eclesistico y la msica de concierto, abarcando un
amplio perodo que va desde aproximadamente el ao 1000 hasta el presente. La
norma central de esta tradicin, de acuerdo a una escuela de pensamiento, se
desarroll entre 1550 y 1825, centrndose en lo que se conoce como el perodo
de la prctica comn. Msica acadmica, msica artstica, msica de arte, msica
de concierto, msica clsica occidental, msica docta, msica erudita, msica
orquestal y msica seria son trminos a veces usados como sinnimos de msica
clsica.

Polifona: Cuando varias melodas discurren al mismo tiempo, teniendo la misma

importancia y cierta independencia, se habla de polifona (poli= varias; fona=
sonidos o melodas).
Sincrnico, ca: (Del gr. ; de , con, y , tiempo). 1. adj. Fs.
Dicho de un proceso o de su efecto: Que se desarrolla en perfecta
correspondencia temporal con otro proceso o causa.48

48

DICCIONARIO DE LA LENGUA ESPAOLA - Vigsima segunda edicin [en linea]<

http://buscon.rae.es/draeI/SrvltConsulta?TIPO_BUS=3&LEMA=sincronico >[citado en 23/05/11 de 2011]

Sinestesia: es el trmino utilizado para describir un conjunto de estados

cognitivos relacionados con la unin de los sentidos. Etimolgicamente hablando,
sin: unin y estesia: sentidos = Unin de los sentidos. Sinestesia es poder percibir
al mismo tiempo sentidos diferentes. Muchas personas tienen esta habilidad. Si
bien hay muchos tipos diferentes de sinestesia[2], un sinestsico no tiene por qu
tener todos y cada uno de esos tipos. Una de las sinestesias ms comunes se
llama sinestesia de grafemas. Comnmente implica percibir colores con las letras
o nmeros de manera involuntaria. Algunos sinestsicos adems pueden llegar a
percibir personalidad o gneros para sus letras o nmeros. Tambin son muy
comunes los calendarios sinestsicos, es decir, cuando uno percibe conceptos
como el ao o la semana como si fueran formas con una posicin especfica, por
ejemplo, un valo tridimensional. En estos casos, los sinestsicos pueden
orientarse con ayuda de estas imgenes mentales. Otra forma de sinestesia que
ocurre a menudo tambin es el percibir la msica como colores y formas. A veces
la msica tambin puede evocar sabores, o sensaciones de estar tocando algo.
Hay una gran cantidad de distintas sinestesias posibles.49.

Software Libre: El software libre es una cuestin de la libertad de los usuarios de

ejecutar, copiar, distribuir, estudiar, cambiar y mejorar el software. Ms
precisamente, significa que los usuarios de programas tienen las cuatro libertades
esenciales: La libertad de ejecutar el programa, para cualquier propsito; La
libertad de estudiar cmo trabaja el programa, y cambiarlo para que haga lo que
usted quiera. El acceso al cdigo fuente es una condicin necesaria para ello; La
libertad de redistribuir copias para que pueda ayudar al prjimo; La libertad de
mejorar el programa y publicar sus mejoras, y versiones modificadas en general,
para que se beneficie toda la comunidad. El acceso al cdigo fuente es una
condicin necesaria.

49

Synaesthesia.com: [en lnea]. < http://www.synaesthesia.com/es/Information/einfuhrung/ > [citado en

17/04/04 de 2011]