| | 1 | // File: IntPatch_RstInt.cxx |
| | 2 | // Created: Fri May 7 12:45:18 1993 |
| | 3 | // Author: Jacques GOUSSARD |
| | 4 | // Copyright: Matra Datavision 1993 |
| | 5 | |
| | 6 | // ---------------------------------------------------------------------- |
| | 7 | //-- lbr: Modifs importantes du 16-17 Nov 95 |
| | 8 | //-- - Chercher APointOnRstStillExist et OnDifferentRst |
| | 9 | //-- On veut pouvoir creer un Vtx (A1 sur S1, A2 sur S2) |
| | 10 | //-- et le Vtx (A1 sur S1, A2bis sur S2) |
| | 11 | //-- ce qui revient a distinguer un point deja pose sur une |
| | 12 | //-- restriction de S avec un point pose sur une nouvelle |
| | 13 | //-- restriction de S. |
| | 14 | //-- - Pour rester coherent avec cette facon de faire, |
| | 15 | //-- Chercher(Nbvtx++). |
| | 16 | |
| | 17 | #include <IntPatch_RstInt.ixx> |
| | 18 | |
| | 19 | #include <IntSurf.hxx> |
| | 20 | |
| | 21 | #include <TColgp_SequenceOfPnt.hxx> |
| | 22 | #include <TColgp_SequenceOfPnt2d.hxx> |
| | 23 | #include <Intf_SectionPoint.hxx> |
| | 24 | #include <Intf_TangentZone.hxx> |
| | 25 | #include <gp_Pnt2d.hxx> |
| | 26 | #include <Precision.hxx> |
| | 27 | |
| | 28 | #include <Adaptor2d_HCurve2d.hxx> |
| | 29 | #include <IntPatch_PolygoTool.hxx> |
| | 30 | #include <IntPatch_WLine.hxx> |
| | 31 | #include <IntPatch_RLine.hxx> |
| | 32 | #include <IntPatch_HInterTool.hxx> |
| | 33 | #include <IntPatch_SearchPnt.hxx> |
| | 34 | #include <IntPatch_PolyLine.hxx> |
| | 35 | #include <IntPatch_PolyArc.hxx> |
| | 36 | #include <IntPatch_CSFunction.hxx> |
| | 37 | #include <IntPatch_CurvIntSurf.hxx> |
| | 38 | |
| | 39 | |
| | 40 | static void Recadre(GeomAbs_SurfaceType typeS1, |
| | 41 | GeomAbs_SurfaceType typeS2, |
| | 42 | const Handle(IntPatch_WLine)& wlin, |
| | 43 | Standard_Integer Param, |
| | 44 | Standard_Real& U1, |
| | 45 | Standard_Real& V1, |
| | 46 | Standard_Real& U2, |
| | 47 | Standard_Real& V2) |
| | 48 | { |
| | 49 | Standard_Integer nbpnts = wlin->NbPnts(); |
| | 50 | if(Param<1) Param=1; else if(Param>nbpnts) Param=nbpnts; |
| | 51 | Standard_Real U1p,V1p,U2p,V2p; |
| | 52 | |
| | 53 | wlin->Point(Param).Parameters(U1p,V1p,U2p,V2p); |
| | 54 | switch(typeS1) { |
| | 55 | case GeomAbs_Cylinder: |
| | 56 | case GeomAbs_Cone: |
| | 57 | case GeomAbs_Sphere: |
| | 58 | case GeomAbs_Torus: |
| | 59 | while(U1<(U1p-1.5*PI)) U1+=PI+PI; |
| | 60 | while(U1>(U1p+1.5*PI)) U1-=PI+PI; |
| | 61 | break; |
| | 62 | default: |
| | 63 | break; |
| | 64 | } |
| | 65 | if(typeS1==GeomAbs_Torus) { |
| | 66 | while(V1<(V1p-1.5*PI)) V1+=PI+PI; |
| | 67 | while(V1>(V1p+1.5*PI)) V1-=PI+PI; |
| | 68 | } |
| | 69 | |
| | 70 | switch(typeS2) { |
| | 71 | case GeomAbs_Cylinder: |
| | 72 | case GeomAbs_Cone: |
| | 73 | case GeomAbs_Sphere: |
| | 74 | case GeomAbs_Torus: |
| | 75 | while(U2<(U2p-1.5*PI)) U2+=PI+PI; |
| | 76 | while(U2>(U2p+1.5*PI)) U2-=PI+PI; |
| | 77 | break; |
| | 78 | default: |
| | 79 | break; |
| | 80 | } |
| | 81 | if(typeS2==GeomAbs_Torus) { |
| | 82 | while(V2<(V1p-1.5*PI)) V2+=PI+PI; |
| | 83 | while(V2>(V2p+1.5*PI)) V2-=PI+PI; |
| | 84 | } |
| | 85 | } |
| | 86 | |
| | 87 | const Standard_Real Confusion = Precision::Confusion(); |
| | 88 | |
| | 89 | inline Standard_Real Tol3d (const Handle(Adaptor3d_HVertex)& vtx, |
| | 90 | const Handle(Adaptor3d_TopolTool)& Domain, |
| | 91 | const Standard_Real tolDef = 0.) |
| | 92 | { |
| | 93 | return (Domain->Has3d() ? Domain->Tol3d(vtx) |
| | 94 | : tolDef < Confusion ? Confusion |
| | 95 | : tolDef); |
| | 96 | } |
| | 97 | |
| | 98 | inline Standard_Real Tol3d (const Handle(Adaptor2d_HCurve2d)& arc, |
| | 99 | const Handle(Adaptor3d_TopolTool)& Domain, |
| | 100 | const Standard_Real tolDef = 0.) |
| | 101 | { |
| | 102 | return (Domain->Has3d() ? Domain->Tol3d(arc) |
| | 103 | : tolDef < Confusion ? Confusion |
| | 104 | : tolDef); |
| | 105 | } |
| | 106 | |
| | 107 | static Standard_Boolean CoincideOnArc(const gp_Pnt& Ptsommet, |
| | 108 | const Handle(Adaptor2d_HCurve2d)& A, |
| | 109 | const Handle(Adaptor3d_HSurface)& Surf, |
| | 110 | const Standard_Real Toler, |
| | 111 | const Handle(Adaptor3d_TopolTool)& Domain, |
| | 112 | Handle(Adaptor3d_HVertex)& Vtx) |
| | 113 | { |
| | 114 | Standard_Real distmin = RealLast(); |
| | 115 | Standard_Real tolarc = Max(Toler,Tol3d(A,Domain)); |
| | 116 | |
| | 117 | Domain->Initialize(A); |
| | 118 | Domain->InitVertexIterator(); |
| | 119 | while (Domain->MoreVertex()) { |
| | 120 | Handle(Adaptor3d_HVertex) vtx1 = Domain->Vertex(); |
| | 121 | Standard_Real prm = IntPatch_HInterTool::Parameter(vtx1,A); |
| | 122 | gp_Pnt2d p2d = A->Value(prm); |
| | 123 | gp_Pnt point = Surf->Value(p2d.X(),p2d.Y()); |
| | 124 | const Standard_Real dist = point.Distance(Ptsommet); |
| | 125 | Standard_Real tol = Max (tolarc, Tol3d(vtx1,Domain)); |
| | 126 | |
| | 127 | if (dist <= tol && dist <= distmin) { // the best coincidence |
| | 128 | distmin = dist; |
| | 129 | Vtx = vtx1; |
| | 130 | } |
| | 131 | Domain->NextVertex(); |
| | 132 | } |
| | 133 | return distmin < RealLast(); |
| | 134 | } |
| | 135 | |
| | 136 | |
| | 137 | static void VerifyTgline(const Handle(IntPatch_WLine)& wlin, |
| | 138 | const Standard_Integer param, |
| | 139 | const Standard_Real Tol, |
| | 140 | gp_Vec& Tgl) { |
| | 141 | |
| | 142 | if( Abs(Tgl.X())<Tol |
| | 143 | && Abs(Tgl.Y())<Tol |
| | 144 | && Abs(Tgl.Z())<Tol) { |
| | 145 | //-- On construit une tangente plus grande |
| | 146 | //-- (Eviter des points tres proches ds Walking) |
| | 147 | Standard_Integer i, n, nbpt=wlin->NbPnts(); |
| | 148 | Standard_Boolean forward = (nbpt-param) >= (param-1); |
| | 149 | for (n = 2; n > 0; n--, forward = !forward) { |
| | 150 | if (forward) { |
| | 151 | for(i=param+1; i<=nbpt; i++) { |
| | 152 | gp_Vec T(wlin->Point(param).Value(),wlin->Point(i).Value()); |
| | 153 | if( Abs(T.X())>=Tol |
| | 154 | || Abs(T.Y())>=Tol |
| | 155 | || Abs(T.Z())>=Tol) { |
| | 156 | Tgl = T ; |
| | 157 | return; |
| | 158 | } |
| | 159 | } |
| | 160 | } |
| | 161 | else { |
| | 162 | for(i=param-1; i>=1; i--) { |
| | 163 | gp_Vec T(wlin->Point(i).Value(),wlin->Point(param).Value()); |
| | 164 | if( Abs(T.X())>=Tol |
| | 165 | || Abs(T.Y())>=Tol |
| | 166 | || Abs(T.Z())>=Tol) { |
| | 167 | Tgl = T ; |
| | 168 | return; |
| | 169 | } |
| | 170 | } |
| | 171 | } |
| | 172 | } |
| | 173 | } |
| | 174 | } |
| | 175 | |
| | 176 | static void GetLinePoint2d (const Handle(IntPatch_Line)& L, |
| | 177 | const Standard_Real param, |
| | 178 | const Standard_Boolean OnFirst, |
| | 179 | Standard_Real& U, Standard_Real& V) |
| | 180 | { |
| | 181 | IntPatch_IType typL = L->ArcType(); |
| | 182 | const Handle(IntPatch_WLine)& wlin = (const Handle(IntPatch_WLine)&)L; |
| | 183 | const Handle(IntPatch_RLine)& rlin = (const Handle(IntPatch_RLine)&)L; |
| | 184 | Standard_Integer Nbptlin = (typL == IntPatch_Walking |
| | 185 | ? wlin->NbPnts() |
| | 186 | : rlin->NbPnts()); |
| | 187 | |
| | 188 | Standard_Real par = IntegerPart(param); |
| | 189 | Standard_Integer Irang = Standard_Integer(par); |
| | 190 | if (Irang == Nbptlin) { |
| | 191 | Irang--; |
| | 192 | par = 1.0; |
| | 193 | } |
| | 194 | else |
| | 195 | par = Abs(param-par); |
| | 196 | |
| | 197 | Standard_Real us1,vs1,us2,vs2; |
| | 198 | if (typL == IntPatch_Walking) { |
| | 199 | if (OnFirst) { |
| | 200 | wlin->Point(Irang).ParametersOnS1(us1,vs1); |
| | 201 | wlin->Point(Irang+1).ParametersOnS1(us2,vs2); |
| | 202 | } |
| | 203 | else { |
| | 204 | wlin->Point(Irang).ParametersOnS2(us1,vs1); |
| | 205 | wlin->Point(Irang+1).ParametersOnS2(us2,vs2); |
| | 206 | } |
| | 207 | } |
| | 208 | else { |
| | 209 | if (OnFirst) { |
| | 210 | rlin->Point(Irang).ParametersOnS1(us1,vs1); |
| | 211 | rlin->Point(Irang+1).ParametersOnS1(us2,vs2); |
| | 212 | } |
| | 213 | else { |
| | 214 | rlin->Point(Irang).ParametersOnS2(us1,vs1); |
| | 215 | rlin->Point(Irang+1).ParametersOnS2(us2,vs2); |
| | 216 | } |
| | 217 | } |
| | 218 | |
| | 219 | U = (1.-par)*us1+par*us2; |
| | 220 | V = (1.-par)*vs1+par*vs2; |
| | 221 | } |
| | 222 | |
| | 223 | static void GetWLinePoint (const Handle(IntPatch_WLine)& wlin, |
| | 224 | const Standard_Real param, |
| | 225 | Standard_Real& U1, Standard_Real& V1, |
| | 226 | Standard_Real& U2, Standard_Real& V2, |
| | 227 | gp_Pnt& P) |
| | 228 | { |
| | 229 | Standard_Integer Nbptlin = wlin->NbPnts(); |
| | 230 | Standard_Real par = IntegerPart(param); |
| | 231 | Standard_Integer Irang = Standard_Integer(par); |
| | 232 | if (Irang == Nbptlin) { |
| | 233 | Irang--; |
| | 234 | par = 1.0; |
| | 235 | } |
| | 236 | else |
| | 237 | par = Abs(param-par); |
| | 238 | |
| | 239 | const IntSurf_PntOn2S& p2s1 = wlin->Point(Irang); |
| | 240 | const IntSurf_PntOn2S& p2s2 = wlin->Point(Irang+1); |
| | 241 | const gp_Pnt& p1 = p2s1.Value(); |
| | 242 | const gp_Pnt& p2 = p2s2.Value(); |
| | 243 | P.ChangeCoord().SetLinearForm(1.-par, p1.XYZ(), par, p2.XYZ()); |
| | 244 | |
| | 245 | Standard_Real us1,vs1,us2,vs2; |
| | 246 | p2s1.ParametersOnS1(us1,vs1); |
| | 247 | p2s2.ParametersOnS1(us2,vs2); |
| | 248 | U1 = (1.-par)*us1+par*us2; |
| | 249 | V1 = (1.-par)*vs1+par*vs2; |
| | 250 | |
| | 251 | p2s1.ParametersOnS2(us1,vs1); |
| | 252 | p2s2.ParametersOnS2(us2,vs2); |
| | 253 | U2 = (1.-par)*us1+par*us2; |
| | 254 | V2 = (1.-par)*vs1+par*vs2; |
| | 255 | } |
| | 256 | |
| | 257 | static Standard_Boolean FindParameter(const Handle(IntPatch_Line)& L, |
| | 258 | const Handle(Adaptor3d_HSurface)& OtherSurf, |
| | 259 | const Standard_Real Tol, |
| | 260 | const gp_Pnt& Ptsom, |
| | 261 | const gp_Pnt2d& Ptsom2d, |
| | 262 | Standard_Real& Param, |
| | 263 | gp_Vec& Tgl, |
| | 264 | const Standard_Integer ParamApproche, |
| | 265 | const Standard_Boolean OnFirst) |
| | 266 | |
| | 267 | { |
| | 268 | // MSV 28.03.2002: find parameter on WLine in 2d space |
| | 269 | |
| | 270 | //Si la ligne est de type restriction, c est qu on provient necessairement |
| | 271 | // du cas implicite/parametree, et que la ligne est restriction de |
| | 272 | // la surface bi-parametree. Cette surface bi-parametree est necessairement |
| | 273 | // passee en argument a PutVertexOnline dans la variable OtherSurf. |
| | 274 | |
| | 275 | // Dans le cas d une ligne de cheminement, il faudrait voir la projection |
| | 276 | // et le calcul de la tangente. |
| | 277 | |
| | 278 | const Handle(IntPatch_RLine)& rlin = (*((Handle(IntPatch_RLine)*)&L)); //-- aucune verification n est |
| | 279 | const Handle(IntPatch_WLine)& wlin = (*((Handle(IntPatch_WLine)*)&L)); //-- faite au cast. |
| | 280 | gp_Pnt ptbid; |
| | 281 | gp_Vec d1u,d1v; |
| | 282 | gp_Pnt2d p2d; |
| | 283 | gp_Vec2d d2d; |
| | 284 | Standard_Real Tol2 = Tol*Tol; |
| | 285 | IntPatch_IType typL = L->ArcType(); |
| | 286 | Tgl.SetCoord(0.0,0.0,0.0); |
| | 287 | |
| | 288 | if ( typL == IntPatch_Restriction) { |
| | 289 | if (!OnFirst && rlin->IsArcOnS1()) { |
| | 290 | IntPatch_HInterTool::Project(rlin->ArcOnS1(),Ptsom2d,Param,p2d); |
| | 291 | rlin->ArcOnS1()->D1(Param,p2d,d2d); |
| | 292 | } |
| | 293 | else if (OnFirst && rlin->IsArcOnS2()) { |
| | 294 | IntPatch_HInterTool::Project(rlin->ArcOnS2(),Ptsom2d,Param,p2d); |
| | 295 | rlin->ArcOnS2()->D1(Param,p2d,d2d); |
| | 296 | } |
| | 297 | else { |
| | 298 | return(Standard_False); |
| | 299 | } |
| | 300 | OtherSurf->D1(p2d.X(),p2d.Y(),ptbid,d1u,d1v); |
| | 301 | if (ptbid.SquareDistance(Ptsom) > Tol2) { |
| | 302 | return Standard_False; |
| | 303 | } |
| | 304 | Tgl.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v); |
| | 305 | return(Standard_True); |
| | 306 | } |
| | 307 | |
| | 308 | else if (typL == IntPatch_Walking) { |
| | 309 | Standard_Integer i, is, nbpt=wlin->NbPnts(); |
| | 310 | Standard_Real norm1,norm2; |
| | 311 | Standard_Integer ParamSearchInf=1; |
| | 312 | Standard_Integer ParamSearchSup=nbpt; |
| | 313 | |
| | 314 | if((ParamApproche-2) > ParamSearchInf) { |
| | 315 | ParamSearchInf = ParamApproche-2; |
| | 316 | } |
| | 317 | if((ParamApproche+2) < ParamSearchSup) { |
| | 318 | ParamSearchSup = ParamApproche+2; |
| | 319 | } |
| | 320 | |
| | 321 | Standard_Integer inf[3],sup[3]; |
| | 322 | // first search inside close bounding around ParamApproche; |
| | 323 | // then search to the nearest end of line; |
| | 324 | // and then search to the farest end of line. |
| | 325 | inf[0] = ParamSearchInf; sup[0] = ParamSearchSup; |
| | 326 | if (ParamSearchInf-1 < nbpt-ParamSearchSup) { |
| | 327 | inf[1] = 1; sup[1] = ParamSearchInf; |
| | 328 | inf[2] = ParamSearchSup; sup[2] = nbpt; |
| | 329 | } |
| | 330 | else { |
| | 331 | inf[1] = ParamSearchSup; sup[1] = nbpt; |
| | 332 | inf[2] = 1; sup[2] = ParamSearchInf; |
| | 333 | } |
| | 334 | |
| | 335 | Standard_Boolean found = Standard_False; |
| | 336 | for (is=0; is < 3 && !found; is++) { |
| | 337 | gp_Vec v1,v2; |
| | 338 | gp_Pnt p1,p2; |
| | 339 | p1 = wlin->Point(inf[is]).Value(); |
| | 340 | v1 = gp_Vec (Ptsom,p1); |
| | 341 | norm1 = v1.SquareMagnitude(); |
| | 342 | Standard_Real normmin = Tol2; |
| | 343 | Standard_Integer ibest = 0; |
| | 344 | if (norm1 <= normmin) { |
| | 345 | normmin = norm1; |
| | 346 | ibest = inf[is]; |
| | 347 | } |
| | 348 | for (i=inf[is]+1; i <= sup[is] && !found; i++) { |
| | 349 | p2 = wlin->Point(i).Value(); |
| | 350 | v2 = gp_Vec (Ptsom,p2); |
| | 351 | norm2 = v2.SquareMagnitude(); |
| | 352 | if (v1.Dot(v2) < 0.) { |
| | 353 | Param = (Standard_Real)(i-1) + 1./(1.+Sqrt(norm2/norm1)); |
| | 354 | Tgl = gp_Vec (p1,p2); |
| | 355 | found = Standard_True; |
| | 356 | } |
| | 357 | else if (norm2 < normmin) { |
| | 358 | normmin = norm2; |
| | 359 | ibest = i; |
| | 360 | } |
| | 361 | v1 = v2; p1 = p2; norm1 = norm2; |
| | 362 | } |
| | 363 | if (!found && ibest) { |
| | 364 | Param = (Standard_Real)ibest; |
| | 365 | found = Standard_True; |
| | 366 | } |
| | 367 | } |
| | 368 | if (found) return Standard_True; |
| | 369 | } |
| | 370 | else { |
| | 371 | Standard_DomainError::Raise(); |
| | 372 | } |
| | 373 | return Standard_False; |
| | 374 | } |
| | 375 | |
| | 376 | inline Standard_Boolean ArePnt2dEqual(const gp_Pnt2d& p1, const gp_Pnt2d& p2, |
| | 377 | const Standard_Real tolU, |
| | 378 | const Standard_Real tolV) |
| | 379 | { |
| | 380 | return Abs(p1.X()-p2.X()) < tolU && Abs(p1.Y()-p2.Y()) < tolV; |
| | 381 | } |
| | 382 | |
| | 383 | static gp_Pnt2d GetPointOnPolygo(const IntPatch_Polygo& Pol, |
| | 384 | const Standard_Real param) |
| | 385 | { |
| | 386 | Standard_Real par = IntegerPart(param); |
| | 387 | Standard_Integer irang = Standard_Integer(par) + 1; |
| | 388 | if (irang == Pol.NbPoints()) { |
| | 389 | irang--; |
| | 390 | par = 1.; |
| | 391 | } |
| | 392 | else { |
| | 393 | par = Abs(param-par); |
| | 394 | } |
| | 395 | gp_Pnt2d p1 = Pol.Point(irang); |
| | 396 | gp_Pnt2d p2 = Pol.Point(irang+1); |
| | 397 | gp_Pnt2d p; |
| | 398 | p.ChangeCoord().SetLinearForm(1.-par,p1.XY(),par,p2.XY()); |
| | 399 | return p; |
| | 400 | } |
| | 401 | |
| | 402 | static Standard_Boolean IsSegment2dSmall(const IntPatch_Polygo& Pol, |
| | 403 | const Standard_Real parmin, |
| | 404 | const Standard_Real parmax, |
| | 405 | const Standard_Real URes, |
| | 406 | const Standard_Real VRes) |
| | 407 | { |
| | 408 | Standard_Integer irang1 = Standard_Integer(IntegerPart(parmin)) + 2; |
| | 409 | Standard_Integer irang2 = Standard_Integer(IntegerPart(parmax)) + 1; |
| | 410 | gp_Pnt2d p1,p2; |
| | 411 | Standard_Real du=0.,dv=0.; |
| | 412 | p1 = GetPointOnPolygo(Pol,parmin); |
| | 413 | for (Standard_Integer i=irang1; i <= irang2 && du <= URes && dv <= VRes; i++) { |
| | 414 | p2 = Pol.Point(i); |
| | 415 | du += Abs(p2.X()-p1.X()); |
| | 416 | dv += Abs(p2.Y()-p1.Y()); |
| | 417 | p1 = p2; |
| | 418 | } |
| | 419 | if (du <= URes && dv <= VRes) { |
| | 420 | p2 = GetPointOnPolygo(Pol,parmax); |
| | 421 | du += Abs(p2.X()-p1.X()); |
| | 422 | dv += Abs(p2.Y()-p1.Y()); |
| | 423 | } |
| | 424 | return du <= URes && dv <= VRes; |
| | 425 | } |
| | 426 | |
| | 427 | //======================================================================= |
| | 428 | //function : PutVertexOnLine |
| | 429 | //purpose : |
| | 430 | //======================================================================= |
| | 431 | |
| | 432 | void IntPatch_RstInt::PutVertexOnLine (Handle(IntPatch_Line)& L, |
| | 433 | const Handle(Adaptor3d_HSurface)& Surf, |
| | 434 | const Handle(Adaptor3d_TopolTool)& Domain, |
| | 435 | const Handle(Adaptor3d_HSurface)& OtherSurf, |
| | 436 | const Standard_Boolean OnFirst, |
| | 437 | const Standard_Real Tol ) |
| | 438 | { |
| | 439 | |
| | 440 | // Domain est le domaine de restriction de la surface Surf. |
| | 441 | // On intersectera un arc de Surf avec la surface OtherSurf. |
| | 442 | // Si OnFirst = True, c est que la surface Surf correspond a la 1ere |
| | 443 | // surface donnee aux algo d intersection. |
| | 444 | |
| | 445 | static IntPatch_SearchPnt Commun; |
| | 446 | |
| | 447 | Standard_Real U,V,W; |
| | 448 | Standard_Real U1,V1,U2,V2; |
| | 449 | Standard_Real paramarc=0.,paramline=0.; |
| | 450 | Standard_Integer i,j,k; |
| | 451 | TColgp_SequenceOfPnt locpt; |
| | 452 | TColgp_SequenceOfPnt2d locpt2; |
| | 453 | const Handle(IntPatch_RLine)& rlin = (*((Handle(IntPatch_RLine)*)&L)); //-- aucune verification n est |
| | 454 | const Handle(IntPatch_WLine)& wlin = (*((Handle(IntPatch_WLine)*)&L)); //-- faite au cast. |
| | 455 | Standard_Integer Nbvtx =0; |
| | 456 | Standard_Integer Nbptlin =0; |
| | 457 | Standard_Real tolPLin = Surf->UResolution(Precision::Confusion()); |
| | 458 | tolPLin = Max (tolPLin, Surf->VResolution(Precision::Confusion())); |
| | 459 | tolPLin = Min (tolPLin, Precision::Confusion()); |
| | 460 | IntPatch_PolyLine PLin(tolPLin); |
| | 461 | |
| | 462 | Standard_Real PFirst,PLast; |
| | 463 | Standard_Integer NbEchant; |
| | 464 | gp_Pnt ptsommet, ptbid; |
| | 465 | gp_Vec tgline, tgrst, d1u, d1v, normsurf; |
| | 466 | |
| | 467 | gp_Pnt2d p2d; |
| | 468 | gp_Vec2d d2d; |
| | 469 | |
| | 470 | IntPatch_Point Sommet, ptline; |
| | 471 | Handle(Adaptor3d_HVertex) vtxarc,vtxline; |
| | 472 | Handle(Adaptor2d_HCurve2d) arc; |
| | 473 | Standard_Boolean VtxOnArc, duplicate, found; |
| | 474 | IntSurf_Transition transarc,transline; |
| | 475 | |
| | 476 | IntPatch_IType typL = L->ArcType(); |
| | 477 | if (typL == IntPatch_Walking) { |
| | 478 | Nbvtx = wlin->NbVertex(); |
| | 479 | PLin.SetWLine(OnFirst,wlin); |
| | 480 | Nbptlin = wlin->NbPnts(); |
| | 481 | } |
| | 482 | else if ( typL == IntPatch_Restriction) { |
| | 483 | Nbvtx = rlin->NbVertex(); |
| | 484 | PLin.SetRLine(OnFirst,rlin); |
| | 485 | Nbptlin = rlin->NbPnts(); |
| | 486 | } |
| | 487 | else { |
| | 488 | Standard_DomainError::Raise(); |
| | 489 | } |
| | 490 | if (!Domain->Has3d()) |
| | 491 | // don't use computed deflection in the mode of pure geometric intersection |
| | 492 | PLin.ResetError(); |
| | 493 | |
| | 494 | const Standard_Boolean SurfaceIsUClosed = Surf->IsUClosed(); |
| | 495 | const Standard_Boolean SurfaceIsVClosed = Surf->IsVClosed(); |
| | 496 | const Standard_Boolean OSurfaceIsUClosed = OtherSurf->IsUClosed(); |
| | 497 | const Standard_Boolean OSurfaceIsVClosed = OtherSurf->IsVClosed(); |
| | 498 | const Standard_Boolean possiblyClosed = (SurfaceIsUClosed || SurfaceIsVClosed || |
| | 499 | OSurfaceIsUClosed || OSurfaceIsVClosed); |
| | 500 | Standard_Real tolUClosed=0., tolVClosed=0., tolOUClosed=0., tolOVClosed=0.; |
| | 501 | if (possiblyClosed) { |
| | 502 | if (SurfaceIsUClosed) |
| | 503 | tolUClosed = (Surf->LastUParameter() - Surf->FirstUParameter()) * 0.01; |
| | 504 | if (SurfaceIsVClosed) |
| | 505 | tolVClosed = (Surf->LastVParameter() - Surf->FirstVParameter()) * 0.01; |
| | 506 | if (OSurfaceIsUClosed) |
| | 507 | tolOUClosed = (OtherSurf->LastUParameter() - OtherSurf->FirstUParameter()) * 0.01; |
| | 508 | if (OSurfaceIsVClosed) |
| | 509 | tolOVClosed = (OtherSurf->LastVParameter() - OtherSurf->FirstVParameter()) * 0.01; |
| | 510 | } |
| | 511 | |
| | 512 | //------------------------------------------------------------------------ |
| | 513 | //-- On traite le cas ou la surface est periodique -- |
| | 514 | //-- il faut dans ce cas considerer la restriction -- |
| | 515 | //-- la restriction decalee de +-2PI -- |
| | 516 | //------------------------------------------------------------------------ |
| | 517 | const Handle(Adaptor3d_HSurface)& Surf1 = (OnFirst ? Surf : OtherSurf); |
| | 518 | const Handle(Adaptor3d_HSurface)& Surf2 = (OnFirst ? OtherSurf : Surf); |
| | 519 | GeomAbs_SurfaceType TypeS1 = Surf1->GetType(); |
| | 520 | GeomAbs_SurfaceType TypeS2 = Surf2->GetType(); |
| | 521 | Standard_Boolean SurfaceIsPeriodic = Standard_False; |
| | 522 | Standard_Boolean SurfaceIsBiPeriodic = Standard_False; |
| | 523 | GeomAbs_SurfaceType surfacetype = (OnFirst ? TypeS1 : TypeS2); |
| | 524 | if( surfacetype == GeomAbs_Cylinder |
| | 525 | || surfacetype == GeomAbs_Cone |
| | 526 | || surfacetype == GeomAbs_Torus |
| | 527 | || surfacetype == GeomAbs_Sphere) { |
| | 528 | SurfaceIsPeriodic = Standard_True; |
| | 529 | if(surfacetype == GeomAbs_Torus) { |
| | 530 | SurfaceIsBiPeriodic = Standard_True; |
| | 531 | } |
| | 532 | } |
| | 533 | |
| | 534 | Standard_Integer NumeroEdge=0; |
| | 535 | Domain->Init(); |
| | 536 | while (Domain->More()) { |
| | 537 | NumeroEdge++; |
| | 538 | arc = Domain->Value(); |
| | 539 | |
| | 540 | // MSV Oct 15, 2001: use tolerance of this edge if possible |
| | 541 | Standard_Real edgeTol = Tol3d(arc,Domain,Tol); |
| | 542 | Standard_Real URes = Surf->UResolution(edgeTol); |
| | 543 | Standard_Real VRes = Surf->VResolution(edgeTol); |
| | 544 | |
| | 545 | IntPatch_HInterTool::Bounds(arc,PFirst,PLast); |
| | 546 | if (Precision::IsNegativeInfinite(PFirst) || |
| | 547 | Precision::IsPositiveInfinite(PLast)) { |
| | 548 | //-- cout<<" IntPatch_RstInt::PutVertexOnLine ---> Restrictions Infinies :"<<endl; |
| | 549 | return; |
| | 550 | } |
| | 551 | |
| | 552 | Standard_Boolean isVFirst = Standard_False, isVLast = Standard_False; |
| | 553 | gp_Pnt2d p2dFirst,p2dLast; |
| | 554 | Standard_Real tolUFirst=0.,tolVFirst=0.,tolULast=0.,tolVLast=0.; |
| | 555 | Domain->Initialize(arc); |
| | 556 | for (Domain->InitVertexIterator(); Domain->MoreVertex(); Domain->NextVertex()) { |
| | 557 | Handle(Adaptor3d_HVertex) vtx = Domain->Vertex(); |
| | 558 | Standard_Real prm = IntPatch_HInterTool::Parameter(vtx,arc); |
| | 559 | if (Abs(prm - PFirst) < Precision::PConfusion()) { |
| | 560 | arc->D0(PFirst,p2dFirst); |
| | 561 | Standard_Real tol3d = Max (Tol3d(vtx,Domain), edgeTol); |
| | 562 | tolUFirst = Surf->UResolution(tol3d); |
| | 563 | tolVFirst = Surf->VResolution(tol3d); |
| | 564 | isVFirst = Standard_True; |
| | 565 | } |
| | 566 | else if (Abs(prm - PLast) < Precision::PConfusion()) { |
| | 567 | arc->D0(PLast,p2dLast); |
| | 568 | Standard_Real tol3d = Max (edgeTol, Tol3d(vtx,Domain)); |
| | 569 | tolULast = Surf->UResolution(tol3d); |
| | 570 | tolVLast = Surf->VResolution(tol3d); |
| | 571 | isVLast = Standard_True; |
| | 572 | } |
| | 573 | } |
| | 574 | |
| | 575 | Bnd_Box2d BPLin = IntPatch_PolygoTool::Bounding(PLin); |
| | 576 | |
| | 577 | if(SurfaceIsPeriodic) { |
| | 578 | Standard_Real xmin,ymin,xmax,ymax,g; |
| | 579 | BPLin.Get(xmin,ymin,xmax,ymax); |
| | 580 | g = BPLin.GetGap(); |
| | 581 | BPLin.SetVoid(); |
| | 582 | BPLin.Update(xmin-PI-PI,ymin, |
| | 583 | xmax+PI+PI,ymax); |
| | 584 | BPLin.SetGap(g); |
| | 585 | } |
| | 586 | if(SurfaceIsBiPeriodic) { |
| | 587 | Standard_Real xmin,ymin,xmax,ymax,g; |
| | 588 | BPLin.Get(xmin,ymin,xmax,ymax); |
| | 589 | g = BPLin.GetGap(); |
| | 590 | BPLin.SetVoid(); |
| | 591 | BPLin.Update(xmin,ymin-PI-PI, |
| | 592 | xmax,ymax+PI+PI); |
| | 593 | BPLin.SetGap(g); |
| | 594 | } |
| | 595 | |
| | 596 | switch(arc->GetType()) |
| | 597 | { |
| | 598 | case GeomAbs_Line: NbEchant=10; break; |
| | 599 | case GeomAbs_BezierCurve: |
| | 600 | { |
| | 601 | NbEchant = (3 + arc->NbPoles()); |
| | 602 | if(NbEchant<10) NbEchant=10; |
| | 603 | else if(NbEchant>50) NbEchant=50; |
| | 604 | } |
| | 605 | break; |
| | 606 | case GeomAbs_BSplineCurve: |
| | 607 | { |
| | 608 | //szv:const Standard_Real nbs = (arc->NbKnots() * arc->Degree())*(arc->LastParameter() - arc->FirstParameter())/(PLast-PFirst); |
| | 609 | const Standard_Real nbs = (arc->NbKnots() * arc->Degree())*(PLast-PFirst)/(arc->LastParameter() - arc->FirstParameter()); |
| | 610 | NbEchant = (nbs < 2.0 ? 2 : (Standard_Integer)nbs); |
| | 611 | if(NbEchant<10) NbEchant=10; |
| | 612 | else if (NbEchant>50) NbEchant=50; |
| | 613 | } |
| | 614 | break; |
| | 615 | default: |
| | 616 | { |
| | 617 | NbEchant = 25; |
| | 618 | } |
| | 619 | } |
| | 620 | |
| | 621 | IntPatch_PolyArc Brise(arc,NbEchant,PFirst,PLast,BPLin); |
| | 622 | |
| | 623 | Standard_Integer IndiceOffsetBiPeriodic = 0; |
| | 624 | Standard_Integer IndiceOffsetPeriodic = 0; |
| | 625 | Standard_Real OffsetV = 0.0; |
| | 626 | Standard_Real OffsetU = 0.0; |
| | 627 | |
| | 628 | do { |
| | 629 | if(IndiceOffsetBiPeriodic == 1) |
| | 630 | OffsetV = -PI-PI; |
| | 631 | else if(IndiceOffsetBiPeriodic == 2) |
| | 632 | OffsetV = PI+PI; |
| | 633 | |
| | 634 | do { |
| | 635 | if(IndiceOffsetPeriodic == 1) |
| | 636 | OffsetU = -PI-PI; |
| | 637 | else if(IndiceOffsetPeriodic == 2) |
| | 638 | OffsetU = PI+PI; |
| | 639 | |
| | 640 | Brise.SetOffset(OffsetU,OffsetV); |
| | 641 | |
| | 642 | static int debug_polygon2d =0; |
| | 643 | if(debug_polygon2d) { |
| | 644 | cout<<" ***** Numero Restriction : "<<NumeroEdge<<" *****"<<endl; |
| | 645 | IntPatch_PolygoTool::Dump(PLin); |
| | 646 | IntPatch_PolygoTool::Dump(Brise); |
| | 647 | } |
| | 648 | |
| | 649 | Commun.Perform(PLin,Brise); |
| | 650 | locpt.Clear(); |
| | 651 | locpt2.Clear(); |
| | 652 | Standard_Integer Commun_NbSectionPoints = Commun.NbSectionPoints(); |
| | 653 | Standard_Integer Commun_NbTangentZones = Commun.NbTangentZones(); |
| | 654 | Standard_Integer Commun_Section_Tangent = Commun_NbSectionPoints |
| | 655 | + Commun_NbTangentZones; |
| | 656 | for (i=1;i<=Commun_Section_Tangent;i++) { |
| | 657 | Standard_Real W1[2],W2[2]; |
| | 658 | Standard_Boolean refine[2],useWL[2]; |
| | 659 | Standard_Integer nbpt = 1; |
| | 660 | if(i<=Commun_NbSectionPoints) { |
| | 661 | // intersection point |
| | 662 | W1[0] = Commun.PntValue(i).ParamOnFirst(); |
| | 663 | W2[0] = Commun.PntValue(i).ParamOnSecond(); |
| | 664 | refine[0] = Standard_True; |
| | 665 | } |
| | 666 | else { |
| | 667 | // tangent zone |
| | 668 | Standard_Real UMinCh,UMaxCh; //-- ligne de cheminement 0..(Nbptlin-1) |
| | 669 | Standard_Real UMinAr,UMaxAr; //-- polyline of arc 0..(NbEchant-1) |
| | 670 | Commun.ZoneValue(i-Commun_NbSectionPoints).ParamOnFirst(UMinCh,UMaxCh); |
| | 671 | Commun.ZoneValue(i-Commun_NbSectionPoints).ParamOnSecond(UMinAr,UMaxAr); |
| | 672 | gp_Pnt2d p1Ar = GetPointOnPolygo(Brise,UMinAr); |
| | 673 | gp_Pnt2d p2Ar = GetPointOnPolygo(Brise,UMaxAr); |
| | 674 | Standard_Real tolU = URes*2.; |
| | 675 | Standard_Real tolV = VRes*2.; |
| | 676 | if (isVFirst && ArePnt2dEqual(p1Ar,p2dFirst,tolUFirst,tolVFirst)) { |
| | 677 | tolU = Max(tolUFirst,tolU); tolV = Max(tolVFirst,tolV); |
| | 678 | } |
| | 679 | if (isVLast && ArePnt2dEqual(p2Ar,p2dLast,tolULast,tolVLast)) { |
| | 680 | tolU = Max(tolULast,tolU); tolV = Max(tolVLast,tolV); |
| | 681 | } |
| | 682 | Standard_Real nptCh = UMaxCh-UMinCh; |
| | 683 | Standard_Boolean isNptLow = nptCh < 10. && nptCh < Nbptlin/100. || |
| | 684 | !Domain->Has3d() && Standard_Integer(nptCh)+1 < Nbptlin; |
| | 685 | if (!isNptLow && !IsSegment2dSmall(Brise,UMinAr,UMaxAr,tolU,tolV)) { |
| | 686 | // treat both ends |
| | 687 | Standard_Real UMinChP,UMaxChP,UMinArP,UMaxArP; |
| | 688 | UMinChP = IntegerPart(UMinCh); UMinArP = IntegerPart(UMinAr); |
| | 689 | UMaxChP = IntegerPart(UMaxCh); UMaxArP = IntegerPart(UMaxAr); |
| | 690 | Standard_Integer irangCh1,irangCh2,irangAr1,irangAr2; |
| | 691 | irangCh1 = Standard_Integer(UMinChP)+1; irangCh2 = Standard_Integer(UMaxChP)+1; |
| | 692 | irangAr1 = Standard_Integer(UMinArP)+1; irangAr2 = Standard_Integer(UMaxArP)+1; |
| | 693 | UMinChP = UMinCh - UMinChP; UMinArP = UMinAr - UMinArP; |
| | 694 | //UMaxChP = UMaxCh - UMaxChP; UMaxArP = UMaxAr - UMaxArP; |
| | 695 | const Standard_Real eps = 1e-10; |
| | 696 | // Standard_Boolean isChExtr1 = irangCh1==1 && UMinChP<eps; |
| | 697 | // Standard_Boolean isChExtr2 = irangCh2==Nbptlin; |
| | 698 | Standard_Boolean isArExtr1 = irangAr1==1 && UMinArP<eps; |
| | 699 | Standard_Boolean isArExtr2 = irangAr2==NbEchant; |
| | 700 | // detect orientation |
| | 701 | gp_Pnt2d p1Ch = GetPointOnPolygo(PLin,UMinCh); |
| | 702 | Standard_Real d11 = p1Ch.SquareDistance(p1Ar); |
| | 703 | Standard_Real d12 = p1Ch.SquareDistance(p2Ar); |
| | 704 | Standard_Boolean sameOri = d11 < d12; |
| | 705 | if (!sameOri) { |
| | 706 | Standard_Boolean itmp=isArExtr1; isArExtr1=isArExtr2; isArExtr2=itmp; |
| | 707 | Standard_Real dtmp=UMinAr; UMinAr=UMaxAr; UMaxAr=dtmp; |
| | 708 | } |
| | 709 | W1[0] = UMinCh; W1[1] = UMaxCh; |
| | 710 | W2[0] = UMinAr; W2[1] = UMaxAr; |
| | 711 | //refine[0] = ! (isChExtr1 || isArExtr1); |
| | 712 | //refine[1] = ! (isChExtr2 || isArExtr2); |
| | 713 | refine[0] = refine[1] = Standard_False; |
| | 714 | useWL[0] = !isArExtr1; |
| | 715 | useWL[1] = !isArExtr2; |
| | 716 | nbpt = 2; |
| | 717 | } |
| | 718 | else { |
| | 719 | // treat the middle point as an intersection point |
| | 720 | W1[0] = 0.5*(UMinCh+UMaxCh); |
| | 721 | W2[0] = 0.5*(UMinAr+UMaxAr); |
| | 722 | refine[0] = Standard_True; |
| | 723 | } |
| | 724 | } |
| | 725 | |
| | 726 | Standard_Boolean nbTreated = 0; |
| | 727 | for (Standard_Integer ip=0; ip < nbpt; ip++) { |
| | 728 | GetLinePoint2d (L, W1[ip]+1, !OnFirst, U,V); |
| | 729 | |
| | 730 | if (!refine[ip] && useWL[ip]) { |
| | 731 | Standard_Real aU1,aV1; |
| | 732 | GetLinePoint2d (L, W1[ip]+1, OnFirst, aU1,aV1); |
| | 733 | p2d.SetCoord(aU1,aV1); |
| | 734 | Standard_Real paramProj; |
| | 735 | if (!IntPatch_HInterTool::Project(arc,p2d,paramProj,p2d)) continue; |
| | 736 | W = paramProj; |
| | 737 | } |
| | 738 | else { |
| | 739 | Standard_Real par = IntegerPart(W2[ip]); |
| | 740 | Standard_Integer Irang = Standard_Integer(par) + 1; |
| | 741 | if (Irang == Brise.NbPoints()) { |
| | 742 | Irang--; |
| | 743 | par = 1.; |
| | 744 | } |
| | 745 | else { |
| | 746 | par =Abs(W2[ip]-par); |
| | 747 | } |
| | 748 | W = (1.-par)*Brise.Parameter(Irang) + par*Brise.Parameter(Irang+1); |
| | 749 | } |
| | 750 | |
| | 751 | Standard_Boolean refined = Standard_False; |
| | 752 | if (refine[ip]) { |
| | 753 | //------------------------------------------------------------------------ |
| | 754 | //-- On a trouve un point 2d approche Ua,Va intersection de la ligne |
| | 755 | //-- de cheminement et de la restriction. |
| | 756 | //-- |
| | 757 | //-- On injecte ce point ds les intersections Courbe-Surface |
| | 758 | //-- |
| | 759 | IntPatch_CSFunction thefunc(OtherSurf,arc,Surf); |
| | 760 | // MSV: extend UV bounds to not miss solution near the boundary |
| | 761 | Standard_Real margCoef = 0.004; |
| | 762 | IntPatch_CurvIntSurf IntCS(U,V,W,thefunc,edgeTol,margCoef); |
| | 763 | if (IntCS.IsDone()) { |
| | 764 | if (!IntCS.IsEmpty()) { |
| | 765 | ptsommet = IntCS.Point(); |
| | 766 | IntCS.ParameterOnSurface(U2,V2); |
| | 767 | paramarc = IntCS.ParameterOnCurve(); |
| | 768 | refined = Standard_True; |
| | 769 | } |
| | 770 | } |
| | 771 | } |
| | 772 | else { |
| | 773 | U2 = U; V2 = V; |
| | 774 | paramarc = W; |
| | 775 | arc->D0(paramarc,p2d); |
| | 776 | Surf->D0(p2d.X(),p2d.Y(),ptsommet); |
| | 777 | } |
| | 778 | |
| | 779 | if (!refine[ip] || refined) { |
| | 780 | duplicate = Standard_False; |
| | 781 | for (j=1; j<=locpt.Length();j++) { |
| | 782 | if (ptsommet.Distance(locpt(j)) <= edgeTol) { |
| | 783 | if (possiblyClosed) { |
| | 784 | locpt2(j).Coord(U,V); |
| | 785 | if (OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed || |
| | 786 | OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed) |
| | 787 | continue; |
| | 788 | } |
| | 789 | duplicate = Standard_True; |
| | 790 | break; |
| | 791 | } |
| | 792 | } |
| | 793 | |
| | 794 | if (!duplicate) { |
| | 795 | Standard_Integer ParamApproxOnLine = Standard_Integer(W1[ip])+1; |
| | 796 | |
| | 797 | arc->D1(paramarc,p2d,d2d); |
| | 798 | U1 = p2d.X(); V1 = p2d.Y(); |
| | 799 | if (typL == IntPatch_Walking && SurfaceIsPeriodic) |
| | 800 | if (OnFirst) |
| | 801 | Recadre(TypeS1,TypeS2,wlin,ParamApproxOnLine,U1,V1,U2,V2); |
| | 802 | else |
| | 803 | Recadre(TypeS1,TypeS2,wlin,ParamApproxOnLine,U2,V2,U1,V1); |
| | 804 | |
| | 805 | locpt.Append(ptsommet); |
| | 806 | locpt2.Append(gp_Pnt2d(U2,V2)); |
| | 807 | |
| | 808 | found = FindParameter(L,OtherSurf,edgeTol,ptsommet,gp_Pnt2d(U2,V2), |
| | 809 | paramline,tgline,ParamApproxOnLine,OnFirst); |
| | 810 | |
| | 811 | if (typL == IntPatch_Walking && found && possiblyClosed) { |
| | 812 | // check in 2d |
| | 813 | if (SurfaceIsUClosed || SurfaceIsVClosed) { |
| | 814 | GetLinePoint2d (L, paramline, OnFirst, U,V); |
| | 815 | if (SurfaceIsUClosed && Abs(U-U1) > tolUClosed || |
| | 816 | SurfaceIsVClosed && Abs(V-V1) > tolVClosed) |
| | 817 | found = Standard_False; |
| | 818 | } |
| | 819 | if (found && (OSurfaceIsUClosed || OSurfaceIsVClosed)) { |
| | 820 | GetLinePoint2d (L, paramline, !OnFirst, U,V); |
| | 821 | if (OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed || |
| | 822 | OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed) |
| | 823 | found = Standard_False; |
| | 824 | } |
| | 825 | } |
| | 826 | if (!found) { |
| | 827 | continue; |
| | 828 | } |
| | 829 | |
| | 830 | VtxOnArc = CoincideOnArc(ptsommet,arc,Surf,edgeTol,Domain,vtxarc); |
| | 831 | Standard_Real vtxTol; |
| | 832 | if (VtxOnArc) { |
| | 833 | vtxTol = Tol3d(vtxarc,Domain); |
| | 834 | if (edgeTol > vtxTol) vtxTol = edgeTol; |
| | 835 | } |
| | 836 | else vtxTol = edgeTol; |
| | 837 | |
| | 838 | //-- It is necessary to test that the point does not already exist |
| | 839 | //-- - It can be already a point on arc |
| | 840 | //-- BUT on a different arc |
| | 841 | // MSV 27.03.2002: find the nearest point; add check in 2d |
| | 842 | Standard_Integer ivtx = 0; |
| | 843 | Standard_Real dmin = RealLast(); |
| | 844 | for (j=1; j<=Nbvtx; j++) { |
| | 845 | const IntPatch_Point& Rptline = (typL == IntPatch_Walking |
| | 846 | ? wlin->Vertex(j) |
| | 847 | : rlin->Vertex(j)); |
| | 848 | Standard_Boolean APointOnRstStillExist = |
| | 849 | (OnFirst && Rptline.IsOnDomS1() && Rptline.ArcOnS1() == arc || |
| | 850 | !OnFirst && Rptline.IsOnDomS2() && Rptline.ArcOnS2() == arc); |
| | 851 | if(!APointOnRstStillExist) { |
| | 852 | if (possiblyClosed) { |
| | 853 | if (SurfaceIsUClosed || SurfaceIsVClosed) { |
| | 854 | if (OnFirst) Rptline.ParametersOnS1(U,V); |
| | 855 | else Rptline.ParametersOnS2(U,V); |
| | 856 | if (SurfaceIsUClosed && Abs(U-U1) > tolUClosed || |
| | 857 | SurfaceIsVClosed && Abs(V-V1) > tolVClosed) |
| | 858 | continue; |
| | 859 | } |
| | 860 | if (OSurfaceIsUClosed || OSurfaceIsVClosed) { |
| | 861 | if (OnFirst) Rptline.ParametersOnS2(U,V); |
| | 862 | else Rptline.ParametersOnS1(U,V); |
| | 863 | if (OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed || |
| | 864 | OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed) |
| | 865 | continue; |
| | 866 | } |
| | 867 | } |
| | 868 | Standard_Real dist = ptsommet.Distance(Rptline.Value()); |
| | 869 | Standard_Real dt = Max(vtxTol, Rptline.Tolerance()); |
| | 870 | if (dist < dmin) { |
| | 871 | if (dist <= dt) { |
| | 872 | ptline = Rptline; |
| | 873 | ivtx = j; |
| | 874 | if( surfacetype == GeomAbs_Cone ) { |
| | 875 | ivtx = 0; |
| | 876 | } |
| | 877 | } |
| | 878 | else { |
| | 879 | // cancel previous solution because this point is better |
| | 880 | // but its tolerance is not large enough |
| | 881 | ivtx = 0; |
| | 882 | } |
| | 883 | dmin = dist; |
| | 884 | } |
| | 885 | } |
| | 886 | } |
| | 887 | if (ivtx) { |
| | 888 | if (ptline.Tolerance() > vtxTol) { |
| | 889 | vtxTol = ptline.Tolerance(); |
| | 890 | if (!VtxOnArc) { |
| | 891 | // now we should repeat attempt to coincide on a bound of arc |
| | 892 | VtxOnArc = CoincideOnArc(ptsommet,arc,Surf,vtxTol,Domain,vtxarc); |
| | 893 | if (VtxOnArc) { |
| | 894 | Standard_Real tol = Tol3d(vtxarc,Domain); |
| | 895 | if (tol > vtxTol) vtxTol = tol; |
| | 896 | } |
| | 897 | } |
| | 898 | } |
| | 899 | } |
| | 900 | |
| | 901 | if (typL == IntPatch_Walking) |
| | 902 | VerifyTgline(wlin,(Standard_Integer)paramline,edgeTol,tgline); |
| | 903 | |
| | 904 | Surf->D1(U1,V1,ptbid,d1u,d1v); |
| | 905 | tgrst.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v); |
| | 906 | |
| | 907 | normsurf = d1u.Crossed(d1v); |
| | 908 | if (normsurf.Magnitude() < gp::Resolution()) { |
| | 909 | transline.SetValue(Standard_True,IntSurf_Undecided); |
| | 910 | transarc.SetValue(Standard_True,IntSurf_Undecided); |
| | 911 | } |
| | 912 | else |
| | 913 | IntSurf::MakeTransition(tgline,tgrst,normsurf,transline,transarc); |
| | 914 | |
| | 915 | if (typL == IntPatch_Walking && !refine[ip]) { |
| | 916 | // for new vertex use coordinates from Line |
| | 917 | if (OnFirst) |
| | 918 | GetWLinePoint (wlin, paramline, U1,V1,U2,V2,ptsommet); |
| | 919 | else |
| | 920 | GetWLinePoint (wlin, paramline, U2,V2,U1,V1,ptsommet); |
| | 921 | } |
| | 922 | |
| | 923 | nbTreated++; |
| | 924 | if (!ivtx) { |
| | 925 | Sommet.SetValue(ptsommet,vtxTol,Standard_False); // pour tangence |
| | 926 | if (OnFirst) |
| | 927 | Sommet.SetParameters(U1,V1,U2,V2); |
| | 928 | else |
| | 929 | Sommet.SetParameters(U2,V2,U1,V1); |
| | 930 | |
| | 931 | if (VtxOnArc) |
| | 932 | Sommet.SetVertex(OnFirst,vtxarc); |
| | 933 | |
| | 934 | //--------------------------------------------------------- |
| | 935 | //-- lbr : On remplace le point d indice paramline sur la - |
| | 936 | //-- ligne par le vertex . - |
| | 937 | //--------------------------------------------------------- |
| | 938 | Sommet.SetParameter(paramline); // sur ligne d intersection |
| | 939 | Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc); |
| | 940 | |
| | 941 | if (typL == IntPatch_Walking) { |
| | 942 | wlin->AddVertex(Sommet); |
| | 943 | Nbvtx++; |
| | 944 | } |
| | 945 | else { |
| | 946 | rlin->AddVertex(Sommet); |
| | 947 | Nbvtx++; |
| | 948 | } |
| | 949 | } |
| | 950 | else { |
| | 951 | // CAS DE FIGURE : en appelant s1 la surf sur laquelle on |
| | 952 | // connait les pts sur restriction, et s2 celle sur laquelle |
| | 953 | // on les cherche. Le point trouve verifie necessairement |
| | 954 | // IsOnDomS1 = True. |
| | 955 | // Pas vtxS1, pas vtxS2 : |
| | 956 | // on recupere le point et on applique SetArcOnS2 et |
| | 957 | // eventuellement SetVertexOnS2. Si on a deja IsOnDomS2, |
| | 958 | // on considere que le point est deja traite, mais ne devrait |
| | 959 | // pas se produire. |
| | 960 | // vtxS1, pas vtxS2 : |
| | 961 | // si pas IsOnDomS2 : pour chaque occurrence, faire SetArcOnS2, |
| | 962 | // et eventuellement SetVertexOnS2. |
| | 963 | // si IsOnDomS2 : impossible, on doit avoir IsVtxOnS2. |
| | 964 | // vtxS1,vtxS2 : |
| | 965 | // on doit avoir VtxOnArc = True. On duplique chaque occurrence |
| | 966 | // "sur S1" du point en changeant ArcOnS2. |
| | 967 | // pas vtxS1, vtxS2 : |
| | 968 | // on doit avoir VtxOnArc = True. On duplique le point sur S1 |
| | 969 | // en changeant ArcOnS2. |
| | 970 | Standard_Boolean OnDifferentRst = |
| | 971 | (OnFirst && ptline.IsOnDomS1() && ptline.ArcOnS1() != arc || |
| | 972 | !OnFirst && ptline.IsOnDomS2() && ptline.ArcOnS2() != arc); |
| | 973 | ptline.SetTolerance(vtxTol); |
| | 974 | if ( (!ptline.IsVertexOnS1() && OnFirst) |
| | 975 | || (!ptline.IsVertexOnS2() && !OnFirst) |
| | 976 | || (OnDifferentRst)) { |
| | 977 | if ( (!ptline.IsOnDomS2() && !OnFirst) |
| | 978 | ||(!ptline.IsOnDomS1() && OnFirst) |
| | 979 | ||(OnDifferentRst)) { |
| | 980 | ptline.SetArc(OnFirst,arc,paramarc,transline,transarc); |
| | 981 | //ptline.SetParameter(paramline); //-- rajout lbr le 20 nov 97 |
| | 982 | if (VtxOnArc) |
| | 983 | ptline.SetVertex(OnFirst,vtxarc); |
| | 984 | if (typL == IntPatch_Walking) { |
| | 985 | if(OnDifferentRst) { |
| | 986 | wlin->AddVertex(ptline); |
| | 987 | Nbvtx++; |
| | 988 | } |
| | 989 | else { |
| | 990 | wlin->Replace(ivtx,ptline); |
| | 991 | } |
| | 992 | } |
| | 993 | else { |
| | 994 | if(OnDifferentRst) { |
| | 995 | rlin->AddVertex(ptline); |
| | 996 | Nbvtx++; |
| | 997 | } |
| | 998 | else { |
| | 999 | rlin->Replace(ivtx,ptline); |
| | 1000 | } |
| | 1001 | } |
| | 1002 | } |
| | 1003 | else if ( ( OnFirst && ptline.IsVertexOnS2()) |
| | 1004 | ||(!OnFirst && ptline.IsVertexOnS1())) { |
| | 1005 | Sommet = ptline; |
| | 1006 | Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc); |
| | 1007 | if (VtxOnArc) |
| | 1008 | Sommet.SetVertex(OnFirst,vtxarc); |
| | 1009 | if (typL == IntPatch_Walking) { |
| | 1010 | wlin->AddVertex(Sommet); |
| | 1011 | Nbvtx++; |
| | 1012 | } |
| | 1013 | else { |
| | 1014 | rlin->AddVertex(Sommet); |
| | 1015 | Nbvtx++; |
| | 1016 | } |
| | 1017 | } |
| | 1018 | else { |
| | 1019 | //-- cout << "pb dans RstInt Type 1 " << endl; |
| | 1020 | } |
| | 1021 | } |
| | 1022 | else { |
| | 1023 | Handle(Adaptor3d_HVertex) vtxref = (OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()) ; |
| | 1024 | if ( ( OnFirst && !ptline.IsOnDomS2()) |
| | 1025 | ||(!OnFirst && !ptline.IsOnDomS1())) { |
| | 1026 | ptline.SetArc(OnFirst,arc,paramarc,transline,transarc); |
| | 1027 | if (VtxOnArc) |
| | 1028 | ptline.SetVertex(OnFirst,vtxarc); |
| | 1029 | if (typL == IntPatch_Walking) { |
| | 1030 | wlin->Replace(ivtx,ptline); |
| | 1031 | } |
| | 1032 | else { |
| | 1033 | rlin->Replace(ivtx,ptline); |
| | 1034 | } |
| | 1035 | |
| | 1036 | for (k=1; k<=Nbvtx; k++) if (k != ivtx) { |
| | 1037 | if (typL == IntPatch_Walking) { |
| | 1038 | ptline = wlin->Vertex(k); |
| | 1039 | } |
| | 1040 | else { |
| | 1041 | ptline = rlin->Vertex(k); |
| | 1042 | } |
| | 1043 | if ( ( OnFirst && ptline.IsVertexOnS1()) |
| | 1044 | || (!OnFirst && ptline.IsVertexOnS2())) { |
| | 1045 | if (Domain->Identical(vtxref, (OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()))) { |
| | 1046 | if (ptline.Tolerance() < vtxTol) ptline.SetTolerance(vtxTol); |
| | 1047 | ptline.SetArc(OnFirst,arc,paramarc,transline,transarc); |
| | 1048 | if (VtxOnArc) |
| | 1049 | ptline.SetVertex(OnFirst,vtxarc); |
| | 1050 | if (typL == IntPatch_Walking) { |
| | 1051 | wlin->Replace(k,ptline); |
| | 1052 | } |
| | 1053 | else { |
| | 1054 | rlin->Replace(k,ptline); |
| | 1055 | } |
| | 1056 | } |
| | 1057 | } |
| | 1058 | } |
| | 1059 | } |
| | 1060 | else if( ( OnFirst && ptline.IsVertexOnS2()) |
| | 1061 | || (!OnFirst && ptline.IsVertexOnS1())) { |
| | 1062 | // on doit avoir vtxons2 = vtxarc... pas de verif... |
| | 1063 | Sommet = ptline; |
| | 1064 | Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc); |
| | 1065 | if (typL == IntPatch_Walking) { |
| | 1066 | wlin->AddVertex(Sommet); |
| | 1067 | Nbvtx++; |
| | 1068 | } |
| | 1069 | else { |
| | 1070 | rlin->AddVertex(Sommet); |
| | 1071 | Nbvtx++; |
| | 1072 | } |
| | 1073 | for (k=1; k<=Nbvtx; k++) if (k != ivtx) { |
| | 1074 | if (typL == IntPatch_Walking) { |
| | 1075 | ptline = wlin->Vertex(k); |
| | 1076 | } |
| | 1077 | else { |
| | 1078 | ptline = rlin->Vertex(k); |
| | 1079 | } |
| | 1080 | if ( ( OnFirst && ptline.IsVertexOnS1()) |
| | 1081 | ||(!OnFirst && ptline.IsVertexOnS2())) { |
| | 1082 | if (Domain->Identical(vtxref,(OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()))) { |
| | 1083 | if (ptline.Tolerance() < vtxTol) ptline.SetTolerance(vtxTol); |
| | 1084 | Sommet = ptline; |
| | 1085 | Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc); |
| | 1086 | if (typL == IntPatch_Walking) { |
| | 1087 | wlin->Replace(k,ptline); |
| | 1088 | wlin->AddVertex(Sommet); |
| | 1089 | Nbvtx++; |
| | 1090 | } |
| | 1091 | else { |
| | 1092 | rlin->Replace(k,ptline); |
| | 1093 | rlin->AddVertex(Sommet); |
| | 1094 | Nbvtx++; |
| | 1095 | } |
| | 1096 | } |
| | 1097 | } |
| | 1098 | } |
| | 1099 | |
| | 1100 | } |
| | 1101 | else { |
| | 1102 | //-- cout << "pb dans RstInt Type 2 " << endl; |
| | 1103 | } |
| | 1104 | } |
| | 1105 | } |
| | 1106 | } |
| | 1107 | } |
| | 1108 | } |
| | 1109 | if (nbTreated == 2 && typL == IntPatch_Walking) { |
| | 1110 | // We processed a tangent zone, and both ends have been treated. |
| | 1111 | // So mark WLine as having arc |
| | 1112 | if(OnFirst) wlin->SetArcOnS1(arc); |
| | 1113 | else wlin->SetArcOnS2(arc); |
| | 1114 | } |
| | 1115 | } |
| | 1116 | |
| | 1117 | IndiceOffsetPeriodic++; |
| | 1118 | } |
| | 1119 | while(SurfaceIsPeriodic && IndiceOffsetPeriodic<=2); |
| | 1120 | |
| | 1121 | IndiceOffsetBiPeriodic++; |
| | 1122 | } |
| | 1123 | while(SurfaceIsBiPeriodic && IndiceOffsetBiPeriodic<=2); |
| | 1124 | Domain->Next(); |
| | 1125 | } |
| | 1126 | |
| | 1127 | //-------------------------------------------------------------------------------- |
| | 1128 | //-- On reprend la ligne et on recale les parametres des vertex. |
| | 1129 | //-- |
| | 1130 | if (typL == IntPatch_Walking) { |
| | 1131 | Standard_Real pu1,pv1,pu2,pv2; |
| | 1132 | pu1=pv1=pu2=pv2=0.0; |
| | 1133 | switch(TypeS1) { |
| | 1134 | case GeomAbs_Cylinder: |
| | 1135 | case GeomAbs_Cone: |
| | 1136 | case GeomAbs_Sphere: |
| | 1137 | pu1=PI+PI; |
| | 1138 | break; |
| | 1139 | case GeomAbs_Torus: |
| | 1140 | pu1=pv1=PI+PI; |
| | 1141 | break; |
| | 1142 | default: |
| | 1143 | { |
| | 1144 | if( Surf1->IsUPeriodic()) { |
| | 1145 | pu1=Surf1->UPeriod(); |
| | 1146 | } |
| | 1147 | else if(Surf1->IsUClosed()) { |
| | 1148 | pu1=Surf1->LastUParameter() - Surf1->FirstUParameter(); |
| | 1149 | //cout<<" UClosed1 "<<pu1<<endl; |
| | 1150 | } |
| | 1151 | if( Surf1->IsVPeriodic()) { |
| | 1152 | pv1=Surf1->VPeriod(); |
| | 1153 | } |
| | 1154 | else if(Surf1->IsVClosed()) { |
| | 1155 | pv1=Surf1->LastVParameter() - Surf1->FirstVParameter(); |
| | 1156 | //cout<<" VClosed1 "<<pv1<<endl; |
| | 1157 | } |
| | 1158 | |
| | 1159 | break; |
| | 1160 | } |
| | 1161 | } |
| | 1162 | |
| | 1163 | switch(TypeS2) { |
| | 1164 | case GeomAbs_Cylinder: |
| | 1165 | case GeomAbs_Cone: |
| | 1166 | case GeomAbs_Sphere: |
| | 1167 | |
| | 1168 | pu2=PI+PI; |
| | 1169 | break; |
| | 1170 | case GeomAbs_Torus: |
| | 1171 | pu2=pv2=PI+PI; |
| | 1172 | break; |
| | 1173 | default: |
| | 1174 | { |
| | 1175 | if( Surf2->IsUPeriodic()) { |
| | 1176 | pu2=Surf2->UPeriod(); |
| | 1177 | } |
| | 1178 | else if(Surf2->IsUClosed()) { |
| | 1179 | pu2=Surf2->LastUParameter() - Surf2->FirstUParameter(); |
| | 1180 | //cout<<" UClosed2 "<<pu2<<endl; |
| | 1181 | } |
| | 1182 | |
| | 1183 | if( Surf2->IsVPeriodic()) { |
| | 1184 | pv2=Surf2->VPeriod(); |
| | 1185 | } |
| | 1186 | else if(Surf2->IsVClosed()) { |
| | 1187 | pv2=Surf2->LastVParameter() - Surf2->FirstVParameter(); |
| | 1188 | //cout<<" VClosed2 "<<pv2<<endl; |
| | 1189 | } |
| | 1190 | |
| | 1191 | break; |
| | 1192 | } |
| | 1193 | } |
| | 1194 | |
| | 1195 | /* |
| | 1196 | if(pu1==0) { |
| | 1197 | pu1=Surf1->LastUParameter() - Surf1->FirstUParameter(); |
| | 1198 | pu1+=pu1; |
| | 1199 | } |
| | 1200 | if(pu2==0) { |
| | 1201 | pu2=Surf2->LastUParameter() - Surf2->FirstUParameter(); |
| | 1202 | pu2+=pu2; |
| | 1203 | } |
| | 1204 | if(pv1==0) { |
| | 1205 | pv1=Surf1->LastVParameter() - Surf1->FirstVParameter(); |
| | 1206 | pv1+=pv1; |
| | 1207 | } |
| | 1208 | if(pv2==0) { |
| | 1209 | pv2=Surf2->LastVParameter() - Surf2->FirstVParameter(); |
| | 1210 | pv2+=pv2; |
| | 1211 | } |
| | 1212 | */ |
| | 1213 | |
| | 1214 | wlin->SetPeriod(pu1,pv1,pu2,pv2); |
| | 1215 | wlin->ComputeVertexParameters(Tol); |
| | 1216 | } |
| | 1217 | else { |
| | 1218 | #ifdef DEB |
| | 1219 | //if(rlin->NbVertex()==0) { |
| | 1220 | // cout<<" \n *** IntPatch RstInt.gxx : nbvtx = 0 sur rline *** \n"<<endl; |
| | 1221 | //} |
| | 1222 | #endif |
| | 1223 | rlin->ComputeVertexParameters(Tol); |
| | 1224 | } |
| | 1225 | } |
projects / occt.git / blame_incremental