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 "eulerops.h"
00051 #include "vectorop.h"
00052 #include "sethmain.h"
00053 #include "splsplit.h"
00054
00055
00056 void MSD_lowSetOpClassify(int op)
00057 {
00058 int i;
00059
00060 #ifdef TRACE_BOOLEAN
00061 fprintf(trace, "\n\n\n");
00062 fprintf(trace, "*************************************************\n");
00063 fprintf(trace, "* *\n");
00064 fprintf(trace, "* SETOPCLASSIFY *\n");
00065 fprintf(trace, "* *\n");
00066 fprintf(trace, "*************************************************\n");
00067 fprintf(trace, "\n");
00068 #endif
00069
00070 #ifdef __VIRTUAL_MEM
00071
00072
00073
00074 fclose(SET03VirtualArray->file);
00075
00076
00077
00078
00079 if (MSD_lowSetOpInitiate3() == ERROR)
00080 {
00081 fprintf(stderr, "setop: 3 - nao conseguiu abrir arquivos de memoria virtual!\n");
00082 return;
00083 }
00084
00085
00086
00087
00088 if (MSD_lowSetOpInitiate5() == ERROR)
00089 {
00090 fprintf(stderr, "setop: 5 - nao conseguiu abrir arquivos de memoria virtual!\n");
00091 return;
00092 }
00093 #endif
00094
00095 nedga = nedgb = 0;
00096
00097 for (i = 0; i < nvtxa; ++i)
00098 {
00099 MSD_lowVtxFacClassify(SetAVFv(i), SetAVFf(i), op, 0);
00100 }
00101 for (i = 0; i < nvtxb; ++i)
00102 {
00103 MSD_lowVtxFacClassify(SetBVFv(i), SetBVFf(i), op, 1);
00104 }
00105
00106 #ifdef __VIRTUAL_MEM
00107
00108
00109
00110 MSD_lowSetOpTerminate2();
00111
00112
00113
00114
00115 MSD_lowSetOpTerminate3();
00116
00117
00118
00119
00120 if ((SET03VirtualArray->file = fopen("SETOP03.TMP", "r+b")) == (FILE *)NIL)
00121 {
00122 fprintf(stderr, "setop: 3!- nao conseguiu abrir arquivos de memoria virtual!\n");
00123 return;
00124 }
00125
00126
00127
00128
00129 if (MSD_lowSetOpInitiate4() == ERROR)
00130 {
00131 fprintf(stderr, "setop: 4 - nao conseguiu abrir arquivos de memoria virtual!\n");
00132 return;
00133 }
00134 #endif
00135
00136 for (i = 0; i < nvvtx; ++i)
00137 {
00138 MSD_lowVtxVtxClassify(SetVVva(i), SetVVvb(i), op);
00139 }
00140
00141 #ifdef __VIRTUAL_MEM
00142
00143
00144
00145 MSD_lowSetOpTerminate4();
00146
00147
00148
00149
00150 MSD_lowSetOpTerminate1();
00151 #endif
00152
00153
00154 #ifdef TRACE_BOOLEAN
00155 fprintf(trace, "\n");
00156 fprintf(trace, "*** setopclassify *** - nedga = %2i\n", nedga);
00157 fprintf(trace, "*** setopclassify *** - nedgb = %2i\n", nedgb);
00158 fprintf(trace, "*** estrutura sonea ***\n");
00159 for (i = 0; i < nedga; i++)
00160 {
00161 trace_e(SetSonea(i));
00162 }
00163 fprintf(trace, "*** estrutura soneb ***\n");
00164 for (i = 0; i < nedgb; i++)
00165 {
00166 trace_e(SetSoneb(i));
00167 }
00168 #endif
00169 }
00170
00171
00172 void MSD_lowVtxVtxClassify(VPTYPE va, VPTYPE vb, int op)
00173 {
00174 #ifdef TRACE_BOOLEAN2
00175 int i;
00176 static char *ff[] = { "OUT", "ON ", "IN " };
00177
00178 fprintf(trace, "\n");
00179 if (op == USP_UNION)
00180 {
00181 fprintf(trace, "*** Caso vtxvtx - Operacao UNIAO\n");
00182 }
00183 if (op == USP_INTERSECT)
00184 {
00185 fprintf(trace, "*** Caso vtxvtx - Operacao INTERSECCAO\n");
00186 }
00187 if (op == USP_DIFFERENCE)
00188 {
00189 fprintf(trace, "*** Caso vtxvtx - Operacao DIFERENCA\n");
00190 }
00191 #endif
00192
00193 MSD_lowSetOpVVGetNeighborhood(va, vb);
00194 #ifdef TRACE_BOOLEAN2
00195 fprintf(trace, "\n*** sgetneighborhood ***\n");
00196 fprintf(trace, "*** Possuimos apenas setores cuja interseccao tambem\n");
00197 fprintf(trace, "*** intersecciona os dois setores!!\n");
00198 for (i = 0; i < nsectors; ++i)
00199 {
00200 trace_sec(i);
00201 }
00202 #endif
00203
00204 MSD_lowSetOpVVReclassifySectors(op);
00205 #ifdef TRACE_BOOLEAN2
00206 fprintf(trace, "\n\n*** sreclassifyonsectors ***\n");
00207 for (i = 0; i < nsectors; ++i)
00208 {
00209 trace_sec(i);
00210 }
00211 #endif
00212
00213 MSD_lowSetOpVVReclassifyEdges(op);
00214 #ifdef TRACE_BOOLEAN2
00215 fprintf(trace, "\n\n*** sbreclasifyonedges ***\n");
00216 for (i = 0; i < nsectors; ++i)
00217 {
00218 trace_sec(i);
00219 }
00220 #endif
00221
00222 MSD_lowSetOpVVInsertNullEdges(op);
00223 }
00224
00225 void MSD_lowVtxFacClassify(VPTYPE v, FPTYPE f, int op, int flag)
00226 {
00227 vector feq;
00228
00229 #ifdef TRACE_BOOLEAN2
00230 int i;
00231
00232 fprintf(trace, "\n");
00233 if (op == USP_UNION)
00234 {
00235 fprintf(trace, "*** Caso vtxfac - Operacao UNIAO\n");
00236 }
00237 if (op == USP_INTERSECT)
00238 {
00239 fprintf(trace, "*** Caso vtxfac - Operacao INTERSECCAO\n");
00240 }
00241 if (op == USP_DIFFERENCE)
00242 {
00243 fprintf(trace, "*** Caso vtxfac - Operacao DIFERENCA\n");
00244 }
00245 if (flag == 0)
00246 {
00247 fprintf(trace, "*** Vertice de A e Face de B\n");
00248 }
00249 if (flag == 1)
00250 {
00251 fprintf(trace, "*** Vertice de B e Face de A\n");
00252 }
00253 #endif
00254
00255 veccopy(feq, FacFeq(f));
00256 MSD_lowSetOpVFGetNeighborhood(v, feq);
00257 #ifdef TRACE_BOOLEAN2
00258 fprintf(trace, "\n*** vizinhanca ***\n");
00259 trace_f(f);
00260 trace_v(v);
00261 for (i = 0; i < nnbr; ++i)
00262 {
00263 trace_he(SetNBRSector(i));
00264 }
00265 fprintf(trace, "\n*** getneighborhood ***\n");
00266 for (i = 0; i < nnbr; ++i)
00267 {
00268 trace_nbr(i);
00269 }
00270 #endif
00271
00272 MSD_lowSetOpVFReclassifyOnSectors(feq, op, flag);
00273 #ifdef TRACE_BOOLEAN2
00274 fprintf(trace, "*** reclassifyonsectors ***\n");
00275 for (i = 0; i < nnbr; ++i)
00276 {
00277 trace_nbr(i);
00278 }
00279 #endif
00280
00281 MSD_lowSetOpVFReclassifyOnEdges();
00282 #ifdef TRACE_BOOLEAN2
00283 fprintf(trace, "*** breclasifyonedges ***\n");
00284 for (i = 0; i < nnbr; ++i)
00285 {
00286 trace_nbr(i);
00287 }
00288 #endif
00289
00290 MSD_lowSetOpVFInsertNullEdges(f, flag);
00291 }
00292
00293 void MSD_lowSetOpVFGetNeighborhood(VPTYPE v, vector SP)
00294 {
00295 HPTYPE he;
00296
00297 #ifndef __VIRTUAL_MEM
00298 VTYPE bisect;
00299 #else
00300 int c1;
00301 VPTYPE bisect;
00302 vector bisectcor;
00303
00304 bisect = MSD_getMemVirtual(VERTEX);
00305 #endif
00306
00307 nnbr = 0;
00308 he = VerVEdge(v);
00309 do
00310 {
00311 SetNBRC1(nnbr) =
00312 -comp(MSD_lowDistancePlanePoint(SP, HalVtx(HalNxt(he))), 0.0, EPS);
00313 SetNBRSector(nnbr) = he;
00314 nnbr++;
00315
00316 #ifndef __VIRTUAL_MEM
00317 if (nnbr == MAXEDGESFORVERTEX)
00318 {
00319 fprintf(stderr, "nbr: falta memoria!\n");
00320 exit(1);
00321 }
00322 #endif
00323
00324 if (MSD_lowCheckWideness(he) == 1)
00325 {
00326 #ifndef __VIRTUAL_MEM
00327 MSD_lowBisector(he, bisect.vcoord);
00328 SetNBRSector(nnbr) = he;
00329 SetNBRC1(nnbr) = SetNBRC1(nnbr - 1);
00330 SetNBRC1(nnbr - 1) =
00331 -comp(MSD_lowDistancePlanePoint(SP, &bisect), 0.0, EPS);
00332 nnbr++;
00333
00334 if (nnbr == MAXEDGESFORVERTEX)
00335 {
00336 fprintf(stderr, "set_nbr: falta memoria!\n");
00337 exit(1);
00338 }
00339 #else
00340 MSD_lowBisector(he, bisectcor);
00341 veccopy(VerVCoord(bisect), bisectcor);
00342 SetNBRSector(nnbr) = he;
00343 c1 = SetNBRC1(nnbr - 1);
00344 SetNBRC1(nnbr) = c1;
00345 SetNBRC1(nnbr - 1) =
00346 -comp(MSD_lowDistancePlanePoint(SP, bisect), 0.0, EPS);
00347 nnbr++;
00348 #endif
00349 }
00350 } while ((he = HalNxt(mate(he))) != VerVEdge(v));
00351
00352 #ifdef __VIRTUAL_MEM
00353 MSD_putMemVirtual(bisect, VERTEX);
00354 #endif
00355 }
00356
00357 void MSD_lowSetOpVFReclassifyOnSectors(vector SP, int op, int flag)
00358 {
00359 FPTYPE f;
00360 vector c;
00361 int i;
00362
00363 for (i = 0; i < nnbr; i++)
00364 {
00365 f = LooLFace(HalWLoop(mate(SetNBRSector(i))));
00366 cross(c, FacFeq(f), SP);
00367 if (comp(dot(c, c), 0.0, EPS * EPS) == 0)
00368 {
00369 if (comp(dot(FacFeq(f), SP), 0.0, EPS) == 1)
00370 {
00371
00372 if (flag)
00373 {
00374 SetNBRC1(i) = (op == USP_UNION) ? USP_IN : USP_OUT;
00375 SetNBRC1((i + 1) % nnbr) = (op == USP_UNION) ? USP_IN : USP_OUT;
00376 if (SetNBRSector((i + 1) % nnbr) == SetNBRSector((i + 2) % nnbr))
00377 {
00378 SetNBRC1((i + 2) % nnbr) = (op == USP_UNION) ? USP_IN : USP_OUT;
00379 }
00380 }
00381 else
00382 {
00383 SetNBRC1(i) = (op == USP_UNION) ? USP_OUT : USP_IN;
00384 SetNBRC1((i + 1) % nnbr) = (op == USP_UNION) ? USP_OUT : USP_IN;
00385 if (SetNBRSector((i + 1) % nnbr) == SetNBRSector((i + 2) % nnbr))
00386 {
00387 SetNBRC1((i + 2) % nnbr) = (op == USP_UNION) ? USP_OUT : USP_IN;
00388 }
00389 }
00390 }
00391 else
00392 {
00393 if (flag)
00394 {
00395 SetNBRC1(i) = (op == USP_UNION) ? USP_IN : USP_OUT;
00396 SetNBRC1((i + 1) % nnbr) = (op == USP_UNION) ? USP_IN : USP_OUT;
00397 if (SetNBRSector((i + 1) % nnbr) == SetNBRSector((i + 2) % nnbr))
00398 {
00399 SetNBRC1((i + 2) % nnbr) = (op == USP_UNION) ? USP_IN : USP_OUT;
00400 }
00401 }
00402 else
00403 {
00404 SetNBRC1(i) = (op == USP_UNION) ? USP_IN : USP_OUT;
00405 SetNBRC1((i + 1) % nnbr) = (op == USP_UNION) ? USP_IN : USP_OUT;
00406 if (SetNBRSector((i + 1) % nnbr) == SetNBRSector((i + 2) % nnbr))
00407 {
00408 SetNBRC1((i + 2) % nnbr) = (op == USP_UNION) ? USP_IN : USP_OUT;
00409 }
00410 }
00411 }
00412 }
00413 }
00414 }
00415
00416 void MSD_lowSetOpVFReclassifyOnEdges(void)
00417 {
00418 int i;
00419
00420 for (i = 0; i < nnbr; ++i)
00421 {
00422 if (SetNBRC1(i) == USP_ON)
00423 {
00424 if (SetNBRC1((nnbr + i - 1) % nnbr) == USP_IN)
00425 {
00426 if (SetNBRC1((i + 1) % nnbr) == USP_IN)
00427 {
00428 SetNBRC1(i) = USP_IN;
00429 }
00430 else
00431 {
00432 SetNBRC1(i) = USP_IN;
00433 }
00434 }
00435 else
00436 {
00437 if (SetNBRC1((i + 1) % nnbr) == USP_IN)
00438 {
00439 SetNBRC1(i) = USP_IN;
00440 }
00441 else
00442 {
00443 SetNBRC1(i) = USP_OUT;
00444 }
00445 }
00446 }
00447 }
00448 }
00449
00450 void MSD_lowSetOpVFInsertNullEdges(FPTYPE f, int flag)
00451 {
00452 HPTYPE tail;
00453 HPTYPE head;
00454 int i, start;
00455
00456 i = 0;
00457 while (!(SetNBRC1(i) == USP_OUT && SetNBRC1((i + 1) % nnbr) == USP_IN))
00458 {
00459 if (++i == nnbr)
00460 {
00461 return;
00462 }
00463 }
00464 start = i;
00465
00466 head = SetNBRSector((i + 1) % nnbr);
00467
00468 while (1)
00469 {
00470 while (!(SetNBRC1(i) == USP_IN && SetNBRC1((i + 1) % nnbr) == USP_OUT))
00471 {
00472 i = (i + 1) % nnbr;
00473 }
00474 tail = SetNBRSector((i + 1) % nnbr);
00475
00476
00477 #ifdef TRACE_BOOLEAN2
00478 fprintf(trace, "*** Aplicando o operador MEV\n");
00479 trace_he(head);
00480 trace_he(tail);
00481 #endif
00482 MSD_lowMEV(head, tail, maxv++, VerVCoord(HalVtx(head))[0],
00483 VerVCoord(HalVtx(head))[1],
00484 VerVCoord(HalVtx(head))[2]);
00485
00486 if (flag == 0)
00487 {
00488 #ifdef TRACE_BOOLEAN2
00489 fprintf(trace, "*** Aresta Solido A inserida na SONEA\n");
00490 trace_e(HalEdg(HalPrv(head)));
00491 #endif
00492
00493 SetSonea(nedga) = HalEdg(HalPrv(head));
00494 nedga++;
00495
00496 #ifndef __VIRTUAL_MEM
00497 if (nedga == MAXNULLEDGES)
00498 {
00499 fprintf(stderr, "sonea: falta memoria!\n");
00500 exit(1);
00501 }
00502 #endif
00503 }
00504 else
00505 {
00506 #ifdef TRACE_BOOLEAN2
00507 fprintf(trace, "*** Aresta Solido B inserida na SONEB\n");
00508 trace_e(HalEdg(HalPrv(head)));
00509 #endif
00510
00511 SetSoneb(nedgb) = HalEdg(HalPrv(head));
00512 nedgb++;
00513
00514 #ifndef __VIRTUAL_MEM
00515 if (nedgb == MAXNULLEDGES)
00516 {
00517 fprintf(stderr, "soneb: falta memoria!\n");
00518 exit(1);
00519 }
00520 #endif
00521 }
00522
00523 MSD_lowSetOpMakeRing(f, VerVCoord(HalVtx(head))[0],
00524 VerVCoord(HalVtx(head))[1],
00525 VerVCoord(HalVtx(head))[2], flag);
00526
00527
00528
00529
00530 while (!(SetNBRC1(i) == USP_OUT && SetNBRC1((i + 1) % nnbr) == USP_IN))
00531 {
00532 if ((i = (i + 1) % nnbr) == start)
00533 {
00534 return;
00535 }
00536 }
00537 }
00538 }
00539
00540 void MSD_lowSetOpMakeRing(FPTYPE f, double x, double y, double z, int flag)
00541 {
00542 HPTYPE he1;
00543 HPTYPE he2;
00544
00545 #ifdef TRACE_BOOLEAN2
00546 fprintf(trace, "*** Aplicando o operador MEV\n");
00547 trace_he(LooLEdg(FacFLOut(f)));
00548 trace_he(LooLEdg(FacFLOut(f)));
00549 #endif
00550
00551 MSD_lowMEV(LooLEdg(FacFLOut(f)), LooLEdg(FacFLOut(f)), maxv++, x, y, z);
00552 he1 = HalPrv(LooLEdg(FacFLOut(f)));
00553
00554 #ifdef TRACE_BOOLEAN2
00555 fprintf(trace, "*** Aplicando o operador MEV\n");
00556 trace_he(he1);
00557 trace_he(he1);
00558 #endif
00559
00560 MSD_lowMEV(he1, he1, maxv++, x, y, z);
00561 he2 = HalPrv(he1);
00562
00563 #ifdef TRACE_BOOLEAN2
00564 fprintf(trace, "*** Aplicando o operador KEMR\n");
00565 trace_he(HalPrv(HalPrv(HalPrv(he1))));
00566 trace_he(he1);
00567 #endif
00568
00569 MSD_lowKEMR(HalPrv(HalPrv(HalPrv(he1))), he1);
00570
00571 if (flag == 1)
00572 {
00573 #ifdef TRACE_BOOLEAN2
00574 fprintf(trace, "*** Aresta Solido A inserida na SONEA\n");
00575 trace_e(HalEdg(he2));
00576 #endif
00577
00578 SetSonea(nedga) = HalEdg(he2);
00579 nedga++;
00580
00581 #ifndef __VIRTUAL_MEM
00582 if (nedga == MAXNULLEDGES)
00583 {
00584 fprintf(stderr, "sonea: falta memoria!\n");
00585 exit(1);
00586 }
00587 #endif
00588 }
00589 else
00590 {
00591 #ifdef TRACE_BOOLEAN2
00592 fprintf(trace, "*** Aresta Solido B inserida na SONEB\n");
00593 trace_e(HalEdg(he2));
00594 #endif
00595
00596 SetSoneb(nedgb) = HalEdg(he2);
00597 nedgb++;
00598
00599 #ifndef __VIRTUAL_MEM
00600 if (nedgb == MAXNULLEDGES)
00601 {
00602 fprintf(stderr, "soneb: falta memoria!\n");
00603 exit(1);
00604 }
00605 #endif
00606 }
00607 }