FACULDADE FARIAS BRITO CIÊNCIA DA...
27
FACULDADE FARIAS BRITO CIÊNCIA DA COMPUTAÇÃO RÔMULO JOSÉ DE LUCENA CASTRO FILHO CONSTRUÇÃO DE UM MODELADOR DE CURVAS E SUPERFÍCIES DE BÈZIER FORTALEZA - 2007
Transcript of FACULDADE FARIAS BRITO CIÊNCIA DA...
FACULDADE FARIAS BRITO
CIÊNCIA DA COMPUTAÇÃO
RÔMULO JOSÉ DE LUCENA CASTRO FILHO
CONSTRUÇÃO DE UM MODELADOR DE CURVAS E
SUPERFÍCIES DE BÈZIER
FORTALEZA - 2007
RÔMULO JOSÉ DE LUCENA CASTRO FILHO
CONSTRUÇÃO DE UM MODELADOR DE CURVAS E
SUPERFÍCIES DE BÈZIER
Monografia apresentada para obtenção dos créditos da disciplina Trabalho de Conclusão do Curso da Faculdade Farias Brito, como parte das exigências para graduação no Curso de Ciência da Computação.
Orientadora: Profª. Drª. Wietske Ineke Meyering.
FORTALEZA – 2007
CONSTRUÇÃO DE UM MODELADOR DE CURVAS E
SUPERFÍCIES DE BÈZIER
Rômulo José de Lucena Castro Filho
PARECER _____________________
Data: ____/____/_________
BANCA EXAMINADORA:
___________________________________
Nome e titulação
(Orientador)
___________________________________
Nome e titulação
(Examinador)
___________________________________
Nome e titulação
(Examinador)
RESUMO
Pierre Bèzier foi um engenheiro francês do ramo automobilístico e desenvolveu métodos
matemáticos para implementar algoritmos que o ajudassem a projetar melhor os modelos
geométricos que ele pretendia apresentar à sua equipe. Este trabalho propõe a construção de
um modelador tridimensional de curvas e superfícies utilizando as formalidades matemáticas
idealizadas por aquele cientista. Espera-se que isso dê àqueles que ainda não tiveram contato
com a parte mais matemática da Computação Gráfica a oportunidade de nutrir um maior
interesse pela área.
SUMÁRIO
1 INTRODUÇÃO..................................................................................................7
1 METODOLOGIA................................................................................................10
1.1 Aspectos matemáticos................................................................................... 10
1.2 Aspectos computacionais..............................................................................12
2 RESULTADOS .................................................................................................. 19
CONCLUSÃO.........................................................................................................24
Possibilidades futuras .........................................................................................24
Considerações finais ...........................................................................................25
3 REFERÊNCIAS ..................................................................................................26
LISTA DE FIGURAS
Figura 1 Exemplo da interface na definição de uma spline ..........................................
12
Figura 2 Diagrama de classes .......................................................................................
18
Figura 3 Exemplo de spline ..........................................................................................
20
Figura 4 Exemplo simples de superfície, com alterações basicamente nas
componentes z dos pontos de controle ...................................................... 21
Figura 5 Exemplo de superfície mais complexa, com alterações aleatórias nas três
direções: x, y e z ........................................................................................ 22
Figura 6 Superfície e curvas desenhadas juntas ............................................................
23
1 INTRODUÇÃO
Este trabalho pode ser considerado um estudo em Modelagem Geométrica, uma
subárea da Computação Gráfica, esta já mais conhecida do público em geral devido ao grande
avanço dos sistemas gráficos e sua disseminação atual, tanto em jogos como em qualquer outro
campo moderno da informação.
A Modelagem Geométrica pode ser definida como um conjunto de métodos que
visam a descrever a forma e as características geométricas de um objeto. Ela, em
geral, é utilizada no desenvolvimento de uma descrição ou modelo analítico,
matemático, abstrato, na tentativa de representar o real. A criação de modelos possibilita o
estudo ou a simulação de situações reais com conveniência e economia, o que denota o imenso
valor didático que a Modelagem Geométrica adquire. Ela pode ser utilizada desde a
representação da aerodinâmica de automóveis e aviões, até imagens médicas, perpassando
assim praticamente todos os campos do conhecimento humano moderno. A modelagem é o
ingrediente básico de sistemas CAD/CAM, computadores gráficos, arte por computador, visão
por computador, simulação, robótica e animação.
Avanços em quaisquer destes campos, de certa forma, dependem de quão bem
definidos estão os modelos geométricos criados. Métodos de modelagem geométrica são uma
síntese de técnicas de muitas áreas como cálculo vetorial, geometria analítica e descritiva,
teoria de conjuntos, análise numérica e matemática matricial, entre outras. Esta combinação de
ferramentas matemáticas com a complexidade dos modelos geométricos requer grande esforço
computacional.
Neste trabalho, no entanto, deu-se ênfase ao processo de construção de um
modelador de curvas e superfícies de Bèzier, que é uma das inúmeras técnicas utilizadas nesse
8
vasto campo da Modelagem Geométrica e, por conseguinte, da Computação Gráfica. Na
confecção do trabalho, são contemplados determinados aspectos matemáticos da Computação
Gráfica.
Ao empreender este esforço, acredita-se estar tendo a oportunidade de divulgar
uma técnica importante para o campo em que ela se insere, desta forma fomentando o
desenvolvimento de posteriores trabalhos nessa área. Assim, através da construção de um
modelador de curvas e superfícies de Bèzier, visa-se à obtenção resultados condizentes com a
proposta de despertar o interesse de estudantes e profissionais para as áreas de Modelagem
Geométrica e Computação Gráfica como um todo.
A técnica utilizada tem seu nome em homenagem a seu criador, Pierre Étienne
Bézier (1910 – 1999), francês e engenheiro da fabricante de automóveis Renault S.A. Ele
desenvolveu curvas e superfícies que pudessem ajudá-lo no projeto dos automóveis da
empresa. As curvas de Bèzier fazem parte do grupo de curvas definidas a partir de pontos de
controle – as chamadas splines. Por conseguinte, as superfícies, extensões das curvas em duas
direções – usualmente chamadas de u e v, também dependem de pontos de controle, que são
em geral fornecidos ao programa modelador de acordo com necessidades pré-estabelecidas.
Aplicativos de desenho modernos utilizam as técnicas de Bèzier como ferramenta –
como é o caso CorelDRAW®, que possui o Bèzier Tool. Há ainda constantes estudos com
intuito de aperfeiçoar as técnicas de Bèzier, entre os quais podemos citar o HBC (Half-way
shifting Bèzier Curve), que incorpora automaticamente informações locais às várias regiões da
curva, aumentando a potência dela, sem custo computacional adicional considerável (SOHEL
et al., 2007).
Propõe-se, assim, a construção de um modelador de curvas e superfícies de Bèzier
de terceiro grau (3 x 3, no caso das superfícies). Esse grau foi o escolhido por tratar-se daquele
mais utilizado corriqueiramente nas aplicações gráficas, sendo ainda de relativamente simples
implementação. Quando um grau acima do terceiro é escolhido, a implementação torna-se
consideravelmente mais complexa e computacionalmente cara, uma vez que serão mais pontos
de controle a serem considerados, computados e devidamente posicionados (HEARN &
BAKER, 2003), além disso, torna-se extremamente poderosa a ferramenta que utiliza equações
cúbicas na modelagem de suas curvas e superfícies e as concatena. Isso significa juntar várias
9
curvas e superfícies de grau não tão elevado (por exemplo, três, como neste caso). Fazendo-se
isso, obtém-se entidades geométricas de baixo custo computacional, mas grande aplicabilidade
e versatilidade. Dessa forma, parece a melhor escolha para o presente trabalho.
Este trabalho de conclusão de curso dividir-se-á nas seguintes seções: esta
introdução; a metodologia, em que são descritos os detalhes técnicos da confecção do projeto
(como linguagem de programação utilizada e aspectos matemáticos contemplados), um
capítulo de resultados, em que será apresentado o que foi obtido na confecção do projeto
proposto e a conclusão, onde o projeto é encerrado.
10
1 METODOLOGIA
O presente trabalho envolve eminentemente aspectos de duas grandes áreas:
Matemática e Computação. Nesse sentido, os esforços foram divididos cronologicamente na
obtenção, em ambas as áreas, da maturidade necessária para atingir o objetivo vislumbrado
nesta monografia. Primeiro, visou-se à solidificação do background matemático imprescindível
à segunda parte, que foi quando se investiu na implementação do programa modelador em si.
1.1 Aspectos matemáticos
A metodologia, como citado, inclui base teórica matemática, para aplicação de
alguns aspectos necessários à implementação proposta, isto é, para a construção do modelador.
Estudou-se de modo intenso a teoria das curvas, sua transformação em superfícies e as nuanças
e particularidades da técnica proposta por Pierre Bèzier (1972).
Sobre os métodos utilizados por Bèzier, pode-se observar que a idéia principal de
seu trabalho é construir curvas que se aproximam dos pontos de controle, as chamadas
approximation splines (HEARN & BAKER, 2003). Isso significa que as curvas de Bèzier
pertencem a uma categoria de curvas que se aproximam de uma curva teórica do gráfico da
função interpolada nos pontos de controle.
Aprofundando-se um pouco na explanação em termos matemáticos, pode-se
apontar a utilização do algoritmo do matemático ucraniano Sergei Natanovich Bernstein (1880
- 1968) nos métodos apreciados neste trabalho (FARIN, 2002). Abaixo representado para o
grau n está o algoritmo de Bernstein:
11
.,...,0,)1()(,
nvvnxvxv
nx
nvb
(eq. 1.1)
Onde
k
n é o coeficiente binomial.
Bèzier (1972) utilizou o algoritmo de Bernstein para representar a influência que
cada ponto de controle terá sobre a curva construída. Um ponto parametrizado em t no espaço
conveniente para a portabilidade, entre 0 e 1 (isto é, 0 representa o início da curva; e 1, o final),
seria assim representado para n pontos de controle:
.1,0,...11
1 110
01
tttt
nt
i
nt n
nniin
i
n
iPPPttPB (eq. 1.2)
Ou seja, um somatório da influência de cada ponto de controle iP , onde i varia de 0
a n, onde n é o grau que deseja-se que a curva tenha. Como citamos na introdução do presente
trabalho, as curvas modeladas pelo programa construído juntamente com este trabalho, são de
terceiro grau – cúbicas -, logo, cada ponto parametrizado é representado por:
.1,0,22
13)1( 3
3
2
1
3
0 13 tttttt PttPPPB (eq. 1.3)
Para as superfícies, como duas dimensões parametrizadas – u e v - têm que ser
contempladas, serão dois somatórios “aninhados”. Um ponto p(u,v) genérico em uma
superfície seria representado por:
kBBp ji
m
j
n
i
m
j
n
ivuvu
,0 0
,
(eq. 1.4)
Onde uBn
i é o algoritmo de Bernstein variando de i a n para um parâmetro
genérico u e k ji , representa os pontos de controle nas direções u e v, aqui simbolizadas por i e
j. Deve-se lembrar oportunamente que, se para uma curva de grau n são necessários n+1
pontos de controle, para uma superfície de grau n x m, necessitam-se de (n+1) x (m+1) pontos
de controle, o que justifica o fato de i variar de 0 a n, e j varia de 0 a m na representação acima.
12
1.2 Aspectos computacionais
Em um segundo momento, veio a implementação, que inclui, num projeto como
este, desde a escolha da linguagem de programação a ser utilizada até os pacotes adicionais e a
interface em si do projeto.
Do ponto de vista da programação, foi utilizada a linguagem C++, por oferecer
desempenho satisfatório nesse tipo de aplicação, já que é uma linguagem voltada para o alto
desempenho, apesar de seu alto nível. Para a modelagem respectivamente da interface e da
renderização, utilizaram-se as bibliotecas wxWidgets e OpenGL, ambas freeware (isto é, de
acesso público livre, sem necessidade de pagamento de direitos autorais), bem como o
compilador utilizado, o Dev-C++, no ambiente operacional Microsoft Windows XP. Interface é
a parte do programa em que o usuário tem a oportunidade de interagir com ele. Neste caso, é a
parte em que o usuário pode dizer quantas retas quer que sejam desenhadas para representar a
curva ou dizer onde deve ficar cada ponto ou mesmo a interação em que o usuário pode utilizar
o mouse para dar zoom, rotacionar ou transladar a tela. Na figura 1, vê-se um exemplo da
interface, no momento em que o usuário pode definir uma spline a ser desenhada.
Fig. 1 – Exemplo da interface na definição de uma spline
13
É oportuno que se exemplifique o funcionamento do programa neste ponto: ao
inserir os pontos numa caixa de diálogo como a mostrada na figura 1, o usuário teria iniciado a
construção de uma spline. O que acontece, então, será ilustrado com algumas linhas do código-
fonte.
A função point, da classe Spline3D, transcrita abaixo, é a responsável pela
construção do ponto a ser desenhado, recebendo como parâmetro o t, resultado do
processamento feito pela função draw (também transcrita abaixo), que, dependendo do número
de partições definido pelo usuário, chamará a função point a cada desenho das retas que
constróem a spline.
Point3D Spline3D::point(double parameter)
{
Point3D point;
double x, y, z;
x = y = z = 0.0;
Abaixo vê-se a eq. 1.3 implementada. Cada elemento x, y e z dos pontos a serem
desenhados é construído como somatório cujas parcelas são produtos das coordenadas
inseridas pelo usuário pelo algoritmo de Bernstein (eq. 1.1), que está implementado na função
blend:
for (int i = 0; i < 4; i++)
{
double b = blend(i, parameter);
x += points[i]->getX()*b;
y += points[i]->getY()*b;
z += points[i]->getZ()*b;
}
point.setX(x);
point.setY(y);
point.setZ(z);
return point;
14
}
void Spline3D::draw()
{
Point3D newPoint = point(0.0);
Line3D line;
line.setWidth(width);
line.setColor(color.getR(), color.getG(), color.getB());
for(int i = 1; i <= partitionsCount; i++)
{
double t = (double) i / (double) partitionsCount;
Point3D oldPoint = newPoint;
newPoint = point(t);
line.setPin(oldPoint);
line.setPfin(newPoint);
line.draw();
}
}
Função blend transcrita, exemplificando como a eq.1.1 é implementada.
double BezierSpline3D::blend(int k, double parameter)
{
double total = 0.0;
if (k == 0)
{
total = pow(1.0 - parameter, 3.0);
}
else if (k == 1)
{
15
total = 3.0 * parameter * pow(1.0 - parameter, 2.0);
}
else if (k == 2)
{
total = 3.0 * pow(parameter, 2.0) * (1.0 - parameter);
}
else if (k == 3)
{
total = pow(parameter, 3.0);
}
return total;
}
Discorrendo sucintamente acerca de aspectos exclusivamente programacionais,
pode-se citar: como estrutura de dados utilizou-se uma lista para splines e outra para
superfícies, ambas do header List.h, da biblioteca STL (JAMSA & KLANDER, 1999). Cada
vez que o usuário insere os dados na caixa de diálogo (vide figura 1) para que seja desenhada
uma spline, esta tanto é desenhada na tela como seus dados (como a posição dos pontos de
controle) são armazenados na lista citada. O mesmo acontece no caso das superfícies, que são
armazenadas na sua lista. Assim, sempre que a função de desenho é chamada para renderizar,
isto é desenhar, as curvas e superfícies no canvas, que é a parte preta (neste caso) da tela em
que serão mostradas as figuras, as listas que as armazenam são percorridas e todas as estruturas
armazenadas são desenhadas, o que oferece ao programa uma boa perspectiva para trabalhos
futuros mais complexos envolvendo vários objetos ao mesmo tempo.
Uma curva é desenhada, em geral, com várias retas. É isso que a função de desenho
implementada faz. A curva é dividida (particionada) em um número de retas (no espaço de 0 a
1 citado), que pode ser escolhido pelo usuário. Após essa escolha, cada reta é desenhada de um
ponto até o próximo correspondente nas equações apresentadas na seção anterior. Desse modo,
quanto mais alto o número de partições escolhido, mais próximo de uma curva real estará a
representação, o que, no entanto, implica maior custo computacional.
16
Foram implementadas funções que possibilitam efetuar, ao se clicar e arrastar o
mouse no canvas, rotação, zoom e translação, mediante a escolha de uma dessas funções com
um prévio clique com o botão direito no próprio canvas. No mesmo menu que possibilita essa
escolha, pode-se também voltar a “câmera”, isto é, a visão do observador, para seu local de
origem. Pode-se ainda optar por exibirem-se ou não os pontos de controle, o grid e o eixo.
Detalhando a maneira como a implementação foi feita, é pertinente que se cite que
o trabalho está bem segmentado (procurou-se seguir os preceitos da Orientação a Objetos (OO)
(JAMSA & KLANDER, 1999)), de modo que a utilização de seus componentes em separado
fica facilitada (o que é bom para possíveis incrementos futuros).
A classe principal para o funcionamento do programa, SMFrame, é a responsável
pela instanciação de janelas, a partir da qual o próprio frame, isto é, a janela em que todo o
programa aparece, principal é criado a cada vez que o executável do programa é iniciado.
Criou-se uma classe (SMCanvas) para o canvas, em que seus componentes, como
cores e tamanho, são atributos.
Cada caixa de diálogo é um objeto instanciado da classe SMSplineDialog ou
SMSurfaceDialog, a depender de o que se deseja criar, respectivamente, uma spline ou uma
superfície.
Cada vez que se clica em “ok” na caixa de diálogo, um objeto da classe
BezierSpline3D (no caso da caixa de diálogo como da figura 1, ou seja, para instanciar
splines) é criado, o mesmo acontece quando se faz o processo análogo para superfícies, mas,
neste caso, é instanciado um objeto da classe BezierSurface3D. As listas, já citadas
anteriormente, são portanto de objetos dessas duas classes, assim, elas armazenam todos os
atributos definidos nelas.
Há ainda várias outras classes, principalmente relacionadas às possíveis figuras
geométricas que podem ser incorporadas ao trabalho no futuro. Por exemplo, todas as classes
de figuras são subclasses da classe Shape3D. As classes Point3D, Line3D, Curve3D (cujo
objeto pode representar um conjunto de splines concatenadas), Spline3D e Surface3D herdam
17
de Shape3D. As classes BezierSpline3D e BezierSurface3D são subclasses de,
respectivamente, Spline3D e Surface3D.
Assim, torna-se intuitivo o entendimento de como o processo de construção das
figuras se dá. Ao ser desenhada, uma curva, Spline3D, representa a instanciação de várias
retas, objetos da classe Line3D. Os pontos de controle da curva são objetos da classe
SplinePoint3D, subclasse da Point3D e assim por diante.
Para maiores detalhes acerca da hierarquia de classes, olhar o diagrama de classes
na figura 2.
18
Fig. 2 – Diagrama de classes
19
3 RESULTADOS
O resultado obtido foi um programa gráfico, conforme as intenções iniciais do
projeto. Portanto, trata-se de um software capaz de, a partir das informações iniciais fornecidas
pelo usuário, modelar (e desenhar na tela) curvas e superfícies de Bèzier. As informações
iniciais incluem o número de partições que a curva ou superfície deve ter, isto é, o número de
retas que serão desenhadas para representar a curva ou cada curva da superfície.
Neste capítulo, serão apresentados alguns screenshots do programa.
Na figura 3, vê-se uma spline representada com seus pontos de controle (esferas),
unidas por retas em vermelho que delimitam o chamado convex hull (HEARN & BAKER,
2003), ou fecho convexo, entidade geométrica que delimita as curvas e superfícies de Bèzier.
Observe-se que se implementou também um eixo tridimensional (eixo z em azul, y em verde e
x em vermelho) e um grid para servirem de referência para as modelagens.
20
Fig. 3 - Exemplo de spline
21
Na figura 4, vê-se uma superfície com alterações basicamente na componente z dos
pontos de controle, de modo a ficar levemente abaulada, apenas para efeito de demonstração.
Ressalte-se, no entanto, a grande plasticidade que essas superfícies podem assumir,
dependendo apenas do modo como os pontos de controle são definidos, o que se pode observar
na próxima figura.
Fig. 4 - Exemplo simples de superfície, com alterações basicamente nas componentes z dos pontos de controle.
22
Na figura 5, vê-se um exemplo da versatilidade desse tipo de superfície. Alteraram-
se as componentes x, y e z de cada ponto de controle, de modo a obter-se um resultado que
demonstrasse como objetos de arquitetura extremamente complexa podem ser modelados com
essa técnica.
Fig. 5 - Exemplo de superfície mais complexa, com alterações aleatórias nas três direções: x, y e z
23
Na figura 6, pode-se perceber o que foi citado na seção de aspectos
computacionais: várias estruturas podem ser desenhadas ao mesmo tempo e processadas de
acordo com as necessidades do programador, já que todas ficam guardadas nas listas criadas.
Vêem-se uma superfície e três curvas, juntamente com o grid e o eixo.
Fig. 6 - Superfície e curvas desenhadas juntas
24
CONCLUSÃO
Possibilidades futuras
Há inúmeras possibilidades para um trabalho como este. Um modo interessante de
aproveitá-lo, por exemplo, é fazê-lo tornar-se parte de um programa gráfico maior que o utilize
total ou parcialmente como rotina, em meio a outras rotinas que desenhem outros tipos de
curvas e superfícies, bem como eventuais outras entidades geométricas.
Existe ainda a interessante possibilidade de expandir-se o programa, incorporando
a ele outras funcionalidades, como a modelagem de outros tipos de figuras, outras técnicas de
modelagem geométrica, de modo a torná-lo mais funcional, robusto e independente.
É interessante que se ressaltem alguns aspectos do trabalho que podem ser alvo de
abordagem futura, servindo para aperfeiçoar este trabalho ou outros na mesma área: as curvas e
superfícies implementadas, como citado em momento oportuno, são apenas do terceiro grau.
Não há a possibilidade de se definirem pontos para as curvas ou superfícies apenas se clicando
no canvas, o que torna difícil a determinação de uma figura geométrica da exata forma que se
espera. Os pontos são inseridos em uma caixa de diálogo, e, no caso das superfícies, o número
de variáveis torna-se particularmente alto, já que, para cada um dos 16 pontos (como citado,
são (n + 1) (m +1) pontos, para uma superfície de grau n x m), tem-se que determinar as três
dimensões, x, y e z.
25
Considerações finais
Por fim, é pertinente observar que este trabalho pode ser visto como um ponto de
partida para vários outros. Por um lado, ele é um estudo em Computação Gráfica; por outro,
um início de implementação de um programa de modelagem gráfica. Início porque, apesar de
os objetivos iniciais terem sido contemplados, eles eram modestos, suficientes apenas para um
trabalho acadêmico em nível de graduação. Sendo necessários complementos relacionados à
implementação de outras técnicas de modelagem para que ele se torne um modelador
realmente aplicável a interesses mais exigentes, como a utilização por empresas que trabalham
com processamento de imagens ou qualquer outra área que demande a utilização de
modeladores poderosos.
O que definitivamente dispensa qualquer questionamento é a utilidade prática como
aprendizado que um projeto do nível deste oferece. A maturidade que se obtém ao longo das
fases de um trabalho que envolve revisão bibliográfica nas área matemática e computacional,
além da programação, é, sem dúvida, um bom complemento à formação adquirida durante todo
o curso de graduação.
26
3 REFERÊNCIAS
BÈZIER, Pierre. Numerical control: mathematics and applications. John Wiley
and Sons Ltd, 1972.
FARIN, Gerald; HANSFORD, Dianne. The Essentials of CAGD. 1st Edition, AK
Peters, Ltd. 2000.
FARIN, Gerald. Curves and Surfaces for Computer-Aided Geometric Design:
A Practical Guide, 5th Edition, Morgan Kaufmann, 2002.
HEARN, Donald; BAKER, Pauline. Computer Graphics. 3 th Edition., Prentice
Hall, 2003.
JAMSA, Kris; KLANDER, Lars. Programando em C/C++ - A Bíblia. São Paulo:
Pearson Education do Brasil, 1999.
SOHEL, F.A.; DOOLEY, L.S.; KARMAKAR, G.C. A Novel Half-Way Shifting
Bezier Curve Model. Disponível em:
<http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=4084913>. Acesso em: 23 jun 2007.
URLs:
http://www.corel.com/servlet/Satellite/us/en/Content/1153321237159 (último
acesso: 22/06/2007)
http://www.wxwidgets.org/ (último acesso: 21/06/2007)
27
http://www.opengl.org/ (último acesso: 21/06/2007)
http://www.ic.uff.br/~aconci/sweeping.html (último acesso: 03/11/2007)
