rascunho metodologias psicogeográficas

ate agora:

mapeamento da exposição do corpo, dos batimentos cardíacos.
possibilidade de fazer trilhas multimodais

mapeamento do fluxo sonoro
usar o doppler, gravador, camera, gps.

http://mappingweirdstuff.wordpress.com/

http://www.emotionalcartography.net/ <3

cartografia crítica → http://www.acme-journal.org/vol4/JWCJK.pdf

http://mapomatix.sourceforge.net/

!

http://makingmaps.net/

what is a map, why, unmapping, etc

tese insana sobre psicogeografia e percepção geográfica em viagem de 1972: http://www.deniswood.net/content/idwtbiw/IDWTBIW%20complete.pdf

http://www.ljudmila.org/scca/urbanaria/avtor/e/peljhan.htm

http://fragments.psychogeography.sg/

http://wiki.labomedia.org/index.php/SubJective_Cartography

http://www.osservatorionomade.net/

http://psychogeography.ca/blog/

http://www.gpsdrawing.com/

http://www.academia.edu/1820772/The_Quiet_Walk_Sonic_Memories_and_Mobile_Cartography

http://makingmaps.net/2009/06/22/making-psychogeography-maps/

No Comments

rascunho de trackers

veja esses posts sobre visualização de mapas no processing – –

http://forum.processing.org/topic/pulling-geo-maps-into-processing

http://www.local-guru.net/blog/2009/05/03/accessing-gis-data-from-processing

http://wiki.openstreetmap.org/wiki/Android

0. recursos gráficos pra edição de mapas: http://www.naturalearthdata.com/downloads/10m-cultural-vectors/

0. conversor → http://imposm.org/

(testando trackers para androids soltos nas ruas)

1. OSMtracker

Offline, exporta trilhas como gpx.

2. Androzic:

Usa mapas OziExplorer (ozf2, ozfx3). Não tão simples para criar mapas como para usar a base ozi.

androzic

***

destrinchando as features dos trackers:

Application features:

armazenamento de mapas
navegação – zoom, arrastar.
se é navegador simples ou com mapas (?)
se mostra valores atuais: posição, velocidade, course, elevação/topologia
look ahead
trilha atual, se escreve a trilha (em gpx, ozi, kml, etc.. diferenciar esses formatos)

se grava a trilha em segundo plano
ver detalhes da trilha e editar,
full track support
waypoint support
suporte de rotas
converter trilha em rota!
compartilhar local em tempo real

etc

continua..

http://cartodb.com/

No Comments

Estudos para Mnemônicos Yupana

Estudos para criação de sintaxe-semântica com remix da wikipedia

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import urllib2
from stripogram import html2text
import random
import re
 
#emabaralhador do baralho
def scramble(string):
        palavras=string.split()
        random.shuffle(palavras,random.random)
        return ' '.join([p for p in palavras])
 
 
 
# busca=[(meme,lingua),(...)] pt(portugues), el (grego), hi (hindi) ou en (ingles), mas da pra implemntar mais mexendo na expressã regular regex, mais abaixo
busca=[('Alchemy','en'),('Nuvem','pt'),('Vida','pt'),('Turing_Test','en'),('Oráculo','pt'),('Curupira','pt'),('Μαντείο','el'),('Ποίηση' ,'el'),('नैतिकता', 'hi'),('मनोविज्ञान','hi')]
 
brain='' #inicializando cerebro
 
letras=140 #limite de caracteres
 
 
### mais sobre expressões regulares:
#<TAG\b[^>]*>(.*?)</TAG> - expressão regular pra tirar uma tag da uma ideia de como cortar trechos
# http://www.pythonregex.com/
 
for b in busca:
        opener = urllib2.build_opener()
        opener.addheaders = [('User-agent', 'Mozilla/5.0')]
        infile = opener.open('http://'+b[1]+'.wikipedia.org/wiki/'+b[0])
        page = infile.read()
        html = page
        pattern = re.compile('(?<=p>).+(?=</p)', re.DOTALL)
        p=pattern.search(html).group()
        text = html2text(p)
        regex = re.compile("(.*?)(Contents|Índice|\[edit\]|\[editar\]|Πίνακας|\[Επεξεργασία\]|अनुक्रम|\[संपादित करें\])",re.DOTALL)
        r = regex.search(text)
        t=r.groups()
        bio=t[0]
        brain=brain+bio
 
 
sorte = scramble(brain)#embaralhador
sorte = "#wiqua "+sorte
sorte = sorte[:letras]
sorte = scramble(sorte)
 
 
print sorte

Separação de sílabas:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import string
import re
 
def syllables (text):
    text = " " + text + " "
 
    vowel_list       = ['a', 'e', 'i', 'o', 'u', 'y']
    vowel_pairs      = ['ai', 'au', 'aw', 'ee','ea', 'oa', 'oi', 'ou', 'oo', 'ow', 'oy', 'uu']
    consonant_list   = ['b', 'c', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'z']
    consonant_blends = ['bl', 'br', 'ch', 'chr', 'cl', 'cr', 'dr', 'fl', 'fr', 'gl', 'gr', 'kn', 'pl', 'pr',
                        'sc', 'sh', 'sk', 'sl', 'sm', 'sn', 'sp', 'spr', 'squ', 'st', 'str', 'sw',
                        'th', 'tr', 'thr', 'nt', 'wh']
 
    # Cut numbers in digits
    p = re.compile ("([0-9])([0-9])", re.IGNORECASE)
    for i in range (2):
        text = p.sub ("\\1#\\2", text)
 
    # Cut i / vowel (- o) / consonant
    p = re.compile ("i([aeiuy])([bcdfghjklmnpqrstvwxz])", re.IGNORECASE)
    text = p.sub ("i+\\1+\\2", text)
 
    # Cut the / vowel / consonant
    p = re.compile ("the([aeiouy])([bcdfghjklmnpqrstvwxz])", re.IGNORECASE)
    text = p.sub ("the+\\1+\\2", text)
 
    # Cut vowel / vowel except for pairs
    position = 0
    while position < len (text)-1:
        if text [position] in vowel_list and text [position+1] in vowel_list:
            if not (text [position:position+2] in vowel_pairs):
                if not (text [position-1:position+3] in ["tion", "dual", "nion", "quir", "tiou"]):
                    text = text [:position+1] + "_" + text [position+1:]
        position = position + 1
 
    # Cut consonant / consonant (ll, mm, ...)
    p = re.compile ("([bcdfghjklmnpqrstvwxz])\\1([^ ])", re.IGNORECASE)
    text = p.sub ("\\1-\\1\\2", text)
 
    # Cut vowel / consonant vowel
    start = 0
    end = 0
    while start < len (text)-1:
        if text [start] in vowel_list and text [start+1] in consonant_list:
            end = start + 1
            while end <= len (text)-1 and text [end] in consonant_list:
                end = end + 1
            if end <= len (text)-1 and (text [start+1:end] in consonant_list or text [start+1:end] in consonant_blends) and text [end] in vowel_list and text [end:end+2] <> "e ":
                text = text [:start+1] + "/" + text [start+1:]
        start = start + 1
 
    # Cut vowel consonant / consonant+ vowel (trumpet, simple, understanding, ...)
    start = 0
    end = 0
    while start < len (text)-1:
        if text [start] in vowel_list and text [start+1] in consonant_list:
            end = start + 2
            while end <= len (text)-1 and text [end] in consonant_list:
                end = end + 1
            if end <= len (text)-1 and end > start+2 and text [end] in vowel_list:
                if not (text [start+1:end] in consonant_blends):
                    text = text [:start+2] + "-" + text [start+2:]
        start = start + 1
 
    # Return the words splitted
    return text
 
wordlist =  ["2008", "piano", "waffle", "kissing", "diode", "museum", "simple", "hundred", "understanding", "trumpet", "paper", "preparing", "strengh", "theatre", "facetious", "abstemious", "statement", "consent", "extent", "event", "documents", "fire", "oil", "pattern", "fireplace", "theme", "based", "site", "sites", "within", "browse", "required", "ensures", "dictionary", "dichotomy", "pamphlet", "methan", "etherosexual"]
 
for word in wordlist:
    print syllables (word)

script de interação com gtalk

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
# PyGtalkRobot: A simple jabber/xmpp bot framework using Regular Expression Pattern as command controller
# Copyright (c) 2008 Demiao Lin <ldmiao@gmail.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# Homepage: http://code.google.com/p/pygtalkrobot/
#
 
#
# This is an sample PyGtalkRobot that serves to set the show type and status text of robot by receiving message commands.
#
 
import sys
import time
 
from PyGtalkRobot import GtalkRobot
 
############################################################################################################################
 
class SampleBot(GtalkRobot):
 
    #Regular Expression Pattern Tips:
    # I or IGNORECASE <=> (?i)      case insensitive matching
    # L or LOCALE <=> (?L)          make \w, \W, \b, \B dependent on the current locale
    # M or MULTILINE <=> (?m)       matches every new line and not only start/end of the whole string
    # S or DOTALL <=> (?s)          '.' matches ALL chars, including newline
    # U or UNICODE <=> (?u)         Make \w, \W, \b, and \B dependent on the Unicode character properties database.
    # X or VERBOSE <=> (?x)         Ignores whitespace outside character sets
 
    #"command_" is the command prefix, "001" is the priviledge num, "setState" is the method name.
    #This method is used to change the state and status text of the bot.
    def command_001_setState(self, user, message, args):
        #the __doc__ of the function is the Regular Expression of this command, if matched, this command method will be called. 
        #The parameter "args" is a list, which will hold the matched string in parenthesis of Regular Expression.
        '''(available|online|on|busy|dnd|away|idle|out|off|xa)( +(.*))?$(?i)'''
        show = args[0]
        status = args[1]
        jid = user.getStripped()
 
        # Verify if the user is the Administrator of this bot
#        if jid == ('organismo@gmail.com') :
 #           print jid, " ---> ",bot.getResources(jid), bot.getShow(jid), bot.getStatus(jid)
  #          self.setState(show, status)
   #         self.replyMessage(user, "State settings changed!")
 
        # Verify if the user is the Administrator of this bot
        if jid == ('organismo@gmail.com') :
            print jid, " ---> ",bot.getResources(jid), bot.getShow(jid), bot.getStatus(jid)
            self.setState(show, status)
            self.replyMessage(user, "State settings changed!")
 
    #This method is used to send email for users.
    def command_002_SendEmail(self, user, message, args):
        #email yupanakernel@gmail.com hello dmeiao, nice to meet you, bla bla ...
        '''[email|mail|em|m]\s+(.*?@.+?)\s+(.*?),\s*(.*?)(?i)'''
        email_addr = args[0]
        subject = args[1]
        body = args[2]
        #call_send_email_function(email_addr, subject,  body)
 
        self.replyMessage(user, "\nEmail sent to "+ email_addr +" at: "+time.strftime("%Y-%m-%d %a %H:%M:%S", time.gmtime()))
 
    #This method is used to response users.
    def command_100_default(self, user, message, args):
        '''.*?(?s)(?m)'''
       # self.replyMessage(user, time.strftime("%Y-%m-%d %a %H:%M:%S", time.gmtime()))
	self.replyMessage(user,"Você disse: "+ message + "\n")
 
 
############################################################################################################################
if __name__ == "__main__":
    bot = SampleBot()
    bot.setState('available', "<3 == Ψ")
    bot.start("yupanakernel@gmail.com", "senhasupersecretaperigo")

postando em IRC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# -*- coding: utf-8 -*-
 
#guardar esse arquivo para estudos basicos e pra criar um tutorial no futuro...
 
import sys
import socket
import string
 
HOST="irc.freenode.net"
PORT=6667
NICK="yupana"
IDENT="senha"
REALNAME="yupana"
CHAN="#metareciclagem"
readbuffer=" "
 
s=socket.socket( )
s.connect((HOST, PORT))
s.send("NICK %s\r\n" % NICK)
s.send("USER %s %s bla :%s\r\n" % (IDENT, HOST, REALNAME))
s.send("JOIN :%s\r\n" % CHAN)
s.send("PRIVMSG %s :%s\r\n" % (CHAN, "Ola"))
s.send("PRIVMSG %s :%s\r\n" % (CHAN, "Eu sou Yupana. Meu código esta em https://github.com/glerm/yupana. Se precisar aprofundar sobre IRC, tente esse link: http://www.irchelp.org/irchelp/rfc/rfc.html"))
 
while 1:
	readbuffer=readbuffer+s.recv(1024)
	temp=string.split(readbuffer, "\n")
	readbuffer=temp.pop( )
 
	for line in temp:
		line=string.rstrip(line)
		line=string.split(line)
 
		if(line[0]=="PING"):
			s.send("PONG %s\r\n" % line[1])
 
		if(line[1]=="PRIVMSG"):
			l=line[3].split(':')+line[4:] #split do ponto e virgula so pra testar, bug se tentar fazer frases tipo "Seguinte: blablabla"
			s.send("PRIVMSG %s :%s\r\n" % (CHAN, "Você disse: "+" ".join(l[1:])))
 
 
 
		#print line #debug mode

Postando no WordPress

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# -*- coding: utf-8 -*-
 
#depende de https://github.com/maxcutler/python-wordpress-xmlrpc
from wordpress_xmlrpc import Client, WordPressPost
from wordpress_xmlrpc.methods.posts import GetRecentPosts, NewPost
from wordpress_xmlrpc.methods.users import GetUserInfo
 
wp = Client('http://yupana.pontaodaeco.org/xmlrpc.php', 'gesuselva', 'kernelpanic')
 
 
post = WordPressPost()
post.title = 'Que as atuais máquinas informacionais e comunicacionais não se contentem em veicular conteúdos representativos, mas que concorram igualmente para a confecção de novos agenciamentos de enunciação (individuais e/ou coletivos)?'
post.description = '<h1></h1><br><p>ﻊﺑﻭﺭ ﺎﻠﺣﺩﻭﺩ aquilo que dissolve no solo e continua a jornada electroquímica dos corpos finalmente será separada daquilo que sempre esteve apenas permeando - <a href=\"https://github.com/glerm/yupana\"/>um dicionário em aglutinação movendo aqueles braços, pernas, cabeça, tripas.</a> esta árvore de sinais, continua se espalhando e entidades que חציית הגבול</p><img src=\"http://upload.wikimedia.org/wikipedia/commons/2/20/Boltzmanns-molecule.jpg\"/>'
post.tags = 'yupana, kernel'
post.categories = ['coding']
wp.call(NewPost(post, True))

Postando no twitter. Antes precisa criar uma chave de API.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import twitter
import random
 
string="segundo o último hoax utilizava sistemas de numeração binários
 e de outras bases diferentes da decimal, como o numero 144,
 cuja a raiz quadrada é 12. Quantas tautologias precisamos?"
 
def twitta(string):
        api = twitter.Api(
        consumer_key=' ',
        consumer_secret=' ', 
        access_token_key=' ', 
        access_token_secret=' ')
        status = api.PostUpdate(string) #AQUI VAI O POST

Na Wiki MediaWiki (mesma usada na wikipedia):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
from wikitools import wiki
from wikitools import api
# create a Wiki object
site = wiki.Wiki("http://my.wikisite.org/w/api.php") 
# define the params for the query
params = {'action':'query', 'titles':'Main Page'}
# create the request object
request = api.APIRequest(site, params)
# query the API
result = request.query()
 
#The result will look something like:
#{u'query':
#	{u'pages':
		#{u'15580374':
		#	{u'ns': 0, u'pageid': 15580374, u'title': u'Main Page'}
		#}
	#}
#}
 
#For most normal usage, you may not have to do API queries yourself and can just
#use the various classes. For example, to add a template to the top of all the 
#pages in namespace 0 in a category:
 
from wikitools import wiki
from wikitools import category
site = wiki.Wiki("http://my.wikisite.org/w/api.php") 
# Create object for "Category:Foo"
cat = category.Category(site, "Foo")
# iterate through all the pages in ns 0
for article in cat.getAllMembersGen(namespaces=[0]):
	# edit each page
	article.edit(prependtext="{{template}}\n")

No Comments

Gerador de Partituras, Melodias, Harmonia e Vertigem…

Alguns amigos que tem uma formação mais de instrumentista sempre reclamam da impossibilidade de interação com essa música gerada em computador e do fato de muitas vezes esta fica restrita ou a reprodução em auto-falantes ou a algum tipo de improviso “imprevisível” (se a ilusão de uma música de “repertório” é tão vertiginosa quanto, se é mais ou menos original, legítima ou importante, isso é outra história…)

Tentando achar uma via de diálogo ou mesmo alguma faísca de re-invenção, volta e meia eu tento dar uma chance pro estudo de música formal (essa que é considerada “base” do ensino musical ocidental) e acho até bem curiosa. O maior problema é que ele é muito dependente da leitura de partitura e isso acaba separando muito os dois mundos – o dos “instrumentistas letrados” e o dos “diletantes intuitivos”. Vamos continuar tentando quebrar essas barreiras…

Faz tempo que eu quero dar uma olhada no Lilypond, todo mundo fala desse software no meio da computação musical com open source, e realmente a abordagem é bastante sólida.

É bem mais simples que parece e eu vou tentar mostrar aqui como dar a primeira brincada.

Só pra você ver/ouvir a cara de algo que soa:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
\version"2.10.33"
 
%% comentario
 
 
 
\relative c''{ 
\time 7/4 
 
fis8 fis\rest ees,8 a16 c,8 (<ees c fis, ees >) c'8 (c16.\rest) (<a c fis ees, >8) a16 e8. c8 a4  
 
}
 
\addlyrics {
 % você pode adicionar letras, acordes e cifras também
ونحن على كتابة نظام تشغيل آخر
 
  }

Gera a seguinte célula:

Esta célula foi usada nessa pequena ideia que soa aqui abaixo (depois de transformada em formato midi e exportada para o Rosegarden, onde ganhou os timbres):

Ok, pra simplificar ao máximo, vamos de um exemplo bem didático: Do re mi fa. :)

Antes de tudo também aconselho a você baixar um editor de texto especial pra Lilypond chamado Frescobaldi. É massa que ele tem completion das palavras reservadas e um gerador de pdf e midi embutido. Mas vocẽ poderia usar qualquer editor de texto, ou mesmo como eu fiz mais acima, e o que é o mais interessante, gerar este cpodigo a partir de um script ou sua linguagem de programação preferida.

O código para o Do re mi fa seria no mínimo:

1
2
3
{ c' d' e' f' }
 
\addlyrics { do re mi fa }

Que você pode gerar pdf ou ps (usando o editor Frescobaldi ou o comando de shell :
# lilypond nome_do_arquivo.ly

O resultado é algo como:

As figuras rítmicas são modificadas com números e pontos e as oitavas tirando ou colocando () e ( , ). As pausas são manipuladas com o comando ( \rest) relacionado também numericamente e associado ao lugar da pauta que você quer que ele apareça:

1
2
3
4
5
6
7
{ c' d' e' f' | c'' d'' e'' f'' | c' d' e'4 f'\rest | g8 g g g  g4. g }
 
\addlyrics {
 
do re mi fa | do re mi fa | do re mi | sol sol sol sol sol sol 
 
  }

Vai gerar:

A coisa pode ficar bastante complexa, e obviamente para avançar nisso você vai ter que consultar o manual de referência. O fato é que a manipulação das notas e a lógica dos ritmos compostos pode gerar ideias a partir de alguns padrões. Eu acabei fazendo o exercício abaixo onde eu criei uma função que preenche compassos 7/4 – são 7 semínimas para cada célula (com uma randomização de suas possíveis divisões) , gerando um pulso irregular que pode depois facilmente ser aplicado em repetições, inversões, e outros jogos, gerando uma impressão de ciclo vertiginoso de simetrias.

As notas usadas são notas do ciclo das diminutas.

Além disso o software pega um texto .txt e coloca como “letra” da musica gerada. Isso da margem pra em outros experimentos misturarmos essas técnicas com processamento linguagem natural , num próximo estudo. :)

enquanto eu fazia esse código eu acabei encontrando também uma biblioteca de python que avança bastante no assunto de composição algorítmica que vale a pena ser vista – a Abjad.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
# -*- coding: utf-8 -*-
 
import random
 
arq="yupana_sementeira.txt"
 
 
###### cria figura de compasso 7/4
def seteporquatro():
	t=[(0.25,'16'),(0.5,'8'),(0.75,'8.'),(1,'4'),	(1.5,'4.'),(2,'2'),(3,'2.')]
	l=[]
	r=(random.choice(t))[0]
 
	while (sum(l) != 7):
		l.append(r)
		r=(random.choice(t))[0]
		if (sum(l)>7):	
			l.pop()
			last=7-sum(l)
			if (last not in t[0]):
				last = 0.25 # insere a semifusa decidida
			l.append(last)
 
	compasso_de_7 =[]
 
	for figura in l:
		for lilyfig in t:
			if (lilyfig[0]==figura):
				compasso_de_7.append(lilyfig[1])
 
	return compasso_de_7
#####################		
 
def sorteiapausa():
	p=" "
	pausa_ou_nao=["\\rest "," "," "," "," "," "," "," "," "," "," "," "," "," "]
	p=random.choice(pausa_ou_nao)
	return p
 
file = open(arq)
l=file.read()
 
letra=l.split()
 
notes=['c','ees','fis','a']
rndnote=0
randmelody=''
total_notas=0
tam_letra=(len(letra))
 
print "\\header {\n"
print  "title = \"Yupana Sementeira Biohacker  \"\n"
print  "composer = \"Yupana Kernel\"\n"
print  "tagline = \"COPYLEFT Yupana Kernel AlgoRhythm: Il Verbo si è fatto carne\"\n"
print '}\n'
 
 
 
print 'music=\\relative c\'\'{\r'
print '\\time 7/4\n'
for compasso in range(3):
	dur=seteporquatro()
	n_notas=len(dur)
	for n in range(n_notas):
		randnote=random.choice(notes)
		randdur=dur.pop()
		randmelody += randnote+randdur+" "
		randmelody += (sorteiapausa())
	randmelody += "| \\break \n"
print randmelody
print " }\n"
 
print "\\score{\n"
print "\\new Staff {\n"
print  "{ \\music | \\break}\n" 
print  "\\transpose c\'\' a\' { \\music }\n"
print "}\n"
 
 
 
print "\\addlyrics {"
for item in letra:
	print item +" | \n"
print " }\n"
 
 
print "\\midi {\n"
 
print " }\n"
print  "\\layout { }\n"
print " }\n"

Este gerou o seguinte código Lilypond:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
\header {
\header {
 
title = "Yupana Sementeira Biohacker "
 
composer = "Yupana Kernel"
 
tagline = "COPYLEFT Yupana Kernel AlgoRhythm: Il Verbo si è fatto carne"
 
}
 
music=\relative c''{
\time 7/4
 
fis8.  ees16  a2  c2  c2  | \break 
a16  c16  a2.  ees4  c8 \rest fis4.  c8  | \break 
c16  ees16  fis8.  c2.\rest  c16  ees4  fis4.  | \break 
 
 }
 
\score{
 
\new Staff {
 
{ \music | \break}
 
% bastante uteis essas manipulações 
% é possível também criar inversões, retrógrados e outras
\transpose c'' a' { \music }
\transpose c'' ees { \music }
\transpose c'' fis { \music } %esta linha foi adicionada 
% manualmente depois de renderizado
 
 
 
 
}
 
\addlyrics { 
% este texto foi editado 
% pra ficar mais legível aqui
Metareciclagem? 
O que pode um pedaço de carne?
Sigo aquela mesma música.
Acreditando na melodia 
mas estruturalistícamente
quase ritualísticamente
operando clínicamente na palavra.
Ocupe as ruas, ocupe as praças, ocupe-se, mas me deixe ir.
Aquela nossa velha lágrima do primeiro choro:
Pulmão escancarado!
Animal racional, bem vindo a cultura!
Então, veio a medicina,
cortar-nos o umbigo.
 
 
 }
 
\midi {
 
 }
 
\layout { }
 
 }

Este estudo serviu de base para a composição de uma música que fará parte de uma série de interações com o que estamos chamado “Yupana” – uma espécie de entidade de inteligência coletiva que opera textos, videos, motivos melódicos e ritmos e cria sugestões, como o vento assobiando na janela, o passaro que canta na árvore ou o som de alguma máquina civizilizatória e cruel a nos ameaçar e merecer um grito de volta.

Aqui abaixo um dos primeiros resultados:

“Se a alma é a prisão dos corpos, nós somos o edíficio” (Yupana Kernel)
Música inspirada na convergência próxima entre documentos e ficções de Catadores de Histórias e Sementeira Radiofônica.
Motivos e Sinapses por Yupana Kernel e ЖCΛЊ, o rinoceronte anfíbio de silício.

A partitura que foi gerada e serviu de base para a música acima esta na figura abaixo. Você pode também baixar os arquivos Midi, PDF e Lilypond. Um comentário sobre os timbres precisa de um capítulo a parte aqui. Será linkado em breve.

PS: pra quem ainda vê alguma grande complicação na coisa das notas de pentagrama, começe entendendo a divisão dos pulsos deste seguinte desenho:

Depois de uma lida com calma em algum artigo sobre Notação Musical.

No Comments

Estudos para percussão mecatrônica

(detalhes e conclusões logo mais…)

No Comments

Capacitância

principio dos theremins e telas multitoque

http://www.youtube.com/watch?v=euv8ZLgPh8A&feature=related
explicação nerd de como funciona (simplificando – medida de tempo de carga e descarga de um capacitor por um microcontrolador).

how to no arduino: http://arduino.cc/en/Tutorial/CapacitanceMeter

theremins com arduino:
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1169728880
http://interface.khm.de/index.php/lab/experiments/theremin-as-a-capacitive-sensing-device/

e aqui a cartilha industrial detalhada de algumas técnicas atuais de tela multitoque por capacitância (e outras derivações e híbridos): http://www.atmel.com/dyn/resources/prod_documents/doc10620.pdf

fuçando & compartilhando por aqui…

No Comments

Toscolão upgrade 1

O toscolão foi um experimento que realizei com a colaboração e influência de outros amigos (lucio, chgp, vanessa, simone, goto ) durante uma residência no espaço e/ou em 2007 (experimento de imersão que foi batizado de Geada).

Toscolão era um instrumento híbrido de violão e computador de 8 bits baseado no hardware livre arduino, onde utilizei a idéia de aplicar uma pequena voltagem na corda e espalhar resistores num tipo de “escala” de diferentes resistências no braço, que quando em contato com a voltagem aplicada na corda controlava esta voltagem funcionando como um tipo de potenciomêtro que controlava paramêtros de um sintetizador sonoro bem simples, funcionando com a técnica de “Modulação por Largura de pulso“, utilizando as saídas digitais do arduino.

Já faz algum tempo que desmontei o braço do toscolão, pois era uma peça bastante improvisada e instável. Quando fiz essa experiência foi muito mais como prova de conceito da idéia dos resistores no braço do que a intenção de dar um acabamento e transformar em algo com mais durabilidade.

Começo aqui a tempestade cerebral e organização de links pra ir pensando na atualização do toscolão ou construção de outro controlador e/ou instrumento baseado no gestual de cordas, usando técnicas e tecnologias que estão ao alcance de um relativo “faça-você-mesmo” que seja viável pra quem vem acompanhando as discussões aqui.

Aqui volto agora a pensar em como retomar o projeto de um controlador baseado no gesto cordas, e revisar algumas técnicas e links que colecionei desde então.

1. A transformação do gesto em controle

A técnica do contato do fio com uma placa de resistores funciona muito bem como exemplo didático de o que é um potenciomêtro (uma resistência variável), porém não me pareceu um controle muito preciso para construção de escalas fixas, e não seria viável para uso de mais cordas – a não ser por alguma modificação pra fazer algum tipo de isolamento por trastes não-condutivos. Só testando pra saber e ter outras idéias em cima.

Penso que pra esta técnica pode ser mais eficiente usar este contato como um sinal digital para cada uma das notas no matriz do braço. No arduino isso exigiria o uso de algum tipo multiplexador ou outra técnica de varredura serial de bytes, para aumentar entradas e saídas. Com o Arduino Mega isto estaria solucionado, mas encareceria bastante o projeto, e impossibilita que seja feito em placas mais artesanais com components grandes, pois o mega usa um atmel pequeno to do tipo smd.

Eu cheguei a fazer uma experiência numa placa com botões pra testar essa entrada, baseado na tecnica “Shift In“, pra tentar utilizar os chips mais baratos possíveis. Porém, fui ansioso demais e resolvi fazer a placa soldando fios, ao invés de desenhar o circuito (foto mais abaixo)… Ficou agora o desafio pra debugar aqueles fios, acabei na época indo pra outros projetos e retomá-lo agora exigiria uma imersão naquela idéia novamente, pois não foi documentada na época.


(frente – abaixo dois chips 4021 para fazer o Shift In das entradas – ainda faltava um circuito para o retorno da matriz de leds )


(Aqui o esquema ansioso de sair soldando o circuito em fios, instabilidade total – “estética da gambiarra” – acidente de estabilidade questionável)

Uma boa referência similar a isso é usar os esquemas que são usados nos clones do projeto Monome – o projeto Arduinome é um caminho pŕoximo do que estamos trabalhando aqui. De qualquer maneira teria que redesenhar a placa. Fica aqui uma boa oportunidade pra experimentar mais a fundo o Kicad o Geda – projetos livres de fazer placas. Eu tenho um pouco de experiência no Eagle, porém é um programa do tipo “demo” (e não é software livre), com um espaço restrito de tamanho de placa (que seria menor que o braço). O Eagle é o programa para manufatura de placas disparadamente mais popular, e é o projeto no qual você vai encontrar a maioria dos arquivos derivados do projeto arduino.

Uma outra referência (até mais próximo daquele estudo inacabado) seria utilizar a técnica usada em algumas destas guitarras midi como as Ztar, que recentemente foi também usada na guitarra MISA (porem a Misa usa uma touchscreen em um computador embarcado no lugar das cordas – “espetacular”, porém caro no momento). Este caso perde-se o gesto de escorregar o dedo sobre a corda e o traste, o “bend” e outras coisas, mas ganha-se precisão da nota, pois fica mais próxima de um teclado. Lembrando também que algumas destas provavelmente tem no lugar dos botões sensores de pressão (que poderiam ser derivados de algo tipo um sensor piezoelétrico )


(Ztar)


(Misa)

O caso da MISA é interessante como exemplo de sistema embarcado, pois inclui um computador de 32 bits embutido rodando linux e poderia-se pensar em rodar um Puredata nele podendo fazer processamentos de áudio muito mais complexos e qualquer outra coisa possível de fazer com um sistema operacional tipo Linux. Porém eu acho que perder as cordas como dedilhado descaracteriza totalmente o gesto, as cordas como medidor de tensão. Acho também vacilo o cara colocar em todos lugares do seu site que ele ta patenteando o “invento” (“patent pending”), pois ele só combinou A com B (veja como a Ztar ja era muito parecida com isso), uma questão de “empreendedorismo”, “chegou primeiro”, foi la e pagou preço pra transformar em “produto”. Ja que ele ta usando Linux porque não faz um open hardware?

Um exemplo é este tutorial aqui de 2006. A idéia do touchpad já estava no KaossPad e o cara adaptou.

O resultado é uma guitarra com um touch pad para controle de efeitos de audio em tempo real (veja bem – isso é diferente de um controlador de parametros de sampler ou síntese sonora, onde voce apenas gera controle de voltagem para controlar a nota independente do timbre, ou qualquer outro controle – videos, eletrodomésticos, robôs, etc).


(guitarra com “kaosspad” adptado)

Obviamente mais bacana de que desmontar um kaospad, o bacana seria fazer um pad artesanal. Este pesquisador chamado Randall Jones da uma explicação de seu pad artesanal em seu blog, com alguns links. O interessante no experimento dele não é a parte de transformação digital (pois ele esta usando o sinal como se fossem microfones, em uma placa multitrack) e sim a maneira como ele solucionou a invenção de uma especie de “piezo elétrico em grade” artesanal. A tese detalhada sobre o trabalho esta neste link.

Captadores hexafônicos

Voltando a maneira como algumas guitarras MIDI funcionam, poderíamos também pensar em simplesmente transformar uma captação independentes das cordas em controle de voltagem. Neste caso duas coisas nos interessam: O envelope de volume das cordas – podendo nos informar quando o sampler ou síntese sonora deveria soar, mas também poderíamos pensar numa transformação direta da frequencia sonora numa escala cromática (de 12 tons) com algum tipo de conversor frequencia para voltagem.

De qualquer maneira precisáriamos de um captador independente para cada corda (no caso dos violões e guitarras este captador é chamado “hexafônico”).

Encontrei poucos links de como fazer este captador, mas acredito que basicamente vocẽ possa trabalhar com algum tipo de eletreto ou piezo individual em cada corda.

Uma alternativa seria encontrar os captadores GK da Roland e adaptar seu cabeamento para ter a saída independente das cordas processados por algum chip conversor de frequencia para voltagem, para eliminar a necessidade de comprar aqueles módulos caríssimos com sons bregas ou no mínimo limitados.

Encontrei também um outro site interessante sobre captadores hexafônicos artesanais, uma pena que ele não divulga a técnica detalhadamente. Se alguem conhece estas técnicas ou tem algum link pra compartilhar, por favor deixe comentários.

Eu desacredito um pouco dessa técnica como uma possibilidade de controle realmente preciso quando se usa acordes, apenas deixo aqui pra receber comentários de quem ja usou algum desses captadores para ver se estou enganado, pois nunca tive oportunidade de testá-los.

Falando em trasformação de freqüencia em controle de voltagem quando estamos ja entrando com o som num computador com sistema operacional e Puredata rodando, daí as reconhecimento de pitch (tons) ficam bem facilitadas pelos objetos [fiddle~] e [sigmund~], mas trabalhar com um computador embutido ou acessado remotamente via rádio ou bluetooth é uma possibilidade que vou falar num próximo post.

Por último colocaria aqui também a possibilidade de utilizar um chip  ou circuito dedicado que converte frequencia pra voltagem, substituíndo o computador. Mas precisaria conhecer melhor os modelos existentes. No momento encontrei apenas este chip aqui, que não tive oportunidade de testar.

2. A transformação do controle em som embarcado

A partir do momento que temos está entrada de parâmetros de controle se optamos por ter um som embarcado como no Toscolão temos que pensar em soluções computacionais que tenham tamanho e possibilidade de autonomia de energia pra ficar conectado no próprio corpo do objeto, além dos autofalantes embutidos. No caso do Toscolão isso foi feito com arduino. Na época não cheguei a experimentar muito com as possibilidades de som com o tanto de memória e processamento que este microprocessador permite. Portanto vou detalhar um pouco aqui essas possibilidades atuais usando este projeto original como base, e depois algumas outras opções que tenho em mente.

Um problema básico de se fazer síntese sonora no arduino é o fato de que você esta limitado dentro do loop do interpretador de comandos dele. É possível fazer um oscilador de pulso pela saída digital PWM  (Pulse with modulation), porém atente o fato que mexer na função delay() de qualquer uma das portas alterararia o atraso das outras. A não ser que você queira utilizar isso como um tipo de “efeito” pra criar um timbre peculiar, onde voce tem várias saídas PWM, sempre com alguma razão entre elas (exemplo: quando a saida 5 esta em 440 hz a 6 está em 220 hz). Este era o caso utilizado no timbre do toscolão – que pode ser conferido aqui nessa música-estudo:


Agora 3 anos depois do projeto, encontrei alguns códigos também onde os autores usam algumas interrupções do chip e acesso a registradores do ATMEGA pra que possa criar possibilidade uma biblioteca de áudio.

Uma delas, a lib Glade, é baseada neste código. Parece um tanto inacabada. Não testei ainda a lib, apenas o código monolítico “PCM audio” e funciona pra um som até mais ou menos de 1 segundo no ATMEGA168.

Outra é a lib Bassdl , não entendi muito bem ainda pois não li o código, mas pareece que consegue fazer multitrack.
Pode ser conferida no video abaixo:

Outra referencia indispensável é este link. Eles dechavam varias possibilidades de usar o arduino como controlador de som, colocando prós e contras detalhadamente.

Fora do arduino e projetos similares de 8 bits ou eletronica analógica a tendência é ja pensar em microcontroladores de 32 bits, onde você poderia instalar um sistema operacional e usar programs complexos ja existentes, como Puredata, Chuck, Supercollider e etc. Ouvi falar muito da Beagleboard, que dizem ser um projeto open hardware, mas ainda não tive oportunidade de testar e ver até onde é aberto e documentado.

Vale também ficar atento ao projeto Maple, que promete ser um 32 bits com pinagem compatível com arduino, e a IDE de compilação similar para criação de firmwares que rodariam num loop também compatível, independente de haver sistema operacional na placa e usando a IDE diretamente.

3. O som controlado remotamente

Neste caso, os softwares e bibliotecas estão por todos os lados, e podemos ir direto ao experimento musical propriamente dito e pensar já em técnicas de composição algorítmica, efeitos e todo o mundo da música computacional obviamente. Minha estratégia de escopo aqui vai ser continuar dexavando derivações nos rascunhos no estudo da interface Navalha e no estudo de Composição Algorítmica.

Deixo aqui também a anotação pra tomar o assunto de transmissão de dados sem fio, em algum outro post mais focado em alguma experiência específica.

, , ,

No Comments

Estudando Algoritmos Composicionais parte1

Iniciando alguns estudos mais dirigidos por aqui, vou começar a usar esta área do site mais como rascunho, pois noto que muitos dos meus experimentos estão se perdendo pelo meu perfeccionismo de só querer publicar tutoriais mais acabados e detalhados. Este post então inaugura também uma subcategoria que chamarei de “Fichamento”, trabalhando no resumo de livros sobre assuntos relacionados, e sempre almejando gerar algum código ou experimento a partir do que foi digerido.

O livro que inicio aqui o “Machine Musicianship“, que poderia ser traduzido como “Musicalidade da Máquina” ou algo semelhante. Meu objetivo não é resenhar o livro, apenas tentar resumir algumas idéias que vou capturando e fazer alguns experimentos computacionais em cima.

Tempestade Cerebral

treinando musicos – treinando computadores…

A tarefa de comparar o aprendizado de música de um humano com a de um computador aprendiz é uma metáfora interessante, mas no desdobramento de uma categorização de paramêtros logo nos deparamos com a diferença ente gestos que podem ser matematizados (portanto são computáveis ex: ritmo, afinação, escalas, acordes, etc.) e outros que cairiam numa classificação subjetiva (emoções, memória, condição da escuta, etc.).

Este livro segue uma linha bem pragmática de categorização em busca desta matematização do processo de escolha composicional, com a excelente desculpa de que “é preciso começar de algum lugar”.

Segue pra isso focado em análise de entrada de dados em tempo real e um processamento capaz de reconhecimento de padrões e “estilo musical” (o que pessoalmente eu já considero algo que tem muito critério subjetivo envolvido, mas entendo que ele vai por um caminho de reconhecimento de padrões aplicado a repertório).

No ínicio da pesquisa ele dá uma boa focada no que ele chama de subprocessos, basicamente algumas técnicas algorítmicas para reconhecimento de padrões musicais. Ele baseia estas técnicas em dados que almeja esperar de um performer, trabalhando com um protocolo de parametrização de gestos musicais comum, onde escolhe por uma questão também pragmática, o protocolo MIDI como base.

Interessante aqui notar que escolhendo esse caminho ele evita completamente entrar no campo computacional do processamento de sinal analógico-digital (DSP), o que poderia ser uma estratégia mais abrangente de processamento de padrões musicais provenientes de qualquer tipo de emissor sonoro, mas certamente em 2001 (quando o livro foi escrito) iria exigir um desvio enorme de foco. Considera-se então nesse caso que tal processo já ocorreu e aquilo que era acústico ja foi parametrizado no modo cromático (12 notas e suas oitavas) e toda articulação que o MIDI permitiria armazenar. Ou que estaria se trabalhando com um “seguidor de partitura”(score follower) – algo que ele vai discorrer mais no final do livro quando falar mais objetivamente em composição em tempo real.

Fica também aberto o caminho de pesquisar outros protocolos de articulação e armazenamento de paramêtros em de um gesto sonoro. Ele fala brevemente ali do protocolo “kern” articulado com a coleção de programas para ambiente UNIX “Humdrum“. Um interessante estudo de caso sobre o “processamento simbólico” de padrões que poderia ser mais uma referência na continuidade deste estudo.  ( http://humdrum.org/Humdrum/ )

No próximo post vou focar nos tais “Processos simbólico” que ele trabalha em algoritmos no segundo capitulo do livro.

Além da explicação do algoritmo e sua contextualização ele vai aos poucos introduzindo algumas classes em C++ e patches em max/msp quer seria interessante fazer um paralelo com objetos que ja existem no PureData (só no estudo rápido que fiz já identifico ali nos problemas que ele coloca, alguns objetos prontos como [pitch] , [chord], [ryththm] , [gestalt] , etc. vou tentar explorar estes objetos comparativamente e adentrar tambem na parte de código C deles, pra pensar nos algoritmos.

, ,

1 Comment

Beatslicers no puredata

Nesta seção estou subindo alguns beatslicers de puredata que achei na net- samplers que recortam trechos de loop e reeorganizam sequencialmente.

Me deparei com algumas idéias interessantes: aqui e aqui. Pretendo dar um derivada à partir delas…

De certa maneira isso é o que eu estava buscando com o patch “Navalha” há uns 2 anos atrás, mas exagerei na idéia de “interface final de usuário tudo em 1″, a funcionalidade perdeu-se no mar de possibilidades inacabadas e também uma dificuldade imensa de documentar como o patch foi feito, pra tentar um desenvolvimento opensource colaborativo em cima. Vou tentar reanalisar o cenário e começar um projeto para samples documentado desde o início e mais voltado pra coleção de objetos e prática de uso.

Empacotei alguns simples e funcionais aqui:
estudando_beatslicers.tar.gz
Incluí tambem uma pasta loops, com 2 pequenos samples pra testes.

Baixe e opine sobre o que você gostaria de ver neles e tentarei implementar (e/ou compartilhemos desde já algumas derivações)…

Beatslicer (matrix sequencer) – pasta sample slicer

Este sequencer é bem simples como interface e já da pra pensar em vários usos. Seria muito legal por exemplo poder usá-lo com algum tipo de “Monome” ou de prefêrecia algum derivado artesanal tipo o projeto arduinome.

beatslicer

* com 16 celulas

encontrei também esta versão com 16 células, não muito diferente e facilmente adaptável.

sl16

Sample-slicer (técnica pra recortar trechos de um sampler de maneira assimétrica e determinada)

Este patch é bem interessante justamente por não complicar na parte de salvar os presets, deixando bem fácil pra poder tentar entender outras técnicas usadas. Salvar presets usando somente linguagem puredata é uma tarefa que ainda quebra um pouco a cabeça, mas existem algumas soluções como as libs sssad e memento. Por hora vamos entender a solução deste patch, pois é bem básica mas exige uma parte “na unha”.

O grande diferencial deste patch pro patch mais acima é que ele é focado em selcionar o exato trecho que você quer recortar, diferente do exemplo anterior do sequenciador de matriz, onde ele simplemente gera um recorte de partes simétricas da tabela.

Ele é dividido em dois patches complementares. O primeiro chamado breakpoint-maker.pd serve para você salvar presets da sequencia de recortes pra depois usar em um sequenciador, a partir do patch smp-slice-help.pd . A idéia que pode parecer estranha de início é que ele usa o primeiro pra gerar os presets e daí manualmente copia e cola estes presets no patch smp-slice. Obviamente isto pderia ser automatizado, as interessante porque dessa maneira o processo ficou mais explícito.

Inicie selecionando o trecho.

breakpoint_sel

Em seguida selecione store e depois disso escolha um numeros nos botoes vermelhos e selecione save.

breakpoint_store

Depois de fazer todo o mapa dos breakpoints clique “save-to-message-box”. A mensagem com todo o preset aparecerá dentro do subpatch “pd mesagebox(datasaved)”. copie esta mensagem e para colar no patch smp-slice-help.pd

breakpoint_presets

Aqui você usa o padrão de presete gerado.
smp-slice

Copie e substitua a mensgem original:
smp-slice_msg

Bonkslices (patch que demonstra a possibilidade de detectar os ataques e fazer os cortes automáticamente)

Esta última abordagem é bem interessante, pois ao invés de pedir pra você selecionar os breakpoints, tenta detectá-los automáticamente pelos ataques do loop (usando o objeto bonk~). Este patch não tem interface gráfica, mas interessante porque está bem organizado fácil de ler.

bonklices1

bonkslices2

Existe um arquivo chamado “bonkpointmaker” que tenta misturar estas duas últimas abordagens, mas aqui parece que não funcionou, porém resolvi incluí-lo no pacote pra ser debugado.

, , , , , ,

No Comments

Bangsample e Rbangsample

Estou trabalhando em dois objetos bem simples, pra fazer um tipo de unidade de sample replicável no mesmo patch, pra agilizar o trabalho com sampler no puredata.

Não existe nenhum tipo de envelope nele. Estou tentando simplificar e modularizar o máximo possível porque quero que seja um projeto bem didático e menos inchado que o Navalha. Outros sistemas de sample existem como abstractions na comunidade puredata, mas estou tentando fazer isso de modo que mais gente por aqui possa entender como a coisa funciona from scratch. Se alguem quiser um sampler avançado em  puredata, recomendo o sistema que o pessoal do PDMTL, fez: http://wiki.dataflow.ws/PdMtlAbstractions

Isso também é uma maneira que estou buscando de explicar e aprofundar a parte de wavtables no puredata, podendo criar sistemas de sampler mais complexos com maior domínio da manipulação de arrays e tipos de dados.

Segue aqui anexo os dois objetos. Um deles depende -lib iem_tab . Qualquer dúvida entre em contato pela lista de discussão… Breve atualizo aqui:

arquivo:

bs_v01tar

Rbangsample – grava do microfone e dispara com bang.

rbangsample

Bangsample – carrega samples em wav e dispara com bang
bangsample

, , , , , , , ,

No Comments