linguagem c-introducao programacao aplicacoes graficas

- LINGUAGEM C –

INTRODUÇÃO À PROGRAMAÇÃO COM APLICAÇÕES GRÁFICAS

Nilson Luiz Maziero

Passo Fundo, setembro de 2008.

SUMÁRIO

Linguagem C – Introdução à programação com aplicações gráficas 2008

Nilson Luiz Maziero [email protected] 2

Introdução........................................................................................................................................ 4 Capítulo 1 ........................................................................................................................................ 5 1. Programação ............................................................................................................................... 5 1.1 Conceitos básicos de programação .......................................................................................... 5 1.2 Tipos de dados .......................................................................................................................... 5 1.3 Operações aritméticas............................................................................................................... 6 1.4 Operadores relacionais.............................................................................................................. 6 1.5 Operadores de incremento e decremento................................................................................. 6 1.6 Funções básicas........................................................................................................................ 7 1.6.1 Função clrscr( )....................................................................................................................... 7 1.6.2 Função printf( ) ....................................................................................................................... 7 1.6.3 Função getch( )....................................................................................................................... 7 1.6.4 Função scanf( )....................................................................................................................... 8 1.6.5 Função for( ) ........................................................................................................................... 9 1.6.6 Função while( ) ....................................................................................................................... 10 1.6.7 Função do while( ) .................................................................................................................. 11 1.6.8 Função if( )....else................................................................................................................... 12 1.6.9 Função delay( ) ....................................................................................................................... 12 1.6.10 Função sqrt( ) ....................................................................................................................... 13 1.6.11 Função sin().......................................................................................................................... 13 1.6.12 Função cos()......................................................................................................................... 13 1.6.13 Função tan() ......................................................................................................................... 13 1.6.14 Função atan() ....................................................................................................................... 13 1.7 Construção de funções do usuário............................................................................................ 13 1.8 Interface gráfica......................................................................................................................... 14 1.9 Funções gráficas ....................................................................................................................... 14 1.10 Programa de desenho de uma reta e um círculo .................................................................... 17 Capítulo 2 ........................................................................................................................................ 20 2. Aplicações ................................................................................................................................... 20 2.1Programa Parábola..................................................................................................................... 20 2.1.1 O que é uma parábola............................................................................................................ 20 2.1.2 Elementos da parábola........................................................................................................... 20 2.1.3 Processo de traçado............................................................................................................... 21 2.1.4 Desenvolvimento do algoritimo............................................................................................... 21 2.1.5 Fluxograma............................................................................................................................. 22 2.1.6 O programa básico ................................................................................................................. 22 2.1.7 O programa parábola – versão 1............................................................................................ 23 2.1.8 O programa parábola – versão 2............................................................................................ 24 2.1.9 O programa parábola – versão 3............................................................................................ 25 2.1.10 Comentários ......................................................................................................................... 26 2.2 Programa Elipse ........................................................................................................................ 27 2.2.1 O que é uma elipse................................................................................................................. 27 2.2.2 Elementos de uma elipse ....................................................................................................... 28 2.2.3 Processo dos círculos concêntricos ....................................................................................... 28 2.2.4 Desenvolvimento do algoritimo............................................................................................... 28 2.2.5 Fluxograma do programa ....................................................................................................... 29 2.2.6 Estrutura básica do programa ................................................................................................ 30 2.2.7 Desenvolvimento do programa............................................................................................... 31 2.2.8 Comentários ........................................................................................................................... 34 2.3 Programa espiral de Arquimedes .............................................................................................. 35 2.3.1 O que é uma espiral de Arquimedes ...................................................................................... 35 2.3.2 Elementos de uma espiral de Arquimedes............................................................................. 35 2.3.3 Processo de traçado............................................................................................................... 36 2.3.4 Desenvolvimento do algoritimo............................................................................................... 36 2.3.5 O programa ............................................................................................................................ 37 2.3.6 Comentários ........................................................................................................................... 38



2.4 Programa falsa espiral de dois centros ..................................................................................... 38 2.4.1 O que é uma falsa espiral de dois centros ............................................................................. 38 2.4.2 Elementos de uma falsa espiral de dois centros .................................................................... 38 2.4.3 Processo de traçado............................................................................................................... 39 2.4.4 Desenvolvimento do algoritimo............................................................................................... 39 2.4.5 Desenvolvimento do programa............................................................................................... 40 2.4.7 Comentários ........................................................................................................................... 41 2.4.8 Animação gráfica.................................................................................................................... 41 2.4.9 Comentários ........................................................................................................................... 43 2.5 Programa evolvente do círculo.................................................................................................. 43 2.5.1 O que é uma evolvente do círculo.......................................................................................... 43 2.5.2 Elementos de uma evolvente do círculo................................................................................. 44 2.5.3 Processo de traçado............................................................................................................... 44 2.5.4 Desenvolvimento do algoritimo............................................................................................... 44 2.5.5 O programa evolvente do círculo ........................................................................................... 45 2.5.6 Programa de traçado da evolvente do círculo com animação da reta ................................... 46 2.5.7 Comentários ........................................................................................................................... 48 2.6 Programa ciclóide regular.......................................................................................................... 48 2.6.1 O que é uma ciclóide regular.................................................................................................. 48 2.6.2 Elementos de uma ciclóide regular ........................................................................................ 48 2.6.3 Processo de traçado............................................................................................................... 49 2.6.4 Desenvolvimento do algoritimo............................................................................................... 49 2.6.6 Desenvolvimento do programa............................................................................................... 49 2.7 Jogo de tênis ............................................................................................................................. 53 2.7.1 O problema............................................................................................................................. 53 2.7.2 Solução do problema.............................................................................................................. 54 2.7.3 Entendimento da lógica do problema ..................................................................................... 54 2.7.4 Programa básico .................................................................................................................... 56 2.7.5 Programação .......................................................................................................................... 57 2.7.6 Definição do espaço de movimento da bola........................................................................... 57 2.7.7 Animação................................................................................................................................ 59 2.7.8 Implementação da raquete..................................................................................................... 65 Capítulo 3 ........................................................................................................................................ 73 3. Desafios....................................................................................................................................... 73 3.1 Problemas a serem resolvidos .................................................................................................. 73 BIBLIOGRAFIA................................................................................................................................ 74 ANEXO 1 – Definições matemáticas .............................................................................................. 75 ANEXO 2 – Código do teclado ....................................................................................................... 76 ANEXO 3 – O ambiente do Turbo C ............................................................................................... 77

INTRODUÇÃO



Considerando que o aprendizado de um assunto está relacionado ao interesse que o mesmo

desperta sobre o indivíduo e de como o assunto é apresentado. Também que imagens servem como atrativos para despertar a curiosidade para o aprendizado.

Assim, este trabalho enfoca o uso da computação gráfica como objeto de trabalho para a aprendizagem dos princípios de programação em linguagem C. O trabalho inicia com a introdução dos comandos básicos para a programação em linguagem C; comandos estes utilizados nos programas exemplo apresentados. Não é a intenção deste trabalho descrever um tratado sobre programação em linguagem C, mas mostrar que é possível e fácil de aprender a programar. Deste modo, os conteúdos são apresentados na forma de problemas gráficos a serem resolvidos, apresentando inicialmente um estudo sobre o problema a ser resolvido e as definições necessárias. Posteriormente, é apresentada a solução matemática para o problema, independente do programa de computador. Os problemas estudados são os traçados de curvas matemáticas conhecidas, mas que são analisadas sobre o enfoque gráfico, baseando-se nos conceitos de desenho geométrico. Juntamente com o trabalho, acompanham os programas executáveis para que o usuário possa ver os resultados a serem atingidos ao final do desenvolvimento de cada programa. Os programas fontes estão escritos no trabalho, o que obriga o leitor a digitá-los, e consequentemente a conhecer os comandos que foram utilizados, complementando assim a forma de aprendizagem. O leitor poderá observar que os programas desenvolvidos, podem ser reutilizados posteriormente com algumas alterações para o problema seguinte. Todos os programas são feitos em linguagem C para o ambiente DOS, onde pode-se utilizar o compilador TURBO C 3.0, encontrado na internet. Para outras informações e dúvidas a rsspeito desta apostila, pode-se contatactar através do email [email protected].

CAPÍTULO 1



1 - PROGRAMAÇÃO Nos dias atuais, o uso da informática está em todas as atividades humanas, desde atividades industriais, comerciais, educacionais e até mesmo dentro de nossas casas, onde vários tipos de equipamentos já a utilizam sem que sejam percebidos. Deste modo, é interessante um conhecimento básico de programação para que o indvíduo possa entender este assunto como algo possível de ser utilizado, e não algo do outro mundo, que somente está acessível aos indivíduos super dotados. Os itens de programação aqui apresentados são aqueles necessários ao entendimento dos programas apresentados. Deve-se lembrar que a matemática é uma parte muito importante para o entendimento e execução de um programa de computador. 1.1 - CONCEITOS BÁSICOS DE PROGRAMAÇÃO A programação é um conjunto de instruções, descrita numa linguagem que o sistema operacional do computador consegue analisar, e que são executadas sequencialmente, de acordo com o que o programador determinou. Para escrever um programa, é necessário conhecer uma linguagem, onde se utiliza um compilador para transformar o programa escrito numa linguagem compreensível pelo ser humano, numa linguagem dita “linguagem de máquina”. Esta linguagem de máquina é escrita num formato que o computador consegue entender e processar rapidamente, mas para o ser humano é difícil. A linguagem de programação é composta por uma série de comandos, que são ordens para a execução de determinadas instruções, que são aquelas operações específicas do programa que o programador descreve para obter um resultado desejado. Além dos comandos, outro elemento importante são as variáveis, que são responsáveis pelo armazenamento das informações, que podem ser numéricas (números inteiros, números reais, etc.) e de caracteres (letras e palavras). Na linguagem C, se uma palavra que representa uma variável é escrita em letras minúsculas, e a mesma palavra é escrita com a letra inicial maiúscula, elas são consideradas variáveis diferentes. Após cada instrução de programa, deve ser colocado um ponto e vírgula ( ; ). 1.2 - TIPOS DE DADOS Na linguagem C, há vários tipos de dados como int , float e char , etc. Os tipos de dados irão definir os tipos de variáveis que serão utilizadas no programa, o que é feito pelo usuário. A definição das variáveis é função específica dos dados utilizados para resolver o problema. int Define uma variável que armazena um número inteiro. Um número inteiro é definido como: int num; num é uma variável inteira. int controle = 2; controle é uma variável inteira e armazena o valor 2. float Define uma variável que armazena um número real. Um número real é definido como: float valores; valores é uma variável real. float numero = 3.23; numero é uma variável real e armazena o valor 3,23. Obs.: Ao escrever um programa com número real, a parte inteira é separa da parte decimal por um ponto (.), e não uma vírgula (,). char Define uma variável que armazena um caracter, que pode ser uma letra um número, ou uma cadeia de caracteres, que é uma palavra. Um char é assim definido: char nome; nome é uma variável que armazena um caracter. char letra = ‘d’; letra é uma variável que armazena um caracter e que é o d.



char numero = ‘5’; numero é uma variável que armazena um caracter e que é o 5. Não é interpretado como o número 5, não podendo ser usado para cálculos. char nomes[5] = “joao”; nomes é uma variável que armazena um vetor de caracteres (cinco posições), mas no máximo quatro caracteres podem ser colocados. 1.3 - OPERAÇÕES ARITMÉTICAS ( = ) Atribuição Este sinal corresponde a atribuir um valor da variável do lado direito do sinal para a variável do lado esquerdo. Onde: a = b; a variável a assume o valor da variável b, e a variável b ainda permanece com o referido valor. c = 5; a variável c passa a armazenar o valor 5. b = c/a; a variável b passa a assumir o valor da divisão da variável c pela variável a. x = y = z; as variáveis x e y recebem o valor da variável z. ( + ) Adição c = a + b; Executa a adição de duas variáveis, a e b, que são armazenadas em c. d = a + b + c; Executa a adição de três variáveis, a, b e c, que são armazenadas em d. ( - ) Subtração c = a - b; Executa a subtração de uma variável da outra (a e b), onde o resultado é armazenado em c. c = a – b - d; Subtrair a variável b da variável a, e deste resultado subtrair a variável d. ( * ) Multiplicação c = a * b; Efetua a multiplicação das duas variáveis a e b, sendo o resultado armazenado em c. c = a * b * d; Efetua a multiplicação das três variáveis e o resultado é armazenado na variável c. ( / ) Divisão c = a / b; Efetua a divisão da variável a pela variável b, sendo o resultado armazenado na variável c. No caso da variável que recebe o resultado de uma operação aritmética, esta deve ser do tipo que resulta o dado. Uma variável inteira (int) não pode receber um resultado que é uma variável de ponto flutuante (float), pois a parte fracionária será suprimida. 1.4 - OPERADORES RELACIONAIS Os operadores relacionais se utilizam para a análise comparativa entre as variáveis. ( > ) maior que (a > b) O valor da variável a é maior que o da variável b. ( >= ) maior ou igual a (a >= b) O valor da variável a é maior ou igual ao da variável b. ( < ) menor que (a < b) O valor da variável a é menor que o da variável b. ( <= ) menor ou igual a (a <= b) O valor da variável a é menor ou igual ao da variável b. ( == ) igual (a == b) O valor da variável a é igual ao valor da variável b. ( != ) diferente (a != b) O valor da variável a é diferente do valor da variável b. 1.5 - OPERADORES DE INCREMENTO E DECREMENTO ( ++ ) Operador de incremento. Adiciona uma unidade a variável inteira j. j++;



( -- ) Operador de decremento. Subtrai uma unidade a variável inteira j. j--; 1.6 – FUNÇÕES BÁSICAS São funções que executam um conjunto de instruções para o programador. Elas fazem parte da linguagem de programação utilizada. Na realidade, em diferentes linguagens de programação, os nomes das funções básicas são semelhantes. Isto permite extender o aprendizado de uma linguagem para outra. 1.6.1 - FUNÇÃO clrscr() Este comando limpa a tela quando no formato texto. O formato texto permite apenas que sejam escritos caracteres na tela. 1.6.2 - FUNÇÃO printf ( ) Permite apresentar na tela um resultado, que pode ser um número ou uma expressão. De acordo com o tipo de variável a ser escrita, deve-se especificar na função o seu formato. Especificação da variável: %d identifica uma variável inteira %f identifica uma variável real %c identifica uma variável caracter %s identifica uma uma variável que tem uma seqüência de caracteres Caracter de controle: \n nova linha – inicia o texto a ser escrito na linha seguinte formato: printf( < formato> , <var1>, <var2>,...); <formato> é o campo que especifica a impressão através de uma seqüência de caracteres que inicia e termina com aspas. <var1>,<var2>,... são expressões que serão impressas de acordo com a especificação feita em <formato>. printf ( “\nescreve o numero real: %f ”,numero ); Antes de imprimir na tela, deve ir para uma nova linha \n, imprime o texto escreve o numero real:, onde %f diz que a variável numero é um número real (float ), e imprime o que estiver armazenado na variável numero . printf ( “ escreve o numero inteiro: %d \n”,numero Inteiro ); onde %d diz que a variável numeroInteiro representa um número inteiro (int ). Depois de escrever deve pular para nova linha (\n), e imprime o que estiver armazenado na variável numeroInteiro . printf ( “ escreve caracteres: %s ”,nome ); onde %s diz que a variável nome representa um caracter (char ) ou uma cadeia de caracteres ( char [ ] ). Escreve sem mudar de linha o que estu\iver armazenado na variável nome . 1.6.3 - FUNÇÃO getch ( ) A função lê um caracter introduzido pelo teclado. Ao encontrar este comando, o programa para esperando que seja introduzido uma informação pelo teclado, por apenas um toque. O valor da tecla é capturado pela função, donde pode-se escrever: char Letra; Letra = getch ( ); O que permite que seja capturado o valor da tecla e transferido para a variável Letra . Ou simplesmente getch( ); para interromper o programa a espera do toque em uma tecla para continuar. //



A colocação de duas barras em seqüência, é interpretado que o que está escrito após as duas barras, e na mesma linha, não seja interpretado pelo programa. Utiliza-se para a colocação de comentários no programa, ou o cancelamento de partes do programa que não serão usados mas é interessante que estejam no arquivo do programa. Digite o programa a seguir e rode no compilador para ver o resultado (ver anexo 3). Programa exemplo 1 #include <stdio.h> //cabeçario necessário para identificar os comandos utilizados. #include <conio.h> void main() // indica a função principal { float numero = 3.8; int numeroInteiro = 5; char nome = ‘h’; char nomeCompleto[5] =“joao”; clrscr(); // limpa a tela printf ( “escreve o numero real: %f ”,numero ); printf ( “ \n escreve o numero inteiro: %d ”,numeroInteiro ); printf ( “ \n escreve caracter: %c ”,nome ); printf ( “ \n escreve nome completo: %s ”,nomeCompleto ); getch(); } // termino da funcao principal resultado: escreve o numero real: 3.8 escreve o numero inteiro: 5 escreve o caracter: h escreve nome completo: joao 1.6.4 - FUNÇÃO scanf ( ) Permite ler um conjunto de informações introduzidas pelo teclado. formato: scanf(<formato>,<end1>,<end2>,...); <formato> a especificação é semelhante ao printf( ); <end1>,<end2>,... correspondem aos endereços onde os dados devem ser lidos. int num; printf ( “tecle um numero”); scanf ( “%d”,&num); (informa o tipo de dado, captura o endereço da variável) O símbolo & na frente da variável permite que o programa leia o endereço da memória onde está armazenado o valor da variável. Programa exemplo 2 #include <stdio.h> #include <conio.h> void main() { float numero; int numeroInteiro; char nome; char nomeCompleto[10]; clrscr(); // limpa a tela



printf ( “ Digite um numero real: ” ); scanf ( “ %f”, &numero); printf ( “ Digite um numero inteiro: ” ); scanf ( “ %d”, &numeroInteiro); printf ( “ Digite um caracter: ” ); nome = getch(); printf ( “ \n Digite até 9 caracteres : ” ); scanf ( “ %s”, &nomeCompleto ); printf ( “\n\n O numero real e: %f ”,numero ); printf ( “ \n O numero inteiro e: %d ”,numeroInteiro ); printf ( “ \n O caracter e: %c ”,nome ); printf ( “ \n A sequencia de caracteres e: %s ”,nomeCompleto ); getch(); } resultado: Digite um numero real: 5.2 ( tecle o número 5.2 e tecle Enter) Digite um numero inteiro: 3 (tecle o número 3 e tecle Enter) Digite um caracter: a (tecle o caracter a e tecle Enter) Digite ate 9 caracteres: abcdefghi (tecle os caracteres abcdefghi e tecle Enter) O numero real e: 5.2 O numero inteiro e: 3 O caracter e: a A sequencia de 9 caracteres e: abcdefghi 1.6.5 - FUNÇÃO for( ) Permite que uma instrução ou um grupo de instruções seja executado um determinado número de vezes que é especificado. O número de vezes que as instruções devem ser executadas deve ser conhecido exatamente. int i; for(i=0;i<10;i++){printf(“\nola!);} Esta instrução diz para o comando for executar um laço com o que está dentro das chaves, iniciando o contador i=0; até que o contador i seja menor que dez (i<10), e a cada volta no laço acrescentar o valor um no contador i (i++) . A palavra ola! será escrita dez vezes uma abaixo da outra. O programa exemplo 3 faz com que o valor do contador i seja multiplicado por 2 a cada laço executado eplo comando for( ).

printf("\n i*2 = %d",i*2)

for (i=0; i<10 i++)

Programa exemplo 3 #include <stdio.h> #include <conio.h> void main ( ) { int i;



clrscr(); for (i=0; i<10; i++) { printf(“\n i*2= %d”,i*2 ); } getch(); } resultado: i*2= 0 i*2= 2 i*2= 4 i*2= 6 i*2= 8 i*2= 10 i*2= 12 i*2= 14 i*2= 16 i*2= 18 1.6.6 - FUNÇÃO while( ){ ... } Permite que uma instrução ou um grupo seja executado um certo número de vezes, enquanto uma determinada condição não ocorra. O teste é feito no início do laço. Comando utilizado quando não se conhece o número de interações a ser realizado. O comando testa a condição inicial entre parentesis e se for válida realiza os comandos que estão entre chaves {...}.

j++

j=0

while(j<10)

printf("ola!")

Programa exemplo 4 #include <stdio.h> #include <conio.h> void main ( ) { int j=0; clrscr(); while( j<10) { printf ( “ olá! ” ); j++; } getch(); } resultado: ola! ola! ola! ola! ola! ola! ola! ola! ola! ola!



Nesta aplicação, o comando while() fica repetindo a expressão ola enquanto a variável j tem um valor menor que dez (j<10). A cada repetição, j é incrementado de um (j++; ), sendo que j inicia com valor zero. Se a variável j fosse igual a 10 (j=10), seria impresso apenas uma vez. Como no comando printf() não há o caracter de controle \n, o resultado é impresso lado a lado. 1.6.7 - FUNÇÃO do { ... } while( ) Permite que uma instrução ou um grupo de instruções seja executado um determinado número de vezes, enquanto uma determinada condição não ocorra. O teste é feito no final do laço. Comando utilizado quando não se conhece o número de interações a ser realizado. Inicialmente são executados os comando que estão entre chaves {...}, e depois é realizado o teste do comando.

j=0;

do

printf("ola!");j++;

while(j<10)

Programa exemplo 5 #include <stdio.h> #include <conio.h> void main ( ) { int j=0; clrscr(); do { printf(“ olá!”); j++; } while( j<10); getch(); } resultado: ola! ola! ola! ola! ola! ola! ola! ola! ola! ola! Nesta aplicação, o comando while() fica repetindo a expressão olá enquanto a variável j tem um valor menor que dez ( j<10 ). A cada repetição, j é incrementado de um, sendo que j inicia com valor zero. Se a variável j fosse igual a 10 (j=10), não seria impresso nada. 1.6.8 - FUNÇÃO if ( ){...} ... else{...} Permite executar testes comparativos entre variáveis. if ( x > y) {printf ( “o valor de X é maior que o valor de Y”);} else { printf ( “o valor de Y é menor que o valor de X”);}



A instrução if( ) compara as variáveis X e Y. Se X é maior que Y, condição verdadeira, as instruções seguintes dentro das chaves {...} são executadas e ignora a opção else . Se o resultado da comparação é que Y é maior que X, a instrução seguinte é ignorada e passa para a instrução else , que será executado o que estiver dentro das chaves {...}. As instruções executadas diretamente pelo if ou else , são identificadas pelo conjunto de chaves. Depois do if( ) e dentro dos parenteses, podem se colocadas quaisquer tipos de comparação.

if

...

else{...}

{...}

Programa exemplo: #include <stdio.h> #include <conio.h> void main ( ) { int x =10, y = 5; clrscr(); if ( x > y) {printf ( “\n O valor de X é maior que o valor de Y.”);} else { printf ( “\n O valor de Y é menor que o valor de X.”);} x=5; y=10; if ( x > y) {printf ( “\n Agora o valor de X é maior que o valor de Y.”);} else { printf ( “\n Agora o valor de Y é menor que o valor de X.”);} getch(); } resultado: O valor de X é maior que o valor de Y. Agora o valor de Y é menor que o valor de X. 1.6.9 - FUNÇÃO delay(int) Esta função faz com que o programa pare um determinado tempo. Este valor de tempo é medido em milisegundos (1/1000 segundo), um segundo dividido em mil partes. Para que o programa pare durante meio segundo, deve-se escrever: delay(500); . Esta função pertence ao #include <dos.h> . 1.6.10 - FUNÇÃO double sqrt( double x ) Obtém o resultado da raiz quadrada de um número real de dupla precisão. Também pode ser colocada uma expressão matemática. Do resultado desta expressão será extraída a raiz quadrada, que é um número real de dupla precisão. sqrt( 16 ); Extrai a raiz quadrada do número 16. sqrt( a + b); Extrai a raiz quadrada do resultado da adição das variáveis a e b. 1.6.11 – FUNÇÃO double sin( double x ) (Anexo 1) Resulta no valor do seno de uma variável x, que é um número real de dupla precisão, resultando como valor um número real de dupla precisão. A variável x deve ser o valor do ângulo em radianos. sin(10); obtém o valor do seno de 10 (valor em radianos).



sin(a + b); Resulta no valor do seno da soma das variáveis a e b. 1.6.12 – FUNÇÃO double cos( double x ) (Anexo 1) Resulta no valor do cosseno de uma variável x, que é um número real de dupla precisão, resultando como valor um número real de dupla precisão. A variável x deve ser o valor do ângulo em radianos. cos(10); obtém o valor do cosseno de 10 (valor em radianos). cos(a + b); Resulta no valor do cosseno da soma das variáveis a e b. 1.6.13 – FUNÇÃO double tan( double x ) (Anexo 1) Resulta no valor da tangente de uma variável x, que é um número real de dupla precisão, resultando como valor um número real de dupla precisão. A variável x deve ser o valor do ângulo em radianos. tan(10); obtém o valor da tangente de 10 (valor em radianos). sin(a + b); Resulta no valor do seno da soma das variáveis a e b. 1.6.14 – FUNÇÃO double asin( double x ) Resulta no valor do arco seno de uma variável x, que é um número real de dupla precisão, resultando como valor um número real de dupla precisão. asin(10); obtém o valor do arco seno de 10, resultando no valor do ângulo em radianos. asin(a + b); Resulta no valor do arco seno da soma das variáveis a e b. 1.6.15 – FUNÇÃO double acos( double x ) Resulta no valor do arco cosseno de uma variável x, que é um número real de dupla precisão, resultando como valor um número real de dupla precisão. acos(10); obtém o valor do arco cosseno de 10, resultando no valor do ângulo em radianos. acos(a + b); Resulta no valor do arco cosseno da soma das variáveis a e b, valor resultante é do ângulo em radianos. 1.6.16 – FUNÇÃO double atan( double x ) Resulta no valor do arco tangente de uma variável x, que é um número real de dupla precisão, resultando como valor um número real de dupla precisão. atan(10); obtém o valor do arco tangente de 10, resultando no valor do ângulo em radianos. atan(a + b); Resulta no valor do arco seno da soma das variáveis a e b, valor resultante é do ângulo em radianos. Obs.: Ver no anexo 1, as definições matemáticas das funções acima. 1.7 - CONSTRUÇÃO DE FUNÇÕES DO USUÁRIO

São utilizadas quando é necessário repetir em vários trechos do programa o mesmo conjunto de instruções. Deste modo, este conjunto de instruções é transformado numa função e chamado sempre que necessário. float quad ( float x) { return ( x * x ); }

Esta função recebe a variável x, e multiplica por ele mesmo, resultando no quadrado do respectivo número, e devolvendo o resultado. A palavra float , antes do nome da função quad , indica que a função devolve um valor que é um número real. A expressão float x , indica que a função deve receber um valor que é um número real, que passa para dentro da função através da variável x. A expressão return , devolve o resultado do que estiver dentro do parentesis. Logo, pode-se escrever: float resultado; resultado = quad (5 ); Onde o resultado é o valor de 25. 1.8 - INTERFACE GRÁFICA A interface gráfica permite que sejam executados desenhos através do computador. Para isso, a interface deve ser inicializada através de algumas instruções adequadas.



Por exemplo, deve ser colocado um include especial no programa: #include <graphics.h> , que permite que as instruções gráficas possam ser interpretadas, transformando a tela para formato gráfico. A tela no formato gráfico é definida como tendo 640x480 pixels, que são pontos na tela que podem ser acesos. O sistema de coordenadas da tela gráfica é igual ao sistema de coordenadas cartesiano, possuindo os eixos X e Y. Porém, possui algumas alterações. Por exemplo, a origem está posicionada no canto esquerdo superior, sendo o eixo X positivo da esquerda para a direita. Já o eixo Y positivo, de cima para baixo (figura 1.1).

X

Y

(x1,y1)

(x2,y2)

x1

y1

640 pixels

480

pixe

ls

reta

raio

(x3,y3)

Figura 1.1 - Representação da tela gráfica.

O trecho de programa descrito a seguir, é o responsável pela inicialização do ambiente gráfico do compilador C (TURBO C 3.0). Se o teste if(errorcode != grOk) , resultar num valor diferente de grOk , que identificou corretamente os arquivos, o programa, emite mensagens a respeito do erro. No caso de erro, normalmente é a falta do arquivo egavga.bgi , que possui as informações gráficas. Sendo que o compilador não conhece o caminho (path) de onde ele está. É necessário indicar através da seqüência Options -Linker -Libraries e assinalar Graphics Library , no editor do TURBO C. //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); //inicialização com a indicação do caminho errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //========================================================= 1.9 – FUNÇÕES GRÁFICAS Alguns destes comandos são apresentados a seguir: FUNÇÃO line (x1,y1,x2,y2 ) Permite o traçado de uma reta conhecendo-se as coordenadas do ponto inicial (x1,y1) e do ponto final (x2,y2). Estes pontos tanto podem ser variáveis do tipo int ou float (figura 1.1).



(x1,y1)

(x2,y2)

FUNÇÃO circle ( x,y,r ) Permite traçar um circulo, conhecendos-se as coordenadas do centro (x,y) e o valor do raio r. Estes pontos tanto podem ser variáveis do tipo int ou float (figura 1.1).

raio

(x,y)

FUNÇÃO setcolor( int ) Este comando permite que a cor da linha seja alterada, para isso pode ser passada o nome da cor ou seu numero inteiro (int) correspondente. As cores podem ser indicadas por números ou palavras como descrito a seguir:

BLACKBLUEGREENCYANREDMAGENTABROWNLIGHTGRAYDARKGRAYLIGHTBLUELIGHTGREENLIGHTCYANLIGHTREDYELLOWWHITE

Comando Cor

14 WhiteYellow13

12 Light RedLight Cyan11

10 Light Green9 Light Blue

Dark Gray8Light Gray7Brown6Magenta5

4 Red3 Cyan

Green2Blue1Black0

# Nome da cor

pode-se escrever: setcolor(YELLOW); ou setcolor(14); FUNÇÂO setbkcolor(int) Função que seleciona a cor de fundo da tela. O número inteiro pode ser entre 0 e 15, ou o nome da cor. FUNÇÂO settextstyle(int fnt,int dir,int tc) Esta função permite configurar os valores para os atributos do texto visualizado em tela gráfica. fnt indica o estilo de fonte do texto; dir direção em que a fonte deve ser escrita. Na horizontal ou vertical. tc Tamanho do caracter visualizado na tela



As tabelas abaixo indicam os valores destas variáveis.

# fnt Nome Fonte de texto 0 DEFAULT_FONT Mapa de bits 8x8 1 TRIPLEX_FONT Triplex 2 SMALL_FONT Small 3 SANS_SERIF_FONT Sans-serif 4 GOTHIC_FONT Gothic 5 SCRIPT_FONT Script 6 SIMPLEX_FONT Simplex 7 TRIPLEX_SCR_FONT Triplex-script 8 COMPLEX_FONT Complex 9 EUROPEAN_FONT European 10 BOLD_FONT Bold

# dir Nome Direção 0 HORIZ_DIR Esquerda para a direita 1 VERT_DIR De baixo para cima

Valor de tc Efeito em outtext/outtextxy 0 Ampliação da fonte (stroked) usando fator de

ampliação default de caracteres (4) ou o tamanho do caractere definido pelo usuário (dado por setusercharsize)

1 Visualização de caracteres da fonte 8x8 (bit-mapped) em um retângulo da tela contendo 8x8 pixels



...... ............... 10 Visualização de caracteres da fonte 8x8 (bit-mapped)

em um retângulo da tela contendo 80x80 pixels FUNÇÃO putpixel(int x, int y, int cor) Função que coloca um pixel na tela nas coordenadas (x,y) e acordo com a cor desejada. FUNÇÃO setlinestyle(int style, unsigned pattern, in t thickness) Função de configuração do tipo de linha e da espessura Style – estilo , pode ser dado de acordo c om a tabela abaixo.

DescriçãoNome#

_ _ _ _ _ _

_..._..._..._

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

Efeito

Linha definida pelo usuárioUSERRBIT_LINE4Linha tracejadaDASHED_LINE3Linha tracejada pontilhada2 CENTER_LINELinha pontilhadaDOTTED_LINE1Linha cheia0 SOLID_LINE

Thickness – espessura , varia com a quantidade de pixels.

# Nome Descrição



1 NORM_WIDTH Espessura de 1 pixel 3 THICK_WIDTH Espessura de 3 pixels

FUNÇÃO closegraph( ) Função responsável pela finalização do ambiente gráfico e retorno à tela normal, tela de texto. 1.10 - PROGRAMA PARA O DESENHO DE UMA RETA E UM CÍR CULO O programa a seguir permite executar o desenho de uma reta e de um círculo, onde as coordenadas de cada um podem ser alteradas para verificar os resultados. //Nome do arquivo DESENHA.C #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> //============================================================= void main() //define a funcao principal { //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1); // retorna codigo de erro } //===================== inicia o programa propriamente dito =========== setcolor(YELLOW); //desenha em amarelo line(100,200,400,350); //desenha uma reta setcolor(RED); //desenha em vermelho circle(90,150,50); //desenha um circulo //===================== final do programa propriamente dito ============ getch(); // espera que seja tocada uma tecla closegraph(); //fecha o modo gráfico } //==================== final do arquivo ============================ 1.11 Interpretação do código Este conjunto de instruções abaixo, corresponde a informação ao compilador dos arquivos necessários ao funcionamento do programa #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <string.h> #include <stdio.h> #include <dos.h>



A função void main() , corresponde ao programa propriamente dito. As instruções escritas entre as duas chaves definirão o programa. void main() {//1 ............ ............ }//1 A seguir há um espaço onde são definidas as variáveis utilizadas no programa para a identificação do ambiente gráfico. As variáveis são definidas como números inteiros, int . //================= definicao das variaveis ================ int gdriver,gmode,errorcode; //=== variaveis graficas No espaço a seguir, estão definidas as variáveis utilizadas no programa, isto por uma questão de organização, pois na linguagem C, as variáveis podem ser criadas em qualquer parte do programa. //============ variaveis do programa ====================== //========== final das variaveis do programa ================== O conjunto de instruções a seguir permite inicializar o ambiente gráfico, de modo a localizar os arquivos necessários ao programa. Se forem encontrados os arquivos gráficos, o programa funcionará normalmente. Do contrário apresentará mensagens na tela como estas: Erro do adaptador grafico Falta o arquivo EGAVGA.BGI Pressione alguma tecla para retornar: //========== inicializa ambiente grafico ===================== gdriver = DETECT; initgraph(&gdriver, &gmode, "c:\\borlandc\\bgi"); errorcode = graphresult(); if (errorcode != grOk) { printf(" Erro do adaptador grafico \n"); printf("Falta o arquivo EGAVGA.BGI\n "); printf("Pressione alguma tecla para retornar:"); getch(); exit(1); // retorna codigo de erro } Neste próximo espaço, será escrito o programa propriamente dito. //============inicia o programa propriamente dito ========== //========== final do programa propriamente dito ============= Nas últimas linhas, o programa espera que seja tocada qualquer tecla, finalizando o ambiente gráfico e o programa. getch(); closegraph(); return 0; }//1 //================ final do arquivo ====================



Comentários: O programa desenha uma reta e um cículo, apresentando o formato de como deve ser escrito um programa gráfico. Na primeira linha do programa está escrito: //Nome do arquivo DESENHA.C , que é interpretado como um comentário pelo compilador devido as duas barras inclinadas (//), e apenas indica o nome do programa. Nas linhas a seguir, estão os #include , que especificam os arquivos do compilador C que devem ser agregados ao programa para que o compilador possa interpretar as instruções escritas. As linhas escritas em negrito correspondem ao programa propriamente dito. Resultado Após rodar o programa, aparecerá como resultado o desenho de uma reta em amarelo e de um círculo em vermelho. Experimente alterar o valor das coordenadas nas funções line() , circle() e setcolor() ; comparando os resultados obtidos.

CAPÍTULO 2 2. APLICAÇÕES Neste capítulo são implementadas as aplicações gráficas que envolvem a definição do problema, busca da solução, e a solução final que é o programa. 2.1 - PROGRAMA PARÁBOLA O desenho da parábola a ser desenvolvido é baseado no traçado gráfico que considera que um ponto (P) sobre a parábola possui a mesma distância ao foco e a diretriz (figura 2.1 (b)). 2.1.1 - O que é uma parábola Uma parábola é uma curva plana infinita resultante da seção de um cone reto por um plano paralelo a uma das geratrizes (figura 2.1 (a)). A parábola é o lugar geométrico dos pontos de um plano cuja relação entre a distâncias de cada ponto P da curva ao foco F e à diretriz é equidistante (igual) (figura 2.1(b)).



F

P

DIR

ET

RIZ

(a) (b)

Figura 2.1 - Cone truncado por um plano paralelo a uma geratriz; desenho da parábola. 2.1.2 - Elementos de uma prábola Uma parábola é composta por vários elementos. Os mais importantes para o desenvolvimento do problema são descritos a seguir (figura 2.2): a) Diretriz: Reta perpendicular ao eixo. b) Eixo: Segmento de reta que contém o vértice e o foco da parábola. c) Parâmetro: distância da diretriz ao foco. d) Foco (F): centro da curva. d) Vértice (V): ponto de cruzamento da curva com o eixo. e) Raios vetores: distância do foco ao ponto P da curva e da diretriz ao ponto P da curva. Obs.: Numa parábola deve ser observada a seguinte condição de distância entre o ponto P da curva com o foco F e a diretriz. FP = Pdiretriz (figura 2.2).

F

Pdiretriz

eixo

foco

vértice

raio vetor

parâmetro

Figura 2.2 - Elementos de uma parábola. 2.1.3 - Processo de traçado A parábola inicia-se com o traçado do eixo e da diretriz , que são perpendiculares entre si (ângulo de 90°). Após, deve-se marcar o vértice (V) da parábola e o foco (F) . Sendo que o vértice está localizado no ponto médio da distância entre o foco e a diretriz (figura 2.3 (a)). Como a distância de um ponto (P) da curva ao foco deve ser igual à distância do mesmo ponto (P) à diretriz, deve-se traçar retas paralelas a diretiz a partir do vértice da parábola. A distância entre as paralelas é arbitrária e, de preferência, que sejam iguais para facilitar o traçado. O próximo passo consiste em pegar a distância (d) (figura 2.3(a)) entre a diretriz e a primeira paralela, com o compasso, e colocar a ponta seca do compasso no foco e traçar um arco que corte a primeira paralela. A seguir pegar a distância da diretriz (d1) (figura 2.3(b)) até a segunda paralela. Colocar a ponta seca do compasso no foco e traçar arco para interseptar a segunda paralela, acima e abaixo do eixo. Novamente pegar a distância da diretriz (d2) (figura 2.3(c)) até a terceira paralela. Colocar a ponta seca do compasso no foco e traçar arco para interseptar a terceira paralela, acima e abaixo do eixo. Repetindo este procedimento, obtém-se os pontos por onde passa a parábola. A curva é então traçada a mão (figura 2.3(d)).



FV

d

d

dFV

d

d

d

d1

d1

d1

V F

d1d

d1

d

d1

d

d2

d2

d2 d2

FV

d1

d1d

d

d2

d1

d

d2

(a) (b) (c) (d)

Figura 2.3 - Processo de traçado da parábola 2.1.4 - Desenvolvimento do algoritmo Considerando a curva traçada, e analizando um ponto P(x,y) qualquer da curva (figura 2.4), pode-se verificar que a distância X da diretriz até ponto P(x,y) , será exatamente a distância do foco F até o ponto P(x,y) , onde (X = R). A coordenada Y deste ponto é resultante da dimensão do cateto maior do triângulo, e Dx, o cateto menor, será função da diferença entre a coordenada X e a distância do foco DF (figura 2.4).

Assim, a distância do vértice até a diretriz é dada por: DVDF

=2

Dx DF x= −| |, sendo o resultado em módulo. logo, Y R Dx= −2 2 Considerando (xo,yo) como pontos de referência do sistema, tem-se as coordendas dos seguintes pontos: V (xo + DF/2, yo) F (xo + DF, yo) P (x, y) Assim: P(x) = xo + DV + Dx P(y) = yo + Y sendo DeltaX um incremento para descrever a curva.

V F

X Y

R

Dx

DF

xo,yo

P(x,y)

Figura 2.4 - Modelo geométrico para definição do modelo matemático.

2.1.5 – FLUXOGRAMA LÓGICO DO PROGRAMA



O fluxograma descreve a lógica do programa, onde os retangulos descrevem as instruções e os losangos os comandos de teste (if() ) (figura 2.5).

STocoualgumatecla?

Desenha um trecho da curvaentre dois pontos

Calcula a posição do pontoP(x,y) da curva

Desenha a diretriz e o eixo

incrementa X

Armazena coordenadasX e Y

controle=1N

S

controle>0

N

fim

Parâmetros da parábola:

início

Figura 2.5 - Fluxograma do programa parábola.

2.1.6 - O programa básico O programa apresentado a seguir é uma estrutura que servirá para o desenvolvimento de todos os programas deste trabalho. A partir destes conceitos, serão implemtados os programa, sendo acrescentadas novas funções e instruções, e a cada novidade, na evolução de um programa, serão escritos em negrito para salientar. #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> //======================================================== void main()//define a funcao principal { //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar");



getch(); exit(1);// retorna codigo de erro } //============= inicia o programa propriamente dito =========== //========== final do programa propriamente dito =========== getch(); closegraph(); //fecha o formato grafico } //============= final do arquivo ================ 2.1.7 - O programa parábola - versão 1 A versão 1, é o programa básico acrescido das novas instruções para que sejam desenhados a diretriz, o eixo e o foco da parábola. //PROGRAMA PARABOLA.C #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> //============================================================= void main() //define a funcao principal { //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas float xo=50; //coordenada inicial X – cruzamen to diretriz-eixo float yo=240; //coordenada inicial Y – cruzame nto diretriz-eixo float distanciaFocal=30; // DF float focoX=xo+distanciaFocal; //coordenada X do fo co float focoY=yo; //coordenada Y do foco //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1); // retorna codigo de erro } //===================== inicia o programa propriamente dito =========== line(xo-50,yo,xo+680,yo); //desenha a diretriz line(xo,yo-240,xo,yo+240); //desenha o eixo circle(focoX,focoY,2); //desenha o foco //===================== final do programa propriamente dito ============ getch(); closegraph();//fecha o formato grafico } //==================== final do arquivo ================================== Comentários Após compilar e rodar o programa (ctrl-F9), basta tocar uma tecla para que o mesmo volte para o editor. Neste programa somente apareceu a estrutura para a construção da parábola, o eixo e a diretriz.



2.1.8 - O programa parábola - versão 2 Na versão 2, são acrescentadas as funções e variáveis para que seja desenhado ramo acima do eixo da parábola. //PROGRAMA PARABOLA.C #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= float quad(float x) // funcao para elevar ao quadrado um numero armazenado na variável X { return (x*x); } //============================================================= void main() //define a funcao principal { //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas float xo=50; //coordenada X inicial float yo=240; //coordenada Y inicial float distanciaFocal=30; float focoX=xo+distanciaFocal; //coordenada X do foco float focoY=yo; //coordenada Y do foco float x=xo+(distanciaFocal/2); //coordendada X in icial do ponto P da curva float y=yo; //coordendada Y inicial do ponto P da curva float xOld=x; // armazena a coordenada anter ior X float yOld=y; // armazena a coordenada anter ior Y float Dx; // Incremento de X //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1); // retorna codigo de erro } //===================== inicia o programa propriamente dito =========== line(xo-50,yo,xo+680,yo); //desenho da diretriz line(xo,yo-240,xo,yo+240); //desenho do eixo circle(focoX,focoY,2); //desenho do foco while(!kbhit( )) { x=x+1; Dx=abs(focoX-x); //calcula o novo valor de Dx y=yo-sqrt(quad(x-xo)-quad(Dx)); //calcula a coorden ada Y acima do eixo setcolor(YELLOW); //muda a cor para amarelo line(xOld,yOld,x,y); //desenha um trecho da cur va acima do eixo xOld=x; //armazena a coordenada X



yOld=y; // armazena a coordenada Y delay(10); //o programa para por 10 milisegundos } //===================== final do programa propriamente dito ============ getch(); closegraph(); } //==================== final do arquivo ================================== Comentários Nesta outra versão, foi introduzido o comando while( !kbhit( ) ) , que faz com que o programa fique num laço até que seja tocada uma tecla para então sair. Os novos includes: #include <math.h> é devido ao uso da função matemática sqrt() . #include <dos.h> é devido ao uso da função matemática delay() . 2.1.9 - O programa parábola - versão 3 Na versão 3, são acrescentadas as funções e variáveis para que seja desenhado ramo abaixo do eixo da parábola (figura 2.6). //PROGRAMA PARABOLA.C #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= float quad(float x) // funcao para elevar ao quadrado um numero aramzenado na variável X { return (x*x); } //============================================================= void main() //define a funcao principal { //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas float xo=50; //coordenada X inicial float yo=240; //coordenada Y inicial float distanciaFocal=30; float focoX=xo+distanciaFocal; //coordenada X do foco float focoY=yo; //coordenada Y do foco float x=xo+(distanciaFocal/2); //coordendada X inicial do ponto P da curva float y=yo; //coordendada Y inicial do ponto P da curva float xOld=x; // armazena a coordenada anterior X float yOld=y; // armazena a coordenada anterior Y float Dx; // Incremento de X float xold=x; // armazena variavel X para desenh ar abaixo do eixo float yold=y; // armazena variavel Y para desenh ar abaixo do eixo //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n");



printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== line(xo-50,yo,xo+680,yo); //desenho da diretriz line(xo,yo-240,xo,yo+240); //desenho do eixo circle(focoX,focoY,2); //desenho do foco while(!kbhit( )) { x=x+1; Dx=abs(focoX-x); //calcula Dx y=yo-sqrt(quad(x-xo)-quad(Dx)); //calcula a coordenada Y acima do eixo setcolor(YELLOW); //muda a cor para amarelo line(xOld,yOld,x,y); //desenha um trecho da curva acima do eixo xOld=x; //armazena a coordenada X yOld=y; // armazena a coordenada Y y=yo+sqrt(quad(x-xo)-quad(Dx)); //calcula a coord enada Y abaixo do eixo line(xold,yold,x,y); //desenha a curva abaixo do eixo xold=x; yold=y; delay(10); //o programa para por 10 milisegundos } //===================== final do programa propriamente dito ============ getch(); closegraph(); } //==================== final do arquivo ================================== 2.1.10 - Comentários Após rodar esta versão, experimente alterar o valor das variáveis para os novos valores escritos a seguir: float xo=80; //coordenada X inicial float yo=240; //coordenada Y inicial float distanciaFocal=70; Como resultado, surgirá uma parábola diferente. As variáveis xo e yo , permitem mudar a posição que a parábola será desenhada. A variável distanciaFocal , permite alterar a forma da parábola.



Figura 2.6 – Desenho resultante na tela.

2.2 - PROGRAMA ELIPSE O programa elipse apresenta o desenho de uma elipse. O algoritimo é desenvolvido baseado no processo dos circulos concêntricos. 2.2.1 - O que é uma elipse Uma elipse é uma curva plana fechada resultante da secção de um cilindro reto por um plano oblíquo a base do cilindro (figura 2.7(a)). Também pode ser obtida pela seção de um cone reto por um plano oblíquo a base (figura 2.7(b)).

ELIPSE

Figura 2.7 - Obtenção da elipse por secção de um sólido (a) cilindro - (b) cone.

2.2.2 - Elementos de uma elipse Uma elipse possui vários elementos a serem identificados para executar a sua representação gráfica. Aqui são apresentados os mais importantes, que são (figura 2.8): a) Diâmetro maior: Também chamado de eixo maior (distância AB ). b) Diâmetro menor: Também chamado de eixo maior (distância CD). Os diâmetros maior e menor são perpendiculares entre sí.



c) Vértices: Extremidades dos diâmetros maior e menor (pontos A, B C e D). d) Centro: Interseção dos diâmetros maior e menor (ponto O). e) Focos: Centro dos raios vetores. A elipse tem dois focos (F e F’). e) Raios vetores: Distância do foco a um ponto da curva (ponto P). Assim, pode-se escrever: AB = FP + F'P.

A B

C

D

F F'O

P

Figura 2.8 - Elementos da elipse.

2.2.3 - Processo dos circulos concêntricos O processo dos circulos concêntricos é um dos processos gráficos utilizado para desenhar uma elipse com instrumentos (figura 2.9). Os dois circulos concêntricos correspondem aos círculos traçados tendo como centro o centro da elipse e o raio da circunferência externa a metade do diâmetro maior e o da circunferência interna a metade do diâmetro menor (figura 2.9(a)). O próximo passo corresponde a dividir uma das circunferências em partes iguais, por exemplo, a maior. A partir de cada divisão, são traçados raios que cortam a circunferência interna (figura 2.9(a)). Traçando-se linhas horizontais a partir da interseção dos raios com a circunferência interna e retas verticais a partir da intersecção dos raios com a circunferência externa, resultam na interseção destas duas retas que resultam num ponto (P) pertencente a elipse (figura 2.9(b)). Realizando este traçado para cada divisão, é possível obter uma série de pontos da elipse. A união destes pontos resulta no traçado da curva (figura 2.9(c)).

BA

D

C

D

C

A B

D

C

BA

(a) (b) (c)

Figura 2.9 - Traçado da elipse pelo processo dos círculos concêntricos.

2.2.4 - Desenvolvimento do algoritmo O algoritmo é baseado no processo gráfico dos circulos concêntricos. Deste modo, deve-se aliar a matemática e o desenho geométrico para achar a solução do problema. Inicialmente, determina-se a posição de um ponto aleatório da elipse. Pode utilizar-se de um dos pontos determinado pelas divisões iguais da circunferência externa. Na figura 2.10, pode-se observar que a determinação das coordenadas P(x,y) de um ponto qualquer, a partir do centro da elipse, pode ser obtida considerando-se o ângulo (α), e a relação dele com os raios das circunferências interna e externa. Deste modo, fazendo-se variar o ângulo (α) de um valor conhecido, é possível determinar uma série de pontos da elipse e efetuar o seu traçado.



Assim, pode-se calcular as coordenadas do ponto P(x,y) (figura 2.10) através das seguintes relações: x = Raio . cos α (1) y = raio . sen α (2) P(x)=xo+x P(y)=yo+y

A

D

C

Bα y

x

raioR

aio

P(x,y)

(xo,yo)

Figura 2.10 - Determinação das coordenadas de um ponto da curva.

O traçado dos raios vetores, que são na realidade os elementos do traçado pelo processo do fio, são obtidos unindo cada foco ao ponto da curva em análise. Para isso, é necessário saber a posição de cada foco que é determinado da seguinte forma (figura 2.11):

FO AO CO= −2 2 (3) Onde FO é denominada de semi-distância focal (figura 2.11).

FA

O

D

F'

C

BAO = FC

Figura 2.11 - Determinação da posição dos focos.

2.2.5 - Fluxograma do programa O fluxograma apresenta a lógica de construção do programa. Inicialmente são definidas as variáveis do programa, calculados os parâmetros principais e desenvolvida a formulação para o desenho da curva (figura 2.12).



Desenha um trecho da curvaentre dois pontos

Calcula a posição do pontoP(x,y) da curva

Desenha os diâmetros e osfocos

Armazena coordenadasX e Y

varia ângulo alfa

N

início

Determina a posição dos focosF1 e F2

Calcula a semi distância focal

Parâmetros da elipse:Coordenadas do centro (x0,y0)Diâmetro MaiorDiâmetro MenorFocos - F1 e F2Ponto da curva P(x,y)

Tocoualgumatecla?

fimS

Figura 2.12 - Fluxograma do programa elipse.

2.2.6 - Estrutura básica do programa #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //======================================================== void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1); // retorna codigo de erro }



//============= inicia o programa propriamente dito =========== //========== final do programa propriamente dito =========== getch(); closegraph(); }//1 //============= final do arquivo ================ 2.2.7 - Desenvolvimento do programa Versão 1: Na Versão 1 é feito o desenho do diâmetro maior e do menor da elipse, tomando como referência o centro da elipse (cruzamento dos diametros (xo,yo)) Deste modo, para dertminar as duas retas a serem desenhadas a partir do centro tem-se (figura 2.13): A(x) = xo - DiametroMaior/2 A(y) = yo B(x) = xo + DiametroMaior/2 B(y) = yo C(x) = xo C(y) = yo - DiametroMenor/2 D(x) = xo D(y) = yo + DiametroMenor/2

xo,yoA

D

C

B

xo+DiametroMaior/2,yo

xo-DiametroMaior/2,yo

xo,yo-DiametroMenor/2

xo,yo+DiametroMenor/2

Figura 2.13 - Determinação dos vértices da elipse. #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= void main() //define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== int xo=320,yo=240; //coordenadas do centro da elipse int DiametroMaior=400,DiametroMenor=200; //diametr os da elipse //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar");



getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== line(xo-DiametroMaior/2,yo,xo+DiametroMaior/2,yo); //tracado do diametro maior line(xo,yo-DiametroMenor/2,xo,yo+DiametroMenor/2); //tracado do dismetro menor //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //==================== final do arquivo ================================== Versão 2: Na versão é determinada a posição dos dois focos F1 F2, a partir do centro da elipse. Isto pode ser visto na figura 2.11 e na equação 3. Onde F e F’, podem ser agora denominadas de F1 e F2. F1 = xo - FO (3) F2 = xo + FO (4) Nas respectivas posições, traça-se um círculo para localizar os focos. #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= float dobro(float x) { return( x*x); } //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== int xo=320,yo=240; //coordenadas do centro da elipse int DiametroMaior=400,DiametroMenor=200; //diametros da elipse float SemiDistanciaFocal; //distancia do centro da alipse até o foco float F1,F2; // focos //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito ===========



//calculo da semi distancia focal SemiDistanciaFocal=sqrt( dobro(DiametroMaior/2)-dob ro(DiametroMenor/2) ); //posicao dos focos no eixo X F1=xo-SemiDistanciaFocal; F2=xo+SemiDistanciaFocal; //desenho dos focos circle(F1,yo,2); //posição do foco circle(F2,yo,2); //posição do foco line(xo-DiametroMaior/2,yo,xo+DiametroMaior/2,yo); //tracado do diametro maior line(xo,yo-DiametroMenor/2,xo,yo+DiametroMenor/2); //tracado do dismetro menor //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //==================== final do arquivo ================================== Versão 3: Nesta versão, é executado o traçado da elipse, sendo esta executada através de pequenas retas. A metodologia utilizada para determinar as coordenadas da curva, está explicada no desenvolvimento do algoritmo, nas equações 1 e 2. #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= void main() //define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== int xo=320,yo=240; //coordenadas do centro da elipse int DiametroMaior=400,DiametroMenor=200; //diametros da elipse float SemiDistanciaFocal; // Distancia do centro da elipse até o foco float F1,F2; //posicao dos focos no eixo X float Dalfa,alfa=0; float xOld,yOld; //pontos anteriores int x,y; //pontos da curva //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro



} //===================== inicia o programa propriamente dito =========== //calculo da semi distancia focal SemiDistanciaFocal=sqrt( dobro(DiametroMaior/2)-dobro(DiametroMenor/2) ); //posicao dos focos no eixo X F1=xo-SemiDistanciaFocal; F2=xo+SemiDistanciaFocal; //desenho dos focos circle(F1,yo,2); circle(F2,yo,2); Dalfa=M_PI/36; //divide a circunferencia em 72 partes xOld=xo+DiametroMaior/2; // coordenada X inicial yOld=yo; // coordenada Y inicial setlinestyle(SOLID_LINE,SOLID_FILL,THICK_WIDTH); while(!kbhit()) { setcolor(WHITE); line(xo-DiametroMaior/2,yo,xo+DiametroMaior/2,yo); //tracado do diametro maior line(xo,yo-DiametroMenor/2,xo,yo+DiametroMenor/2); //tracado do dismetro menor alfa=alfa-Dalfa; x=xo+(DiametroMaior/2)*cos(alfa); // calculas as c oordenadas X y=yo+(DiametroMenor/2)*sin(alfa); // calculas as c oordenadas Y setcolor(YELLOW); line(xOld,yOld,x,y); // Desenha a elipse xOld=x; //armazenas pontos anteriores yOld=y; //armazenas pontos anteriores delay(40); //tempo de retardo } //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //==================== final do arquivo ================================== Basta rodar o programa e ver a formação de uma elipse pelo processo dos círculos concêntricos (figura 2.14). 2.2.8 - Comentários Após rodar esta versão, experimente alterar o valor das variáveis para os novos valores escritos a seguir: float DiametroMaior=200,DiametroMenor=400; Como resultado, surgirá uma elipse em posiçao diferente. As variáveis xo e yo , permitem mutar a posição que a elipse será desenhada. Experimente alterar DiametroMaior=300 e DiametroMenor=300.



Figura 2.14 – Desenho da elipse na tela.

2.3 - PROGRAMA ESPIRAL DE ARQUIMEDES O programa executa o traçado de uma espiral de arquimedes. 2.3.1 - O que é uma Espiral de Arquimedes A espiral de Arquimedes é a trajetória resultante do deslocamento de um ponto (P) com velocidade retilínea uniforme sobre uma reta que possui movimento de rotação uniforme em torno de um centro (figura 2.15).

Ponto P(x,y) em translação sobre a reta

reta em rotação

centro

Figura 2.15 - Espiral de Arquimedes.

2.3.2 - Elementos de uma espiral de Arquimedes (figura 2.16) a) Centro: centro de rotação da reta que descreve a espiral b) Espira: uma volta completa da reta que descreve a respiral. c) Passo: distância entre duas espiras.

passo

espira

centro

Figura 2.16 - Elementos da espiral de Arquimedes.



2.3.3 - Processo de traçado Inicia-se com o traçado de uma circunferência que vai determinar uma volta da espiral (uma espira). Divide-se esta circunferência num número de partes iguais (por exemplo 12 - figura 2.17(a)). O raio desta circunferência também deve ser dividido na mesma quantidade em que a circunferência foi dividida. Pelos divisões do raio, serão determinados os pontos por onde a curva passa (figura 2.17(b)). Para determinar os pontos da curva, deve-se traçar um arco que tem o centro da circunferência, e ser traçado no espaço da divisão da circunferência. Para cada nova divisão do raio, traça-se o arco que avança uma divisão da circunferência (figura 2.17(c)). Com a determinação dos pontos, traçar a curva que passa pelos respectivos pontos (figura 2.17(d)).

(a) (b) (c) (d)

Figura 2.17 - Traçado da espiral de Arquimedes.

2.3.4 - Desenvolvimento do algoritmo Considerando um ponto P(x,y) da espiral (figura 2.18), pode-se deduzir que a coordenada deste ponto é dependente do valor do raio vetor, do ângulo α, e do número de partes analisadas. O raio e o ângulo α são divididos em igual número de partes. Assim, o incremento do raio e do ângulo produrem os movimentos de rotação e translação.

Variação do raio: ∆raioraio

numeroPartes= raio raio raio= + ∆

Variação do ângulo: ∆α =°360

numeroPartes α α α= + ∆

Posição do ponto P a partir do centro da espiral: x raio= .cosα y raio= .senα Coordenadas a partir da origem do sistema: P(x) = CoordX + x P(y) = CoordY + y

α

ponto P(x,y)

(coordX,coordY)

Figura 2.18 - Parâmetros de cálculo da espiral de Arquimedes.



2.3.5 - O programa #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== float Passo=30; // Passo da espiral - Equivale ao raio da circunferencia de tracado float Dpasso=0.0; //variacao do passo float raio=0.0; // raio de desenho float alfa=0.0; // angulo de posicao float Dalfa=0.0; // incremento do angulo float x,y; // coordenadas do ponto da curva int divisao=24; // numero de divisoes em analise float coordX=320,coordY=240; // coordenadas de pos icao do centro da espiral float xo=coordX,yo=coordY; // coordenadas anterio res do ponto da curva //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== Dpasso=Passo/divisao; //calcula o incremento do ra io Dalfa=M_PI/divisao; //calcula o incremento do ang ulo alfa setlinestyle(SOLID_LINE,SOLID_FILL,THICK_WIDTH); setcolor(YELLOW); // especifica a cor amarela par a a curva while(!kbhit()) { raio=raio+Dpasso; //incrementa o raio alfa=alfa+Dalfa; //incrementa o angulo alfa x=coordX+raio*cos(alfa); //calcula coordenada X do ponto y=coordY+raio*sin(alfa); //calcula coordenada Y do ponto line(x,y,xo,yo); //desenha a curva xo=x; //armazena a coordenada antiga de X yo=y; //armazena a coordenada antiga de Y delay(50); // tempo de parada } //===================== final do programa propriamente dito ============ getch();



closegraph(); }//1 //================= final do arquivo ============================== 2.3.6 - Comentários O desenho obtido da espiral de Arquimedes está na figura 2.19. Após rodar o programa, experimente alterar o valor de algumas variáveis iniciais como: Passo=60; divisao=4;

Figura 2.19 – Desenho da Espiral de Arquimedes na tela.

2.4 - PROGRAMA FALSA ESPIRAL DE DOIS CENTROS 2.4.1 - O que é uma falsa espiral de dois centros Uma falsa espiral de dois centros é resultante da trajetória do movimento de um ponto em torno de dois ou mais centros, produzindo um movimento não uniforme. Considerando dois centros alinhados, e que um fio está enrolado nos dois pontos, ao serem desenrolado o fio e mantendo-o esticado, a trajetória da extremidade resulta na falsa espiral de dois centros. Se o fio estiver enrolado em torno de um polígono (mais de dois centros) resultará numa outra espiral (figura 2.20).

C1 C2

R1

R2

R3

Figura 2.20 – Falsa espiral de dois centros

2.4.2 - Elementos de uma falsa espira de dois centr os a) Centro b) Espira c) Passo d) Núcleo 2.4.3 - Processo de traçado



Inicia-se com o traçado a reta que passa pelos pontos P1 e P2 (figura 2.21), os quais determinam o centro da espiral (figura 2.21(a)). O traçado da espiral é feito considerando que é enrolado um fio flexível em torno dos pontos P1 e P2, feito o enrolamento no sentido horário, sendo que a ponta do fio coincide com o ponto P2.

O traçado da espiral corresponde ao desenrolamento do fio no sentido anti-horário (figura 2.21(b)), o que produz o arco descrito pelo raio R1. Que inicia no ponto P2, centro no pomnto P1, e termina no prolongamento da reta que passa pelos pontos P1 e P2.

Como o fio vai desenrolando, o centro de traçado do arco R2 (figura 2.21( c)) passa a ser o ponto P2. O arco é traçado até atingir o prolongamento da reta que passa pelos pontos P1 e P2. No momento em que o arco atinge esta reta, o centro do arco passa novamente para o ponto P1.

O arco de Raio R3 (figura 2.21(d)), possui agora o centro em P1, e é traçado de modo semelhante ao arco de raio R1. Se este processo for repedido, obtém-se o traçado de uma falsa espiral de dois centros.

(d)(c)(b)(a)

C2C1 C2C1 C2C1

R3

R2

R1

C2C1

R2

R1

Figura 2.21 – Traçado da falsa espiral de dois centros.

2.4.4 - Desenvolvimento do algoritmo O desenvolvimento do algoritmo corresponde a interpretação do traçado descrito anteriormente. A determinação do ponto P(x,y) corresponde ao ponto da curva necessário ao traçado da mesma. Para isso é necessário determinar as coordenadas do ponto P(x,y) para cada trecho de 180°, sendo que para cada trecho, o raio deve ser alterado e o centro de rotação também (figura 2.22). Para o trecho de 0° a 180°, o centro é C1 e o raio R1. Para 0°< θ<180° P1(x)=C1(x) + R1.cosθ P2(y)= C1(y) + R1.senθ Para 180°< θ<360° P1(x)=C2(x) + R2.cosθ P2(y)= C2(y) + R2.senθ Assim alternando a cada 180° o deslocamento do centro de rotação.

R2

R1

C1

C1

C2 C2

P1(x,y)

θ

θ

P2(x,y)

Figura 2.22 – desenvolvimento do algoritmo. 2.4.5 - Desenvolvimento do programa



Neste programa, é desenvolvido o traçado da falsa espiral de dois centros. #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== int C1x=300,C1y=240; //centro 1 da falsa espiral int C2x,C2y; //centro 2 da falsa espiral int Cx,Cy; //centro da espiral para calculo float distancia=20; //distancia entre centros float Raio=0; // raio de tra'cado float teta=0; // angulo de calculo float Px,Py; // coordenadas da curva float POx,POy; // coordenadas anteriores float Dteta=0; // incremento do angulo float controlaTeta=0; //controle do angulo a cada 180 graus float controlaCentro=1; // controla a alternacia dos centros //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\bc45\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== Dteta=M_PI/36; // incremento do angulo C2x=C1x+distancia; //coordenada X do segundo cent ro Cx=C1x; //coordenada X do centro generico C2y=Cy=C1y; // coordenada Y do segundo centro e do centro generico POx=C2x; // coordenadas antigas POy=C2y; Raio=Raio+distancia; while(!kbhit()) { if(controlaTeta>M_PI) { controlaTeta=0; Raio=Raio+distancia; if(controlaCentro==1){Cx=C2x;controlaCentro=-1;} else{Cx=C1x;controlaCentro=1;} } circle(C1x,C1y,2); circle(C2x,C2y,2);



Px=Cx+Raio*cos(teta); Py=Cy+Raio*sin(teta); teta=teta+Dteta; setcolor(YELLOW); line(POx,POy,Px,Py); setcolor(WHITE); POx=Px; POy=Py; controlaTeta=controlaTeta+Dteta; delay(120); } //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //==================== final do arquivo ================================== 2.4.6 - Comentários Após digitar o programa, execute para ver os resultados. Pode-se experimentar alterar os valores das variáveis C1x, C2y e distancia . Execute o programa e observe os resultados (figura 2.23).

Figura 2.23 – Falsa espiral de dois centros

2.4.8 - Animação Gráfica

Neste segundo programa são introduzidos conceitos de animação gráfica, de modo a representar o efeito do fio que está enrolado entre os pontos C1 eC2 e um ponto da curva P(x,y) (figura 2.22).

A animação gráfica consiste em desenhar um objeto numa posição, apagar, e redesenhar este mesmo objeto em outra posição ou sob nova configuração.

Em computação gráfica, o processo consiste em desenhar um objeto em qualquer cor, diferente da de fundo, redesenhar este objeto na mesma posição, somente que agora deve ser desenhado com a cor da tela de fundo. Após, desenhar o objeto na próxima posição ou configuração com a cor diferente da cor de fundo da tela.

Com a repetição deste processo, e com velocidade desejada, pode-se obter o efeito de animação. Há outros processos que podem ser utilizados. #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= void main()//define a funcao principal



{//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== int C1x=300,C1y=240; int C2x,C2y; int Cx,Cy; float distancia=50; float Raio=0,teta=0; float Px,Py; float POx,POy; float Dteta=0; float controlaTeta=0; float controlaCentro=1; int controle=0; // controla o início da animação //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\bc45\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== Dteta=M_PI/36; C2x=C1x+distancia; Cx=C1x; C2y=Cy=C1y; POx=C2x; POy=C2y; Raio=Raio+distancia; while(!kbhit()) { if(controle==1) { setcolor(BLACK); //troca a cor de desemho line(Cx,Cy,POx,POy); //desenha a linha agora com a cor de fundo da tela setcolor(WHITE); //troca a cor de desenho } controle=1; if(controlaTeta>M_PI) { controlaTeta=0; Raio=Raio+distancia; if(controlaCentro==1){Cx=C2x;controlaCentro=-1;} else{Cx=C1x;controlaCentro=1;} } circle(C1x,C1y,2); circle(C2x,C2y,2); Px=Cx+Raio*cos(teta); Py=Cy+Raio*sin(teta); teta=teta+Dteta;



setcolor(YELLOW); line(POx,POy,Px,Py); setcolor(RED); line(Cx,Cy,Px,Py); setcolor(WHITE); POx=Px; POy=Py; controlaTeta=controlaTeta+Dteta; delay(120); } //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //==================== final do arquivo ================================== 2.4.9 - Comentários Nesta versão final, o programa apresenta o desenho do traçado da falsa espiral de dois centros, e apresenta o raio vetor se movimentando, como se fosse um fio enrolado entre o centro da falsa espiral, como descrito no traçado. Experimente cancelar o seguinte trecho: /*if(controle==1) { setcolor(BLACK);//troca a cor de desemho line(Cx,Cy,POx,POy);//desenha a linha agora com a cor de fundo da tela setcolor(WHITE);//troca a cor de desenho }*/

Salve o programa e rode para observar o que acontece.

2.5 - PROGRAMA EVOLVENTE DO CÍRCULO 2.5.1 - O que é uma evolvente do círculo A evolvente do círculo é a curva resultante da trajetória de um ponto que está sobre uma reta, sendo que esta reta rola tangente, e sem escorregar, em torno de um círculo estacionário (figura 2.24). Esta curva é utilizada na construção do perfil de dentes de engrenagens.

P(x,y)

CÍRCULO DE BASE

RETA

EVOLVENTE

Figura 2.24 – Desenho de uma evolvente do círculo.

2.5.2 - Elementos de uma evolvente do círculo a) Círculo de base: Círculo sobre o qual a reta rola para gerar a evolvente do círculo (figura 2.25).



CÍRCULO DE BASE

P(x,y)

EVOLVENTE

FIO ESTICADO

Figura 2.25 – Considerando um fio esticado. 2.5.3 - Processo de traçado Como o movimento da reta em torno do círculo é um movimento uniforme, para se determinar os pontos da curva é necessário interromper este movimento de modo a determinar a posição do ponto em análise a cada instante. Para isso se determinam pontos de análise para o traçado. Assim, primeiramente a circunferência de base é dividida num determinado número de partes, sendo que quanto maior, maior a precisão do traçado (figura 2.65(a)). Se imaginarmos esta reta a partir de um fio enrolado em torno do da circunferência de base sendo desenrolado e mantido esticado, pode-se ver que ele será tangente a circunferência, e que seu comprimento é extamente igual ao comprimento do arco de circunferência ao qual estava enrolado. A partir das divisões da circunferência, são traçadas retas tangentes (figura 2.26(a)). Sobre as tangentes são marcados os comprimentos dos arcos, igual ao comprimento do arco entre cada divisão (figura 2.26(b)). A união dos pontos extremos sobre as tangentes, com uma curva, resulta na evolvente do círculo Figura 2.26(c)).

A A A

(a) (b) (c)

Figura 2.26 – Traçado da evolvente do círculo. 2.5.4 - Desenvolvimento do algoritmo O algoritmo deve determinar as coordendas do ponto P(x,y) para que possa ser traçada a evolvente do círculo (figura 2.27). P x raioVetor( ) .cos= β P y raioVetor( ) .sen= β

( )raioVetor comprimntoArco Raio= +2 2( )

comprimentoArco Raio= .α sendo α o ângulo que varia em função do problema.



β α θ= − onde θ =

arctg

comprimentoArco

Raio

O ponto P1(x1,y1) é dado por: P x Raio1( ) .cos= α P y Raio1( ) .sen= α

P(x,y)α

θ

βRaio

comprimento do arco

P1(x1,y1)

raioVetor

círculo de base

evolvente

Figura 2.27 – Especificação do algoritmo.

2.5.5 - O programa – Traçado da evolvente do círcul o #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= double quad(double x) //funcao do usuário { return (x*x); } //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== float Raio=20; //raio da circunferencia de base float raioVetor; //raio da curva float x,y; // coordenadas da curva float Dalfa; //incremento do angulo alfa float alfa=0,beta,teta; //angulos float comprimentoArco; float coordX=320,coordY=240; //coordenadas do ce ntro da circunferencia de base float xOld=coordX+Raio,yOld=coordY; // coordenadas anteriores da curva //=================== inicializa ambiente grafico ============== gdriver=DETECT;



initgraph(&gdriver,&gmode,"c:\\bc45\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== Dalfa=2*M_PI/48; alfa=Dalfa; while(!kbhit()) {

circle(coordX,coordY,Raio); //desenha o circulo d e base

comprimentoArco=Raio*alfa; // calcula o compriment o do arco desenrolado teta=atan(comprimentoArco/Raio); // calcula o angul o teta beta=alfa-teta; // calcula o angulo beta raioVetor=sqrt(quad(comprimentoArco)+quad(Raio)); //calcula o raio maior x=coordX+raioVetor*cos(beta); //determina o ponto X da curva y=coordY+raioVetor*sin(beta); //determina o ponto Y da curva setcolor(YELLOW); line(xOld,yOld,x,y);

xOld=x;yOld=y; //armazena as coordenadas ante riores alfa=alfa+Dalfa; // incrementa o angulo alfa delay(100); // tempo de parada

} //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //================== final do arquivo ============================== 2.5.6 - O programa – Traçado da evolvente do círcul o com animação da reta #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= double quad(double x) { return (x*x); } //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa===========



float Raio=20; //raio da circunferencia de base float raioVetor; //raio da curva float x,y; // coordenadas da curva float Dalfa; //incremento do angulo alfa float alfa=0,beta,teta; //angulos float comprimentoArco; float coordX=320,coordY=240; //coordenadas do centro da circunferencia de base float xOld=coordX+Raio,yOld=coordY; // coordenadas anteriores da curva float x1=xOld,y1=yOld; // coordenadas do ponto do raio sobre a circunferencia de base int controle=0; //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\bc45\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== Dalfa=2*M_PI/48; alfa=Dalfa; while(!kbhit()) { if(controle==1) { setcolor(BLACK); line(xOld,yOld,x1,y1); setcolor(WHITE); } circle(coordX,coordY,Raio); //desenha o circulo de base x1=coordX+Raio*cos(alfa); //calcula ponto X do rai o sobre a circunferencia de base y1=coordY+Raio*sin(alfa); //calcula o ponto Y do r aio sobre a circunferencia de base comprimentoArco=Raio*alfa; // calcula o comprimento do arco desenrolado teta=atan(comprimentoArco/Raio); // calcula o angulo teta beta=alfa-teta; // calcula o angulo beta raioVetor=sqrt(quad(comprimentoArco)+quad(Raio)); //calcula o raio maior x=coordX+raioVetor*cos(beta); //determina o ponto X da curva y=coordY+raioVetor*sin(beta); //determina o ponto Y da curva setcolor(RED); line(x,y,x1,y1); setcolor(YELLOW); line(xOld,yOld,x,y); xOld=x;yOld=y; //armazena as coordenadas anteriores alfa=alfa+Dalfa; // incrementa o angulo alfa delay(100); // tempo de parada controle=1; }



//===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //================== final do arquivo ============================== 2.5.7 - Comentários Realize alteração no valor das variáveis para verificar o tipo de resultado nos desenhos.

Figura 2.28 – Evolvente do círculo.

2.6 - PROGRAMA CICLÓIDE REGULAR 2.6.1 - O que é uma ciclóide regular Chama-se ciclóide a curva descrita por um ponto fixo num círculo móvel que rola sem escorregar sobre uma reta (figura 2.29). 2.6.2 - Elementos de uma ciclóide regular (figura 2.29) a) Círculo gerador: Círculo que rola sem escorregar sobre a reta diretora. b) Reta diretora: reta onde o circulo gerador rola.

D

reta diretora

circulo gerador

π.D

Figura 2.29 – Ciclóide regular. 2.6.3 – Processo de traçado O traçado é iniciado com o desenho de um círculo de diâmetro D (figura 2.30). De de uma reta com o comprimento da circunferência (πD), tangente a este círculo. Após deve-se dividir o c´rculo em partes iguais, neste caso em 12 partes.



A partir de cada divisão sobre a circunferência, traçar retas horizontais e paralelas a reta que possui o comprimento.

π.D π.D

Figura 2.30 Traçado inicial da ciclóide regular.

A reta que passa pelo centro do circuloo deve ser dividida em 12 partes iguais. Pegando o compasso com o raio do círculo diretor, deve-se colocá-lo em cada marcação e traçar um arco sobre uma linha horizontal, simulando o deslocamento do círculo. A união destes pontos resulta numa ciclóide regular.

π.D π.D

Figura 2.31 - Traçado final da ciclóide regular. 2.6.4 - Desenvolvimento do algoritmo O ponto (x1,y1) (figura 2.32) corresponde ao ponto inial do traçado da curva bemcomo o ponto de refeência para o desenvolvimento do algoritmo. O ponto (Cx,Cy) corresponde a um ponto qualquer que esta sobre o círculo que rola sobre a reta sem escorregar. Na realidade, corresponde a posição de uma das 12 divisões do círculo.

α(Cx,Cy)

(x,y)

(x1,y1)

Figura 2.32 – Coordenadas do ponto da ciclóide regular. 2.6.5 - Desenvolvimento do programa Versão 1 – Animação do deslocamento do círculo sobr e a reta #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h>



//============================================================= //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== float x1=50,y1=240; float x=x1,y=y1; int Raio=25; float Dx; float xOld=x; int controle=0; //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\bc45\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== Dx=2*M_PI*Raio/24; y=y1-Raio; while(!kbhit()) { if(controle==1) { setcolor(BLACK); circle(xOld,y1-Raio,Raio); setcolor(WHITE); } line(x1,y1,x1+500,y1); circle(x,y1-Raio,Raio); xOld=x; x=x+Dx; controle=1; delay(50); } //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //================== final do arquivo ============================== versão 2 – Simulação do movimento de rotação Para isso, é utilizada a representação de um ponto sobre a circinferência que troca de posição produzindo o efeito de rotação. #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h>



//============================================================= //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== float x1=50,y1=240; float x=x1,y=y1; float Raio=25; float Dx; float xOld=x; int controle=0; float cx=x1,cy=y1; float alfa,Dalfa; float cxOld=cx,cyOld=cy; //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\bc45\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== Dx=2*M_PI*Raio/24; y=y1-Raio; Dalfa=M_PI/24; alfa=0; while(!kbhit()) { if(controle==1) { setcolor(BLACK); circle(xOld,y,Raio); circle(cxOld,cyOld,2); setcolor(WHITE); } line(x1,y1,x1+500,y1); circle(x,y,Raio); setcolor(YELLOW); cy=y+Raio*cos(alfa); cx=x-Raio*sin(alfa); circle(cx,cy,2); xOld=x; cxOld=cx; cyOld=cy; x=x+Dx; delay(50); controle=1; alfa=alfa+Dalfa;



} //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //================== final do arquivo ============================== versão 3 – Traçado da curva #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #include <math.h> //============================================================= //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== float x1=50,y1=240; float x=x1,y=y1; float Raio=25; float Dx; float xOld=x; int controle=0; float cx=x1,cy=y1; float alfa,Dalfa; float cxOld=cx,cyOld=cy; //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\bc45\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== Dx=2*M_PI*Raio/24; Dalfa=2*M_PI/24; alfa=0; y=y1-Raio; while(!kbhit()) { if(controle==1) { setcolor(BLACK); circle(xOld,y,Raio); circle(cxOld,cyOld,2); setcolor(WHITE); } line(x1,y1,x1+500,y1); circle(x,y,Raio);



setcolor(YELLOW); cy=y+Raio*cos(alfa); cx=x-Raio*sin(alfa); circle(cx,cy,2); line(cx,cy,cxOld,cyOld); xOld=x; cxOld=cx; cyOld=cy; x=x+Dx; controle=1; delay(50); alfa=alfa+Dalfa; } //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //================== final do arquivo ==============================

Figura 2.33 - ciclóide regular.

2.7 - JOGO DE TENIS 2.7.1 - O PROBLEMA O problema a ser resolvido consiste da construção de um jogo. Neste jogo tem-se uma bola que se desloca com velocidade constante e que se movimenta em trajetória retilínea até atingir um obstáculo. Um obstáculo pode ser o limite do jogo (tela do computador delimitada por um retângulo), ou um objeto interno ao retângulo, que representa uma raquete para rebater a bola (figura 2.34). A raquete terá movimento vertical em dois sentidos (para cima e para baixo) continuamente, sendo que o jogador poderá alterar o sentido de deslocamento através do teclado(↑,↓). No momento em que a raquete atingir o limite superior ou inferior, o sentido de deslocamento deverá inverter, deslocando-se até o próximo limite, ou até que seja indicada outra ação. Ao atingir um obstáculo, a bola deve se deslocar numa direção a 90° a partir da trajetória que originou o choque com obstáculo (figura 2.34). Considerar que não há interferência do atrito e da energia cinética com relação ao choque.



Figura 2.34 - Ilustração do problema.

2.7.2 - SOLUÇÃO DO PROBLEMA A solução do problema passa por quatro etapas básicas: a) Entendimento da lógica do problema; b) Solução matemática em função das condições de contorno; c) Fluxograma da solução; d) Programação da solução do problema. A resolução será feita em etapas, sendo construído o programa à medida que determinadas situações são descritas e resolvidas, de modo a se tornar interessante, não ficando enfadonha toda a demonstração de uma teoria. 2.7.3 - ENTENDIMENTO DA LÓGICA DO PROBLEMA A lógica de funcionamento do problema pode ser analisada em partes. Deste modo, são apresentadas a seguir as situações limites da bola com relação ao limite do jogo. a) Bola choca-se com o limite esquerdo e direito Ocorre quando uma determinada situação física se apresenta. Deve-se saber, que a tela é representada por pixels, pontos que são acesos ou apagados durante o programa para representar as informações gráficas. Para executar um desenho, deve-se conhecer as coordenadas onde será realizada a representação gráfica. Deste modo, na figura 2.35, está representado o princípio da representação do sistema de coordenadas, onde a origem, se situa no canto esquerdo superior da tela. O sentido do eixo +X é representado da esquerda para a direita. O sentido +Y é representado de cima para baixo. Assim, o canto esquerdo superior é a origem (0,0) e canto direito inferior, é designado como (maxX,maxY), sendo os respectivos valores das variáveis dependentes do número de pixels da tela (p. exe: 640x480 pixels). Para representar internamente um retângulo, é necessário conhecer-se as coordenadas de dois de seus vértices. Assim o canto esquerdo superior foi definido com (10,10), e o canto direito inferior (maxX-10,maxY-10), mantendo uma margem constante de dez pixels em volta.

Figura 2.35 – Definição dos limites da tela.



Para definir os limites, deve-se considerar a bola nas duas posições extremas. Como a bola é representada a partir das coordenadas do centro (x,y) e do raio, estes fatores servirão de elementos para a análise da posição da bola durante o deslocamento. Na figura 2.36, estão representadas as situações. O limite esquerdo, é definido como sendo a distância da origem até a borda do retângulo, e mais o raio da do círculo. O limite direito, a dimensão máxima da tela em X, menos a borda do retângulo e menos o raio da circunferência. Estas duas considerações permitem definir qual a coordenada X limite que deve ser desenhado o círculo. Estas considerações geram as seguintes condições: Se X <=10, então se desloque na direção de X positivo (deslocamento para direita). Se X >= (maxX-10-Raio), então se desloque na direção de X negativo (deslocamento para esquerda).

Figura 2.36 – Condições limites na direção X.

b) Bola choca-se com o limite superior e inferior Na figura 2.37 estão descritas as situações em que a bola se choca com os limites do retângulo quando esta se desloca na direção vertical.

O limite superior, é definido como sendo a distância da origem até a borda do retângulo, e mais o raio da do círculo (figura 2.37). O limite inferior, a dimensão máxima da tela em Y, menos a borda do retângulo e menos o raio da circunferência. Estas duas considerações permitem definir qual a coordenada Y limite que deve ser desenhado o círculo. Estas considerações geram as seguintes condições: Se Y <=10, então se desloque na direção de Y positivo (deslocamento para baixo). Se Y >= (maxY-10-Raio), então se desloque na direção de Y negativo (deslocamento para cima).

Figura 2.37 – Condições limites na direção Y.



Ao se analisar simultaneamente os deslocamento nas direções X e Y, pode-se analisar uma trajetória onde X e Y variam continuamente. A execução do programa para representar esta primeira situação é dividida em etapas, pode-se enumerá-las a seguir: 1) Traçado do limite da tela; 2) Traçado do circulo que representa a bola; 3) Movimento da bola em X; 4) Movimento da bola em Y; 5) Estabelecimento das condições de contorno na direção X; 6) Estabelecimento das condições de contorno na direção Y; A seguir é apresentado o programa básico e após a evolução dos vários passos nos programas. 2.7.4 - PROGRAMA BÁSICO O programa a seguir deve ser copiado integralmente, respeitando se as letras são maiúsculas ou minúsculas. Os caracteres (//) definem que: o que estiver após ele, na respectiva linha, não será interpretado pelo programa. O arquivo a seguir, deve ser salvo como projeto1.c . Versão 1 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //==================== final do arquivo ================================== Ao rodar o programa, aparecerá uma tela escura, pois não foi ainda programado nada. Toque uma tecla para sair do programa.



2.7.5 - PROGRAMAÇÃO 2.7.6 - DEFINIÇÃO DO ESPAÇO DE MOVIMENTO DA BOLA

Para desenhar um retângulo utiliza-se da função (figura 2.38): rectangle(x1,y1,x2,y2) onde x1 e y1 correspondem as coordenadas do primeiro canto do retângulo. As coordenadas x2 e y2 as coordenadas do canto oposto.

Figura 2.38 – Definição de um retângulo.

Para a situação específica fica assim: Rectangle(10,10,maxX-10,maxY-10) Onde os valores de maxX e maxY, são capturados através das funções getmaxx() e

getmaxy() , que retornam as coordenadas máxima da tela. Ao mesmo tempo são criadas duas variáveis para armazenar estes valores, que são: maxX e maxY (figura 2.38). O programa deverá ser complementado com as linhas escritas em negrito. Versão 2 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y



rectangle(10,10,maxX-10,maxY-10); //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //==================== final do arquivo ================================== Ao rodar este programa, deverá aparecer o desenho de um retângulo na tela. A seguir toque qualquer tecla para o programa terminar. Para desenhar um círculo na tela, utiliza-se da função circle(x,y,r) , onde x e y correspondem as coordenadas do centro do círculo, e r o raio do círculo. Deste modo serão acrescentadas novas informações no programa que são o desenho do círculo e as variáveis x=100, y=100 e R=25. Isto permite desenhar o círculo numa posição específica da tela (figura 2.39).

Figura 2.39 – Definição do círculo.

Versão 3 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; int x=100,y=100,Raio=25; //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y



rectangle(10,10,maxX-10,maxY-10); circle(x,y,Raio); //===================== final do programa propriamente dito ============ getch(); closegraph(); }//1 //==================== final do arquivo ================================== Após salvar, ao rodar o programa deverá aparecer o desenho do respectivo círculo. 2.7.7 - ANIMAÇÃO A animação pode ser obtida através do processo de desenhar e apagar o desenho, e redesenhá-lo em outra posição. No computador, o processo de apagar corresponde a pintar o desenho da mesma cor da tela de fundo. Para isso são implementadas algumas seqüências a serem seguidas. Deve-se cancelar a função getch() . A função while() permite que o programa fique executando as instruções que estão dentro do laço, até que uma condição específica ocorra, neste caso, uma tecla seja tocada. Versão 4 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; int x=100,y=100,Raio=25; //coordenadas inicias do circulo int valorX=1,valorY=1; //valor de incremento de des locamento do circulo int controle=1; //variavel de controle para apaga r o circulo int xo,yo; //coordenadas anteriores do centro d o circulo //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y while(!kbhit()) //o programa fica dentro do laco at 'e uma tecla ser tocada { if(controle>1)



{ setcolor(BLACK); //pinta de preto circle(xo,yo,Raio); // desenha circulo em preto so bre o existente setcolor(WHITE); // pinta de branco } rectangle(10,10,maxX-10,maxY-10); x=x+valorX; //acrescenta valorX na coordenada X circle(x,y,Raio); xo=x; //armazena a variavel x em xo para poder a pagar o desenho yo=y; //armazena a variavel y em yo para poder a pagar o desenho controle++; //acrescenta um na variavel controle delay(4); // para o programa por um tempo de 4 mi lisegundos } //===================== final do programa propriamente dito ============ //getch(); closegraph(); }//1 //==================== final do arquivo ================================== Ao rodar o programa com a inserção das novas linhas, pode-se observar que o círculo se desloca para a direita e some da tela, isto ocorre porque não há limites para estabelecer o fim do movimento. O computador não reconhece o retângulo desenhado como um limite real. É necessário descrever este limite. Faça um teste cancelando toda a função if() , verá que serão desenhados um círculo após o outro, pois o anterior não será apagado. //if(controle>1) // após o primeiro desenho o prog rama começa apagar //{ //setcolor(BLACK); // define a cor de desenho como preta //circle(xo,yo,R); // desenha o círculo em preto s obre o existente //} Para determinar o limite de deslocamento da bola na direção de X, para a direita, deve-se observar a situação limite que ocorre quando o círculo toca o lado do retângulo (figura 2.40). Nesta condição, deve-se determinar qual é a posição das coordenadas do centro do círculo, pois são elas que controlam o círculo. Versão 5 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; int x=100,y=100,Raio=25; //coordenadas inicias do circulo int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo int controle=1; //variavel de controle para apagar o circulo int xo,yo; //coordenadas anteriores do centro do circulo //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT;



initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y while(!kbhit()) //o programa fica dentro do laco at'e uma tecla ser tocada { if(controle>1) { setcolor(BLACK); //pinta de preto circle(xo,yo,Raio); // desenha circulo em preto sobre o existente setcolor(WHITE); // pinta de branco } rectangle(10,10,maxX-10,maxY-10); if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar x=x+valorX; //acrescenta valorX na coordenada X circle(x,y,Raio); xo=x; //armazena a variavel x em xo para poder apagar o desenho yo=y; //armazena a variavel y em yo para poder apagar o desenho controle++; //acrescenta um na variavel controle delay(4); // para o programa por um tempo de 4 milisegundos } //===================== final do programa propriamente dito ============ //getch(); closegraph(); }//1 //==================== final do arquivo ================================== Ao rodar o programa, verá que o círculo ao tocar no lado direito do retângulo, imediatamente retornará em sentido contrário, em direção ao lado esquerdo, sendo que continuará indefinidamente, pois não foi estabelecido o respectivo limite. O retorno é feito através do incremento valorX que é –1. Para estabelecer o limite do lado esquerdo, deve-se observar a situação limite (figura 2.40), onde a coordenada X do centro do círculo é definida por: x = 10 + R (figura 2.40), onde se o valor de x for menor que esta coordenada, o círculo deve inverter o sentido de movimento, devido ao incremento valorX que é 1. Versão 6 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas



int maxX,maxY; int x=100,y=100,Raio=25; //coordenadas inicias do circulo int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo int controle=1; //variavel de controle para apagar o circulo int xo,yo; //coordenadas anteriores do centro do circulo //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y while(!kbhit()) //o programa fica dentro do laco at'e uma tecla ser tocada { if(controle>1) { setcolor(BLACK); //pinta de preto circle(xo,yo,Raio); // desenha circulo em preto sobre o existente setcolor(WHITE); // pinta de branco } rectangle(10,10,maxX-10,maxY-10); if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar if(x<=(10+Raio)){valorX=1;} //se atingir o lado esq uerdo, deve retornar x=x+valorX; //acrescenta valorX na coordenada X circle(x,y,Raio); xo=x; //armazena a variavel x em xo para poder apagar o desenho yo=y; //armazena a variavel y em yo para poder apagar o desenho controle++; //acrescenta um na variavel controle delay(4); // para o programa por um tempo de 4 milisegundos } //===================== final do programa propriamente dito ============ //getch(); closegraph(); }//1 //==================== final do arquivo ================================== Para obter o movimento da bola no sentido vertical, deve-se estabelecer os limites e o seu deslocamento. Cancele as condições de deslocamento horizontal e implemente as condições verticais. Versão 7 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h>



#include <dos.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; int x=100,y=100,Raio=25; //coordenadas inicias do circulo int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo int controle=1; //variavel de controle para apagar o circulo int xo,yo; //coordenadas anteriores do centro do circulo //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y while(!kbhit()) //o programa fica dentro do laco at'e uma tecla ser tocada { if(controle>1) { setcolor(BLACK); //pinta de preto circle(xo,yo,Raio); // desenha circulo em preto sobre o existente setcolor(WHITE); // pinta de branco } rectangle(10,10,maxX-10,maxY-10); //if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda //if(x<=(10+Raio)){valorX=1;} //se atingir o lado e squerdo, deve retornar para direita if(y>=(maxY-10-Raio)){valorY=-1;} //se atingir o la do inferior, retorna para cima if(y<=(10+Raio)){valorY=1;} //se atingir o lado sup erior, retorna para baixo //x=x+valorX; //acrescenta valorX na coordenada X y=y+valorY; //acrescenta valorY na coordenada Y circle(x,y,Raio); xo=x; //armazena a variavel x em xo para poder apagar o desenho yo=y; //armazena a variavel y em yo para poder apagar o desenho controle++; //acrescenta um na variavel controle delay(4); // para o programa por um tempo de 4 milisegundos } //===================== final do programa propriamente dito ============ //getch(); closegraph(); }//1 //==================== final do arquivo ==================================



O resultado obtido é o deslocamento da bola somente no sentido vertical dentro dos limites do retângulo. O próximo passo é liberara as linhas do cancelamento para o sistema funcionar completamente, com a bola se deslocando em 45° e chocando-se contra as paredes. Versão 8 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; int x=100,y=100,Raio=25; //coordenadas inicias do circulo int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo int controle=1; //variavel de controle para apagar o circulo int xo,yo; //coordenadas anteriores do centro do circulo //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y while(!kbhit()) //o programa fica dentro do laco at'e uma tecla ser tocada { if(controle>1) { setcolor(BLACK); //pinta de preto circle(xo,yo,Raio); // desenha circulo em preto sobre o existente setcolor(WHITE); // pinta de branco } rectangle(10,10,maxX-10,maxY-10); if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o l ado direito, deve retornar para esquerda if(x<=(10+Raio)){valorX=1;} //se atingir o lado esq uerdo, deve retornar para direita if(y>=(maxY-10-Raio)){valorY=-1;} //se atingir o la do inferior, retorna para cima if(y<=(10+Raio)){valorY=1;} //se atingir o lado sup erior, retorna para baixo x=x+valorX; //acrescenta valorX na coordenada X y=y+valorY; //acrescenta valorY na coordenada Y circle(x,y,Raio);



xo=x; //armazena a variavel x em xo para poder apagar o desenho yo=y; //armazena a variavel y em yo para poder apagar o desenho controle++; //acrescenta um na variavel controle delay(4); // para o programa por um tempo de 4 milisegundos } //===================== final do programa propriamente dito ============ //getch(); closegraph(); }//1 //==================== final do arquivo ================================== O resultado após rodar o programa é a obtenção do movimento da bola em um ângulo de 45°. O que é dado pelos valores de valoX=1 e valorY=1 . Se os valores das variáveis forem alterados, outras trajetórias serão obtidas. 2.7.8 - IMPLEMENTAÇÃO DA RAQUETE A raquete é representada por um retângulo. Ela terá movimento contínuo entre os lados inferior (y=maxY-10) e superior (y=10) do retângulo, sendo que o seu sentido poderá ser alterado pelo usuário quando desejar (figura 2.36). Para modelar esta situação, considerar o retângulo desenhado a partir da posição x=500 e y=y1 (onde y1 corresponde a uma posição y qualquer). Sendo o comprimento de 50 pixels e a largura de 10 pixels. O retângulo que representa a raquete será então representado por (figura 2.36).

figura 2.40 – Limites de deslocamento da raquete.

A raquete é então representada por: rectangle(500,y1,505,y1+50) Para ter o controle do sentido de deslocamento da raquete, ou seja, para cima ou para baixo, é necessário implementar as teclas UpKey ( ↑↑↑↑ ) para subir, DownKey ( ↓↓↓↓ ) para descer e da tecla Esc para sair do programa. Para isso são necessárias as seguintes definições: #define UpKey 80 #define DnKey 72 #define EscKey 27 Também é necessário acrescentar as seguintes variáveis do programa: int y1=10; int valorY1=20; int y1o; unsigned char ch; int teste=0;



A função while(!kbhit()) é substituida pela nova função while(teste= =0) , para permitir que ao ser tocada uma tecla, esta seja lida e efetuada a troca do sentido de movimento da raquete. Dentro da condição if(controle>1 ), é acrescentada a função rectangle(500,y1o,505,y1o+50); para que o retângulo (raquete) seja apagado. if(kbhit()!=0) Esta função é ativada quando uma tecla é tocada, de preferencia se forem uma das definidas DnKey, UpKey ou Esc. { ch=getch(); Esta função faz a leitura da tecla switch(ch) Função que permite a escolha de uma das opções descritas a seguir { case DnKey : valorY1=2; A raquete se desloca para cima dois pixels de cada vez break; case UpKey : valorY1=-2; a raquete se desloca para baixo dois pixels de cada vez break; case EscKey :teste=1; Sai do programa break; } } if(y1<=10){valorY1=1;} Se a raquete atingir esta posição, superior, ela inverte automaticamente o sentido de deslocamento if(y1>=(maxY-60)){valorY1=-1;} Se a raquete atingir esta posição, inferior, ela inverte automaticamente o sentido de deslocamento rectangle(500,y1,505,y1+50); Desenha o retângulo em branco y1o=y1; Guarda a posição do retângulo para depois apagar Para implementar o restante do programa, salve o programa projeto1.c, como projeto2.c. Como resultado, o retângulo se desloca somente para um lado e desaparece da tela. Se cancelar com Esc , e depois rodar novamente, utilize as teclas UpKey ( ↑↑↑↑ ) e DownKey ( ↓↓↓↓ ) para efetuar o controle. Pode-se observar que é possível mudar de direção o deslocamento da raquete. Porém, se deixar, a raquete sumirá da tela. Para isso, é necessário criar os limites verticais da tela para a raquete. Para que o retângulo fique se deslocando continuamente entre os lados superior e inferior do retângulo de contorno, é necessário definir os limites. Para isso são definidas duas condições: if(y1<=10) { valorY1=1;} limite do lado superior if(y1>= (maxY-60)) { valorY1=-1;} limite do lado inferior (ver figura 2.41) sendo valorY1 o incremento a ser dado no movimento da raquete. Veja o programa a seguir como fica.



Figura 2.41 – Posições extremas da raquete.

Versão 9 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #define UpKey 72 #define DnKey 80 #define EscKey 27 //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; int x=100,y=100,Raio=25; //coordenadas inicias do circulo int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo int controle=1; //variavel de controle para apagar o circulo int xo,yo; //coordenadas anteriores do centro do circulo int y1=10; //posicao inicial da raquete int y1o; //coordenada anterior da raquete int valorY1=1; //incremento de movimento da raquete unsigned char ch; //define uma variavel para recebe r o sinal do teclado int teste=0; //condicao para entrar no loop //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X



maxY=getmaxy(); //captura coordenada maxima de Y while(teste==0) //o programa fica dentro do laco at'e uma tecla ser tocada { if(controle>1) { setcolor(BLACK); //pinta de preto circle(xo,yo,Raio); // desenha circulo em preto sobre o existente rectangle(500,y1o,505,y1o+50); //desenha a raquete sobre a existente setcolor(WHITE); // pinta de branco } rectangle(10,10,maxX-10,maxY-10); if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar para direita if(y>=(maxY-10-Raio)){valorY=-1;} //se atingir o lado inferior, retorna para cima if(y<=(10+Raio)){valorY=1;} //se atingir o lado superior, retorna para baixo if(kbhit()) { ch=getch(); switch(ch) { case DnKey: valorY1=1; break; case UpKey: valorY1=-1; break; case EscKey: teste=1; break; } } rectangle(500,y1,505,y1+50); y1o=y1; y1=y1+valorY1; //acrescenta valorY1 na coordenada Y 1 x=x+valorX; //acrescenta valorX na coordenada X y=y+valorY; //acrescenta valorY na coordenada Y circle(x,y,Raio); xo=x; //armazena a variavel x em xo para poder apagar o desenho yo=y; //armazena a variavel y em yo para poder apagar o desenho controle++; //acrescenta um na variavel controle delay(4); // para o programa por um tempo de 4 milisegundos } //===================== final do programa propriamente dito ============ //getch(); closegraph(); }//1 //==================== final do arquivo ================================== Agora, a raquete fica limitada à região do retângulo. Para determinar a posição de choque da bola com a raquete, é necessário fixar as condições de quando e como ocorrerá o choque. O choque ocorrerá, considerando que a bola se desloca da esquerda para a direita, quando ela estiver a uma distância do raio com relação a raquete, ou seja, 475 pixels (figura 2.42). No sentido vertical, deve-se considerar que a bola somente colidirá com a raquete se as duas estiverem em posição adequada. Isto pode ser visto na figura 2.42, onde o centro da bola deve estar



abaixo da posição y1, e também acima da posição (y1+50). Se isto ocorrer, a bola deve retornar no sentido contrário do deslocamento em x. Deste modo pode ser escrita seguinte expressão.

if((x>=475 && x<= 476) && (y>=y1) && (y<=y1+50)){va lorX=-1;} Esta condição especifica que o centro do círculo (x,y) deva estar entre as coordenadas do lado da raquete (figura 2.42).

Figura 2.42 – Posições de controle da bola em relação a raquete.

Versão 10 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #define UpKey 72 #define DnKey 80 #define EscKey 27 //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; int x=100,y=100,Raio=25; //coordenadas inicias do circulo int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo int controle=1; //variavel de controle para apagar o circulo int xo,yo; //coordenadas anteriores do centro do circulo int y1=10; //posicao inicial da raquete int y1o; //coordenada anterior da raquete int valorY1=1; //incremento de movimento da raquete unsigned char ch; //define uma variavel para receber o sinal do teclado int teste=0; //condicao para entrar no loop //=================== final das variaveis do programa===========



//=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y while(teste==0) //o programa fica dentro do laco at'e uma tecla ser tocada { if(controle>1) { setcolor(BLACK); //pinta de preto circle(xo,yo,Raio); // desenha circulo em preto sobre o existente rectangle(500,y1o,505,y1o+50); //desenha a raqute sobre a existente setcolor(WHITE); // pinta de branco } if(y1<=10){valorY1=1;} //se bater no lado superior, inverte descendo if(y1>=(maxY-60)){valorY1=-1;} //se bater no lado i nferior, inverte subindo rectangle(10,10,maxX-10,maxY-10); if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar para direita if(y>=(maxY-10-Raio)){valorY=-1;} //se atingir o lado inferior, retorna para cima if(y<=(10+Raio)){valorY=1;} //se atingir o lado superior, retorna para baixo if(kbhit()) { ch=getch(); switch(ch) { case DnKey: valorY1=1; break; case UpKey: valorY1=-1; break; case EscKey: teste=1; break; } } rectangle(500,y1,505,y1+50); y1o=y1; y1=y1+valorY1; //acrescenta valorY1 na coordenada Y1 x=x+valorX; //acrescenta valorX na coordenada X y=y+valorY; //acrescenta valorY na coordenada Y circle(x,y,Raio); xo=x; //armazena a variavel x em xo para poder apagar o desenho yo=y; //armazena a variavel y em yo para poder apagar o desenho controle++; //acrescenta um na variavel controle



delay(4); // para o programa por um tempo de 4 milisegundos } //===================== final do programa propriamente dito ============ //getch(); closegraph(); }//1 //==================== final do arquivo ================================== Rodar o programa para obter os resultados. Versão 12 #include <graphics.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> #include <dos.h> #define UpKey 72 #define DnKey 80 #define EscKey 27 //============================================================= void main()//define a funcao principal {//1 //=================== definicao das variaveis ================== int gdriver,gmode,errorcode; //=== variaveis graficas int maxX,maxY; int x=100,y=100,Raio=25; //coordenadas inicias do circulo int valorX=1,valorY=1; //valor de incremento de deslocamento do circulo int controle=1; //variavel de controle para apagar o circulo int xo,yo; //coordenadas anteriores do centro do circulo int y1=10; //posicao inicial da raquete int y1o; //coordenada anterior da raquete int valorY1=1; //incremento de movimento da raquete unsigned char ch; //define uma variavel para receber o sinal do teclado int teste=0; //condicao para entrar no loop //=================== final das variaveis do programa=========== //=================== inicializa ambiente grafico ============== gdriver=DETECT; initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi"); errorcode=graphresult(); if(errorcode!=grOk) { printf("Erro do adaptador grafico\n"); printf("Falta o arquivo EGAVGA.BGI\n"); printf("Pressione qualquer tecla para retornar"); getch(); exit(1);// retorna codigo de erro } //===================== inicia o programa propriamente dito =========== maxX=getmaxx(); //captura coordenada maxima de X maxY=getmaxy(); //captura coordenada maxima de Y while(teste==0) //o programa fica dentro do laco at'e uma tecla ser tocada { if(controle>1) { setcolor(BLACK); //pinta de preto



circle(xo,yo,Raio); // desenha circulo em preto sobre o existente rectangle(500,y1o,505,y1o+50); //desenha a raqute sobre a existente setcolor(WHITE); // pinta de branco } rectangle(10,10,maxX-10,maxY-10); if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar para esquerda if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar para direita if(y>=(maxY-10-Raio)){valorY=-1;} //se atingir o lado inferior, retorna para cima if(y<=(10+Raio)){valorY=1;} //se atingir o lado superior, retorna para baixo if(kbhit()) { ch=getch(); switch(ch) { case DnKey: valorY1=1; break; case UpKey: valorY1=-1; break; case EscKey: teste=1; break; } } if((x>=475 && x<=476) && (y>y1) && (y<(y+50))){valo rX=-1;} if(y1<=10){valorY1=5;} //se bater no lado superior, inverte descendo if(y1>=(maxY-60)){valorY1=-1;} //se bater no lado i nferior, inverte subindo rectangle(500,y1,505,y1+50); y1o=y1; y1=y1+valorY1; //acrescenta valorY1 na coordenada Y1 x=x+valorX; //acrescenta valorX na coordenada X y=y+valorY; //acrescenta valorY na coordenada Y circle(x,y,Raio); xo=x; //armazena a variavel x em xo para poder apagar o desenho yo=y; //armazena a variavel y em yo para poder apagar o desenho controle++; //acrescenta um na variavel controle delay(4); // para o programa por um tempo de 4 milisegundos } //===================== final do programa propriamente dito ============ //getch(); closegraph(); }//1 //==================== final do arquivo ================================== Comentários Este programa apresenta princípios básicos de animação e controle do programa através do teclado. Este jogo simples demonstra claramente a lógica aplicada em computação para a representação de imagens simples. A raquete somente tem efeito quando a bola atinge ela de frente. Pense em como implementar um placar para que o jogador saiba o status do jogo.

CAPÍTULO 3



3. DESAFIOS O objetivo deste capítulo é apresentar uma série de problemas que podem ser resolvidos utilizando os conhecimentos adquiridos no estudo, para instigar o leitor a prosseguir nos estudos. 3.1 PROBLEMAS A SEREM RESOLVIDOS O objetivo desta lista de problemas, é instigar o leitor para os desafios de utilizar os conhecimentos adquiridos no estudo do conteúdo apresentado. A metodologia a ser utilizada, deve ser a mesma apresentada no livro, que acredito se adequar ao referido estudo. Partes dos programas desenvolvidos podem ser utilizadas nas soluções, o que torna mais rápida a programação, método muito utilizado de copiar partes já desenvolvidas em outros programas. PROBLEMA 1: Desenvolver o programa de traçado de uma hipérbole. PROBLEMA 2: Desenvolver o programa de traçado de uma ciclóide alongada. PROBLEMA 3: Desenvolver o programa de traçado de uma ciclóide encurtada. PROBLEMA 4: Desenvolver o programa de traçado de uma epiciclóide alongada. PROBLEMA 5: Desenvolver o programa de traçado de uma epiciclóide encurtada. PROBLEMA 6: Desenvolver o programa de traçado de uma hipociclóide encurtada. PROBLEMA 7: Desenvolver o programa de traçado de uma hipociclóide alongada. PROBLEMA 8: Desenvolver o programa de traçado de uma de uma parábola com a animação do desenho dos raios vetores. PROBLEMA 9: Programa de animação para o processo de traçado do raios vetores para a elipse. PROBLEMA 10: Desenvolver o programa para o traçado de uma hipociclóide regular PROBLEMA 11: Melhorar o programa jogo de tênis: a) Incluir o deslocamento para a esquerda e para a direita da rquete; b) um contador de pontos para cada vez que a bola bate no lado direito da tela. BIBLIOGRAFIA Arakaki, Reginaldo; Arakaki, Julio;Angerami, Paulo Mattos; Aoki, Osvaldo Luis; Salles, Djalma de Souza;.-2.ed.-Rio de Janeiro:LTC-Livros Técnicos e Científicos Ed.,1990. Carvalho, Benjamin de A.. Desenho Geométrico. Editora Ao Livro Técnico. São Paulo, 19..



Fechine, J. Machado, Queiroz, José E. R. Gráficos em C usando Turbo C 3.0. Notas de aula. Januário, Antônio Jaime. Desenho Geométrico. Florianópolis: Ed. da UFSC, 2000. Mizrahi, Victorine Viviane. Treinamento em linguagem C. São Paulo: McGraw-Hill, 1990. Rangel, Alcyr Pinheiro. Curvas. Universidade Federal do Rio de Janeiro, Rio de Janeiro,1982. ANEXO 1 – DEFINIÇÕES MATEMÁTICAS

Função seno: senα =b

c

Função cosseno: cosα =a

c



Função tangente: tanα =b

a

Pitágoras : 222 bac +=

cb

aα

ANEXO 2 – CÓDIGO DO TECLADO

Tecla Retorno Tecla Retorno Tecla Retorno Tecla Retorno 1 2 A 30 N 49 Esc 1 2 3 B 48 O 24 Home 71 3 4 C 46 P 25 End 79



4 5 D 32 Q 16 PgUp 73 5 6 E 18 R 19 PgDn 81 6 7 F 33 S 31 Seta Alto 72 7 8 G 34 T 20 Seta Baixo 80 8 9 H 35 U 22 Seta Esquerda 75 9 10 I 23 V 47 Seta Direita 77 0 11 J 36 X 45 Enter 28 K 37 W 17 Tab 15 L 38 Y 21 Barra Espaço 57 M 20 Z 44

Tecla Retorno Tecla Retorno Tecla Retorno Apenas Alt+ Ctrl+

F1 59 F1 104 F1 94 F2 60 F2 105 F2 95 F3 61 F3 106 F3 96 F4 62 F4 107 F4 97 F5 63 F5 108 F5 98 F6 64 F6 109 F6 99 F7 65 F7 110 F7 100 F8 66 F8 111 F8 101 F9 67 F9 112 F9 102 F10 68 F10 113 F10 103 F11 87 F12 88

ANEXO 3 - O AMBIENTE DO TURBO C 3.0 O TURBO C 3.0 é um compilador simples e versátil, ideal para aqueles que pretendem iniciar-se no aprendizado da linguagem C. O objetivo desta seção é passar ao usuário os conhecimentos mínimos necessários para que possa editar, compilar e executar os programas deste livro. Para maiores informações, pode-se utilizar o próprio Help do TURBO C, ou consultar Arakaki, 1990.



As opções do menu (figura 1) são dispostas horizontalemnte na parte superior do editor. Para desativar um menu basta teclar ESC.

Figura 1 – Tela básica do Turbo C 3.0.

Na figura 2, a opção ativa do menu é o FILE, o qual abre um menu em cascata que oferece uma série de opções de comando. Os seguintes comandos estão disponíveis: NEW: Carrega no editor um novo arquivo cujo nome é NONAME.CPP; OPEN: Carrega um arquivo na janela de edição. Se o arquivo não existir será criado; SAVE: Salva o arquivo que está sendo editado e, caso o arquivo tenha o nome NONAME.CPP, um novo nome de arquivo será solicitado para o arquivo ser salvo; SAVE AS: Salva o arquivo que está sendo editado com um novo nome a ser especificado; SAVE ALL: Salva o arquivo que está sendo editado; CHANGE DIR: Muda o diretório corrente; PRINT: Imprime o arquivo que está sendo editado; DOS SHELL: Retorna ao sistema operacional sem abandonar o Turbo C; QUIT: Abandona o Turbo C e retorna ao sistema operacional. As opções apresentadas junto aos comandos no menu, podem ser ativadas através das teclas especificadas.



Figura 2 – Menu File

Na figura 3, estão localizados os comandos da janela do editor. Estes comandos permitem

movimentar a tela. O cursor pode ser movimentado através das teclas de seta.

Figura 3 – Comandos da janela.

Na figura 4 está representado o arquivo NONAME01.CPP aberto para a edição.



Figura 4 – Editor criado através do new.

Na figura 5 tem-se: No menu EDIT, tem-se os seguintes comandos: UNDO: Retorna a ultima edição; REDO: Avança uma edição eliminada; CUT: Retira um trecho do texto marcado; COPY: Copia um trecho de texto marcado; PASTE: Cola em posição indicada no trecho de texto cortado como comando CUT; CLEAR: Elimina um trecho de texto marcado;

Figura 5 – Menu Edit.

Na figura 6, tem-se: No menu RUN, tem-se os seguintes comandos:



RUN: Executa o programa; PROGRAM RESET: Cancela o programa em execução; GO TO CURSOR: Executa o programa até o comando onde se encontra o cursor na tela de edição; TRACE INTO: Permite entrar numa função para depurar; STEP OVER: Executa uma função sem depurá-la.

Figura 6 – Menu Run

Na figura 7, são apresentados alguns comandos do menu COMPILE: COMPILE: Compila o programa verificando os erros; MAKE: Constrói o arquivo executável.

Figura 7 – Menu Compile.

Na figura 8, são apresentados alguns comandos do menu HELP:



CONTENTS: Ajuda do do compilador. Basta clicar em cima do texto colorido e teclar Enter. INDEX: Permite efetuar a busca com o nome dos comandos de programação a partir da digitação do nome do comando.

Figura 8 – Menu Help.

CONSTRUINDO UM PROGRAMA Inicialmente o programa deve ser editado, ou seja, digitado todo o texto que compreende o programa conforme está descrito no livro. Logo após o início da digitação, salvar o arquivo no diretório escolhido com um nome definido. É um bom costume salvar o arquivo de tempos em tempos (tecle F2). Após o arquivo ser todo digitado, salve-o, e tecle Ctrl-F9, ao mesmo tempo. Deste modo o arquivo será compilado e executado. Se o arquivo contiver erros, será apresentada uma janela na parte inferior do editor, que colocando o cursor e clicando sobre uma linha que indica erro, será apresentado no editor o onde está o erro encontrado na compilação. Corrija o erro e rode tecle Ctrl-F9 para compilar o programa novamente. Os erros normalmente são devidos a digitação. Olhe com atenção o que está escrito no programa no livro e o que foi digitado. Podem também ocorrer erros devido ao erro de lógica ou devido a configuração do compilador.

linguagem c-introducao programacao aplicacoes graficas

Documents