1 // Created by: Modelization
2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
4 // The content of this file is subject to the Open CASCADE Technology Public
5 // License Version 6.5 (the "License"). You may not use the content of this file
6 // except in compliance with the License. Please obtain a copy of the License
7 // at http://www.opencascade.org and read it completely before using this file.
9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 // The Original Code and all software distributed under the License is
13 // distributed on an "AS IS" basis, without warranty of any kind, and the
14 // Initial Developer hereby disclaims all such warranties, including without
15 // limitation, any warranties of merchantability, fitness for a particular
16 // purpose or non-infringement. Please see the License for the specific terms
17 // and conditions governing the rights and limitations under the License.
20 #include <IntPatch_Intersection.ixx>
22 #include <IntPatch_ALineToWLine.hxx>
23 #include <IntPatch_GLine.hxx>
24 #include <IntPatch_ALine.hxx>
25 #include <IntPatch_WLine.hxx>
26 #include <IntPatch_RLine.hxx>
27 #include <IntPatch_PrmPrmIntersection.hxx>
28 #include <IntPatch_ImpPrmIntersection.hxx>
29 #include <IntPatch_ImpImpIntersection.hxx>
30 #include <IntSurf_Quadric.hxx>
35 static const Standard_Integer aNbPointsInALine = 200;
37 //======================================================================
38 // function: SequenceOfLine
39 //======================================================================
40 const IntPatch_SequenceOfLine& IntPatch_Intersection::SequenceOfLine() const { return(slin); }
42 //======================================================================
43 // function: IntPatch_Intersection
44 //======================================================================
45 IntPatch_Intersection::IntPatch_Intersection ()
46 : done(Standard_False),
48 myTolArc(0.0), myTolTang(0.0),
49 myUVMaxStep(0.0), myFleche(0.0),
50 myIsStartPnt(Standard_False)
51 //myU1Start, myV1Start, myU2Start, myV2Start
55 //======================================================================
56 // function: IntPatch_Intersection
57 //======================================================================
58 IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)& S1,
59 const Handle(Adaptor3d_TopolTool)& D1,
60 const Handle(Adaptor3d_HSurface)& S2,
61 const Handle(Adaptor3d_TopolTool)& D2,
62 const Standard_Real TolArc,
63 const Standard_Real TolTang)
64 : done(Standard_False),
66 myTolArc(TolArc), myTolTang(TolTang),
67 myUVMaxStep(0.0), myFleche(0.0),
68 myIsStartPnt(Standard_False)
69 //myU1Start, myV1Start, myU2Start, myV2Start
71 if(myTolArc<1e-8) myTolArc=1e-8;
72 if(myTolTang<1e-8) myTolTang=1e-8;
73 if(myTolArc>0.5) myTolArc=0.5;
74 if(myTolTang>0.5) myTolTang=0.5;
75 Perform(S1,D1,S2,D2,TolArc,TolTang);
78 //======================================================================
79 // function: IntPatch_Intersection
80 //======================================================================
81 IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)& S1,
82 const Handle(Adaptor3d_TopolTool)& D1,
83 const Standard_Real TolArc,
84 const Standard_Real TolTang)
85 : done(Standard_False),
87 myTolArc(TolArc), myTolTang(TolTang),
88 myUVMaxStep(0.0), myFleche(0.0),
89 myIsStartPnt(Standard_False)
90 //myU1Start, myV1Start, myU2Start, myV2Start
92 Perform(S1,D1,TolArc,TolTang);
95 //======================================================================
96 // function: SetTolerances
97 //======================================================================
98 void IntPatch_Intersection::SetTolerances(const Standard_Real TolArc,
99 const Standard_Real TolTang,
100 const Standard_Real UVMaxStep,
101 const Standard_Real Fleche)
105 myUVMaxStep = UVMaxStep;
107 if(myTolArc<1e-8) myTolArc=1e-8;
108 if(myTolTang<1e-8) myTolTang=1e-8;
109 if(myTolArc>0.5) myTolArc=0.5;
110 if(myTolTang>0.5) myTolTang=0.5;
111 if(myFleche<1.0e-3) myFleche=1e-3;
112 if(myUVMaxStep<1.0e-3) myUVMaxStep=1e-3;
113 if(myFleche>10) myFleche=10;
114 if(myUVMaxStep>0.5) myUVMaxStep=0.5;
117 //======================================================================
119 //======================================================================
120 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
121 const Handle(Adaptor3d_TopolTool)& D1,
122 const Standard_Real TolArc,
123 const Standard_Real TolTang)
127 if(myFleche == 0.0) myFleche = 0.01;
128 if(myUVMaxStep==0.0) myUVMaxStep = 0.01;
130 done = Standard_True;
134 empt = Standard_True;
135 tgte = Standard_False;
136 oppo = Standard_False;
138 switch (S1->GetType())
141 case GeomAbs_Cylinder:
144 case GeomAbs_Torus: break;
147 IntPatch_PrmPrmIntersection interpp;
148 interpp.Perform(S1,D1,TolArc,TolTang,myFleche,myUVMaxStep);
149 if (interpp.IsDone())
151 done = Standard_True;
152 tgte = Standard_False;
153 empt = interpp.IsEmpty();
154 const Standard_Integer nblm = interpp.NbLines();
155 for (Standard_Integer i=1; i<=nblm; i++) slin.Append(interpp.Line(i));
162 /////////////////////////////////////////////////////////////////////////////
163 // These several support functions provide methods which can help basic //
164 // algorithm to intersect infinite surfaces of the following types: //
166 // a.) SurfaceOfExtrusion; //
167 // b.) SurfaceOfRevolution; //
168 // c.) OffsetSurface. //
170 /////////////////////////////////////////////////////////////////////////////
171 #include <TColgp_Array1OfXYZ.hxx>
172 #include <TColgp_Array1OfPnt.hxx>
173 #include <TColgp_SequenceOfPnt.hxx>
174 #include <Extrema_ExtPS.hxx>
175 #include <Extrema_POnSurf.hxx>
176 #include <Geom2d_Curve.hxx>
177 #include <Geom2dAPI_InterCurveCurve.hxx>
178 #include <GeomAdaptor.hxx>
179 #include <GeomAdaptor_HCurve.hxx>
180 #include <GeomAdaptor_Curve.hxx>
181 #include <GeomAdaptor_Surface.hxx>
182 #include <Handle_GeomAdaptor_HSurface.hxx>
183 #include <Geom_Plane.hxx>
184 #include <ProjLib_ProjectOnPlane.hxx>
185 #include <GeomProjLib.hxx>
186 #include <ElCLib.hxx>
187 #include <Geom_TrimmedCurve.hxx>
188 #include <Geom_Surface.hxx>
189 #include <Geom_SurfaceOfLinearExtrusion.hxx>
190 #include <Geom_OffsetSurface.hxx>
191 #include <Geom_SurfaceOfRevolution.hxx>
192 #include <Geom_RectangularTrimmedSurface.hxx>
194 //===============================================================
195 //function: FUN_GetMinMaxXYZPnt
196 //===============================================================
197 static void FUN_GetMinMaxXYZPnt( const Handle(Adaptor3d_HSurface)& S,
198 gp_Pnt& pMin, gp_Pnt& pMax )
200 const Standard_Real DU = 0.25 * Abs(S->LastUParameter() - S->FirstUParameter());
201 const Standard_Real DV = 0.25 * Abs(S->LastVParameter() - S->FirstVParameter());
202 Standard_Real tMinXYZ = RealLast();
203 Standard_Real tMaxXYZ = -tMinXYZ;
204 gp_Pnt PUV, ptMax, ptMin;
205 for(Standard_Real U = S->FirstUParameter(); U <= S->LastUParameter(); U += DU)
207 for(Standard_Real V = S->FirstVParameter(); V <= S->LastVParameter(); V += DV)
210 const Standard_Real cXYZ = PUV.XYZ().Modulus();
211 if(cXYZ > tMaxXYZ) { tMaxXYZ = cXYZ; ptMax = PUV; }
212 if(cXYZ < tMinXYZ) { tMinXYZ = cXYZ; ptMin = PUV; }
218 //==========================================================================
219 //function: FUN_TrimInfSurf
220 //==========================================================================
221 static void FUN_TrimInfSurf(const gp_Pnt& Pmin,
223 const Handle(Adaptor3d_HSurface)& InfSurf,
224 const Standard_Real& AlternativeTrimPrm,
225 Handle(Adaptor3d_HSurface)& TrimS)
227 Standard_Real TP = AlternativeTrimPrm;
228 Extrema_ExtPS ext1(Pmin, InfSurf->Surface(), 1.e-7, 1.e-7);
229 Extrema_ExtPS ext2(Pmax, InfSurf->Surface(), 1.e-7, 1.e-7);
230 if(ext1.IsDone() || ext2.IsDone())
232 Standard_Real Umax = -1.e+100, Umin = 1.e+100, Vmax = -1.e+100, Vmin = 1.e+100, cU, cV;
235 for(Standard_Integer i = 1; i <= ext1.NbExt(); i++)
237 const Extrema_POnSurf & pons = ext1.Point(i);
238 pons.Parameter(cU,cV);
239 if(cU > Umax) Umax = cU;
240 if(cU < Umin) Umin = cU;
241 if(cV > Vmax) Vmax = cV;
242 if(cV < Vmin) Vmin = cV;
247 for(Standard_Integer i = 1; i <= ext2.NbExt(); i++)
249 const Extrema_POnSurf & pons = ext2.Point(i);
250 pons.Parameter(cU,cV);
251 if(cU > Umax) Umax = cU;
252 if(cU < Umin) Umin = cU;
253 if(cV > Vmax) Vmax = cV;
254 if(cV < Vmin) Vmin = cV;
257 TP = Max(Abs(Umin),Max(Abs(Umax),Max(Abs(Vmin),Abs(Vmax))));
259 if(TP == 0.) { TrimS = InfSurf; return; }
262 const Standard_Boolean Uinf = Precision::IsNegativeInfinite(InfSurf->FirstUParameter());
263 const Standard_Boolean Usup = Precision::IsPositiveInfinite(InfSurf->LastUParameter());
264 const Standard_Boolean Vinf = Precision::IsNegativeInfinite(InfSurf->FirstVParameter());
265 const Standard_Boolean Vsup = Precision::IsPositiveInfinite(InfSurf->LastVParameter());
266 Handle(Adaptor3d_HSurface) TmpSS;
267 Standard_Integer IsTrimed = 0;
268 const Standard_Real tp = 1000.0 * TP;
269 if(Vinf && Vsup) { TrimS = InfSurf->VTrim(-tp, tp, 1.0e-7); IsTrimed = 1; }
270 if(Vinf && !Vsup){ TrimS = InfSurf->VTrim(-tp, InfSurf->LastVParameter(), 1.0e-7); IsTrimed = 1; }
271 if(!Vinf && Vsup){ TrimS = InfSurf->VTrim(InfSurf->FirstVParameter(), tp, 1.0e-7); IsTrimed = 1; }
275 if(Uinf && Usup) TrimS = TmpSS->UTrim(-tp, tp, 1.0e-7);
276 if(Uinf && !Usup) TrimS = TmpSS->UTrim(-tp, InfSurf->LastUParameter(), 1.0e-7);
277 if(!Uinf && Usup) TrimS = TmpSS->UTrim(InfSurf->FirstUParameter(), tp, 1.0e-7);
281 if(Uinf && Usup) TrimS = InfSurf->UTrim(-tp, tp, 1.0e-7);
282 if(Uinf && !Usup) TrimS = InfSurf->UTrim(-tp, InfSurf->LastUParameter(), 1.0e-7);
283 if(!Uinf && Usup) TrimS = InfSurf->UTrim(InfSurf->FirstUParameter(), tp, 1.0e-7);
287 //================================================================================
288 //function: FUN_GetUiso
289 //================================================================================
290 static void FUN_GetUiso(const Handle(Geom_Surface)& GS,
291 const GeomAbs_SurfaceType& T,
292 const Standard_Real& FirstV,
293 const Standard_Real& LastV,
294 const Standard_Boolean& IsVC,
295 const Standard_Boolean& IsVP,
296 const Standard_Real& U,
297 Handle(Geom_Curve)& I)
299 if(T != GeomAbs_OffsetSurface)
301 Handle(Geom_Curve) gc = GS->UIso(U);
302 if(IsVP && (FirstV == 0.0 && LastV == (2.*M_PI))) I = gc;
305 Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstV,LastV);
306 //szv:I = Handle(Geom_Curve)::DownCast(gtc);
312 const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&GS;
313 const Handle(Geom_Surface) bs = gos->BasisSurface();
314 Handle(Geom_Curve) gcbs = bs->UIso(U);
315 GeomAdaptor_Curve gac(gcbs);
316 const GeomAbs_CurveType GACT = gac.GetType();
317 if(IsVP || IsVC || GACT == GeomAbs_BSplineCurve || GACT == GeomAbs_BezierCurve || Abs(LastV - FirstV) < 1.e+5)
319 Handle(Geom_Curve) gc = gos->UIso(U);
320 if(IsVP && (FirstV == 0.0 && LastV == (2*M_PI))) I = gc;
323 Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstV,LastV);
324 //szv:I = Handle(Geom_Curve)::DownCast(gtc);
328 else//Offset Line, Parab, Hyperb
330 Standard_Real VmTr, VMTr;
331 if(GACT != GeomAbs_Hyperbola)
333 if(FirstV >= 0. && LastV >= 0.){ VmTr = FirstV; VMTr = ((LastV - FirstV) > 1.e+4) ? (FirstV + 1.e+4) : LastV; }
334 else if(FirstV < 0. && LastV < 0.){ VMTr = LastV; VmTr = ((FirstV - LastV) < -1.e+4) ? (LastV - 1.e+4) : FirstV; }
335 else { VmTr = (FirstV < -1.e+4) ? -1.e+4 : FirstV; VMTr = (LastV > 1.e+4) ? 1.e+4 : LastV; }
339 if(FirstV >= 0. && LastV >= 0.)
341 if(FirstV > 4.) return;
342 VmTr = FirstV; VMTr = (LastV > 4.) ? 4. : LastV;
344 else if(FirstV < 0. && LastV < 0.)
346 if(LastV < -4.) return;
347 VMTr = LastV; VmTr = (FirstV < -4.) ? -4. : FirstV;
349 else { VmTr = (FirstV < -4.) ? -4. : FirstV; VMTr = (LastV > 4.) ? 4. : LastV; }
351 //Make trimmed surface
352 Handle(Geom_RectangularTrimmedSurface) rts = new Geom_RectangularTrimmedSurface(gos,VmTr,VMTr,Standard_True);
357 //================================================================================
358 //function: FUN_GetViso
359 //================================================================================
360 static void FUN_GetViso(const Handle(Geom_Surface)& GS,
361 const GeomAbs_SurfaceType& T,
362 const Standard_Real& FirstU,
363 const Standard_Real& LastU,
364 const Standard_Boolean& IsUC,
365 const Standard_Boolean& IsUP,
366 const Standard_Real& V,
367 Handle(Geom_Curve)& I)
369 if(T != GeomAbs_OffsetSurface)
371 Handle(Geom_Curve) gc = GS->VIso(V);
372 if(IsUP && (FirstU == 0.0 && LastU == (2*M_PI))) I = gc;
375 Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstU,LastU);
376 //szv:I = Handle(Geom_Curve)::DownCast(gtc);
382 const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&GS;
383 const Handle(Geom_Surface) bs = gos->BasisSurface();
384 Handle(Geom_Curve) gcbs = bs->VIso(V);
385 GeomAdaptor_Curve gac(gcbs);
386 const GeomAbs_CurveType GACT = gac.GetType();
387 if(IsUP || IsUC || GACT == GeomAbs_BSplineCurve || GACT == GeomAbs_BezierCurve || Abs(LastU - FirstU) < 1.e+5)
389 Handle(Geom_Curve) gc = gos->VIso(V);
390 if(IsUP && (FirstU == 0.0 && LastU == (2*M_PI))) I = gc;
393 Handle(Geom_TrimmedCurve) gtc = new Geom_TrimmedCurve(gc,FirstU,LastU);
394 //szv:I = Handle(Geom_Curve)::DownCast(gtc);
398 else//Offset Line, Parab, Hyperb
400 Standard_Real UmTr, UMTr;
401 if(GACT != GeomAbs_Hyperbola)
403 if(FirstU >= 0. && LastU >= 0.){ UmTr = FirstU; UMTr = ((LastU - FirstU) > 1.e+4) ? (FirstU + 1.e+4) : LastU; }
404 else if(FirstU < 0. && LastU < 0.){ UMTr = LastU; UmTr = ((FirstU - LastU) < -1.e+4) ? (LastU - 1.e+4) : FirstU; }
405 else { UmTr = (FirstU < -1.e+4) ? -1.e+4 : FirstU; UMTr = (LastU > 1.e+4) ? 1.e+4 : LastU; }
409 if(FirstU >= 0. && LastU >= 0.)
411 if(FirstU > 4.) return;
412 UmTr = FirstU; UMTr = (LastU > 4.) ? 4. : LastU;
414 else if(FirstU < 0. && LastU < 0.)
416 if(LastU < -4.) return;
417 UMTr = LastU; UmTr = (FirstU < -4.) ? -4. : FirstU;
419 else { UmTr = (FirstU < -4.) ? -4. : FirstU; UMTr = (LastU > 4.) ? 4. : LastU; }
421 //Make trimmed surface
422 Handle(Geom_RectangularTrimmedSurface) rts = new Geom_RectangularTrimmedSurface(gos,UmTr,UMTr,Standard_True);
427 //================================================================================
428 //function: FUN_PL_Intersection
429 //================================================================================
430 static void FUN_PL_Intersection(const Handle(Adaptor3d_HSurface)& S1,
431 const GeomAbs_SurfaceType& T1,
432 const Handle(Adaptor3d_HSurface)& S2,
433 const GeomAbs_SurfaceType& T2,
434 Standard_Boolean& IsOk,
435 TColgp_SequenceOfPnt& SP,
438 IsOk = Standard_False;
439 // 1. Check: both surfaces have U(V)isos - lines.
440 DV = gp_Vec(0.,0.,1.);
441 Standard_Boolean isoS1isLine[2] = {0, 0};
442 Standard_Boolean isoS2isLine[2] = {0, 0};
443 Handle(Geom_Curve) C1, C2;
444 const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(&(S1->Surface()));
445 const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(&(S2->Surface()));
446 const Handle(Geom_Surface) gs1 = gas1.Surface();
447 const Handle(Geom_Surface) gs2 = gas2.Surface();
448 Standard_Real MS1[2], MS2[2];
449 MS1[0] = 0.5 * (S1->LastUParameter() + S1->FirstUParameter());
450 MS1[1] = 0.5 * (S1->LastVParameter() + S1->FirstVParameter());
451 MS2[0] = 0.5 * (S2->LastUParameter() + S2->FirstUParameter());
452 MS2[1] = 0.5 * (S2->LastVParameter() + S2->FirstVParameter());
453 if(T1 == GeomAbs_SurfaceOfExtrusion) isoS1isLine[0] = Standard_True;
454 else if(!S1->IsVPeriodic() && !S1->IsVClosed()) {
455 if(T1 != GeomAbs_OffsetSurface) C1 = gs1->UIso(MS1[0]);
457 const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
458 const Handle(Geom_Surface) bs = gos->BasisSurface();
459 C1 = bs->UIso(MS1[0]);
461 GeomAdaptor_Curve gac(C1);
462 if(gac.GetType() == GeomAbs_Line) isoS1isLine[0] = Standard_True;
464 if(!S1->IsUPeriodic() && !S1->IsUClosed()) {
465 if(T1 != GeomAbs_OffsetSurface) C1 = gs1->VIso(MS1[1]);
467 const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
468 const Handle(Geom_Surface) bs = gos->BasisSurface();
469 C1 = bs->VIso(MS1[1]);
471 GeomAdaptor_Curve gac(C1);
472 if(gac.GetType() == GeomAbs_Line) isoS1isLine[1] = Standard_True;
474 if(T2 == GeomAbs_SurfaceOfExtrusion) isoS2isLine[0] = Standard_True;
475 else if(!S2->IsVPeriodic() && !S2->IsVClosed()) {
476 if(T2 != GeomAbs_OffsetSurface) C2 = gs2->UIso(MS2[0]);
478 const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
479 const Handle(Geom_Surface) bs = gos->BasisSurface();
480 C2 = bs->UIso(MS2[0]);
482 GeomAdaptor_Curve gac(C2);
483 if(gac.GetType() == GeomAbs_Line) isoS2isLine[0] = Standard_True;
485 if(!S2->IsUPeriodic() && !S2->IsUClosed()) {
486 if(T2 != GeomAbs_OffsetSurface) C2 = gs2->VIso(MS2[1]);
488 const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
489 const Handle(Geom_Surface) bs = gos->BasisSurface();
490 C2 = bs->VIso(MS2[1]);
492 GeomAdaptor_Curve gac(C2);
493 if(gac.GetType() == GeomAbs_Line) isoS2isLine[1] = Standard_True;
495 Standard_Boolean IsBothLines = ((isoS1isLine[0] || isoS1isLine[1]) &&
496 (isoS2isLine[0] || isoS2isLine[1]));
500 // 2. Check: Uiso lines of both surfaces are collinear.
502 gp_Vec derS1[2], derS2[2];
503 S1->D1(MS1[0], MS1[1], puvS1, derS1[0], derS1[1]);
504 S2->D1(MS2[0], MS2[1], puvS2, derS2[0], derS2[1]);
505 C1.Nullify(); C2.Nullify();
506 Standard_Integer iso = 0;
507 if(isoS1isLine[0] && isoS2isLine[0] &&
508 derS1[1].IsParallel(derS2[1],Precision::Angular())) {
510 FUN_GetViso(gs1,T1,S1->FirstUParameter(),S1->LastUParameter(),
511 S1->IsUClosed(),S1->IsUPeriodic(),MS1[1],C1);
512 FUN_GetViso(gs2,T2,S2->FirstUParameter(),S2->LastUParameter(),
513 S2->IsUClosed(),S2->IsUPeriodic(),MS2[1],C2);
515 else if(isoS1isLine[0] && isoS2isLine[1] &&
516 derS1[1].IsParallel(derS2[0],Precision::Angular())) {
518 FUN_GetViso(gs1,T1,S1->FirstUParameter(),S1->LastUParameter(),
519 S1->IsUClosed(),S1->IsUPeriodic(),MS1[1],C1);
520 FUN_GetUiso(gs2,T2,S2->FirstVParameter(),S2->LastVParameter(),
521 S2->IsVClosed(),S2->IsVPeriodic(),MS2[0],C2);
523 else if(isoS1isLine[1] && isoS2isLine[0] &&
524 derS1[0].IsParallel(derS2[1],Precision::Angular())) {
526 FUN_GetUiso(gs1,T1,S1->FirstVParameter(),S1->LastVParameter(),
527 S1->IsVClosed(),S1->IsVPeriodic(),MS1[0],C1);
528 FUN_GetViso(gs2,T2,S2->FirstUParameter(),S2->LastUParameter(),
529 S2->IsUClosed(),S2->IsUPeriodic(),MS2[1],C2);
531 else if(isoS1isLine[1] && isoS2isLine[1] &&
532 derS1[0].IsParallel(derS2[0],Precision::Angular())) {
534 FUN_GetUiso(gs1,T1,S1->FirstVParameter(),S1->LastVParameter(),
535 S1->IsVClosed(),S1->IsVPeriodic(),MS1[0],C1);
536 FUN_GetUiso(gs2,T2,S2->FirstVParameter(),S2->LastVParameter(),
537 S2->IsVClosed(),S2->IsVPeriodic(),MS2[0],C2);
540 IsOk = Standard_False;
543 IsOk = Standard_True;
544 // 3. Make intersections of V(U)isos
545 if(C1.IsNull() || C2.IsNull()) return;
547 Handle(Geom_Plane) GPln = new Geom_Plane(gp_Pln(puvS1,gp_Dir(DV)));
548 Handle(Geom_Curve) C1Prj =
549 GeomProjLib::ProjectOnPlane(C1,GPln,gp_Dir(DV),Standard_True);
550 Handle(Geom_Curve) C2Prj =
551 GeomProjLib::ProjectOnPlane(C2,GPln,gp_Dir(DV),Standard_True);
552 if(C1Prj.IsNull() || C2Prj.IsNull()) return;
553 Handle(Geom2d_Curve) C1Prj2d =
554 GeomProjLib::Curve2d(C1Prj,*(Handle_Geom_Surface *)&GPln);
555 Handle(Geom2d_Curve) C2Prj2d =
556 GeomProjLib::Curve2d(C2Prj,*(Handle_Geom_Surface *)&GPln);
557 Geom2dAPI_InterCurveCurve ICC(C1Prj2d,C2Prj2d,1.0e-7);
558 if(ICC.NbPoints() > 0 )
560 for(Standard_Integer ip = 1; ip <= ICC.NbPoints(); ip++)
562 gp_Pnt2d P = ICC.Point(ip);
563 gp_Pnt P3d = ElCLib::To3d(gp_Ax2(puvS1,gp_Dir(DV)),P);
568 //================================================================================
569 //function: FUN_NewFirstLast
570 //================================================================================
571 static void FUN_NewFirstLast(const GeomAbs_CurveType& ga_ct,
572 const Standard_Real& Fst,
573 const Standard_Real& Lst,
574 const Standard_Real& TrVal,
575 Standard_Real& NewFst,
576 Standard_Real& NewLst,
577 Standard_Boolean& NeedTr)
579 NewFst = Fst; NewLst = Lst; NeedTr = Standard_False;
583 case GeomAbs_Parabola:
585 if(Abs(Lst - Fst) > TrVal)
587 if(Fst >= 0. && Lst >= 0.)
590 NewLst = ((Fst + TrVal) < Lst) ? (Fst + TrVal) : Lst;
592 if(Fst < 0. && Lst < 0.)
595 NewFst = ((Lst - TrVal) > Fst) ? (Lst - TrVal) : Fst;
599 NewFst = (Fst < -TrVal) ? -TrVal : Fst;
600 NewLst = (Lst > TrVal) ? TrVal : Lst;
602 NeedTr = Standard_True;
606 case GeomAbs_Hyperbola:
608 if(Abs(Lst - Fst) > 10.)
610 if(Fst >= 0. && Lst >= 0.)
614 NewLst = (Lst > 4.) ? 4. : Lst;
616 if(Fst < 0. && Lst < 0.)
618 if(Lst < -4.) return;
620 NewFst = (Fst < -4.) ? -4. : Fst;
624 NewFst = (Fst < -4.) ? -4. : Fst;
625 NewLst = (Lst > 4.) ? 4. : Lst;
627 NeedTr = Standard_True;
635 //================================================================================
636 //function: FUN_TrimBothSurf
637 //================================================================================
638 static void FUN_TrimBothSurf(const Handle(Adaptor3d_HSurface)& S1,
639 const GeomAbs_SurfaceType& T1,
640 const Handle(Adaptor3d_HSurface)& S2,
641 const GeomAbs_SurfaceType& T2,
642 const Standard_Real& TV,
643 Handle(Adaptor3d_HSurface)& NS1,
644 Handle(Adaptor3d_HSurface)& NS2)
646 const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(&(S1->Surface()));
647 const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(&(S2->Surface()));
648 const Handle(Geom_Surface) gs1 = gas1.Surface();
649 const Handle(Geom_Surface) gs2 = gas2.Surface();
650 const Standard_Real UM1 = 0.5 * (S1->LastUParameter() + S1->FirstUParameter());
651 const Standard_Real UM2 = 0.5 * (S2->LastUParameter() + S2->FirstUParameter());
652 const Standard_Real VM1 = 0.5 * (S1->LastVParameter() + S1->FirstVParameter());
653 const Standard_Real VM2 = 0.5 * (S2->LastVParameter() + S2->FirstVParameter());
654 Handle(Geom_Curve) visoS1, visoS2, uisoS1, uisoS2;
655 if(T1 != GeomAbs_OffsetSurface){ visoS1 = gs1->VIso(VM1); uisoS1 = gs1->UIso(UM1); }
658 const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs1;
659 const Handle(Geom_Surface) bs = gos->BasisSurface();
660 visoS1 = bs->VIso(VM1); uisoS1 = bs->UIso(UM1);
662 if(T2 != GeomAbs_OffsetSurface){ visoS2 = gs2->VIso(VM2); uisoS2 = gs2->UIso(UM2); }
665 const Handle(Geom_OffsetSurface) gos = *(Handle_Geom_OffsetSurface*)&gs2;
666 const Handle(Geom_Surface) bs = gos->BasisSurface();
667 visoS2 = bs->VIso(VM2); uisoS2 = bs->UIso(UM2);
669 if(uisoS1.IsNull() || uisoS2.IsNull() || visoS1.IsNull() || visoS2.IsNull()){ NS1 = S1; NS2 = S2; return; }
670 GeomAdaptor_Curve gau1(uisoS1);
671 GeomAdaptor_Curve gav1(visoS1);
672 GeomAdaptor_Curve gau2(uisoS2);
673 GeomAdaptor_Curve gav2(visoS2);
674 GeomAbs_CurveType GA_U1 = gau1.GetType();
675 GeomAbs_CurveType GA_V1 = gav1.GetType();
676 GeomAbs_CurveType GA_U2 = gau2.GetType();
677 GeomAbs_CurveType GA_V2 = gav2.GetType();
678 Standard_Boolean TrmU1 = Standard_False;
679 Standard_Boolean TrmV1 = Standard_False;
680 Standard_Boolean TrmU2 = Standard_False;
681 Standard_Boolean TrmV2 = Standard_False;
682 Standard_Real V1S1,V2S1,U1S1,U2S1, V1S2,V2S2,U1S2,U2S2;
683 FUN_NewFirstLast(GA_U1,S1->FirstVParameter(),S1->LastVParameter(),TV,V1S1,V2S1,TrmV1);
684 FUN_NewFirstLast(GA_V1,S1->FirstUParameter(),S1->LastUParameter(),TV,U1S1,U2S1,TrmU1);
685 FUN_NewFirstLast(GA_U2,S2->FirstVParameter(),S2->LastVParameter(),TV,V1S2,V2S2,TrmV2);
686 FUN_NewFirstLast(GA_V2,S2->FirstUParameter(),S2->LastUParameter(),TV,U1S2,U2S2,TrmU2);
687 if(TrmV1) NS1 = S1->VTrim(V1S1, V2S1, 1.0e-7);
688 if(TrmV2) NS2 = S2->VTrim(V1S2, V2S2, 1.0e-7);
693 Handle(Adaptor3d_HSurface) TS = NS1;
694 NS1 = TS->UTrim(U1S1, U2S1, 1.0e-7);
696 else NS1 = S1->UTrim(U1S1, U2S1, 1.0e-7);
702 Handle(Adaptor3d_HSurface) TS = NS2;
703 NS2 = TS->UTrim(U1S2, U2S2, 1.0e-7);
705 else NS2 = S2->UTrim(U1S2, U2S2, 1.0e-7);
709 //=======================================================================
712 //=======================================================================
713 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
714 const Handle(Adaptor3d_TopolTool)& theD1,
715 const Handle(Adaptor3d_HSurface)& theS2,
716 const Handle(Adaptor3d_TopolTool)& theD2,
717 const Standard_Real TolArc,
718 const Standard_Real TolTang,
719 const Standard_Boolean isGeomInt)
723 if(myFleche <= Precision::PConfusion())
725 if(myUVMaxStep <= Precision::PConfusion())
728 done = Standard_False;
731 empt = Standard_True;
732 tgte = Standard_False;
733 oppo = Standard_False;
735 GeomAbs_SurfaceType typs1 = theS1->GetType();
736 GeomAbs_SurfaceType typs2 = theS2->GetType();
738 Standard_Boolean TreatAsBiParametric = Standard_False;
739 if(typs1 == GeomAbs_Cone)
741 const gp_Cone Con1 = theS1->Cone();
742 const Standard_Real a1 = Abs(Con1.SemiAngle());
743 if((a1 < 0.02) || (a1 > 1.55))
745 if(typs2==GeomAbs_Plane)
749 const gp_Pln Plan2 = theS2->Plane();
750 const gp_Dir axec = Con1.Axis().Direction();
751 const gp_Dir axep = Plan2.Axis().Direction();
752 const Standard_Real ps = Abs(axec.Dot(axep));
755 TreatAsBiParametric = Standard_True;
760 TreatAsBiParametric = Standard_True;
764 if(typs2 == GeomAbs_Cone)
766 const gp_Cone Con2 = theS2->Cone();
767 const Standard_Real a2 = Abs(Con2.SemiAngle());
768 if((a2 < 0.02) || (a2 > 1.55))
770 if(typs1 == GeomAbs_Plane)
774 const gp_Pln Plan1 = theS1->Plane();
775 const gp_Dir axec = Con2.Axis().Direction();
776 const gp_Dir axep = Plan1.Axis().Direction();
777 const Standard_Real ps = Abs(axec.Dot(axep));
780 TreatAsBiParametric = Standard_True;
785 TreatAsBiParametric = Standard_True;
788 //// modified by jgv, 15.12.02 for OCC565 ////
789 if (typs1 == GeomAbs_Cone && TreatAsBiParametric)
791 const gp_Cone Con1 = theS1->Cone();
792 const Standard_Real a1 = Abs(Con1.SemiAngle());
793 //if collinear, treat as canonical
794 const gp_Ax1 A1 = Con1.Axis(), A2 = Con2.Axis();
796 if (A1.IsParallel(A2,Precision::Angular()) &&
797 (L1.Distance(A2.Location()) <= Precision::Confusion()))
799 TreatAsBiParametric = Standard_False;
801 else if (a1 > 1.55 && a2 > 1.55) //quasi-planes: if same domain, treat as canonic
803 const gp_Ax1 A1 = Con1.Axis(), A2 = Con2.Axis();
804 if (A1.IsParallel(A2,Precision::Angular()))
806 const gp_Pnt Apex1 = Con1.Apex(), Apex2 = Con2.Apex();
807 const gp_Pln Plan1( Apex1, A1.Direction() );
808 if (Plan1.Distance( Apex2 ) <= Precision::Confusion())
810 TreatAsBiParametric = Standard_False;
814 }// if (typs1 == GeomAbs_Cone) {
815 }// if(typs2 == GeomAbs_Cone) {
817 if(theD1->DomainIsInfinite() || theD2->DomainIsInfinite()) {
818 TreatAsBiParametric= Standard_False;
821 // Modified by skv - Mon Sep 26 14:58:30 2005 Begin
822 // if(TreatAsBiParametric) { typs1 = typs2 = GeomAbs_BezierSurface; }
823 if(TreatAsBiParametric)
825 if (typs1 == GeomAbs_Cone && typs2 == GeomAbs_Plane)
826 typs1 = GeomAbs_BezierSurface; // Using Imp-Prm Intersector
827 else if (typs1 == GeomAbs_Plane && typs2 == GeomAbs_Cone)
828 typs2 = GeomAbs_BezierSurface; // Using Imp-Prm Intersector
830 // Using Prm-Prm Intersector
831 typs1 = GeomAbs_BezierSurface;
832 typs2 = GeomAbs_BezierSurface;
835 // Modified by skv - Mon Sep 26 14:58:30 2005 End
837 // Surface type definition
838 Standard_Integer ts1 = 0;
842 case GeomAbs_Cylinder:
844 case GeomAbs_Cone: ts1 = 1; break;
848 Standard_Integer ts2 = 0;
852 case GeomAbs_Cylinder:
854 case GeomAbs_Cone: ts2 = 1; break;
858 // Possible intersection types: 1. ts1 == ts2 == 1 <Geom-Geom>
859 // 2. ts1 != ts2 <Geom-Param>
860 // 3. ts1 == ts2 == 0 <Param-Param>
863 if(ts1 == ts2 && ts1 == 1)
865 const Standard_Boolean RestrictLine = Standard_True;
866 IntSurf_ListOfPntOn2S ListOfPnts;
870 GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
874 ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
881 GeomParamPerfom(theS1, theD1, theS2, theD2, ts1 == 0, typs1, typs2);
885 if(ts1 == ts2 && ts1 == 0)
887 const Standard_Boolean RestrictLine = Standard_True;
888 IntSurf_ListOfPntOn2S ListOfPnts;
891 ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
895 //=======================================================================
898 //=======================================================================
899 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
900 const Handle(Adaptor3d_TopolTool)& theD1,
901 const Handle(Adaptor3d_HSurface)& theS2,
902 const Handle(Adaptor3d_TopolTool)& theD2,
903 const Standard_Real TolArc,
904 const Standard_Real TolTang,
905 IntSurf_ListOfPntOn2S& ListOfPnts,
906 const Standard_Boolean RestrictLine,
907 const Standard_Boolean isGeomInt)
911 if(myFleche <= Precision::PConfusion())
913 if(myUVMaxStep <= Precision::PConfusion())
916 done = Standard_False;
919 empt = Standard_True;
920 tgte = Standard_False;
921 oppo = Standard_False;
923 GeomAbs_SurfaceType typs1 = theS1->GetType();
924 GeomAbs_SurfaceType typs2 = theS2->GetType();
926 Standard_Boolean TreatAsBiParametric = Standard_False;
927 if(typs1 == GeomAbs_Cone)
929 const gp_Cone Con1 = theS1->Cone();
930 const Standard_Real a1 = Abs(Con1.SemiAngle());
931 if((a1 < 0.02) || (a1 > 1.55))
933 if(typs2==GeomAbs_Plane)
937 const gp_Pln Plan2 = theS2->Plane();
938 const gp_Dir axec = Con1.Axis().Direction();
939 const gp_Dir axep = Plan2.Axis().Direction();
940 const Standard_Real ps = Abs(axec.Dot(axep));
943 TreatAsBiParametric = Standard_True;
948 TreatAsBiParametric = Standard_True;
952 if(typs2 == GeomAbs_Cone)
954 const gp_Cone Con2 = theS2->Cone();
955 const Standard_Real a2 = Abs(Con2.SemiAngle());
956 if((a2 < 0.02) || (a2 > 1.55))
958 if(typs1 == GeomAbs_Plane)
962 const gp_Pln Plan1 = theS1->Plane();
963 const gp_Dir axec = Con2.Axis().Direction();
964 const gp_Dir axep = Plan1.Axis().Direction();
965 const Standard_Real ps = Abs(axec.Dot(axep));
968 TreatAsBiParametric = Standard_True;
973 TreatAsBiParametric = Standard_True;
976 //// modified by jgv, 15.12.02 for OCC565 ////
977 if (typs1 == GeomAbs_Cone && TreatAsBiParametric)
979 const gp_Cone Con1 = theS1->Cone();
980 const Standard_Real a1 = Abs(Con1.SemiAngle());
981 //if collinear, treat as canonical
982 const gp_Ax1 A1 = Con1.Axis(), A2 = Con2.Axis();
984 if (A1.IsParallel(A2,Precision::Angular()) &&
985 (L1.Distance(A2.Location()) <= Precision::Confusion()))
987 TreatAsBiParametric = Standard_False;
989 else if (a1 > 1.55 && a2 > 1.55) //quasi-planes: if same domain, treat as canonic
991 const gp_Ax1 A1 = Con1.Axis(), A2 = Con2.Axis();
992 if (A1.IsParallel(A2,Precision::Angular()))
994 const gp_Pnt Apex1 = Con1.Apex(), Apex2 = Con2.Apex();
995 const gp_Pln Plan1( Apex1, A1.Direction() );
996 if (Plan1.Distance( Apex2 ) <= Precision::Confusion())
998 TreatAsBiParametric = Standard_False;
1002 }// if (typs1 == GeomAbs_Cone) {
1003 }// if(typs2 == GeomAbs_Cone) {
1005 if(theD1->DomainIsInfinite() || theD2->DomainIsInfinite()) {
1006 TreatAsBiParametric= Standard_False;
1009 if(TreatAsBiParametric)
1011 // Using Prm-Prm Intersector
1012 typs1 = GeomAbs_BezierSurface;
1013 typs2 = GeomAbs_BezierSurface;
1016 // Surface type definition
1017 Standard_Integer ts1 = 0;
1021 case GeomAbs_Cylinder:
1022 case GeomAbs_Sphere:
1023 case GeomAbs_Cone: ts1 = 1; break;
1027 Standard_Integer ts2 = 0;
1031 case GeomAbs_Cylinder:
1032 case GeomAbs_Sphere:
1033 case GeomAbs_Cone: ts2 = 1; break;
1037 // Possible intersection types: 1. ts1 == ts2 == 1 <Geom-Geom>
1038 // 2. ts1 != ts2 <Geom-Param>
1039 // 3. ts1 == ts2 == 0 <Param-Param>
1043 ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
1047 GeomParamPerfom(theS1, theD1, theS2, theD2, ts1 == 0, typs1, typs2);
1051 ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
1055 GeomGeomPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
1059 //=======================================================================
1060 //function : ParamParamPerfom
1062 //=======================================================================
1063 void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_HSurface)& theS1,
1064 const Handle(Adaptor3d_TopolTool)& theD1,
1065 const Handle(Adaptor3d_HSurface)& theS2,
1066 const Handle(Adaptor3d_TopolTool)& theD2,
1067 const Standard_Real TolArc,
1068 const Standard_Real TolTang,
1069 IntSurf_ListOfPntOn2S& ListOfPnts,
1070 const Standard_Boolean RestrictLine,
1071 const GeomAbs_SurfaceType typs1,
1072 const GeomAbs_SurfaceType typs2)
1074 IntPatch_PrmPrmIntersection interpp;
1075 if(!theD1->DomainIsInfinite() && !theD2->DomainIsInfinite())
1077 Standard_Boolean ClearFlag = Standard_True;
1078 if(!ListOfPnts.IsEmpty())
1080 interpp.Perform(theS1,theD1,theS2,theD2,TolArc,TolTang,myFleche,myUVMaxStep, ListOfPnts, RestrictLine);
1081 ClearFlag = Standard_False;
1083 interpp.Perform(theS1,theD1,theS2,theD2,TolArc,TolTang,myFleche,myUVMaxStep,ClearFlag); //double call!!!!!!!
1085 else if((theD1->DomainIsInfinite()) ^ (theD2->DomainIsInfinite()))
1087 gp_Pnt pMaxXYZ, pMinXYZ;
1088 if(theD1->DomainIsInfinite())
1090 FUN_GetMinMaxXYZPnt( theS2, pMinXYZ, pMaxXYZ );
1091 const Standard_Real MU = Max(Abs(theS2->FirstUParameter()),Abs(theS2->LastUParameter()));
1092 const Standard_Real MV = Max(Abs(theS2->FirstVParameter()),Abs(theS2->LastVParameter()));
1093 const Standard_Real AP = Max(MU, MV);
1094 Handle(Adaptor3d_HSurface) SS;
1095 FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS1, AP, SS);
1096 interpp.Perform(SS,theD1,theS2,theD2,TolArc,TolTang,myFleche,myUVMaxStep);
1100 FUN_GetMinMaxXYZPnt( theS1, pMinXYZ, pMaxXYZ );
1101 const Standard_Real MU = Max(Abs(theS1->FirstUParameter()),Abs(theS1->LastUParameter()));
1102 const Standard_Real MV = Max(Abs(theS1->FirstVParameter()),Abs(theS1->LastVParameter()));
1103 const Standard_Real AP = Max(MU, MV);
1104 Handle(Adaptor3d_HSurface) SS;
1105 FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS2, AP, SS);
1106 interpp.Perform(theS1, theD1, SS, theD2,TolArc,TolTang,myFleche,myUVMaxStep);
1108 }//(theD1->DomainIsInfinite()) ^ (theD2->DomainIsInfinite())
1111 if(typs1 == GeomAbs_OtherSurface || typs2 == GeomAbs_OtherSurface)
1113 done = Standard_False;
1117 Standard_Boolean IsPLInt = Standard_False;
1118 TColgp_SequenceOfPnt sop;
1120 FUN_PL_Intersection(theS1,typs1,theS2,typs2,IsPLInt,sop,v);
1124 if(sop.Length() > 0)
1126 for(Standard_Integer ip = 1; ip <= sop.Length(); ip++)
1128 gp_Lin lin(sop.Value(ip),gp_Dir(v));
1129 Handle(IntPatch_GLine) gl = new IntPatch_GLine(lin,Standard_False);
1130 slin.Append(*(Handle_IntPatch_Line *)&gl);
1133 done = Standard_True;
1136 done = Standard_False;
1139 }// 'COLLINEAR LINES'
1142 Handle(Adaptor3d_HSurface) nS1 = theS1;
1143 Handle(Adaptor3d_HSurface) nS2 = theS2;
1144 FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+8,nS1,nS2);
1145 interpp.Perform(nS1,theD1,nS2,theD2,TolArc,TolTang,myFleche,myUVMaxStep);
1146 }// 'NON - COLLINEAR LINES'
1147 }// both domains are infinite
1149 if (interpp.IsDone())
1151 done = Standard_True;
1152 tgte = Standard_False;
1153 empt = interpp.IsEmpty();
1155 for(Standard_Integer i = 1; i <= interpp.NbLines(); i++)
1157 if(interpp.Line(i)->ArcType() != IntPatch_Walking)
1158 slin.Append(interpp.Line(i));
1161 for (Standard_Integer i = 1; i <= interpp.NbLines(); i++)
1163 if(interpp.Line(i)->ArcType() == IntPatch_Walking)
1164 slin.Append(interpp.Line(i));
1169 //=======================================================================
1170 ////function : GeomGeomPerfom
1172 //=======================================================================
1173 void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& theS1,
1174 const Handle(Adaptor3d_TopolTool)& theD1,
1175 const Handle(Adaptor3d_HSurface)& theS2,
1176 const Handle(Adaptor3d_TopolTool)& theD2,
1177 const Standard_Real TolArc,
1178 const Standard_Real TolTang,
1179 IntSurf_ListOfPntOn2S& ListOfPnts,
1180 const Standard_Boolean RestrictLine,
1181 const GeomAbs_SurfaceType typs1,
1182 const GeomAbs_SurfaceType typs2)
1184 IntPatch_ImpImpIntersection interii(theS1,theD1,theS2,theD2,myTolArc,myTolTang);
1185 const Standard_Boolean anIS = interii.IsDone();
1189 empt = interii.IsEmpty();
1192 tgte = interii.TangentFaces();
1194 oppo = interii.OppositeFaces();
1196 for (Standard_Integer i = 1; i <= interii.NbLines(); i++)
1198 const Handle_IntPatch_Line& line = interii.Line(i);
1199 if (line->ArcType() == IntPatch_Analytic)
1201 const GeomAbs_SurfaceType typs1 = theS1->GetType();
1202 const GeomAbs_SurfaceType typs2 = theS2->GetType();
1203 IntSurf_Quadric Quad1,Quad2;
1208 Quad1.SetValue(theS1->Plane());
1211 case GeomAbs_Cylinder:
1212 Quad1.SetValue(theS1->Cylinder());
1215 case GeomAbs_Sphere:
1216 Quad1.SetValue(theS1->Sphere());
1220 Quad1.SetValue(theS1->Cone());
1230 Quad2.SetValue(theS2->Plane());
1232 case GeomAbs_Cylinder:
1233 Quad2.SetValue(theS2->Cylinder());
1236 case GeomAbs_Sphere:
1237 Quad2.SetValue(theS2->Sphere());
1241 Quad2.SetValue(theS2->Cone());
1248 IntPatch_ALineToWLine AToW(Quad1,Quad2,0.01,0.05,aNbPointsInALine);
1249 Handle(IntPatch_Line) wlin=AToW.MakeWLine((*((Handle_IntPatch_ALine *)(&line))));
1253 slin.Append(interii.Line(i));
1256 for (Standard_Integer i = 1; i <= interii.NbPnts(); i++)
1258 spnt.Append(interii.Point(i));
1263 ParamParamPerfom(theS1, theD1, theS2, theD2, TolArc, TolTang, ListOfPnts, RestrictLine, typs1, typs2);
1266 //=======================================================================
1267 ////function : GeomParamPerfom
1269 //=======================================================================
1270 void IntPatch_Intersection::GeomParamPerfom(const Handle(Adaptor3d_HSurface)& theS1,
1271 const Handle(Adaptor3d_TopolTool)& theD1,
1272 const Handle(Adaptor3d_HSurface)& theS2,
1273 const Handle(Adaptor3d_TopolTool)& theD2,
1274 const Standard_Boolean isNotAnalitical,
1275 const GeomAbs_SurfaceType typs1,
1276 const GeomAbs_SurfaceType typs2)
1278 IntPatch_ImpPrmIntersection interip;
1281 if (isNotAnalitical/*ts1 == 0*/)
1282 interip.SetStartPoint(myU1Start,myV1Start);
1284 interip.SetStartPoint(myU2Start,myV2Start);
1287 if(theD1->DomainIsInfinite() && theD2->DomainIsInfinite())
1289 Standard_Boolean IsPLInt = Standard_False;
1290 TColgp_SequenceOfPnt sop;
1292 FUN_PL_Intersection(theS1,typs1,theS2,typs2,IsPLInt,sop,v);
1296 if(sop.Length() > 0)
1298 for(Standard_Integer ip = 1; ip <= sop.Length(); ip++)
1300 gp_Lin lin(sop.Value(ip),gp_Dir(v));
1301 Handle(IntPatch_GLine) gl = new IntPatch_GLine(lin,Standard_False);
1302 slin.Append(*(Handle_IntPatch_Line *)&gl);
1305 done = Standard_True;
1308 done = Standard_False;
1314 Handle(Adaptor3d_HSurface) nS1 = theS1;
1315 Handle(Adaptor3d_HSurface) nS2 = theS2;
1316 FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+5,nS1,nS2);
1317 interip.Perform(nS1,theD1,nS2,theD2,myTolArc,myTolTang,myFleche,myUVMaxStep);
1321 interip.Perform(theS1,theD1,theS2,theD2,myTolArc,myTolTang,myFleche,myUVMaxStep);
1323 if (interip.IsDone())
1325 done = Standard_True;
1326 empt = interip.IsEmpty();
1330 for(Standard_Integer i = 1; i <= interip.NbLines(); i++)
1332 if(interip.Line(i)->ArcType() != IntPatch_Walking)
1333 slin.Append(interip.Line(i));
1336 for(Standard_Integer i = 1; i <= interip.NbLines(); i++)
1338 if(interip.Line(i)->ArcType() == IntPatch_Walking)
1339 slin.Append(interip.Line(i));
1342 for (Standard_Integer i = 1; i <= interip.NbPnts(); i++)
1343 spnt.Append(interip.Point(i));
1349 void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
1350 const Handle(Adaptor3d_TopolTool)& D1,
1351 const Handle(Adaptor3d_HSurface)& S2,
1352 const Handle(Adaptor3d_TopolTool)& D2,
1353 const Standard_Real U1,
1354 const Standard_Real V1,
1355 const Standard_Real U2,
1356 const Standard_Real V2,
1357 const Standard_Real TolArc,
1358 const Standard_Real TolTang)
1361 myTolTang = TolTang;
1362 if(myFleche == 0.0) {
1364 //cout<<" -- IntPatch_Intersection::myFleche fixe par defaut a 0.01 --"<<endl;
1365 //cout<<" -- Utiliser la Methode SetTolerances( ... ) "<<endl;
1369 if(myUVMaxStep==0.0) {
1371 //cout<<" -- IntPatch_Intersection::myUVMaxStep fixe par defaut a 0.01 --"<<endl;
1372 //cout<<" -- Utiliser la Methode SetTolerances( ... ) "<<endl;
1377 done = Standard_False;
1381 empt = Standard_True;
1382 tgte = Standard_False;
1383 oppo = Standard_False;
1385 const GeomAbs_SurfaceType typs1 = S1->GetType();
1386 const GeomAbs_SurfaceType typs2 = S2->GetType();
1388 if( typs1==GeomAbs_Plane
1389 || typs1==GeomAbs_Cylinder
1390 || typs1==GeomAbs_Sphere
1391 || typs1==GeomAbs_Cone
1392 || typs2==GeomAbs_Plane
1393 || typs2==GeomAbs_Cylinder
1394 || typs2==GeomAbs_Sphere
1395 || typs2==GeomAbs_Cone)
1397 myIsStartPnt = Standard_True;
1398 myU1Start = U1; myV1Start = V1; myU2Start = U2; myV2Start = V2;
1399 Perform(S1,D1,S2,D2,TolArc,TolTang);
1400 myIsStartPnt = Standard_False;
1404 IntPatch_PrmPrmIntersection interpp;
1405 interpp.Perform(S1,D1,S2,D2,U1,V1,U2,V2,TolArc,TolTang,myFleche,myUVMaxStep);
1406 if (interpp.IsDone())
1408 done = Standard_True;
1409 tgte = Standard_False;
1410 empt = interpp.IsEmpty();
1411 const Standard_Integer nblm = interpp.NbLines();
1412 Standard_Integer i = 1;
1413 for (; i<=nblm; i++) slin.Append(interpp.Line(i));
1417 //======================================================================
1418 #include <IntPatch_IType.hxx>
1419 #include <IntPatch_LineConstructor.hxx>
1420 #include <Handle_Adaptor2d_HCurve2d.hxx>
1424 //void IntPatch_Intersection__MAJ_R(Handle_Adaptor2d_HCurve2d *R1,
1425 // Handle_Adaptor2d_HCurve2d *R2,
1428 // Standard_Integer nbR1,
1429 // Standard_Integer nbR2,
1430 // const IntPatch_Point& VTX)
1431 void IntPatch_Intersection__MAJ_R(Handle_Adaptor2d_HCurve2d *,
1432 Handle_Adaptor2d_HCurve2d *,
1437 const IntPatch_Point& )
1440 if(VTX.IsOnDomS1()) {
1442 //-- long unsigned ptr= *((long unsigned *)(((Handle_Standard_Transient *)(&(VTX.ArcOnS1())))));
1443 for(Standard_Integer i=0; i<nbR1;i++) {
1444 if(VTX.ArcOnS1()==R1[i]) {
1446 printf("\n ******************************");
1450 printf("\n R Pas trouvee (IntPatch)\n");
1457 //void IntPatch_Intersection::Dump(const Standard_Integer Mode,
1458 void IntPatch_Intersection::Dump(const Standard_Integer ,
1459 const Handle(Adaptor3d_HSurface)& S1,
1460 const Handle(Adaptor3d_TopolTool)& D1,
1461 const Handle(Adaptor3d_HSurface)& S2,
1462 const Handle(Adaptor3d_TopolTool)& D2) const
1465 //-- ----------------------------------------------------------------------
1466 //-- construction de la liste des restrictions & vertex
1468 int NR1[MAXR],NR2[MAXR];
1469 Handle_Adaptor2d_HCurve2d R1[MAXR],R2[MAXR];
1470 Standard_Integer nbR1=0,nbR2=0;
1471 for(D1->Init();D1->More() && nbR1<MAXR; D1->Next()) {
1472 R1[nbR1]=D1->Value();
1476 for(D2->Init();D2->More() && nbR2<MAXR; D2->Next()) {
1477 R2[nbR2]=D2->Value();
1482 printf("\nDUMP_INT: ----empt:%2ud tgte:%2ud oppo:%2ud ---------------------------------",empt,tgte,empt);
1483 Standard_Integer i,j,nbr1,nbr2,nbgl,nbgc,nbge,nbgp,nbgh,nbl,nbr,nbg,nbw,nba;
1484 nbl=nbr=nbg=nbw=nba=nbgl=nbge=nbr1=nbr2=nbgc=nbgp=nbgh=0;
1486 for(i=1;i<=nbl;i++) {
1487 const Handle(IntPatch_Line)& line=Line(i);
1488 const IntPatch_IType IType=line->ArcType();
1489 if(IType == IntPatch_Walking) nbw++;
1490 else if(IType == IntPatch_Restriction) {
1492 Handle(IntPatch_RLine)& rlin =
1493 *((Handle(IntPatch_RLine) *)&line);
1494 if(rlin->IsArcOnS1()) nbr1++;
1495 if(rlin->IsArcOnS2()) nbr2++;
1497 else if(IType == IntPatch_Analytic) nba++;
1499 if(IType == IntPatch_Lin) nbgl++;
1500 else if(IType == IntPatch_Circle) nbgc++;
1501 else if(IType == IntPatch_Parabola) nbgp++;
1502 else if(IType == IntPatch_Hyperbola) nbgh++;
1503 else if(IType == IntPatch_Ellipse) nbge++;
1508 printf("\nDUMP_INT:Lines:%2d Wlin:%2d Restr:%2d(On1:%2d On2:%2d) Ana:%2d Geom:%2d(L:%2d C:%2d E:%2d H:%2d P:%2d)",
1509 nbl,nbw,nbr,nbr1,nbr2,nba,nbg,nbgl,nbgc,nbge,nbgh,nbgp);
1511 IntPatch_LineConstructor LineConstructor(2);
1513 Standard_Integer nbllc=0;
1515 Standard_Integer nbva,nbvw,nbvr,nbvg;
1516 nbva=nbvr=nbvw=nbvg=0;
1517 for (j=1; j<=nbl; j++) {
1518 Standard_Integer v,nbvtx;
1519 const Handle(IntPatch_Line)& intersLinej = Line(j);
1520 Standard_Integer NbLines;
1521 LineConstructor.Perform(SequenceOfLine(),intersLinej,S1,D1,S2,D2,1e-7);
1522 NbLines = LineConstructor.NbLines();
1524 for(Standard_Integer k=1;k<=NbLines;k++) {
1526 const Handle(IntPatch_Line)& LineK = LineConstructor.Line(k);
1527 if (LineK->ArcType() == IntPatch_Analytic) {
1528 Handle(IntPatch_ALine)& alin =
1529 *((Handle(IntPatch_ALine) *)&LineK);
1530 nbvtx=alin->NbVertex();
1532 for(v=1;v<=nbvtx;v++) {
1533 IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,alin->Vertex(v));
1536 else if (LineK->ArcType() == IntPatch_Restriction) {
1537 Handle(IntPatch_RLine)& rlin =
1538 *((Handle(IntPatch_RLine) *)&LineK);
1539 nbvtx=rlin->NbVertex();
1541 for(v=1;v<=nbvtx;v++) {
1542 IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,rlin->Vertex(v));
1545 else if (LineK->ArcType() == IntPatch_Walking) {
1546 Handle(IntPatch_WLine)& wlin =
1547 *((Handle(IntPatch_WLine) *)&LineK);
1548 nbvtx=wlin->NbVertex();
1550 for(v=1;v<=nbvtx;v++) {
1551 IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,wlin->Vertex(v));
1555 Handle(IntPatch_GLine)& glin =
1556 *((Handle(IntPatch_GLine) *)&LineK);
1557 nbvtx=glin->NbVertex();
1559 for(v=1;v<=nbvtx;v++) {
1560 IntPatch_Intersection__MAJ_R(R1,R2,NR1,NR2,nbR1,nbR2,glin->Vertex(v));
1565 printf("\nDUMP_LC :Lines:%2d WLin:%2d Restr:%2d Ana:%2d Geom:%2d",
1566 nbllc,nbw,nbr,nba,nbg);
1567 printf("\nDUMP_LC :vtx :%2d r:%2d :%2d :%2d",
1568 nbvw,nbvr,nbva,nbvg);