Relatório EP CAD CAM

Relatório EP CAD CAM

(Parte 1 de 2)

1. Introdução

O objetivo deste trabalho é a utilizaçãodo programa USPDesignerpara o desenvolvimento de três funções em linguagem C++ para o cálculo da área, volume e centro de gravidade de um determinado sólido. Também é desenvolvido uma função para construção de um sólido primitivo T, dadas as suas dimensões. O desenvolvimento dos comandos é mostrado abaixo.

1.1Cálculo da Área

Na realidade, todas as funções usadas para o cálculo da área foram dadas para servir como exemplo para o desenvolvimento das outras funções. A idéia para calcular a área dos sólidos é calcular a área dos triângulos formados pelas meias-arestas e seus vértices. Cada shell tem um conjunto de faces que por sua vez possui um conjunto de laços que é formado por uma seqüência de meias-arestas que liga os vértices do sólido. Com base nesta organização, o cálculo da área de cada triângulo formado pelas meias-arestas do sólido, resulta a área total. A fórmula usada segue a baixo:

2121Árearr,(1)

onde o triângulo tem vértices T

1.2Cálculo do Volume

Analogamente à área, o cálculo do volume do sólido é baseado no volume de um tetraedro. A organização das propriedades utilizadas no calculo é a mesma descrita para o cálculo da área. A idéia é transformar, através da matriz de transformação T, um tetraedro qualquer em um tetraedro unitário ortogonal, através dos vértices do sólido original para o novo sistema de coordenadas, desta forma defini-se:

T(2)

z y x

Desta forma o volume é dado por:

TV,(3)

onde T é o valor absoluto do determinante da matriz T.

1.3Cálculo do centro de gravidade

Utilizando a idéia do cálculo do volume do tetraedro, o centro de gravidade do sólido é a somatória do centro de gravidade de cada tetraedro unitário ortogonal multiplicado pelo seu volume divido pelo volume total do sólido, sendo, portanto uma média ponderada. Define-se as coordenadas do centro de gravidade de cada tetraedro como:

,(4)

z y x

1.4Gerando o T primitivo

Dadas as dimensões d1, d2, d3, d4 e d5 do T, utilizam-se os operadores de

Euler MVSF (Make Vertex Solid Face), MEV (Make Edge Vertex) e MEF (Make Edge Face) para gerar o sólido desejado. A idéia é fazer a face de cima primeiro. Em seguida, geram-se as arestas que estendem os vértices da primeira face e ao final geram-se todas as faces laterais. Por último, a face inferior. A seqüência da criação de vértices é mostrada na figura 1.

Figura 1 – Seqüência da geração de vértices e arrestas do T.

2. Código fonte

#include <stdio.h> #include <string.h>

#define __VIRTUAL_MEM

#define __ROV__

#include "mensagem.h"

#include "memvirtu.h"

#include "lowparam.h"

#include "lowmacro.h"

#include "lowsolid.h"

#include "eulerops.h"

#include "vectorop.h"

#include "genfunc_.h"

#include "analise_.h"

#include "prop.h"

#include "mancommd.h"

// AREA float MSD_highNamePropriedadeArea(char *name); float MSD_highPropriedadeArea(Id sn); double MSD_lowPropriedadeArea(SPTYPE s); double MSD_lowPropriedadeAreaFace(FPTYPE f); double MSD_lowPropriedadeAreaLaco(LPTYPE l);

// VOLUME float MSD_highNamePropriedadeVolume(char *name); float MSD_highPropriedadeVolume(Id sn); double MSD_lowPropriedadeVolume(SPTYPE s); double MSD_lowPropriedadeVolumeFace(FPTYPE f); double MSD_lowPropriedadeVolumeLaco(LPTYPE l);

// CENTRO DE GRAVIDADE void MSD_highNamePropriedadeCGravidade(char *name,float *cx,float *cy,float *cz); void MSD_highPropriedadeCGravidade(Id sn,float *cx, float *cy,float *cz); void MSD_lowPropriedadeCGravidade(SPTYPE s,float *cx, float *cy, float *cz); void MSD_lowPropriedadeCGravidadeFace(FPTYPE f,float *cx, float *cy, float *cz); void MSD_lowPropriedadeCGravidadeLaco(LPTYPE l,float *cx, float *cy, float *cz);

// PRIMITIVO T void MSD_highCreatePrimitivoT(char *name, float *d1, float *d2, float *d3,float *d4, float *d5);

int ip;
char onam[30];
matrix mat ;
float area, volume, cx, cy, cz ; // definição das variáveis locais
float d1, d2, d3, d4, d5;
for (ip = 0 ; ip == 0 ; ) {
switch(optin()) { // recupera as oções do comando
// - Comando calcula a area - recupera o nome do solido
case 'a':
if (1 == sscanf(restbuf, "%s", onam)) {
area = MSD_highNamePropriedadeArea(onam) ;
ip = 1 ;
printf("area = %f\n", - area);
}

/***************************************************** MAIN *****************************************************/ void MSD_execManipulatePropriedade(void) { break ;

case 'v':
if (1 == sscanf(restbuf, "%s", onam)) {
volume = abs(MSD_highNamePropriedadeVolume(onam)) ;
ip = 1 ;
printf("volume = %f\n", volume);
}
break ;
// - Comando calcula o centro de gravidade
case 'c':
if (1 == sscanf(restbuf, "%s", onam)) {
MSD_highNamePropriedadeCGravidade(onam, &cx, &cy, &cz) ;
ip = 1 ;
printf("centro de gravidade = [%f,%f,%f]\n", cx, cy, cz);
}
break ;
// - Comando para criar o primitivo barra T
case 't':
if(6 == sscanf(restbuf,"%s %f %f %f %f %f",onam,&d1,&d2,&d3,&d4, &d5))
MSD_highCreatePrimitivoT(onam, &d1, &d2, &d3, &d4, &d5);
ip = 1 ;
}
break ;
}
if (ip == 0) {
printf("-avct nome do sólido\n") ;
if (!lineins("? "))
return ;
}
}

// - Comando calcula o volume { }

int sn ; // identificador do sólido
if ((sn = MSD_getSolidIdFromName(name)) == -1) {
fprintf(stderr, "area: nao encontrou o sólido %s!\n", name) ;
return(0.0) ;
}
return(MSD_highPropriedadeArea(sn)) ;
SPTYPE s ; // ponteiro para o sólido
if ((s = MSD_getSolid(sn)) == SNIL) {
fprintf(stderr, "area: nao encontrou o sólido %d!\n", sn) ;
return(0.0) ;
}
return(MSD_lowPropriedadeArea(s)) ;
DPTYPE d;
FPTYPE f;

double MSD_lowPropriedadeArea(SPTYPE s) { double area = 0;

for (f = SheSFaces(d) ; f != FNIL ; f = FacNextF(f))
area += MSD_lowPropriedadeAreaFace(f);
return(area);

for (d = SolSShells(s) ; d != DNIL ; d = SheNextD(d)) }

LPTYPE l;
double area = 0;
area = MSD_lowPropriedadeAreaLaco(FacFLOut(f));
for (l = FacFLoops(f) ; l != LNIL ; l = LooNextL(l))
if (l != FacFLOut(f))
area -= MSD_lowPropriedadeAreaLaco(l);
return(area);

double MSD_lowPropriedadeAreaFace(FPTYPE f) { }

HPTYPE he ;
VPTYPE v1 ;
vector a, b, c, d, vv1 ;
veczer(d) ;
he = LooLEdg(l) ;
v1 = HalVtx(he) ;
he = HalNxt(he) ;
do {
veccopy(vv1, VerVCoord(v1)) ;
vecminus(a, VerVCoord(HalVtx(he)), vv1) ;
vecminus(b, VerVCoord(HalVtx(HalNxt(he))), vv1) ;
cross(c, a, b) ;
vecplus(d, d, c) ;
} while ((he = HalNxt(he)) != LooLEdg(l)) ;
return(-0.5 * dot(FacFeq(LooLFace(l)), d)) ;

double MSD_lowPropriedadeAreaLaco(LPTYPE l) { }

int sn ; // identificador do sólido
if ((sn = MSD_getSolidIdFromName(name)) == -1) {
fprintf(stderr, "Volume: nao encontrou o sólido %s!\n", name) ;
return(0.0) ;
}
return(MSD_highPropriedadeVolume(sn)) ;
SPTYPE s ; // ponteiro para o sólido
if ((s = MSD_getSolid(sn)) == SNIL) {
fprintf(stderr, "Volume: nao encontrou o sólido %d!\n", sn) ;
return(0.0) ;
}
return(MSD_lowPropriedadeVolume(s)) ;
DPTYPE d;// shell
FPTYPE f;// face

double MSD_lowPropriedadeVolume(SPTYPE s) {

VPTYPE v;// vertice double Volume = 0;

for (f = SheSFaces(d) ; f != FNIL ; f = FacNextF(f))
Volume += MSD_lowPropriedadeVolumeFace(f);
return(Volume);

for (d = SolSShells(s) ; d != DNIL ; d = SheNextD(d)) }

LPTYPE l;
double Volume = 0;
Volume = MSD_lowPropriedadeVolumeLaco(FacFLOut(f)); // passa laco externo da face f
for (l = FacFLoops(f) ; l != LNIL ; l = LooNextL(l))
if (l != FacFLOut(f))
Volume -= MSD_lowPropriedadeVolumeLaco(l);
return(Volume);

double MSD_lowPropriedadeVolumeFace(FPTYPE f) { }

HPTYPE he ;
VPTYPE v1 ;
vector a, b, c, d, vv1, vv2, vv3;

double MSD_lowPropriedadeVolumeLaco(LPTYPE l) { double volume; volume = 0;

he = LooLEdg(l) ;
v1 = HalVtx(he) ;
he = HalNxt(he) ;
do {
} while ((he = HalNxt(he)) != LooLEdg(l)) ;

veccopy(vv1, VerVCoord(v1)); veccopy(a, VerVCoord(HalVtx(he))); veccopy(b, VerVCoord(HalVtx(HalNxt(he)))); cross(c, vv1, b); volume += dot(c, a); return(-volume/6); }

int sn ; // identificador do sólido
float volume;// volume do sólido
if ((sn = MSD_getSolidIdFromName(name)) == -1) {
fprintf(stderr, "CGravidade: nao encontrou o sólido %s!\n", name) ;
return ;
}
MSD_highPropriedadeCGravidade(sn,cx,cy,cz);
volume = MSD_highNamePropriedadeVolume(name);
*cx = *cx/volume;
*cy = *cy/volume;
*cz = *cz/volume;

/***************************************************** Cálculo do centro de gravidade *****************************************************/ void MSD_highNamePropriedadeCGravidade(char *name, float *cx, float *cy, float *cz) { }

SPTYPE s ; // ponteiro para o sólido
if ((s = MSD_getSolid(sn)) == SNIL) {
fprintf(stderr, "CGravidade: nao encontrou o sólido %d!\n", sn) ;

void MSD_highPropriedadeCGravidade(Id sn,float *cx, float *cy, float *cz) { return ;

MSD_lowPropriedadeCGravidade(s,cx,cy,cz);
DPTYPE d;// shell
FPTYPE f;// face
VPTYPE v;// vertice
for (d = SolSShells(s) ; d != DNIL ; d = SheNextD(d))
for (f = SheSFaces(d) ; f != FNIL ; f = FacNextF(f))
MSD_lowPropriedadeCGravidadeFace(f,cx,cy,cz);

void MSD_lowPropriedadeCGravidade(SPTYPE s,float *cx, float *cy, float *cz) { }

(Parte 1 de 2)

Comentários