design aplicado à instalações multimídia

design aplicado a instalações multimídia com projeção

nos dias 13, 14 e 15 de março, estarei em são paulo, no centro cultural trackers, ministrando uma curta oficina cujo objetivo é proporcionar um espaço intenso e produtivo para o estudo de projetos multimídia que involvem tecnologia de projeção. esta oficina está baseada em outras versões prévias, com foco nos benefícios do design como metodologia de produção e conhecimento acerca de instalações deste porte.

utilizaremos, fundamentalmente, três ferramentas: vpt – uma já razoavelmente conhecida ferramenta aberta de mapeamento de projeção desenvolvida por hc gilje -, lpmt – outra aplicação aberta de mapeamento de projeção, particularmente interessante para usuários linux – e google sketchup, para projetar e estudar possíveis situações instalativas.

o chamado “videomapping”, ou projeção mapeada (termo que prefiro utilizar) corresponde a um agora relativamente conhecido uso criativo da linguagem visual aplicada à contextos inusitados. a tecnologia chama a atenção de uma diversidade de profissionais, entusiastas e pesquisadores, com diferentes bases de conhecimento. neste cenário de interdisciplinaridade, a aplicação de um método de design próprio se justifica, considerando a diversidade de técnicas e equipamentos que tais projetos geralmente implicam. são de extrema utilidade conhecimentos básicos sobre o funcionamento de um projetor e seus componentes, sobre como uma imagem projetada se adequa a um suporte, sobre formatação de vídeo pensando em situações site-specific, sobre a matemática involvida no posicionamento de projetores e cálculo de lentes, e assim por diante.

baseada em tais considerações, a programação da oficina está planejada da seguinte forma:

dia 1 (13/03): introdução à metodologia do design aplicada a tecnologia de projeção

que tipos de conhecimentos estão relacionados com a tecnologia de mapeamento de projeção? o que é um projetor, e como funciona? que tipos de equipamento devem ser considerados em tais projetos? e quanto a formatação de vídeo ou imagem? essas perguntas frequentes serão abordadas  na introdução de uma metodologia de design que compreenda à diversas situações de projeção. faremos um pequeno exercício no qual os participantes serão convidados a criar e planejar uma instalação utilizando o google sketchup.

dia 2 (14/03): vpt e lpmt  - adaptação de imagens à superfícies

este é o dia em que se dará uma introdução as ferramentas de mapeamento de projeção, enquanto se aborda as diferenças e similaridades entre texturização “virtual” e “real”. passaremos por técnicas típicas de mapeamento, como distorção por ajuste de vértices, máscaras e frame blending.como exercício, os participantes serão convidados a adequarem uma imagem ou vídeo de sua preferência ao suporte selecionado para o projeto iniciado no dia anterior.

dia 3 (15/03): finalizando

o último encontro está reservado para a finalização da instalação e para o esclarecimento de dúvidas específicas que não foram abordadas nos dias anteriores.

para inscrições e mais info, clique aqui.

nos vemos lá!

 

..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................

fatto in casa no panoramica 2012

fatto in casa - panoramica 2012

e 2012 começa com uma apresentação de fatto in casa, junto ao amigo e mentor, jorge crowe. a performance participará do festival panoramica no espacio fundación telefonica de buenos aires (arenales 1540), sábado, 10 de março, às 19hs. espere por algumas novidades desta vez: sincronia audiovisual via arduino + pduino, brinquedos que acendem quando sobre a jugetomatica (interface que uso para o remix de imagens em tempo real), e outras cositas más ;)

por favor consulte o site oficial do evento para mais info:

http://panoramica.cc/ed_2012_jam.php

http://www.panoramica.cc/ed_2012.php

até lá!

..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................

brinquedos modificados ocupam bsas

fatto in casa medul.la jorge crowe

se você não está sabendo dos brinquedos modificados que estão realizando uma ocupação em buenos aires (ok, apenas uma piada oportunista), agora é sua chance de encontrá-los. jorge crowe e eu estaremos apresentando a performance audiovisual fatto in casa em algumas oportunidades na capital portenha.

para os que não conhecem a performance, trata-se de uma proposta de reutilização e modificação de brinquedos e objetos velhos em uma plataforma audiovisual. jorge produz paisagens sonoras com um set enorme de pequenos frankensteins, enquanto eu modifico em tempo real imagens provenientes de um vídeo de seu set de brinquedos, usando de um protótipo – bastante improvisado, diga-se de passagem – do conhecido projeto reactableeste ano já performamos duas vezes, e agora convidamos a todos para esta intensa semana de apresentações em vários eventos interessantes.

a primeira performance será dia 10/12, sábado, durante o street a delika, no zafra espacio de formación artística (sarmiento 3096), às 17hs.

street a delika

no dia 11, estaremos no E.A.S.T.encuentro de arte sonoro en transito, na galería patio del liceo (santa fé 2729), das 16hs em diante.

encuentro de arte sonoro en transito

na quinta, 15/12, estaremos no espacio ecléctico, no interessante encontro genealogía del objeto. começamos a fazer barulho às 20hs.

genealogía del objeto

a ocupação dos brinquedos se encerra no dia 17, sábado, na terceira edição do já conhecido encontro dorkbot de buenos aires. o horário da performance neste dia está para ser confirmado, assim que fiquem atentos ao blog ou em meu facebook.

dorkbot 3 buenos aires

para esquentar, abaixo posto umas imagens das duas primeiras apresentações em setembro. o vídeo eu fico devendo por agora, mas devo postá-lo nos próximos dias.

nos vemos!

 

..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................

fatto in casa

fatto in casa

estarei brincando com imagens em tempo real junto a jorge crowe no sábado, 10 de setembro, para a performance/”arteônica” fatto in casa. será uma noite dupla: a primeira apresentação será no centro cultural recoleta, as 8pm, como parte da programação do seminario de narrativas hiper/textuales. logo depois, seguimos para o centro cultural zaguán, onde performamos a 1am na festa sintomatica.

espero vê-los por lá! abaixo segue um vídeo de jorge performando o fatto in casa no encontro panoramica, em março de 2011, no espacio telefonica.

..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................

apresentação do processo de residência demolición/ construcción

presentación del proyecto loci - demolición/construcción

que significa historiar hoje? como os mecanismos de armazenamento e transmissão de informação modificam a maneira como a memória humana opera? essas são algumas das questões que o projeto loci tenta abordar.

o nome vem do substantivo plural do termo latim locus, que encontra significado em um extenso conjunto de conceitos, tais como lugar, situação, estado. o projeto foi apresentado no sábado dia 16 de julho, no espaço de memória la perla, como parte da residência demolición/construcción. ainda em estágio de desenvolvimento, a aplicação web foi apresentada como protótipo, para que fosse sujeita a discussão em conjunto com os demais artistas e estudiosos participantes.

basicamente, meu aporte ao assunto da residência não considera o que vou aqui denominar como ‘aspectos mais icônicos’, ou seja, toda a imagem aparente que se pode associar ao contexto da ditadura militar argentina – que na prática durou pelo menos 20 anos. em troca, adotei uma concepção de giorgio agamben acerca da impossibilidade de conceber o inumano. preferi assim abordar o que considero problemas mais amplos, que residem nas intersecções entre memória, arte e política. esta concepção gradualmente tomou forma durante minhas leituras de o que resta de auschwitz, de agamben, e cultura_RAM, de jose luis brea. baseado na idéia de testimônio como “uma relação entre o dizível e o indizível” e de arquivo como “um sistema de relações entre o dito e o não dito” (AGAMBEN, 199: p. 45), a questão das dimensões de memória na contemporaneidade me pareceu bastante digna para a temática da residência.

propus assim uma meta-mídia que referencia algumas características de modelos computacionais e humanos de arquivamento e resgate de informação. como lembra luis brea, depois dos meios eletrônicos e digitais, a memória humana passa a adaptar-se a uma complexa realidade imposta pela paisagem midiática, em uma corrente transformação de um mecanismo que recuperação para um canal de julgamento de experiências recentes e simultâneas. neste sentido, o aspecto moralizante da memória – a iconização do passado – tem decaído em favor de necessidades mais urgentes, como a preterização do futuro e um entendimento construído em rede de padrões informacionais instantâneos e em constante metamorfose. assim, luis brea relaciona as ‘obsoletas’ formas de história com a memória computacional de tipo ROM (Read Only Memory), e discursa sobre um panorama mais recente que pode ser metaforizado como uma memoria de tipo RAM (Random Access Memory), ao afirmar que a noção de verdade histórica como produto da sua materialidade – é dizer, formas arquiváveis de cultura – ou de sua provabilidade – o testimônio de grupos específicos – está dando lugar a uma rede sistemática de processos inter-projetivos, dos quais emergem perspectivas antes marginalizadas pela história institucionalizada, que interagem entre si e propõem alternativas multi-discursivas do que é status quo. neste sentido, se algo é verdadeiro ou não, pouco importa: desde que este algo tenha poder afetivo e capacidade de transitar por diferentes redes, então é digno, não importando a natureza de seu discurso.

loci

loci sugere uma desterritorialização de formas objetivadas de história: arquivos de diferentes formatos digitalizados de mídia (rádio, televisão, jornais, livros, et cetera) são processados por um software que opera em três níveis. o primeiro é matemático, um contínuo fluxo de texturas de dados que são resultados instantâneos de cálculos algorítmicos, justapondo e sobrepondo diferentes camadas e tipos de mídia; o segundo é linguístico, o qual relaciona os meta-dados associados a toda informação presente no banco (como datas, nomes, palavras relacionadas), reconfigurando a rede semântica no seu nível textual e interferindo diretamente no que é “lembrado”, ou seja, no que emerge como interface; o que caracteriza o terceiro nível de operação, o perceptivo: imagens, textos e sons fragmentados, um contínuo devir de descontinuidades. Uma meta-forma.

o banco de dados para a versão 1.0 de loci contém exemplos de informação que corria pelos meios de massa da argentina dos anos 70 e 80, período profundamente marcado pela repressão sistemática do governo militar na comunicação em geral. grande parte deste material foi obtida durante pesquisa no archivo provincial de la memoria de córdoba, no cispren e no archivo del servicio de radio y televisión de la universidad nacional de córdoba. tive também a ajuda de amigos que colaboraram com referências culturais populares da época. um pouco de youtube também não caiu mal :)

esse banco de dados não é de forma alguma permanente ou único. loci não será caracterizado pela informação que gerencia, mas pela própria in-formação como uma metáfora sistemática de processos de memória contemporâneos. isso significa que, em versões futuras, loci terá a capacidade de carregar diferentes bancos de dados e integra-los a outros disponíveis na rede.

mapa mental loci

em outras palavras, loci é proposto como uma proto-memória, uma máquina de recordar que, em seu curso, gera ficções e contra-fatos (ou hiper-fatos, como gostaria de denominar) ao salvar suas “memórias” distorcidas pelo processo como novos “fatos” no banco. não obstante, loci busca por informações presentes em bancos abertos na web por intermédio de APIs (Application Programming Interfaces) de serviços como flickr ou twitter, estendendo seu espectro histórico e semântico a outros limites, talvez a lugares próximos do que wittgenstein definiu como barreiras de linguagem.

a aplicação estará disponível na web assim que a versão 1.0 esteja pronta, o que deve acontecer nas próximas semanas. seu lançamento será anunciado neste blog. o desenvolvimento está sendo realizado em processing, e o código-fonte da aplicação estará disponível na mesma página.

mais detalhes quanto ao processo de desenvolvimento serão revelados logo. é também de minha intenção publicar aqui um texto que suporta conceitualmente algumas das questões tratadas pelo projeto (conforme anunciei a um par de semanas atrás).

a apresentação do projeto foi muito construtiva precisamente pelo retorno obtido dos outros artistas e pensadores presentes, e gostaria de deixar um grande obrigado a todos por isso. um agradecimento especial vai para lina lopes – quem eu também gostaria de agradecer pela maioria das fotos da apresentação -, gabriela halacgraciela de oliveiraeugenia almeida pelo seu interesse e contribuição aos assuntos do projeto. e obrigado também a ángel poyónfhernando poyónedgar calel pelos excelentes intercâmbios de idéias que tivemos durante nosso tempo de estadia na fundación pluja, a qual gostaria de agradecer pela hospitalidade.

gostaria também de agradecer ao espacio de memoria la perla, ao cispren, ao archivo provincial de la memoria de córdoba e a universidad nacional de córdoba pelo seu apoio à pesquisa.

e claro, um enorme agradecimento a graciela de oliveira e a soledad sanchez pela predisposição em organizar a residência phronesis criolla.

aqui estão imagens e um vídeo do dia da apresentação de loci. fiquem ligados no blog para os próximos passos do projeto.

 

..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................

visualização de câmera e sonar

como último exercício proposto para a oficina datajockey, os códigos para processing e arduino abaixo geram uma representação visual de dois fenômenos diferentes: primeiramente, a imagem de uma câmera conectada ao computador é convertida, via processing, em uma matriz de pixels coloridos. estes pixels tem suas propriedades alteradas em tempo real, conforme a distância detectada de um objeto em relação a um sonar, que por sua vez está ligado a um arduino.

o código para a aplicação no processing é este. para a biblioteca de vídeo, optou-se pela gsvideo, já que é baseada em gstreamer e funciona em linux:

 
//camera-sonar module visualization
//by medul.la
//based on the example 'mirror', of the gsvideo processing library,
//and the code found in this forum post by dvnanness:
//http://forum.processing.org/topic/multiple-sonar-reading-from-arduino-to-processing
 
import processing.serial.*;
import codeanticode.gsvideo.*;
 
// Number of columns and rows in our system
int cols, rows;
// Variable for capture device
GSCapture video;
 
Serial myPort;
int numSensors = 1;
int linefeed = 10;
int sensors[];
float read1;
int cellZFactor;
 
// Size of each cell in the grid
int cellSize = 15;
 
void setup() {
size(640, 480, P3D);
//set up columns and rows
cols = width / cellSize;
rows = height / cellSize;
colorMode(RGB, 255, 255, 255, 100);
rectMode(CENTER);
 
// uses the default video input, see the reference if this causes an error
video = new GSCapture(this, width, height, 30);
 
// list all the available serial ports
println(Serial.list());
 
// change the 0 to the appropriate number of the serial port
// that your microcontroller is attached to.
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil(linefeed);
}
 
void draw() {
if (sensors != null) {
 
// if valid data arrays are not null
// compare each sensor value with the previuos reading
// to establish change
 
read1 = map(sensors[0], 0, 600, 1, 30);
cellZFactor = int(read1);
}
if (video.available()) {
video.read();
video.loadPixels();
 
background(0);
 
// begin loop for columns
for (int i = 0; i < cols;i++) {
// begin loop for rows
for (int j = 0; j < rows;j++) {
 
// where are we, pixel-wise?
int x = i * cellSize;
int y = j * cellSize;
int loc = (video.width - x - 1) + y*video.width; // reversing x to mirror the image
 
// the rects' color and z position depends on the information from the sonar input,
// the brightness and the colors captured by the camera
color c = video.pixels[loc];
float sz = (brightness(c) / 255.0) * cellSize + cellZFactor;
fill(red(c)/cellZFactor,(blue(c)+(cellZFactor)), (green(c)*(cellZFactor)/3));
noStroke();
rect(x + cellSize/2, y + cellSize/2, sz, sz);
}
}
}
}
 
void serialEvent(Serial myPort) {
 
// read the serial buffer:
String myString = myPort.readStringUntil(linefeed);
 
// if you got any bytes other than the linefeed:
if (myString != null) {
 
myString = trim(myString);
 
// split the string at the commas
// and convert the sections into integers:
 
sensors = int(split(myString, '\n'));
 
// print out the values you got:
 
for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
print("Sensor " + sensorNum + ": " + sensors[sensorNum] + "\t");
}
// add a linefeed after all the sensor values are printed:
println();
}
}

E este é o código para realizar a leitura de um sonar, similar ao modelo HC-SR04, por meio de um arduino.

//defining ports
const int pingPin = 7;
const int pingPin8 = 8;
 
void setup() {
Serial.begin(9600);
}
 
void loop(){
long duration, inches, cm;
pinMode(pingPin, OUTPUT);
digitalWrite(pingPin, LOW);
delayMicroseconds(2);
digitalWrite(pingPin, HIGH);
delayMicroseconds(5);
digitalWrite(pingPin, LOW);
 
pinMode(pingPin8, INPUT);
duration = pulseIn(pingPin8, HIGH);
 
inches = microsecondsToInches(duration);
cm = microsecondsToCentimeters(duration);
Serial.println(cm);
 
delay(100);
}
 
long microsecondsToInches(long microseconds){
return microseconds / 74 / 2;
}
 
long microsecondsToCentimeters(long microseconds){
return microseconds / 29 / 2;
}

mais detalhes em como plugar um HC-SR04 em um arduino aqui.

..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................

visualização de dados do twitter

visualização de dados 3D que exibe as últimas mensagens armazenadas no banco de dados do twitter contendo um termo um conjunto de termos. a visualização foi feita em processing, utilizando de uma versão resumida da biblioteca twitter4j e da API do twitter. um dos exercícios propostos para a oficina datajockey, realizada no Museu da Imagem e do Som de São Paulo, de 17 a 31 de maio de 2011.

o sketch realiza uma busca por um termo nos últimos tweets armazenados no banco de dados do twitter, e exibe os resultados em um espaço 3D. a posição e a cor são dados de acordo com o horário em que cada tweet foi postado. se dois ou mais tweets foram postados com um horário próximo, uma linha os conecta no espaço 3D de visualização, gerando estruturas. o tamanho dos cubos é dado pelo valor respectivo aos minutos do horário em que o tweet foi postado.

uma pena que não consigo postar a própria aplicação aqui, devido a limitações do processing.js. mas o código-fonte encontra-se abaixo. antes de testá-lo no processing, é preciso fazer o download da biblioteca do twitter4j e inserir o arquivo dentro de uma pasta chamada “code”, que por sua vez deve estar dentro da pasta do seu sketch de processing. é necessário também conseguir algumas chaves de acesso ao banco de dados do twitter, registrando uma aplicação nova na página de API do twitter. depois basta inserir as respectivas chaves nas variáveis indicadas no código.

//twitter 3D data visualization
//by medul.la
//http://medul.la
//based on the sketch '3D Processing World', by Josue Page
//http://www.openprocessing.org/visuals/?visualID=19216
//the twitter connection is made by using the twitter4j java library:
//http://twitter4j.org
 
// Before you use this sketch, register your Twitter application at dev.twitter.com
// Once registered, you will have the info for the OAuth tokens
 
//setting twitter API info:
static String OAuthConsumerKey = "PUT YOUR CONSUMER KEY HERE";
static String OAuthConsumerSecret = "PUT YOUR CONSUMER SECRET KEY HERE";
static String AccessToken = "PUT YOUR ACCESS TOKEN HERE";
static String AccessTokenSecret = "PUT YOUR ACCESS TOKEN SECRET HERE";
 
//define parameters
//a word to search for in the tweets database:
String searchTerm = "PUT YOUR SEARCH TERM HERE";
//a number of tweets to work with (you can choose any number up to 100) :
int numOfTweets = 50;
 
java.util.List statuses = null;
Twitter twitter = new TwitterFactory().getInstance();
RequestToken requestToken;
String[] theSearchTweets = new String[numOfTweets];
Date[] tweetTimeData = new Date[numOfTweets];
String[] tweetTimeStrings = new String[0];
int[] tweetTimeInts = new int[0];
color[] colors = new color[0];
int[] coords = new int[0];
int objects = numOfTweets, zoom = -300, xCube, yCube, zCube;
Pts[] cubes = new Pts[objects];
color bgColor = 0, lineColor = 255;
float R, G, B;
PFont theFont;
 
void setup() {
  size(1024, 750, P3D);
  connectTwitter();
  getSearchTweets(searchTerm);
  convertDateToString();
  convertStringToInts();
  convertIntsToColor();
  convertIntsToPosition();
  checkColors();
  checkCoords();
  background(255);
  translate(width, 0, 0);
  theFont = createFont("Arial",1000);
  for (int i = 0; i < numOfTweets ; i++) {
    String t = theSearchTweets[i];
    //println(t);
    cubes[i] = new Pts(coords[i], coords[i+1], coords[i+2], colors[i], 1, t);
  }
}
 
void draw() {
  translate(width/2, height/2, width/2+zoom);
  rotateX(map(mouseY, 0, height, -2*PI, 2*PI));
  rotateY(map(mouseX, 0, width, -2*PI, 2*PI));
  background(bgColor, 50);
  for (int u = 0; u < objects ; u++) {
    cubes[u].drawCubes();
    for (int v=0;v<objects;v++) {
      if (abs(cubes[u].z-cubes[v].z)<200) {
        if (abs(cubes[u].x-cubes[v].x)<200) {
          if (abs(cubes[u].y-cubes[v].y)<200) {
            stroke(lineColor, 50);
            beginShape(LINES);
            vertex(cubes[u].x, cubes[u].y, cubes[u].z);
            vertex(cubes[v].x, cubes[v].y, cubes[v].z);
            endShape();
          }
        }
      }
    }
    cubes[u].change();
  }
 
  if (mousePressed) {
    bgColor = 255;
    lineColor = color(255, 0, 0);
  }
  else {
    bgColor = 0;
    lineColor = 255;
  }
}
 
class Pts {
  int x, y, z;
  float tem;
  color cubeColorC;
  String theText;
 
  Pts(int a, int b, int c, color d, float e, String t) {
  x = a;
  y = b;
  z = c;
  cubeColorC = d;
  tem = b/20;
  theText = t;
 
  }
 
  void drawCubes() {
    if (mousePressed) {
      fill(0, 50);
    }
    else {
      fill(lineColor, 50);
    }
    noStroke();
    fill(cubeColorC);
    text(theText, x+30, y, 100, 1000, z);
    pushMatrix();
    translate(x, y, z); 
    fill(cubeColorC);
    box(tem);
    popMatrix();
  }
 
  void change() {
    if (x <- width) {
      x =- width + 10;
    }
    else {
      if (x > height) {
        x = height - 10;
      }
      else {
        x = x + int(random(-3, 3));
      }
    }
    if (y <- height) {
      y =- height+10;
    }
    else {
      if (y > width) {
        y = width - 10;
      }
      else {
        y = y + int(random(-5, 5));
      }
      if (z > width) {
        z = width - 10;
      }
      else {
        z = z + int(random(-5, 5));
      }
      if ( z<- width) {
        z =- width + 10;
      }
    }
  }
}
 
void keyPressed() {
  if (keyCode == 40) {
    zoom -= 300;
  }
  if (keyCode == 38) {
    zoom += 300;
  }
}
 
//twitter API functions
 
// Initial connection
void connectTwitter() {
  twitter.setOAuthConsumer(OAuthConsumerKey, OAuthConsumerSecret);
  AccessToken accessToken = loadAccessToken();
  twitter.setOAuthAccessToken(accessToken);
}
 
// Loading up the access token
private static AccessToken loadAccessToken() {
  return new AccessToken(AccessToken, AccessTokenSecret);
}
 
// Search for tweets
void getSearchTweets(String searchTerm) {
 
  String queryStr = searchTerm;
 
  try {
    Query query = new Query(queryStr);    
    query.setRpp(numOfTweets); // Get 10 of the 100 search results  
    QueryResult result = twitter.search(query);    
    ArrayList tweets = (ArrayList) result.getTweets();    
 
    for (int i=0; i<tweets.size(); i++) {	
      Tweet t = (Tweet)tweets.get(i);	
      String user = t.getFromUser();
      String msg = t.getText();
      Date d = t.getCreatedAt();	
      theSearchTweets[i] = msg;
      tweetTimeData[i] = d;
      println(theSearchTweets[i]);
      println("----------------");
      println("Tweet by " + user + " at " + d);
      println("----------------");
      println(tweetTimeData[i]);
      println("----------------");
    }
 
  } catch (TwitterException e) {    
    println("Search tweets: " + e);  
  }
 
}
 
void convertDateToString(){
   for (int i = 0; i < tweetTimeData.length; i++){
    SimpleDateFormat df = new SimpleDateFormat("dd/MM/yyyy/HH/mm/ss");
    String s = df.format(tweetTimeData[i]);
    String sArray[] = new String [0];
    sArray = splitTokens(s, "/");
    for (int j = 0; j < sArray.length; j++){
      tweetTimeStrings = append(tweetTimeStrings, sArray[j]);
      println(tweetTimeStrings[j]);
    } 
   }
}
 
void convertStringToInts(){
   for (int i = 0; i < tweetTimeStrings.length; i++){
    int num = int(tweetTimeStrings[i]);
    tweetTimeInts = append(tweetTimeInts, num);
    println("tweetTimeInts at the index of " + i + " is: " + num);
   }
}
 
void convertIntsToColor(){
   for (int i = 3; i < tweetTimeInts.length; i = i+6){
      R = map (tweetTimeInts[i], 0, 24, 0, 255);
      G = map (tweetTimeInts[(i+1)], 0, 60, 0, 255);
      B = map (tweetTimeInts[(i+2)], 0, 60, 0, 255);
      color clr = color (R, G, B); 
      colors = append (colors, clr);
      //println("color stored is = R " + red(clr) + ", G " + green(clr) + ", B " + blue(clr));   
   }
}
 
void convertIntsToPosition(){
   for (int i = 3; i < tweetTimeInts.length; i = i+6){
      xCube = int(map (tweetTimeInts[i], 0, 24, -width, width));
      yCube = int(map (tweetTimeInts[(i+1)], 0, 60, -height, height));
      zCube = int(map (tweetTimeInts[(i+2)], 0, 60, -width, width));
      coords = append (coords, xCube);
      coords = append (coords, yCube);
      coords = append (coords, zCube);
      //println("position stored is = xCube " + xCube + ", yCube " + yCube + ", zCube " + zCube);   
   }
}
 
void checkColors(){
   for (int i = 0; i < objects; i++){
      println("color stored is = R " + red(colors[i]) + ", G " + green(colors[i]) + ", B " + blue(colors[i]));
   }
}
 
void checkCoords(){
   for (int i = 0; i < coords.length; i=i+3){
      println("position stored is = xCube " + coords[i] + ", yCube " + coords[i+1] + ", zCube " + coords[i+2]);
   }
}

..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................

visualização de dados textuais

visualizing text data

fiz o upload de um sketch de  processing na plataforma openprocessing, que propus como exercício para a oficina datajockey. o sketch pode ser utilizado como forma de representar dados textuais em diferentes tipos de representação geométrica.

pressione “C” para círculos, “S” para quadrados e retângulos, “A” para arcos e “L” para linhas.

o exemplo acima é uma representação de alguns parágrafos presentes na ficção de machado de assis, dom casmurro.

o código fonte e o próprio sketch podem ser encontrados aqui.

..........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................