PostScript

Ilustrando e aprendendo matemtica

verso 1.1

Frederico Jos Andries Lopes

Sumrio
Introduo ............................................................................................................... 4 Captulo 1................................................................................................................. 6 Os fundamentos da linguagem...........................................................................6 1.1 O sistema de coordenadas ..........................................................................6 1.2 A unidade de medida ....................................................................................7 1.3 Notao ps-fixa e operaes aritmticas....................................................8 1.4 A pilha ........................................................................................................... 9 1.5 Exerccios.................................................................................................... 11 Captulo 2 .............................................................................................................. 13 Linhas retas (I).................................................................................................. 13 2.1 Segmentos de reta .....................................................................................13 2.2 Pontos......................................................................................................... 18 2.3 Nomeando trechos de cdigo: o comando def............................................19 2.4 Exerccios.................................................................................................... 20 Captulo 3 .............................................................................................................. 22 Linhas retas (II)................................................................................................. 22 3.1 Estilos de linhas ......................................................................................... 22 3.1.1 setgray ............................................................................................... 22 3.1.2 setlinewidth ........................................................................................ 24 3.1.3 setdash ............................................................................................... 26 3.2 Os comandos gsave e grestore ..................................................................27 3.3 Exerccios.................................................................................................... 29 Captulo 4............................................................................................................... 31 Circunferncias, arcos de circunferncia, elipses e curvas de Bzier...............31 4.1 Circunferncias e arcos de circunferncias.................................................31 4.1.1 arc....................................................................................................... 31 4.1.2 arcn..................................................................................................... 34 1

4.2 Elipses......................................................................................................... 35 4.3 Efeitos de sombra.......................................................................................36 4.4 Curvas de Bzier......................................................................................... 37 4.5 Exerccios.................................................................................................... 39 Captulo 5............................................................................................................... 40 Transformaes ............................................................................................... 40 5.1 O ponto corrente ........................................................................................ 40 5.2 Translao .................................................................................................. 41 5.3 Rotao ...................................................................................................... 42 5.4 Ampliao e reduo...................................................................................46 5.5 Reflexo...................................................................................................... 47 5.6 Exerccios.................................................................................................... 48 Captulo 6............................................................................................................... 49 Elementos de programao..............................................................................49 6.1 O comando de repetio repeat .................................................................49 6.2 Procedimentos............................................................................................ 53 6.3 Arrays (vetores)........................................................................................... 54 6.4 Exerccios.................................................................................................... 57 Captulo 7............................................................................................................... 58 Fontes............................................................................................................... 58 7.1 Fontes PostScript........................................................................................ 58 7.2 Principais comandos...................................................................................58 7.3 Outros comandos........................................................................................ 61 7.4 Exerccios.................................................................................................... 62 Captulo 8............................................................................................................... 63 Acabamentos, cores e clipping.........................................................................63 8.1 Acabamentos............................................................................................... 63 8.2 Cores........................................................................................................... 65 8.3 Clipping....................................................................................................... 66 8.4 Exerccios.................................................................................................... 68

Bibliografia ............................................................................................................. 69 Apndices .............................................................................................................. 71 A - Preparando o ambiente ..............................................................................71 B - Trabalhando com PostScript .......................................................................73 Trabalhando interativamente .......................................................................73 C Fontes PostScript.......................................................................................74 D - Criando um arquivo EPS.............................................................................76

Introduo
Para explicar contedos de matemtica, professores frequentemente fazem uso de ilustraes. Seja desenhada no quadro negro ou na forma de slides, uma boa figura permite a representao e a interpretao dos elementos de uma ideia que se apresenta compreenso do aluno. Como elementos essenciais na geometria ou como metforas em outras reas, ilustraes de conceitos matemticos so vistas, desde a antiguidade, como um dos melhores auxlios que uma pessoa pode ter durante seu esforo de aprendizado. Desde o nascimento da era do computador pessoal, no idos dos anos de 1970, matemticos e cientistas da computao tm se dedicado criao de meios computacionais que facilitem a criao de figuras. E cada vez mais, computadores tm-nos permitido produzir material ilustrativo de excelente qualidade para uma gama crescente de assuntos e pblicos, ampliando e fortalecendo o campo da educao em praticamente todas as reas. Destacando-se no campo da informao visual e no desenvolvimento de tecnologias voltadas a esse fim, a empresa americana Adobe Systems Incorporated criou, na dcada de 1980, a linguagem de programao PostScript, especificamente voltada para a visualizao de informaes. Desde ento, a Adobe Systems a mesma empresa que posteriormente criou o formato PDF vem desenvolvendo a linguagem, que se encontra atualmente em sua terceira verso, e fornecendo ao pblico gratuitamente excelentes manuais para seu aprendizado (Adobe Systems, 1985, 1988, 1999). A linguagem PostScript fornece uma gama de comandos especficos para o desenho de letras e figuras, incluindo comandos de traado e formas de representao de imagens. uma linguagem de programao completa, interpretada, simples e fcil de aprender. Alguns poderiam dizer, como de fato dizem (Adobe Systems, 1985), que a PostScript pode ser abordada inicialmente como uma variao da linguagem LOGO, qual foram acrescentados novos e avanados recursos. Um programa de edio de texto simples e um interpretador gratuito so mais do que suficientes para operarmos com a linguagem em sua plenitude. Foi com as obras de Bill Casselman (Casselman, 2000 e 2005) que a PostScript foi redescoberta como a linguagem fundamental da ilustrao matemtica, a despeito das alternativas usuais advindas da comunidade de usurios do sistema de tipografia LaTeX, como os pacotes de macros PStricks e PGF/TikZ, ou as linguagens MetaFont e MetaPost. Ainda que programas comerciais geradores

de grficos matemticos, como o Maple, o Mathematica e o MatLab sejam capazes de produzir belssimas ilustraes, apenas a PostScript permite o controle fino do processo de desenho, produzindo resultados impossveis de serem atingidos satisfatoriamente por qualquer outro programa. O que nos interessa aqui, neste livro, mostrar uma resposta satisfatria pergunta: por que usar PostScript no ensino de matemtica? Como nos informa Casselman no prefcio de seu livro Mathematical Illustrations: A Manual of Geometry and PostScript (2005), uma boa ilustrao matemtica sempre requer matemtica no processo de desenho. Esse aspecto da criao e da programao de ilustraes captou nossa ateno desde nossos primeiros contatos com a linguagem. A necessidade de usar matemtica para ilustrar matemtica faz da PostScript uma excelente ferramenta para no s explicar, mas tambm descobrir matemtica. Aprender PostScript uma atividade estimulante, facilmente integrada com diversas outras metodologias de ensino de matemtica. Por exemplo, a habilidade de desenhar algoritmicamente nos permite criar figuras que esclarecem os argumentos de textos matemticos. Tentar criar ilustraes para obras centrais da matemtica clssica, como os Elementos, de Euclides, ou os Principia, de Newton, obriga o estudante a compreender a argumentao do autor, criando um envolvimento ativo e criativo no processo de aprendizagem. O campo de uso da PostScript bastante amplo. Pelo menos quatro classes de profissionais podem ser beneficiadas pelo aprendizado da linguagem: cientistas de vrias reas que precisam criar uma grande quantidade de ilustraes, e que gostaria de ter uma outra alternativa computacional alm dos programas convencionais; professores em qualquer nvel de aprendizado que desejam tornar a matemtica mais compreensvel e interessante a seus alunos; estudantes que desejam ver como a matemtica, mesmo elementar, pode ser aplicada a problemas reais interessantes, e artistas e designers grficos interessados em arte algortmica ou mesmo carentes de novos instrumentos para suas produes grficas.

Em vista do que foi dito, este livro pretende promover o estudo das geometrias atravs da criao de ilustraes. E no s as geometrias euclidiana e analtica planas podem sair beneficiadas, mas tambm as geometrias projetiva e a hiperblica, uma vez que a linguagem PostScript flexvel o bastante para incorporar mdulos, desenvolvidos por terceiros, que permitem a manipulao de imagens mais avanadas.

Captulo 1
Os fundamentos da linguagem
Antes de iniciarmos a criao de grficos, vamos primeiro explorar alguns conceitos fundamentais da linguagem PostScript, como o sistema de coordenadas, a unidade medida e os principais operadores de que ela se serve para realizar desenhos e construes geomtricas. Todos os captulos seguintes dependem de uma boa compreenso dos conceitos aqui apresentados. Tambm essencial ao aprendizado o bom funcionamento dos programas utilizados para a gerao de grficos. Certifique-se de ter lido e compreendido o Apndice A para poder trabalhar com eficincia na programao com PostScript.

1.1 O sistema de coordenadas

Para localizar e desenhar ponto em uma folha de papel, a PostScript faz uso do que chamamos de sistema de coordenadas. Imaginemos uma folha de papel com eixos localizados em sua extremidade inferior esquerda. Esses eixos correm da esquerda para a direita e de baixo para cima, como nos mostra a figura seguinte:

figura 1.1 Os desenhos so feitos com esse sistema de coordenadas em mente, em uma folha de papel imaginria. O canto inferior esquerdo, chamado de origem, tem coordenadas (0, 0). A partir dessa referncia inicial, podemos encontrar a localizao de qualquer objeto na pgina. Por exemplo, se um ponto tem coordenadas (100, 200), isso significa que ele se localiza na folha de papel imaginria a 100 pontos direita da origem, e 200 pontos acima da origem. como no jogo de batalha naval ou na notao da posio das peas em um tabuleiro de xadrez.

1.2 A unidade de medida

Na seo anterior falamos de coordenadas de um ponto. Mas o que vem a ser um ponto na linguagem PostScript? Em PostScript, um ponto uma unidade de medida, chamada de ponto PostScript. Em uma polegada (2,54 cm) h exatamente 72 pontos PostScript. Isso nos diz que um ponto equivale medida de aproximadamente 0,35278 mm. Assim, podemos afirmar que uma folha de papel A4, de dimenses 210 mm x 297 mm, mede, aproximadamente, 595 pontos na horizontal e 842 pontos na vertical. Para efeitos prticos, vamos imaginar um ponto PostScript como um pequeno retngulo localizado na posio dada pela coordenadas. Certamente esse no o conceito matemtico de ponto, mas essa a melhor representao do que efetivamente acontece na tela de um computador digital. Um ponto PostScript, 7

alm de uma unidade de medida, ser visto como um elemento grfico distinto, possuindo comprimento e largura, ainda que diminutos. Apesar de imaginarmos pontos PostScript como pequenos retngulos empilhados uns sobre os outros, no devemos confundi-los com os pixels da tela do computador. A unidade de medida ponto PostScript ser posteriormente substituda pelas unidades de medida usuais como o milmetro e o centmetro. Por ora, lembrese apenas de que uma polegada, equivalente a aproximadamente 2,5 cm, contm 72 pontos PostScript.

1.3 Notao ps-fixa e operaes aritmticas

A PostScript usa a chamada notao ps-fixa (ou ps-fixada) para expressar comandos. Com essa notao, uma operao aritmtica simples como 7 + 5 passa a ser escrita como 7 5 + ou seja, o nmero 7, um espao em branco, o nmero 5, um espao em branco, e o sinal de +. Observe que o smbolo da operao a ser realizada sobre os dados vem depois dos dados (da o nome ps-fixa). Em verdade, a operao acima escrita, em PostScript, como 7 5 add em que o operador add substitui o tradicional sinal +. Em PostScript existem vrios operadores aritmticos. A lista abaixo, que usaremos como referncia, mostra alguns deles. Usamos o smbolo para indicar o resultado da operao: add adiciona dois nmeros: sub subtrai dois nmeros: mul multiplica dois nmeros: div divide dois nmeros: neg inverte o sinal de um nmero: 5 6 add 11 8 5 sub 3 4 6 mul 24 18 3 div 6 3 neg -3 -5 neg 5

Todos os operadores agem imediatamente sobre os nmeros encontrados logo esquerda, substituindo-os pelo resultado da operao. Como so armazenados esses dados?

1.4 A pilha
O uso da notao ps-fixa uma consequncia da maneira como os dados em PostScript so armazenados na memria do computador, em uma estrutura conhecida como pilha. Os dados em PostScript vo para a memria do computador como se fossem empilhados uns sobre os outros, como em uma pilha de pratos. Quando precisamos de um prato, costumamos tirar primeiro o prato de cima, para depois tirar o de baixo. Ou seja, o ltimo prato a ser empilhado o primeiro a ser desempilha do. Essa maneira simples de estruturar os dados na memria do computador chamada de estrutura LIFO, do ingls last in, first out (ltimo a entrar, primeiro a sair). Precisamos entender bem como essa estrutura funciona. No lugar de uma pilha de pratos, imaginemos uma fila de livros que vo sendo colocados na estante um aps o outro, da esquerda para a direita: | | | | | ... etc. Em PostScript, vamos usar essa metfora para entender o cdigo que escrevemos. Primeiro colocamos os dados um aps o outro na pilha (ou estante) 7 5 e depois dizemos o que fazer com eles: 7 5 add O operador add diz que devemos adicionar os dados e deixar o resultado (12) na pilha. Se desejamos subtrair dados, a ordem tambm a da esquerda para a direita, como fazemos normalmente. Se escrevemos 12 5 sub expresso em que sub denota o operador de subtrao, teremos na pilha o resultado 7. 9

Operaes aritmticas mais complexas devem ser cuidadosamente analisadas, para que a entrada de dados na pilha seja feita com correo. Por exem plo, a operao

8 deve ser notada como 73

8 7 3 sub div

pois d entrada na pilha, da esquerda para a direita, na seguinte sequncia: 8 8 8 8 8 8 2

7 7 3 7 3 sub 4 4 div

Observe que os operadores sub e div, assim que entram na pilha, operam imediatamente sobre os dois dados mais prximos esquerda, deixando o resultado na pilha antes da entrada dos dados e operadores seguintes. Pode ser necessrio realizar uma troca de elementos na pilha, eliminar um deles, duplicar um outro, e assim por diante, em operaes aritmticas. Sera ne cessrio, portanto, alterar a ordem dos dados na pilha, atravs de operadores criados exclusivamente para esse fim. A lista abaixo mostra alguns dos mais usados operadores: clear remove todos os elementos da pilha: dup duplica o elemento superior da pilha: pop remove o elemento no topo da pilha: 3 5 9 clear (vazio) 3 5 9 dup 3 5 9 9 3 5 9 pop 3 5 3 5 9 exch 3 9 5 Os operadores de pilha nos do mais flexibilidade nas operaes aritmticas. Por exemplo, os dois cdigos seguintes so equivalentes (deixam o mesmo resultado na pilha): 14 2 5 add div

exch troca a posio dos dois elementos do topo da pilha:

2 5 add 14 exch div

Qualquer uma das duas linhas de cdigo acima realiza a operao

14 . 25

A segunda, porm, segue um pouco mais a lgica que utilizamos no dia a dia, realizando primeiro a soma no denominador e depois a diviso. Vejamos um esquema passo a passo dessa operao: 2 2 5 2 5 add 7 7 14 7 14 exch 14 7 14 7 div 2 Em palavras, primeiro alimentamos a pilha com 2 e 5 e fizemos a operao de adio, deixando 7 na pilha. Alimentamos a pilha com 14, mas no podemos realizar a operao de diviso, que daria

7 14 , e no , como desejamos. 14 7

Por isso, alimentamos a pilha com o operador exch, que inverte a posio dos dois nmeros mais recentemente introduzidos na pilha. Agora podemos realizar a operao, ficando com o resultado correto 2. Percebemos, no entanto, que a notao da primeira linha mais econmica e mais simples, mas exige um conhecimento mais seguro de como so realizadas as operaes em pilha. Para entender melhor esses recursos, realize os exer ccios no fim de cada captulo, comeando desde j sua histria pessoal com essa magnfica linguagem.

1.5 Exerccios
1. Escreva as operaes abaixo em PostScript: a) 7 b)

6 2

6 7 2
11

c) d)

5 2 2 5 52 25

2. Calcule mentalmente o resultado das operaes abaixo: a) 2 3 add 5 div b) 6 1 5 add sub c) 3 5 div 2 5 div add d) 3 4 5 add mul e) 3 4 mul 5 add 3. Escreva os valores que ficam na pilha depois da operaes: a) 2 dup 6 dup b) 3 8 exch dup c) 3 9 exch pop d) 4 7 pop 5 exch e) 1 2 3 pop exch 4. Calcule mentalmente o resultado das operaes abaixo: a) 1 2 dup div add b) 3 6 2 sub exch sub c) 2 7 5 3 pop sub mul d) 4 5 exch sub 3 dup mul add e) 3 6 9 12 exch sub sub div

Captulo 2
Linhas retas (I)
Linhas retas so os componentes mais frequentes em ilustraes matemticas, e os primeiros que aprendemos quando estudamos PostScript, antes mesmo de aprendermos a desenhar um simples ponto. Neste captulo vamos aprender como lidar com esse elemento simples e extremamente verstil, nas diversas formas em que se apresenta. Vamos tambm estudar o comando def, que nos possibilitar nomear trechos de cdigo, evitando sua repetio e aumentando a legibilidade de nossos programas.

2.1 Segmentos de reta

Segmentos de reta so tradicionalmente o primeiro elemento que dominamos quando aprendemos PostScript. Comecemos aprendendo a desenhar um segmento horizontal de 100 pontos de comprimento em nosso espao grfico. Todo desenho, em PostScript, deve ser preferencialmente iniciado com o comando newpath Aps esse comando, podemos imaginar que uma mo passou a segurar um lpis. Vamos imaginar tambm que a ponta desse lpis no escreve com grafite ou tinta, mas feita de ao ou de outro material que marca a folha, deixando nela um leve sulco. Agora vamos desenhar um segmento de reta horizontal de 100 pontos a partir das coordenadas (300, 500). Primeiro, devemos mover a ponta do lpis at l usando o comando moveto:

13

300 500 moveto O comando moveto desloca a ponta do lpis para as coordenadas (300, 500). Com o lpis em posio, marquemos no papel uma linha horizontal de tamanho 100 pontos para a direita com o comando lineto, ou seja, do ponto de coordenadas (300, 500) at o ponto de coordenadas (400, 500): 400 500 lineto Em verdade, o segmento ainda no foi traado. Apenas um sulco foi feito sobre a folha, uma marca que ser posteriormente preenchida com tinta. A ponta do lpis est agora sobre o ponto (400, 500), esperando o prximo comando. O comando stroke preenche com tinta as marcaes feitas. Aps os quatro comandos newpath 300 500 moveto 400 500 lineto stroke devemos ver a seguinte imagem na folha:

figura 2.1-a Aps passar tinta sobre as marcas criadas, o comando stroke retira o lpis do papel e "esquece" as indicaes dadas. preciso um outro newpath para realizar um novo desenho. Uma folha pode conter vrios desenhos, cada um en volvido por um par de comandos newpath e stroke. Suponha agora que, antes de finalizar o desenho, voc queira traar mais um segmento, paralelo ao primeiro, mas 20 pontos acima. Lembre-se que, aps o comando 400 500 lineto, a ponta do lpis imaginrio est exatamente sobre essas coordenadas, ou seja, sobre o ponto de coordenadas (400, 500). necessrio mover a ponta do lpis 100 pontos para trs (subtraindo 100 da coordenada 400) e 20 pontos para cima (somando 20 coordenada 500): 300 520 moveto

Agora a ponta do lpis est localizada 20 pontos acima do incio do segmento original. Agora trace o novo segmento: 400 520 lineto Acrescente essas duas linhas ao seu programa original, antes do comando stroke. Seu programa agora : newpath 300 500 400 500 300 520 400 520 stroke

moveto lineto moveto lineto

% move novamente o lpis % marca um novo segmento

O smbolo % utilizado em programas PostScript para indicar o incio de um comentrio. Tudo o que vem depois dele, at o final da linha em que aparece, ignorado quando o programa interpretado. Voc poderia substituir o comando 300 520 moveto por um outro: -100 20 rmoveto O comando rmoveto executa um movimento relativo ao ponto em que o lpis se encontra. Como precisvamos subtrair 100 da coordenada 400, e somar 20 coordenada 500, podemos informar isso ao comando rmoveto que ele faz as contas por ns. Substitua a linha no seu programa e visualize o resultado, que deve ser:

figura 2.1-b Suponha agora que, em vez de traar uma paralela, voc queira traar um segmento de reta para cima, como o tamanho de 100 pontos. Voc tem duas alternativas: escrever, logo aps 400 500 lineto, uma das linhas 400 600 lineto ou 15

0 100 rlineto Na primeira opo, voc faz as contas e informa ao comando lineto at onde a ponta do lpis deve ir. Na segunda, voc informa apenas o acrscimo que quer dar s coordenadas correntes. Seu programa agora, para o segmento original acrescentado com o segmento perpendicular, fica: newpath 300 500 moveto 400 500 lineto 0 100 rlineto stroke gerando a figura

% marca um segmento vertical

figura 2.1-c Se voc quer desenhar um quadrado, bastam quatro comandos rlineto a partir do primeiro moveto: newpath 300 500 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto 0 -100 rlineto stroke

% inicia a marcao de 4 segmentos

figura 2.1-d Faa agora uma experincia. No programa GSview, amplie o desenho, clicando no cone que tem o desenho de uma lupa, apertando em seguida a tecla R, e observe o vrtice inferior esquerdo do quadrado, o incio do desenho. No pare ce que os segmentos esto bem conectados; h uma pequena falha bem no canto (compare com os outros vrtices do quadrado). Vamos corrigir esse problema com o comando closepath: newpath 300 500 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto closepath stroke

% fecha o caminho traado

O comando closepath elimina o problema descrito na seo anterior, o da falha na unio dos segmentos (amplie a nova figura e repare). Sempre que desejar usar formas fechadas, utilize o comando closepath para melhores resultados visuais. Se voc deseja desenhar figuras preenchidas, use o comando fill no lugar do comando stroke: newpath 300 500 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto closepath fill

% preenche o caminho traado 17

figura 2.1-e Em verdade, o comando fill substitui no s o comando stroke, mas tambm o comando closepath. Apague o comando closepath no programa acima, e verifique o resultado. O comando stroke pode ser usado vrias vezes no desenho, um stroke aps cada novo elemento do desenho. Essa tcnica deve ser utilizada sempre que aparecerem elementos indesejados no desenho.

2.2 Pontos
Em PostScript, um ponto visto como um segmento de reta de tamanho 1, em qualquer direo. Se desejamos colocar um ponto nas coordenadas (100, 100), comeamos dizendo ao interpretador que desejamos realizar um desenho, movemos o lpis at as coordenadas (100, 100), marcamos sobre a folha um segmento de dimenso 1, e preenchemos com tinta: newpath 100 100 moveto 1 0 rlineto stroke

% marca um segmento de tamanho 1

A direo da esquerda para a direita foi escolhida apenas por comodidade. Poderamos traar um segmento de tamanho 1 em qualquer direo. Em geral, um ponto com essas dimenses dificilmente visvel na tela do computador ou no papel impresso. Essa dificuldade superada substituindo-o, graficamente, por um pequeno crculo cheio ou vazio, que aprenderemos a desenhar no captulo 4.

2.3 Nomeando trechos de cdigo: o comando def

O ponto PostScript no uma medida que costumamos usar em nosso dia a dia. Seria bem melhor se pudssemos usar em nossos desenhos as medidas usuais de centmetro (cm) e milmetro (mm), o que faremos com o comando def. O comando def de importncia fundamental quando desejamos dar um nome a determinados conjuntos de comandos. Aqui, vamos us-lo para definir uma nova unidade. Comecemos definindo o centmetro. Suponhamos que queremos escrever um programa que desenha um quadrado, de lado igual a 5 cm, da seguinte maneira: newpath 10 cm 15 cm moveto 5 cm 0 cm rlineto 0 cm 5 cm rlineto -5 cm 0 cm rlineto closepath stroke Como fazer isso? Como mover a ponta do lpis 10 cm para direita e 15 cm para cima, e da comear o quadrado, usando a medida dos lados em centmetros? Primeiro, vamos entender como converter essas medidas 5 cm, 10 cm e outras no nmero de pontos PostScript correspondentes. Sabemos que uma polegada tem 72 pontos PostScript, e que uma polegada mede exatamente 2,54 cm. Para encontrarmos a medida em polegadas de 5 cm, basta dividir 5 por 2,54, o que nos d aproximadamente 1,97 polegadas. Ou seja, 5 cm equivalem a aproximadamente 1,97 polegadas. Quantos pontos PostScript h em 1,97 polegadas? Basta multiplicarmos 1,97 por 72, obtendo aproximadamente 141,84 pontos PostScript. Em resumo, fizemos (5 / 2,54) x 72. Em PostScript, fica 5 2.54 div 72 mul Se agora queremos saber quantos pontos h em 10 cm, a conta ser 10 2.54 div 72 mul Observe que o conjunto de instrues 2.54 div 72 mul o mesmo nos dois casos, e ser o mesmo com qualquer outra medida em centmetros. Aqui que entra o comando def. 19

O comando def atribui um nome a um conjunto de instrues. Sua sintaxe bem simples: /cm {2.54 div 72 mul} def que equivalente a /cm {28.35 mul} def % definio simplificada % definio de cm

pois dividir por 2,54 e multiplicar por 72 o mesmo que multiplicar por 72/2,54 = 28,34646, ou ainda, aproximadamente por 28,35. Isso significa que quando quere mos um segmento de 3 cm, precisamos multiplicar 3 por 28,35 para encontrarmos o valor em pontos. Como podemos perceber, h aproximadamente 28,35 pontos PostScript em 1 cm. Atribumos ao nome cm o conjunto de instrues 28.35 mul. Observe que h uma barra / antes do nome e chaves ao redor do conjunto de instrues. Com isso, em vez de escrevermos 10 28.35 mul 15 28.35 mul moveto escrevemos apenas 10 cm 15 cm moveto o que aumenta enormemente a legibilidade de nossos programas. Para ganharmos essa flexibilidade, basta acrescentarmos a linha /cm {28.35 mul} def antes do comando newpath, ou seja, como a primeira linha de nosso programa.

2.4 Exerccios
Os exerccios seguintes foram planejados de maneira a exigirem do programador conhecimentos especficos de matemtica. A ajuda de bons livros de geometria euclideana plana e de geometria analtica talvez sejam indispensveis. O aprendizado de matemtica, lembremos, um dos objetivos deste livro. 1. Desenhe dois segmentos que sejam: a) concorrentes

b) concorrentes e que se dividam mutuamente na razo 2:1 c) concorrentes e que faam um ngulo de 30 o entre si 2. Desenhe um tringulo: a) equiltero b) retngulo com a hipotenusa paralela base da folha de papel c) com lados na proporo 3:5:7 3. Desenhe um quadriltero com lados no congruentes e no paralelos. Desenhe o quadriltero formado pelos segmentos que unem os pontos mdios de cada lado. 4. Faa uma ilustrao para o teorema de Tales: Se duas retas so transversais de um feixe de retas paralelas, ento a razo entre dois segmentos quaisquer de uma delas igual razo entre os respectivos segmentos correspondentes da outra. 5. Desenhe duas setas paralelas, como na figura abaixo:

Desenhe agora os eixos coordenados da figura 1.1.

21

Captulo 3
Linhas retas (II)
Neste captulo aprenderemos como alterar o estilo de uma linha, em funo de uma melhor apresentao grfica das ilustraes. Vamos estudar tambm os comandos gsave e grestore, dando os primeiros passos para a simplificao de nossos programas.

3.1 Estilos de linhas

Em muitos desenhos, precisamos de mais de um estilo de linhas para mostrar que certos elementos so mais importantes do que outros, ou que alguns elementos so linhas de construo, provisrias. Esses elementos no devem ser considerados como parte integrante do desenho final, como quando realizamos construes com rgua e compasso. Geralmente, linhas contnuas e pontilhadas so usadas juntamente com linhas linhas finas e grossas, e tambm com linhas claras e escuras para causar esse efeito. Veremos alguns comandos da PostScript que tratam desse assunto.

3.1.1 setgray
O comando que especifica se uma linha ser mais clara do que outra o setgray. Esse comando usado com um nmero entre 0 e 1, que especfica tons de cinza, entre o preto (0) e o branco (1). Retome o programa das paralelas, usando agora rmoveto e rlineto, e acrescente antes do stroke o comando 0.7 setgray: newpath 300 500 moveto 100 0 rlineto -100 20 rmoveto 100 0 rlineto

0.7 setgray stroke

% estabelece uma tonalidade de cinza

figura 3.1.1-a Executando o programa sem 0.7 setgray, voc ver duas paralelas pretas; com 0.7 setgray, as paralelas tomaram a tonalidade cinza claro. O comando 0.7 setgray veio antes de stroke apenas para nos lembrarmos que o comando stroke que realiza o desenho, e que a ele informamos que a tonalidade deveria ser 0.7. Se voc deseja que um segmento seja claro e o outro escuro, por enquanto voc deve fazer dois desenhos: newpath 300 500 moveto 100 0 rlineto stroke newpath 300 520 moveto 100 0 rlineto 0.7 setgray stroke

figura 3.1.1-b Se no definimos o valor de setgray, a PostScript assume que ele 0 (preto). No precisamos desse comando se no so necessrias tonalidades diferentes em nosso desenho. Mas adiante, veremos como evitar a escrita de dois desenhos com os comandos gsave e grestore.

23

3.1.2 setlinewidth
Tambm a espessura das linhas pode ser alterada. Se desejamos que nossas linhas tenham a espessura de 10 pontos PostScript, simplesmente escrevemos 10 setlinewidth logo antes de stroke: newpath 300 500 moveto 100 0 rlineto 10 setlinewidth stroke

% estabelece a espessura da linha

figura 3.1.2-a preciso ter em mente que as marcaes feitas na folha pelo comando rlineto no tm a espessura de 10 pontos. o comando 10 setlinewidth que funciona como um pincel de 10 pontos de largura a ser passado sobre as marcaes invisveis. Essas marcaes podem ser imaginadas como a "alma" das linhas, localizadas bem no centro delas:

figura 3.1.2-b Na figura 3.1.2-b acima, desenhamos uma linha em branco no meio da linha preta apenas para representar a marcao invisvel sobre a qual a PostScript desenha com os comandos fill e stroke. Esse conceito, o de tinta sobre a marcao, deve ser mantido em mente o tempo todo, pois uma linha com 10 pontos de largura significa 5 pontos de largura para cada lado, alterando as dimenses reais do desenho. Por exemplo, o quadrado da figura 2.1.4, se traado com uma linha de 10 pontos de espessura, ter a medida de seus lados aumentada em 10 pontos:

figura 3.1.2-c Observe agora outra caracterstica da linguagem PostScript. Copie o seguinte programa e visualize no GSview: newpath 300 500 moveto 100 0 rlineto 10 setlinewidth stroke newpath 300 520 moveto 100 0 rlineto 0.7 setgray stroke

figura 3.1.2-d Apenas lendo o programa, percebemos que a primeira parte traa um segmento de reta de espessura 10 pontos, e a segunda parte traa um segmento de reta mais claro que o primeiro. No entanto, quando visualizamos o resultado, a segunda linha tambm aparece com a espessura de 10 pontos! O que aconteceu, se no escrevemos 10 setlinewidth tambm na segunda parte (e, portanto, a PostScript deveria assumir que a espessura 1 setlinewidth)? Dissemos que o comando stroke finaliza um desenho, passando a tinta sobre as marcaes efetuadas, esquecendo-as logo depois. Mas esse comando 25

no esquece de detalhes como cor, espessura e estilo de linha. Esses dados continuam guardados na memria do computador para uso futuro, e so chamados de estado grfico do desenho. Portanto, se voc deseja uma linha clara com a espessura de 1 ponto, ser necessrio escrever 1 setlinewidth antes de stroke na segunda parte do desenho. Faa isso agora e visualize o resultado.

3.1.3 setdash
Quando precisamos de linhas tracejadas ou pontilhadas, usamos o comando setdash. Vamos traar um quadrado e depois uma de suas diagonais com uma linha tracejada: newpath 300 500 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto closepath stroke newpath 300 500 moveto 100 100 rlineto [5 4] 0 setdash stroke

% cria um padro de traos e espaos

figura 3.1.3 O comando setdash bastante flexvel. Com ele podemos criar diversos padres de linhas pontinhadas, tracejadas e mistas, bastando para isso definir o padro de pontos pretos e brancos que desejamos. Em nosso caso, determinamos

que seria uma linha tracejada com 5 pontos pretos seguidos de 4 pontos brancos. Por isso, escrevemos [5 4]. O zero em [5 4] 0 nos diz que esse padro deve ser repetido a partir do primeiro ponto do padro original. Se desejamos comear com brancos, devemos comear a partir do sexto ponto: [5 4] 6. O padro sempre o de pretos seguidos de brancos. Faa alguns testes: tente trocar [5 4] por [5 4 1 4] e observe o que acontece. Troque tambm o nmero que vem logo depois para outros valores. Como na figura acima, e tambm nas figuras que mostraram linhas claras e escuras, precisamos comear dois desenhos. Os comando da seo seguinte, gsave e grestore nos ajudaro a economizar linhas de cdigo.

3.2 Os comandos gsave e grestore

Os comando gsave e grestore costumam andar juntos. Funcionam como parnteses no meio do cdigo, salvando as configuraes do estado grfico at o momento, rastaurando-as depois quando necessrio. Lembremo-nos que o estado grfico de um desenho, como dito na seo 3.1.2, um conjunto de informaes sobre a espessura das linhas, suas cores e seus estilos. Tambm faz parte do estado grfico de um desenho as marcaes feitas at ento e o ltimo ponto sobre o qual se apoiou a ponta de nosso lpis imaginrio, ponto esse chamado de ponto corrente. Vejamos na prtica como usar esses comandos. Suponha que voc queira fazer o seguinte desenho:

figura 3.2 Preenchemos um quadrado com a tonalidade de cinza 0.5 setgray e depois o emolduramos com uma borda de 10 pontos de largura. Como voc faria 27

isso? Por enquanto, so necessrios 2 desenhos, um para o preenchimento e outro para a moldura: newpath 300 500 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto 0.5 setgray fill newpath 300 500 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto closepath 0 setgray 10 setlinewidth stroke Esse cdigo produz o resultado desejado, alm de simples e de fcil leitura. No entanto, h muitas linhas repetidas nas duas partes, e seria interessante que pudssemos aproveitar na segunda parte o que foi escrito na primeira, ou vice-versa. Observe como h muita redundncia entre as partes. Vamos mostrar como ficaria esse cdigo usando os comandos gsave e grestore, passando a explicar seu funcionamento logo depois: newpath 300 500 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto closepath gsave 0.7 setgray fill grestore 10 setlinewidth stroke

% salva o estado grfico % restaura o estado grfico

As seis primeiras linhas so as marcaes iniciais do quadrado que desejamos preencher. Nesse momento, a PostScript tambm assume que a espessura da tinta sobre essas marcaes ser, futuramente, de 1 ponto (1 setlinewidth) e ser da cor preta (0 setgray). At que informemos mais coisas, esse o atual estado grfico do desenho. Quando usamos o comando gsave, pedimos PostScript que armazene na memria esse atual estado grfico: as marcaes feitas mais as caractersticas de espessura e cor assumidas. Agora vamos fazer algumas alteraes nesse estado grfico. Quando escrevemos 0.7 setgray e fill, ordenamos PostScript que mude a cor, de preto para um cinza claro, e que preencha as marcaes com esse tom de cinza. O estado grfico foi claramente alterado. Logo depois, aparece o comando grestore, que traz de volta todo o estado grfico anterior ao gsave: todas as marcaes feitas, a espessura e a cor da tinta. como se depois do closepath pulssemos diretamente para o comando 10 setlinewidth, que informar ao comando stroke que a linha ser pintada tem a espessura de 10 pontos. Em um primeiro momento, os comando gsave e grestore podem parecer confusos, mas a experincia com a linguagem os tornar mais claros. Como dissemos, a diviso de um desenho em vrias partes uma boa alternativa para criar mos cdigos mais simples e mais legveis. Mas haver momentos em que os co mando gsave e grestore, inteligentemente utilizados, sero a nica alternativa para realizarmos desenhos matemticos complexos. Como exerccio, reescreva os programas das sees 3.1.2 e 3.1.3 com os comandos gsave e grestore.

3.3 Exerccios
1. Desenhe um tringulo escaleno obtusngulo. Em relao ao maior lado, desenhe, em um tom de cinza: a) a mediana b) a mediatriz c) a altura 2. Desenhe as figuras abaixo com as diagonais pontilhadas: a) um trapzio issceles c) um trapzio retngulo 29

d) um trapzio qualquer 3. Desenhe um pentgono. Desenhe suas diagonais com metade da espessura dos lados. 4. Usando gsave e grestore, desenhe: a) trs linhas paralelas com tonalidades diferentes de cinza b) trs linhas paralelas com padres diferentes de linha c) um tringulo retngulo com preenchimento cinza e lados pretos 5. Ilustre a regra do paralelogramo utilizada na soma de dois vetores. Se os veto res v e w so v = (a, b) e w = (c, d), ento v + w = (a + c, b + d).

Captulo 4
Circunferncias, arcos de circunferncia, elipses e curvas de Bzier
Circunferncias e arcos de circunferncia, so to importantes nas ilustraes quanto segmentos de reta. Neste captulo veremos como desenh-los, e tambm elipses, arcos de elipses e o que so as famosas curvas de Bzier.

4.1 Circunferncias e arcos de circunferncias

Circunferncias e arcos de circunferncia so simples de serem desenhados em PostScript. Os dois principais comandos so arc e arcn.

4.1.1 arc
O comando arc desenha arcos que variam de 0 o a 360o, em sentido antihorrio. Esse comando opera com 5 parmetros: as coordenadas do centro da circunferncia, o raio da circunferncia e os ngulos inicial e final, nessa ordem. Como exemplo, o comando para desenhar um arco de 90o de uma circunferncia de raio igual a 50 pontos com centro no ponto (300, 400) 300 400 50 0 90 arc

figura 4.1.1-a

31

O comando comeou com as coordenadas do centro da circunferncia, (300, 400). Logo depois, informamos o valor do raio, 50, e dissemos que o arco comearia em 0o e terminaria em 90o. O programa todo , simplesmente, newpath 300 400 50 0 90 arc stroke % arco de 90 graus, raio 50

Se desejamos desenhar uma circunferncia, basta informarmos que o ngulo final 360o: 300 400 50 0 360 arc

figura 4.1.1-b Podemos traar uma circunferncia tracejada, utilizando o comando setdash visto no captulo anterior: newpath 300 400 50 0 90 arc [5 5] 0 setdash stroke

figura 4.1.1-c

Observe como o primeiro e o ltimo trao formaram um trao maior logo no incio do arco. Podemos ajustar isso alterando o nmero imediatamente anterior ao comando setdash ou o mudando padro de brancos e pretos do comando. Teste alguns valores at conseguir uma figura que lhe seja conveniente. Se desejamos desenhar um anel, basta traarmos um arco mais largo, com o uso do comando setlinewidth. Vamos desenhar um anel circular com uma linha de 30 pontos de espessura: newpath 300 400 40 0 360 arc 30 setlinewidth stroke

figura 4.1.1-d Observe a pequena fenda direita. Isso pode ser corrigido com o comando closepath. Acrescente-o logo depois do comando arc, e veja como a fenda some. Com figuras fechadas, use sempre com o comando closepath, mesmo lhe pareendo redundante. Como o comando lineto, o comando arc responsvel por realizar apenas uma marcao invisvel no papel, sobre a qual o comando stroke passar um pincel com tinta. Se queremos desenhar um anel circular, no devemos simplesmente aumentar a espessura da linha, como fizemos na figura 4.1.1-d acima, mas desenhar dois crculos com fill, um com a cor preta e outro com a cor branca. Vamos desenhar uma coroa circular com raio externo de 2 cm e raio interno de 1 cm. Lembremo-nos de usar o comando def para transformar a medida "cm" em pontos. /cm {28.35 mul} def % define a unidade cm

33

newpath 300 400 2 cm 0 360 arc % circunferncia externa fill % preenche a circunf. externa 300 400 1 cm 0 360 arc % circunferncia interna 1 setgray % define a cor branca fill % preenche a circunf. interna

figura 4.1.1-e

4.1.2 arcn
O comando arcn como o comando arc, mas a contagem do ngulo feita em sentido horrio. O programa abaixo o mesmo que gerou a figura 4.1.1-a com o comando arc substitudo pelo comando arcn: newpath 300 400 50 0 90 arcn stroke

figura 4.1.2 Observe que a diviso da circunferncia em ngulos continua a ser feita no sentido anti-horrio. O comando arcn simplesmente anda na direo contrria

 marcao usual dos ngulos. Tudo o que pode ser feito com o comando arcn pode ser feito com o comando arc, com os devidos ajustes.

4.2 Elipses
A PostScript capaz de desenhar elipses atravs de um truque simples: primeiro, desenhamos uma circunferncia, depois achatamos sua altura ou seu comprimento. Isso conseguido com o comando scale: newpath 1 0.3 scale % reduz a altura da circ. em 30% 300 400 80 0 360 arc stroke

figura 4.2.1 O comando scale recebe dois argumentos. Ambos multiplicam o tamanho natural de um desenho por um valor. Em nosso caso, o primeiro valor, 1, multiplicou o comprimento da figura por 1, ou seja, manteve o comprimento inalterado. O segundo valor, 0.3, multiplicou a altura do desenho por 0,3. Em outras palavras, fez com que o desenho ficasse com apenas 30% de sua altura original. Em verdade, o comando scale altera as dimenses de todos os pontos da pgina pelo valor informado. Se tivssemos escrito em nosso programa 0.5 0.5 scale teramos reduzido as dimenses de todos os pontos da pgina para a metade, e teramos uma circunferncia com a metade do dimetro original. Discutiremos com mais detalhes esse comando no prximo captulo.

35

4.3 Efeitos de sombra

Um dos artifcios usados para se criar a iluso de tridimensionalidade a presena de sombras no desenho. Em PostScript, esse efeito conseguido por meio de trs desenhos sobrepostos, comeando de baixo para cima: primeiro desenhamos a sombra, deslocada alguns pontos para a direita e para baixo, depois desenhamos o interior branco do desenho e, por fim, desenhamos o contorno. Observe o cdigo abaixo, escrito como trs desenhos distintos por questes meramente didticas: newpath 305 395 50 0 360 arc fill stroke newpath 300 400 50 0 360 arc 1 setgray fill stroke newpath 300 400 50 0 360 arc 0 setgray stroke % a sombra

% o interior

% o contorno

figura 4.3.1 O raio do crculo de interior branco de 50 pontos, com centro em (300, 400). Sua sombra, afastada para a direita e para baixo em 5 pontos, um crculo tambm de raio 50, mas de centro (305, 395). O desenho feito de baixo para cima porque o interior do crculo branco deve apagar o interior do crculo preto.

Sabemos como usar inteligentemente os comandos gsave e grestore para economizar cdigo. Seria possvel utilizar esse par de comandos aqui?

4.4 Curvas de Bzier

Curvas de Bzier so importantes nas engenharias e na cincia da computao. Essas curvas receberam esse nome em homenagem ao engenheiro francs Pierre tienne Bzier (1910-1999), que as utilizou amplamente no design de automveis. Curvas de Bzier so criadas pelo comando curveto. O comando curveto gera curvas de Bzier formadas por um ponto inicial e um ponto final, mais pontos intermedirios, ditos pontos de controle:

figura 4.4-a Na curva da figura 4.4.1-a acima, temos os pontos P0 e P3 como pontos inicial e final, respectivamente, e os pontos P1 e P2 como pontos de controle. Visualmente, a curva parece ser "atrada" pelos pontos de controle, sem passar por eles, e se ligar aos pontos inicial e final tangenciando as linhas pontilhadas. Se invertemos os pontos P1 e P2, a situao se modifica bastante:

figura 4.4-b 37

Agora a curva parte de P0 em direo a P1, atrada por P2 e depois se dirige a P3. difcil prevermos o comportamento de curvas de Bzier, mesmo entendendo suas equaes. A maioria das vezes, usamos essas curvas por tentativa e erro, mas depois de alguma prtica acabamos com uma boa noo acerca de seu funcionamento. Observe agora o que ocorre quando unimos o ponto inicial ao ponto final:

figura 4.4-c Vejamos agora como essas figuras foram geradas. O cdigo seguinte mostra apenas a curva da figura 4.4-a, sem as linhas pontilhadas e o nome dos pontos. /cm /P0 /P1 /P2 /P3 {28.35 mul} {1 cm 1 cm} {1 cm 5 cm} {4 cm 5 cm} {5 cm 2 cm} def def def def def % % % % % define define define define define centmetro ponto P0 ponto P1 ponto P2 ponto P3

newpath P0 moveto P1 P2 P3 curveto stroke

% move lpis at o ponto P0 % P1 e P2 de controle, P3 final

O programa inicia-se com uma seo de definies. Definimos a unidade de medida (cm), e depois 4 pontos, P0, P1, P2 e P3. Logo depois, comeamos o desenho com newpath, e indicamos ao lpis imaginrio que se mova at o ponto P0. Logo aps, dizemos ao comando curveto quais so os dois pontos de controle e o ponto final da curva. Com o comando stroke, a curva desenhada. Curvas de Bzier so bastante utilizadas em programas de ilustrao vetorial. Um excelente programa gratuito o Inkscape (www.inkscape.org), no qual podemos treinar nossa intuio geomtrica relativa a curvas de Bzier.

4.5 Exerccios
1. Desenhe: a) trs circunferncias concntricas, com tonalidades diferentes de linha b) duas circunferncias de raios diferentes tangentes externamente c) duas circunferncias de raios diferentes tangentes internamente 2. Desenhe: a) duas coroas circulares concntricas c) meia coroa circular d) duas meias coroas circulares afastadas uma da outra em 1 mm 3. Desenhe: a) um setor circular de 60o b) um segmento circular de 60o c) uma circunferncia e seu dimetro 4. Desenhe: a) um tringulo retngulo escaleno inscrito em uma semicircunferncia b) uma circunferncia, um ngulo central de 60 o e um ngulo inscrito de 30o c) uma circunferncia e duas cordas concorrentes que no sejam dimetros 5. Desenhe duas circunferncias de tamanhos diferentes e uma reta tangente s duas 6. Desenhe uma circunferncia usando curvas de Bzier. Compare-a com uma circunferncia criada com o comando arc. 7. Desenhe uma espiral qualquer usando curvas de Bzier.

39

Captulo 5
Transformaes
Transformaes planas como translaes, rotaes, homotetias e reflexes so extremamente importantes do ponto de vista geomtrico. Elas nos proporcionam meios econmicos de realizarmos muitas ilustraes matemticas. Este captulo introduz o uso das principais transformaes no mbito da linguagem PostScript.

5.1 O ponto corrente

Voltemos metfora do lpis invisvel. Enquanto o lpis caminha fazendo marcas invisveis sobre o papel, seguindo as instrues de nosso programa, a PostScript armazena as coordenadas do ltimo ponto sobre o qual a ponta desse lpis se apoiou. Esse o chamado ponto corrente do desenho, cujas coordenadas so obtidas atravs do comando currentpoint. O comando currentpoint coloca na pilha as coordenadas do ponto corrente. Se a pilha se encontra, por exemplo, com os nmeros 120 350 200 110 e a ponta do lpis parada sobre o ponto de coordenadas (200, 250), o comando currentpoint faz com que a PostScript coloque essas coordenadas na pilha: 120 350 200 110 200 250 Esse comando bastante til com os comandos translate e rotate, vistos nas sees seguintes.

5.2 Translao
A operao de translao consiste em mover a origem dos eixos coordenados para uma nova posio, estabelecendo um novo ponto de referncia para as coordenadas dos desenhos. O comando que realiza essa operao o translate. Antes de explicar o uso do comando, lembremo-nos que, inicialmente, a origem do nosso sistema de coordenadas se encontra na extremidade inferior esquerda da folha de papel:

figura 5.2-a A seta que aponta da esquerda para a direita nos d a direo do chamado eixo x; a que aponta de baixo para cima nos d a direo do chamado eixo y. O ponto (0, 0) chamado de origem do sistema de coordenadas. Para mudarmos a origem do sistema para outro ponto, usamos o comando translate informando as coordenadas da nova origem. Por exemplo, se desejamos transladar todo o sistema para o ponto de coordenadas (200, 250), fazemos 200 250 translate e as coordenadas do desenho passam a ser referenciadas a partir desse novo ponto:

41

figura 5.2-b Com esse novo sistema, um ponto de coordenadas (300, 600), por exemplo, passa a ter coordenadas (100, 350), pois a origem do sistema se aproximou dele 200 pontos na horizontal e 250 pontos na vertical. Para ser executado, o comando translate usa os dois ltimos nmeros da pilha. Se movermos a ponta de nosso lpis para as coordenadas (400, 500) e logo depois acionarmos o comando currentpoint, teremos na pilha os nmeros 400 e 500. O comando translate logo em seguida far com que nosso sistema seja deslocado para o ponto (400, 500). Assim, escrever 400 500 translate equivalente a 400 500 moveto currentpoint translate

% coloca 400 e 500 na pilha e % translada o sistema para l

5.3 Rotao
Como a translao, a rotao age sobre o sistema de coordenadas, girando-o em sentido anti-horrio. O comando que realiza a rotao o rotate. Volte figura 5.2-a. Nela, a origem dos eixos coordenados est no canto inferior esquerdo da folha de papel. O comando

45 rotate gira o sistema em 45o no sentido anti-horrio:

figura 5.3-a Observe bem: se os eixos esto rotacionados em 45 o, a maneira de pensarmos as coordenadas tambm muda. Por exemplo, o comando 200 0 rlineto, a partir da origem do sistema, no vai marcar uma linha horizontal de 200 pontos de comprimento na folha, mas uma de 200 pontos de comprimento na diagonal, ou seja, no novo sentido do eixo x. Teste o programa abaixo para ver o que queremos dizer. newpath 60 rotate 0 0 moveto 200 0 rlineto stroke O comando rotate, combinado com translate e currentpoint, so capazes de realizar faanhas nos desenhos. Por exemplo, o pentgono a seguir

43

figura 5.3-b foi desenhado com o programa newpath 100 100 moveto % currentpoint translate % 50 0 rlineto % 72 rotate % currentpoint translate % 50 0 rlineto 72 rotate currentpoint translate 50 0 rlineto 72 rotate currentpoint translate 50 0 rlineto 72 rotate closepath 2 setlinewidth stroke

move lpis para (100, 100) translada para (100, 100) marca uma linha de 50 pontos rotaciona o sistema em 72o translada para a extremidade

O programa acima no ser to repetitivo quando aprendermos alguns princpios de programao nos captulos seguintes. Mas um timo exemplo de como podemos usar inteligentemente os comandos currentpoint, translate e rotate. Vamos analis-lo passo a passo. Aps o newpath, deslocamos a ponta de nosso lpis para as coordenadas (100, 100). De l evocamos o comando currentpoint, que coloca na pilha os nmeros 100 e 100, ou seja, coloca na pilha as coordenadas da ponta do lpis. Logo depois, transladamos a origem de nosso sistema para esse ponto, com o comando translate. Temos, nesse momento, a origem de nosso sistema no ponto (100, 100). Da nova origem do sistema, marcamos uma reta de tamanho 50 pontos para a direita. Nesse momento, a ponta do lpis est na extremidade mais direita

desse segmento. Da, giramos os eixos do sistema em 72 o e o deslocamos para onde est a ponta do lpis. Estamos agora com a seguinte situao:

figura 5.3-c Na figura acima vemos um segmento de reta com os novos eixos em uma extremidade, rotacionados em 72o no sentido anti-horrio. Vamos repetir o processo: marcamos um novo segmento de 50 unidades na direo do novo eixo x, rota cionamos novamente o sistema e o deslocamos para a extremidade no novo segmento. Ficamos com a seguinte situao:

figura 5.3-d Repetindo todo o processo mais duas vezes, temos:

figura 5.3-e Nesse momento, fechamos o desenho com o comando closepath, estipulamos a espessura da linha em dois pontos e, com o comando stroke, traamos as linhas, e ficamos com a figura 5.3-b. importante ter em mente: a origem e a orientao do sistema ainda se encontram na posio anterior ao closepath. O ideal repetir mais uma vez os comandos 50 0 rlineto, 72 rotate e currentpoint translate antes do closepath. 45

Assim, garantiramos que a origem do nosso sistema se encontra exatamente nas coordenadas iniciais do desenho. Se desejamos que a origem volte para o canto inferior esquerdo da pgina, fazemos -100 -100 translate desfazendo a primeira translao realizada. Teremos a oportunidade de trabalhar com esses comandos em muitas ilustraes. Tente fazer um hexgono apenas para se acostumar com com eles, lembrando-se de que a rotao necessria nesse caso de 60 o.

5.4 Ampliao e reduo

Um desenho pode ser ampliado, reduzido e invertido com o comando scale, que introduz na linguagem PostScript a noo matemtica de homotetia. Em verdade, o comando scale amplia ou reduz o tamanho do ponto PostScript. No amplia ou reduz a figura, mas os pontos que a constituem. Sua forma geral x y scale em que x o fator de ampliao ou reduo na direo horizontal e y o fator de ampliao ou reduo na vertical. Se x maior que 1, o ponto PostScript ser ampliado na direo x; se ficar entre 0 e 1, estamos diante de uma reduo na mesma direo. O mesmo ocorre com o argumento y. Vamos pensar a partir de um exemplo. Suponha que queremos desenhar um quadrado com 50 pontos de lado. Usaremos o cdigo a seguir, mas ampliando os pontos 4 vezes na direo x: newpath 4 1 scale 50 50 moveto 50 0 rlineto 0 50 rlineto -50 0 rlineto closepath stroke

% multiplica por 4 na horizontal % e 1 na vertical

Esse programa comea com o comando 4 1 scale. Isso significa que quadruplicamos as dimenses do ponto na horizontal, e mantemos a espessura 1 na vertical. Nesse novo sistema, uma linha de 50 pontos na horizontal ser 4 vezes maior do que uma linha com 50 pontos na vertical. Por isso, apesar de traarmos um quadrado de lado 50, teremos, na prtica, um retngulo de propores 4:1, como na figura a seguir:

figura 5.4 Repare tambm que os lados verticais ficaram mais espessos do que os lados horizontais. Isso porque, como dissemos, ampliamos os pontos 4 vezes na direo x. Os pontos, portanto, so quatro vezes maiores na horizontal do que na vertical, ou seja, so retngulos de propores 4:1. Essa caracterstica, a de ampliar no a figura em si, mas os pontos que a constituem, fazem com que o co mando scale produza resultados por vezes imprevisveis. Mas um uma boa alternativa para criar os efeitos que passamos a descrever.

5.5 Reflexo
O comando scale, como vimos, tem 2 argumentos: um para ampliao ou reduo na direo x, e outro na direo y. Podemos utiliz-lo para espelhar uma figura em relao a um desses eixos. Por exemplo, considere o tringulo retngulo abaixo:

figura 5.5-a Se desejamos o mesmo tringulo espelhado em relao ao eixo y, como na figura seguinte, 47

figura 5.5-b basta acrescentarmos a linha -1 1 scale depois da ltima translao efetuada. Sim, necessrio que os eixos do desenho estejam transladados para algum ponto mais ao centro da folha, pois seno o re sultado estar fora dos limites da folha, e voc no conseguir visualiz-lo.

5.6 Exerccios
1. Usando o comando translate pelo menos duas vezes no cdigo do programa, desenhe: a) trs segmentos de reta paralelos b) trs quadrados unidos por um de seus vrtices c) trs circunferncias de mesmo raio tangentes entre si duas a duas 2. Usando os comandos rotate e translate, desenhe: a) um tringulo equiltero b) um hexgono c) um tringulo retngulo com a hipotenusa paralela base da folha 3. Usando o comando scale, desenhe: a) trs circunferncias concntricas b) dois tringulos equilteros espelhados por um eixo paralelo a um dos lados c) como no exerccio anterior, mas com um dos tringulos com 1/3 do tamanho do outro

Captulo 6
Elementos de programao
No captulo anterior, aprendemos os importantes comandos currentpoint, translate, rotate e scale, que nos possibilitaram realizar desenhos de maneira mais simples e inteligente. Neste captulo, daremos um passo adiante e aprenderemos como realizar tarefas repetitivas, entender os conceitos de procedimento e de array (vetor).

6.1 O comando de repetio repeat

Vamos reescrever o programa para desenhar o pentgono do captulo anterior. Originalmente, o programa repetia 4 vezes as seguintes trs linhas currentpoint translate 50 0 rlineto 72 rotate e o quinto lado do pentgono era resolvido com o comando closepath. No h nada de errado nisso, mas vamos agora reescrev-lo de maneira que ele repita a operao 5 vezes, deixando ao comando closepath a tarefa de fazer apenas o arremate final: newpath 100 100 moveto currentpoint translate 50 0 rlineto 72 rotate currentpoint translate 50 0 rlineto 49

72 rotate currentpoint translate 50 0 rlineto 72 rotate currentpoint translate 50 0 rlineto 72 rotate currentpoint translate 50 0 rlineto 72 rotate closepath stroke Essa uma maneira um tanto cansativa de desenharmos um pentgono. No seria interessante se pudssemos informar ao interpretador que algumas linhas devem ser repetidas, economizando nosso tempo de digitao? Isso possvel com o comando repeat, que tem a seguinte estrutura: nmero { ... ... ...

} repeat

em que nmero o numero de vezes que o cdigo entre as chaves devem ser repetidos. No programa do pentgono, esse comando utilizado assim: newpath 100 100 moveto 5 { currentpoint translate 50 0 rlineto 72 rotate } repeat closepath stroke

% incio do repeat % fim do repeat

Veja que o cdigo acima produz exatamente o mesmo resultado, um pentgono, mas agora com muito menos digitao. Alm disso, revelou um padro re petitivo, um pequeno programa dentro do programa, que poder ser utilizado posteriormente para realizar tarefas semelhantes. Vamos agora desenhar uma estrela:

figura 6.1 Considerando que o desenho comea da ponta inferior esquerda, ento um programa possvel : newpath 100 100 moveto 72 rotate 5 { currentpoint translate 100 0 rlineto -144 rotate } repeat closepath stroke

% % % %

rotao inicial incio do repeat lado de 100 pontos fim do repeat

Observe que o programa extremamente semelhante ao do pentgono, exceto pelo tamanho do lado e pelos ngulos de rotao. Tambm notvel a rotao inicial dos eixos at que o programa comece a se repetir. possvel desenhar essa estrela sem a rotao inicial. Voc saberia escrever um programa assim, possivelmente comeando de outro ponto? Um segundo comando de repetio importante o for, presente em quase todas as linguagens de programao usuais. Sua sintaxe incio passo fim { ... ... ...

} for

ou seja, uma estrutura como a do repeat, mas toma trs nmeros, chamados incio, passo e fim, para funcionar. O incio indica de que nmero partimos, e o fim, o nmero que desejamos atingir. O passo indica o tamanho do pulo que damos at chegar l. Por exem51

plo, se os nmero so 0 10 50, isso significa que, partindo de 0, avanaremos de 10 em 10 at alcanarmos 50, ou seja, geraremos a sequncia 0, 10, 20, 30, 40, 50. Um exemplo vai esclarecer melhor esse comando. Suponha que voc deseja desenhar a figura seguinte:

figura 6.1-b A figura 6.1-b consiste em 60 raios de 70 pontos de comprimento partindo do centro da figura. A ngulo entre cada dois raios de 6 o. Se inicialmente transladamos nosso sistema de eixos para as coordenadas (200, 200), podemos usar o comando for da seguinte maneira: 1 1 60 { ... ... ...

} for

ou seja, 60 raios, comeando do 1 e chegando at 60, pulando de 1 em 1. O que est dentro do comando for? Apenas as linhas 0 0 moveto 70 0 rlineto 6 rotate ou seja, movemos o lpis para a origem das coordenadas, traamos uma linha de 70 pontos, e giramos os eixos. Fazemos isso 60 vezes, o que nos d o programa completo:

newpath 200 200 translate 0 0 moveto 1 1 60 { 0 0 moveto 70 0 rlineto 6 rotate} for stroke O comando repeat costuma ser suficiente para a maioria de nossas aplicaes. O comando for serve de alternativa, e tem a virtude de explicitar o comeo, o passo e o fim de nosso lao de repetio, trazendo clareza para nossos pro gramas.

6.2 Procedimentos
Vimos que o comando def usado para dar um nome a trechos de cdigo, nome que pode ser usado no corpo do programa como um novo comando. Em nossa definio de centmetro /cm {28.35 mul} def o trecho de cdigo {28.35 mul} ganha o nome cm. Sempre que o interpretador encontra cm no cdigo, imediatamente o substitui por {28.35 mul}. Essa ideia pode ser generalizada. No lugar de apenas um pequeno trecho de cdigo, podemos de finir procedimentos inteiros. Por exemplo, o trecho repetitivo que desenha a estrela currentpoint translate 100 0 rlineto -144 rotate pode ganhar um nome, digamos, lado, e ser declarado no incio do programa: /lado {currentpoint translate 100 0 rlineto -144 rotate } def newpath 100 100 moveto 53 % procedimento lado

72 rotate 5 {lado} repeat closepath stroke

% usando o procedimento lado

O programa faz o mesmo desenho. Mas quando lemos o programa, comeamos com o que est entre newpath e stroke, e percebemos que, depois de um movimento e uma rotao de eixos, o procedimento lado executado cinco vezes. Essa a lgica, o propsito do programa. A lgica do procedimento lado entendida depois, se desejamos ir mais fundo e entender os detalhes do procedimen to. Podemos usar procedimentos dentro de procedimentos. Se queremos desenhar uma estrela de 5 cm de lado, declaramos /cm {28.35 mul} def antes do procedimento lado e nele substitumos 100 0 rlineto por 5 cm 0 rlineto. Procedimentos so os candidatos mais fortes para se tornarem trechos de outros programas, atravs do recurso de copiar e colar. Um bom procedimento pode ser aproveitado vrias vezes em outros programas. Em verdade, programa dores costumam criar arquivos sem um programa principal contendo apenas uma srie de procedimentos reutilizveis. Esses arquivos so chamados de bibliotecas, usados por outros programas. uma maneira de no termos que inventar a roda a cada novo programa.

6.3 Arrays (vetores)

Um array, ou vetor, simplesmente um conjunto de dados delimitado por colchetes: [20 40 70 10 50] O vetor [20 40 70 10 50] tem cinco elementos. Dizemos que o primeiro elemento, 20, est na posio zero, ou seja, tem ndice 0. O segundo elementos tem ndice 1, e assim por diante, at o quinto elemento, 50, que tem ndice 4. Ou seja, um vetor de cinco elementos est enumerado de 0 a 4. Um vetor de 100 elementos estaria enumerado de 0 a 99. Vetores so teis quando precisamos lidar com dados externos, ou dados que aparentemente no tm uma lgica interna. Suponhamos que o vetor [20 40 70 10 50] represente o lucro de uma empresa, em milhes de rais, durante um perodo de 5 anos. Um grfico de barras seria bastante adequado para visualizarmos a evoluo do lucro:

figura 6.3 Como realizar esse grfico da maneira mais simples? Como escrever um programa que desenhe grficos de barra para vetores de qualquer tamanho? Primeiro, vamos dar um nome ao nosso vetor, apenas por comodidade: /dados [20 40 70 10 50] def Agora podemos usar a palavra dados para nos referirmos ao vetor que nos interessa. Futuramente, quando desejarmos trocar os dados, bastar substituir o vetor original por outro. Logo em seguida, vamos escrever o programa que realizar o grfico: newpath 100 100 translate 0 0 moveto 20 setlinewidth dados {barra} forall stroke

% comando forall

O programa comea com o tradicional newpath, seguido de uma translao, um movimento at a nova origem e a especificao de que usaremos uma linha com 20 pontos de espessura. A linha seguinte o corao do programa: dados {barra} forall O comando forall recebe dois argumentos como entrada: um vetor e um procedimento. Esse comando percorre os elementos do vetor, um a um, e realiza sobre cada um deles o procedimento que aqui chamamos de barra. Quando o forall termina de percorrer todos os elementos do vetor, o comando stroke gera o grfico resultante. Como funciona o procedimento barra? O procedimento barra, que deve ser declarado logo depois do vetor dados, o seguinte: /barra {dup 0 exch rlineto 30 exch neg rmoveto} def 55

Vamos explicar seu funcionamento, que bem simples. O comando forall percorre o vetor, do primeiro ao ltimo elemento, e coloca na pilha o elemento da vez. No comeo, ele encontra o primeiro elemento, 20, e o coloca na pilha. Agora tem incio o procedimento barra: ele duplica o elemento com o comando dup, acrescenta 0 pilha e, com o comando exch, troca de posio os dois ltimos elementos. Nesse momento, a pilha 20 0 20 O comando rlineto toma os dois ltimos elementos da pilha, 0 e 20, e traa uma linha de 20 pontos de altura. Na pilha resta agora apenas o nmero 20, e a ponta do lpis se encontra sobre o topo da primeira barra. Logo em seguida, o nmero 30 acrescentado pilha, o comando exch o troca de posio com o nmero 20 e o comando neg o transforma em -20. A pilha, nesse momento, tem os seguinte elementos: 30 -20 Finalmente, o comando rmoveto parte do topo da primeira barra, toma 30 e -20 como argumentos, desloca a ponta do lpis 30 pontos para a direita e 20 pontos para baixo, posiciona a ponta do lpis na base da barra seguinte, que ser desenhada da mesma maneira. Assim ser com todos os elementos, at que o comando forall chegue ao fim do vetor. O programa completo, da maneira que de agora em diante passaremos a escrever, o seguinte: % procedimentos /vetor [20 40 70 10 50] def /barra {dup 0 exch rlineto 30 exch neg rmoveto} def % rotina principal newpath 100 100 translate 0 0 moveto 20 setlinewidth vetor {barra} forall stroke A separao entre a declarao dos procedimentos e a rotina principal aumenta a legibilidade do programa. Frequentemente precisamos ler nossos prprios programas, e quase sempre teremos nos esquecido de como foi que pensamos para criar esse ou aquele trecho de cdigo.

6.4 Exerccios
1. Desenhe: a) um hexgono regular b) uma estrela de 11 pontas c) um quadriculado para o jogo-da-velha d) um tabuleiro de xadrez 2. Desenhe a pseudo-espiral urea:

O retngulo externo tem propores aproximadas de 1:1.618. Observe que o padro visual dessa figura um quadrado com um arco de circunferncia interno, reduzido e reposicionado em relao ao quadrado original vrias vezes at ficar bem pequeno, dando a impresso de um processo infinito. 3. Modifique o programa de grfico de barras da seo 6.3 de maneira que: a) as barras tenham espessura de 1 cm, afastadas umas das outras em 0,5 cm b) as barras estejam posicionadas na horizontal, sem o emprego do comando rotate c) as barras sejam substitudas por uma pequena circunferncia na altura indicada

57

Captulo 7
Fontes
Fontes constituem um assunto extenso na linguagem PostScript. Em verdade, a PostScript foi criada com a inteno de servir como instrumento de formatao de textos, e apenas secundariamente como ferramenta de desenho digital. Apesar da extenso do assunto e da profuso de comandos da linguagem PostScript que manipulam fontes, estudaremos neste captulo apenas aqueles que nos permitem imprimir letras na tela, e com isso nomear pontos, segmentos, circunferncias e todos os demais elementos grficos que servem nossa inteno de criar ilustraes matemticas.

7.1 Fontes PostScript

Quando instalamos o GhostScript em nosso computador, ganhamos gratuitamente tambm 35 fontes PostScript. Essa fontes, cujos nomes e formatos se encontram no Apndice C, sero usadas para nomearmos os elementos de nossos desenhos. Diferentemente das fontes que usamos em programas como Microsoft Word, OpenOffice e outros, as fontes PostScript no esto disponveis para escolha em um menu. O acesso e a manipulao dessas fontes feito atravs de uma srie de comandos especficos muito simples e intuitivos, que passaremos a explicar a seguir.

7.2 Principais comandos

Os principais comandos para operarmos com fontes em PostScript so 4: findfont, scalefont, setfont e show. Na maioria das vezes, so utilizados como se fossem um s, cada um responsvel por uma parte do trabalho de imprimir na tela uma letra ou um texto inteiro.

O comando findfont opera procurando no comutador a fonte desejada. Por exemplo, se desejamos utilizar a fonte Helvetica (da qual a fonte Arial uma cpia ligeiramente modificada), usamos o comando /Helvetica findfont A fonte Helvetica apenas uma das 35 fontes convencionais disposio do usurio no catlogo de fontes que acompanha o programa GhostScript, armazenada em um diretrio prprio. O Apndice C, que lista as 35 fontes disponveis, deve ser consultado para a escolha de outras fontes. Aps a determinao da fonte, ser necessrio dizer ao interpretador PostScript que tamanho ela ter. Usamos o comando scalefont, precedido do tamanho da fonte, em pontos, para essa funo: /Helvetica findfont 12 scalefont Observe que estipulamos a medida de 12 pontos para a fonte. Logo aps a escolha do tamanho, o comando setfont diz que aquela fonte, naquele tamanho, que ser usada no programa da em diante: /Helvetica findfont 12 scalefont setfont Agora estamos aptos a escrever com a fonte Helvetica, de tamanho 12, em qualquer lugar da tela. A linha acima, com os comandos findfont, scalefont e setfont costuma ser escrita como fizemos, como se fosse apenas um grande comando composto. Uma vez selecionada, escalada e estabelecida a fonte, como fazemos para escrever na tela? Primeiramente, devemos mover o lpis para a posio desejada: /Helvetica findfont 12 scalefont setfont 200 300 moveto Depois, colocamos nosso texto entre parnteses e adicionamos ao fim o comando show: /Helvetica findfont 12 scalefont setfont 200 300 moveto (Eis aqui um texto!) show

59

Com isso, devemos ver o texto Eis aqui um texto! localizado na posio (200, 300) de nossa folha. A posio (200, 300) se refere ao canto inferior esquerdo do texto todo. Para desenhar mais um texto, digamos, 15 pontos abaixo do texto anterior, basta movermos a ponta do lpis at l e escrever: /Helvetica findfont 12 scalefont setfont 200 300 moveto (Eis aqui um texto!) show 200 285 moveto (E eis aqui um outro texto!!) show O programa acima gera o seguinte texto:

figura 7.2-a como espervamos. No se esquea de que as coordenadas de cada linha, dadas como parmetros ao comando moveto, referem-se ao canto inferior esquerdo de cada texto. Em nosso caso, s beiradas de baixo das letras E. Podemos escrever o texto inclinado, ou em qualquer direo que desejarmos. Basta tratarmos o texto como um desenho qualquer.. Observe que o programa abaixo /Helvetica findfont 12 scalefont setfont 200 300 translate 45 rotate 0 0 moveto (Eis aqui um texto!) show ir imprimir Eis aqui um texto! nas coordenadas (200,300) agora a nova origem de nosso sistema girado 45o no sentido anti-horrio:

figura 7.2-b Um comando como, por exemplo, -1 1 scale, poder ser usado livremente, como em um desenho qualquer:

figura 7.2-c Enfim, sobre textos podemos operar exatamente como com qualquer outro elemento grfico.

7.3 Outros comandos

Uma variao interessante do comando show o comando ashow. Ele prov maior flexibilidade na disposio das letras do texto a ser exibido. O comando ashow recebe 3 argumentos, dois nmeros e o texto entre parnteses: 12 0 (Eis aqui um texto!) ashow e mostra na tela o mesmo texto, mas agora com as letras separadas 12 pontos umas das outras na direo horizontal:

figura 7.3-a Outro comando interessante o charpath, que mostra apenas o contorno da letra, sem preench-la por dentro. O programa seguinte 61

/Helvetica findfont 24 scalefont setfont 200 300 moveto (Eis aqui um texto!) true charpath stroke desenha apenas o contorno das letras, agora com o tamanho 24:

figura 7.3-b Observe que o comando charpath foi precedido no s do texto a ser impresso, mas da palavra true.

7.4 Exerccios
1. Desenhe um tringulo escaleno e rotule seus vrtices as letras A, B e C. 2. Coloque as letras X e Y nos eixos da figura 1.1. 3. Nomeie os elementos do Teorema de Tales dos exerccios da seo 2.4. 4. Coloque as letras A, B, C, D, e E nos vrtices da estrela da figura 6.1 5. Escreva seu nome espelhado.

Captulo 8
Acabamentos, cores e clipping
Neste captulo, vamos tratar de comandos que interferem diretamente na apresentao das ilustraes, principalmente no seu acabamento e na sua cor, levando uma qualidade esttica superior s ilustraes. Apresentamos tambm o conceito de clipping (recorte), em que usamos uma figura para delimitar outra.

8.1 Acabamentos
H trs tipos de terminaes para uma linha qualquer: linhas sem terminao, linhas com terminao arredondada e linhas com terminao quadrada, como nos mostra a figura a seguir:

figura 8.1-a A linha de baixo, com uma linha em branco bem no meio (representando o caminho abstrato que a PostScript faz antes de passar a tinta), mostra o padro de acabamento de linhas da linguagem PostScript. No necessrio nenhum comando para que as linhas fiquem assim. A linha do meio mostra extremidades arredondadas, o que aumenta um pouco o tamanho da linha.

63

A linha de cima mostra extremidades quadradas com um ligeiro acrscimo em seu tamanho. Tanto neste quanto no acabamento anterior, o caminho envolvido pela tinta, o que no acontece no acabamento padro. As diferenas entre um e outro acabamento so conseguidas com o comando setlinecap, com os argumentos 0 (o padro), 1 ou 2. Por exemplo, a linha do meio conseguida com o comando 1 setlinecap A escolha de um ou outro acabamento para a linha vai depender apenas dos efeitos estticos desejados. Linhas podem tambm apresentar os seguintes efeitos quando unidas umas s outras:

figura 8.1-b O tipo de unio de linhas na parte de baixo da figura o padro, a maneira que temos utilizado at agora. O tipo de unio de linhas no meio da figura mostra que a PostScript pode arredondar as beiradas de uma figura para ns. Finalmente, o tipo de unio de linhas do topo da figura mostra que a PostScript tambm pode cortar um pouco de cada linha, caso no desejemos que a unio seja pontuda ou arredondada. O comando que usamos para selecionar uma ou outra maneira de unir linhas o setlinejoin, com argumentos 0 (o padro), 1, ou 2. Por exemplo, se desejamos uma unio de linhas como aquela do topo da figura, escrevemos 2 setlinejoin Observe que o padro adotado pela PostScript (0 setlinejoin) aumenta ligeiramente o tamanho da figura. Isso ainda mais notvel quanto menor for o n gulo que uma linha faz com a outra. Nesses casos, o melhor usar 2 setlinejoin.

8.2 Cores
A PostScript usa o padro RGB (Red, Green, Blue Vermelho, Verde, Azul) para escolher a cor da tinta que usar. Esse padro dito aditivo, e cria cores a partir da mistura de vermelho, verde e azul. O comando que faz essa seleo o setrgbcolor, com trs argumentos, cada um variando de 0 a 1. Por exemplo, se desejamos uma linha com 10 pontos de espessura, mas da cor vermelha, devemos inserir no programa o seguinte comando 1 0 0 setrgbcolor o que produziria a figura abaixo:

figura 8.2-a Retome o programa que gerou a figura 3.2. Suponha agora que voc deseja um quadrado amarelo cercado por uma borda azul. No lugar de setgray, voc deveria usar, para o amarelo, 1 1 0 setrgbcolor e, para o azul, 0 0 1 setrgbcolor gerando a figura

figura 8.2-b 65

No padro RGB, o amarelo criado pela adio de vermelho e verde. Quais cores so criadas pela adio de vermelho e azul, e verde e azul? Teste com o programa acima, e confira. Observe tambm que escrever 0.5 0.5 0.5 setrgbcolor produz o mesmo efeito de 0.5 setgray. Cinzas so criados com a adio de partes iguais de vermelho, verde e azul. Existem outros sistemas de cores, mas importante conhecer bem o padro RGB, usado tambm nos cdigos de cores da linguagem HTML.

8.3 Clipping
Suponha que voc deseja cria uma figura como a seguinte

figura 8.3-a Como isso pode ser feito? O trabalho de calcular o tamanho de cada raio parece muito difcil. No seria melhor se desenhssemos primeiro

figura 8.3-b

e depois recortssemos um quadrado l de dentro? exatamente essa a ideia de clipping: um recorte. Primeiro desenhamos a figura com o programa newpath 200 200 translate 0 0 moveto 72 {0 0 moveto 70 0 rlineto 5 rotate} repeat stroke mas antes definimos a figura que recortar essa: 150 150 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto 0 -100 rlineto clip

% o comando clip no lugar de stroke

Observe que o quadrado que ser recortado termina com o comando clip, indicando que aquele um caminho de recorte, no um caminho sobre o qual ser passada tinta com o comando stroke. O programa completo fica 150 150 moveto 100 0 rlineto 0 100 rlineto -100 0 rlineto 0 -100 rlineto clip % o recorte

newpath % a figura 200 200 translate 0 0 moveto 72 { 0 0 moveto 70 0 rlineto 5 rotate} repeat stroke

67

O caminho de recorte pode ser qualquer desenho fechado. Basta declarlo logo no incio.

8.4 Exerccios
1. Retome os trs primeiros exerccios do capitulo 3 e substitua as linhas cinzas e pontilhadas por linhas coloridas sua escolha. 2. Escreva um texto de trs palavras, cada uma com uma cor diferente. 3. Desenhe a figura abaixo (use clipping):

Bibliografia
ADOBE SYSTEMS. PostScript Language: Tutorial and Cookbook. Reading: Addison-Wesley, 1985. ______________. PostScript Language Program Design. Reading: Addison-Wesley, 1988. ______________. PostScript Language Reference Manual. 3rd edition. Reading: Addison-Wesley, 1999. ______________. PostScript Language Reference Supplement. Reading: AddisonWesley, 1999. CASSELMAN, Bill. Mathematical Illustrations: A Manual of Geometry and PostScript. Cambridge: Cambridge University Press, 2005. ______________. Pictures and Proofs. In: Notices of AMS, volume 47, n. 10, pp. 1257-1266. Providence: AMS, 2000. HOLZGANG, David A. Understanding PostScript Programming. 2nd edition. Berkeley: Sybex Inc., 1988. McGILTON, Henry, e CAMPIONE, Mary. PostScript by Example. Reading: Addison-Wesley, 1992. REID, Glenn C. Thinking in PostScript. Reading: Addison-Wesley, 1990.

69

ROTH, Stephen. Real World Postscript: Techniques from Postscript Professionals. Reading: Addison-Wesley, 1988. SMITH, Ross. Learning PostScript: a Visual Approach. Berkeley: Peachpit Press, 1990.

Apndices
A - Preparando o ambiente
Para utilizar a PostScript em ambiente Windows, voc precisar de um editor de texto simples, como o Bloco de Notas, e os programas GhostScript e GSView. Esse programas sero usados em conjunto da seguinte maneira: o Bloco de Notas ser usado na escrita dos programas, e o GhostScript interpretar esses programas, transformando-os em desenhos que sero visualizados na tela do computador pelo GSView ou enviado diretamente para impresso em uma folha de papel. O Bloco de Notas vem com o Windows. Para instalar o GhostScript e o GSView, siga os passos abaixo: Acesse a pgina http://pages.cs.wisc.edu/~ghost/ Escolha a verso mais nova de "GPL GhostScript" e clique no link para acessar a pgina de downloads. No fim da pgina, na seo "Microsoft Windows", escolha a verso de 32 ou 64 bits, segundo a arquitetura de seu computador. Na dvida, escolha a verso de 32 bits. Clique no link e baixe o arquivo em uma pasta de seu computador. Volte pgina indicada e baixe tambm a mas recente verso do programa GSView. Acesse a pasta em que voc gravou os dois programas e instale PRIMEIRO o GhostScript. Basta dar dois cliques no arquivo baixado e selecionar "Setup" na primeira janela que aparecer, e em "Install" na segunda. O GhostScript ser instalado. Agora instale o GSView. D dois cliques no arquivo e clique em "Setup" na primeira janela que aparecer. Logo depois, haver uma nova janela para escolha da lngua. Escolha uma de sua preferncia (infelizmente, o programa no d a opo de escolher portugus). V clicando em "Next" a cada nova janela, e no final em "Exit".

71

Pronto! Voc j pode programar em Postscript e visualizar arquivos de extenso ps, a extenso em que devemos gravar os arquivo de agora em diante. Observe que os programas acima so distribudos pela internet. possvel que, no momento em que voc l este livro, a pgina onde esto disponveis tenha mudado de endereo. Com a ajuda de algum buscador de sua preferncia, procure o novo endereo, acesse a nova pgina, e siga os passos acima.

B - Trabalhando com PostScript

Existe uma metodologia simples para trabalharmos com a PostScript: Abra o Bloco de Notas e crie um arquivo com o nome que desejar, salvando-o com a extenso ps em algum diretrio de seu computador. Por exemplo, se voc deseja que seu grfico se chame meugrafico, salve-o como "meugrafico.ps". Mantenha o Bloco de Notas aberto. Abra o GSView. Clique no boto "OK" na janela que vai aparecer no centro da tela. Agora abra o arquivo "meugrafico.ps". Por enquanto, nada deve aparecer na tela.

Nesse momento, voc deve estar com duas janelas abertas no seu computador, uma para o Bloco de Notas e outra para o GSView. Para verificar se seu sistema est bem configurado, digite, no arquivo "meugrafico.ps", as seguintes linhas de cdigo: newpath 0 0 moveto 250 250 lineto stroke Salve o arquivo e observe o resultado no GSView. Uma linha diagonal deve aparecer no canto inferior esquerdo da pgina. Se necessrio, role a pgina para baixo ou diminua o zoom. Se voc ainda no viu a linha, aperte a tecla "R" para atualizar a pgina. Agora voc deve ter visto o grfico, no canto inferior esquerdo, e j sabe como proceder de agora em diante.

Trabalhando interativamente
Outra maneira de trabalhar com PostScript interativamente, digitando cada uma das linhas acima em um prompt de comandos do GhostScript. Nesse caso, voc precisar acrescentar o comando showpage no final do cdigo para que seu desenho seja mostrado em uma nova janela. Maximize essa nova janela para visualizar o seu desenho. Aps visto o desenho, aperte a tecla enter para vol tar ao prompt de comando. Proceda dessa maneira para testar trechos de seu cdigo. Esse mtodo, porm, recomendado apenas para testes rpidos, e no para desenvolvimento de longos desenhos.

73

C Fontes PostScript
As 35 fontes padronizadas da linguagem PostScript so:

Alm dessas, existem muitas outras fontes disponveis gratuitamente na internet. Verses recenes do programa Ghostscript trazem muitas outras no lista das aqui. A instalao de fontes PostScript est explicada em (Adobe Systems, 1999).

75

D - Criando um arquivo EPS

Arquivos EPS (Encapsulated PostScript) so extensamente utilizados na indstria grfica, pois permitem incorporar os grficos gerados em documentos diversos. Em particular, os arquivos EPS so a opo preferencial de grficos para o sistema de tipografia LaTeX, e por isso muito importantes na rea cientfica. A gerao de um arquivo EPS simples: Depois de visualizado o grfico desejado pelo GhostView, acesse o menu File e clique na opo PS to EPS Nas prximas duas caixas de dilogo que aparecerem, clique em Yes ou Sim, e escolha a pasta de destino onde ser gerado o arquivo EPS.

O arquivo EPS gerado pode ser convertido para outros formatos, segundo a convenincia. Um programa gratuito muito bom para visualizar e converter os arquivos EPS em um grande nmero de outros formatos o IrfanView, gratuitamente disponvel na internet.