UNIVERSIDADE DO ESTADO DE SANTA CATARINA BACHARELADO EM CINCIA COMPUTAO

Rafael Alceste Berri

Interseco de Slidos de Faces Triangulares no Espao

Alexandre Gonalves Silva Orientador

Joinville, Novembro de 2004

UNIVERSIDADE DO ESTADO DE SANTA CATARINA BACHARELADO EM CINCIA COMPUTAO

Rafael Alceste Berri

Interseco de Slidos de Faces Triangulares no Espao

Trabalho de concluso de curso submetido Universidade Estadual de Santa Catarina como parte dos requisitos para a obteno do grau de Bacharel em Cincia da Computao

Alexandre Gonalves Silva Orientador

IV

Joinville, Novembro de 2004

Interseco de Slidos de Faces TRIANGULARES NO ESPAO

Rafael Alceste Berri

Este Trabalho de Concluso de Curso foi julgado adequado para a obteno do ttulo de Bacharel em Cincia da Computao na rea de Concentrao de Computao Grfica e aprovada em sua forma final pelo Curso de Cincia da Computao Noturno do CCT/UDESC.

________________________________
Cinara Menegazzo

Banca Examinadora ________________________________

Alexandre Gonalves Silva

________________________________
Siovani Cintra Felipussi

________________________________
Gilmrio Barbosa dos Santos

Ns somos o qu repetidamente fazemos. Excelncia, portanto, no um ato, mas um hbito (Aristteles)

VI

A Deus, por todo sustento e graa concedidos. A minha famlia, pelo apoio e compreenso, Amo vocs!

VII

Agradecimentos especiais ao mestre Alexandre Gonalves Silva pelo incentivo, apoio e amizade.

VIII

SUMRIO LISTA DE FIGURAS.........................................................................................................X LISTA DE TABELAS.....................................................................................................XII RESUMO.........................................................................................................................XIII ABSTRACT....................................................................................................................XIV INTRODUO..................................................................................................................15 1 GEOMETRIA ANALTICA.........................................................................................20 1.1ELEMENTOS PRIMITIVOS.................................................................................................21 1.2 SISTEMA CARTESIANO NO ESPAO 2D............................................................................21 1.3SISTEMA CARTESIANO NO ESPAO TRIDIMENSIONAL..........................................................22 1.4VETORES......................................................................................................................24 1.4.1Soma de vetores...................................................................................................24 1.4.2Multiplicao escalar..........................................................................................24 1.4.3Multiplicao de vetores.....................................................................................25 1.5EQUAES DE RETAS.....................................................................................................25 1.6PLANO.........................................................................................................................29 2 MODELAGEM DE SLIDOS.....................................................................................31 2.1SUPERFCIES PARAMTRICAS...........................................................................................31 2.2FACES TRIANGULARES...................................................................................................32 3ESTUDO DE CASOS DA LITERATURA SOBRE INTERSECO DE SLIDOS DE FACES TRIANGULARES........................................................................................35 3.1INTERSECO DE PARES DE TRINGULOS...........................................................................35 3.2INTERSECO ENTRE SUPERFCIES TRIANGULARES...............................................................37 3.3INTERSECO DE SUPERFCIES PARAMTRICAS....................................................................40 4FILTRAGEM...................................................................................................................46 5INTERSECO TRIANGULAR 2D...........................................................................51 5.1VARIVEIS GLOBAIS......................................................................................................52 5.2RETAS DOS TRINGULOS.................................................................................................53 5.3ENCONTRANDO PONTOS DE INTERSECO..........................................................................57 5.3.1Funo inserirPontoIntersec .............................................................................57 5.3.2Funo PontoNoTriangulo.................................................................................57 5.3.3Funo PontosDeEncontro.................................................................................60

IX

5.4SEGMENTOS DA INTERSECO..........................................................................................63 5.5PROGRAMA EXEMPLO.....................................................................................................65 6ALGORITMO FINAL INTERSECO 3D............................................................67 CONCLUSO....................................................................................................................73 TRABALHOS FUTUROS................................................................................................75 ANEXO 1 FUNO LER.............................................................................................76 ANEXO 2 FUNO PROCURARVERTICE............................................................77 ANEXO 3 FUNO FILTRAR....................................................................................78 ANEXO 4 FUNO ENCONTRARDIMENSES...................................................81 ANEXO 5 FUNO TESTARFACEREGIAO..........................................................84 ANEXO 6 FUNO ENCONTRARVIZINHANA.................................................85 ANEXO 7 FUNO PERTENCEM............................................................................89 ANEXO 8 FUNO ENCONTRARPONTOINICIAL.............................................90 ANEXO 9 FUNO LOOPINTERSEC......................................................................99 ANEXO 10 FUNO ENCONTRARPONTOSDEENCONTRO..........................107 REFERNCIAS BIBLIOGRFICAS..........................................................................109

LISTA DE FIGURAS

FIGURA 1 - EXEMPLO DE PLANIFICAO DE UM CILINDRO........................16 FIGURA 2 - INTERSECO DE CILINDRO EM CILINDRO................................17 FIGURA 3 - PLANIFICAO DO CILINDRO PRINCIPAL DA INTERSECO DE CILINDRO EM CILINDRO.....................................................................................18 FIGURA 4 - PLANIFICAO DO CILINDRO QUE SE INSERE NO CILINDRO PRINCIPAL DA INTERSECO CILINDRO EM CILINDRO...............................18 FIGURA 5 - PONTO NO PLANO CARTESIANO BIDIMENSIONAL....................22 FIGURA 6 - PONTO NO PLANO CARTESIANO TRIDIMENSIONAL.................23 FIGURA 7 - VISO DA FRMULA PARAMTRICA DA RETA...........................29 FIGURA 8 - REPRESENTAES DE UMA SUPERFCIE: A) ESPAO EUCLIDIANO; B) ESPAO PARAMTRICO............................................................32 FIGURA 9 - CARACOL DE HIDROELTRICA........................................................33 FIGURA 10 - TRAAGEM DO CONE NO PROCESSO TRADICIONAL.............34 FIGURA 11 - TRAAGEM UTILIZANDO MTODO DA TRIANGULAO.....34 FIGURA 12 - INTERSECO ENTRE DOIS TRINGULOS (TIPO 1).................36 FIGURA 13 - INTERSECO ENTRE DOIS TRINGULOS (TIPO 2).................36 FIGURA 14 - INTERSECO ENTRE DOIS TRINGULOS (TIPO 3).................36 FIGURA 15 - INTERSECO ENTRE DOIS TRINGULOS (TIPO 4).................37 FIGURA 16 - PONTO P DENTRO DO TRINGULO (TIPO 1)...............................38

XI

FIGURA 17 - PONTO P NA BORDA DO TRINGULO (TIPO 2)...........................39 FIGURA 18 - PONTO P UM VRTICE DO TRINGULO (TIPO 3)...................39 FIGURA 19 - OS TRINGULOS ESTO EM UM MESMO PLANO (TIPO 4).....39 FIGURA 20 - EXEMPLOS DE SUPERFCIES PARAMTRICAS QUE PASSARAM PELO ALGORITMO DE (COELHO, 2000)..........................................43 FIGURA 21 - PROBLEMA DE INTERSECO.........................................................44 FIGURA 22 - REGIO DE INTERSECO ENTRE OS PARALELEPPEDOS..48 FIGURA 23 - DELIMITANDO OS SEGMENTOS DE RETAS (TRANSFORMANDO EM INEQUAES).................................................................56 FIGURA 24 - REGIO DE UM TRINGULO.............................................................59 FIGURA 25 - INTERSECO DE SEGMENTOS DE RETAS TIPO 1...................62 FIGURA 26 - INTERSECO DE SEGMENTOS DE RETAS TIPO 2...................62 FIGURA 27 - INTERSECO DE SEGMENTOS DE RETAS TIPO 3...................63 FIGURA 28 - INTERSECO DE SEGMENTOS DE RETAS TIPO 4...................63 FIGURA 29 - UM EXEMPLO DE PROGRAMA DE INTERSECO DE TRINGULOS 2D.............................................................................................................66 FIGURA 30 - REGIO FECHADA DE INTERSECO...........................................71 FIGURA 31 - REGIO ABERTA DE INTERSECO..............................................71

XII

LISTA DE TABELAS
TABELA 1 - VANTAGENS E DESVANTAGENS DA INTERSECO DE PARES DE TRINGULOS............................................................................................................37 TABELA 2 - VANTAGENS E DESVANTAGENS DA INTERSECO ENTRE SUPERFCIES TRIANGULARES.................................................................................40 TABELA 3 - VANTAGENS E DESVANTAGENS DA INTERSECO DE SUPERFCIES PARAMTRICAS.................................................................................45

XIII

RESUMO

Este trabalho descreve um estudo realizado para criao de um algoritmo capaz de realizar interseco de slidos de faces triangulares de forma eficiente, direcionado descoberta de possibilidades e recursos que podem ser aplicados a softwares de modelagem ou empresas desenvolvedoras de sistemas CAD. mostrado um estudo de tcnicas j existentes na literatura. O algoritmo herdou as caractersticas que se adaptam a slidos formados por faces triangulares comumente empregados.

XIV

ABSTRACT

This work describe a study realized for creation of an algorithm able to realize intersection of triangular solid faces of a efficient way, directing to the discovery of possibilities and resources that can be applied to the modeling software or development enterprises CAD system. It's showed a study of techniques already existents on the literature. The algorithm inherited the characteristics that adapting it to the solids formed for triangular faces usually used.

INTRODUO

As empresas brasileiras que desenvolvem softwares de CAD (Computer Aided Design - Projeto Auxiliado por computador) esto a todo o vapor, pois, em 2004, at agosto a indstria cresceu 8,8% (IBGE, 2004) e tambm a capacidade ociosa das empresas esto em queda chegando a 11,4% (IBGE, 2004). Em todo o ramo industrial o CAD empregado seja na manuteno, construo ou criao. Esses ndices ento nos mostram respectivamente que a indstria est tendo um grande crescimento este ano e tambm que precisar adquirir novas mquinas e ampliar seus parques fabris. Esse crescimento tambm estimula a criao de novas solues/mdulos para que o processo de projeto seja ainda mais rpido e simples. Outra novidade no desenvolvimento de softwares a possibilidade de exportao, pois o mercado internacional de softwares, que ainda no muito explorado por empresas brasileiras desenvolvedoras, est sendo descoberto pelas mesmas somente agora. Com essa abertura no mercado de softwares os produtos que querem se tornar competitivo no mercado global precisam ter diferencial, pois tero que competir de igual para igual com empresas de pases desenvolvidos h anos no mercado e investindo muito dinheiro em pesquisa. Com o intuito de ter um diferencial em relao a softwares de modelagem industrial, o tema deste trabalho, Interseco de Slidos de Faces Triangulares no Espao, foi sugerido por pesquisadores na rea de modelagem. Pode-se pensar, por exemplo, em um software de planificao em caldeiraria. Planificao nada mais do que a forma como devemos cortar uma chapa de ao para que possamos ter um cilindro com as seguintes dimenses: Dimetro 1000 mm e Altura 2000 mm. A planificao deste cilindro

16

mostrada na Figura 1, basta cortar a chapa nas dimenses corretas e dobrala pela dimenso 3141.5 (permetro) para se obter um cilindro com essas dimenses.

Figura 1 - Exemplo de planificao de um cilindro Para uma aplicao industrial, as planificaes so mais complexas de serem desenvolvidas, sendo que o cilindro, sem dvida, a planificao de forma mais simples, pois a sua planificao um retngulo da Altura x Permetro Circunferncia. No nosso exemplo o permetro da circunferncia 2xPIx1000/2=3141.5 (2xPIxraio). Todos os softwares deste setor possuem uma grande variedade de clculos de peas. Esses clculos so gerados a partir de dimenses informadas pelo usurio. No caso do cilindro o software indaga a altura e dimetro. Desta forma, o usurio est limitado aos clculos a ele oferecidos porque cada clculo nico, ento necessita de um algoritmo especfico para o resolver. Seria interessante conseguir um mdulo em que seja possvel, a partir da interseco 3D, gerar automaticamente a planificao das peas

17

(slidos). O programa continuar calculando, a partir do modo tradicional, informando as dimenses de uma pea por um formulrio de entrada, as diversas peas bsicas em caldeiraria como cilindros, cones, transies, etc, o software gerar o 3D das peas primitivas desejadas. Com o 3D das peas ser possvel coloca-las em interseco, gerando assim uma nova pea. Como pode ser visto na Figura 2 foram colocados duas peas primitivas (cilindros) em uma posio em que esto em interseco gerando uma Interseco de Cilindro em Cilindro.

Figura 2 - Interseco de Cilindro em Cilindro Ento o trabalho do usurio colocar os slidos na posio correta de interseco. A partir deste ponto, o software localizaria a regio onde os dois slidos esto se encontrando, cortaria essa regio e por fim geraria as planificaes das peas. A planificao do cilindro principal mostrada na Figura 3 e do cilindro secundrio (menor) mostrada na Figura 4.

18

Figura 3 - Planificao do cilindro principal da Interseco de Cilindro em cilindro

Figura 4 - Planificao do cilindro que se insere no cilindro principal da Interseco Cilindro em cilindro

19

Este trabalho tem como objetivo principal apresentar um algoritmo para localizar as linhas onde os slidos esto ocupando o mesmo lugar no espao (esto em interseco), ou seja, apresentado um algoritmo de localizao da regio de interseco dos slidos como resultado. Os slidos so formados por faces 3D, por esse motivo podemos dizer que slido um conjunto de faces. Sero adotadas faces triangulares, pois o padro 3D utilizado na maioria dos algoritmos de modelagem geomtrica 3D. O trabalho est dividido em cinco captulos. O Captulo 1 aborda conceitos de Geometria que so utilizadas nos algoritmos de interseco. No Captulo 2 tem-se um estudo de como apresentado o padro de slidos deste trabalho para a proposta de um algoritmo e tambm abordado sobre superfcies paramtricas. O Captulo 3 apresenta alguns trabalhos j desenvolvidos na literatura para interseces 3D. No Captulo 4 estudada uma forma de filtro. J o Captulo 5 ilustra a interseco 2D (interseces no mesmo plano). Por fim, o Captulo 6 proposto um algoritmo diferenciado para interseco de slidos de faces triangulares no espao utilizando-se dos estudos feitos neste trabalho, este captulo, portanto a apresentao do resultado da pesquisa.

GEOMETRIA ANALTICA

A palavra geometria derivada do grego, com base no radical ge de g = terra e mtron = medida (MARIELLI, 2004). H em grego clssico o verbo gemtrin = medir a terra, ser agrimensor ou gemetra. Segundo os historiadores, os egpcios e os caldeus desenvolveram a geometria. Conforme descobertas arqueolgicas os caldeus (um dos povos que habitavam a mesopotmia) usavam frmulas geomtricas para calcular reas e volumes. Os egpcios, nesta mesma poca, utilizavam a geometria para construir templos de projees uniformes e precisas. Certamente que, nesta poca, eles utilizavam mtodos arcaicos de medies, como pavimentar com mosaicos quadrados e contar quantos quadrados eram necessrios para cobrir todo o retngulo, por exemplo. Mas com esses mtodos eles conseguiram notar que s precisariam contar quantos quadrados possui uma fileira e quantas fileiras so. Estava descoberta assim, a frmula da rea do quadrado que rea = Base x Altura. Durante todo esse perodo histrico a geometria foi evoluindo, surgiram novos conceitos e mtodos de estudo. Um grande avano obtido sobre a geometria dos gregos foi quando, no sculo XVII, se estabeleceu a correspondncia entre os pontos de uma reta e os nmeros reais. Marcandose um ponto para ser origem na reta, e fixando-se uma unidade de medida e um sentido, a cada ponto corresponder um nmero, que o resultado da medida de sua distncia origem escolhida, sendo verdadeiro a recproca. Essa correspondncia permitiu o aparecimento da geometria analtica, em 1637. Um sculo aps a geometria recebia nova contribuio do gnio criador de Gaspard Monge com seu trabalho de associar as figuras do espao tridimensional s do plano, atravs de projees, dando origem geometria

21

descritiva. Com os trabalhos de Monge e de seus discpulos foi generalizado novo mtodo de estudo da geometria, atravs de transformaes das figuras, ou seja, do estabelecimento de uma correspondncia entre os elementos das figuras geomtricas.

1.1 Elementos Primitivos

A geometria admite como elementos primitivos o ponto, a reta e o plano (TCA, 1996). Os conceitos geomtricos so estabelecidos por meio de definies. As noes primitivas so adotadas sem definio. Como podemos imaginar ou formar idias de ponto, reta e plano, ento sero aceitos sem definio. O ponto imaginado como uma estrela, um pingo de caneta, um furo de agulha,... Representa-se o ponto por uma letra maiscula do alfabeto latino (A, B, C,...) (TCA, 1996). A reta imaginada sem espessura, no tem comeo e nem fim. Representamos a reta por uma letra minscula do alfabeto latino (a, b, c,...), quando uma reta desenhada no caderno ou quadro, representa-se parte da reta (TCA, 1996). O plano imaginado como um conjunto infinito de pontos. Plano imaginado sem limites em todas as direes, como acontece com a reta impossvel representar o plano no papel ou quadro (TCA, 1996). Por isso visto parte deste. Apresenta-se o plano por uma letra do alfabeto grego. Como alfa (), beta () e gama ().

1.2 Sistema Cartesiano no Espao 2D

22

O Sistema Cartesiano no Espao 2D ou Geometria Plana formado por duas retas orientadas (dimenses) x e y, perpendiculares entre si. Chamamos a reta orientada x de Eixo X ou Eixo das Abscissas e a reta orientada y de Eixo Y ou Eixo das Ordenadas. Neste sistema existe somente um plano e ele dividido pelos Eixos X e Y em 4 quadrantes. De um ponto qualquer se pode traar perpendiculares sobre cada um dos eixos, obtendo assim os pontos Px e Py, sendo x = OPx e y = OPy (VENTURI, 2003). Na Figura 5 esse processo visto.

Figura 5 - Ponto no plano cartesiano bidimensional Ento P = (x,y), onde x abscissa de P e y a ordenada de P. Esse sistema torna-se importante na rea computacional porque a interface entre o computador e o mundo exterior feita atravs de monitores de vdeo onde a imagem vista em uma tela 2D utilizando o sistema cartesiano.

1.3 Sistema Cartesiano no Espao Tridimensional

A diferena primria da Geometria Espacial (tridimensional) para a Geometria Plana (bidimensional) o nmero de coordenadas.

23

Enquanto na Geometria Plana temos dois eixos x e y na Geometria espacial temos eixos x, y e z. O conjunto de pontos do espao tridimensional indicado por E3. As retas x, y e z so orientadas mutuamente perpendiculares entre si e concorrentes no ponto O (VENTURI, 2003). Com base em um ponto P traam-se trs planos paralelos aos planos coordenados. Veremos que essas faces interceptam os eixos x em Px, y em Py e z em Pz. Assim obtemos as trs coordenadas do ponto P (VENTURI, 2003). Esse processo exemplificado na Figura 6.

Figura 6 - Ponto no plano cartesiano tridimensional Ento P = (x, y, z), onde x a abscissa, y a ordenada e z a cota. Esse sistema o utilizado em algoritmos que lidam com o espao tridimensional como o caso do algoritmo final deste trabalho.

24

1.4 Vetores

Em 1586 surgiu o conceito de vetor. Em seu livro Esttica e Hidrosttica, Simon Stevin, desenvolveu uma regra emprica para encontrar a soma de duas foras aplicadas em um mesmo ponto (VENTURI, 2004). Essa regra conhecida hoje como regra do paralelogramo. Segundo (DRAKOS, 1994), um vetor uma entidade que tem magnitude e direo, ele pode ser representado por um segmento de linha direcionada. Dois vetores so iguais se eles tem a mesma magnitude e direo. Um vetor pode ter n dimenses. Um exemplo de vetor tridimensional seria: u = (x,y,z). Sendo que x, y, z R.

1.4.1 Soma de vetores

Para somar dois vetores basta somar suas respectivas coordenadas. Sendo u = (x1,y1) e v = (x2,y2), sua soma, u + v igual a (x1+x2,y1+y2). O processo de subtrao de vetores idntico ficando u - v igual a (x1-x2,y1-y2).

1.4.2 Multiplicao escalar

Se u = (x1, y1) e a um escalar (um nmero real), ento o mltiplo escalar au de u por a o vetor (ax1,ay1) (KOLMAN, 1996). Ento o mltiplo escalar de au um a multiplicando todas as coordenadas de u.

25

Caso a seja um nmero menor que zero ento o produto escalar de a por u ter o sentido inverso de u, sendo ele maior que zero ter o mesmo sentido de u.

1.4.3 Multiplicao de vetores

Para multiplicar dois vetores basta multiplicar as suas coordenadas correspondentes, ou seja, tendo u = (x1,y1) e v = (x2,y2) ento u * v = (x1*x2,y1*y2).

1.5 Equaes de Retas

As retas possuem uma equao que as rege. Mas para saber a equao de uma reta preciso ter dois pontos que a pertence, ou seja, com dois pontos definida qualquer reta seja 2D ou 3D. Para sistemas 2D, a equao de reta denominada por y = a*x + b. Tendo os pontos P1 (x1,y1) e P2 (x1,y1) podemos encontrar os coeficientes da reta passa por eles: a = (y1 - y2) / (x1 - x2) b = y1 - a * x1 Porm esse mtodo tem seus problemas, pois tendo x1 = x2, resultaria em a = (y1 - y2) / 0, o que no possvel calcular. Outro ponto importante que essa equao, em um sistema 3D, define um plano ( visto a frente) com coeficiente de z sendo 0. Em Computao Grfica so mais usadas equaes

26

paramtricas de retas. As equaes paramtricas que regem uma reta precisam de um ponto e um vetor diretor para que sejam definidas. O vetor diretor quem dita a inclinao da reta, ou seja, ele quem especifica dentre as infinitas retas passantes por um ponto P a que se procura, pois ele paralelo a essa reta. Tendo um ponto P0 (x0, y0) e um vetor diretor r (a, b) podemos especificar as equaes paramtricas da reta passante em P como sendo: x = x0 + t * a y = y0 + t * b onde t chamado de parmetro e um nmero real. Para que um ponto qualquer (x, y) pertena a essa reta, eles precisam resultar em um mesmo t (ter o mesmo parmetro). Quando se tm dois pontos da reta, P0 (x0, y0) e P1 (x1, y1), voc pode encontrar o vetor diretor fazendo r = P1 - P0. Ento as equaes poderiam ser descritas por: x = x0 + t * (x1 - x0) y = y0 + t * (y1 - y0) isolando o t das duas equaes temos: x - x0 = x1 - x0 y1 - y0 y - y0

Toda reta calculada por P0 e P1 pode ser tratado como um segmento de reta de P0 a P1 porque se o valor de t for 0, ento o ponto resultante das equaes P0, j se o valor de t for 1 seu resultante ser P1. Ento o segmento de reta P0P1 vai de t=0 at t=1.

27

Tendo-se

dois

sistemas

de

retas

x1=x01+t1*a1

y1=y01+t1*b1, x2=x02+t2*a2 e y2=y02+t2*b2, possvel que esses sistemas representem uma mesma reta, pois, podem ter sido gerado por 4 pontos colineares (pertencentes a uma mesma reta) e s o fato de terem sido geradas por pontos diferentes j as tornam distintas. Para saber se esses sistemas de retas pertencem mesma reta basta aplicar a frmula a1*b2 b1*a2 = 0. Se for igual a zero estamos falando de uma mesma reta. Para encontrar onde x1=x01+t1*a1 e y1=y01+t1*b1,

x2=x02+t2*a2 e y2=y02+t2*b2 se cruzam basta aplicar as seguintes frmulas: (x02 x01) * b2 + (y01 y02) * a2 t1 = a1 * b2 b1 * a2

(x01 x02) * b1 + (y02 y01) * a1 t2 = a2 * b1 b2 * a1

Onde t1 e t2 sero gerados, porm preciso fazer o teste para ver se so vlidos, pois sero vlidos somente se t1 e t2 resultem nos mesmos (x,y) em suas equaes. Se no gerarem o mesmo (x,y) dizemos que as retas so paralelas, pois geraram pontos de interseco invlidos. Para retas 3D as equaes paramtricas so constitudas da mesma forma. Tendo um ponto P0 (x0, y0, z0) e o vetor diretor r (a, b, c):

28

x = x0 + t * a y = y0 + t * b z = z0 + t * c Tendo dois pontos P0 (x0, y0, z0) e P1 (x1, y1, z1): x = x0 + t * (x1 - x0) y = y0 + t * (y1 - y0) z = z0 + t * (z1 - z0) isolando o t das equaes temos:

X - x0 = X1 - x0

y - y0 = y1 - y0

z z0 z1 z0

Pode-se dizer que uma equao genrica de uma reta seria: P = P0 + t * r Ento se tem que o ponto P igual a um parmetro multiplicado pelo vetor diretor acrescidos do ponto P0. A Figura 7 ilustra essa frmula.

29

Figura 7 - Viso da frmula paramtrica da reta

1.6 Plano

Um plano definido por trs pontos no colineares (no pertencentes mesma reta), ou seja, esses trs pontos so contidos somente por um plano. A equao da reta a frmula para sabermos se um ponto realmente est inserido em um determinado plano, e tambm, com essa equao podemos encontrar todos os pontos pertenam ao plano. A equao geral do plano ax+by+cz+d = 0. Tendo trs pontos de um determinado plano: P1 (x1,y1,z1), P2 (x2,y2,z2) e P3 (x3,y3,z3) a equao que rege o plano que contm os trs pontos dada pelo determinante da matriz abaixo segundo (DRAKOS, 1994): x-x1 x2x1 y-y1 y2y1 z-z1 z2z1 =0

30

x3x1

y3y1

z3z1

Resolvendo a matriz encontramos: a = y2*z3 - y2*z1 - y1*z3 - y3*z2 + y1*z2 + y3*z1 b = x3*z2 - x1*z2- x3*z1 - x2*z3 + x2*z1 + x1*z3 c = x2*y3 - x2*y1 - x1*y3 - x3*y2 + x1*y2 + x3*y1 d = - a*x1 - b*y1- c*z1 A forma paramtrica da equao de reta : x = (1 - m - n) * x1 + m * x2 + n * x3 y = (1 - m - n) * y1 + m * y2 + n * y3 z = (1 - m - n) * z1 + m * z2 + n * z3 onde m e n so parmetros da equao e um ponto qualquer P(x,y,z) pertencer somente ao plano se existir um m e n que satisfaa as trs equaes paramtricas do plano.

MODELAGEM DE SLIDOS

De acordo com (PIO, 2004), Um slido em seu sentido fsico pode ser entendido como uma substncia material, em cuja molculas tm situao mais ou menos estvel e espontaneamente no mudam de lugar. Os corpos em estado slido tm forma prpria e volume prprio, possuindo ainda, menor ou em maior grau, energia de forma e volume, ou seja, resistem s deformaes. A Modelagem de Slidos uma rea da Computao Grfica que estuda a construo e representao consistente de modelos de slidos em computador. Podemos entende-la como o conjunto de tcnicas, teorias e sistemas de computadores, para a completa informao sobre slidos representao que permita no mnimo calcular automaticamente qualquer informao geomtrica bem definida sobre o slido. Nas sees seguintes desse captulo, tem-se um estudo sobre dois tipos de representaes a por Superfcies Paramtricas e a representao por faces triangulares.

2.1 Superfcies Paramtricas

De maneira geral dizemos que o mtodo de Superfcies Paramtricas a discretizao do domnio do problema, ou seja, a completa definio do problema fsico. Segundo Lira (2002) essa discretizao denominada ... malha de elementos, consiste em um conjunto de ns ou vrtices (pontos com coordenadas) e um conjunto de clulas com uma topologia pr-definida. Esses elementos se definem por uma lista de vrtices pertencentes a eles, ou seja, o nmero de vrtices define o tipo de elemento empregado (tringulos, quadrilteros, ou tetraedros, por exemplo).

32

Os mtodos de formas implcitas e equaes paramtricas so os mais comuns de representao de superfcies/malhas em modelagem geomtricas. A forma implcita lida no espao Euclidiano (x,y,z) sendo que a sua superfcie dada pela equao f(x,y,z) = 0 (LIRA, 2002). A representao paramtrica da superfcie dada por S(u,v) = (x(u,v),y(u,v),z(u,v)), sendo u e v formadores do sistema de eixos no espao paramtrico da superfcie (LIRA, 2002). Para algoritmos de clculo de interseco empregada a forma paramtrica da representao de superfcies, pois se torna possvel trabalhar com duas dimenses (v,u) para encontrar a regio de interseco. A Figura 8 mostra o exemplo de uma superfcie definida no espao Euclidiano e o seu espao paramtrico.

(LIRA, 2002) Figura 8 - Representaes de uma superfcie: a) espao Euclidiano; b) espao paramtrico.

2.2 Faces Triangulares

O modelo de slido abordado neste trabalho constitudo de faces triangulares, ou seja, os slidos so conjuntos de faces triangulares. Cada face triangular formada por trs vrtices (pontos) e trs linhas de

33

bordas (segmentos de retas entre os vrtices). Este modelo o adotado por ser bastante usual em softwares de modelagem. O tringulo a face mais simples existente, pois so utilizados trs pontos na sua constituio. Alm disso, ganha-se muita liberdade para criao de slidos, pois com um tringulo possvel formar uma infinidade de formas geomtricas. Outra informao importante a respeito desse tipo de slido que pode haver uma grande diferena de rea entre os tringulos. Porm esse fato tem uma explicao simples. Em caldeiraria, por exemplo, so feitos clculos de peas grandes e de mdio porte como caracol de hidroeltricas, cones, etc e para facilitar a traagem em uma chapa preciso simplificar a forma da planificao. Na Figura 9 pode ser visto a montagem de um caracol. Esse outro ponto importante para essa adoo de faces triangulares, porque facilita a criao da planificao da pea. Um bom exemplo desse problema de traagem um cone, pois pelo mtodo tradicional o cone traado por dois arcos e duas linhas, como mostrado na Figura 10. Para desenvolver um arco preciso ter um compasso que comporte a abertura do raio h pea grandes que precisam de cerca de 20 metros de raio (ou mais at). J o mtodo da triangulao utiliza os mesmos tringulos que formam a pea 3D para gerar a planificao, o que torna sua traagem mais simples. Na Figura 11 visto a mesma planificao da Figura 10 s que utilizando o mtodo da triangulao.

Figura 9 - Caracol de hidroeltrica

34

Figura 10 - Traagem do cone no processo tradicional

Figura 11 - Traagem utilizando mtodo da triangulao

3 ESTUDO DE CASOS DA LITERATURA SOBRE INTERSECO DE SLIDOS DE FACES TRIANGULARES

Na literatura existem diversos algoritmos para interseco de slidos, nas sees seguintes ser abordado a Interseco de pares de tringulos, entre superfcies triangulares e superfcies paramtricas.

3.1 Interseco de pares de tringulos

Este mtodo de interseco tambm conhecido como forabruta. Ele consiste em checar se todas a linhas de borda de um tringulo A (Ta) possui interseco com um tringulo B (Tb), se no for encontrado, checa todas as linhas de borda do Tb para Ta (ZACHMANN, 2003). Isso acarreta em no mximo 5 interaes para saber se a linha de Ta intercepta Tb. O nmero de linhas dos tringulos testados podem ser diminudos para no mximo 4 (ZACHMANN, 2003). Segundo Wang e Lo (2004), para a interseco de pares de faces de tringulos h quatro casos gerais que podem ser identificados: 1 A interseco do ponto P est dentro do tringulo ABC como mostrado na Figura 12.

36

(WANG, 2004) Figura 12 - Interseco entre dois tringulos (tipo 1) 2 A interseco do ponto P est na borda do tringulo ABC com mostrado na Figura 13.

(WANG, 2004)

Figura 13 - Interseco entre dois tringulos (tipo 2) 3 A interseco do ponto P est no vrtice do triangulo ABC com mostrado na Figura 14.

(WANG, 2004)

Figura 14 - Interseco entre dois tringulos (tipo 3)

37

4 A interseco maior que um ponto e os tringulos esto em um mesmo plano como mostrado na Figura 15.

(WANG, 2004) Figura 15 - Interseco entre dois tringulos (tipo 4) Um algoritmo de interseco precisa identificar a qual desses tipos interseco dos pares de tringulos se encaixa. Portanto cada um desses tipos uma tratativa diferenciada. Na Tabela 1 so apresentadas as vantagens e desvantagens desse mtodo. Vantagens Facilidade de Desvantagens - Algoritmo ineficiente testar dois a dois o

implementao ( o algoritmo mais (por ser um mtodo em que simples existente para interseco de necessrio slidos de faces triangulares); - Utiliza o modelo de slido do trabalho tringulo).

Tabela 1 - Vantagens e desvantagens da interseco de pares de tringulos

3.2 Interseco entre superfcies triangulares

38

Uma interseco entre duas superfcies representada por laos ou loops de segmentos de linhas (WANG, 2004). Por toda essas linhas de interseco esto tringulos vizinhos uns dos outros. Pode-se tomar isso como base para desenvolver um algoritmo capaz de se utilizar desse conceito de vizinhana para encontrar as linhas de interseces entre as superfcies triangulares. Este algoritmo denominado TNOIT (tracing the neighbours of intersecting triangles). Existem segundo Wang e Lo (2004) quatro tipos que devem ser considerado para um algoritmo dessa natureza que so: 1 Se em um ponto de interseco est dentro do tringulo ento no necessrio traar seus vizinhos (WANG, 2004). Como mostrado na Figura 16. Neste caso, a continuao da interseco do ponto P (prximo ponto depois de P a ser encontrado) tambm est dentro de T1.

(WANG, 2004) Figura 16 - Ponto P dentro do tringulo (tipo 1) 2 Se o ponto de interseco P est na borda de T1, e h um tringulo T2 que compartilha essa borda (vizinho), ento o prximo ponto de interseco estar em T2 e ser encontrada pelo algoritmo em T2. Com mostrado na Figura 17.

39

(WANG, 2004) Figura 17 - Ponto P na borda do tringulo (tipo 2) 3 Se o ponto de interseco P for um vrtice de T1 ento todos os tringulos em que possuam esse vrtice em comum precisaram ser analisados para encontrar a continuao da linha de interseco. preciso considerar ento os tringulos T2, T3, T4, T5 para a interseco com o tringulo F1, pois P est em todos eles. Na Figura 18 esse processo visualizado.

(WANG, 2004) Figura 18 - Ponto P um vrtice do tringulo (tipo 3) 4 Se dois tringulos esto no mesmo plano ento no necessrio computar a interseco. Como mostrado na Figura 19 o resultado da interseco poder ser uma rea (no somente um segmento de reta). Esse tipo de situao no tratado por Wang e Lo (2004).

(WANG, 2004) Figura 19 - Os tringulos esto em um mesmo plano (tipo 4)

40

Na Tabela 2 so apresentadas as vantagens e desvantagens desse mtodo. Vantagens - Algoritmo eficiente por utilizar as vantagens vizinhana entre os tringulos, pois tcnicas). no necessrio o teste de todas as faces, somente sero testadas as faces que a linha de interseco ir passar e suas vizinhas; - Utiliza o modelo de slido do trabalho. Desvantagens - Implementao mais

da difcil (sua implementao exige mais

Tabela 2 - Vantagens e desvantagens da interseco entre superfcies triangulares

3.3 Interseco de superfcies paramtricas

Uma boa soluo para localizao das linhas de interseco com superfcies paramtricas deve satisfazer os seguintes critrios segundo Lira (2002): Exatido: As curvas de interseco calculadas devem estar sobre as superfcies. Se as curvas de interseco esto apenas sobre as faces das malhas, mas no esto sobre as superfcies, pode fornecer resultados inaceitveis.

41

Fidelidade: A geometria da superfcie resultante deve refletir, fielmente, a geometria das superfcies originais, porque elas representam a inteno do responsvel pela modelagem. Preciso: Pontos no espao paramtrico correspondendo ao mesmo ponto de interseco devem estar a uma distncia muito pequena (deve-se adotar uma distncia mxima padro). Coelho (2000) props um algoritmo para determinar a interseco entre as malhas das superfcies A e B como sendo: (1) Determinao dos pontos de interseco: (1a) Clculo e armazenamento das interseces das arestas em A contra as arestas em B; (1b) Clculo e armazenamento das interseces das arestas em B contra as faces em A. (2) Determinao das curvas de trimming1: (2a) Conexo dos pontos de interseco em linhas poligonais representando as curvas de trimming; (2b) Interpolao das curvas paramtricas passando pelos pontos de linha poligonal; (2c) Determinao de novos pontos com espaamento adequado nessas curvas; (2d) Projeo desses novos pontos em cada superfcie.

Curvas resultantes de interseco entre superfcies com representaes nos seus espaos paramtricos e no espao tridimensional.

42

(3) Reconstruo da topologia: (3a) Determinao das regies de trimming removendo vrtices e arestas baseadas na linha poligonal; (3b) Insero de novas arestas sobre as curvas de trimming usando os novos pontos definidos no passo (2c); (3c) Triangulao das regies de trimming em ambas superfcies; (3d) Suavizao das malhas. Este algoritmo proposto por Coelho (2000) completo, pois alm de encontrar os pontos da interseco ele ajusta a representao e as corta neste ponto. A ttulo deste trabalho se est buscando a localizao da regio de interseco (passo (1)) por isso os passos (2) e (3) desse algoritmo no sero tratados. Na Figura 20 pode ver o resultado do algoritmo do coelho para duas superfcies paramtricas. As malhas das superfcies so armazenadas em uma estrutura de dados chamada de DCEL (Doubly Connecter Edge List) (PREPARATA, 1990). Essa estrutura utilizada quando se precisa guardar informaes entre duas malhas, informaes que sero utilizadas para encontrar as curvas de trimming. Alm disso, as entidades (vrtices, arestas e faces) so armazenadas em rvores, ao invs de listas ou vetores, para que se ganhe velocidade nas buscas necessrias. As arestas ainda possuem uma varivel chamada intersection, que a chave para conexo entre as duas estruturas de dados DCEL das superfcies.

43

(LIRA, 2002) Figura 20 - Exemplos de superfcies paramtricas que passaram pelo algoritmo de (COELHO, 2000) No passo (1) do algoritmo, as arestas de uma superfcie so testadas contra as faces na outra superfcie que so candidatas a interceptalas, ou seja, a entrada do algoritmo uma rvore de faces e arestas de cada superfcies contendo ainda uma ligao com as faces candidatas da outra superfcie. Para cada aresta/face selecionados, preciso encontrar a interseco resolvendo o problema de minimizao F(u,v,t) = S(u,v) R(t), como mostrado na Figura 21. O algoritmo busca resolver a minimizao at que distncia entre o ponto da aresta com valor paramtrico t e o ponto da face com coordenadas (u,v) menor que a tolerncia. A tolerncia adotada como uma frao do menor comprimento das arestas envolvidas na interseco. Na Figura 21, o parmetro t, define a variao ao longo da aresta interceptada, pode ser expresso como uma interpolao linear dada pelo segmento de reta no espao paramtrico (w,h) que conecta V0 e V1. Aps encontrar os dois pares paramtricos (uf,vf) e (ue,ve), da face e da aresta respectivamente, o algoritmo para localizao de ponto em polgono verifica se

44

o ponto interno, externo, sobre a borda, ou sobre o vrtice da face em questo. Se o ponto estiver fora da face no um ponto da interseco. Se o ponto estiver sobre uma aresta, alm do par aresta/face, a aresta identificada pelo algoritmo deve ser atualizada. Quando a interseco estiver sobre um vrtice da face todas as arestas adjacentes a esse vrtice devem ser atualizados. Essa atualizao consiste em atualizar a varivel intersection da aresta. Para completar a localizao dos pontos de interseco deve-se repetir esse procedimento trocando as superfcies, ou seja, testando as arestas da segunda superfcie contra as faces da primeira.

(LIRA, 2002) Figura 21 - Problema de interseco Para se encontrar as Curvas de interseco, percorre-se as faces interceptadas da primeira superfcie, propagando-se a interseco pelas faces adjacentes das arestas interceptadas, identificadas pela varivel intersection. Cada ponto de referncia das arestas interceptado em cada superfcie armazenado e quando todas as faces tiverem sido percorridas, todos os componentes conectados da interseco foram encontrados. Esses

45

pontos so os pontos chaves da interseco. Esses pontos chaves so os utilizados para encontrar a curva de trimming, como as faces desse tipo de estrutura so curvas no so traadas linhas entre os pontos, mas sim curvas e essas curvas so chamadas de curvas de trimming. Porm esses pontos j so suficientes, pois se tem que transformar para a topologia de slidos tratada neste trabalho que por faces triangulares. Na Tabela 3 so apresentadas as vantagens e desvantagens desse mtodo.

Vantagens como Possui grande

Desvantagens - Torna-se complicado

desempenho, pois trata os slidos o uso para o modelo de slido superfcies paramtricas empregado no trabalho, pois preciso parametricamente Isso pode vir a os slidos. causar contendo dois parmetros. Com isso descrever torna-se aplicvel os algoritmos 2D.

limitaes futuras, pois possvel que existam slidos que sejam incapazes de serem convertidos para esse formato. Tabela 3 - Vantagens e desvantagens da interseco de superfcies paramtricas

46

4 FILTRAGEM

Uma maneira muito eficaz de se otimizar um algoritmo de interseco minimizar o nmero de faces que se analisar. Uma das formas de se conseguir essa filtragem subdividindo o espao em vrias regies e testar se nessas regies h faces de ambos os slidos. Caso haja somente faces de um slido essa regio descartada para o algoritmo de interseco, pois certamente no h interseco. Para o algoritmo de filtragem apresentado neste trabalho h duas partes. A primeira parte denominada de filtro grosso e a segunda de filtro fino. O filtro grosso responsvel pelo primeiro refino. Nele os slidos so substitudos por um paraleleppedo, esses paraleleppedos so formados atravs de (Xmnimo, Xmximo), (Ymnimo, Ymximo) e (Zmnimo, Zmximo) do slido. Seu pseudocdigo o seguinte: 1. Calcular dimenses mnimas e mximas dos slidos; 2. Encontrar a interseco entre os paraleleppedos

gerados dos slidos; 3. Encontrar as faces que possuem alguma parte dentro do paraleleppedo resultante. No passo1 montado o paraleleppedo de ambas as peas encontrando suas coordenadas mximas e mnimas. No passo dois, usando as dimenses mximas e mnimas de cada eixo (x,y,z), encontra-se a interseco dos paraleleppedos dos slidos. O processo para encontrar essa regio precisa ser feito para X, Y, Z e o

47

seguinte:

Se mnimo1 mnimo2 E mximo1 > mnimo2 Ento MnimoIntersec mnimo2 Se mximo2 < mximo1 Ento MximoIntersec mximo1 Seno MximoIntersec mximo2 Fim Se Seno Se mnimo2 mnimo1 E mximo2 > mnimo1 Ento MnimoIntersec mnimo1 Se mximo2 < mximo1 Ento MximoIntersec mximo1 Seno MximoIntersec mximo2 Fim Se Seno No h interseco entre os slidos Fim Se

onde mnimo1 e mximo1 so referentes ao slido 1 e mnimo2 e mximo2 ao slido2. O processo ir retornar o MnimoIntersec e MximoIntersec que forma o paraleleppedo de interseco. Esse passo tambm identifica grossamente se h ou no interseco entre os slidos, pois se no h interseco entre os paraleleppedos certamente os slidos no se interseccionam e pode-se parar o processo neste momento. MinimoIntersec e MximoIntersec nada mais do que (Xmnimo, Xmximo), (Ymnimo, Ymximo) e (Zmnimo, Zmximo) do paraleleppedo de interseco. Pode-se ento encontrar os 8 vrtices dessa regio importante, sendo: 1 (Xmnimo, Ymnimo, Zmnimo); 2 (Xmximo, Ymnimo, Zmnimo); 3 (Xmnimo, Ymximo, Zmnimo); 4 (Xmximo, Ymximo, Zmnimo); 5 (Xmnimo, Ymnimo, Zmximo); 6 (Xmximo, Ymnimo, Zmximo); 7 (Xmnimo, Ymximo, Zmximo); 8 (Xmximo, Ymximo, Zmximo). Na Figura 22 mostrado constituio da regio de interseco entre os paraleleppedos.

48

Aps ter encontrado a regio de interseco entre os paraleleppedos, o passo3 encontrar as faces que pertenam a essa regio, por isso recebe o nome de filtro fino". Para isso basta calcular (Xmnimo, Xmximo), (Ymnimo, Ymximo) e (Zmnimo, Zmximo) de todas as faces de ambos os slidos. Com essas informaes tem-se um paraleleppedo que contenha a face triangular. Para que uma face triangular esteja dentro do paraleleppedo interseco (calculado no passo2) preciso testar se h interseco entre esse paraleleppedo interseco e o paraleleppedo da face. Havendo a face est na regio de interseco e continuam como faces que sero analisadas pelo algoritmo de interseco.

Figura 22 - Regio de interseco entre os paraleleppedos O segundo filtro consiste em dividir a regio de interseco encontrada no passo2 do filtro grosso em partes menores (diviso espacial). Onde para cada face que passe pelo passo3 do mesmo seja inserida na lista de faces de pelo menos uma clula, mas pode pertencer a todas. Por isso para cada face que est na regio de interseco, buscar em todas as clulas se est inserida nela. Para dividir o espao leva-se em conta o menor tamanho das faces. Tendo o tamanho menor para os eixos (X, Y, Z) ou (MenorX, MenorY, MenorZ), divide-se pelas dimenses do paraleleppedo de interseco por N partes de acordo com as equaes: Nx = Int((Xmximo - Xmnimo) / MenorX) + 1

49

Ny = Int((Ymximo - Ymnimo) / MenorY) + 1 Nz = int((Zmximo - Zmnimo) / MenorZ) + 1 Com isso se tem o nmero de divises para cada eixos. O nmero total de clulas Nx * Ny * Nz. Nx, Ny e Nz so inteiros e maiores que 1, ou seja, preciso pelo menos os dividir em duas partes. A forma da Clula a seguinte: xMax, xMin yMax, yMin zMax, zMin faces1 faces2 interseco

Aps a face ter passado pelo passo3 do filtro grosso, testada com todas as clulas para se saber quais das clulas que contenham pelo menos uma parte dessa face. Se contiver a face inserida na lista de faces de acordo com o slido que faa parte (se pertencer ao slido1 inserida na lista de faces1, se pertencer ao slido2 na lista de faces2). Para fazer o teste as faces so substitudas por um paraleleppedo utilizando-se suas dimenses mximas e mnimas, e essas dimenses so testadas com as dimenses mximas e mnimas das clulas. Todas as clulas que houver somente faces de um mesmo slido so descartadas pelo algoritmo de interseco (varivel interseco igual a 0 significa descarte). O algoritmo com os dois filtros o seguinte:

50

Encontrar MenorX, MenorY, MenorZ das faces. Encontrar Xmax, Xmin, Ymax, Ymin, Zmax, Zmin dos slidos. Calcular paraleleppedo de interseco entre os slidos. Dividir o paraleleppedo em clulas. Para todas faces dos dois slidos testar se esto na regio do paraleleppedo de interseco. Testando em quais clulas elas esto.

5 INTERSECO TRIANGULAR 2D

Um algoritmo de interseco de faces triangulares 3D precisa identificar e tratar de forma diferente tringulos que esto em um mesmo plano. Por isso se torna importante o estudo sobre interseco triangular 2D. O 2D nada mais que um plano no 3D (x = qualquer, y = qualquer, z=0), por esse motivo o seu algoritmo muito parecido ao que ser estudado para interseco 3D de tringulos no mesmo plano. preciso ter em mente de que quando estamos falando em interseco de tringulos no mesmo plano pode-se ter o resultados sendo: nulo, um ponto, um segmento de reta ou at mesmo uma rea. Essa rea pode ser desde um tringulo at um hexgono (onde sero seis pontos de interseco encontrados). O algoritmo tem a seguinte constituio:
Variveis Globais: Triangulo1(3, 2) // numrica Retas1(3, 7) // numrica Triangulo2(3, 2) // numrica Retas2(3, 7) // numrica PontosIntersec(6, 2) // numrica LinhasIntersec(6, 6) // numrica ultPontoInt // numrica Intersec2D() ultPontosInt = -1 // inicializa o ultimo ponto da interseco // primeira parte prepararRetas(Triangulo1(),Retas1()) // prepara as retas do triangulo1 prepararRetas(Triangulo2(),Retas2()) // prepara as retas do triangulo2 // segunda parte Para i 0 at 2 Se PontoNoTriangulo(Triangulo1(i, 0), Triangulo1(i, 1), Retas2()) = Verdadeiro ento InserirPontoIntersec(Triangulo1(i, 0), Triangulo1(i, 1)) // inserindo o ponto Fim Se

52 Prximo i Para i = 0 at 2 Se PontoNoTriangulo(Triangulo2(i, 0), Triangulo2(i, 1), Retas1()) = Verdadeiro ento InserirPontoIntersec(Triangulo2(i, 0), Triangulo2(i, 1)) // inserindo o ponto Fim se Prximo i PontosDeEncontro(Retas1(),Retas2()) // terceira parte LinhasIntersec() Fim Intersec2D

Podemos dividir esse algoritmo em trs partes. A primeira parte seria encontrar os segmentos de retas pertencentes aos dois tringulos. A segunda encontrar os pontos de interseco entre os tringulos. O terceiro encontrar as retas que compem a interseco dos tringulos. A seguir, sero abordadas as constituies das variveis e essas 3 partes do algoritmo (retas dos tringulos, pontos da interseco e segmentos da interseco).

5.1 Variveis Globais

As variveis principais usadas pela funo Intersec2D so globais ao Mdulo. Os vetores Triangulo1(3, 2) e Triangulo2(3, 2) contm as posies X e Y dos pontos do tringulo1 e do tringulo2 respectivamente. Ento para acessar as coordenadas do ponto 1 do tringulo1 temos Triangulo1(0, 0) como o X e Triangulo1(0, 1) como o Y, os demais pontos so encontrados da mesma forma. Esse vetor muito importante, pois ele que contm os dados de entrada e atravs dele que todos os outros vetores so calculados. Os vetores Retas1(3, 7) e Retas2(3, 7), so usados para armazenar a equaes dos segmentos de retas do tringulo1 e do tringulo2 respectivamente. So usadas as equaes paramtricas para esse algoritmo.

53

Essas equaes so calculadas a partir das coordenados dos tringulos. A constituio destes vetores a seguinte: Retas(nReta, 0) = x0 Retas(nReta, 1) = a Retas(nReta, 2) = y0 Retas(nReta,3) = b Retas(nReta,4) = menor t Retas(nReta,5) = maior t Retas(nReta,6) = tipo de interesse da reta onde nReta seria o nmero da reta (de 0 a 2). J o vetor PontosIntersec ir guardar os pontos da interseco encontrados. Sendo PontosIntersec(nPonto, 0) guarda a coordenada X e PontosIntersec(nPonto, 1) a Y. Como o nmero de pontos de interseco no fixo ser usado uma varivel auxiliar que contenha a posio do ltimo ponto inserido, ela chamada de ultPontoInt. O ultPontoInt nulo quando contiver o valor 1, sendo assim, se contiver o valor 1 o vetor de pontos de interseco estar nulo tambm. E por fim o LinhasIntersec(6, 6) que ir conter os segmentos de retas da interseco.

5.2 Retas dos tringulos

54

A funo no algoritmo encarregada de calcular as retas do tringulo a prepararRetas. Essa funo precisa de dois parmetros que so: o vetor de coordenadas dos pontos do tringulo e um vetor de resposta das retas. atravs desse vetor que as retas sero retornadas por isso a constituio desse vetor a mesma dos vetores Reta1 e Reta2. Essa funo a seguinte:

prepararRetas(Pontos(), Retas()) Para i 0 at 2 ji+1 Se j > 2 ento j0 Fim se fj+1 Se f > 2 ento f0 Fim se // primeira parte - encontrando reta // calculando as equaes paramtricas Retas(i, 0) Pontos(i, 0) // x0 Retas(i, 1) Pontos(j, 0) - Pontos(i, 0) Retas(i, 2) Pontos(i, 1) // y0 Retas(i, 3) Pontos(j, 1) - Pontos(i, 1)

// calculando o a // calculando o b

// encontrando menor e maior t // t = x - x0/a ou t = y - y0/b Se Retas(i, 1) 0 ento // usando a (X) para calcular o t Retas(i, 4) 0 // x = x0 sempre ento t=0 Retas(i, 5) (Pontos(j, 0) - Pontos(i, 0)) / Retas(i, 1) Seno // usando o b (Y) para calcular o t Retas(i, 4) 0 // y = y0 sempre Retas(i, 5) (Pontos(j, 1) - Pontos(i, 1)) / Retas(i, 3) Fim se // Incio da segunda parte - se analisa maior ou menor xf Pontos(f, 0) // do Pf yf Pontos(f, 1) // do Pf Se reta(nReta, 1) = 0 ento // se a = 0 Se xf > Retas(i, 0) ento Retas(i, 6) 2 // Maior Seno Retas(i, 6) 1 // Menor Fim se Seno Se reta(nReta, 3) = 0 ento // se b = 0 Se yf > Retas(i, 2) ento

55 Retas(i, 6) 2 // Maior Seno Retas(i, 6) 1 // Menor Fim se Seno // se a 0 e b 0 Se ((Retas(i, 2) + Retas(i, 3) * (xf - Retas(i, 0)) / Retas(i, 1)) < yf) ento Retas(i, 6) 2 // Maior Seno Retas(i, 6) 1 // Menor Fim se Fim se Prximo I Fim prepararRetas

Essa funo possui trs variveis ndices que so: i, j e f. Onde i contm o ndice do vetor de pontos do Ponto i (Pi), j a do Ponto j (Pj) e f do ponto restante que seria o Pf. A posio de Pi tambm a mesma da Reta decorrente, se Pi o ponto 1 do vetor de Pontos (ndice 0) ento estamos calculando a reta 1, j se Pi o ponto 3 do vetor de pontos estamos calculando a terceira reta. Cada tringulo formado por 3 segmentos de retas, cada segmento pertencente ao tringulo definido por dois pontos do tringulo (dois vrtices). As retas do tringulo so definidas por: reta1 (P1 e P2), reta2 (P2 e P3) e reta3 (P3 e P1). Os pontos Pi e Pj so usados para calcular: x0, a, y0, b, tMnimo, tMximo. Adotou-se como padro que x0 sendo igual ao Xi (X de Pi) e o y0 igual ao Yi. O clculo de a Xj Xi e b Yj Yi. Essa a primeira parte do algoritmo. So tMnimo e tMximo que delimitam o segmento, pois sem eles no possvel dizer qual parte da reta que pertence ao tringulo. bom salientar que o tMnimo ser 0 e que o tMximo ser 1, pois os mesmos pontos usados para calcular a reta, delimitam o segmento. A segunda parte do algoritmo encontrar onde est o Pf (PBase) em relao reta, para atribuirmos o valor do tipo de interesse da reta. Se Pf estiver direta e/ou acima da reta dizemos que o ponto maior e se for esquerda e/ou abaixo dizemos que menor. No item 5.3.2 ser utilizado o tipo de interesse da reta. Se o Pf for maior, Retas(i, 6) receber

56

valor 2 se for menor receber valor 1. Na Figura 23, vemos que Pf est direita da reta i por isso dizemos que neste caso Pf maior. Existem 3 condies para que se possa saber se um ponto Maior ou Menor. Na primeira se o coeficiente a da equao X da reta for igual a 0, seu X ser sempre constante e igual a X0. Dizemos ento que para Pf ser Maior preciso ter Xf maior que o X constante da reta (X0 da reta), ou seja, estar direita da reta, para ser menor precisa ter Xf menor que o X constante da reta (esquerda).

Figura 23 - Delimitando os segmentos de retas (transformando em inequaes) Na segunda se o coeficiente b for igual a 0, seu Y ser sempre constante e igual a y0. Dizemos ento que para Pf ser Maior precisa ter Yf maior que o Y constante da reta (Y0 da reta), ou seja, esta acima da reta, para ser menor precisa ter Yf menor que o Y constante da reta (abaixo). Se a e b forem diferentes de 0 ento utilizamos Xf para calcular um t e com esse t calculamos o Y. Se o Yf for Maior que esse Y dizemos que ele maior (est acima e a direita). J se o Yf for Menor que Y ento ele Menor (abaixo e a esquerda). Esse Y de teste calculado no algoritmo sem usar esse t usando a frmula y0 + b * (xf x0) / a.

57

5.3 Encontrando pontos de interseco

Para encontrar os pontos de interseco h trs funes envolvidas: inserirPontoIntersec, PontoNoTriangulo e PontosDeEncontro. A seguir visto detalhadamente cada uma dessas funes.

5.3.1 Funo inserirPontoIntersec

A funo inserirPontoIntersec somente utilizada para inserir um ponto de interseco no vetor PontosIntersec. O cdigo da funo o seguinte:
inserirPontoIntersec(x, y) Se ultPontoInt -1 ento Para i 0 at ultPontoInt Se PontosIntersec(i, 0) = x E PontosIntersec(i, 1) = y ento Sair inserirPontoIntersec // tem igual Fim se Prximo i Fim Se ultPontoInt = ultPontoInt + 1 PontosIntersec(ultPontoInt, 1) = x PontosIntersec(ultPontoInt, 2) = y Fim inserirIntersec

Essa funo recebe as coordenadas (x, y) de um ponto que faz parte da interseco e testa se esse ponto j no foi inserido anteriormente no vetor. Se isso ocorrer ele no insere e sai da funo, caso encontre insere e incrementa ultPontoInt.

5.3.2 Funo PontoNoTriangulo

58

A funo PontoNoTriangulo procura se um determinado ponto est dentro de um tringulo. Os parmetros da funo so x e y do ponto de procura e o vetor de retas do tringulo que se vai procurar. Seu retorno boleano, ou seja, verdadeiro ou falso. Seu cdigo o seguinte:
PontoNoTriangulo(xPonto, yPonto, Retas()) Para i = 0 To 2 x0 Retas(i, 1) a Retas(i, 2) y0 Retas(i, 3) b Retas(i, 4) Se a = 0 ento t (yPonto - y0) / b // se for menor Retas(i, 7) = 1 e xPonto > x0 ento no est no tringulo Se (((xPonto > x0) E (Retas(i, 7) = 1)) Ou ((xPonto < x0) E (Retas(i, 7) = 2))) ento retorna Falso Fim se Seno Se b = 0 ento t (xPonto - x0) / a // estiver acima do maior ou menor que o menor t no satisfaz a essa reta Se (((yPonto > y0) E (Retas(i, 7) = 1)) Ou ((yPonto < y0) E (Retas(i, 7) = 2))) ento retorna Falso Fim se Seno Se Retas(i, 7) = 1 ento //t de x precisa gerar um y menor igual ao ycalculado Se ((y0 + b * (xf - x0) / a) > yf) ento retorna Falso Fim se Seno // t de x precisa gerar um y maior igual ao ycalculado Se ((y0 + b * (xf - x0) / a) < yf) ento retorna Falso Fim se Fim se Fim se Prximo i retorna Verdadeiro Fim PontoNoTriangulo

Ela no trabalha com os segmentos de retas, mas sim, com inequaes, ou seja, as retas tornam-se como: x>=x0+a*t ou x<=x0+a*t e y>=y0+b*t ou y<=y0+b*t. Pode-se dizer que se um ponto satisfazer as trs inequaes do tringulo ele est dentro do tringulo (est na regio de interseco entre as inequaes). Na Figura 24 possvel visualizar a regio do tringulo (interseco entre as inequaes).

59

Figura 24 - Regio de um tringulo exatamente esse teste que a funo faz. Utiliza-se o tipo de interesse da reta calculado pela funo de inicializao da reta prepararRetas. Se esse tipo for 2 equivale a >=, se for 1, <=. O algoritmo testa de forma a encontrar o primeiro momento que o ponto no satisfaa uma inequao, ento se a rea de interesse da inequao a >= a reta, ser testado como <, ento se for < j sai da funo retornando falso (no necessrio testar todas as inequaes). O algoritmo primeiramente testa se a igual a 0, sendo assim, se preocupa somente com a inequao de X. O mesmo processo ocorre se b igual a 0, onde a inequao Y somente levada em conta para o teste. Caso a e b sejam diferentes de 0 ento preciso encontrar o t do x do ponto de teste substituir na inequao de Y e testar se esse resultado de Y calculado < (para tipo de interesse da reta igual a 2) ou > (para tipo de interesse da reta igual a 1) que o Y do ponto de busca. S retornado verdadeiro se passar por todas as inequaes.

60

5.3.3 Funo PontosDeEncontro

A funo PontosDeEncontro tem como objetivo encontrar se segmentos de retas de um tringulo 1 se cruzam com as de um tringulo 2. Esses pontos encontrados so inseridos no vetor de interseco, pois so partes da interseco tambm. Ele recebe o vetor de retas1 (tringulo 1) e o vetor de retas 2 (tringulo 2). Abaixo segue o cdigo da funo:
encontrarPontosDeEncontro(Retas1(), Retas2()) // tringulo1 Para i 0 at 2 x01 Retas1(i, 0) a1 Retas1(i, 1) y01 Retas1(i, 2) b1 Retas1(i, 3) tMax1 Retas1(i, 4) tMin1 Retas1(i, 5) // tringulo2 Para j 0 at 2 x02 Retas2(j, 0) a2 Retas2(j, 1) y02 Retas2(j, 2) b2 Retas2(j, 3) tMax2 Retas2(j, 4) tMin2 Retas2(j, 5) // inicio do encontro Se (a1 * b2 - b1 * a2) = 0 ento // mesma reta xMax1 x01 + tMax1 * a1 xMin1 x01 + tMin1 * a1 yMax1 y01 + tMax1 * b1 yMin1 y01 + tMin1 * b1 xMax2 x02 + tMax2 * a2 xMin2 x02 + tMin2 * a2 yMax2 y02 + tMax2 * b2 yMin2 y02 + tMin2 * b2 // convertendo t reta2 para t de reta1 Se a1 0 ento t2Max (xMax2 - x01) / a t2Min (xMin2 - x01) / a Seno t2Max (yMax2 - y01) / b t2Min (yMin2 - y01) / b Fim se

61 Se t2Min tMin1 E t2Max tMax1 ento inserirPontoIntersec xMin2, yMin2 inserirPontoIntersec xMax2, yMax2 Seno Se tMin1 t2Min E tMax1 t2Max ento inserirPontoIntersec xMin1, yMin1 inserirPontoIntersec xMax1, yMax1 Seno se tMin1 t2Min E tMin1 t2Max E tMax1 > t2Max ento inserirPontoIntersec xMin1, yMin1 inserirPontoIntersec xMax2, yMax2 Seno se t2Min tMin1 E t2Min tMax1 E t2Max > tMax1 ento inserirPontoIntersec xMin2, yMin2 inserirPontoIntersec xMax1, yMax1 End If Seno t1 ((x02 - x01) * b2 + (y01 - y02) * a2) / (b2 * a1 - b1 * a2) t2 ((x01 - x02) * b1 + (y02 - y01) * a1) / (b1 * a2 - b2 * a1) Se t1 tMax1 E t1 tMin1 ento Se t2 tMax2 E t2 tMin2 ento x x01 + t1 * a1 y y01 + t1 * b1 // testa se as retas no so paralelas Se (x = x02 + t2 * a2) E (y = y02 + t2 * b2) ento inserirPontoIntersec x, y Fim Se Fim Se Fim Se Fim Se Prximo j Prximo I Fim encontrarPontosDeEncontro

A funo possui algumas variveis, porm foram adotadas somente para deixar o cdigo mais limpo para o entendimento e foram usados nomes sugestivos. Na funo existem dois laos, um para cada tringulo. atravs desses laos que todos os seguimentos de retas que formam os tringulo1 e tringulo2 so testados dois a dois. Em tringulos diferentes os segmentos de retas podem pertencer mesma reta ou no. So essas duas situaes tratadas no algoritmo. Se (a1 * b2 - b1 * a2) = 0 ento os dois segmentos esto na mesma reta. A interseco dos dois segmentos de reta pode ser nula, um ponto ou pode at gerar um terceiro segmento de reta. Caso gere um ponto, no levado em considerao, pois j foi inserido pela funo PontoNoTriangulo no vetor de pontos da interseco ( um vrtice de um dos

62

tringulos). Para que possamos saber o segmento de reta que a interseco dos dois segmentos da reta em anlise preciso ter os tMax e tMin dos dois segmentos da reta, ento sempre se converte o segmento do tringulo 2 para as equaes do tringulo1. O tMax2 convertido para as equaes do tringulo1 guardado pela varivel t2Max (que encontrado atravs do xMax2 ou yMax2 usando equao de 1) e tMin2 convertido est em t2Min (que encontrado atravs do xMin2 ou yMin2 usando equao de 1). Com tMax1, t2Max e tMin1 e t2Min possvel encontrar se pertence a um dos quatro tipos seguintes: pertence ao tipo1 se: t2Min for maior ou igual tMin1 e t2Max for menor ou igual a tMax1. A interseco ento o segmento do tringulo 2. Como mostrado na Figura 25.

Figura 25 - Interseco de segmentos de retas tipo 1 pertence ao tipo2 se: tMin1 for maior ou igual t2Min e tMax1 for menor ou igual a t2Max. A interseco ento o segmento do tringulo 1. Como mostrado na Figura 26.

Figura 26 - Interseco de segmentos de retas tipo 2 pertence ao tipo3 se: tMin1 for maior ou igual t2Min, tMin1 for menor ou igual a t2Max e tMax1 for maior que t2Max.

63

A interseco ento o segmento formado por tMin1 e t2Max. Como mostrado na Figura 27.

Figura 27 - Interseco de segmentos de retas tipo 3 pertence ao tipo4 se: t2Min for maior ou igual tMin1, t2Min for menor ou igual a tMax1 e t2Max for maior que tMax1. A interseco ento o segmento formado por t2Min e tMax1. Como mostrado na Figura 28.

Figura 28 - Interseco de segmentos de retas tipo 4 Caso no pertena mesma reta, o trabalho do algoritmo identificar em que ponto as retas, em que os segmentos de retas dos tringulos esto inseridos, se cruzam. A primeira coisa a se fazer identificar o t1 e t2 que so relativos aos pontos onde a retas se cruzam para a reta do tringulo 1 e do tringulo 2 respectivamente. Em seguida, v-se t1 est dentro do segmento de reta aceitvel por tMax1 e tMin1, e se t2 tambm est entre tMax2 e tMin2. Se at agora tudo for vlido um ltimo teste precisa ser feito. Se o ponto gerado por t1 e t2 forem diferentes no existe ponto de encontro das retas, ou seja, elas so paralelas, caso contrrio s inserir o ponto no vetor de pontos de interseco.

5.4 Segmentos da interseco

64

Para encontrar os segmentos da interseco precisa-se testar todos os pontos dois a dois do vetor de pontos da interseco (j encontrado anteriormente). Por isso se no houver pelo menos dois pontos o algoritmo no utilizado, pois no h segmentos de retas. A funo LinhasIntersec esse algoritmo est exemplificado:
LinhasIntersec() Se ultPontoInt > 0 ento Para i 1 at ultPontoInt - 1 Para j 2 at ultPontoInt // tringulo1 Para k 0 To 2 // todas as retas do tringulo 1 x0 Retas1(k, 0) a Retas1(k, 1) y0 Retas1(k, 2) b Retas1(k, 3) Se a = 0 Ento Se PontosIntersec(i, 0) = x0 E PontosIntersec(j, 0) = x0 Ento ultLinhaInt ultLinhaInt + 1 // Insere linha e prximo j Fim Se SenoSe b = 0 Ento Se PontosIntersec(i, 1) = y0 E PontosIntersec(j, 1) = y0 Ento ultLinhaInt ultLinhaInt + 1 // Insere linha e prximo j Fim Se Seno t1 (PontosIntersec(i, 0) - x0) / a Se (y0 + b * t1) = PontosIntersec(i, 1) Ento t2 (PontosIntersec(j, 0) - x0) / a Se (y0 + b * t2) = PontosIntersec(j, 1) Ento ultLinhaInt ultLinhaInt + 1 // Insere linha e prximo j Fim Se Fim Se Fim Se Prximo k // tringulo2 Para k 0 To 2 x0 Retas2(k, 0) a Retas2(k, 1) y0 Retas2(k, 2) b Retas2(k, 3) Se a = 0 Ento Se PontosIntersec(i, 0) = x0 E PontosIntersec(j, 0) = x0 Ento ultLinhaInt ultLinhaInt + 1 // Insere linha e prximo j Fim Se SenoSe b = 0 Ento Se PontosIntersec(i, 1) = y0 E PontosIntersec(j, 1) = y0 Ento ultLinhaInt ultLinhaInt + 1

65 // Insere linha e prximo j Fim Se Seno t1 = (PontosIntersec(i, 0) - x0) / a Se (y0 + b * t1) = PontosIntersec(i, 1) Ento t2 (PontosIntersec(j, 0) - x0) / a Se (y0 + b * t2) = PontosIntersec(j, 1) Ento ultLinhaInt ultLinhaInt + 1 // Insere linha e prximo j Fim Se Fim Se Fim Se // j achou todas as retas pois chegou ao nmero de pontos Se ultLinhaInt = totPontosInt Ento Sair LinhasIntersec Fim Se Prximo k Fim Se Prximo j Prximo i Fim Se Fim LinhasIntersec

Para cada dois pontos do vetor de interseco ele encontra a primeira reta pertencente a um dos tringulos em que esses dois pontos esto inseridos e retorna essa reta. No possvel simplesmente pegar dois a dois os pontos e calcular a reta passante por eles, pois no sabemos se essa reta faz parte de algum dos tringulos. Somente as retas que pertenam aos tringulos so retas pertencentes forma geomtrica de interseco. Outro ponto importante que se o nmero de retas encontradas at o momento igual ao nmero de pontos, o trabalho est concludo, mesmo que haja ainda grupos de pontos a serem testados, pois o nmero de pontos da interseco o nmero de retas pertencentes rea de interseco (retas a serem encontradas). Exceto quando se tm dois pontos no gerada uma rea, por isso essa afirmao anterior no se torna vlida, por ter dois pontos apenas e resultar somente em uma reta. Porm, neste caso, s h um grupo de pontos e a primeira interao j basta para se obter o resultado.

5.5 Programa exemplo

66

A Figura 29 o screen de um programa exemplo para interseco de 2 tringulos 2D. Nele pedido s coordenadas (x,y) dos 3 pontos pertencentes aos 2 tringulos (T1 e T2). No boto Desenhar ele apenas desenha os dois tringulos, j no boto Interseco ele encontra a interseco dos tringulos usando o algoritmo descrito neste captulo.

Figura 29 - Um exemplo de programa de interseco de tringulos 2D

6 ALGORITMO FINAL INTERSECO 3D

O algoritmo de interseco 3D para slidos que foi escolhido para ser usado na interseco foi Interseco entre superfcies triangulares. Pois um algoritmo eficiente, pois busca minimizar ao mximo o nmero de faces a serem analisadas utilizando-se da vizinhana entre os tringulos. Uma informao importante a respeito do algoritmo que ele trabalha com parmetros por referncia e que suas estruturas so objetos com algumas funes implcitas como no caso de uma lista inserir, remover, etc, porm as prprias funes se explicam, pois foram utilizados nomes sugestivos. As estruturas que o algoritmo utiliza esto formadas da seguinte modo:
Estrutura Face V1 // vrtice 1 da face V2 // vrtice 2 da face V3 // vrtice 3 da face Linhas(3) // lista de linhas de borda da face // linha 1 geradas por V2 e V3 // linha 2 geradas por V3 e V1 // linha 3 geradas por V1 e V2 Clulas // lista de clulas que a face pertence Estrutura Vrtice x y z faces // listas de faces que o vrtice pertence Estrutura Linha x0 a y0 b z0 c

68 vizinho // face vizinha por essa linha de borda

O algoritmo final de interseco 3D constitudo da seguinte forma:

Variveis: Lista Vertices1 // lista de vrtices do slido 1 Lista Vertices2 // lista de vrtices do slido 2 Lista Faces1 // lista de faces do slido 1 Lista Faces2 // lista de faces do slido 2 Lista FacesFiltradas1 // lista de faces do slido 2 Lista FacesFiltradas2 // lista de faces do slido 2 Lista Clulas // lista de clulas Interseco3D() // leitura Ler(Faces1) Ler(Faces2) // filtragem Se Filtrar() = False ento Retornar Falso Fim Se // preparao da interseco EncontrarVizinhana // interseco Para todas clulas c de clulas faa Se c.interseco = 1 Ento EncontrarPontoInicial(Faces1, Faces2) Fim Se Prxima c Fim interseco3D

Esse algoritmo est dividido em vrias partes que so: leitura, filtragem, preparao da interseco e a interseco. O primeiro passo do algoritmo a leitura dos slidos. Essa funo carrega os slidos para as listas de faces que dele correspondem (Faces 1 ou Faces 2). Essa funo descrita no (ANEXO 1) de uma forma mas a funo de leitura a parte mais subjetiva das funes, porque tudo depende de como os slidos esto armazenados. O que se precisa ter em mente que essa funo inicia o vetor de faces e vrtices, ou seja, ela a encarregada, alm de preparar as faces, insere os vrtices das faces na lista de vrtices. O detalhe dela justamente a procura que ela desempenha para saber se j existe um vrtice com essas coordenadas. Existindo preciso

69

atribuir a face o vrtice j existente. Exemplificando, se um vrtice V pertence tanto face f1 e f2 ento existe um V para 2 faces, pois o vrtice (objeto vrtice) o mesmo para ambas as faces. Essa tratativa feita para conseguir facilmente encontrar as faces que possuem um vrtice, bastando conhecer uma das faces que possvel descobrir as demais. A funo de busca por um vrtice faz parte da leitura dos slidos, pois ela quem diz, por consulta na lista de vrtices, se um determinado vrtice j existe, existindo ela o retorna para que esse vrtice seja adicionada na nova face e a nova face ao vrtice. Seu cdigo o visto no (ANEXO 2). Aps as faces j estarem inseridas o prximo passo fazer a filtragem dos slidos. Esse processo de filtragem foi explicado no Captulo 4. Seu cdigo pode ser visto no (ANEXO 3). Nos (ANEXO 4) e (ANEXOS 5) so mostrados respectivamente que o as algoritmo rotinas de encontrarDimensoes filtro utiliza. A e testarFaceRegio Funo

encontrarDimensoes encontra as dimenses mximas e mnimas. J a Funo testarFaceRegiao identifica se uma face est em uma regio pelos valores mximos e mnimos. Essa regio pode ser uma clula ou mesmo a regio toda de interseco. A parte seguinte do algoritmo de interseco

EncontrarVizinhana. Essa funo responsvel por fazer a preparao da interseco, pois encontra as faces de um mesmo slido que compartilham linhas de borda e as liga atravs de um ponteiro que as prprias linhas carregam, ou seja, se duas faces f1 e f2 esto ligadas pelas linhas l1 e l2 respectivamente, ento l2.vizinho aponta para f1 e l1.vizinho aponta para f2. Alm disso, esse algoritmo prepara a reta para ser usada posteriormente atribuindo os valores de x0, a, y0, b, z0, c. O algoritmo dessa funo encontrado no (ANEXO 6). A funo Pertencem utilizada pelo algoritmo EncontrarVizinhana e ela somente informa se dois vrtices esto em uma determinada face. Seu cdigo visto no (ANEXO 7).

70

A parte do algoritmo mais importante a interseco. Tendo os passos anteriores concludos chegada a hora de a comear. Existem duas funes responsveis em encontrar as interseces entre os slidos que so: EncontrarPontoInicial (descrita no ANEXO 8) e a loopIntersec ANEXO 9). O trabalho de EncontrarPontoInicial achar o primeiro segmento da interseco. Ela utiliza interseco de pares de tringulos para isso. Ela recebe a lista de faces de uma clula, porm somente de clulas aptas a interseco (tendo a varivel interseco igual a 1). As clulas so consideradas no aptas por duas razes: se existirem faces de um nico slido nela e se j houver sido encontrado algum segmento da interseco em alguma face que a pertena. Toda vez que um segmento encontrado em duas faces a varivel intersection das clulas a que elas pertencem so passadas a conter 0. Com isso o algoritmo sabe se h regies (clulas) com possibilidade de haver interseco ainda no visitadas pelo algoritmo. Assim o algoritmo que encontra o segmento inicial somente busca nessas clulas. Aps encontrar o primeiro segmento (dois pontos) a funo EncontrarPontoInicial chama a funo loopIntersec um dos pontos encontrados e as faces onde ela deve continuar procurando o prximo ponto da interseco. A partir desse momento o algoritmo de busca da linha de interseco passa a ser por vizinhana (superfcies triangulares) e todas as regras descritas no tpico 3.2 so tratados pela funo loopIntersec. Quando o algoritmo loopIntersec chamado, comea ento a identificar os segmentos de interseco seqentes. Ele necessita de um ponto e das duas faces onde deve procurar o segundo ponto da interseco. Esse segundo ponto passa a ser a entrada que loopIntersec que chamando novamente (recursividade). Para que essa corrente ou loop termine precisa encontrar o Pf (xf,yf,zf) ou Ponto Final. Esse ponto final o segundo ponto do segmento encontrado pelo EncontrarPontoInicial (o outro foi usado para iniciar o loop de interseco). Encontrando Pf a varivel fim passa a conter (vista no

71

verdadeiro. Assim EncontrarPontoInicial sabe que no h mais interseces nessa rea e pode-se dizer que essa regio fechada. Na Figura 30 pode ser visto melhor como a forma de uma regio fechada. Caso loopIntersec chegue ao final das interseco e no encontre o Pf fim retornar falso e EncontrarPontoInicial passa a loopIntersec o outro ponto de seu segmento encontrado para que prossiga localizando, se houver, o restante da interseco. Dizemos ento que esta regio aberta e na Figura 31 melhor visto esse tipo de regio.

Figura 30 - Regio fechada de interseco

Figura 31 - Regio Aberta de interseco A funo encontrar PontosDeEncontro utilizada pela funo loopIntersec para encontrar onde as retas de duas faces se encontram. Ela utilizada somente para faces no mesmo plano. Seu cdigo descrito no

72

(ANEXO 10).

CONCLUSO

O presente trabalho apresentou noes de geometria analtica para um desenvolvimento de um algoritmo de interseco de faces triangulares. Alm de interseco 3D de faces foi desenvolvido um algoritmo de interseco 2D entre dois tringulos. Inclusive implementado em Visual Basic. Aps um estudo de trs algoritmos de interseco 3D: Interseco de pares de tringulos, Interseco de Superfcies triangulares e Interseco de Superfcies Paramtricas, notou-se que para superfcies irregulares o algoritmo de Superfcies Paramtricas torna-se menos eficiente para slidos constitudos de malhas ou superfcies regulares, pois podem ser representadas por equaes paramtricas e com essa constituio mostra-se eficiente para encontrar a interseco. Tanto a Interseco de pares de tringulos como a Interseco de Superfcies triangulares adaptam-se ao padro de slidos irregulares que so possveis de serem formados por faces triangulares, porm o de superfcies triangulares mais complexo pois necessita de uma estrutura capaz de localizar as faces vizinhas de um determinado tringulo, que seja possvel acessar todas as faces que possuem um vrtice e de um ponto da interseco para que possa desenvolver o trajeto da interseco. Essas informaes so usadas para melhorar seu processo. A grande vantagem da interseco de pares de tringulos a maior facilidade de implementao, pois no precisa de nenhuma estrutura especial somente das faces para traar as linhas de interseco, mas um algoritmo menos eficiente. Adotou-se ento o algoritmo de Superfcies triangulares como padro para a interseco e para

74

encontrar o primeiro segmento de interseco utiliza-se o algoritmo de pares de tringulos. Outro ponto primordial do algoritmo a minimizao das faces a serem analisada com algum tipo de filtro. O filtro empregado no algoritmo consiste em encontrar a regio/paraleleppedo onde a interseco dos slidos est inserida fazendo com que somente as faces pertencentes a essa regio continuem sendo analisadas. Alm disso, esse processo faz uma anlise primria se h interseco entre dois slidos pois se no for possvel encontrado o paraleleppedo de interseco certamente no h interseco. O segundo passo do algoritmo de filtro dividir a regio encontrada em clula transformando-a em uma matriz tridimensional e encontrar para cada face apta em qual regio. Essas clulas ajudam o algoritmo de iniciao da interseco a encontrar o primeiro segmento, pois, torna-se possvel identificar se uma clula composta de faces de um s slido. O algoritmo no representa uma soluo tima, mas se caracteriza por relativa simplicidade de implementao e eficincia. Seu desenvolvimento foi inspirado nos pontos fortes dos trabalhos estudados, tendo um compromisso com a facilidade de entendimento e um modelo formado por faces triangulares.

75

TRABALHOS FUTUROS

Existem alguns pontos que podem vir a se tornar trabalhos futuros. O primeiro seria estudar heursticas para se encontrar o ponto inicial no algoritmo final de forma mais eficiente, pois ele utiliza o algoritmo que pesquisa dois a dois todos os tringulos at encontrar o primeiro segmento. Analisando esse ponto o algoritmo pode vir a perder desempenho se logo nas primeiras interaes no for encontrado o primeiro segmento da interseco. Um segundo ponto interessante seria desenvolver um algoritmo que corte as faces nas linhas de interseco encontradas pelo algoritmo apresentado neste trabalho.

76

ANEXO 1 FUNO LER

Ler(face, vertices) Para toda face do arquivo faa f nova face // v1 v leia() f.v1 ProcurarVertice(v.x, v.y, v.z, vertices) Se f.v1 = nulo ento f.v1 v vertices.inserir f.v1 Fim se v.faces.inserir f // v2 v leia() f.v2 ProcurarVertice(v.x, v.y, v.z , vertices) Se f.v2 = nulo ento f.v2 v vertices.inserir f.v2 Fim se f.v2.faces.inserir f //v3 v leia() f.v3 ProcurarVertice(v.x, v.y, v.z, vertices) Se f.v3 = nulo ento f.v3 v v.faces.inserir f Fim se vrtices.inserir f.v3 Fim Ler

77

ANEXO 2 FUNO PROCURARVERTICE

ProcurarVertice(x,y,z,vertices) Para todo vrtice v de vertices Se v.x = x E v.y = y E v.z = z ento retorna v Fim se Prximo v retorna nulo Fim ProcuraVertice

78

ANEXO 3 FUNO FILTRAR

Filtrar(faces1, faces2, fFiltra1, fFiltra2, Celulas) MenorX infinito // nmero bem grande MenorY infinito MenorZ infinito encontrarDimenses(Xmax1, Xmin1, Ymax1, Ymin1, Zmax1, Zmin1, MenorX, MenorY, MenorZ, faces1) encontrarDimenses(Xmax2, Xmin2, Ymax2, Ymin2, Zmax2, Zmin2, MenorX, MenorY, MenorZ, faces2) Se Xmin1 Xmin2 E Xmax1 > Xmin2 Ento XMnimoIntersec Xmin2 Se Xmax2 < Xmax1 Ento XMximoIntersec Xmax1 Seno XMximoIntersec Xmax2 Fim Se Seno Se Xmin2 Xmin1 E Xmax2 > Xmin1 Ento XMnimoIntersec Xmin1 Se Xmax2 < Xmax1 Ento XMximoIntersec Xmax1 Seno XMximoIntersec Xmax2 Fim Se Seno retorna falso // sem interseco Fim Se Se Ymin1 Ymin2 E Ymax1 > Ymin2 Ento YMnimoIntersec Ymin2 Se Ymax2 < Xmax1 Ento YMximoIntersec Ymax1 Seno YMximoIntersec Ymax2 Fim Se Seno Se Ymin2 Ymin1 E Ymax2 > Ymin1 Ento YMnimoIntersec Ymin1 Se Ymax2 < Ymax1 Ento YMximoIntersec Ymax1 Seno YMximoIntersec Ymax2 Fim Se Seno retorna falso // sem interseco Fim Se Se Zmin1 Zmin2 E Zmax1 > Zmin2 Ento ZMnimoIntersec Zmin2 Se Zmax2 < Xmax1 Ento ZMximoIntersec Zmax1

79 Seno ZMximoIntersec Zmax2 Fim Se Seno Se Zmin2 Zmin1 E Zmax2 > Zmin1 Ento ZMnimoIntersec Zmin1 Se Zmax2 < Zmax1 Ento ZMximoIntersec Zmax1 Seno ZMximoIntersec Zmax2 Fim Se Seno retorna falso // sem interseco Fim Se // dividindo paraleppedo em clulas Nx int((XMximoIntersec - XMnimoIntersec) / MenorX) + 1 Ny int((YMximoIntersec - YMnimoIntersec) / MenorY) + 1 Nz int((ZMximoIntersec - ZMnimoIntersec) / MenorZ) + 1 passoX (XMximoIntersec - XMnimoIntersec) / Nx passoY (YMximoIntersec - YMnimoIntersec) / Ny passoZ (ZMximoIntersec - ZMnimoIntersec) / Nz Para x 1 at Nx Para y 1 at Ny Para z 1 at Nz celula nova clula celula.xMax XMnimoIntersec + passoX*x celula.xMin XMnimoIntersec + passoX*(x-1) celula.yMax YMnimoIntersec + passoY*y celula.yMin YMnimoIntersec + passoY*(y-1) celula.zMax ZMnimoIntersec + passoZ*z celula.zMin ZMnimoIntersec + passoZ*(z-1) celulas.inserir celula Prximo z Prximo y Prximo x // testar se as faces esto na regio Para todas faces f de faces1 Se testarFaceRegiao(f, XMnimoIntersec, XMximoIntersec, YMnimoIntersec, YMximoIntersec, ZMnimoIntersec, ZMximoIntersec) = verdadeiro ento // est no paraleppedo de interseco fFiltra1.inserir f // insere f como face apta para interseco // encontrar clulas Para todas as clulas c de clulas Se testarFaceRegiao(f, c.xMin, c.xMax, c.yMin, c.yMax, c.zMin, c.zMax) = verdadeiro ento // est na regio c.faces1.inserir f f.Clulas.inserir c fim se Prximo c fim se

80 Prximo f Para todas faces f de faces2 Se testarFaceRegiao(f, XMnimoIntersec, XMximoIntersec, YMnimoIntersec, YMximoIntersec, ZMnimoIntersec, ZMximoIntersec) = verdadeiro ento // est no paraleppedo de interseco fFiltra1.inserir f // insere f como face apta para interseco // encontrar clulas Para todas as clulas c de clulas Se testarFaceRegiao(f, c.xMin, c.xMax, c.yMin, c.yMax, c.zMin, c.zMax) = verdadeiro ento // est na regio c.faces2.inserir f f.Clulas.inserir c fim se Prximo c fim se Prximo f retorna verdadeiro fim filtrar

81

ANEXO 4 FUNO ENCONTRARDIMENSES

encontrarDimenses(Xmax, Xmin, Ymax, Ymin, Zmax, Zmin, MenorX, MenorY, MenorZ, faces) Xmax -infinito Xmin infinito Ymax -infinito Ymin infinito Zmax -infinito Zmin infinito Para toda face f em faces // v1 Se Xmax < f.v1.x ento Xmax f.v1.x fim se Se Xmin > f.v1.x ento Xmin f.v1.x fim se Se Ymax < f.v1.y ento Ymax f.v1.y fim se Se Ymin > f.v1.y ento Ymin f.v1.y fim se Se Zmax < f.v1.z ento Zmax f.v1.z fim se Se Zmin > f.v1.z ento Zmin f.v1.Z fim se // v2 Se Xmax < f.v2.x ento Xmax f.v2.x fim se Se Xmin > f.v2.x ento Xmin f.v2.x fim se Se Ymax < f.v2.y ento Ymax f.v2.y fim se Se Ymin > f.v2.y ento Ymin f.v2.y fim se Se Zmax < f.v2.z ento Zmax f.v2.z fim se Se Zmin > f.v2.z ento Zmin f.v2.Z fim se // v3

82 Se Xmax < f.v3.x ento Xmax f.v3.x fim se Se Xmin > f.v3.x ento Xmin f.v3.x fim se Se Ymax < f.v3.y ento Ymax f.v3.y fim se Se Ymin > f.v3.y ento Ymin f.v3.y fim se Se Zmax < f.v3.z ento Zmax f.v3.z fim se Se Zmin > f.v3.z ento Zmin f.v3.Z fim se // Medidas Menores // x dTmp mdulo(f.v1.x - f.v2.x) // em mdulo Se MenorX > dTmp ento MenorX dTmp fim Se dTmp mdulo(f.v1.x - f.v3.x) // em mdulo Se MenorX > dTmp ento MenorX dTmp fim Se dTmp mdulo(f.v3.x - f.v2.x) // em mdulo Se MenorX > dTmp ento MenorX dTmp fim Se // y dTmp mdulo(f.v1.y - f.v2.y) // em mdulo Se MenorY > dTmp ento MenorY dTmp fim Se dTmp mdulo(f.v1.y - f.v3.y) // em mdulo Se MenorY > dTmp ento MenorY dTmp fim Se dTmp mdulo(f.v3.y - f.v2.y) // em mdulo Se MenorY > dTmp ento MenorY dTmp fim Se // z dTmp mdulo(f.v1.z - f.v2.z) // em mdulo Se MenorZ > dTmp ento MenorZ dTmp fim Se dTmp mdulo(f.v1.z - f.v3.z) // em mdulo Se MenorZ > dTmp ento MenorZ dTmp

83 fim Se dTmp mdulo(f.v3.z - f.v2.z) // em mdulo Se MenorZ > dTmp ento MenorZ dTmp fim Se Prximo f Fim encontrarDimenses

84

ANEXO 5 FUNO TESTARFACEREGIAO

testarFaceRegiao(face, Xmin, Xmax, Ymin, Ymax, Zmin, Zmax) Se (face.Xmin < Xmin E face.Xmax < Xmin) ou (Xmin < face.Xmin E Xmax < face.Xmin) Ento retorna falso // sem interseco Fim Se Se (face.Ymin < Ymin E face.Ymax < Ymin) ou (Ymin < face.Ymin E Ymax < face.Ymin) ento Ento retorna falso // sem interseco Fim Se Se (face.Zmin < Zmin E face.Zmax < Zmin) ou (Zmin < face.Zmin E Zmax < face.Zmin) Ento retorna falso // sem interseco Fim Se retorna verdadeiro fim testarFaceRegiao

85

ANEXO 6 FUNO ENCONTRARVIZINHANA

EncontrarVizinhana(Faces, Vrtices) Para todas faces t de Faces Para todas faces t2 Faces Se t t2 ento // testa se no a mesma face Se t.linhas(1) Nulo ento Se t2.v1 = t.v2 Ou t2.v1 = t.v3 ento Se t2.v2 = t.v2 Ou t2.v2 = t.v3 ento // vizinho de t pelos vrtices V1 e V2 t2.linhas(3) nova linha t2.linhas(3).x0 t.v2.x t2.linhas(3).a t.v3.x - t.v2.x t2.linhas(3).y0 t.v2.y t2.linhas(3).b t.v3.y - t.v2.y t2.linhas(3).z0 t.v2.z t2.linhas(3).c t.v3.z - t.v2.z t2.linhas(3).vizinho t // vizinho de t2 pelos vrtices V2 e V3 t.linhas(1) nova linha t.linhas(1).x0 t2.linhas(3).x0 t.linhas(1).a t2.linhas(3).a t.linhas(1).y0 t2.linhas(3).y0 t.linhas(1).b t2.linhas(3).b t.linhas(1).z0 t2.linhas(3).z0 t.linhas(1).c t2.linhas(3).c t.linhas(1).vizinho t2 Seno Se t2.v3 = t.v2 Ou t2.v3 = t.v3 ento // vizinho de t pelos vrtices V3 e V1 t2.linhas(2) nova linha t2.linhas(2).x0 t.v2.x t2.linhas(2).a t.v3.x - t.v2.x t2.linhas(2).y0 t.v2.y t2.linhas(2).b t.v3.y - t.v2.y t2.linhas(2).z0 = t.v2.z t2.linhas(2).c = t.v3.z - t.v2.z t2.linhas(2).vizinho = t // vizinho de t2 pelos vrtices V2 e V3 t.linhas(1) nova linha t.linhas(1).x0 t2.linhas(2).x0 t.linhas(1).a t2.linhas(2).a t.linhas(1).y0 t2.linhas(2).y0 t.linhas(1).b t2.linhas(2).b t.linhas(1).z0 t2.linhas(2).z0 t.linhas(1).c t2.linhas(2).c t.linhas(1).vizinho t2 Fim Se Seno Se t2.v2 = t.v2 Ou t2.v2 = t.v3 ento Se t2.v3 = t.v2 Ou t2.v3 = t.v3 ento // vizinho de t pelos vrtices V2 e V3 t2.linhas(1) nova linha

86 t2.linhas(1).x0 t.v2.x t2.linhas(1).a t.v3.x - t.v2.x t2.linhas(1).y0 t.v2.y t2.linhas(1).b t.v3.y - t.v2.y t2.linhas(1).z0 t.v2.z t2.linhas(1).c t.v3.z - t.v2.z t2.linhas(1).vizinho t // vizinho de t2 pelos vrtices V2 e V3 t.linhas(1) nova linha t.linhas(1).x0 t2.linhas(1).x0 t.linhas(1).a t2.linhas(1).a t.linhas(1).y0 t2.linhas(1).y0 t.linhas(1).b t2.linhas(1).b t.linhas(1).z0 t2.linhas(1).z0 t.linhas(1).c t2.linhas(1).c t.linhas(1).vizinho t2 Fim Se Fim Se Seno Se t.linhas(2) Nulo E Pertencem(t.V3, t.V1, t2) ento Se t2.v1 = t.v3 Ou t2.v1 = t.v1 ento Se t2.v2 = t.v3 Ou t2.v2 = t.v1 ento // vizinho de t pelos vrtices V1 e V2 t2.linhas(3) nova linha t2.linhas(3).x0 t.v3.x t2.linhas(3).a t.v1.x - t.v3.x t2.linhas(3).y0 t.v3.y t2.linhas(3).b t.v1.y - t.v3.y t2.linhas(3).z0 t.v3.z t2.linhas(3).c t.v1.z - t.v3.z t2.linhas(3).vizinho t // vizinho de t2 pelos vrtices V3 e V1 t.linhas(2) nova linha t.linhas(2).x0 t2.linhas(3).x0 t.linhas(2).a t2.linhas(3).a t.linhas(2).y0 t2.linhas(3).y0 t.linhas(2).b t2.linhas(3).b t.linhas(2).z0 t2.linhas(3).z0 t.linhas(2).c t2.linhas(3).c t.linhas(2).vizinho t2 Seno Se t2.v3 = t.v3 Ou t2.v3 = t.v1 ento // vizinho de t pelos vrtices V3 e V1 t2.linhas(2) nova linha t2.linhas(2).x0 t.v3.x t2.linhas(2).a t.v1.x - t.v3.x t2.linhas(2).y0 t.v3.y t2.linhas(2).b t.v1.y - t.v3.y t2.linhas(2).z0 t.v3.z t2.linhas(2).c t.v1.z - t.v3.z t2.linhas(2).vizinho t // vizinho de t2 pelos vrtices V3 e V1 t.linhas(2) nova linha

87 t.linhas(2).x0 t2.linhas(2).x0 t.linhas(2).a t2.linhas(2).a t.linhas(2).y0 t2.linhas(2).y0 t.linhas(2).b t2.linhas(2).b t.linhas(2).z0 t2.linhas(2).z0 t.linhas(2).c t2.linhas(2).c t.linhas(2).vizinho t2 Fim Se Seno Se t2.v2 = t.v3 Ou t2.v2 = t.v1 ento Se t2.v3 = t.v3 Ou t2.v3 = t.v1 ento // vizinho de t pelos vrtices V2 e V3 t2.linhas(1) nova linha t2.linhas(1).x0 t.v3.x t2.linhas(1).a t.v1.x - t.v3.x t2.linhas(1).y0 t.v3.y t2.linhas(1).b t.v1.y - t.v3.y t2.linhas(1).z0 t.v3.z t2.linhas(1).c t.v1.z - t.v3.z t2.linhas(1).vizinho t // vizinho de t2 pelos vrtices V3 e V1 t.linhas(2) nova linha t.linhas(2).x0 t2.linhas(1).x0 t.linhas(2).a t2.linhas(1).a t.linhas(2).y0 t2.linhas(1).y0 t.linhas(2).b t2.linhas(1).b t.linhas(2).z0 t2.linhas(1).z0 t.linhas(2).c t2.linhas(1).c t.linhas(2).vizinho t2 Fim Se Fim Se Seno Se t.linhas(3) Nulo E Pertencem(t.V1, t.V2, t2) ento Se t2.v1 = t.v1 Ou t2.v1 = t.v2 ento Se t2.v2 = t.v1 Ou t2.v2 = t.v2 ento // vizinho de t pelos vrtices V1 e V2 t2.linhas(3) nova linha t2.linhas(3).x0 t.v1.x t2.linhas(3).a t.v2.x - t.v1.x t2.linhas(3).y0 t.v1.y t2.linhas(3).b t.v2.y - t.v1.y t2.linhas(3).z0 t.v1.z t2.linhas(3).c t.v2.z - t.v1.z t2.linhas(3).vizinho t // vizinho de t2 pelos vrtices V1 e V2 t.linhas(3) nova linha t.linhas(3).x0 t2.linhas(3).x0 t.linhas(3).a t2.linhas(3).a t.linhas(3).y0 t2.linhas(3).y0 t.linhas(3).b t2.linhas(3).b t.linhas(3).z0 t2.linhas(3).z0 t.linhas(3).c t2.linhas(3).c t.linhas(3).vizinho t2 Seno Se t2.v3 = t.v1 Ou t2.v3 = t.v2 ento // vizinho de t pelos vrtices V3 e V1

88 t2.linhas(2) nova linha t2.linhas(2).x0 t.v1.x t2.linhas(2).a t.v2.x - t.v1.x t2.linhas(2).y0 t.v1.y t2.linhas(2).b t.v2.y - t.v1.y t2.linhas(2).z0 t.v1.z t2.linhas(2).c t.v2.z - t.v1.z t2.linhas(2).vizinho t // vizinho de t2 pelos vrtices V1 e V2 t.linhas(3) nova linha t.linhas(3).x0 t2.linhas(2).x0 t.linhas(3).a t2.linhas(2).a t.linhas(3).y0 t2.linhas(2).y0 t.linhas(3).b t2.linhas(2).b t.linhas(3).z0 t2.linhas(2).z0 t.linhas(3).c t2.linhas(2).c t.linhas(3).vizinho t2 Fim Se Seno Se t2.v2 = t.v1 Ou t2.v2 = t.v2 ento Se t2.v3 = t.v1 Ou t2.v3 = t.v2 ento // vizinho de t pelos vrtices V2 e V3 t2.linhas(1) nova linha t2.linhas(1).x0 t.v1.x t2.linhas(1).a t.v2.x - t.v1.x t2.linhas(1).y0 t.v1.y t2.linhas(1).b t.v2.y - t.v1.y t2.linhas(1).z0 t.v1.z t2.linhas(1).c t.v2.z - t.v1.z t2.linhas(1).vizinho t // vizinho de t2 pelos vrtices V1 e V2 t.linhas(3) nova linha t.linhas(3).x0 t2.linhas(1).x0 t.linhas(3).a t2.linhas(1).a t.linhas(3).y0 t2.linhas(1).y0 t.linhas(3).b t2.linhas(1).b t.linhas(3).z0 t2.linhas(1).z0 t.linhas(3).c t2.linhas(1).c t.linhas(3).vizinho t2 Fim Se Fim Se Fim Se Fim Se Prximo t2 Prximo t Fim EncontrarVizinhana

89

ANEXO 7 FUNO PERTENCEM

Pertencem(v1,v2, face) Se face.v1 = v1 Ou face.v1 = v2 ento Se face.v2 = v2 Ou face.v2 = v1 ento // vizinho de t pelos vrtices V1 e V2 retorna Verdadeiro Seno Se face.v3 = v2 Ou face.v3 = v1 ento // vizinho de t pelos vrtices V1 e V3 retorna Verdadeiro Fim Se Seno Se face.v2 = v1 Ou face.v2 = v2 ento Se face.v3 = v2 Ou face.v3 = v1 ento // vizinho de t pelos vrtices V2 e V3 retorna Verdadeiro Fim Se Fim Se retorna Falso Fim Pertencem

90

ANEXO 8 FUNO ENCONTRARPONTOINICIAL

EncontrarPontoInicial(Faces1,Faces2) Para todas Faces f1 em Faces1 faa a1 f1.v2.y*f1.v3.z - f1.v2.y2*f1.v1.z - f1.v1.y*f1.v3.z - f1.v3.y*f1.v2.z + f1.v1.y*f1.v2.z + f1.v3.y*f1.v1.z b1 f1.v3.x*f1.v2.z - f1.v1.x*f1.v2.z - f1.v3.x*f1.v1.z - f1.v2.x*f1.v3.z + f1.v2.x*f1.v1.z + f1.v1.x*f1.v3.z c1 f1.v2.x*f1.v3.y - f1.v2.x*f1.v1.y - f1.v1.x*f1.v3.y - f1.v3.x*f1.v2.y + f1.v1.x*f1.v2.y + f1.v3.x*f1.v1.y d1 - a*f1.v1.x - b*f1.v1.y - c*f1.v1.z Para todas Faces f2 em Faces2 faa a2 f2.v2.y*f2.v3.z - f2.v2.y2*f2.v1.z - f2.v1.y*f2.v3.z - f2.v3.y*f2.v2.z + f2.v1.y*f2.v2.z + f2.v3.y*f2.v1.z b2 f2.v3.x*f2.v2.z - f2.v1.x*f2.v2.z - f2.v3.x*f2.v1.z - f2.v2.x*f2.v3.z + f2.v2.x*f2.v1.z + f2.v1.x*f2.v3.z c2 f2.v2.x*f2.v3.y - f2.v2.x*f2.v1.y - f2.v1.x*f2.v3.y - f2.v3.x*f2.v2.y + f2.v1.x*f2.v2.y + f2.v3.x*f2.v1.y d2 - a*f2.v1.x - b*f2.v1.y - c*f2.v1.z Se a1 = a2 E b1 = b2 E c1 = c2 ento Se d1 d2 ento // so paralelos Prximo f2 Fim se Seno // interseco entre as faces //encontrando reta de interseco entre os planos dx b1*c2 - c1*b2 dy c1*a2 - c2*a1 dz a1*b2 - a2*b1 //encontrando P0 Se a1 0 E b1 0 E b2 0 ento x0 (b1*d2 d1) / (a1*b2 a2*b1) y0 (-a1*X0 d1) / b1 z0 0 Seno Se a1 0 E c1 0 E c2 0 ento x0 (c1*d2 d1) / (a1*c2 a2*c1) y0 0 z0 (-a1*X0 d1) / c1 Seno Se b1 0 E c1 0 E c2 0 ento x0 0 y0 (c1*d2 d1) / (b1*c2 b2*c1) z0 (-b1*Y0 d1) / c1 Seno Se b1 0 E a2 0 E b2 0 ento x0 (b2*d1 d2) / (a2*b1 a1*b2)

91 y0 (-a2*X0 d2) / b2 z0 0 Seno Se c1 0 E a2 0 E c2 0 ento x0 (c2*d1 d2) / (a2*c1 a1*c2) y0 0 z0 (-a2*X0 d2) / c2 Seno Se c1 0 E b2 0 E c2 0 ento x0 0 y0 (c2*d1 d2) / (b2*c1 b1*c2) z0 (-b2*Y0 d2) / c2 Seno Se a1 0 E b2 0 ento x0 -d1 / a1 y0 -d2 / b2 z0 0 Seno Se a1 0 E c2 0 ento x0 -d1 / a1 y0 0 z0 -d2 / c2 Seno Se b1 0 E a2 0 ento x0 -d2 / a2 y0 -d1 / b1 z0 0 Seno Se b1 0 E c2 0 ento x0 0 y0 -d1 / b1 z0 -d2 / c2 Seno Se c1 0 E a2 0 ento x0 -d2 / a2 y0 0 z0 -d1 / c1 Seno Se b1 0 E b2 0 ento x0 0 y0 -d2 / b2 z0 -d1 / c1 Fim se // Testar reta com as linhas de bordas dos tringulos //face1 // flag para saber se h ponto de interseco j // calculado teste Falso Para todas as linhas l de f1.linhas faa // inicio do encontro Se (l.a * dy - l.b * dx) = 0 E (l.a * dz - l.c * dx) = 0 E (l.b * dz - l.c * dy) = 0 ento // mesma reta //convertendo t da reta l para t da reta de //interseco Se dx 0 ento tMin1 (l.x0 - x0) / dx tMax1 ((l.x0 + l.a) - x0) / dx Seno Se dy 0 ento tMin1 (l.y0 - y0) / dy

92 tMax1 ((l.y0 + l.b) - y0) / dy Seno Se dz 0 ento tMin1 (l.z0 - z0) / dz tMax1 ((l.y0 + l.b) - z0) / dz Fim se Se tMin1 > tMax1 ento tTmp tMin1 tMin1 tMax1 tMax1 tTmp Fim Se nMax2 nMin1 nulo Sai do Para Seno Se (l.a * dy - l.b * dx) 0 ento t1 ((x0 - l.x0) * dy + (y0 - l.y0) * dx) / (dy * l.a - l.b * dx) t2 ((l.x0 - x0) * l.b + (y0 - l.y0) * l.a) / (l.b * dx - dy * l.a) Seno Se (l.a * dz - l.c * dx) 0 ento t1 ((x0 - l.x0) * dz + (z0 - l.z0) * dx) / (dz * l.a - l.c * dx) t2 ((l.x0 - x0) * l.c + (z0 - l.z0) * l.a) / (l.c * dx - dz * l.a) Seno Se (l.b * dz - l.c * dy) 0 ento t1 ((y0 - l.y0) * dz + (z0 - l.z0) * dy) / (dz * l.b - l.c * dy) t2 ((l.y0 - y0) * l.c + (z0 - l.z0) * l.b) / (l.c * dy - dz * l.b) Fim Se // no segmento // da linha de // borda Se t1 0 E t1 1 ento // testa se est

Se teste = Verdadeiro ento Se tMin1 > t2 ento tMax1 tMin1 vMax1 vMin1 tMin1 t2 Se t1 = 0 Ou t1 = 1 ento nMin1 nulo // um vertice Seno nMin1 l.vizinho Fim se Seno tMax1 t2 Se t1 = 0 Ou t1 = 1 ento nMax1 nulo // um vertice Seno nMax1 l.vizinho Fim se Fim Se // encontrou os dois pontos // de encontro Sai do Para Seno tMin1 t2 Se t1 = 0 Ou t1 = 1 ento // um vertice

93 nMin1 nulo Seno nMin1 l.vizinho Fim se teste Verdadeiro Fim se Fim se Se l = f1.linhas.ultimo ento // como no encontrou dois pontos // de encontro no necessrio // procurar em f2 Prximo f2 Fim se Fim se Prximo l //face2 // flag para saber se h ponto de interseco j calculado teste Falso Para todas as linhas l de f2.linhas faa // inicio do encontro Se (l.a * dy - l.b * dx) = 0 E (l.a * dz - l.c * dx) = 0 E (l.b * dz - l.c * dy) = 0 ento // mesma reta //convertendo t da reta l para t da reta de interseco Se dx 0 ento tMin2 (l.x0 - x0) / dx tMax2 ((l.x0 + l.a) - x0) / dx Seno Se dy 0 ento tMin2 (l.y0 - y0) / dy tMax2 ((l.y0 + l.b) - y0) / dy Seno Se dz 0 ento tMin2 (l.z0 - z0) / dz tMax2 ((l.y0 + l.b) - z0) / dz Fim se Se tMin1 > tMax1 ento tTmp tMin2 tMin2 tMax2 tMax2 tTmp Fim se nMax2 nMin2 nulo Sai do Para Seno Se (l.a * dy - l.b * dx) 0 ento t1 ((x0 - l.x0) * dy + (y0 - l.y0) * dx) / (dy * l.a - l.b * dx) t2 ((l.x0 - x0) * l.b + (y0 - l.y0) * l.a) / (l.b * dx - dy * l.a) Seno Se (l.a * dz - l.c * dx) 0 ento t1 ((x0 - l.x0) * dz + (z0 - l.z0) * dx) / (dz * l.a - l.c * dx) t2 ((l.x0 - x0) * l.c + (z0 - l.z0) * l.a) / (l.c * dx - dz * l.a) Seno Se (l.b * dz - l.c * dy) 0 ento

94 t1 ((y0 - l.y0) * dz + (z0 - l.z0) * dy) / (dz * l.b - l.c * dy) t2 ((l.y0 - y0) * l.c + (z0 - l.z0) * l.b) / (l.c * dy - dz * l.b) Fim se Se (l.x0 + t1* l.a) (x0 + t2 * dx) Ou (l.y0 + t1* l.b) (y0 + t2 * dy) Ou (l.z0 + t1* l.c) (z0 + t2 * dz) ento // as retas geraram um ponto de interseco invlido por isso so paralelas Prximo l Fim se // no segmento // da linha de // borda Se t1 0 E t1 1 ento // testa se est

Se teste = Verdadeiro ento Se tMin1 > t2 ento tMax1 tMin1 tMin1 t2 Se t1 = 0 Ou t1 = 1 ento nMin2 nulo // um vertice Seno nMin2 l.vizinho Fim se Seno tMax1 t2 Se t1 = 0 Ou t1 = 1 ento nMax2 nulo // um vertice Seno nMax2 l.vizinho Fim se Fim Se // encontrou os dois pontos // de encontro Sai do Para Seno tMin1 t2 teste Verdadeiro Se t1 = 0 Ou t1 = 1 ento nMin2 nulo // um vertice Seno nMin2 l.vizinho Fim se Fim se Fim se Se l = f2.linhas.ultimo ento // como no encontrou dois pontos // de encontro no necessrio // procurar em f2

95 Prximo f2 Fim se Fim se Prximo l Se tMin2 tMin1 E tMax2 tMax1 ento x1 x0 + tMin2*dx y1 y0 + tMin2*dy z1 z0 + tMin2*dz n1 nMin2 Se n1 = nulo ento // um vrtice //pega as faces do vrtice VFaces1encontrarVertice(x1,y1,z1,f2).Faces Fim se n2 nMin1 Se tMin2 = tMin1 ento Se n2 = nulo ento // um vrtice VFaces2encontrarVertice(x1,y1,z1,f1).Faces Fim se Seno n2 f1 Fim se x2 x0 + tMax2*dx y2 y0 + tMax2*dy z2 z0 + tMax2*dz n3 nMax2 Se n3 = nulo ento // um vrtice //pega as faces do vrtice VFaces3encontrarVertice(x2,y2,z2,f2).Faces Fim se n4 nMin1 Se tMax2 = tMax1 Se n2 = nulo ento // um vrtice Vfaces4encontrarVertice(x2,y2,z2,f1).Faces Fim se Seno n4 f1 Fim se Seno Se tMin1 tMin2 E tMax1 t2Max ento x1 x0 + tMin1*dx y1 y0 + tMin1*dy z1 z0 + tMin1*dz n1 nMin1 Se n1 = nulo ento // um vrtice //pega as faces do vrtice VFaces1encontrarVertice(x1,y1,z1,f1).Faces Fim se n2 nMin2 Se tMin2 = tMin1 Se n2 = nulo ento // um vrtice VFaces2encontrarVertice(x1,y1,z1,f2).Faces Fim se Seno n2 f2 Fim se

96

x2 x0 + tMax1*dx y2 y0 + tMax1*dy z2 z0 + tMax1*dz Se n3 = nulo ento // um vrtice //pega as faces do vrtice VFaces3encontrarVertice(x2,y2,z2,f1).Faces Fim se n4 nMin2 Se tMax2 = tMax1 Se n2 = nulo ento // um vrtice Vfaces4encontrarVertice(x2,y2,z2,f2).Faces Fim se Seno n4 f2 Fim se Seno Se tMin1 tMin2 E tMin1 tMax2 E tMax1 > tMax2 Ento x1 x0 + tMin1*dx y1 y0 + tMin1*dy z1 z0 + tMin1*dz Se n1 = nulo ento // um vrtice //pega as faces do vrtice VFaces1encontrarVertice(x1,y1,z1,f1).Faces Fim se n2 nMin2 Se tMin2 = tMin1 Se n2 = nulo ento // um vrtice VFaces2encontrarVertice(x1,y1,z1,f2).Faces Fim se Seno n2 f2 Fim se x2 x0 + tMax2*dx y2 y0 + tMax2*dy z2 z0 + tMax2*dz Se n3 = nulo ento // um vrtice //pega as faces do vrtice VFaces3encontrarVertice(x2,y2,z2,f2).Faces Fim se n4 nMin1 Se tMax2 = tMax1 Se n2 = nulo ento // um vrtice Vfaces4encontrarVertice(x2,y2,z2,f1).Faces Fim se Seno n4 f1 Fim se Seno Se t2Min tMin1 E tMin2 tMax1 E tMax2 > tMax1 ento x1 x0 + tMin2*dx y1 y0 + tMin2*dy z1 z0 + tMin2*dz Se n1 = nulo ento // um vrtice //pega as faces do vrtice vFaces1encontrarVertice(x1,y1,z1,f2).Faces Fim se

97 n2 nMin1 Se tMin2 = tMin1 Se n2 = nulo ento // um vrtice VFaces2encontrarVertice(x1,y1,z1,f1).Faces Fim se Seno n2 f1 Fim se x2 x0 + tMax1*dx y2 y0 + tMax1*dy z2 z0 + tMax1*dz Se n3 = nulo ento // um vrtice //pega as faces do vrtice vFaces3encontrarVertice(x2,y2,z2,f1).Faces Fim se n4 nMin2 Se tMax2 = tMax1 Se n2 = nulo ento // um vrtice Vfaces4encontrarVertice(x2,y2,z2,f2).Faces Fim se Seno n4 f2 Fim se Fim se tirarFlagCelulas(f1.Clulas) tirarFlagCelulas(f2.Clulas) InserirSegmento (x1, y1, z1, x2, y2, z2, f1, f2) Se Vfaces1 nulo ento Para toda face n1 de Vfaces1 Se Vfaces2 nulo ento Para toda face n2 de Vfaces1 teste loopIntersec(n1, n2, x1, y1, z1,x2, y2, z2, fim) Se teste Verdadeiro ento Sai do Para // j encontrou a interseco Fim se Prximo n2 Seno teste loopIntersec(n1, n2, x1, y1, z1, x2, y2, z2, fim) Fim se Se teste = Verdadeiro ento Sai do Para // j encontrou a interseco Fim se Prximo n1 Seno Se Vfaces2 nulo ento Para toda face n2 de Vfaces1 teste loopIntersec(n1, n2, x1, y1, z1,x2, y2, z2, fim) Se teste Verdadeiro ento Sai do Para // j encontrou a interseco Fim se Prximo n2 Seno teste loopIntersec(n1, n2, x1, y1, z1, x2, y2, z2, fim)

98 Fim se Se teste = Verdadeiro ento Sai do Para // j encontrou a interseco Fim se Fim se Se fim = Falso ento // se ainda no percorreu todo o // loop Se Vfaces3 nulo ento Para toda face n3 de Vfaces3 Se Vfaces4 nulo ento Para toda face n4 de Vfaces4 teste loopIntersec(n3, n4, x2, y2, z2, x1, y1, y1, Falso, fim) Se teste = Verdadeiro ento Sai do Para // j encontrou a // interseco Fim se Prximo n4 Seno teste loopIntersec(n3, n4, x2, y2, z2, x1, y1, y1, Falso, fim) Fim se Se teste = Verdadeiro ento Sai do Para // j encontrou a interseco Fim se Prximo n3 Seno Se Vfaces4 nulo ento Para toda face n4 de Vfaces4 teste loopIntersec(n3, n4, x2, y2, z2, x1, y1, y1, Falso, fim) Se teste = Verdadeiro ento Sai do Para // j encontrou a // interseco Fim se Prximo n4 Seno teste loopIntersec(n3, n4, x2, y2, z2, x1, y1, y1, Falso, fim) Fim se Se teste = Verdadeiro ento Sai do Para // j encontrou a interseco Fim se Fim se Fim Se retorna Fim se Prximo f2 Prximo f1 Fim EncontrarPontoInicial

99

ANEXO 9 FUNO LOOPINTERSEC

loopIntersec(f1, f2, x, y, z, xf, yf, zf, fim) a1 f1.v2.y*f1.v3.z - f1.v2.y2*f1.v1.z - f1.v1.y*f1.v3.z - f1.v3.y*f1.v2.z + f1.v1.y*f1.v2.z + f1.v3.y*f1.v1.z b1 f1.v3.x*f1.v2.z - f1.v1.x*f1.v2.z - f1.v3.x*f1.v1.z - f1.v2.x*f1.v3.z + f1.v2.x*f1.v1.z + f1.v1.x*f1.v3.z c1 f1.v2.x*f1.v3.y - f1.v2.x*f1.v1.y - f1.v1.x*f1.v3.y - f1.v3.x*f1.v2.y + f1.v1.x*f1.v2.y + f1.v3.x*f1.v1.y d1 - a*f1.v1.x - b*f1.v1.y - c*f1.v1.z a2 f2.v2.y*f2.v3.z - f2.v2.y2*f2.v1.z - f2.v1.y*f2.v3.z - f2.v3.y*f2.v2.z + f2.v1.y*f2.v2.z + f2.v3.y*f2.v1.z b2 f2.v3.x*f2.v2.z - f2.v1.x*f2.v2.z - f2.v3.x*f2.v1.z - f2.v2.x*f2.v3.z + f2.v2.x*f2.v1.z + f2.v1.x*f2.v3.z c2 f2.v2.x*f2.v3.y - f2.v2.x*f2.v1.y - f2.v1.x*f2.v3.y - f2.v3.x*f2.v2.y + f2.v1.x*f2.v2.y + f2.v3.x*f2.v1.y d2 - a*f2.v1.x - b*f2.v1.y - c*f2.v1.z Se a1 = a2 E b1 = b2 E c1 = c2 E d1 = d2 ento // no mesmo plano // lista PontosIntersec de vetores // lista LinhasIntersec(6, 6) nmero Para todo vrtice v de f1 Se PontoNoTriangulo(v.x, v.y, v.z, f2) = Verdadeiro Ento InserirPontoIntersec(v.x, v.y, v.z) // inserindo o ponto Fim Se Prximo v Para todo vrtice v de f2 Se PontoNoTriangulo(v.x, v.y, v.z, f2) = Verdadeiro Ento InserirPontoIntersec(v.x, v.y, v.z) // inserindo o ponto Fim Se Prximo v PontosDeEncontro(f1, f2, PontosIntersec) Se PontosIntersec.vazia = falso Then Para v1 1 at PontosIntersec.tamanho - 1 Para v2 2 at PontosIntersec.tamanho //face1 Para todas linhas l da face f1 todas as retas da face1 testar false Se l.a 0 ento t1 (v1.x - l.x0) / l.a t2 (v2.x - l.x0) / l.a testar Verdadeiro Fim se

100 Se l.b 0 ento Se testar = Verdadeiro ento l.b ento // no uma linha vlida Prximo l Fim Se Seno t1 (v1.y - l.y0) / l.b t2 (v2.y - l.y0) / l.b testar Verdadeiro Fim se Fim se Se l.c 0 ento Se testar = Verdadeiro ento l.c ento // no uma linha vlida Prximo l Fim Se Seno l.c ento // no uma linha vlida Prximo l Fim Se Fim se Fim se // pertence a reta InserirSegmento (v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, f1, f2) Prximo v2 Prximo l //face2 Para todas linhas l da face f2 todas as retas da face2 testar false Se l.a 0 ento t1 (v1.x - l.x0) / l.a t2 (v2.x - l.x0) / l.a testar Verdadeiro Fim se Se l.b 0 ento Se testar = Verdadeiro ento Se t1 (v1.y - l.y0) / l.b Ou t2 (v2.y - l.y0) / l.b ento // no uma linha vlida Prximo l Fim Se Seno t1 (v1.y - l.y0) / l.b t2 (v2.y - l.y0) / l.b testar Verdadeiro Fim se Se t1 (v1.z - l.z0) / l.c Ou t2 (v2.z - l.z0) / Se t1 (v1.z - l.z0) / l.c Ou t2 (v2.z - l.z0) / Se t1 (v1.y - l.y0) / l.b Ou t2 (v2.y - l.y0) /

101 Fim se Se l.c 0 ento Se testar = Verdadeiro ento ento // no uma linha vlida Prximo l Fim Se Seno Se t1 (v1.z - l.z0) / l.c Ou t2 (v2.z - l.z0) / // no uma linha vlida Prximo l Fim Se Fim se Fim se // pertence a reta InserirSegmento (v1.x, v1.y, v1.z, v2.x, v2.y, v2.z, f1, f2) retorna Verdadeiro Prximo v2 Fim Se Prximo l Prximo v2 Prximo v1 Seno // interseco entre as faces //encontrando reta de interseco entre os planos dx b1*c2 - c1*b2 dy c1*a2 - c2*a1 dz a1*b2 - a2*b1 x0 x y0 y z0 z // Testar reta com as linhas de bordas dos tringulos //face1 // flag para saber se h ponto de interseco j // calculado teste Falso Para todas as linhas l de f1.linhas faa 'inicio do encontro Se (l.a * dy - l.b * dx) = 0 E (l.a * dz - l.c * dx) = 0 E (l.b * dz - l.c * dy) = 0 ento // mesma reta // convertendo t da reta l para t da reta de interseco Se dx 0 ento tMin1 (l.x0 - x0) / dx tMax1 ((l.x0 + l.a) - x0) / dx Seno Se dy 0 ento Se t1 (v1.z - l.z0) / l.c Ou t2 (v2.z - l.z0) / l.c

l.c ento

102 tMin1 (l.y0 - y0) / dy tMax1 ((l.y0 + l.b) - y0) / dy Seno Se dz 0 ento tMin1 (l.z0 - z0) / dz tMax1 ((l.y0 + l.b) - z0) / dz Fim se Se tMin1 > tMax1 ento tTmp tMin1 tMin1 tMax1 tMax1 tTmp Fim Se nMax2 nMin1 nulo Sai do Para Seno Se (l.a * dy - l.b * dx) 0 ento t1 ((x0 - l.x0) * dy + (y0 - l.y0) * dx) / (dy * l.a - l.b * dx) t2 ((l.x0 - x0) * l.b + (y0 - l.y0) * l.a) / (l.b * dx - dy * l.a) Seno Se (l.a * dz - l.c * dx) 0 ento t1 ((x0 - l.x0) * dz + (z0 - l.z0) * dx) / (dz * l.a - l.c * dx) t2 ((l.x0 - x0) * l.c + (z0 - l.z0) * l.a) / (l.c * dx - dz * l.a) Seno Se (l.b * dz - l.c * dy) 0 ento t1 ((y0 - l.y0) * dz + (z0 - l.z0) * dy) / (dz * l.b - l.c * dy) t2 ((l.y0 - y0) * l.c + (z0 - l.z0) * l.b) / (l.c * dy - dz * l.b) Fim Se l.b) (y0 + t2 * dy) Se (l.x0 + t1* l.a) (x0 + t2 * dx) Ou (l.y0 + t1*

Ou (l.z0 + t1* l.c) (z0 + t2 * dz) ento // as retas geraram um ponto de interseco invlido por isso so paralelas Prximo l Fim se Se t1 0 E t1 1 ento // testa se est no segmento // da linha de borda Se teste = Verdadeiro ento Se tMin1 > t2 ento tMax1 tMin1 vMax1 vMin1 tMin1 t2 Se t1 = 0 Ou t1 = 1 ento nMin1 nulo // um vertice Seno nMin1 l.vizinho Fim se Seno tMax1 t2 Se t1 = 0 Ou t1 = 1 ento nMax1 nulo Seno // um vertice nMax1 l.vizinho Fim se Fim se // encontrou os dois pontos de encontro

103 Sai do Para Seno tMin1 t2 Se t1 = 0 Ou t1 = 1 ento // um vertice nMin1 nulo Seno nMin1 l.vizinho Fim se teste Verdadeiro Fim se Fim se Se l = f1.linhas.ultimo ento // como no encontrou dois pontos de encontro // no necessrio retorna Falso Fim se Prximo l //face2 // flag para saber se h ponto de interseco j calculado teste Falso Para todas as linhas l de f2.linhas faa // inicio do encontro Se (l.a * dy - l.b * dx) = 0 E (l.a * dz - l.c * dx) = 0 E (l.b * dz - l.c * dy) = 0 ento // mesma reta //convertendo t da reta l para t da reta de interseco Se dx 0 ento tMin2 (l.x0 - x0) / dx tMax2 ((l.x0 + l.a) - x0) / dx Seno Se dy 0 ento tMin2 (l.y0 - y0) / dy tMax2 ((l.y0 + l.b) - y0) / dy Seno Se dz 0 ento tMin2 (l.z0 - z0) / dz tMax2 ((l.y0 + l.b) - z0) / dz Fim se Se tMin1 > tMax1 ento tTmp tMin2 tMin2 tMax2 tMax2 tTmp Fim se nMax2 nMin2 nulo Sai do Para Seno Se (l.a * dy - l.b * dx) 0 ento t1 ((x0 - l.x0) * dy + (y0 - l.y0) * dx) / (dy * l.a - l.b * dx) t2 ((l.x0 - x0) * l.b + (y0 - l.y0) * l.a) / (l.b * dx - dy * l.a) Seno Se (l.a * dz - l.c * dx) 0 ento t1 ((x0 - l.x0) * dz + (z0 - l.z0) * dx) / (dz * l.a - l.c * dx) t2 ((l.x0 - x0) * l.c + (z0 - l.z0) * l.a) / (l.c * dx - dz * l.a)

104 Seno Se (l.b * dz - l.c * dy) 0 ento t1 ((y0 - l.y0) * dz + (z0 - l.z0) * dy) / (dz * l.b - l.c * dy) t2 ((l.y0 - y0) * l.c + (z0 - l.z0) * l.b) / (l.c * dy - dz * l.b) Fim se Se t1 0 E t1 1 ento // testa se est no segmento da // linha de borda Se teste = Verdadeiro ento Se tMin1 > t2 ento tMax1 tMin1 tMin1 t2 Se t1 = 0 Ou t1 = 1 ento nMin2 nulo // um vertice Seno nMin2 l.vizinho Fim se Seno tMax1 t2 Se t1 = 0 Ou t1 = 1 ento nMax2 nulo // um vertice Seno nMax2 l.vizinho Fim se Fim Se // encontrou os dois pontos de encontro Sai do Para Seno tMin1 t2 teste Verdadeiro Se t1 = 0 Ou t1 = 1 ento nMin2 nulo // um vertice Seno nMin2 l.vizinho Fim se Fim se Fim se Se l = f2.linhas.ultimo ento // como no encontrou dois pontos // de encontro no // necessrio retorna Falso Fim se Fim se Prximo l contNeg = 0 // cont negativo contPos = 0 // cont positivo Se tMin1 < 0 ento contNeg +=1 Seno Se tMin1 > 0 ento ContPos += 0

105 Fim se Se tMax1 < 0 ento contNeg +=1 Seno Se tMax1 > 0 ento contPos += 0 Fim se Se tMin2 < 0 ento contNeg +=1 Seno Se tMin2 > 0 ento contPos += 0 Fim se Se tMax2 < 0 ento contNeg +=1 Seno Se tMax2 > 0 ento contPos += 0 Fim se t=0 Se contPos = 2 ento Se tMax1 < tMax2 ento t = tMax1 n1 = nMax1 n2 = f2 Seno se tMax2 < tMax1 ento t = tMax2 n1 = nMax1 n2 = f1 Seno t = tMax1 n1 = nMax1 n2 = nMax2 Fim se Seno Se tMin1 > tMin2 ento t = tMin1 n1 = nMin1 n2 = f2 Seno se tMin2 > tMin1 ento t = tMin2 n1 = f1 n2 = nMin1 Seno t = tMin1 n1 = nMin1 n2 = nMin2 Fim se Fim se x1 x0 + t*dx y1 y0 + t*dy z1 z0 + t*dz Se n1 = nulo ento // um vrtice Vfaces1 encontrarVertice(x1,y1,z1,f1).Faces

106 Fim se Se n2 = nulo ento // um vrtice Vfaces2 encontrarVertice(x1,y1,z1,f2).Faces Fim se tirarFlagCelulas(f1.Clulas) tirarFlagCelulas(f2.Clulas) InserirSegmento (x, y, z, x1, y1, z1, f1, f2) // testa se chegou ao ponto final caso tenha chego no continua o loop Se (x1 xf E y1 yf E z1 zf) ento Se Vfaces1 nulo ento Para toda face n1 de Vfaces1 Se Vfaces2 nulo ento Para toda face n2 de Vfaces1 teste loopIntersec(n1, n2, x1, y1, z1, xf, yf, zf, fim) Se teste = Verdadeiro ento Sai do Para // j encontrou a // interseco Fim se Prximo n2 Seno teste loopIntersec(n1, n2, x1, y1, z1, xf, yf, zf, fim) Fim se Se teste = Verdadeiro ento Sai do Para // j encontrou a interseco Fim se Prximo n1 Seno Se Vfaces2 nulo ento Para toda face n2 de Vfaces1 teste loopIntersec(n1, n2, x1, y1, z1, xf, yf, zf, fim) Se teste = Verdadeiro ento Sai do Para // j encontrou a // interseco Fim se Prximo n2 Seno teste loopIntersec(n1, n2, x1, y1, z1, xf, yf, zf, fim) Fim se Se teste = Verdadeiro ento Sai do Para // j encontrou a interseco Fim se Fim se Seno fim verdadeiro Fim se retorna Verdadeiro Fim se fim loopIntersec

107

ANEXO 10 FUNO ENCONTRARPONTOSDEENCONTRO

encontrarPontosDeEncontro(f1, f2, PontosIntersec) // Face 1 Para todas linhas l1 de f1 // Face 2 Para todas linhas l2 de f2 // inicio do encontro Se (l1.a * l2.b - l1.b * l2.a) = 0 E (l1.a * l2.c l1.c * l2.a) = 0 E (l1.b * l2.c l1.c * l2.b) = 0 ento // mesma reta xMax1 l1.x0 + l1.a xMin1 l1.x0 yMax1 l1.y0 + l1.b yMin1 l1.y0 zMax1 l1.z0 + l1.c zMin1 l1.z0 xMax2 l2.x0 + l2.a xMin2 l2.x0 yMax2 l2.y0 + l2.b yMin2 l2.y0 zMax2 l2.z0 + l2.c zMin2 l2.z0 // convertendo t reta2 para t de reta1 Se l1.a 0 ento t2Max (xMax2 - l1.x0) / l1.a t2Min (xMin2 - l1.x0) / l1.a Seno Se l1.b 0 ento t2Max (yMax2 - l1.y0) / l1.b t2Min (yMin2 - l1.y0) / l1.b Seno Se l1.c 0 ento t2Max (yMax2 - l1.z0) / l1.c t2Min (yMin2 - l1.z0) / l1.c Fim se v1 novo vrtice v2 novo vrtice Se t2Min 0 E t2Max 1 ento v1.x xMin2 v1.y yMin2 v1.z zMin2 PontosIntersec.inserir v1 v2.x xMax2 v2.y yMax2 v2.z zMax2 PontosIntersec.inserir v2

108 Seno Se 0 t2Min E 1 t2Max ento v1.x xMin1 v1.y yMin1 v1.z zMin1 PontosIntersec.inserir v1 v2.x xMax2 v2.y yMax2 v2.z zMax2 PontosIntersec.inserir v2 Seno se 0 t2Min E 0 t2Max E 1 > t2Max ento v1.x xMin1 v1.y yMin1 v1.z zMin1 PontosIntersec.inserir v1 v2.x xMax2 v2.y yMax2 v2.z zMax2 PontosIntersec.inserir v2 Seno se t2Min 0 E t2Min 1 E t2Max > 1 ento v1.x xMin2 v1.y yMin2 v1.z zMin2 PontosIntersec.inserir v1 v2.x xMax1 v2.y yMax1 v2.z zMax1 PontosIntersec.inserir v2 End If Seno t1 ((l2.x0 - l1.x0) * l2.b + (l1.y0 - l2.y0) * l2.a) / (l2.b * l1.a - l1.b * l2.a) t2 ((l1.x0 - l2.x0) * l1.b + (l2.y0 - l1.y0) * l1.a) / (l1.b * l2.a - l2.b * l1.a) Se t1 1E t1 0ento Se t2 1E t2 0ento x l1.x0 + t1 * l1.a y l1.y0 + t1 * l1.b z l1.z0 + t1 * l1.c // testa se as retas no so paralelas Se (x = l2.x0 + t2 * l2.a) E (y = l2.y0 + t2 * l2.b) E (y = l2.y0 + t2 * l2.b) ento v1 novo vrtice v1.x x v1.y y v1.y y inserirPontoIntersec.inserir v1 Fim Se Fim Se Fim Se Fim Se Prximo j Prximo i Fim encontrarPontosDeEncontro

109

REFERNCIAS BIBLIOGRFICAS
COELHO, L. C. G., Gattass, M. and Figueiredo, L. H.; Intersecting and Trimming Parametric Meshes on Finite-Element Shells. International Journal for Numerical Methods in Engineering. Chichester, Reino Unido, vol. 47, no. 4, pp. 777-800, 2000. DRAKOS, Nikos. Computer Based Learning Unit: 1994, University of Leeds. Disponvel em: http://www.cs.fit.edu/wds/classes/cse5255/thesis/index. Acesso em: 28/09/2004. GUIGUE, Philippe; DEVILLERS, Olivier. Fast and Robust Triangle-Triangle Overlap Test using Orientation Predicates: 2003, Sophia Antipolis. Disponvel Acesso em: 25/10/2004. IBGE. Produo Industrial cresce pelo sexto ms consecutivo: 2004, IBGE (Instituto Brasileiro de Geogrfica e Estatstica). Disponvel em: http://www.ibge.gov.br/home/presidencia/noticias/noticia_visualiza.php? id_noticia=233&id_pagina=1. Acessado em: 15/10/2004. KOLMAN, Bernard. Introduo lgebra Linear. Rio de Janeiro: LTC - Livros Tcnicos e Cientficos Editora S. A., 1996. LAY, David C. lgebra Linear e Suas Aplicaes. Rio de Janeiro: LTC Livros Tcnicos e Cientficos Editora S. A., 1999. LIRA, William Wagner Matos. Modelagem Geomtrica Para Elementos Finitos Usando Multi-regies e Superfcies Paramtricas. Pontifcia Universidade Catlica do Rio de Janeiro. Rio de Janeiro, Brasil, Maio de 2002. MARIELLI. Histria da Geometria: 2004. Disponvel em: http://users.hotlink.com.br/marielli/matematica/histomatica/histogeo.html. Acessado em: 01/09/2004. MLLER, Tomas. A Fast Triangle-Triangle Intersection Test, Journal of graphics tools. Goteborg, Sucia, vol. 2, no. 2, 25-30, 1997. em: http://wwwsop.inria.fr/prisme/personnel/guigue/triangle_triangle_intersection.html.

110

PIO, Jos Luiz de Souza. Modelagem de Slidos: 2004, UFMG. Disponvel em: PREPARATA, F. http://www.dcc.ufmg.br/~josepio/discp/modgeo/modgeo.html. P.; Shamos, M. I. Computational Geometry: An Acessado em: 27/10/04. Introduction. Nova York: Springer Verlag, 1990. ROSSIGNAC, Jarek. Triangle Meshes 3D Modeling, Graphics and Animation. Georgia Institute of Technology. Atlanta, USA, 29 de Abril de 2004. STEINBRUCH, Alfredo; WINTERLE, Paulo. Person Education do Brasil, 1987. TCA. Geometria: 1996, KidBit. Disponvel em: http://www.kidbit.com.br/mate12.htm. Acessado em 14/10/2004 VENTURI, Jacir J. lgebra Vetorial e Geometria Analtica. Curitiba: UFPR, 2003. WANG, W. X; LO, S. H. A fast robust algorithm for the intersection of triangulated surfaces. Engineering with Computers. Londres, Inglaterra, 20, 11-21, 4 de maro de 2004. ZACHMANN, Gabriel. Triangle and Quadrangle Intersection Tests. Bonn, Alemanha, 19 de Maio de 2003. lgebra Linear. So Paulo: