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 #include "curvgeom.h"
00053
00054 int GeneratingVertices_edges(SPTYPE s)
00055 {
00056 if (MakingEdges_tables(s) == ERROR)
00057 {
00058 return(ERROR);
00059 }
00060 if (MakingVertices_edges(s) == ERROR)
00061 {
00062 return(ERROR);
00063 }
00064 return(SUCCESS);
00065 }
00066
00067 int MakingEdges_tables(SPTYPE s)
00068 {
00069 DPTYPE d;
00070 EPTYPE e;
00071 HPTYPE he1;
00072 HPTYPE he2;
00073 HPTYPE phe1;
00074 HPTYPE phe2;
00075 HPTYPE nhe1;
00076 HPTYPE nhe2;
00077 VPTYPE vhe1;
00078 VPTYPE vhe2;
00079 real t;
00080 vector p, p1, p2, va, vche1, vche2, fche1, fche2;
00081
00082 for (AllShellsSolid(s, d))
00083 {
00084 for (AllEdgesShell(d, e))
00085 {
00086 veccopy(va, VerVCoord(HalVtx(EdgHe1(e))));
00087 vecminus(p, va, VerVCoord(HalVtx(EdgHe2(e))));
00088 EdgD(e) = sqrt(dot(p, p));
00089 }
00090 }
00091
00092 for (AllShellsSolid(s, d))
00093 {
00094 for (AllEdgesShell(d, e))
00095 {
00096 #ifdef __TRACE_ROUND__
00097 printf("e=%d fgp=%d fgn=%d ", EdgEdgeNo(e),
00098 EdgFgRound(HalEdg(HalPrv(EdgHe1(e)))),
00099 EdgFgRound(HalEdg(HalPrv(EdgHe2(e)))));
00100 printf("aprv=%f ", angle_edge(EdgHe1(e)));
00101 printf("anxt=%f ", angle_edge(HalNxt(EdgHe1(e))));
00102 #endif
00103
00104 he1 = EdgHe1(e);
00105 phe1 = HalPrv(he1);
00106 vhe1 = HalVtx(he1);
00107 nhe1 = HalNxt(he1);
00108 he2 = EdgHe2(e);
00109 phe2 = HalPrv(he2);
00110 vhe2 = HalVtx(he2);
00111 nhe2 = HalNxt(he2);
00112 veccopy(vche1, VerVCoord(vhe1));
00113 veccopy(vche2, VerVCoord(vhe2));
00114 veccopy(fche1, FacFeq(LooLFace(HalWLoop(he1))));
00115 veccopy(fche2, FacFeq(LooLFace(HalWLoop(he2))));
00116
00117 if (EdgFgRound(HalEdg(phe1)) > 1)
00118 {
00119 if (comp(angle_edge(he1), PI, EPS) == -1)
00120 {
00121 veccopy(va, VerVCoord(HalVtx(phe1)));
00122 _line(va, HalR(phe1), vche1, HalR(mate(phe1)), p1, p2,
00123 fche1);
00124 line_inter(p1, p2, vche1, vche2, p);
00125 t = calc_t(vche1, vche2, p);
00126
00127 #ifdef __TRACE_ROUND__
00128 printf("t1= %f\n", t);
00129 #endif
00130 if ((t < 0) || (t > 1))
00131 {
00132 printf("Raio incompativel!\n");
00133 return(ERROR);
00134 }
00135 EdgT1(e) = t;
00136 }
00137 else
00138 {
00139 EdgT1(e) = 2;
00140 }
00141 }
00142 else
00143 {
00144 EdgT1(e) = 2;
00145 }
00146
00147 if (EdgFgRound(HalEdg(nhe1)) > 1)
00148 {
00149 if (comp(angle_edge(nhe1), PI, EPS) == -1)
00150 {
00151 veccopy(va, VerVCoord(HalVtx(nhe1)));
00152 _line(va, HalR(nhe1), VerVCoord(HalVtx(mate(nhe1))),
00153 HalR(mate(nhe1)), p1, p2, fche1);
00154 line_inter(p1, p2, vche1, vche2, p);
00155 t = calc_t(VerVCoord(HalVtx(nhe1)), vche1, p);
00156
00157 #ifdef __TRACE_ROUND__
00158 printf("t3= %f\n", t);
00159 #endif
00160 if ((t < 0) || (t > 1))
00161 {
00162 printf("Raio incompativel!\n");
00163 return(ERROR);
00164 }
00165 EdgT3(e) = t;
00166 }
00167 else
00168 {
00169 EdgT3(e) = 3;
00170 }
00171 }
00172 else
00173 {
00174 EdgT3(e) = 3;
00175 }
00176
00177
00178 if (EdgFgRound(HalEdg(phe2)) > 1)
00179 {
00180 if (comp(angle_edge(he2), PI, EPS) == -1)
00181 {
00182 veccopy(va, VerVCoord(HalVtx(phe2)));
00183 _line(va, HalR(phe2), vche2,
00184 HalR(mate(phe2)), p1, p2, fche2);
00185 line_inter(p1, p2, vche2, vche1, p);
00186 t = calc_t(vche2, vche1, p);
00187
00188 #ifdef __TRACE_ROUND__
00189 printf("t4= %f\n", t);
00190 #endif
00191 if ((t < 0) || (t > 1))
00192 {
00193 printf("Raio incompativel!\n");
00194 return(ERROR);
00195 }
00196 EdgT4(e) = t;
00197 }
00198 else
00199 {
00200 EdgT4(e) = 3;
00201 }
00202 }
00203 else
00204 {
00205 EdgT4(e) = 3;
00206 }
00207
00208 if (EdgFgRound(HalEdg(nhe2)) > 1)
00209 {
00210 if (comp(angle_edge(nhe2), PI, EPS) == -1)
00211 {
00212 veccopy(va, VerVCoord(HalVtx(nhe2)));
00213 _line(va, HalR(nhe2),
00214 VerVCoord(HalVtx(mate(nhe2))),
00215 HalR(mate(nhe2)), p1, p2,
00216 fche2);
00217 line_inter(p1, p2, vche2, vche1, p);
00218 t = calc_t(VerVCoord(HalVtx(nhe2)), vche2, p);
00219
00220 #ifdef __TRACE_ROUND__
00221 printf("t2= %f\n", t);
00222 #endif
00223 if ((t < 0) || (t > 1))
00224 {
00225 printf("Raio incompativel!\n");
00226 return(ERROR);
00227 }
00228 EdgT2(e) = t;
00229 }
00230 else
00231 {
00232 EdgT2(e) = 2;
00233 }
00234 }
00235 else
00236 {
00237 EdgT2(e) = 2;
00238 }
00239
00240 #ifdef __TRACE_ROUND__
00241 printf("e= %d, t1= %f, t2= %f, t3= %f, t4= %f\n\n", EdgEdgeNo(e),
00242 EdgT1(e),
00243 EdgT2(e),
00244 EdgT3(e),
00245 EdgT4(e));
00246 #endif
00247 }
00248 }
00249 return(SUCCESS);
00250 }
00251
00252 int MakingVertices_edges(SPTYPE s)
00253 {
00254 DPTYPE d;
00255 EPTYPE e;
00256 vector p, va;
00257 int flag;
00258 real t;
00259
00260 for (AllShellsSolid(s, d))
00261 {
00262 for (AllEdgesShell(d, e))
00263 {
00264 flag = 0;
00265 if (EdgFgMake(e) == 0)
00266 {
00267 if (((EdgT1(e) > fabs(1 - EdgT3(e))) && (EdgT1(e) != 2)) ||
00268 ((EdgT1(e) > fabs(1 - EdgT4(e))) && (EdgT1(e) != 2)) ||
00269 ((EdgT2(e) > fabs(1 - EdgT3(e))) && (EdgT2(e) != 2)) ||
00270 ((EdgT2(e) > fabs(1 - EdgT4(e))) && (EdgT2(e) != 2)))
00271 {
00272 printf("Parametros Incompativeis!\n");
00273 return(ERROR);
00274 }
00275 if ((EdgFgRound(HalEdg(HalNxt(EdgHe1(e)))) == MSD_ROUND_FLAG_E0) &&
00276 (comp(angle_edge(HalNxt(EdgHe1(e))), PI, EPS) == -1))
00277 {
00278 t = 0.5;
00279 HalR(EdgHe1(e)) = 0;
00280 HalR(EdgHe2(e)) = 0;
00281 flag = 1;
00282 }
00283 if ((EdgFgRound(HalEdg(HalPrv(EdgHe1(e)))) == MSD_ROUND_FLAG_E0) &&
00284 (comp(angle_edge(EdgHe1(e)), PI, EPS) == -1))
00285 {
00286 t = 0.5;
00287 HalR(EdgHe1(e)) = 0;
00288 HalR(EdgHe2(e)) = 0;
00289 flag = 1;
00290 }
00291 else
00292 {
00293 if (VerFgRound(HalVtx(EdgHe1(e))) == MSD_ROUND_FLAG_V0)
00294 {
00295 if (((comp(EdgT2(e), EdgT1(e), EPS) != -1) ||
00296 (EdgT1(e) == 2)) && (EdgT2(e) > 0) && (EdgT2(e) < 1))
00297 {
00298 t = EdgT2(e);
00299 flag = 1;
00300 }
00301 if (((EdgT1(e) > EdgT2(e)) || (EdgT2(e) == 2)) &&
00302 (EdgT1(e) > 0) && (EdgT1(e) < 1))
00303 {
00304 t = EdgT1(e);
00305 flag = 1;
00306 }
00307 }
00308 else
00309 {
00310 if ((EdgT1(e) > 0) && (EdgT1(e) < 1) &&
00311 (EdgT2(e) > 0) && (EdgT2(e) < 1))
00312 {
00313 t = (EdgT1(e) + EdgT2(e)) * 0.5;
00314 flag = 1;
00315 }
00316 if ((EdgT1(e) == 2) && (EdgT2(e) > 0) && (EdgT2(e) < 1))
00317 {
00318 t = EdgT2(e);
00319 flag = 1;
00320 }
00321 if ((EdgT2(e) == 2) && (EdgT1(e) > 0) && (EdgT1(e) < 1))
00322 {
00323 t = EdgT1(e);
00324 flag = 1;
00325 }
00326 }
00327 }
00328 if (flag == 1)
00329 {
00330 veczer(p);
00331
00332 #ifdef __TRACE_ROUND__
00333
00334 #endif
00335
00336 veccopy(va, VerVCoord(HalVtx(EdgHe2(e))));
00337 vecminus(p, va, VerVCoord(HalVtx(EdgHe1(e))));
00338 normalize(p);
00339 vecesc(p, p, EdgD(e) * t);
00340 vecplus(p, p, VerVCoord(HalVtx(EdgHe1(e))));
00341 maxv = MSD_getMaxVertexId(s);
00342 if (vecequal(p, VerVCoord(HalVtx(HalNxt(EdgHe1(e))))) == 0)
00343 {
00344 MSD_lowMEV(EdgHe1(e), HalNxt(EdgHe2(e)), ++maxv, p[0],
00345 p[1],
00346 p[2]);
00347 #ifdef __TRACE_ROUND__
00348 printf("V1 = ( %f, %f, %f)\n",
00349 VerVCoord(HalVtx(EdgHe1(e)))[0],
00350 VerVCoord(HalVtx(EdgHe1(e)))[1],
00351 VerVCoord(HalVtx(EdgHe1(e)))[2]);
00352 #endif
00353
00354 VerFgMake(HalVtx(EdgHe1(e))) = MSD_ROUND_V_FASE1;
00355 EdgFgMake(HalEdg(HalPrv(EdgHe1(e)))) = MSD_ROUND_E_FASE1;
00356 EdgFgRound(HalEdg(HalPrv(EdgHe1(e)))) = EdgFgRound(e);
00357 HalR(HalPrv(EdgHe1(e))) = HalR(EdgHe1(e));
00358 HalR(HalNxt(EdgHe2(e))) = HalR(EdgHe2(e));
00359 EdgD(HalEdg(HalPrv(EdgHe1(e)))) = EdgD(e);
00360 }
00361 }
00362
00363 flag = 0;
00364 t = 0;
00365 if ((EdgFgRound(HalEdg(HalNxt(EdgHe2(e)))) == MSD_ROUND_FLAG_E0) &&
00366 (comp(angle_edge(HalNxt(EdgHe2(e))), PI, EPS) == -1))
00367 {
00368 t = 0.5;
00369 flag = 1;
00370 }
00371 if ((EdgFgRound(HalEdg(HalPrv(EdgHe2(e)))) == MSD_ROUND_FLAG_E0) &&
00372 (comp(angle_edge(EdgHe2(e)), PI, EPS) == -1))
00373 {
00374 t = 0.5;
00375 flag = 1;
00376 }
00377 else
00378 {
00379 if (VerFgRound(HalVtx(EdgHe2(e))) == MSD_ROUND_FLAG_V0)
00380 {
00381 if (((EdgT3(e) >= EdgT4(e)) || (EdgT4(e) == 3)) &&
00382 (EdgT3(e) > 0) && (EdgT3(e) < 1))
00383 {
00384 t = EdgT3(e);
00385 flag = 1;
00386 }
00387 if (((EdgT4(e) > EdgT3(e)) || (EdgT3(e) == 3)) &&
00388 (EdgT4(e) > 0) && (EdgT4(e) < 1))
00389 {
00390 t = EdgT4(e);
00391 flag = 1;
00392 }
00393 }
00394 else
00395 {
00396 if ((EdgT3(e) > 0) && (EdgT3(e) < 1) &&
00397 (EdgT4(e) > 0) && (EdgT4(e) < 1))
00398 {
00399 t = (EdgT3(e) + EdgT4(e)) * 0.5;
00400 flag = 1;
00401 }
00402 if ((EdgT3(e) == 3) && (EdgT4(e) > 0) && (EdgT4(e) < 1))
00403 {
00404 t = EdgT4(e);
00405 flag = 1;
00406 }
00407 if ((EdgT4(e) == 3) && (EdgT3(e) > 0) && (EdgT3(e) < 1))
00408 {
00409 t = EdgT3(e);
00410 flag = 1;
00411 }
00412 }
00413 }
00414 if (flag == 1)
00415 {
00416 veczer(p);
00417
00418 #ifdef __TRACE_ROUND__
00419 printf("t= %f\n", t);
00420 #endif
00421
00422 veccopy(va, VerVCoord(HalVtx(EdgHe1(e))));
00423 vecminus(p, va, VerVCoord(HalVtx(EdgHe2(e))));
00424 normalize(p);
00425 vecesc(p, p, EdgD(e) * t);
00426 vecplus(p, p, VerVCoord(HalVtx(EdgHe2(e))));
00427 maxv = MSD_getMaxVertexId(s);
00428 if (vecequal(p, VerVCoord(HalVtx(HalNxt(EdgHe2(e))))) == 0)
00429 {
00430 MSD_lowMEV(EdgHe2(e), HalNxt(EdgHe1(e)), ++maxv, p[0],
00431 p[1],
00432 p[2]);
00433
00434 #ifdef __TRACE_ROUND__
00435 printf("V2 = ( %f, %f, %f)\n",
00436 VerVCoord(HalVtx(EdgHe2(e)))[0],
00437 VerVCoord(HalVtx(EdgHe2(e)))[1],
00438 VerVCoord(HalVtx(EdgHe2(e)))[2]);
00439 #endif
00440
00441 VerFgMake(HalVtx(EdgHe2(e))) = MSD_ROUND_V_FASE1;
00442 EdgFgMake(HalEdg(HalPrv(EdgHe2(e)))) = MSD_ROUND_E_FASE1;
00443 EdgFgRound(HalEdg(HalPrv(EdgHe2(e)))) = EdgFgRound(e);
00444 HalR(HalPrv(EdgHe2(e))) = HalR(EdgHe1(e));
00445 HalR(HalNxt(EdgHe1(e))) = HalR(EdgHe2(e));
00446 EdgD(HalEdg(HalPrv(EdgHe2(e)))) = EdgD(e);
00447 }
00448 }
00449 }
00450 }
00451 }
00452
00453 return(SUCCESS);
00454 }