bioinformática. uma introdução com a linguagem...

Aula 09 – Strings, Leitura e Escrita de

Arquivos (continuação)

©2

01

5 D

r. W

alte

r F.

de

Aze

ve

do

Jr.

1

azevedolab.net

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.

Programa read_fasta_01.pdewww.processing.org

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

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

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


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


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.









}








count_aa += 1;

}

}


if (j == 0) {


} else {


}

count_aa = 0;

}


}

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;

}

}


if (j == 0) {


} else {


}

count_aa = 0;

}


}

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;

}

}


if (j == 0) {


} else {


}

count_aa = 0;

}


}

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

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

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


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.

String[] sequence;


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

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


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


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;



String[] sequence;


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

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







int delta_xy = 80;

int offset = 15;





String my_fasta;

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;



String[] sequence;


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

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







int delta_xy = 80;

int offset = 15;





String my_fasta;

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


A função textAlign() indica

como o texto será

posicionado. A função text()

define o texto a ser escrito natela, 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);

textAlign(CENTER);

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

}

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ávelnorm_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);

textAlign(CENTER);

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);

textAlign(CENTER);

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


textFont(f);

textAlign(CENTER);

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

textFont(f);

rotate(-1.57);

textAlign(CENTER);

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

}

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



// Looping through sequence to get all sequence in one string



}

// 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++) {




count_aa += 1;

}

}

if (total_aa > 0) {

data_count_aa[j] = count_aa;

count_aa = 0;

}

}

int my_max = max(data_count_aa);


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


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


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

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

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.

Função loadStrings()www.processing.org

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

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_urlhttp://www.rcsb.org/pdb/files/fasta.txt?structureIdList=xxxx,

onde xxxx é o código acesso PDB da sequência FASTA.

Função loadStrings()www.processing.org

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);

http://www.rcsb.org/pdb/files/fasta.txt?structureIdList=xxxx

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.

Programa download_fasta_02.pdewww.processing.org

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.


-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

Referênciaswww.processing.org

bioinformática. uma introdução com a linguagem...

Documents