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 #include <string.h>
00043 #include <math.h>
00044 #include "memvirtu.h"
00045 #include "lowmacro.h"
00046 #include "lowparam.h"
00047 #include "lowsolid.h"
00048 #include "eulerops.h"
00049 #include "vectorop.h"
00050 #include "mancommd.h"
00051 #include "rndround.h"
00052
00053 int EdgeGeneration_faces(SPTYPE s)
00054 {
00055 GenerationEdges_corners(s);
00056 GenerationEdges_nvertices(s);
00057 return(SUCCESS);
00058 }
00059
00060
00061
00062 int GenerationEdges_corners(SPTYPE s)
00063 {
00064 DPTYPE d;
00065 FPTYPE f;
00066 LPTYPE l;
00067 HPTYPE he;
00068 HPTYPE heaux;
00069 HPTYPE he3;
00070 real th;
00071 int flag;
00072
00073 for (AllShellsSolid(s, d))
00074 {
00075 for (AllFacesShell(d, f))
00076 {
00077 for (AllLoopsFace(f, l))
00078 {
00079 he = he3 = LooLEdg(l);
00080 printf("*");
00081 do
00082 {
00083 if (VerFgMake(HalVtx(he)) == 1)
00084 {
00085 he3 = he;
00086 printf("ok");
00087 break;
00088 }
00089 } while ((he = HalNxt(he)) != LooLEdg(l));
00090
00091 he = he3;
00092 do
00093 {
00094 printf("<");
00095 flag = 0;
00096 if (VerFgMake(HalVtx(he)) == MSD_ROUND_V_ORIGINAL)
00097 {
00098 printf(":");
00099 heaux = he;
00100 he = HalNxt(he);
00101 th = angle_edge(heaux);
00102 if (comp(th, PI, EPS) == -1)
00103 {
00104 printf("<1");
00105 flag = 1;
00106 MakeEdgeConvexCorner(s, heaux);
00107 }
00108 if (comp(th, PI, EPS) == 0)
00109 {
00110 printf("<2");
00111 flag = 1;
00112 MakeEdgeFlatCorner(s, heaux);
00113 }
00114 if (comp(th, PI, EPS) == 1)
00115 {
00116 printf("<3");
00117 flag = 1;
00118 MakeEdgeConcaveCorner(s, heaux);
00119 }
00120 if (flag == 0)
00121 {
00122 he = HalNxt(he);
00123 }
00124 }
00125 else
00126 {
00127 he = HalNxt(he);
00128 }
00129 } while (HalVtx(he) != HalVtx(he3));
00130 }
00131 }
00132 }
00133
00134 printf("[saiu]");
00135 return(TRUE);
00136 }
00137
00138 int GenerationEdges_nvertices(SPTYPE s)
00139 {
00140 DPTYPE d;
00141 FPTYPE f;
00142 LPTYPE l;
00143 EPTYPE ee;
00144 HPTYPE he;
00145 HPTYPE he1;
00146 HPTYPE he2;
00147 HPTYPE heloop;
00148 VPTYPE v;
00149 int flag, cont, VFgM, EFgM, EFgR;
00150 vector p1, p2, p3, p4, n, vaux, vau1;
00151
00152 maxv = MSD_getMaxVertexId(s);
00153 maxf = MSD_getMaxFaceId(s);
00154 for (AllShellsSolid(s, d))
00155 {
00156 for (AllFacesShell(d, f))
00157 {
00158 for (AllLoopsFace(f, l))
00159 {
00160 printf("$");
00161 #ifdef __TRACE_ROUND__
00162 printf("face = %d\n", FacFaceNo(f));
00163 #endif
00164
00165 he1 = he2 = LooLEdg(l);
00166 do
00167 {
00168 ee = HalEdg(he1);
00169 VFgM = VerFgMake(HalVtx(he1));
00170 EFgM = EdgFgMake(ee);
00171 EFgR = EdgFgRound(ee);
00172 if (((VFgM == 1) && (EFgR == 1) && (EFgM != 2)) || (VFgM == 2))
00173 {
00174 he2 = he1;
00175 break;
00176 }
00177 } while ((he1 = HalNxt(he1)) != LooLEdg(l));
00178
00179 flag = 0;
00180 he1 = he2;
00181 ee = HalEdg(he1);
00182 VFgM = VerFgMake(HalVtx(he1));
00183 EFgM = EdgFgMake(ee);
00184 EFgR = EdgFgRound(ee);
00185
00186 if (((VFgM == 1) && (EFgR == 1) && (EFgM != 2)) || (VFgM == 2))
00187 {
00188 cont = 0;
00189 if ((((EFgR == 1) && (EFgM == 1) && (EFgM != 2)) || (VFgM == 2)) &&
00190 (EdgFgRound(HalEdg(HalNxt(he1))) != 1))
00191 {
00192 flag = 1;
00193 }
00194
00195 v = HalVtx(he1);
00196 do
00197 {
00198 ee = HalEdg(he2);
00199 EFgM = EdgFgMake(ee);
00200 EFgR = EdgFgRound(ee);
00201 if ((EFgR != 1) && (EFgM == 0))
00202 {
00203 cont = 1;
00204 }
00205
00206 he2 = HalNxt(he2);
00207 ee = HalEdg(he2);
00208 VFgM = VerFgMake(HalVtx(he2));
00209 EFgM = EdgFgMake(ee);
00210 EFgR = EdgFgRound(ee);
00211 if ((((VFgM == 1) && (EFgR == 1) && (EFgM != 2)) || (VFgM == 2)) &&
00212 (flag == 1) &&
00213 (HalPrv(HalPrv(he2)) != he1) && (he1 != he2) &&
00214 (HalNxt(he2) != he1) && (cont == 1))
00215 {
00216 if (VFgM == 1)
00217 {
00218 if ((VerFgMake(HalVtx(HalNxt(he2))) == 2) &&
00219 (he1 != HalNxt(he2)) &&
00220 (HalNxt(HalNxt(he2)) != he1))
00221 {
00222 he2 = HalNxt(he2);
00223 }
00224 }
00225 #ifdef __TRACE_ROUND__
00226 printf("criou nova face!\n");
00227 printf("v1=(%.2f,%.2f,%.2f) v2=(%.2f,%.2f,%.2f)\n",
00228 VerVCoord(HalVtx(he1))[0],
00229 VerVCoord(HalVtx(he1))[1],
00230 VerVCoord(HalVtx(he1))[2],
00231 VerVCoord(HalVtx(he2))[0],
00232 VerVCoord(HalVtx(he2))[1],
00233 VerVCoord(HalVtx(he2))[2]);
00234 #endif
00235
00236 MSD_lowMEF(he1, he2, ++maxf);
00237 he = HalPrv(he2);
00238 ee = HalEdg(he);
00239 EdgFgMake(ee) = MSD_ROUND_E_FASE2;
00240 EdgFgRound(ee) = MSD_ROUND_FLAG_E1;
00241 flag = 0;
00242 cont = 0;
00243 he1 = he2;
00244 }
00245
00246 if ((((VFgM == 1) && (EFgR == 1) && (EFgM != 2)) || (VFgM == 2)) && (cont == 0))
00247 {
00248 he1 = he2;
00249 flag = 1;
00250 }
00251 if (EFgR == 0)
00252 {
00253 cont = 1;
00254 }
00255 if ((VFgM != 1) || (EFgR != 1) || (VFgM != 2))
00256 {
00257 he = HalPrv(he2);
00258 ee = HalEdg(he);
00259 if ((EdgFgRound(ee) != 1) &&
00260 (EdgFgMake(ee) == MSD_ROUND_E_ORIGINAL))
00261 {
00262 flag = 1;
00263 }
00264 }
00265 } while (HalVtx(he2) != v);
00266 }
00267 }
00268 }
00269 }
00270
00271 for (AllShellsSolid(s, d))
00272 {
00273 for (AllFacesShell(d, f))
00274 {
00275 for (AllLoopsFace(f, l))
00276 {
00277 printf("!");
00278 he = heloop = LooLEdg(l);
00279 do
00280 {
00281 printf("+");
00282 if ((VerFgMake(HalVtx(he)) == 1) &&
00283 (EdgFgRound(HalEdg(he)) != 1) &&
00284 (comp(angle_edge(he), PI, EPS) == 0))
00285 {
00286 veccopy(vaux, VerVCoord(HalVtx(HalPrv(HalPrv(he)))));
00287 if (vecequal(vaux, VerVCoord(HalVtx(HalPrv(he)))) != 1)
00288 {
00289 veccopy(vaux, VerVCoord(HalVtx(he)));
00290 vecminus(p3, vaux, VerVCoord(HalVtx(mate(he))));
00291 veccopy(vaux, VerVCoord(HalVtx(HalPrv(HalPrv(he)))));
00292 vecminus(p4, vaux, VerVCoord(HalVtx(HalPrv(he))));
00293 cross(n, p4, p3);
00294 normalize(n);
00295 }
00296 else
00297 {
00298 veccopy(vaux, VerVCoord(HalVtx(HalNxt(HalNxt(he)))));
00299 vecminus(p3, vaux, VerVCoord(HalVtx(HalNxt(he))));
00300 veccopy(vaux, VerVCoord(HalVtx(HalNxt(he))));
00301 vecminus(p4, vaux, VerVCoord(HalVtx(he)));
00302 cross(n, p4, p3);
00303 normalize(n);
00304 }
00305
00306 veccopy(vaux, VerVCoord(HalVtx(he)));
00307 point_perp(vaux, VerVCoord(HalVtx(mate(he))), p1, n, 1);
00308 veccopy(vau1, VerVCoord(HalVtx(HalPrv(HalPrv(he)))));
00309 line_inter(vaux, p1, vau1,
00310 VerVCoord(HalVtx(HalPrv(HalPrv(HalPrv(he))))), p2);
00311 if (cont_point(HalVtx(HalPrv(HalPrv(he))),
00312 HalVtx(HalPrv(HalPrv(HalPrv(he)))), p2) == 1)
00313 {
00314 printf("1");
00315 MSD_lowMEV(HalPrv(HalPrv(HalPrv(he))),
00316 HalNxt(mate(HalPrv(HalPrv(HalPrv(he))))),
00317 ++maxv, p2[0],
00318 p2[1],
00319 p2[2]);
00320 VerFgMake(HalVtx(HalPrv(HalPrv(HalPrv(he))))) = MSD_ROUND_V_FASE2;
00321 EdgFgMake(HalEdg(HalPrv(HalPrv(HalPrv(he))))) = MSD_ROUND_E_FASE2;
00322 MSD_lowMEF(HalPrv(HalPrv(HalPrv(he))), he, ++maxf);
00323 EdgFgMake(HalEdg(HalPrv(he))) = MSD_ROUND_E_FASE2;
00324 break;
00325 }
00326 else
00327 {
00328 printf("2");
00329 MSD_lowMEV(HalPrv(HalPrv(HalPrv(HalPrv(he)))),
00330 HalNxt(mate(HalPrv(HalPrv(HalPrv(HalPrv(he)))))),
00331 ++maxv, p2[0],
00332 p2[1],
00333 p2[2]);
00334 VerFgMake(HalVtx(HalPrv(HalPrv(HalPrv(HalPrv(he)))))) = MSD_ROUND_V_FASE2;
00335 EdgFgMake(HalEdg(HalPrv(HalPrv(HalPrv(HalPrv(he)))))) = MSD_ROUND_E_FASE2;
00336 MSD_lowMEF(HalPrv(HalPrv(HalPrv(HalPrv(he)))), he, ++maxf);
00337 EdgFgMake(HalEdg(HalPrv(he))) = MSD_ROUND_E_FASE2;
00338 break;
00339 }
00340 }
00341 he = HalNxt(he);
00342 } while (he != heloop);
00343 }
00344 }
00345 }
00346 return(TRUE);
00347 }
00348
00349
00350
00351 void MakeEdgeFlatCorner(SPTYPE s, HPTYPE he)
00352 {
00353 vector n, p1, p2, pm, vaux, vmhe;
00354 HPTYPE prev = HalPrv(he);
00355 HPTYPE mateh = mate(he);
00356 EPTYPE edge = HalEdg(he);
00357 EPTYPE edgp = HalEdg(prev);
00358
00359 printf("MakeEdgeFlatCorner\n");
00360 maxv = MSD_getMaxVertexId(s);
00361 veccopy(n, FacFeq(LooLFace(HalWLoop(he))));
00362 veccopy(vaux, VerVCoord(HalVtx(he)));
00363 veccopy(vmhe, VerVCoord(HalVtx(mateh)));
00364 if (EdgFgMake(edge) < 2)
00365 {
00366 if ((EdgFgRound(edge) != 1) && (EdgFgRound(edgp) == 1))
00367 {
00368 point_perp(vaux, vmhe, pm, n, HalR(he));
00369 MSD_lowMEV(he, he, ++maxv, pm[0], pm[1], pm[2]);
00370 prev = HalPrv(he);
00371 edgp = HalEdg(prev);
00372 VerFgMake(HalVtx(prev)) = MSD_ROUND_V_FASE2;
00373 EdgFgMake(edgp) = MSD_ROUND_E_FASE2;
00374 EdgFgRound(edgp) = 1;
00375 }
00376
00377 if ((EdgFgRound(edgp) != 1) && (EdgFgRound(edge) == 1))
00378 {
00379 point_perp(vaux, vmhe, pm, n, HalR(mate(prev)));
00380 MSD_lowMEV(he, he, ++maxv, pm[0], pm[1], pm[2]);
00381 prev = HalPrv(he);
00382 edgp = HalEdg(prev);
00383 VerFgMake(HalVtx(prev)) = MSD_ROUND_V_FASE2;
00384 EdgFgMake(edgp) = MSD_ROUND_E_FASE2;
00385 EdgFgRound(edgp) = 1;
00386 }
00387
00388 if ((EdgFgRound(edge) != 1) && (EdgFgRound(edgp) != 1))
00389 {
00390 point_perp(vaux, vmhe, p1, n, HalR(he));
00391 point_perp(vaux, vmhe, p2, n, HalR(mate(prev)));
00392 vecplus(pm, p1, p2);
00393 vecesc(pm, pm, 0.5);
00394 MSD_lowMEV(he, he, ++maxv, pm[0], pm[1], pm[2]);
00395 prev = HalPrv(he);
00396 edgp = HalEdg(prev);
00397 VerFgMake(HalVtx(prev)) = MSD_ROUND_V_FASE2;
00398 EdgFgMake(edgp) = MSD_ROUND_E_FASE2;
00399 EdgFgRound(edgp) = 1;
00400 }
00401 }
00402 }
00403
00404 void MakeEdgeConcaveCorner(SPTYPE s, HPTYPE he)
00405 {
00406 vector n, p1, p2, p3, p4, p_inter, p_nxt, p_prv, vaux;
00407
00408 printf("MakeEdgeConcaveCorner\n");
00409 maxv = MSD_getMaxVertexId(s);
00410 if (EdgFgMake(HalEdg(he)) < 2)
00411 {
00412 if ((EdgFgRound(HalEdg(he)) != 1) && (EdgFgRound(HalEdg(HalPrv(he))) != 1))
00413 {
00414 if (VerFgRound(HalVtx(he)) == 1)
00415 {
00416 #ifdef __TRACE_ROUND__
00417 printf("v=(%.0f,%.0f,%.0f) he.r=%f mate.r=%f\n",
00418 VerVCoord(HalVtx(he))[0],
00419 VerVCoord(HalVtx(he))[1],
00420 VerVCoord(HalVtx(he))[2],
00421 HalR(he), HalR(mate(HalPrv(he))));
00422 #endif
00423 GetNxtVertex(he, p_nxt);
00424 GetPrvVertex(he, p_prv);
00425 veccopy(n, FacFeq(LooLFace(HalWLoop(he))));
00426 veccopy(vaux, VerVCoord(HalVtx(he)));
00427 point_perp(vaux, VerVCoord(HalVtx(mate(he))), p1, n, HalR(he));
00428 veccopy(n, FacFeq(LooLFace(HalWLoop(he))));
00429 vecesc(n, n, -1);
00430 veccopy(vaux, VerVCoord(HalVtx(he)));
00431 point_perp(vaux, VerVCoord(HalVtx(HalPrv(he))), p2, n,
00432 HalR(mate(HalPrv(he))));
00433 #ifdef __TRACE_ROUND__
00434 printf("p1=(%.1f,%.1f,%.1f)\n", p1 [0], p1 [1], p1 [2]);
00435 printf("pnxt=(%.1f,%.1f,%.1f)\n", p_nxt[0], p_nxt[1], p_nxt[2]);
00436 printf("p2=(%.1f,%.1f,%.1f)\n", p2 [0], p2 [1], p2 [2]);
00437 printf("pprv=(%.1f,%.1f,%.1f)\n", p_prv[0], p_prv[1], p_prv[2]);
00438 #endif
00439
00440 line_inter(p1, p_nxt, p2, p_prv, p_inter);
00441
00442 #ifdef __TRACE_ROUND__
00443 printf("pinter=(%.1f,%.1f,%.1f)\n", p_inter[0],
00444 p_inter[1],
00445 p_inter[2]);
00446 #endif
00447
00448 MSD_lowMEV(he, he, ++maxv, p_inter[0], p_inter[1], p_inter[2]);
00449 VerFgMake(HalVtx(HalPrv(he))) = MSD_ROUND_V_FASE2;
00450 EdgFgMake(HalEdg(HalPrv(he))) = 3;
00451 }
00452 else
00453 {
00454 veccopy(n, FacFeq(LooLFace(HalWLoop(he))));
00455 veccopy(vaux, VerVCoord(HalVtx(he)));
00456 line_parallel(vaux, VerVCoord(HalVtx(mate(he))), p1, p2, n, HalR(he));
00457 line_parallel(VerVCoord(HalVtx(HalPrv(he))), vaux, p3, p4, n,
00458 HalR(mate(HalPrv(he))));
00459 line_inter(p1, p2, p3, p4, p_inter);
00460 MSD_lowMEV(he, he, ++maxv, p_inter[0], p_inter[1], p_inter[2]);
00461 VerFgMake(HalVtx(HalPrv(he))) = MSD_ROUND_V_FASE2;
00462 EdgFgMake(HalEdg(HalPrv(he))) = 3;
00463 }
00464 }
00465 else
00466 {
00467 if ((EdgFgRound(HalEdg(he)) != 1) && (EdgFgRound(HalEdg(HalPrv(he))) == 1))
00468 {
00469 GetNxtVertex(he, p_nxt);
00470 veccopy(n, FacFeq(LooLFace(HalWLoop(he))));
00471 veccopy(vaux, VerVCoord(HalVtx(he)));
00472 point_perp(vaux, VerVCoord(HalVtx(mate(he))), p1, n, HalR(he));
00473 line_inter(p_nxt, p1, vaux, VerVCoord(HalVtx(HalPrv(he))), p_inter);
00474 MSD_lowMEV(he, he, ++maxv, p_inter[0], p_inter[1], p_inter[2]);
00475 VerFgMake(HalVtx(HalPrv(he))) = MSD_ROUND_V_FASE2;
00476 EdgFgMake(HalEdg(HalPrv(he))) = 3;
00477 }
00478 if ((EdgFgRound(HalEdg(he)) == 1) && (EdgFgRound(HalEdg(HalPrv(he))) != 1))
00479 {
00480 GetPrvVertex(he, p_prv);
00481 veccopy(n, FacFeq(LooLFace(HalWLoop(he))));
00482 veccopy(vaux, VerVCoord(HalVtx(he)));
00483 point_perp(vaux, VerVCoord(HalVtx(HalPrv(he))), p1, n,
00484 HalR(mate(HalPrv(he))));
00485 line_inter(p1, p_prv, vaux, VerVCoord(HalVtx(mate(he))), p_inter);
00486 MSD_lowMEV(he, he, ++maxv, p_inter[0], p_inter[1], p_inter[2]);
00487 VerFgMake(HalVtx(HalPrv(he))) = MSD_ROUND_V_FASE2;
00488 EdgFgMake(HalEdg(HalPrv(he))) = 3;
00489 }
00490 }
00491 }
00492 }
00493
00494 HPTYPE MakeEdgeConvexCorner(SPTYPE s, HPTYPE he)
00495 {
00496 vector n, p, p_nxt, p_prv, p1, p2, p3, p4, vaux, normal, vhe, vme, vpe;
00497 real r1, r2, r3;
00498 HPTYPE mhe;
00499 HPTYPE phe;
00500
00501 maxv = MSD_getMaxVertexId(s);
00502 maxf = MSD_getMaxFaceId(s);
00503
00504 if ((EdgFgRound(HalEdg(he)) != 1) &&
00505 (EdgFgRound(HalEdg(HalPrv(he))) != 1) && (VerFgMake(HalVtx(he)) == 0))
00506 {
00507 r1 = HalR(he);
00508 r2 = HalR(mate(HalPrv(he)));
00509
00510
00511 if (EdgFgMake(HalEdg(HalNxt(mate(he)))) != 3)
00512 {
00513 r3 = HalR(HalNxt(mate(he)));
00514 }
00515 else
00516 {
00517 r3 = HalR(HalNxt(mate(HalNxt(mate(he)))));
00518 }
00519 printf("MakeEdgeConvexCorner r1 = %10.4f r2 = %10.4f r3 = %10.4f\n", r1, r2, r3);
00520
00521 if ((r3 > r1) && (r3 > r2) && (VerFgRound(HalVtx(he)) == 0))
00522 {
00523 veccopy(n, FacFeq(LooLFace(HalWLoop(he))));
00524 veccopy(vaux, VerVCoord(HalVtx(he)));
00525 line_parallel(vaux, VerVCoord(HalVtx(mate(he))), p1, p2, n, HalR(he));
00526 veccopy(vaux, VerVCoord(HalVtx(HalPrv(he))));
00527 line_parallel(vaux, VerVCoord(HalVtx(mate(HalPrv(he)))), p3, p4, n,
00528 HalR(mate(HalPrv(he))));
00529 line_inter(p1, p2, p3, p4, p);
00530 MSD_lowMEV(he, he, ++maxv, p[0], p[1], p[2]);
00531 VerFgMake(HalVtx(HalPrv(he))) = MSD_ROUND_V_FASE2;
00532 EdgFgMake(HalEdg(HalPrv(he))) = 3;
00533 EdgFgRound(HalEdg(HalPrv(he))) = EdgFgRound(HalEdg(he));
00534 }
00535
00536 if (((comp(r3, r1, EPS) != 1) && (comp(r3, r2, EPS) != 1)) || (VerFgRound(HalVtx(he)) == 1))
00537 {
00538 if (VerFgRound(HalVtx(he)) == 1)
00539 {
00540 printf("d");
00541 GetNxtVertex(he, p_nxt);
00542 GetPrvVertex(he, p_prv);
00543 veccopy(vaux, VerVCoord(HalVtx(HalPrv(he))));
00544 line_inter(vaux, p_nxt, VerVCoord(HalVtx(mate(he))), p_prv, p);
00545
00546 if (vecequal(p, VerVCoord(HalVtx(HalPrv(HalPrv(he))))) == 0)
00547 {
00548 printf("e");
00549 MSD_lowMEV(HalPrv(he), HalPrv(he), ++maxv, p[0], p[1], p[2]);
00550 VerFgMake(HalVtx(HalPrv(HalPrv(he)))) = MSD_ROUND_V_FASE2;
00551 EdgFgMake(HalEdg(HalPrv(HalPrv(he)))) = MSD_ROUND_E_FASE2;
00552 MSD_lowMEF(HalPrv(HalPrv(he)), HalNxt(he), ++maxf);
00553 EdgFgRound(HalEdg(HalNxt(he))) = MSD_ROUND_E_FASE2;
00554 }
00555 else
00556 if (vecequal(p, VerVCoord(HalVtx(HalNxt(HalNxt(he))))) == 0)
00557 {
00558 MSD_lowMEF(HalPrv(HalPrv(he)), HalNxt(he), ++maxf);
00559 EdgFgMake(HalEdg(HalNxt(he))) = MSD_ROUND_E_FASE2;
00560 }
00561 }
00562 else
00563 {
00564 printf("r");
00565 mhe = mate(he);
00566 phe = HalPrv(he);
00567 veccopy(normal, FacFeq(LooLFace(HalWLoop(he))));
00568 veccopy(vhe, VerVCoord(HalVtx(he)));
00569 veccopy(vme, VerVCoord(HalVtx(mhe)));
00570 veccopy(vpe, VerVCoord(HalVtx(phe)));
00571 line_parallel(vhe, vme, p1, p2, normal, r1);
00572 line_parallel(vpe, vhe, p3, p4, normal, r2);
00573 line_inter(p1, p2, p3, p4, p);
00574 if (vecequal(p, VerVCoord(HalVtx(HalPrv(phe)))) == 0)
00575 {
00576 printf("f");
00577 MSD_lowMEV(phe, phe, ++maxv, p[0], p[1], p[2]);
00578 phe = HalPrv(phe);
00579 VerFgMake(HalVtx(phe)) = MSD_ROUND_V_FASE2;
00580 EdgFgMake(HalEdg(phe)) = MSD_ROUND_E_FASE2;
00581 MSD_lowMEF(phe, HalNxt(he), ++maxf);
00582 EdgFgMake(HalEdg(HalNxt(he))) = MSD_ROUND_E_FASE2;
00583 printf("e");
00584 return(HalNxt(he));
00585 }
00586 else
00587 if (vecequal(p, VerVCoord(HalVtx(HalNxt(HalNxt(he))))) == 0)
00588 {
00589 MSD_lowMEF(HalPrv(HalPrv(he)), HalNxt(he), ++maxf);
00590 EdgFgMake(HalEdg(HalNxt(he))) = MSD_ROUND_E_FASE2;
00591 }
00592 }
00593 }
00594
00595 if ((comp(r2, r3, EPS) == -1) && (comp(r3, r1, EPS) != 1) &&
00596 (VerFgRound(HalVtx(he)) == 0))
00597 {
00598 veccopy(vaux, VerVCoord(HalVtx(he)));
00599 point_perp(VerVCoord(HalVtx(HalPrv(he))), vaux, p,
00600 FacFeq(LooLFace(HalWLoop(he))), HalR(mate(HalPrv(he))));
00601 MSD_lowMEV(HalPrv(he), HalPrv(he), ++maxv, p[0], p[1], p[2]);
00602 VerFgMake(HalVtx(HalPrv(HalPrv(he)))) = MSD_ROUND_V_FASE2;
00603 EdgFgMake(HalEdg(HalPrv(HalPrv(he)))) = MSD_ROUND_E_FASE2;
00604 }
00605
00606 if ((comp(r1, r3, EPS) == -1) && (comp(r3, r2, EPS) != 1) &&
00607 (VerFgRound(HalVtx(he)) == 0))
00608 {
00609 veccopy(vaux, VerVCoord(HalVtx(HalNxt(he))));
00610 point_perp(vaux, VerVCoord(HalVtx(mate(HalNxt(he)))), p,
00611 FacFeq(LooLFace(HalWLoop(he))), HalR(he));
00612 MSD_lowMEV(HalNxt(he), HalNxt(he), ++maxv, p[0], p[1], p[2]);
00613 VerFgMake(HalVtx(HalNxt(HalNxt(he)))) = MSD_ROUND_V_FASE2;
00614 EdgFgMake(HalEdg(HalNxt(he))) = MSD_ROUND_E_FASE2;
00615 }
00616 }
00617 return(he);
00618 }
00619
00620 void GetNxtVertex(HPTYPE he, vector p)
00621 {
00622 HPTYPE heaux;
00623 real th;
00624 int flag = 1;
00625 vector n, vaux;
00626
00627 heaux = he;
00628 do
00629 {
00630 printf("n");
00631 heaux = HalNxt(heaux);
00632 if (VerFgMake(HalVtx(heaux)) == MSD_ROUND_V_FASE2)
00633 {
00634 veccopy(p, VerVCoord(HalVtx(heaux)));
00635 flag = 0;
00636 }
00637 if (VerFgMake(HalVtx(heaux)) == MSD_ROUND_V_ORIGINAL)
00638 {
00639 th = angle_edge(heaux);
00640 if (comp(th, PI, EPS) == 0)
00641 {
00642 if ((EdgFgRound(HalEdg(HalPrv(heaux))) != 1) &&
00643 (EdgFgRound(HalEdg(heaux)) != 1))
00644 {
00645 veccopy(vaux, VerVCoord(HalVtx(heaux)));
00646 point_perp(vaux, VerVCoord(HalVtx(mate(heaux))), p,
00647 FacFeq(LooLFace(HalWLoop(heaux))),
00648 (HalR(heaux) + HalR(mate(HalPrv(heaux)))) * 0.5);
00649 flag = 0;
00650 }
00651 if (EdgFgRound(HalEdg(HalPrv(heaux))) == 1)
00652 {
00653 veccopy(vaux, VerVCoord(HalVtx(heaux)));
00654 point_perp(vaux, VerVCoord(HalVtx(mate(heaux))), p,
00655 FacFeq(LooLFace(HalWLoop(heaux))), HalR(heaux));
00656 flag = 0;
00657 }
00658 if (EdgFgRound(HalEdg(heaux)) == 1)
00659 {
00660 veccopy(vaux, VerVCoord(HalVtx(heaux)));
00661 point_perp(vaux, VerVCoord(HalVtx(mate(heaux))), p,
00662 FacFeq(LooLFace(HalWLoop(heaux))),
00663 HalR(mate(HalPrv(heaux))));
00664 flag = 0;
00665 }
00666 }
00667 if (comp(th, PI, EPS) == 1)
00668 {
00669 veccopy(n, FacFeq(LooLFace(HalWLoop(heaux))));
00670 vecesc(n, n, -1);
00671 veccopy(vaux, VerVCoord(HalVtx(heaux)));
00672 point_perp(vaux, VerVCoord(HalVtx(HalPrv(heaux))), p, n,
00673 HalR(mate(HalPrv(heaux))));
00674 flag = 0;
00675 }
00676 if (comp(th, PI, EPS) == -1)
00677 {
00678 veccopy(p, VerVCoord(HalVtx(HalNxt(heaux))));
00679 flag = 0;
00680 }
00681 }
00682 } while (flag == 1 && heaux != he);
00683 }
00684
00685 void GetPrvVertex(HPTYPE he, vector p)
00686 {
00687 HPTYPE heaux;
00688 real th;
00689 int flag = 1;
00690 vector n, vaux;
00691
00692 heaux = he;
00693 do
00694 {
00695 printf("p");
00696 heaux = HalPrv(heaux);
00697 if (VerFgMake(HalVtx(heaux)) == MSD_ROUND_V_FASE2)
00698 {
00699 veccopy(p, VerVCoord(HalVtx(heaux)));
00700 flag = 0;
00701 }
00702 if (VerFgMake(HalVtx(heaux)) == MSD_ROUND_V_ORIGINAL)
00703 {
00704 th = angle_edge(heaux);
00705 if (comp(th, PI, EPS) == 0)
00706 {
00707 if ((EdgFgRound(HalEdg(HalPrv(heaux))) != 1) &&
00708 (EdgFgRound(HalEdg(heaux)) != 1))
00709 {
00710 veccopy(vaux, VerVCoord(HalVtx(heaux)));
00711 point_perp(vaux, VerVCoord(HalVtx(mate(heaux))), p,
00712 FacFeq(LooLFace(HalWLoop(heaux))),
00713 (HalR(heaux) + HalR(mate(HalPrv(heaux)))) * 0.5);
00714 flag = 0;
00715 }
00716 if (EdgFgRound(HalEdg(HalPrv(heaux))) == 1)
00717 {
00718 veccopy(vaux, VerVCoord(HalVtx(heaux)));
00719 point_perp(vaux, VerVCoord(HalVtx(mate(heaux))), p,
00720 FacFeq(LooLFace(HalWLoop(heaux))), HalR(heaux));
00721 flag = 0;
00722 }
00723 if (EdgFgRound(HalEdg(heaux)) == 1)
00724 {
00725 veccopy(vaux, VerVCoord(HalVtx(heaux)));
00726 point_perp(vaux, VerVCoord(HalVtx(mate(heaux))), p,
00727 FacFeq(LooLFace(HalWLoop(heaux))),
00728 HalR(mate(HalPrv(heaux))));
00729 flag = 0;
00730 }
00731 }
00732 if (comp(th, PI, EPS) == 1)
00733 {
00734 veccopy(n, FacFeq(LooLFace(HalWLoop(heaux))));
00735 veccopy(vaux, VerVCoord(HalVtx(heaux)));
00736 point_perp(vaux, VerVCoord(HalVtx(mate(heaux))), p, n, HalR(heaux));
00737 flag = 0;
00738 }
00739 if (comp(th, PI, EPS) == -1)
00740 {
00741 veccopy(p, VerVCoord(HalVtx(HalPrv(heaux))));
00742 flag = 0;
00743 }
00744 }
00745 } while (flag == 1 && heaux != he);
00746 }
00747
00748 int cont_point(VPTYPE v1, VPTYPE v2, vector p)
00749 {
00750 real d12, dp1, dp2;
00751 vector vaux;
00752
00753 veccopy(vaux, VerVCoord(v1));
00754 d12 = vecd(vaux, VerVCoord(v2));
00755 dp1 = vecd(vaux, p);
00756 dp2 = vecd(VerVCoord(v2), p);
00757 if ((dp1 > d12) || (dp2 > d12))
00758 {
00759 return(0);
00760 }
00761 return(1);
00762 }