azevedolab.net 2015 Dr. Walter F. de Azevedo Jr. Aula 09 Strings, Leitura e Escrita de Arquivos (continuação)

(1)

Aula 09 – Strings, Leitura e Escrita de Arquivos (continuação)

2015 Dr. Walter F. de Azevedo Jr.

1

(2)

2

Exercício de programação: Elabore um programa que leia um arquivo FASTA e gere um gráfico de barras, onde a altura da barra é proporcional ao número de aminoácidos.

(3)

3

A seguir temos o código read_fasta_01.pde. Como o código é longo dividiremos em partes, explicando o funcionamento de cada trecho do código.

Esta parte inicial traz a definição de variáveis globais, temos um total de três arrays. O array data_count_aa será usado para armazenar a quantidade de cada aminoácido, por isso foi definido como um array do tipo inteiro de 20 elementos. O array do tipo string sequence armazenará a sequência de amino ácidos lida do arquivo FASTA. O terceiro array, é atribuído à variável my_all_aa, é do tipo string e traz o código de uma letra para cada um dos 20 aminoácidos naturais.

int[] data_count_aa = new int [20];

String[] sequence;

String[] my_all_aa = {

"A", "R", "N", "D", "C", "E", "Q", "G", "H", "I",

"L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"

}; // Amino acid array

(4)

4

Abaixo temos a definição da função setup(), no caso é bem simples, definimos o tamanho da tela com a função size(400,100) e carregamos o conteúdo do arquivo no formato FASTA com a função loadStrings(“2a4l.fasta”). Neste caso o arquivo a ser lido chama-se 2a4l.fasta e tem que necessariamente estar no diretório onde estamos rodando o código. Como sabemos, a função setup() é executada somente uma vez.

void setup() { size(400, 100);

// Load FASTA file as an array of Strings sequence = loadStrings( "2a4l.fasta");

}

(5)

5

Agora temos a função draw(). Nela definimos a cor de fundo, com a função background(). Definimos a cor da linha, com a função stroke() e a cor de preenchimento do retângulo, com a função fill(). Em seguida chamamos a função count_amino_acids(), uma função que definimos para leitura do número de amino ácidos. Esta função será detalhada nos próximos slides. Em seguida temos um loop for, que desenha um retângulo para cada amino ácido, onde a altura do retângulo é definida pelo número de aminoácidos. Veja na definição do retângulo, que a altura é definida por –data_aa[i], que traz o número de aminoácidos, o sinal - é para invertermos o retângulo, de baixo para cima. O noLoop() encerra a função draw().

void draw() {

background(255);

stroke(0);

fill(255);

count_amino_acids();

//Looping through data_count_aa

for (int i = 0; i < data_count_aa.length; i ++ ) { rect(i*20, 100, 20, - data_count_aa[i]);

}

noLoop();

}

(6)

6 void count_amino_acids() {

int count_aa = 0; // Count for each amin oacid String sequence_string = ""; // String for sequence

String my_count_out = ""; // String for number of amino acids // Looping through to get all aa in one string after header

for (int i = 1; i < sequence.length; i++) { // Get lines after header

sequence_string += sequence[i];

}

// Looping through all 20 amino acids (elements of an array) for ( int j = 0; j < my_all_aa.length; j++) {

// Looping through sequence_string

for (int k = 0; k < sequence_string.length (); k++) { String my_aa = str(sequence_string.charAt(k));

// Test if amino acid is in the sequence if (my_aa.equals(my_all_aa[j]) ) {

count_aa += 1;

} }

// Builds a string with the numbers of each aa if (j == 0) {

my_count_out += str(count_aa);

} else {

my_count_out +=","+str(count_aa);

}

count_aa = 0;

}

data_count_aa = int(split(my_count_out, ','));

Ao lado temos o código da função count_amino_acids().

Inicialmente definimos variáveis locais. Um contador de aminoácido, é atribuído à variável do tipo inteiro count_aa. Temos duas variáveis do tipo string,

sequence_string e

my_count_out. À variável sequence_string, é atribuída a sequência após o cabeçalho do arquivo FASTA.

À variável my_count_out, é atribuída uma string com os valores dos contadores de cada aminoácido, separados por vírgulas.

(7)

7

O primeiro loop for varre a string lida do arquivo FASTA, atribuída à variável sequence. No loop é omitida a primeira linha, para evitar o cabeçalho do arquivo FASTA.

Veja que o primeiro valor atribuído à variável i é 1, assim, a primeira linha, que está na posição zero, não é adicionada à string sequence_string.

void count_amino_acids() {

}

count_aa += 1;

} }

} else {

}

count_aa = 0;

}

(8)

8

Agora temos dois loops for, um para varrer o array do tipo string com o código de

uma letra de cada

aminoácido, variável my_all_aa. O outro loop for varre todos elementos atribuídos ao array sequence_string. Cada caractere da string sequence_string é um aminoácido, que é convertido para string, para ser comparado no if com o aminoácido contido no array my_all_aa. Toda vez que a condição for verdadeira, é somado um ao contador de aminoácidos, atribuído à variável count_aa.

}

count_aa += 1;

} }

} else {

}

count_aa = 0;

}

(9)

9

Em seguida montamos a string my_count_out.

Usamos o método split() para dividirmos os valores dos contadores de cada resíduo de aminoácido e atribuir como elemento do array data_count_aa.

}

count_aa += 1;

} }

} else {

}

count_aa = 0;

}

(10)

10

À direita temos o gráfico de barra gerado. À esquerda temos o arquivo FASTA 2a4l.fasta usado para gerar o gráfico.

>2A4L:A|PDBID|CHAIN|SEQUENCE

MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVF EFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYT HEVVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSF PKWARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHLRL

(11)

11

Exercício de programação: Elabore um programa que leia um arquivo FASTA e gere um gráfico de barras, onde a altura da barra é proporcional ao número de aminoácidos de cada tipo, considerando a classificação mostrada no diagrama de Venn abaixo.

Diagrama de Venn para os 20 aminoácidos mais comuns.

(12)

12

Iremos mostrar um programa que lê um arquivo FASTA e gera um gráfico de barras. O nome do arquivo FASTA é digitado pelo usuário e o gráfico traz a identificação de cada aminoácido e a quantidade do aminoácido, como mostrado no gráfico abaixo

(13)

13

As novidades já começam na primeira linha, como iremos escrever na tela, e não com println(), temos que chamar a classe fonte, com Pfont f.

Este linha define que f é um objeto que pertence à classe fonte, que é capaz de gerar caracteres na tela.

Depois temos o array com a quantidade de cada aminoácido, atribuído à variável data_count_aa. À variável norm_data_count_aa é atribuído um float que é proporcional ao número de aminoácidos, dado pela equação

norm_data_count_aa[l] = (1/1.2)*(y_length/my_max)*d ata_count_aa[l];

PFont f;

int[] data_count_aa = new int [20]; // Array with 20 elements float[] norm_data_count_aa = new float [20]; // Array with 20 ele.

"A", "R", "N", "D", "C", "E", "Q", "G", "H", "I",

"L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"

}; // Amino acid array int screen_length = 800;

int screen_height = 600;

float x_length = 0.8*screen_length;

float y_length = 0.8*screen_height;

int bar_length = 30;

int delta_xy = 80;

int offset = 15;

// Variable to store text currently being typed String typing = "" ;

// Variable to store saved text when return is hit String saved = " " ;

String my_fasta;

(14)

14

As strings atribuídas às variáveis sequence e

my_all_aa já foram

detalhadas no código read_fasta_01.pde. Às variáveis screen_length e screen_height serão atribuídos os valores da largura e altura da tela, respectivamente. Às variáveis do tipo float x_length e y_length são atribuídos os comprimentos

dos eixos x e y,

respectivamente.

Escolhemos usar 80 % do tamanho da tela para os tamanhos dos eixos.

PFont f;

"A", "R", "N", "D", "C", "E", "Q", "G", "H", "I",

"L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"

int offset = 15;

String my_fasta;

(15)

15

Às variáveis bar_length, delta_xy e offset são atribuídos os valores do comprimento do retângulo, os deslocamentos do posicionamento x e y, e um ajuste para posicionamento do retângulo e texto na tela.

São escolhas do

programador, para gerar um gráfico simétrico.

À variável typing é atribuído o caractere que está sendo digitado, um por vez.

À variável saved é atribuída a string digitada, que traz o nome do arquivo FASTA.

À variável my_fasta é atribuído o nome do arquivo FASTA.

PFont f;

"A", "R", "N", "D", "C", "E", "Q", "G", "H", "I",

"L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"

int offset = 15;

String my_fasta;

(16)

16

A função setup() define o tamanho da tela, chamando a função size(). Além disso, chama a função createFont(), que no caso define a fonte como sendo arial 16.

A função draw() define a cor de fundo, com a função background(), e redefine o tamanho da fonte, com a

chamada da função

createFont(). A função fill() define a cor como preta. A função textFont(f) define que o texto seguirá a fonte definida anteriormente.

void setup() {

size(screen_length, screen_height);

f = createFont( "Arial", 16, true);

}

void draw() { background(255);

fill(0);

textFont(f);

textAlign(CENTER);

text( " Type in FASTA file? ", width/2, 30);

}

(17)

17

A função textAlign() indica

como o texto será

posicionado. A função text() define o texto a ser escrito na tela, como caso a string "

Type in FASTA file? “.

Os outros dois argumentos são as coordenadas x e y em pixels, onde será posicionado o texto, no código ao lado temos, width/2 e 30.

void setup() {

size(screen_length, screen_height);

}

void draw() { background(255);

fill(0);

textFont(f);

text( " Type in FASTA file? ", width/2, 30);

}

(18)

18

Ao lado temos a função gen_bar_plot(), que basicamente gera o gráfico de barras, usando a informação atribuída à variável

norm_data_count_aa[i].

Também definimos o texto com os nomes dos eixos e o texto com o título do gráfico.

As linhas que envolvem o gráfico, são definidas pela função drawLine().

void gen_bar_plot() { //Looping through data

for (int i = 0; i < data_count_aa.length; i ++ ) { stroke(0);

fill(0, 0, 255);

strokeWeight(1);

rect(i*bar_length+delta_xy+offset, screen_height - delta_xy, bar_length-5, - norm_data_count_aa[i]);

line( (i+1)*bar_length+delta_xy-3, screen_height - delta_xy - 6, (i+1)*bar_length+delta_xy-3, screen_height - delta_xy); // tick marks

drawLine(delta_xy, screen_height - delta_xy, x_length, 0);

drawLine(delta_xy, screen_height - delta_xy - y_length, x_length, 0);

drawLine(delta_xy, screen_height - delta_xy, y_length, 270);

drawLine(delta_xy + x_length, screen_height - delta_xy, y_length, 270);

fill(0);

textFont(f);

text(data_count_aa[i], i*bar_length+delta_xy+15+offset, 1.05*(screen_height - delta_xy)- norm_data_count_aa[i]-30);

text(my_all_aa[i], i*bar_length+delta_xy+15+offset, 1.05*(screen_height - delta_xy) );

}

fill(255);

noStroke();

rect(width/2-200, 8, 400, 30);

fill(0);

textFont(f);

text( " Amino Acid Distribution for "+my_fasta, width/2, 30);

textFont(f);

text( " Amino acid", width/2, height-30);

textFont(f);

rotate(-1.57);

text( "Number of Amino Acids", -height/2, width/2-340);

(19)

19

A função

count_amino_acids() é praticamente idêntica à descrita no código read_fasta_01.pde. Uma das diferenças é a variável total_aa, ao qual é atribuído

o número total de

aminoácidos lidos. Outra variável nova é a my_max, à qual é atribuída a maior quantidade de aminoácidos.

Este valor máximo é usado para normalizar a altura dos retângulos, para que não tenhamos retângulos maiores que o eixo y (variável y_length).

int count_aa = 0; // Count for each amino acid String sequence_string = ""; // String for sequence

String my_count_out = ""; // String for number of amino acids // Looping through sequence to get all sequence in one string for (int i = 1; i < sequence.length; i++) {

}

// Get total number of amino acids

int total_aa = int(sequence_string.length() );

// Looping sequence_string

for (int k = 0; k<sequence_string.length (); k++) { String my_aa = str(sequence_string.charAt(k));

count_aa += 1;

} }

if (total_aa > 0) {

data_count_aa[j] = count_aa;

count_aa = 0;

} }

int my_max = max(data_count_aa);

// Looping through all 20 amino acids (elements of an array) for ( int l = 0; l < my_all_aa.length; l++) {

norm_data_count_aa[l] =

(1/1.2)*(y_length/my_max)*data_count_aa[l];

} }

(20)

20

A função drawLine() é usada para desenhar uma linha, a partir dos argumentos para as coordenadas do início da linha cx e cy, e duas variáveis adicionais, para o tamanho, len, e o ângulo de rotação em radianos da linha, variável angle.

void drawLine(float cx, float cy, float len, float angle) { strokeWeight(2);

stroke(0);

pushMatrix();

translate(cx, cy);

rotate(radians(angle));

line(0, 0, len, 0);

popMatrix();

}

(21)

21

A função keyPressed() foi vista na aula anterior, ela basicamente registra o que foi digitado, para termos os nome do arquivo FASTA, a ser atribuído à variável my_fasta.

void keyPressed() {

// If the return key is pressed, save the String and clear it if (key == '\n') {

saved = typing;

my_fasta = saved;

sequence = loadStrings(my_fasta);

count_amino_acids(); // Call count_amino_acids() gen_bar_plot(); // Call gen_bar_plot() typing = " " ;

noLoop();

// Otherwise, concatenate the String } else {

typing = typing + key;

} }

(22)

22

Exercício de programação: Modifique o código read_fasta_03.pde, de forma que seja mostrado sobre as barras do gráfico a porcentagem do aminoácido, ao invés da quantidade de aminoácidos.

(23)

23

Usamos a função loadStrings() para carregamos a informação armazenada num arquivo que está no nosso computador. Mas a abrangência desta função vai além do nosso computador. Podemos usá-la para fazer donwload de um arquivo disponível na web. Por exemplo, arquivos no formato FASTA são armazenados no site do Protein Data Bank (PDB) (http://www.rcsb.org/pdb/home/home.do), assim, podemos usar a função loadStrings() para fazer download de arquivos, diretamente do PDB.

O programa donwload_fasta_01.pde faz download do arquivo FASTA 2A4L. Veja a simplicidade do código.

String my_url = "http://www.rcsb.org/pdb/files/fasta.txt?structureIdList=2a4l" ; String[] lines = loadStrings(my_url);

String my_fasta = join(lines, " " );

println(my_fasta);

(24)

24

A primeira linha do código define o endereço do site, que é atribuído à variável my_url.

A segunda linha usa a função loadStrings(), que baixa a string contida no site indicado.

O método join() junta as linhas, usando como delimitador um espaço. Por último mostramos a informação lida.

Assim podemos baixar qualquer arquivo FASTA disponível no PDB, basta usarmos

como string atribuída à variável my_url

http://www.rcsb.org/pdb/files/fasta.txt?structureIdList=xxxx, onde xxxx é o código acesso PDB da sequência FASTA.

String my_url = "http://www.rcsb.org/pdb/files/fasta.txt?structureIdList=2a4l" ; String[] lines = loadStrings(my_url);

String my_fasta = join(lines, " " );

println(my_fasta);

(25)

25

Exercício de programação: Modifique o código download_fasta_01.pde, de forma que o código de acesso PDB da sequência FASTA seja digitado pelo usuário. Além disso, o programa mostra a sequência numa tela, sem gráficos.

(26)

26

Exercício de programação: Modifique o código read_fasta_03.pde, de forma seja digitado o código de acesso PDB da sequência a ser baixada pelo usuário. O programa faz o gráfico de barras da sequência baixada.

(27)

-MODEL, Mitchell L.Bioinformatics Programming Using Python. Sebastopol:O’Reilly Media, Inc., 2011. 1584 p.

-REAS, Casey & FRY, Bem. Geeting Started with Processing. Sebastopol: O’Reilly Media, Inc., 2010. 194 p.

-SHIFFMAN, Daniel. Learning Processing. A Beginner’s Guide to Programming Images, Animation, and Interaction.

Burlington: Morgan Kaufmann, 2008. 453 p.

-SHIFFMAN, Daniel. The Nature of Code: Simulating Natural Systems with Processing. Mountain View: The Nature of Code, 2012. 498 p.

Última atualização: 16 de novembro de 2015.

27