1 // Created on: 1993-07-12
2 // Created by: Yves FRICAUD
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
17 #define Debug(expr) cout<<" MAT2d_Tool2d.cxx : expr :"<<expr<<endl;
22 #include <DrawTrSurf.hxx>
27 #include <Draw_Appli.hxx>
28 #include <DrawTrSurf_Curve2d.hxx>
29 #include <GCE2d_MakeSegment.hxx>
30 #include <DrawTrSurf.hxx>
34 #include <Bisector_Bisec.hxx>
35 #include <Bisector_BisecAna.hxx>
36 #include <Bisector_BisecCC.hxx>
37 #include <Bisector_Curve.hxx>
38 #include <Bisector_Inter.hxx>
40 #include <Extrema_ExtPC2d.hxx>
41 #include <Geom2d_CartesianPoint.hxx>
42 #include <Geom2d_Circle.hxx>
43 #include <Geom2d_Curve.hxx>
44 #include <Geom2d_Ellipse.hxx>
45 #include <Geom2d_Geometry.hxx>
46 #include <Geom2d_Hyperbola.hxx>
47 #include <Geom2d_Line.hxx>
48 #include <Geom2d_Parabola.hxx>
49 #include <Geom2d_Point.hxx>
50 #include <Geom2d_TrimmedCurve.hxx>
51 #include <Geom2dAdaptor_Curve.hxx>
52 #include <Geom2dInt_GInter.hxx>
53 #include <gp_Circ2d.hxx>
54 #include <gp_Elips2d.hxx>
55 #include <gp_Hypr2d.hxx>
56 #include <gp_Lin2d.hxx>
57 #include <gp_Parab2d.hxx>
58 #include <gp_Pnt2d.hxx>
59 #include <gp_Vec2d.hxx>
60 #include <IntRes2d_Domain.hxx>
61 #include <IntRes2d_IntersectionPoint.hxx>
62 #include <IntRes2d_IntersectionSegment.hxx>
63 #include <MAT2d_Circuit.hxx>
64 #include <MAT2d_Connexion.hxx>
65 #include <MAT2d_MiniPath.hxx>
66 #include <MAT2d_SequenceOfSequenceOfGeometry.hxx>
67 #include <MAT2d_Tool2d.hxx>
68 #include <MAT_Bisector.hxx>
69 #include <MAT_Edge.hxx>
70 #include <Precision.hxx>
71 #include <Standard_NotImplemented.hxx>
72 #include <StdFail_NotDone.hxx>
73 #include <TColStd_Array1OfReal.hxx>
76 static Handle(DrawTrSurf_Curve2d) draw;
77 static Standard_Integer AffichBis = Standard_False;
80 static void MAT2d_DrawCurve(const Handle(Geom2d_Curve)& aCurve,
81 const Standard_Integer Indice);
82 static Standard_Boolean Store = Standard_False;
83 static Standard_Boolean AffichDist = Standard_False;
86 //=====================================================================
88 //=====================================================================
89 static IntRes2d_Domain Domain
90 (const Handle(Geom2d_TrimmedCurve)& Bisector1,
91 const Standard_Real Tolerance);
93 static Handle(Standard_Type) Type (const Handle(Geom2d_Geometry)& acurve);
95 static Standard_Boolean AreNeighbours(const Standard_Integer IEdge1,
96 const Standard_Integer IEdge2,
97 const Standard_Integer NbEdge);
99 static void SetTrim(Bisector_Bisec& Bis, const Handle(Geom2d_Curve)& Line1);
100 static Standard_Boolean CheckEnds (const Handle(Geom2d_Geometry)& Elt ,
101 const gp_Pnt2d& PCom ,
102 const Standard_Real Distance,
103 const Standard_Real Tol);
105 static Standard_Real MAT2d_TOLCONF = 1.e-7;
107 //============================================================================
110 //============================================================================
111 MAT2d_Tool2d::MAT2d_Tool2d()
114 theJoinType = GeomAbs_Arc; //default
115 theNumberOfBisectors = 0;
120 //=============================================================================
121 //function : InitItems
123 //=============================================================================
124 void MAT2d_Tool2d::InitItems(const Handle(MAT2d_Circuit)& EquiCircuit)
126 theGeomBisectors.Clear();
129 theLinesLength.Clear();
130 theNumberOfBisectors = 0;
134 theCircuit = EquiCircuit;
137 //=============================================================================
140 //=============================================================================
141 void MAT2d_Tool2d::Sense(const MAT_Side aside)
143 if(aside == MAT_Left) theDirection = 1.;
144 else theDirection = -1.;
147 //=============================================================================
148 //function : SetJoinType
150 //=============================================================================
151 void MAT2d_Tool2d::SetJoinType(const GeomAbs_JoinType aJoinType)
153 theJoinType = aJoinType;
156 //=============================================================================
157 //function : NumberOfItems
159 //=============================================================================
160 Standard_Integer MAT2d_Tool2d::NumberOfItems() const
162 return theCircuit->NumberOfItems();
165 //=============================================================================
166 //function : ToleranceOfConfusion
168 //=============================================================================
169 Standard_Real MAT2d_Tool2d::ToleranceOfConfusion() const
171 return 2*MAT2d_TOLCONF;
174 //=============================================================================
175 //function : FirstPoint
177 //=============================================================================
178 Standard_Integer MAT2d_Tool2d::FirstPoint(const Standard_Integer anitem,
179 Standard_Real& dist )
181 Handle(Geom2d_Curve) curve;
182 Handle(Geom2d_Point) point;
185 if (theCircuit->ConnexionOn(anitem)){
186 gp_Pnt2d P1 = theCircuit->Connexion(anitem)->PointOnFirst();
187 gp_Pnt2d P2 = theCircuit->Connexion(anitem)->PointOnSecond();
188 theGeomPnts.Bind(theNumberOfPnts,gp_Pnt2d((P1.X() + P2.X())*0.5,
189 (P1.Y() + P2.Y())*0.5));
190 dist = P1.Distance(P2)*0.5;
191 return theNumberOfPnts;
194 Handle(Standard_Type) type;
195 type = theCircuit->Value(anitem)->DynamicType();
198 if ( type != STANDARD_TYPE(Geom2d_CartesianPoint)){
199 curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(anitem));
200 theGeomPnts.Bind(theNumberOfPnts,curve->Value(curve->FirstParameter()));
203 point = Handle(Geom2d_Point)::DownCast(theCircuit->Value(anitem));
204 theGeomPnts.Bind(theNumberOfPnts,point->Pnt2d());
206 return theNumberOfPnts;
209 //=============================================================================
210 //function : TangentBefore
212 //=============================================================================
213 Standard_Integer MAT2d_Tool2d::TangentBefore(const Standard_Integer anitem,
214 const Standard_Boolean IsOpenResult)
216 Standard_Integer item;
217 Handle(Geom2d_Curve) curve;
221 item = (anitem == theCircuit->NumberOfItems()) ? 1 : (anitem + 1);
223 item = (anitem == theCircuit->NumberOfItems()) ? (anitem - 1) : (anitem + 1);
224 if (theCircuit->ConnexionOn(item)){
225 Standard_Real x1,y1,x2,y2;
226 theCircuit->Connexion(item)->PointOnFirst().Coord(x1,y1);
227 theCircuit->Connexion(item)->PointOnSecond().Coord(x2,y2);
228 theGeomVecs.Bind(theNumberOfVecs,gp_Vec2d((x2-x1),(y2-y1)));
229 return theNumberOfVecs;
232 Handle(Standard_Type) type;
233 type = theCircuit->Value(anitem)->DynamicType();
234 if ( type != STANDARD_TYPE(Geom2d_CartesianPoint)){
235 curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(anitem));
236 theGeomVecs.Bind(theNumberOfVecs,curve->DN(curve->LastParameter(),1));
239 curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(item));
240 Standard_Real param = (IsOpenResult && anitem == theCircuit->NumberOfItems())?
241 curve->LastParameter() : curve->FirstParameter();
242 theGeomVecs.Bind(theNumberOfVecs,curve->DN(param,1));
245 return theNumberOfVecs;
248 //=============================================================================
249 //function : TangentAfter
251 //=============================================================================
252 Standard_Integer MAT2d_Tool2d::TangentAfter(const Standard_Integer anitem,
253 const Standard_Boolean IsOpenResult)
255 Standard_Integer item;
256 Handle(Geom2d_Curve) curve;
260 if (theCircuit->ConnexionOn(anitem)){
261 Standard_Real x1,y1,x2,y2;
262 theCircuit->Connexion(anitem)->PointOnFirst().Coord(x1,y1);
263 theCircuit->Connexion(anitem)->PointOnSecond().Coord(x2,y2);
264 theGeomVecs.Bind(theNumberOfVecs,gp_Vec2d((x1-x2),(y1-y2)));
265 return theNumberOfVecs;
268 Handle(Standard_Type) type;
269 type = theCircuit->Value(anitem)->DynamicType();
270 if ( type != STANDARD_TYPE(Geom2d_CartesianPoint)){
271 curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(anitem));
272 thevector = curve->DN(curve->FirstParameter(),1);
276 item = (anitem == 1) ? theCircuit->NumberOfItems() : (anitem - 1);
278 item = (anitem == 1) ? 2 : (anitem - 1);
279 curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(item));
280 Standard_Real param = (IsOpenResult && anitem == 1)?
281 curve->FirstParameter() : curve->LastParameter();
282 thevector = curve->DN(param,1);
284 theGeomVecs.Bind(theNumberOfVecs,thevector.Reversed());
285 return theNumberOfVecs;
288 //=============================================================================
291 //=============================================================================
292 Standard_Integer MAT2d_Tool2d::Tangent(const Standard_Integer bisector)
295 theGeomVecs.Bind(theNumberOfVecs,GeomBis(bisector).Value()
296 ->DN(GeomBis(bisector).Value()
297 ->LastParameter(),1));
298 return theNumberOfVecs;
301 //=============================================================================
302 //function : CreateBisector
304 //=============================================================================
305 void MAT2d_Tool2d::CreateBisector(const Handle(MAT_Bisector)& abisector)
307 Handle(Geom2d_Point) point1,point2;
308 Handle(Geom2d_Geometry) elt1,elt2;
309 Bisector_Bisec bisector;
310 Standard_Real tolerance = MAT2d_TOLCONF ;
312 Standard_Integer edge1number = abisector->FirstEdge()->EdgeNumber();
313 Standard_Integer edge2number = abisector->SecondEdge()->EdgeNumber();
314 Standard_Boolean ontheline = AreNeighbours(edge1number,
317 Standard_Boolean InitialNeighbour = ontheline;
319 if(theCircuit->ConnexionOn(edge2number)) ontheline = Standard_False;
321 elt1 = theCircuit->Value(edge1number);
322 elt2 = theCircuit->Value(edge2number);
324 Handle(Standard_Type) type1;
325 type1 = theCircuit->Value(edge1number)->DynamicType();
326 Handle(Standard_Type) type2;
327 type2 = theCircuit->Value(edge2number)->DynamicType();
328 Handle(Geom2d_Curve) item1;
329 Handle(Geom2d_Curve) item2;
331 if ( type1 != STANDARD_TYPE(Geom2d_CartesianPoint)){
332 item1 = Handle(Geom2d_Curve)::DownCast(elt1);
335 if ( type2 != STANDARD_TYPE(Geom2d_CartesianPoint)){
336 item2 = Handle(Geom2d_Curve)::DownCast(elt2);
340 Standard_Boolean Affich = Standard_False;
343 cout<<"BISECTOR number : "<<theNumberOfBisectors+1<<endl;
344 cout<<" Item 1 : "<<endl;
345 cout<<edge1number<<endl;
349 cout<<" Item 2 : "<<endl;
350 cout<<edge2number<<endl;
357 if(type1 != STANDARD_TYPE(Geom2d_CartesianPoint) &&
358 type2 != STANDARD_TYPE(Geom2d_CartesianPoint)) {
359 bisector.Perform(item1,item2,
360 GeomPnt (abisector->IssuePoint()),
361 GeomVec (abisector->FirstVector()),
362 GeomVec (abisector->SecondVector()),
363 theDirection,theJoinType,tolerance,ontheline);
365 else if(type1 == STANDARD_TYPE(Geom2d_CartesianPoint) &&
366 type2 == STANDARD_TYPE(Geom2d_CartesianPoint)) {
367 point1 = Handle(Geom2d_Point)::DownCast(elt1);
368 point2 = Handle(Geom2d_Point)::DownCast(elt2);
369 bisector.Perform(point1,point2,
370 GeomPnt (abisector->IssuePoint()),
371 GeomVec (abisector->FirstVector()),
372 GeomVec (abisector->SecondVector()),
373 theDirection,tolerance,ontheline);
375 else if(type1 == STANDARD_TYPE(Geom2d_CartesianPoint)) {
376 point1 = Handle(Geom2d_Point)::DownCast(elt1);
377 bisector.Perform(point1,item2,
378 GeomPnt (abisector->IssuePoint()),
379 GeomVec (abisector->FirstVector()),
380 GeomVec (abisector->SecondVector()),
381 theDirection,tolerance,ontheline);
384 point2 = Handle(Geom2d_Point)::DownCast(elt2);
385 bisector.Perform(item1,point2,
386 GeomPnt (abisector->IssuePoint()),
387 GeomVec (abisector->FirstVector()),
388 GeomVec (abisector->SecondVector()),
389 theDirection,tolerance,ontheline);
392 //------------------------------
393 // Restriction de la bisectrice.
394 //-----------------------------
395 TrimBisec(bisector,edge1number,InitialNeighbour,1);
396 TrimBisec(bisector,edge2number,InitialNeighbour,2);
398 theNumberOfBisectors++;
399 theGeomBisectors.Bind(theNumberOfBisectors,bisector);
401 abisector->BisectorNumber(theNumberOfBisectors);
405 Standard_Boolean AffichDraw = Standard_False;
406 if (AffichDraw) Dump(abisector->BisectorNumber(),1);
408 Handle(Standard_Type) Type1 = Type(bisector.Value()->BasisCurve());
409 Handle(Geom2d_Curve) BasisCurve;
410 if (Type1 == STANDARD_TYPE(Bisector_BisecAna)) {
411 BasisCurve = Handle(Bisector_BisecAna)
412 ::DownCast(bisector.Value()->BasisCurve())->Geom2dCurve();
414 char *name = new char[100];
415 sprintf(name,"BISSEC_%d",abisector->BisectorNumber());
416 DrawTrSurf::Set(name,BasisCurve);
424 //=============================================================================
425 //function : TrimBisec
426 //purpose : Restriction de la bisectrice.
427 // Restriction des bissectrice separant deux elements lies par une
428 // connexion ou l un au moins des elements est un cercle.
429 // Cette restriction est necessaire a la logique de l algorithme.
430 //=============================================================================
431 void MAT2d_Tool2d::TrimBisec ( Bisector_Bisec& B1,
432 const Standard_Integer IndexEdge,
433 const Standard_Boolean InitialNeighbour,
434 const Standard_Integer StartOrEnd ) const
436 Handle(Geom2d_Curve) Curve;
437 Handle(Geom2d_TrimmedCurve) LineSupportDomain,Line;
438 Handle(Geom2d_Line) Line1,Line2;
440 //gp_Vec2d Tan1,Tan2;
441 gp_Pnt2d Ori; //PEdge;
442 Standard_Integer INext;
443 INext = (IndexEdge == theCircuit->NumberOfItems()) ? 1 : (IndexEdge + 1);
445 Handle(Standard_Type) EdgeType = theCircuit->Value(IndexEdge)->DynamicType();
447 if (EdgeType != STANDARD_TYPE(Geom2d_CartesianPoint)) {
448 if(!InitialNeighbour) {
449 Curve = Handle(Geom2d_TrimmedCurve)
450 ::DownCast(theCircuit->Value(IndexEdge))->BasisCurve();
451 EdgeType = Curve->DynamicType();
452 //-------------------------------------------------------------------
453 // si l edge est liee a sa voisine precedente par une connexion.
454 //-------------------------------------------------------------------
455 if (theCircuit->ConnexionOn(IndexEdge) && StartOrEnd == 1){
456 if (EdgeType == STANDARD_TYPE(Geom2d_Circle)) {
457 Ori = Handle(Geom2d_Circle)::DownCast(Curve)->Location();
458 gp_Pnt2d P2 = theCircuit->Connexion(IndexEdge)->PointOnFirst();
459 Line1 = new Geom2d_Line (Ori,gp_Dir2d(P2.X() - Ori.X(),
463 //-----------------------------------------------------------------------
464 // Si l edge est liee a sa voisine suivante par une connexion.
465 //-----------------------------------------------------------------------
466 if (theCircuit->ConnexionOn(INext) && StartOrEnd == 2){
467 if (EdgeType == STANDARD_TYPE(Geom2d_Circle)) {
468 Ori = Handle(Geom2d_Circle)::DownCast(Curve)->Location();
469 gp_Pnt2d P2 = theCircuit->Connexion(INext)->PointOnSecond();
470 Line2 = new Geom2d_Line (Ori,gp_Dir2d(P2.X() - Ori.X(),
474 if (Line1.IsNull() && Line2.IsNull()) return;
476 //-----------------------------------------------------------------------
477 // Restriction de la bisectrice par les demi-droites liees aux connexions
478 // si elles existent.
479 //-----------------------------------------------------------------------
480 if (!Line1.IsNull()) {
481 Line = new Geom2d_TrimmedCurve(Line1,0.,Precision::Infinite());
484 if (!Line2.IsNull()) {
485 Line = new Geom2d_TrimmedCurve(Line2,0.,Precision::Infinite());
492 //=============================================================================
493 //function : TrimBisector
495 //=============================================================================
496 Standard_Boolean MAT2d_Tool2d::TrimBisector
497 (const Handle(MAT_Bisector)& abisector)
499 Standard_Real param = abisector->FirstParameter();
502 Standard_Boolean Affich = Standard_False;
503 if (Affich) cout<<"TRIM de "<<abisector->BisectorNumber()<<endl;
506 Handle(Geom2d_TrimmedCurve)
507 bisector = Handle(Geom2d_TrimmedCurve)
508 ::DownCast(ChangeGeomBis(abisector->BisectorNumber()).ChangeValue());
510 if(bisector->BasisCurve()->IsPeriodic() && param == Precision::Infinite()) {
511 param = bisector->FirstParameter() + 2*M_PI;
513 if (param > bisector->BasisCurve()->LastParameter()) {
514 param = bisector->BasisCurve()->LastParameter();
516 if(bisector->FirstParameter() == param) return Standard_False;
518 bisector->SetTrim(bisector->FirstParameter(),param);
519 return Standard_True;
522 //=============================================================================
523 //function : TrimBisector
525 //=============================================================================
526 Standard_Boolean MAT2d_Tool2d::TrimBisector
527 (const Handle(MAT_Bisector)& abisector,
528 const Standard_Integer apoint)
531 Handle(Geom2d_TrimmedCurve)
532 Bisector = Handle(Geom2d_TrimmedCurve)::
533 DownCast(ChangeGeomBis(abisector->BisectorNumber()).ChangeValue());
535 Handle(Bisector_Curve) Bis = Handle(Bisector_Curve)::
536 DownCast(Bisector->BasisCurve());
538 // Param = ParameterOnCurve(Bisector,theGeomPnts.Value(apoint));
539 Param = Bis->Parameter(GeomPnt (apoint));
541 if (Bisector->BasisCurve()->IsPeriodic()) {
542 if (Bisector->FirstParameter() > Param) Param = Param + 2*M_PI;
544 if(Bisector->FirstParameter() >= Param)return Standard_False;
545 if(Bisector->LastParameter() < Param)return Standard_False;
546 Bisector->SetTrim(Bisector->FirstParameter(),Param);
549 Standard_Boolean Affich = Standard_False;
550 if (Affich) MAT2d_DrawCurve(Bisector,2);
553 return Standard_True;
556 //=============================================================================
557 //function : Projection
559 //=============================================================================
560 Standard_Boolean MAT2d_Tool2d::Projection (const Standard_Integer IEdge ,
561 const gp_Pnt2d& PCom ,
562 Standard_Real& Distance)
566 Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge);
567 Handle(Standard_Type) Type = Elt->DynamicType();
568 Handle(Geom2d_TrimmedCurve) Curve;
569 Standard_Integer INext;
570 Standard_Real Eps = MAT2d_TOLCONF;//*10.;
572 if (Type == STANDARD_TYPE(Geom2d_CartesianPoint)) {
573 PEdge = Handle(Geom2d_Point)::DownCast(Elt)->Pnt2d();
574 Distance = PCom.Distance(PEdge);
577 Distance = Precision::Infinite();
578 Curve = Handle(Geom2d_TrimmedCurve)::DownCast(Elt);
579 //-----------------------------------------------------------------------
580 // Calcul des parametres MinMax sur l edge si celui ci est lies a ses
581 // voisins par des connexions la courbe de calcul est limitee par
583 //-----------------------------------------------------------------------
584 Standard_Real ParamMin = Curve->FirstParameter();
585 Standard_Real ParamMax = Curve->LastParameter();
586 if (theCircuit->ConnexionOn(IEdge)) {
587 ParamMin = theCircuit->Connexion(IEdge)->ParameterOnSecond();
589 INext = (IEdge == theCircuit->NumberOfItems()) ? 1 : (IEdge + 1);
590 if (theCircuit->ConnexionOn(INext)) {
591 ParamMax = theCircuit->Connexion(INext)->ParameterOnFirst();
592 if (Curve->BasisCurve()->IsPeriodic()){
593 ElCLib::AdjustPeriodic(0.,2*M_PI,Eps,ParamMin,ParamMax);
596 //---------------------------------------------------------------------
597 // Constuction de la courbe pour les extremas et ajustement des bornes.
598 //---------------------------------------------------------------------
599 Geom2dAdaptor_Curve C1(Curve);
600 GeomAbs_CurveType TypeC1 = C1.GetType();
601 if (TypeC1 == GeomAbs_Circle) {
602 Standard_Real R = C1.Circle().Radius();
603 Standard_Real EpsCirc = 100.*Eps;
604 if ( R < 1.) EpsCirc = Eps/R;
605 if (((ParamMax - ParamMin + 2*EpsCirc) < 2*M_PI)) {
606 ParamMax = ParamMax + EpsCirc; ParamMin = ParamMin - EpsCirc;
610 ParamMax = ParamMax + Eps; ParamMin = ParamMin - Eps;
612 //-----------------------------------------------------
613 // Calcul des extremas et stockage minimum de distance.
614 //-----------------------------------------------------
615 Extrema_ExtPC2d Extremas(PCom,C1,ParamMin,ParamMax);
616 if (Extremas.IsDone()){
617 Distance = Precision::Infinite();
618 if(Extremas.NbExt() < 1)
620 return Standard_False;
622 for (Standard_Integer i = 1; i <= Extremas.NbExt(); i++) {
623 if (Extremas.SquareDistance(i) < Distance) {
624 Distance = Extremas.SquareDistance(i);
627 Distance = Sqrt(Distance);
630 if (TypeC1 == GeomAbs_Circle) {
631 Distance = C1.Circle().Radius();
635 return Standard_True;
638 //=============================================================================
639 //function : IsSameDistance
641 //=============================================================================
642 Standard_Boolean MAT2d_Tool2d::IsSameDistance (
643 const Handle(MAT_Bisector)& BisectorOne,
644 const Handle(MAT_Bisector)& BisectorTwo,
645 const gp_Pnt2d& PCom,
646 Standard_Real& Distance) const
648 TColStd_Array1OfReal Dist(1,4);
649 const Standard_Real eps = 1.e-7;
650 Standard_Integer IEdge1,IEdge2,IEdge3,IEdge4;
652 IEdge1 = BisectorOne->FirstEdge() ->EdgeNumber();
653 IEdge2 = BisectorOne->SecondEdge()->EdgeNumber();
654 IEdge3 = BisectorTwo->FirstEdge() ->EdgeNumber();
655 IEdge4 = BisectorTwo->SecondEdge()->EdgeNumber();
657 Standard_Boolean isDone1 = Projection(IEdge1,PCom,Dist(1));
658 Standard_Boolean isDone2 = Projection(IEdge2,PCom,Dist(2));
664 Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge2);
665 Standard_Real Tol = Max(Precision::Confusion(), eps*Dist(1));
666 if(CheckEnds (Elt, PCom, Dist(1), Tol))
676 Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge1);
677 Standard_Real Tol = Max(Precision::Confusion(), eps*Dist(2));
678 if(CheckEnds (Elt, PCom, Dist(2), Tol))
685 Standard_Boolean isDone3 = Standard_True, isDone4 = Standard_True;
686 if (IEdge3 == IEdge1) Dist(3) = Dist(1);
687 else if (IEdge3 == IEdge2) Dist(3) = Dist(2);
688 else isDone3 = Projection(IEdge3,PCom,Dist(3));
690 if (IEdge4 == IEdge1) Dist(4) = Dist(1);
691 else if (IEdge4 == IEdge2) Dist(4) = Dist(2);
692 else isDone4 = Projection(IEdge4,PCom,Dist(4));
698 Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge4);
699 Standard_Real Tol = Max(Precision::Confusion(), eps*Dist(3));
700 if(CheckEnds (Elt, PCom, Dist(3), Tol))
710 Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge3);
711 Standard_Real Tol = Max(Precision::Confusion(), eps*Dist(4));
712 if(CheckEnds (Elt, PCom, Dist(4), Tol))
721 for (Standard_Integer j = 1; j <= 4;j++){
722 cout <<"Distance number : "<<j<<" is :"<< Dist(j)<<endl;
726 Standard_Real EpsDist = MAT2d_TOLCONF*300. ;
728 if (theJoinType == GeomAbs_Intersection &&
729 Precision::IsInfinite(Distance))
731 for (Standard_Integer i = 2; i <= 4; i++)
732 if (!Precision::IsInfinite(Dist(i)))
738 for (Standard_Integer i = 1; i <= 4; i++){
739 if (theJoinType == GeomAbs_Intersection &&
740 Precision::IsInfinite(Dist(i)))
742 if (Abs(Dist(i) - Distance) > EpsDist) {
743 Distance = Precision::Infinite();
744 return Standard_False;
747 return Standard_True;
750 //=============================================================================
751 //function : IntersectBisector
753 //=============================================================================
754 Standard_Real MAT2d_Tool2d::IntersectBisector (
755 const Handle(MAT_Bisector)& BisectorOne,
756 const Handle(MAT_Bisector)& BisectorTwo,
757 Standard_Integer& IntPnt)
759 Standard_Real Tolerance = MAT2d_TOLCONF;
760 Standard_Real Param1,Param2;
761 Standard_Real Parama,Paramb;
762 Standard_Real Distance = 0.,DistanceMini;
763 Standard_Boolean SolutionValide;
764 gp_Pnt2d PointSolution;
766 Handle(Geom2d_TrimmedCurve)
767 Bisector1 = Handle(Geom2d_TrimmedCurve)
768 ::DownCast(ChangeGeomBis(BisectorOne->BisectorNumber()).ChangeValue());
770 Handle(Geom2d_TrimmedCurve)
771 Bisector2 = Handle(Geom2d_TrimmedCurve)
772 ::DownCast(ChangeGeomBis(BisectorTwo->BisectorNumber()).ChangeValue());
774 if(Bisector1.IsNull() || Bisector2.IsNull()) return Precision::Infinite();
776 //-------------------------------------------------------------------------
777 // Si les deux bissectrices separent des elements consecutifs et qu elles
778 // sont issues des connexions C1 et C2.
779 // Si C1 est la reverse de C2 ,alors les deux bissectrices sont issues
780 // du meme point. Dans ce cas l intersection n est pas validee.
781 //-------------------------------------------------------------------------
782 Standard_Integer IS1 = BisectorOne->SecondEdge()->EdgeNumber();
783 Standard_Integer IS2 = BisectorTwo->SecondEdge()->EdgeNumber();
784 Standard_Integer IF1 = BisectorOne->FirstEdge() ->EdgeNumber();
785 Standard_Integer IF2 = BisectorTwo->FirstEdge() ->EdgeNumber();
787 if (AreNeighbours(IF1,IS1,NumberOfItems()) &&
788 AreNeighbours(IF2,IS2,NumberOfItems()) &&
789 theCircuit->ConnexionOn(IS2) &&
790 theCircuit->ConnexionOn(IS1) ) {
791 Handle(MAT2d_Connexion) C1,C2;
792 C1 = theCircuit->Connexion(IS1);
793 C2 = theCircuit->Connexion(IS2);
794 if (C2->IndexFirstLine() == C1->IndexSecondLine() &&
795 C1->IndexFirstLine() == C2->IndexSecondLine() )
796 return Precision::Infinite();
799 // -----------------------------------------
800 // Construction des domaines d intersection.
801 // -----------------------------------------
802 IntRes2d_Domain Domain1 = Domain(Bisector1,Tolerance);
803 IntRes2d_Domain Domain2 = Domain(Bisector2,Tolerance);
805 if (Domain1.LastParameter() - Domain1.FirstParameter() < Tolerance)
806 return Precision::Infinite();
807 if (Domain2.LastParameter() - Domain2.FirstParameter() < Tolerance)
808 return Precision::Infinite();
811 Standard_Boolean Affich = Standard_False;
814 cout<<"INTERSECTION de "<<BisectorOne->BisectorNumber()<<
815 " et de "<<BisectorTwo->BisectorNumber()<<endl;
816 cout<<" Bisector 1 : "<<endl;
817 // (Bisector1->BasisCurve())->Dump(-1,1);
819 Debug(Domain1.FirstParameter());
820 Debug(Domain1.LastParameter());
821 cout<<"-----------------"<<endl;
822 cout<<" Bisector 2 : "<<endl;
823 // (Bisector2->BasisCurve())->Dump(-1,1);
825 Debug(Domain2.FirstParameter());
826 Debug(Domain2.LastParameter());
827 cout<<"-----------------"<<endl;
831 // -------------------------
832 // Calcul de l intersection.
833 // -------------------------
835 Bisector_Inter Intersect;
836 Intersect.Perform (GeomBis(BisectorOne->BisectorNumber()),Domain1,
837 GeomBis(BisectorTwo->BisectorNumber()),Domain2,
838 Tolerance,Tolerance,Standard_True);
840 // Geom2dInt_GInter Intersect;
841 // Intersect.Perform(Bisector1,Domain1,Bisector2,Domain2,Tolerance,Tolerance);
843 // -------------------------------------------------------------------------
844 // Exploitation du resultat de l intersection et selection du point solution
845 // equidistant des deux edges et le plus proche en parametre de l origine
847 // -------------------------------------------------------------------------
849 if(!Intersect.IsDone()) return Precision::Infinite();
851 if(Intersect.IsEmpty()) return Precision::Infinite();
853 DistanceMini = Precision::Infinite();
854 Param1 = Precision::Infinite();
855 Param2 = Precision::Infinite();
856 SolutionValide = Standard_False;
858 if(Intersect.NbSegments() >= 1) {
859 Standard_Real MaxSegmentLength = 10.*Tolerance;
860 for (Standard_Integer i=1;i<=Intersect.NbSegments();i++) {
861 IntRes2d_IntersectionSegment Segment = Intersect.Segment(i);
862 Standard_Boolean PointRetenu = Standard_False;
863 gp_Pnt2d PointOnSegment;
864 // ----------------------------------------------------------------
865 // Si les segments sont petits, recherche des points sur le segment
866 // equidistants des edges.
867 // ----------------------------------------------------------------
868 if ((Segment.HasFirstPoint() && Segment.HasLastPoint())) {
870 Standard_Real SegmentLength;
871 P1 = Segment.FirstPoint().Value();
872 P2 = Segment.LastPoint().Value();
873 SegmentLength = P1.Distance(P2);
874 if (SegmentLength <= Tolerance) {
876 if(IsSameDistance(BisectorOne,BisectorTwo,
877 PointOnSegment,Distance))
878 PointRetenu = Standard_True;
880 else if (SegmentLength <= MaxSegmentLength) {
881 gp_Dir2d Dir(P2.X()-P1.X(),P2.Y()-P1.Y());
882 Standard_Real Dist = 0.;
883 while (Dist <= SegmentLength + Tolerance){
884 PointOnSegment = P1.Translated(Dist*Dir);
885 if(IsSameDistance(BisectorOne,BisectorTwo,
886 PointOnSegment,Distance)) {
887 PointRetenu = Standard_True;
890 Dist = Dist + Tolerance;
895 // ----------------------------------------------------------------
896 // Sauvegarde du point equidistant des edges de plus petit
897 // parametre sur les bissectrices.
898 // ----------------------------------------------------------------
900 Parama = Handle(Bisector_Curve)::DownCast(Bisector1->BasisCurve())
901 ->Parameter(PointOnSegment);
902 Paramb = Handle(Bisector_Curve)::DownCast(Bisector2->BasisCurve())
903 ->Parameter(PointOnSegment);
904 if(Parama < Param1 && Paramb < Param2) {
907 DistanceMini = Distance;
908 PointSolution = PointOnSegment;
909 SolutionValide = Standard_True;
915 if(Intersect.NbPoints() != 1) {
916 for(Standard_Integer i=1; i<=Intersect.NbPoints(); i++) {
917 if(IsSameDistance(BisectorOne,BisectorTwo,
918 Intersect.Point(i).Value(),Distance) &&
919 Distance > Tolerance ) {
920 Parama = Intersect.Point(i).ParamOnFirst();
921 Paramb = Intersect.Point(i).ParamOnSecond();
922 if (Parama < Param1 && Paramb < Param2) {
925 DistanceMini = Distance;
926 PointSolution = Intersect.Point(i).Value();
927 SolutionValide = Standard_True;
933 PointSolution = Intersect.Point(1).Value();
934 Param1 = Intersect.Point(1).ParamOnFirst();
935 Param2 = Intersect.Point(1).ParamOnSecond();
936 SolutionValide = IsSameDistance(BisectorOne,BisectorTwo,
937 PointSolution,DistanceMini);
940 if (!SolutionValide) return Precision::Infinite();
942 theGeomPnts.Bind(theNumberOfPnts,PointSolution);
943 IntPnt = theNumberOfPnts;
945 //-----------------------------------------------------------------------
946 // Si le point d intersection est quasi confondue avec une des extremites
947 // de l une ou l autre des bisectrices, l intersection n est pas validee.
949 // SAUF si une des bisectrices est issue d une connexion et que les
950 // edges separes par les bissectrices sont des voisines sur le contour
952 // en effet le milieu de la connexion P qui est l origine d une des
953 // bissectrices peut etre sur l autre bissectrice.
954 // P est donc point d intersection
955 // et la bissectrice issue de la connexion est de longueur nulle.
956 // (ex : un rectangle dans un rectangle ou la connexion est entre un coin
958 //-----------------------------------------------------------------------
960 Standard_Integer IndexEdge1,IndexEdge2,IndexEdge3,IndexEdge4;
961 Standard_Boolean ExtremiteControle = Standard_True;
963 IndexEdge1 = BisectorOne->FirstEdge() ->EdgeNumber();
964 IndexEdge2 = BisectorOne->SecondEdge()->EdgeNumber();
965 IndexEdge3 = BisectorTwo->FirstEdge() ->EdgeNumber();
966 IndexEdge4 = BisectorTwo->SecondEdge()->EdgeNumber();
968 if (theCircuit->ConnexionOn(IndexEdge2)){
969 // --------------------------------------
970 // BisectorOne est issue d une connexion.
971 // --------------------------------------
972 if (AreNeighbours(IndexEdge1,IndexEdge2,NumberOfItems()) &&
973 AreNeighbours(IndexEdge3,IndexEdge4,NumberOfItems()) &&
974 IndexEdge2 == IndexEdge3 ){
975 ExtremiteControle = Standard_False;
976 Param1 = Param1 + Tolerance;
980 if (theCircuit->ConnexionOn(IndexEdge4)){
981 //--------------------------------------
982 //BisectorTwo est issue d une connexion.
983 //--------------------------------------
984 if (AreNeighbours(IndexEdge1,IndexEdge2,NumberOfItems()) &&
985 AreNeighbours(IndexEdge3,IndexEdge4,NumberOfItems()) &&
986 IndexEdge2 == IndexEdge3 ){
987 ExtremiteControle = Standard_False;
988 Param2 = Param2 + Tolerance;
992 //if (ExtremiteControle) {
993 // if(Bisector1->StartPoint().Distance(PointSolution) < Tolerance ||
994 // Bisector2->StartPoint().Distance(PointSolution) < Tolerance )
995 // return Precision::Infinite();
998 if(ExtremiteControle)
1000 if(Bisector1->StartPoint().Distance(PointSolution) < Tolerance)
1005 DrawTrSurf::Set("Bis1", Bisector1);
1006 DrawTrSurf::Set("Bis2", Bisector2);
1009 return Precision::Infinite();
1011 if(Bisector2->StartPoint().Distance(PointSolution) < Tolerance)
1017 DrawTrSurf::Set("Bis1", Bisector1);
1018 DrawTrSurf::Set("Bis2", Bisector2);
1021 return Precision::Infinite();
1027 if(BisectorOne->SecondParameter() < Precision::Infinite() &&
1028 BisectorOne->SecondParameter() < Param1*(1. - Tolerance ))
1029 return Precision::Infinite();
1031 if(BisectorTwo->FirstParameter() < Precision::Infinite() &&
1032 BisectorTwo->FirstParameter() < Param2*(1.- Tolerance))
1033 return Precision::Infinite();
1035 BisectorOne->SecondParameter(Param1);
1036 BisectorTwo->FirstParameter (Param2);
1041 cout<<" coordonnees : "<<GeomPnt (IntPnt).X()<<" "
1042 <<GeomPnt (IntPnt).Y()<<endl;
1043 cout<<" parametres : "<<Param1<<" "<<Param2<<endl;
1044 cout<<" distancemini : "<<DistanceMini<<endl;
1048 return DistanceMini;
1051 //=============================================================================
1052 //function : Distance
1054 //=============================================================================
1055 Standard_Real MAT2d_Tool2d::Distance(const Handle(MAT_Bisector)& Bis,
1056 const Standard_Real Param1,
1057 const Standard_Real Param2) const
1059 Standard_Real Dist = Precision::Infinite();
1061 if (Param1 != Precision::Infinite() && Param2 != Precision::Infinite()) {
1062 gp_Pnt2d P1 = GeomBis(Bis->BisectorNumber()).Value()->Value(Param1);
1063 gp_Pnt2d P2 = GeomBis(Bis->BisectorNumber()).Value()->Value(Param2);
1064 Dist = P1.Distance(P2);
1069 //=============================================================================
1072 //=============================================================================
1074 void MAT2d_Tool2d::Dump(const Standard_Integer ,
1075 const Standard_Integer ) const
1077 Standard_NotImplemented::Raise();
1079 void MAT2d_Tool2d::Dump(const Standard_Integer bisector,
1080 const Standard_Integer) const
1082 if(bisector == -1) return;
1083 if(bisector > theNumberOfBisectors) return;
1085 Handle(Geom2d_Curve) thebisector = Handle(Geom2d_Curve)::DownCast(GeomBis(bisector).Value());
1087 MAT2d_DrawCurve(thebisector,3);
1093 //=============================================================================
1094 //function : GeomBis
1096 //=============================================================================
1097 const Bisector_Bisec& MAT2d_Tool2d::GeomBis (const Standard_Integer Index)
1100 return theGeomBisectors.Find(Index);
1103 //=============================================================================
1104 //function : ChangeGeomBis
1106 //=============================================================================
1107 Bisector_Bisec& MAT2d_Tool2d::ChangeGeomBis(const Standard_Integer Index)
1109 return theGeomBisectors.ChangeFind(Index);
1113 //=============================================================================
1114 //function : GeomElt
1116 //=============================================================================
1117 Handle(Geom2d_Geometry) MAT2d_Tool2d::GeomElt(const Standard_Integer Index)
1120 return theCircuit->Value(Index);
1124 //=============================================================================
1125 //function : GeomPnt
1127 //=============================================================================
1128 const gp_Pnt2d& MAT2d_Tool2d::GeomPnt(const Standard_Integer Index) const
1130 return theGeomPnts.Find(Index);
1133 //=============================================================================
1134 //function : GeomVec
1136 //=============================================================================
1137 const gp_Vec2d& MAT2d_Tool2d::GeomVec(const Standard_Integer Index)const
1139 return theGeomVecs.Find(Index);
1142 //=============================================================================
1143 //function : Circuit
1145 //=============================================================================
1146 Handle(MAT2d_Circuit) MAT2d_Tool2d::Circuit()const
1151 //=============================================================================
1152 //function : BisecFusion
1154 //=============================================================================
1155 void MAT2d_Tool2d::BisecFusion(const Standard_Integer I1,
1156 const Standard_Integer I2)
1158 Standard_Real DU,UL1,UF1;
1159 Handle(Geom2d_TrimmedCurve) Bisector1;
1160 Handle(Geom2d_TrimmedCurve) Bisector2;
1162 Bisector1 = Handle(Geom2d_TrimmedCurve)::DownCast(GeomBis(I1).Value());
1163 Bisector2 = Handle(Geom2d_TrimmedCurve)::DownCast(GeomBis(I2).Value());
1164 UF1 = Bisector1->FirstParameter();
1165 UL1 = Bisector1->LastParameter();
1167 Handle(Standard_Type) Type1 = Bisector1->BasisCurve()->DynamicType();
1168 if (Type1 == STANDARD_TYPE(Bisector_BisecCC)) {
1169 //------------------------------------------------------------------------------------
1170 // les bissectrice courbe/courbe sont construites avec un point de depart
1171 // elles ne peuvent pas etre trimes par un point se trouvant de l autre cote du
1173 // pour faire la fusion des deux bissectrices on reconstruit la bissectrice entre les
1174 // deux courbes avec comme point de depart le dernier point de la Bisector2.
1175 // on trime ensuite la courbe par le dernier point de Bisector1.
1176 //------------------------------------------------------------------------------------
1177 Standard_Real Tolerance = MAT2d_TOLCONF;
1180 gp_Pnt2d P2 = Bisector2->Value(Bisector2->LastParameter());
1181 gp_Pnt2d P1 = Bisector1->Value(Bisector1->LastParameter());
1182 Handle(Bisector_BisecCC) BCC1 = Handle(Bisector_BisecCC)::DownCast(Bisector1->BasisCurve());
1184 Bis.Perform(BCC1->Curve(2), BCC1->Curve(1), P2, VBid, VBid,
1185 theDirection, theJoinType, Tolerance, Standard_False);
1187 Bisector1 = Handle(Geom2d_TrimmedCurve)::DownCast(Bis.Value());
1188 BCC1 = Handle(Bisector_BisecCC) ::DownCast(Bisector1->BasisCurve());
1189 UF1 = BCC1->FirstParameter();
1190 UL1 = BCC1->Parameter(P1);
1191 Bisector1->SetTrim(UF1,UL1);
1192 theGeomBisectors.Bind(I1,Bis);
1195 DU = Bisector2->LastParameter() - Bisector2->FirstParameter();
1198 Handle(Bisector_BisecAna) BAna = Handle(Bisector_BisecAna)::DownCast(Bisector1->BasisCurve());
1199 //---------------------------- uncomment if new method Bisector_BisecAna::SetTrim(f,l) is not used
1200 // Handle(Geom2d_Curve) C2d = BAna->Geom2dCurve();
1201 // Handle(Geom2d_TrimmedCurve) trimC2d = new Geom2d_TrimmedCurve(C2d, UF1, UL1);
1202 // BAna->Init(trimC2d);
1203 //--------------------------- end
1204 BAna->SetTrim(UF1,UL1); // put comment if SetTrim(f,l) is not used
1206 Bisector1->SetTrim(UF1,UL1);
1210 //=============================================================================
1213 //=============================================================================
1214 static Handle(Standard_Type) Type(const Handle(Geom2d_Geometry)& aGeom)
1216 Handle(Standard_Type) type = aGeom->DynamicType();
1217 Handle(Geom2d_Curve) curve;
1219 if (type == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
1220 curve = Handle(Geom2d_TrimmedCurve)::DownCast(aGeom)->BasisCurve();
1221 type = curve->DynamicType();
1226 //==========================================================================
1227 //function : AreNeighbours
1228 //purpose : Return TRUE si IEdge1 et IEdge2 correspondent a des elements
1229 // consecutifs sur un contour ferme de NbEdge elements.
1230 //==========================================================================
1231 Standard_Boolean AreNeighbours(const Standard_Integer IEdge1,
1232 const Standard_Integer IEdge2,
1233 const Standard_Integer NbEdge)
1235 if (Abs(IEdge1 - IEdge2) == 1) return Standard_True;
1236 else if (Abs(IEdge1 - IEdge2) == NbEdge -1) return Standard_True;
1237 else return Standard_False;
1240 //==========================================================================
1241 //function : SetTrim
1243 //==========================================================================
1244 static void SetTrim(Bisector_Bisec& Bis, const Handle(Geom2d_Curve)& Line1)
1246 Geom2dInt_GInter Intersect;
1247 Standard_Real Distance;
1248 Standard_Real Tolerance = MAT2d_TOLCONF;
1249 Handle(Geom2d_TrimmedCurve) Bisector =
1250 Handle(Geom2d_TrimmedCurve)::DownCast(Bis.ChangeValue());
1252 IntRes2d_Domain Domain1 = Domain(Bisector,Tolerance);
1253 Standard_Real UB1 = Bisector->FirstParameter();
1254 Standard_Real UB2 = Bisector->LastParameter();
1256 gp_Pnt2d FirstPointBisector = Bisector->Value(UB1);
1257 Standard_Real UTrim = Precision::Infinite();
1259 Geom2dAdaptor_Curve AdapBisector(Bisector);
1260 Geom2dAdaptor_Curve AdapLine1 (Line1);
1261 Intersect.Perform(AdapBisector, Domain1,
1262 AdapLine1, Tolerance, Tolerance);
1264 if (Intersect.IsDone() && !Intersect.IsEmpty()) {
1265 for (Standard_Integer i = 1; i <= Intersect.NbPoints(); i++) {
1266 gp_Pnt2d PInt = Intersect.Point(i).Value();
1267 Distance = FirstPointBisector.Distance(PInt);
1268 if (Distance > 10.*Tolerance &&
1269 Intersect.Point(i).ParamOnFirst() < UTrim ) {
1270 UTrim = Intersect.Point(i).ParamOnFirst();
1274 // ------------------------------------------------------------------------
1275 // Restriction de la Bissectrice par le point d intersection de plus petit
1277 // ------------------------------------------------------------------------
1278 if (UTrim < UB2 && UTrim > UB1) Bisector->SetTrim(UB1,UTrim);
1281 //==========================================================================
1284 //==========================================================================
1285 IntRes2d_Domain Domain(const Handle(Geom2d_TrimmedCurve)& Bisector1,
1286 const Standard_Real Tolerance)
1288 Standard_Real Param1 = Bisector1->FirstParameter();
1289 Standard_Real Param2 = Bisector1->LastParameter();
1290 if(Param2 > 10000.) {
1292 Handle(Standard_Type) Type1 = Type(Bisector1->BasisCurve());
1293 Handle(Geom2d_Curve) BasisCurve;
1294 if (Type1 == STANDARD_TYPE(Bisector_BisecAna)) {
1295 BasisCurve = Handle(Bisector_BisecAna)
1296 ::DownCast(Bisector1->BasisCurve())->Geom2dCurve();
1297 Type1 = BasisCurve->DynamicType();
1299 gp_Parab2d gpParabola;
1300 gp_Hypr2d gpHyperbola;
1301 Standard_Real Focus;
1302 Standard_Real Limit = 50000.;
1303 if (Type1 == STANDARD_TYPE(Geom2d_Parabola)) {
1304 gpParabola = Handle(Geom2d_Parabola)::DownCast(BasisCurve)->Parab2d();
1305 Focus = gpParabola.Focal();
1306 Standard_Real Val1 = Sqrt(Limit*Focus);
1307 Standard_Real Val2 = Sqrt(Limit*Limit);
1308 Param2 = (Val1 <= Val2 ? Val1:Val2);
1310 else if (Type1 == STANDARD_TYPE(Geom2d_Hyperbola)) {
1311 gpHyperbola = Handle(Geom2d_Hyperbola)::DownCast(BasisCurve)->Hypr2d();
1312 Standard_Real Majr = gpHyperbola.MajorRadius();
1313 Standard_Real Minr = gpHyperbola.MinorRadius();
1314 Standard_Real Valu1 = Limit/Majr;
1315 Standard_Real Valu2 = Limit/Minr;
1316 Standard_Real Val1 = Log(Valu1+Sqrt(Valu1*Valu1-1));
1317 Standard_Real Val2 = Log(Valu2+Sqrt(Valu2*Valu2+1));
1318 Param2 = (Val1 <= Val2 ? Val1:Val2);
1322 IntRes2d_Domain Domain1(Bisector1->Value(Param1),Param1,Tolerance,
1323 Bisector1->Value(Param2),Param2,Tolerance);
1324 if(Bisector1->BasisCurve()->IsPeriodic()) {
1325 Domain1.SetEquivalentParameters(0.,2.*M_PI);
1330 //=============================================================================
1331 //function : CheckEnds
1333 //=============================================================================
1334 Standard_Boolean CheckEnds (const Handle(Geom2d_Geometry)& Elt ,
1335 const gp_Pnt2d& PCom ,
1336 const Standard_Real Distance,
1337 const Standard_Real Tol)
1340 Handle(Standard_Type) Type = Elt->DynamicType();
1341 Handle(Geom2d_TrimmedCurve) Curve;
1343 if (Type == STANDARD_TYPE(Geom2d_CartesianPoint)) {
1344 return Standard_False;
1347 Curve = Handle(Geom2d_TrimmedCurve)::DownCast(Elt);
1348 gp_Pnt2d aPf = Curve->StartPoint();
1349 gp_Pnt2d aPl = Curve->EndPoint();
1350 Standard_Real df = PCom.Distance(aPf);
1351 Standard_Real dl = PCom.Distance(aPl);
1352 if(Abs(df - Distance) <= Tol)
1353 return Standard_True;
1354 if(Abs(dl - Distance) <= Tol)
1355 return Standard_True;
1357 return Standard_False;
1362 //==========================================================================
1363 //function : MAT2d_DrawCurve
1364 //purpose : Affichage d une courbe <aCurve> de Geom2d. dans une couleur
1365 // definie par <Indice>.
1366 // Indice = 1 jaune,
1368 // Indice = 3 rouge,
1370 //==========================================================================
1371 void MAT2d_DrawCurve(const Handle(Geom2d_Curve)& aCurve,
1372 const Standard_Integer /*Indice*/)
1374 Handle(Standard_Type) type = aCurve->DynamicType();
1375 Handle(Geom2d_Curve) curve,CurveDraw;
1377 Handle(DrawTrSurf_Curve2d) dr;
1381 if (type == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
1382 curve = Handle(Geom2d_TrimmedCurve)::DownCast(aCurve)->BasisCurve();
1383 type = curve->DynamicType();
1384 // PB de representation des courbes semi_infinies.
1385 gp_Parab2d gpParabola;
1386 gp_Hypr2d gpHyperbola;
1387 Standard_Real Focus;
1388 Standard_Real Limit = 50000.;
1389 Standard_Real delta = 400;
1391 // PB de representation des courbes semi_infinies.
1392 if (aCurve->LastParameter() == Precision::Infinite()) {
1394 if (type == STANDARD_TYPE(Geom2d_Parabola)) {
1395 gpParabola = Handle(Geom2d_Parabola)::DownCast(curve)->Parab2d();
1396 Focus = gpParabola.Focal();
1397 Standard_Real Val1 = Sqrt(Limit*Focus);
1398 Standard_Real Val2 = Sqrt(Limit*Limit);
1399 delta= (Val1 <= Val2 ? Val1:Val2);
1401 else if (type == STANDARD_TYPE(Geom2d_Hyperbola)) {
1402 gpHyperbola = Handle(Geom2d_Hyperbola)::DownCast(curve)->Hypr2d();
1403 Standard_Real Majr = gpHyperbola.MajorRadius();
1404 Standard_Real Minr = gpHyperbola.MinorRadius();
1405 Standard_Real Valu1 = Limit/Majr;
1406 Standard_Real Valu2 = Limit/Minr;
1407 Standard_Real Val1 = Log(Valu1+Sqrt(Valu1*Valu1-1));
1408 Standard_Real Val2 = Log(Valu2+Sqrt(Valu2*Valu2+1));
1409 delta = (Val1 <= Val2 ? Val1:Val2);
1411 CurveDraw = new Geom2d_TrimmedCurve(aCurve,
1412 aCurve->FirstParameter(),
1413 aCurve->FirstParameter() + delta);
1425 Standard_Integer Indice = 1;
1426 if (Indice == 1) Couleur = Draw_jaune;
1427 else if (Indice == 2) Couleur = Draw_bleu;
1428 else if (Indice == 3) Couleur = Draw_rouge;
1429 else if (Indice == 4) Couleur = Draw_vert;
1431 if (type == STANDARD_TYPE(Geom2d_Circle))
1432 dr = new DrawTrSurf_Curve2d(CurveDraw,Couleur,30);
1433 else if (type == STANDARD_TYPE(Geom2d_Line))
1434 dr = new DrawTrSurf_Curve2d(CurveDraw,Couleur,2);
1436 dr = new DrawTrSurf_Curve2d(CurveDraw,Couleur,500);