UNIVERSIDADE ESTADUAL DO RIO DE JANEIRO

INSTITUTO POLITÉCNICO
Pós-graduação em Modelagem Computacional

Relatório Final
Projeto Geometria Computacional

Disciplina: Técnicas Computacionais

Professor: João Flávio de Vasconcellos
Aluno: Marciana Amorim Lima

Nova Friburgo
31 de julho de 2010
1 Introdução
Neste relatório, descrevemos as diferentes etapas do Projeto Geometria Computacional, tais
como, Implementação das Classes: Racional, Ponto2D, Linha2D, Raio2D, Segmento2D e Poli-
gono2D, Testes e Vericações e Aplicação.
As classes deste projeto, foram desenvolvidas por Marciana Amorim Lima e Melicia Aline
Cortat Ribeiro. Para que ambas pudessem desenvolver suas atividades em conjunto, e adquirir
o conhecimento da construção de todas as classes, cada uma teve a função de montar uma parte
de cada classe. Durante o desenvolvimento das classes, a dupla se reunia para vericação do
andamento e das dúvidas que surgiam.

2 Construção das Classes de Geometria Computacional

2.1 Classe Racionais
Na construção da Classe de Racionais, a primeira diculdade encontrada foi a implementação
das sobrecargas dos operadores, onde após uma pesquisa nas referências [1] e [5] e a ajuda do
professor João Flávio Vieira de Vasconcellos, conseguimos entender as declarações e denições
das sobrecargas dos operadores.
Depois de implementados os operadores para operações entre números racionais com racionais
e racionais com inteiros, vericou-se através dos testes que faltava implementar as declarações e
denições das sobrecargas para as operações entre inteiros e racionais. Além disso, percebemos
que não seria necessário fazer essa implementação para todos os operadores, pois não era para
todos que se validava as operações entre inteiros e racionais. Assim, procurou-se desenvolver a
classe de Racionais com os padrões estudados na sala de aula e no livro texto do Curso exposto
na referência [1].
Os operadores sobrecarregados, nesta classe foram:

Tabela 1: Operadores sobrecarregados na classe Racional

Números Números Números Incrementos e
Inteiros com Racionais com Racionais com decrementos
Racionais Inteiros Racionais pós e pré xado
+ soma + soma + soma ++
- diferença - diferença - diferença --
* produto * produto * produto
/ divisão / divisão / divisão
> comparação > comparação > comparação
>= comparação >= comparação >= comparação
< comparação < comparação < comparação
<= comparação <= comparação <= comparação
== comparação == comparação == comparação
!= comparação != comparação != comparação
= atribuição = atribuição
+= atribuição += atribuição
-= atribuição -= atribuição
*= atribuição *= atribuição
/= atribuição /= atribuição
Extração Inserção
<< >>

O operador de extração, dene a impressao do objeto Racional da seguinte maneira: (a/b),

e o operador de inserção dene a inserção de um Racional como: a/b. Além disso, sentimos a

1
necessidade de implementar algumas funções, tais como:
1. const Racional Rabs()const . Esta função calcula o módulo de um número racional,
onde não tem nenhum parâmetro de entrada e tem como parâmetro de saída um Racional.
2. Racional rpow (const int &) . Esta calcula a potência de um número Racional, tendo
um parâmetro de entrada do tipo inteiro que equivale ao expoente da potência e retorna
um Racional.
3. void Simplica(). Esta é uma função que simplica um número Racional, nela não há
parâmetros de entrada e nem saída.
Para desenvolver os algoritmos dessas funções, foram feitas pesquisas na internet, buscando as
propriedades matemáticas que se inseria em cada uma. Na referência [8] encontramos o seguinte
algoritmo,

Figura 1: Algoritmo de Euclides.

com este, foi possível o desenvolvimento da terceira função.

2.2 Classe Ponto2D

Nesta classe, não tivemos muitas diculdades, pois já haviamos adquirido o conhecimento
básico de programação. Então, aproveitando os conhecimentos adquiridos na construção da
classe anterior e através de pesquisas na internet sobre as propriedades de um Ponto2D, pudemos
sobrecarregar alguns operadores e funções que iriamos utilizar para a construção das próximas
classes.
Os operadores sobrecarregados, nesta classe foram:

Tabela 2: Operadores sobrecarregados na classe Racional

Ponto2D com Racionais Ponto2D com Inteiros Ponto2D com Ponto2D
+ soma
- diferença
* produto * produto * produto
== comparação
!= comparação (diferente)
= atribuição
Extração Inserção
<< >>

O operador de extração, dene a impressao do objeto Ponto da seguinte maneira: (x,y), e o

operador de inserção dene a inserção de um Ponto como: (x,y). Além disso, foram denidas as
duas funções abaixo:
1. Distancia_ao_quadrado. Esta função, calcula a distância ao quadrado entre dois pon-
tos.

2
 2. Distancia. Esta, calcula a distância entre dois pontos.

2.3 Classes Linha2D, Raio2D e Segmento2D

Na construção dessas classes, a primeira diculdade que encontramos estava nas denições
matemáticas. Ao longo da implementação da classe Linha2D tivemos a necessidade de acesso
aos membros privados da classe Ponto2D, e através de uma pesquisa no livro texto, identicamos
que para uma classe ter acesso aos membros privates de outra classe é necessário que ela seja
uma classe amiga. Com isso, declaramos a classe Linha2D como amiga da Ponto2D.
A cada função criada, faziamos testes para vericar se havia algum erro, em alguns testes
não encontramos respostas desejáveis. Comunicamos o professor o que estava ocorrendo e ele
nos explicou o que deveria e como deveria ser implementado, conseguimos assimilar sua idéia e
zemos a implementação.
Outra diculdade encontrada, foi declarar uma função membro que verica e calcula o ponto
de interseção entre um objeto Linha2D e um objeto Segmento2D e Linha2D e Raio2D, já que
os objetos Segmento2D e Raio2D ainda não haviam sido criados. Novamente, com a ajuda do
professor entendemos o que deveria ser feito.
Nesta classe, foram criadas as seguintes funções protegidas:
1. template <class T> const bool Intersecao (const T &, Rac &, Rac &)const :
Esta é uma função modelo que verica a existência de paralelismo entre uma Linha2D e
os tipos genéricos (Linha2D, Segmento2D ou Raio2D ) e calcula o paramétrico r do objeto
Linha2D e dos tipos genéricos.
2. const bool Intersecao(const Ponto &, Rac &, Rac &)const. Calcula o paramétrico
r e verica se um ponto pertence ou não a uma Linha2D.

3. const Rac Intersecao(const Ponto &)const. Esta, calcula o paramétrico r de um

Ponto2D ortogonal que dene um Segmento2D ortogonal a uma Linha2D .
e as funções membros públicas:
1. const bool Pertence (const Ponto &)const. Essa função utiliza a função Interse-
cao(const Ponto &, Rac &, Rac &) para vericar se um ponto pertence ou não a uma
linha, se pertencer será calculado o ponto de intersecção.
2. const bool Ponto_Ortogonal(const Ponto &, Ponto &)const . Esta, utiliza a função
Intersecao(const Ponto &) para calcular o paramétrico da Linha2D. Primeiramente ela
verica a existência de um ponto ortogonal, caso exista, o mesmo é calculado.
3. const bool Intersecao (const Linha_2D &, Ponto &)const. Nesta, é vericado a
existência de um ponto de interseção entre duas linhas. Ela faz a chamada da função
Intersecao (const T &, Rac &, Rac &), onde T=Linha2D, caso essa, retorne true, o ponto
de interseção é calculado.
4. const bool Intersecao (const Segmento_2D &, Ponto &)const. Esta função faz a
chamada da função Intersecao (const T &, Rac &, Rac &), T=Segmento2D, se essa retornar
false, não existirá ponto de interseção, caso contrário, verica se o valor do paramétrico do
Segmento2D está contido no intervalo [−1, 1], se isso ocorrer, haverá interseção e o ponto
é calculado.
5. const bool Intersecao (const Raio_2D &, Ponto &)const . Essa função faz a cha-
mada da função Intersecao (const T &, Rac &, Rac &), T=Raio2D, se essa retornar false,
não existirá ponto de interseção, caso contrário, verica se o valor do paramétrico do Raio2D
r ≥ −1, se isso ocorrer, haverá interseção e o ponto é calculado.

3
 Nas classes Linha2D, Raio2D e Segmento2D foi sobrecarregado apenas o operador de ex-
tração (<<) que imprime um objeto Linha2D, Raio2D e Segmento2D das seguintes formas,
respectivamente: Linha_2D[p1,p2], Raio_2D[p1,p2] e Segmento_2D[p1,p2].
A classe Raio2D é derivada da classe base Linha2D. A construção dessa classe não foi com-
plicada, pois quase tudo que foi feito na classe Linha2D foi utilizado nesta classe. Algumas
funções da classe Linha2D só precisaram ser complementadas, pois agora teriamos que fazer as
vericações observando o paramétrico do Raio2D.
As funções da classe Linha2D que sofreram algumas alterações na classe Raio2D, foram:
Pertence (const Ponto &), Ponto_Ortogonal(const Ponto &, Ponto &), Intersecao
(const Linha_2D &, Ponto &) e Intersecao (const Segmento_2D &, Ponto &)
A classe Segmento2D é derivada da classe Raio2D. Nesta classe, as mesmas funções anterior-
mente citadas passaram por mudanças, com excessão da função Intersecao (const Segmento_2D
&, Ponto &), pois agora o paramétrico do Segmento2D é que deve ser observado. Além disso,
a interseção de raio com segmento é a mesma de segmento com raio e a interseção de linha com
segmento é a mesma de segmento com linha.

2.4 Classe Poligono2D

Em particular, a classe Poligono2D foi a mais trabalhosa. Para o seu desenvolvimento, foram
feitas pesquisas na internet buscando as denições e propriedades matemáticas de um polígono.
As funções membros implementadas estão destacadas abaixo.
1. const double Area () const. Calcula o módulo da área de um polígono. Primeiramente,
calcula-se a área com sinal através da função Orientacao ().
2. const double Orientacao () const. Calcula a área orientada de um polígono, ou seja, a
área com sinal.
3. const double Area_triangulo(const Ponto &,const Ponto &,const Ponto &)const :
Nesta função, é calculada a área orientada de um triângulo.
4. const bool Pertence (const Ponto &)const . Função que verica se um ponto pertence
a um polígono.
5. void Triangularizacao ( vector<Poligono_2D> &). Função que triangulariza um
polígono. ela é baseada na triangularização por remoção de orelhas. Utiliza a função
Orelha().
6. const bool Orelha(const Ponto &,const Ponto &,const Ponto &)const. Verica
se três vértices consecutivos de um polígono formam uma orelha. Para que três vértices
consecutivos vi , vi+1 e vi+2 formem uma orelha, o segmento formado pelos vértices vi e
vi+2 devem ser diagonal do polígono.

7. const int size() const. Retorna o número de elementos de um objeto Poligono2D.

8. const Ponto Get(const int &) const. Função que dá o acesso ao vertice i do poligono.
9. const Poligono_2D troca( const int &, const int &) const. Função que troca a
posição de dois elementos do polígono.
Nesta classe, foram sobrecarregados os operadores de extração (<<) e inserção (>>). O
operador de extração, dene a impressao do objeto Poligono2D da seguinte maneira:

P oligono_2D[v1 , v2 , v3 , v4 , ..., vn ]

onde v1 , v2 , v3 , v4 , ..., vn são os vértices do polígono no sentido que o polígono foi inserido.
O operador de inserção dene a inserção de um Poligono2D em dois passos:

4
 1. Inserir número de vértices.
2. Inserir vértices (x, y), x e y números racionais. Como já vimos x ou y são inseridos como:
a/b.
Na fase nal do projeto, a equipe dividiu a tarefa de construção da classe Poligono2D e a
documentação de todo o projeto no software Doxygen. A aluna Marciana cou responsável pela
primeira tarefa e a aluna Melicia pela segunda.

2.5 Testes e Vericações

Na conclusão de cada classe, testamos todos os operadores e funções para vericar se havia al-
gum erro. Os testes foram feitos com valores cujas soluções eram fáceis de calcular manualmente,
para que pudessemos comparar os resultados do programa com a solução analítica.
As principais diculdades encontradas na classe Racional, estava na falta do conhecimento
básico de programação, mas ao longo da construção dessa classe conseguimos assimilar o conheci-
mento básico para prosseguirmos com as outras classes. Na classe Ponto2D, a maior diculdade
foi encontrar um erro na denição do operador de extração, mas com a ajuda do professor
conseguimos entender a causa do erro.
Nos testes da classe Ponto2D, Linha2D, Raio2D, Segmento2D e Poligono2D utilizamos um
software de matemática dinâmica, que reúne GEOmetria, álGEBRA e cálculo, chamado Ge-
ogebra. Este tem a habilidade de tratar das variáveis para números, vetores e pontos, permite
achar derivadas e integrais de funções oferece comandos como Raízes ou Extremos [12]. Com o
Geogebra pudemos visualizar se um segmento é ortogonal a uma linha, raio ou segmento, se um
ponto pertence ou não a uma linha, raio ou segmento e se existe interseção entre duas linhas,
dois raios, dois segmentos, linha e segmento e linha e raio.
Na classe Poligono2D para os testes das funções membros utilizou-se três modelos de polígo-
nos, os mesmos seguem abaixo:

Figura 2: Polígono 1 Figura 3: Polígono 2

Figura 4: Polígono 3

5
3 Aplicação
• Determinar o número de câmeras necessárias para observar uma sala com uma geometria
qualquer.

Para resolver a aplicação, utilizamos o problema da coloração de grafos, que consiste na

escolha de uma cor para colorir os vértices do grafo de tal maneira que não tenha vértices
adjacentes da mesma cor. Se sobrar vértices não coloridos, repetimos o processo com outra cor,
e assim por diante, até que tenhamos um grafo completamente colorido. Ao nal, é escolhida a
frequência da cor que teve menos repetição, sendo esta frequência o número de guardas necessários
para observar a sala com a geometria dada. Eis o algoritmo [13]:
1. Triangularizar o polígono.
2. Determinar os vértices adjacentes a cada vértice do polígono.
3. Ordenar os vértices do polígono em ordem de maior grau (maior número de vértices adja-
centes).
4. i := 1.
5. Enquanto G contém vértices não coloridos:
3.1. Para Cada vértice v de G não colorido:
3.1.1. Se Nenhum vértice adjacente a v possui a cor i:
3.1.1.1. Atribuir cor i ao vértice v
3.2. i := i + 1.
6. Retornar G.
Obs: Na apresentação do algoritmo acima, utilizamos a seguinte convenção: cada cor é identi-
cada por um número inteiro.
Testamos a aplicação para os polígonos das guras 2, 3 e 4. Os resultados obtidos são
apresentados nas guras 5, 6 e 7 abaixo.

Figura 5: Polígono 1

Figura 6: Polígono 2

6
 Figura 7: Polígono 3

As setas nas guras indicam o sentido que o polígono foi inserido. Como podemos ver na
Fig.(5), para uma sala com essa geometria seria necessário apenas um guarda para cobrir toda a
área, sendo que há apenas uma possibilidade para o ponto estratégico. Já na Fig(6) apenas dois
guardas cobririam toda a área. Como podemos observar existem três possibilidades de pontos
estratégicos. Na Fig(7) só há uma possibilidade de pontos estratégicos, sendo toda área coberta
por apenas dois guardas.

4 Considerações nais
Durante a construção deste projeto, pude perceber a necessidade dos conhecimentos básicos
de programação em c++ e aprender a identicar os erros que geralmente aparecem e corrigí-los.
Além disso, aprendi analisar as informações disponíveis na internet, fóruns e nos livros e apostilas
de programação.
Como exposto nas seções anteriores, alguns erros foram encontrados, e com a ajuda do
professor, pudemos analisá-los para entender o que estava ocasionando-os. Com a aplicação
desenvolvida, pude vericar que as classes do projeto mostraram resultados satisfatórios.
Diante disso, posso dizer que esta disciplina trouxe grandes desaos, busquei absorver o
máximo de conhecimentos para poder caminhar durante o curso com rmeza e com base, uma
vez que estarei desenvolvendo todos os meus trabalhos e talvez a dissertação em torno desta
linguagem de programação.

Referências
[1] Deitel, H. M. e Deitel, P. J. C++
Como Programar 5a Edição, Editora Pearson, 2006
[2] DOLCE, O., POMPEO, J. N., Fundamentos de Matemática Elementar 9 - Geometria Plana
- Volume IX - 7a ed. - São Paulo: Atual Editora, 1997.
[3] MIZRAHI, V. V., Treinamento em Linguagem C++ - Módulo I - São Paulo: Makron Books,
1994.
[4] VENTURI, J. J., Álgebra Vetorial e Álgebra Analítica - 9a ed. - Curitiba: Unicado, 1949.

7
 [5] http://www.ic.ufmt.br/siteIC/downloads/professores/aula7-CLP-Sobrecarga-de-
operadores.pdf. Acessado em 27 de maio de 2010.
[6] http://www.ic.ufmt.br/siteIC/downloads/professores/aula7-CLP-Sobrecarga-de- operado-
res.pdf. Acessado em 27 de maio de 2010.
[7] http://www.ime.usp.br/ freitas/gc. Acessado em: 28 de maio de 2010.
[8] http://www.profcardy.com/cardicas/euclides.php?&width=1280, acessado em 02 de junho
2010.
[9] http://www2.mat.ua.pt/disciplinas/geocomp/Acetatos/ACECG05.pdf. Acessado em: 21 de
junho de 2010.
[10] http://www.ime.usp.br/ cris/mac331/notas-de-aula/inter-seg.pdf. Acessado em: 21 de ju-
nho de 2010.
[11] http://softsurfer.com/Archive/algorithm_0104/algorithm_0104B.htm. Acessado em: 21 de
junho de 2010.
[12] Disponível em: <http://www.geogebra.org/cms/>. Acessado em: 09 de julho de 2010.
[13] http://www.professeurs.polymtl.ca/michel.gagnon/Disciplinas/Bac/Grafos/Color/color.html.
Acessado em 25 de julho de 2010.