00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041 #include <stdio.h>
00042 #ifndef __UNIX_
00043 #include <stdlib.h>
00044 #endif
00045 #include <math.h>
00046 #include "memvirtu.h"
00047 #include "lowparam.h"
00048 #include "lowmacro.h"
00049 #include "lowsolid.h"
00050 #include "lowgeome.h"
00051 #include "eulerops.h"
00052 #include "vectorop.h"
00053 #include "sethmain.h"
00054
00055
00056 void MSD_lowSetOpVVInsertNullEdges(int op)
00057 {
00058 HPTYPE ha1;
00059 HPTYPE ha2;
00060 HPTYPE hb1;
00061 HPTYPE hb2;
00062 int i, j, InterCont;
00063
00064
00065
00066
00067
00068 for (InterCont = j = 0; j < nsectors; j++)
00069 {
00070 if (SetSecInter(j) == 1)
00071 {
00072 InterCont++;
00073 }
00074 }
00075
00076 if ((InterCont != 0) && (InterCont != 2))
00077 {
00078 fprintf(stderr, "%d", InterCont);
00079 }
00080
00081 i = 0;
00082 while (1)
00083 {
00084 while (SetSecInter(i) == 0)
00085 {
00086 if (++i > nsectors - 1)
00087 {
00088 return;
00089 }
00090 }
00091
00092 ha1 = hb1 = ha2 = hb2 = HNIL;
00093 if (SetSecs1a(i) == USP_IN)
00094 {
00095 ha1 = SetANBHe(SetSecA(i));
00096 }
00097 else
00098 {
00099 ha2 = SetANBHe(SetSecA(i));
00100 }
00101 if (SetSecs1b(i) == USP_OUT)
00102 {
00103 hb1 = SetBNBHe(SetSecB(i));
00104 }
00105 else
00106 {
00107 hb2 = SetBNBHe(SetSecB(i));
00108 }
00109
00110 if (++i > nsectors - 1)
00111 {
00112 return;
00113 }
00114
00115 while (SetSecInter(i) == 0)
00116 {
00117 if (++i > nsectors - 1)
00118 {
00119 return;
00120 }
00121 }
00122
00123 if (SetSecs1a(i) == USP_IN)
00124 {
00125 ha1 = SetANBHe(SetSecA(i));
00126 }
00127 else
00128 {
00129 ha2 = SetANBHe(SetSecA(i));
00130 }
00131 if (SetSecs1b(i) == USP_OUT)
00132 {
00133 hb1 = SetBNBHe(SetSecB(i));
00134 }
00135 else
00136 {
00137 hb2 = SetBNBHe(SetSecB(i));
00138 }
00139 i++;
00140
00141 if ((ha1 == HNIL) || (ha2 == HNIL) || (hb1 == HNIL) || (hb2 == HNIL))
00142 {
00143 for (InterCont = j = 0; j < nsectors; j++)
00144 {
00145 if (SetSecInter(j) == 1)
00146 {
00147 InterCont++;
00148 }
00149 }
00150 fprintf(stderr, "*%d*", InterCont);
00151 if (i > nsectors - 1)
00152 {
00153 return;
00154 }
00155 fprintf(stderr, "+");
00156 continue;
00157 }
00158
00159 if ((ha1 == ha2) && (hb1 == hb2))
00160 {
00161 continue;
00162 }
00163 if (ha1 == ha2)
00164 {
00165 MSD_lowSetOpSepar2(ha1, 0, MSD_lowSetOpGetOrient(ha1, hb1, hb2), op);
00166 MSD_lowSetOpSepar1(hb1, hb2, 1);
00167 }
00168 else
00169 if (hb1 == hb2)
00170 {
00171 MSD_lowSetOpSepar2(hb1, 1, MSD_lowSetOpGetOrient(hb1, ha2, ha1), op);
00172 MSD_lowSetOpSepar1(ha2, ha1, 0);
00173 }
00174 else
00175 {
00176 MSD_lowSetOpSepar1(ha2, ha1, 0);
00177 MSD_lowSetOpSepar1(hb1, hb2, 1);
00178 }
00179 if (i > nsectors - 1)
00180 {
00181 return;
00182 }
00183 }
00184 }
00185
00186
00187
00188
00189
00190
00191
00192 int MSD_lowSetOpGetOrient(HPTYPE ref, HPTYPE he1, HPTYPE he2)
00193 {
00194 HPTYPE mhe1;
00195 HPTYPE mhe2;
00196 int retcode;
00197
00198
00199 mhe1 = HalNxt(mate(he1));
00200 mhe2 = HalNxt(mate(he2));
00201
00202
00203
00204 if ((mhe1 != he2) && (mhe2 == he1))
00205 {
00206 retcode = MSD_lowSetOpConvexEdge(he2);
00207 }
00208 else
00209 {
00210 retcode = MSD_lowSetOpConvexEdge(he1);
00211 }
00212
00213 #ifdef TRACE_BOOLEAN2
00214 FILE *ttrace = fopen("trace.txt", "a");
00215 fprintf(ttrace, "--> *******\n");
00216 fprintf(ttrace, "--> mhe1 != he2 --> %s\n", mhe1 != he2 ? "TRUE" : "FALSE");
00217 fprintf(ttrace, "--> mhe2 == he1 --> %s\n", mhe2 == he1 ? "TRUE" : "FALSE");
00218 fprintf(ttrace, "--> MSD_lowSetOpConvexEdge(ref) = %d\n", MSD_lowSetOpConvexEdge(ref));
00219 fprintf(ttrace, "--> MSD_lowSetOpConvexEdge(he2) = %d\n", MSD_lowSetOpConvexEdge(he2));
00220 fprintf(ttrace, "--> MSD_lowSetOpConvexEdge(he1) = %d\n", MSD_lowSetOpConvexEdge(he1));
00221 fprintf(ttrace, "--> MSD_lowSetOpSectorWide(mhe1, 0) = %d\n", MSD_lowSetOpSectorWide(mhe1, 0));
00222 fprintf(ttrace, "--> MSD_lowSetOpSectorWide(mhe2, 0) = %d\n", MSD_lowSetOpSectorWide(mhe2, 0));
00223 fprintf(ttrace, "--> MSD_lowSetOpSectorWide(he2, 0) = %d\n", MSD_lowSetOpSectorWide(he2, 0));
00224 fprintf(ttrace, "--> MSD_lowSetOpSectorWide(he1, 0) = %d\n", MSD_lowSetOpSectorWide(he1, 0));
00225 fprintf(ttrace, "--> MSD_lowSetOpSectorWide(ref, 0) = %d\n", MSD_lowSetOpSectorWide(ref, 0));
00226 int ret = retcode;
00227 if ((MSD_lowSetOpSectorWide(mhe1, 0) == 1) && (MSD_lowSetOpSectorWide(ref, 0) == 1))
00228 {
00229 ret = 1 - retcode;
00230 }
00231 fprintf(ttrace, "--> return code = %d\n\n", 1 - ret);
00232 fclose(ttrace);
00233 #endif
00234
00235 if ((MSD_lowSetOpSectorWide(mhe1, 0) == 1) && (MSD_lowSetOpSectorWide(ref, 0) == 1))
00236 {
00237 retcode = 1 - retcode;
00238 }
00239
00240 if ((mhe1 != he2) && (mhe2 == he1) && (MSD_lowSetOpConvexEdge(ref) == 0) &&
00241 (MSD_lowSetOpConvexEdge(he1) == 0) &&
00242 (MSD_lowSetOpConvexEdge(he2) == 0) &&
00243 (MSD_lowSetOpSectorWide(mhe1, 0) == 1) &&
00244 (MSD_lowSetOpSectorWide(mhe2, 0) == 1) &&
00245 (MSD_lowSetOpSectorWide(he2, 0) == 1) &&
00246 (MSD_lowSetOpSectorWide(he1, 0) == 1) &&
00247 (MSD_lowSetOpSectorWide(ref, 0) == 0))
00248 {
00249 return(0);
00250 }
00251
00252 return(1 - retcode);
00253 }
00254
00255 int MSD_lowSetOpSectorWide(HPTYPE he, int ind)
00256 {
00257 vector ref1[2], ref2[2], ref12[2];
00258 vector v1, v2, v3;
00259
00260 veccopy(v1, VerVCoord(HalVtx(HalPrv(he))));
00261 veccopy(v2, VerVCoord(HalVtx(HalNxt(he))));
00262 veccopy(v3, VerVCoord(HalVtx(he)));
00263 vecminus(ref1[ind], v1, v3);
00264 vecminus(ref2[ind], v2, v3);
00265 cross(ref12[ind], ref1[ind], ref2[ind]);
00266 if (vecnull(ref12[ind], EPS))
00267 {
00268 return(1);
00269 }
00270 return((dot(ref12[ind], FacFeq(LooLFace(HalWLoop(he)))) > 0.0) ? 0 : 1);
00271 }
00272
00273 int MSD_lowSetOpConvexEdge(HPTYPE he)
00274 {
00275 HPTYPE h2;
00276 vector dir, cr, v1, v2, f1, f2;
00277
00278 h2 = HalNxt(he);
00279 if (MSD_lowSetOpNullEdge(he))
00280 {
00281 h2 = HalNxt(h2);
00282 }
00283 veccopy(v1, VerVCoord(HalVtx(h2)));
00284 veccopy(v2, VerVCoord(HalVtx(he)));
00285 vecminus(dir, v1, v2);
00286 veccopy(f1, FacFeq(LooLFace(HalWLoop(he))));
00287 veccopy(f2, FacFeq(LooLFace(HalWLoop(mate(he)))));
00288 cross(cr, f1, f2);
00289 if (vecnull(cr, EPS))
00290 {
00291 return(1);
00292 }
00293 return(dot(dir, cr) < 0.0);
00294 }
00295
00296
00297 void MSD_lowSetOpSepar1(HPTYPE from, HPTYPE to, int type)
00298 {
00299 HPTYPE PrvFrom;
00300
00301
00302 #ifdef TRACE_BOOLEAN2
00303 fprintf(trace, "*** separ1! ***\n");
00304 #endif
00305
00306 PrvFrom = HalPrv(from);
00307
00308
00309 if (MSD_lowSetOpNullEdge(PrvFrom) && MSD_lowSetOpStrutNullEdge(PrvFrom))
00310 {
00311 #ifdef TRACE_BOOLEAN2
00312 fprintf(trace, "*** existe um strut null edge na frente de from!\n");
00313 #endif
00314
00315 if (PrvFrom == EdgHe2(HalEdg(PrvFrom)))
00316 {
00317 from = HalPrv(PrvFrom);
00318 }
00319 }
00320
00321 if (MSD_lowSetOpNullEdge(HalPrv(to)) && MSD_lowSetOpStrutNullEdge(HalPrv(to)))
00322 {
00323 #ifdef TRACE_BOOLEAN2
00324 fprintf(trace, "*** existe um strut null edge na frente de to!\n");
00325 #endif
00326
00327 if (HalPrv(to) == EdgHe1(HalEdg(HalPrv(to))))
00328 {
00329 to = HalPrv(HalPrv(to));
00330 }
00331 }
00332
00333 if (HalVtx(from) != HalVtx(to))
00334 {
00335 if (HalPrv(from) == mate(HalPrv(to)))
00336 {
00337 from = HalPrv(from);
00338
00339 #ifdef TRACE_BOOLEAN2
00340 fprintf(trace, "*** from e to possuem vertices diferentes\n");
00341 #endif
00342 }
00343 else
00344 if (HalVtx(HalPrv(from)) == HalVtx(to))
00345 {
00346 from = HalPrv(from);
00347
00348 #ifdef TRACE_BOOLEAN2
00349 fprintf(trace, "*** from->prv e to possuem vertices iguais\n");
00350 #endif
00351 }
00352 else
00353 if (HalVtx(HalPrv(to)) == HalVtx(from))
00354 {
00355 to = HalPrv(to);
00356
00357 #ifdef TRACE_BOOLEAN2
00358 fprintf(trace, "*** to->prv e from possuem vertices iguais\n");
00359 #endif
00360 }
00361 }
00362
00363 #ifdef TRACE_BOOLEAN2
00364 fprintf(trace, "*** Aplicando o operador MEV\n");
00365 trace_he(from);
00366 trace_he(to);
00367 #endif
00368
00369 MSD_lowMEV(from, to, maxv++, VerVCoord(HalVtx(from))[0],
00370 VerVCoord(HalVtx(from))[1],
00371 VerVCoord(HalVtx(from))[2]);
00372 if (type == 0)
00373 {
00374 #ifdef TRACE_BOOLEAN2
00375 fprintf(trace, "*** Aresta Solido A inserida na SONEA\n");
00376 trace_e(HalEdg(HalPrv(from)));
00377 #endif
00378
00379 SetSonea(nedga) = HalEdg(HalPrv(from));
00380 nedga++;
00381
00382 #ifndef __VIRTUAL_MEM
00383 if (nedga == MAXNULLEDGES)
00384 {
00385 fprintf(stderr, "sonea: falta memoria!\n");
00386 exit(1);
00387 }
00388 #endif
00389 }
00390 else
00391 {
00392 #ifdef TRACE_BOOLEAN2
00393 fprintf(trace, "*** Aresta Solido A inserida na SONEB\n");
00394 trace_e(HalEdg(HalPrv(from)));
00395 #endif
00396
00397 SetSoneb(nedgb) = HalEdg(HalPrv(from));
00398 nedgb++;
00399
00400 #ifndef __VIRTUAL_MEM
00401 if (nedgb == MAXNULLEDGES)
00402 {
00403 fprintf(stderr, "soneb: falta memoria!\n");
00404 exit(1);
00405 }
00406 #endif
00407 }
00408 }
00409
00410
00411 void MSD_lowSetOpSepar2(HPTYPE he, int type, int orient, int)
00412 {
00413 HPTYPE tmp;
00414
00415 #ifdef TRACE_BOOLEAN2
00416 fprintf(trace, "*** separ2! ***\n");
00417 #endif
00418
00419 if (MSD_lowSetOpNullEdge(HalPrv(he)))
00420 {
00421 if (((HalPrv(he) == EdgHe1(HalEdg(HalPrv(he)))) && orient) ||
00422 ((HalPrv(he) == EdgHe2(HalEdg(HalPrv(he)))) && !orient))
00423 {
00424 he = HalPrv(he);
00425 }
00426
00427 #ifdef TRACE_BOOLEAN2
00428 fprintf(trace, "*** existe um null edge na frente de he!\n");
00429 #endif
00430 }
00431
00432 #ifdef TRACE_BOOLEAN2
00433 fprintf(trace, "*** Aplicando o operador MEV\n");
00434 trace_he(he);
00435 trace_he(he);
00436 #endif
00437 MSD_lowMEV(he, he, maxv++, VerVCoord(HalVtx(he))[0],
00438 VerVCoord(HalVtx(he))[1],
00439 VerVCoord(HalVtx(he))[2]);
00440
00441
00442 if (orient)
00443 {
00444 #ifdef TRACE_BOOLEAN2
00445 fprintf(trace, "*** Realizou magica\n");
00446 #endif
00447
00448 tmp = EdgHe1(HalEdg(HalPrv(he)));
00449 EdgHe1(HalEdg(HalPrv(he))) = EdgHe2(HalEdg(HalPrv(he)));
00450 EdgHe2(HalEdg(HalPrv(he))) = tmp;
00451 }
00452
00453 if (type == 0)
00454 {
00455 #ifdef TRACE_BOOLEAN2
00456 fprintf(trace, "*** Aresta Solido A inserida na SONEA\n");
00457 trace_e(HalEdg(HalPrv(he)));
00458 #endif
00459
00460 SetSonea(nedga) = HalEdg(HalPrv(he));
00461 nedga++;
00462
00463 #ifndef __VIRTUAL_MEM
00464 if (nedga == MAXNULLEDGES)
00465 {
00466 fprintf(stderr, "sonea: falta memoria!\n");
00467 exit(1);
00468 }
00469 #endif
00470 }
00471 else
00472 {
00473 #ifdef TRACE_BOOLEAN2
00474 fprintf(trace, "*** Aresta Solido A inserida na SONEB\n");
00475 trace_e(HalEdg(HalPrv(he)));
00476 #endif
00477
00478 SetSoneb(nedgb) = HalEdg(HalPrv(he));
00479 nedgb++;
00480
00481 #ifndef __VIRTUAL_MEM
00482 if (nedgb == MAXNULLEDGES)
00483 {
00484 fprintf(stderr, "soneb: falta memoria!\n");
00485 exit(1);
00486 }
00487 #endif
00488 }
00489 }
00490
00491 int MSD_lowSetOpStrutNullEdge(HPTYPE he)
00492 {
00493 if ((he == HalNxt(mate(he))) || (he == HalPrv(mate(he))))
00494 {
00495 return(1);
00496 }
00497 return(0);
00498 }
00499
00500 int MSD_lowSetOpNullEdge(HPTYPE he)
00501 {
00502 return(MSD_lowVtxVtxContainment(HalVtx(he), HalVtx(HalNxt(he))));
00503 }