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
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.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.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.5 O programa ............................................................................................................................ 37
2.3.6 Comentários ........................................................................................................................... 38
Nilson Luiz Maziero nmaziero@terra.com.br 2

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.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.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.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
nmaziero@terra.com.br.
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”,numeroInteiro ); 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( ).
for (i=0; i<10 i++)
printf("\n i*2 = %d",i*2)
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=0
while(j<10)
printf("ola!")
j++
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.
else{...} if
{...}
...
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
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
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).
io
ra
Y (x3,y3)
y1
(x2,y2)
480 pixels
(x1,y1)
reta
x1
640 pixels
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).

(x2,y2)
(x1,y1)
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).
io
ra
(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:
# Nome da cor Comando Cor
0 Black BLACK
1 Blue BLUE
2 Green GREEN
3 Cyan CYAN
4 Red RED
5 Magenta MAGENTA
6 Brown BROWN
7 Light Gray LIGHTGRAY
8 Dark Gray DARKGRAY
9 Light Blue LIGHTBLUE
10 Light Green LIGHTGREEN
11 Light Cyan LIGHTCYAN
12 Light Red LIGHTRED
13 Yellow YELLOW
14 White WHITE
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
...... ...............
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, int 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.
# Nome Descrição Efeito
0 SOLID_LINE Linha cheia
1 DOTTED_LINE Linha pontilhada ...............
2 CENTER_LINE Linha tracejada pontilhada
3 DASHED_LINE Linha tracejada ______
4 USERRBIT_LINE Linha definida pelo usuário _..._..._..._
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ÍRCULO
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===========

gdriver=DETECT;
initgraph(&gdriver,&gmode,"c:\\borlandc\\bgi");
if(errorcode!=grOk)
{
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 <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 ================

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();
}
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)).

DIRETRIZ
P
(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).
P raio vetor
diretriz
foco
eixo
F
vértice
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)).

d2 d2
d1 d1 d1
d d d d
V F V F V F V F
d d d d
d1 d1 d1
d2 d2
d d d
d d1 d1 d1
d2 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).
DF
Assim, a distância do vértice até a diretriz é dada por: DV =
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.
P(x,y)
X Y
R
V F Dx
xo,yo
DF
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).
início
Parâmetros da parábola:
Desenha a diretriz e o eixo
Tocou S
alguma fim
tecla?
incrementa X
Armazena coordenadas Calcula a posição do ponto

XeY P(x,y) da curva
N
controle=1 controle>0
Desenha um trecho da curva

entre dois pontos
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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
//========================================================
void main()//define a funcao principal
{

gdriver=DETECT;
if(errorcode!=grOk)
{

getch();
}
//============= 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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
//=============================================================
{
float xo=50; //coordenada inicial X – cruzamento diretriz-eixo

float yo=240; //coordenada inicial Y – cruzamento diretriz-eixo
float distanciaFocal=30; // DF
float focoX=xo+distanciaFocal; //coordenada X do foco
float focoY=yo; //coordenada Y do foco
gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
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
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.


Na versão 2, são acrescentadas as funções e variáveis para que seja desenhado ramo acima do
eixo da parábola.
#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);
}
//=============================================================
{
float xo=50; //coordenada X inicial

float yo=240; //coordenada Y inicial
float distanciaFocal=30;
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
gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
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 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
delay(10); //o programa para por 10 milisegundos
}
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().

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).
#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);
}
//=============================================================
{

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 desenhar abaixo do eixo
float yold=y; // armazena variavel Y para desenhar abaixo do eixo
gdriver=DETECT;
if(errorcode!=grOk)
{


getch();
}
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 coordenada 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

}

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:
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.
C
P
A B
F O
F'
D
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)).
C C C
A B A B A B
D D D
(a) (b) (c)
Figura 2.9 - Traçado da elipse pelo processo dos círculos concêntricos.

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
C P(x,y)
Raio
io
ra
y
α
A
B
(xo,yo) x
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 2 − CO 2 (3)
Onde FO é denominada de semi-distância focal (figura 2.11).
C
=F
AO
A B
F O
F'
D
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).

início
Parâmetros da elipse:
Coordenadas do centro (x0,y0)
Diâmetro Maior
Diâmetro Menor
Focos - F1 e F2
Ponto da curva P(x,y)
Calcula a semi distância focal
Determina a posição dos focos

F1 e F2
Tocou S
alguma fim
tecla?
varia ângulo alfa
Desenha os diâmetros e os
focos
Armazena coordenadas Calcula a posição do ponto

XeY P(x,y) da curva
Desenha um trecho da curva

entre dois pontos
Figura 2.12 - Fluxograma do programa elipse.
2.2.6 - Estrutura básica do programa
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//========================================================
{//1

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}

//============= 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,yo-DiametroMenor/2
C
xo+DiametroMaior/2,yo
A B
xo,yo
xo-DiametroMaior/2,yo
D
xo,yo+DiametroMenor/2
Figura 2.13 - Determinação dos vértices da elipse.
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
{//1
int xo=320,yo=240; //coordenadas do centro da elipse
int DiametroMaior=400,DiametroMenor=200; //diametros da elipse

gdriver=DETECT;
if(errorcode!=grOk)
{

getch();
}
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

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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
float dobro(float x)
{
return( x*x);
}
//=============================================================

{//1

float SemiDistanciaFocal; //distancia do centro da alipse até o foco
float F1,F2; // focos

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}

//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); //posição do foco
circle(F2,yo,2); //posição do foco


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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
{//1

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

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();

}
//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);
alfa=alfa-Dalfa;
x=xo+(DiametroMaior/2)*cos(alfa); // calculas as coordenadas X
y=yo+(DiametroMenor/2)*sin(alfa); // calculas as coordenadas 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

}
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).
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).
centro
Ponto P(x,y) em
translação sobre a reta
reta em rotação
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.
centro
espira
passo
Figura 2.16 - Elementos da espiral de Arquimedes.


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.

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.
raio
Variação do raio: ∆raio = raio = raio + ∆raio
numeroPartes
360°
Variação do ângulo: ∆α = α = α + ∆α
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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
{//1

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 posicao do centro da espiral
float xo=coordX,yo=coordY; // coordenadas anteriores do ponto da curva

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
Dpasso=Passo/divisao; //calcula o incremento do raio
Dalfa=M_PI/divisao; //calcula o incremento do angulo alfa
setlinestyle(SOLID_LINE,SOLID_FILL,THICK_WIDTH);
setcolor(YELLOW); // especifica a cor amarela para 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

}
getch();

closegraph();
}//1
//================= final do arquivo ==============================
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).
R3
R1
C1 C2 R2
Figura 2.20 – Falsa espiral de dois centros
2.4.2 - Elementos de uma falsa espira de dois centros

a) Centro
b) Espira
c) Passo
d) Núcleo

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.
R3
R1
R1
C1 C2 C1 C2 C1 C2 C1 C2 R2
R2
(a) (b) (c) (d)
Figura 2.21 – Traçado da falsa espiral de dois centros.

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.

P1(x,y)
R1 C1
θ
C1 C2 C2
θ
R2
P2(x,y)
Figura 2.22 – desenvolvimento do algoritmo.


Neste programa, é desenvolvido o traçado da falsa espiral de dois centros.
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
{//1

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
gdriver=DETECT;
initgraph(&gdriver,&gmode,"c:\\bc45\\bgi");
if(errorcode!=grOk)
{
getch();
}
Dteta=M_PI/36; // incremento do angulo
C2x=C1x+distancia; //coordenada X do segundo centro
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;
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);
}

getch();
closegraph();
}//1
//==================== final do arquivo ==================================
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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================

{//1

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
gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
Dteta=M_PI/36;
C2x=C1x+distancia;
Cx=C1x;
C2y=Cy=C1y;
POx=C2x;
POy=C2y;
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;
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);
}

getch();
closegraph();
}//1
//==================== final do arquivo ==================================
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.
EVOLVENTE
CÍRCULO DE BASE
P(x,y)
RETA
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).

EVOLVENTE
CÍRCULO DE BASE
P(x,y)
FIO ESTICADO
Figura 2.25 – Considerando um fio esticado.

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.
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) 2 + ( Raio) 2

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

 comprimentoArco 
β = α −θ onde θ = arctg 
 Raio 
O ponto P1(x1,y1) é dado por:
P1( x ) = Raio.cosα P1( y ) = Raio.sen α
círculo de base
raioVetor
β
α θ
P(x,y)
Raio
evolvente
comprimento
P1(x1,y1)
do arco
Figura 2.27 – Especificação do algoritmo.
2.5.5 - O programa – Traçado da evolvente do círculo
#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);
}
//=============================================================
{//1

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
gdriver=DETECT;

if(errorcode!=grOk)
{
getch();
}
Dalfa=2*M_PI/48;
alfa=Dalfa;
while(!kbhit())
{
circle(coordX,coordY,Raio); //desenha o circulo 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(YELLOW);
line(xOld,yOld,x,y);
xOld=x;yOld=y; //armazena as coordenadas anteriores

alfa=alfa+Dalfa; // incrementa o angulo alfa
}
getch();
closegraph();
}//1
//================== final do arquivo ==============================
2.5.6 - O programa – Traçado da evolvente do círculo com animação da reta
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
double quad(double x)
{
return (x*x);
}
//=============================================================
{//1

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;

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
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 raio sobre a circunferencia de base

y1=coordY+Raio*sin(alfa); //calcula o ponto Y do raio 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
controle=1;
}


getch();
closegraph();
}//1
//================== final do arquivo ==============================
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.
circulo gerador
D
reta diretora
π.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.

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.
(x,y)
(Cx,Cy)
α
(x1,y1)
Figura 2.32 – Coordenadas do ponto da ciclóide regular.
Versão 1 – Animação do deslocamento do círculo sobre a reta
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>

//=============================================================
//=============================================================
{//1
float x1=50,y1=240;
float x=x1,y=y1;
int Raio=25;
float Dx;
float xOld=x;
int controle=0;
gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
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);
}
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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>

//=============================================================
//=============================================================
{//1

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;
gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
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;

}
getch();
closegraph();
}//1
//================== final do arquivo ==============================
versão 3 – Traçado da curva
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <math.h>
//=============================================================
//=============================================================
{//1
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;
gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
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;
}
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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
{//1

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}

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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
{//1
int maxX,maxY;

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
maxX=getmaxx(); //captura coordenada maxima de X
maxY=getmaxy(); //captura coordenada maxima de Y

rectangle(10,10,maxX-10,maxY-10);

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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
{//1
int maxX,maxY;
int x=100,y=100,Raio=25;

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}

circle(x,y,Raio);

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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
{//1
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

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
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
}
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
}
//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 programa começa apagar
//{
//setcolor(BLACK); // define a cor de desenho como preta
//circle(xo,yo,R); // desenha o círculo em preto sobre 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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
{//1
int maxX,maxY;

gdriver=DETECT;

if(errorcode!=grOk)
{
getch();
}
{
if(controle>1)
{
}
if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar
circle(x,y,Raio);

}
//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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
{//1

int maxX,maxY;

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
{
if(controle>1)
{
}
if(x>=(maxX-10-Raio)){valorX=-1;} // se atingir o lado direito, deve retornar
if(x<=(10+Raio)){valorX=1;} //se atingir o lado esquerdo, deve retornar
circle(x,y,Raio);

}
//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 <conio.h>
#include <stdlib.h>
#include <stdio.h>

#include <dos.h>
//=============================================================
{//1
int maxX,maxY;

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
{
if(controle>1)
{
}
//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
//x=x+valorX; //acrescenta valorX na coordenada X

y=y+valorY; //acrescenta valorY na coordenada Y
circle(x,y,Raio);

}
//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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
//=============================================================
{//1
int maxX,maxY;

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
{
if(controle>1)
{
}
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


circle(x,y,Raio);


}
//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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#define UpKey 72
#define DnKey 80
#define EscKey 27
//=============================================================
{//1
int maxX,maxY;
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

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}

while(teste==0) //o programa fica dentro do laco at'e uma tecla ser tocada
{
if(controle>1)
{
rectangle(500,y1o,505,y1o+50); //desenha a raquete sobre a existente
}

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
circle(x,y,Raio);

}
//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)){valorX=-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 <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#define UpKey 72
#define DnKey 80
#define EscKey 27
//=============================================================
{//1
int maxX,maxY;


gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
{
if(controle>1)
{
rectangle(500,y1o,505,y1o+50); //desenha a raqute sobre a existente
}
if(y1<=10){valorY1=1;} //se bater no lado superior, inverte descendo

if(y1>=(maxY-60)){valorY1=-1;} //se bater no lado inferior, inverte subindo

if(kbhit())
{
ch=getch();
switch(ch)
{
break;

break;

break;
}
}
rectangle(500,y1,505,y1+50);
y1o=y1;
circle(x,y,Raio);



}
//getch();
closegraph();
}//1
//==================== final do arquivo ==================================
Rodar o programa para obter os resultados.
Versão 12
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#define UpKey 72
#define DnKey 80
#define EscKey 27
//=============================================================
{//1
int maxX,maxY;

gdriver=DETECT;
if(errorcode!=grOk)
{
getch();
}
{
if(controle>1)
{


rectangle(500,y1o,505,y1o+50); //desenha a raqute sobre a existente
}

if(kbhit())
{
ch=getch();
switch(ch)
{
break;

break;

break;
}
}
if((x>=475 && x<=476) && (y>y1) && (y<(y+50))){valorX=-1;}

if(y1<=10){valorY1=5;} //se bater no lado superior, inverte descendo
if(y1>=(maxY-60)){valorY1=-1;} //se bater no lado inferior, inverte subindo
rectangle(500,y1,505,y1+50);
y1o=y1;
circle(x,y,Raio);

}
//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
b
Função seno: sen α =
c
a
Função cosseno: cos α =
c

b
Função tangente: tan α =
a
Pitágoras : c2 = a2 + b2
c
b
α 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

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Linguagem C-Introducao Programacao Aplicacoes Graficas

Caricato da

Copyright:

Formati disponibili

- LINGUAGEM C –

Nilson Luiz Maziero

Passo Fundo, setembro de 2008.

Nilson Luiz Maziero nmaziero@terra.com.br 2

2.4 Programa falsa espiral de dois centros ..................................................................................... 38

ANEXO 1 – Definições matemáticas .............................................................................................. 75

ANEXO 2 – Código do teclado ....................................................................................................... 76

ANEXO 3 – O ambiente do Turbo C ............................................................................................... 77

Nilson Luiz Maziero nmaziero@terra.com.br 3

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

Nilson Luiz Maziero nmaziero@terra.com.br 4

1.1 - CONCEITOS BÁSICOS DE PROGRAMAÇÃO

A programação é um conjunto de instruções, descrita numa linguagem que o sistema operacional

1.2 - TIPOS DE DADOS

Nilson Luiz Maziero nmaziero@terra.com.br 5

1.3 - OPERAÇÕES ARITMÉTICAS

c = 5; a variável c passa a armazenar o valor 5.

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

Nilson Luiz Maziero nmaziero@terra.com.br 6

( -- ) Operador de decremento. Subtrai uma unidade a variável inteira j. j--;

1.6 – FUNÇÕES BÁSICAS

1.6.1 - FUNÇÃO clrscr()

1.6.2 - FUNÇÃO printf ( )

printf ( “ escreve o numero inteiro: %d \n”,numeroInteiro ); onde %d diz que a variável

1.6.3 - FUNÇÃO getch ( )

Nilson Luiz Maziero nmaziero@terra.com.br 7

#include <stdio.h> //cabeçario necessário para identificar os comandos utilizados.

clrscr(); // limpa a tela

printf ( “escreve o numero real: %f ”,numero );

1.6.4 - FUNÇÃO scanf ( )

<formato> a especificação é semelhante ao printf( );

<end1>,<end2>,... correspondem aos endereços onde os dados devem ser lidos.

clrscr(); // limpa a tela

Nilson Luiz Maziero nmaziero@terra.com.br 8

printf ( “ Digite um numero real: ” );

printf ( “\n\n O numero real e: %f ”,numero );

O numero real e: 5.2

1.6.5 - FUNÇÃO for( )

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

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

Nilson Luiz Maziero nmaziero@terra.com.br 9

1.6.6 - FUNÇÃO while( ){ ... }

Nilson Luiz Maziero nmaziero@terra.com.br 10

1.6.7 - FUNÇÃO do { ... } while( )

1.6.8 - FUNÇÃO if ( ){...} ... else{...}

if ( x > y) {printf ( “o valor de X é maior que o valor de Y”);}

Nilson Luiz Maziero nmaziero@terra.com.br 11

A instrução if( ) compara as variáveis X e Y. Se X é maior que Y, condição verdadeira, as

1.6.9 - FUNÇÃO delay(int)

1.6.10 - FUNÇÃO double sqrt( double x )

1.6.11 – FUNÇÃO double sin( double x ) (Anexo 1)

Nilson Luiz Maziero nmaziero@terra.com.br 12

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)

1.6.13 – FUNÇÃO double tan( double x ) (Anexo 1)

printf("\n i2 = %d",i2)