// commercial license or contractual agreement.
#define Debug(expr) cout<<" MAT2d_Tool2d.cxx : expr :"<<expr<<endl;
-
+//#define OCCT_DEBUG
+//#define DRAW
#ifdef DRAW
#include <DBRep.hxx>
#include <DrawTrSurf.hxx>
#include <Precision.hxx>
#ifdef DRAW
- static Handle(DrawTrSurf_Curve2d) draw;
+static Handle(DrawTrSurf_Curve2d) draw;
+static Standard_Integer AffichBis = Standard_False;
#endif
#ifdef OCCT_DEBUG
- static void MAT2d_DrawCurve(const Handle(Geom2d_Curve)& aCurve,
- const Standard_Integer Indice);
- static Standard_Boolean Store = Standard_False;
+static void MAT2d_DrawCurve(const Handle(Geom2d_Curve)& aCurve,
+ const Standard_Integer Indice);
+static Standard_Boolean Store = Standard_False;
+static Standard_Boolean AffichDist = Standard_False;
#endif
//=====================================================================
//=====================================================================
static IntRes2d_Domain Domain
(const Handle(Geom2d_TrimmedCurve)& Bisector1,
- const Standard_Real Tolerance);
+ const Standard_Real Tolerance);
static Handle(Standard_Type) Type (const Handle(Geom2d_Geometry)& acurve);
static Standard_Boolean AreNeighbours(const Standard_Integer IEdge1,
- const Standard_Integer IEdge2,
- const Standard_Integer NbEdge);
+ const Standard_Integer IEdge2,
+ const Standard_Integer NbEdge);
static void SetTrim(Bisector_Bisec& Bis , Handle(Geom2d_Curve)& Line1);
+static Standard_Boolean CheckEnds (const Handle(Geom2d_Geometry)& Elt ,
+ const gp_Pnt2d& PCom ,
+ const Standard_Real Distance,
+ const Standard_Real Tol);
static Standard_Real MAT2d_TOLCONF = 1.e-7;
theNumberOfBisectors = 0;
theNumberOfVecs = 0;
theNumberOfPnts = 0;
-
+
theCircuit = EquiCircuit;
}
-
+
//=============================================================================
//function : Sense
//purpose :
//purpose :
//=============================================================================
Standard_Integer MAT2d_Tool2d::FirstPoint(const Standard_Integer anitem,
- Standard_Real& dist )
+ Standard_Real& dist )
{
Handle(Geom2d_Curve) curve;
Handle(Geom2d_Point) point;
gp_Pnt2d P1 = theCircuit->Connexion(anitem)->PointOnFirst();
gp_Pnt2d P2 = theCircuit->Connexion(anitem)->PointOnSecond();
theGeomPnts.Bind(theNumberOfPnts,gp_Pnt2d((P1.X() + P2.X())*0.5,
- (P1.Y() + P2.Y())*0.5));
+ (P1.Y() + P2.Y())*0.5));
dist = P1.Distance(P2)*0.5;
return theNumberOfPnts;
}
theNumberOfVecs++;
if (!IsOpenResult)
- item = (anitem == theCircuit->NumberOfItems()) ? 1 : (anitem + 1);
+ item = (anitem == theCircuit->NumberOfItems()) ? 1 : (anitem + 1);
else
item = (anitem == theCircuit->NumberOfItems()) ? (anitem - 1) : (anitem + 1);
if (theCircuit->ConnexionOn(item)){
}
else {
if (!IsOpenResult)
- item = (anitem == 1) ? theCircuit->NumberOfItems() : (anitem - 1);
+ item = (anitem == 1) ? theCircuit->NumberOfItems() : (anitem - 1);
else
item = (anitem == 1) ? 2 : (anitem - 1);
curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(item));
{
theNumberOfVecs++;
theGeomVecs.Bind(theNumberOfVecs,GeomBis(bisector).Value()
- ->DN(GeomBis(bisector).Value()
- ->LastParameter(),1));
+ ->DN(GeomBis(bisector).Value()
+ ->LastParameter(),1));
return theNumberOfVecs;
}
Standard_Integer edge1number = abisector->FirstEdge()->EdgeNumber();
Standard_Integer edge2number = abisector->SecondEdge()->EdgeNumber();
Standard_Boolean ontheline = AreNeighbours(edge1number,
- edge2number,
- NumberOfItems());
+ edge2number,
+ NumberOfItems());
Standard_Boolean InitialNeighbour = ontheline;
if(theCircuit->ConnexionOn(edge2number)) ontheline = Standard_False;
cout<<" Item 1 : "<<endl;
cout<<edge1number<<endl;
cout<<endl;
-// elt1->Dump(1,1);
+ // elt1->Dump(1,1);
cout<<endl;
cout<<" Item 2 : "<<endl;
cout<<edge2number<<endl;
cout<<endl;
-// elt2->Dump(1,1);
+ // elt2->Dump(1,1);
cout<<endl;
}
#endif
if(type1 != STANDARD_TYPE(Geom2d_CartesianPoint) &&
- type2 != STANDARD_TYPE(Geom2d_CartesianPoint)) {
- bisector.Perform(item1,item2,
- GeomPnt (abisector->IssuePoint()),
- GeomVec (abisector->FirstVector()),
- GeomVec (abisector->SecondVector()),
- theDirection,tolerance,ontheline);
+ type2 != STANDARD_TYPE(Geom2d_CartesianPoint)) {
+ bisector.Perform(item1,item2,
+ GeomPnt (abisector->IssuePoint()),
+ GeomVec (abisector->FirstVector()),
+ GeomVec (abisector->SecondVector()),
+ theDirection,tolerance,ontheline);
}
else if(type1 == STANDARD_TYPE(Geom2d_CartesianPoint) &&
- type2 == STANDARD_TYPE(Geom2d_CartesianPoint)) {
- point1 = Handle(Geom2d_Point)::DownCast(elt1);
- point2 = Handle(Geom2d_Point)::DownCast(elt2);
- bisector.Perform(point1,point2,
- GeomPnt (abisector->IssuePoint()),
- GeomVec (abisector->FirstVector()),
- GeomVec (abisector->SecondVector()),
- theDirection,tolerance,ontheline);
+ type2 == STANDARD_TYPE(Geom2d_CartesianPoint)) {
+ point1 = Handle(Geom2d_Point)::DownCast(elt1);
+ point2 = Handle(Geom2d_Point)::DownCast(elt2);
+ bisector.Perform(point1,point2,
+ GeomPnt (abisector->IssuePoint()),
+ GeomVec (abisector->FirstVector()),
+ GeomVec (abisector->SecondVector()),
+ theDirection,tolerance,ontheline);
}
else if(type1 == STANDARD_TYPE(Geom2d_CartesianPoint)) {
point1 = Handle(Geom2d_Point)::DownCast(elt1);
bisector.Perform(point1,item2,
- GeomPnt (abisector->IssuePoint()),
- GeomVec (abisector->FirstVector()),
- GeomVec (abisector->SecondVector()),
- theDirection,tolerance,ontheline);
+ GeomPnt (abisector->IssuePoint()),
+ GeomVec (abisector->FirstVector()),
+ GeomVec (abisector->SecondVector()),
+ theDirection,tolerance,ontheline);
}
else {
point2 = Handle(Geom2d_Point)::DownCast(elt2);
bisector.Perform(item1,point2,
- GeomPnt (abisector->IssuePoint()),
- GeomVec (abisector->FirstVector()),
- GeomVec (abisector->SecondVector()),
- theDirection,tolerance,ontheline);
+ GeomPnt (abisector->IssuePoint()),
+ GeomVec (abisector->FirstVector()),
+ GeomVec (abisector->SecondVector()),
+ theDirection,tolerance,ontheline);
}
//------------------------------
Handle(Geom2d_Curve) BasisCurve;
if (Type1 == STANDARD_TYPE(Bisector_BisecAna)) {
BasisCurve = Handle(Bisector_BisecAna)
- ::DownCast(bisector.Value()->BasisCurve())->Geom2dCurve();
+ ::DownCast(bisector.Value()->BasisCurve())->Geom2dCurve();
#ifdef DRAW
char *name = new char[100];
sprintf(name,"BISSEC_%d",abisector->BisectorNumber());
// Cette restriction est necessaire a la logique de l algorithme.
//=============================================================================
void MAT2d_Tool2d::TrimBisec ( Bisector_Bisec& B1,
- const Standard_Integer IndexEdge,
- const Standard_Boolean InitialNeighbour,
- const Standard_Integer StartOrEnd ) const
+ const Standard_Integer IndexEdge,
+ const Standard_Boolean InitialNeighbour,
+ const Standard_Integer StartOrEnd ) const
{
Handle(Geom2d_Curve) Curve;
Handle(Geom2d_TrimmedCurve) LineSupportDomain,Line;
Handle(Geom2d_Line) Line1,Line2;
-
+
//gp_Vec2d Tan1,Tan2;
gp_Pnt2d Ori; //PEdge;
Standard_Integer INext;
INext = (IndexEdge == theCircuit->NumberOfItems()) ? 1 : (IndexEdge + 1);
-
+
Handle(Standard_Type) EdgeType = theCircuit->Value(IndexEdge)->DynamicType();
-
+
if (EdgeType != STANDARD_TYPE(Geom2d_CartesianPoint)) {
if(!InitialNeighbour) {
Curve = Handle(Geom2d_TrimmedCurve)
- ::DownCast(theCircuit->Value(IndexEdge))->BasisCurve();
+ ::DownCast(theCircuit->Value(IndexEdge))->BasisCurve();
EdgeType = Curve->DynamicType();
//-------------------------------------------------------------------
// si l edge est liee a sa voisine precedente par une connexion.
//-------------------------------------------------------------------
if (theCircuit->ConnexionOn(IndexEdge) && StartOrEnd == 1){
- if (EdgeType == STANDARD_TYPE(Geom2d_Circle)) {
- Ori = Handle(Geom2d_Circle)::DownCast(Curve)->Location();
- gp_Pnt2d P2 = theCircuit->Connexion(IndexEdge)->PointOnFirst();
- Line1 = new Geom2d_Line (Ori,gp_Dir2d(P2.X() - Ori.X(),
- P2.Y() - Ori.Y()));
- }
+ if (EdgeType == STANDARD_TYPE(Geom2d_Circle)) {
+ Ori = Handle(Geom2d_Circle)::DownCast(Curve)->Location();
+ gp_Pnt2d P2 = theCircuit->Connexion(IndexEdge)->PointOnFirst();
+ Line1 = new Geom2d_Line (Ori,gp_Dir2d(P2.X() - Ori.X(),
+ P2.Y() - Ori.Y()));
+ }
}
//-----------------------------------------------------------------------
// Si l edge est liee a sa voisine suivante par une connexion.
//-----------------------------------------------------------------------
if (theCircuit->ConnexionOn(INext) && StartOrEnd == 2){
- if (EdgeType == STANDARD_TYPE(Geom2d_Circle)) {
- Ori = Handle(Geom2d_Circle)::DownCast(Curve)->Location();
- gp_Pnt2d P2 = theCircuit->Connexion(INext)->PointOnSecond();
- Line2 = new Geom2d_Line (Ori,gp_Dir2d(P2.X() - Ori.X(),
- P2.Y() - Ori.Y()));
- }
+ if (EdgeType == STANDARD_TYPE(Geom2d_Circle)) {
+ Ori = Handle(Geom2d_Circle)::DownCast(Curve)->Location();
+ gp_Pnt2d P2 = theCircuit->Connexion(INext)->PointOnSecond();
+ Line2 = new Geom2d_Line (Ori,gp_Dir2d(P2.X() - Ori.X(),
+ P2.Y() - Ori.Y()));
+ }
}
if (Line1.IsNull() && Line2.IsNull()) return;
// si elles existent.
//-----------------------------------------------------------------------
if (!Line1.IsNull()) {
- Line = new Geom2d_TrimmedCurve(Line1,0.,Precision::Infinite());
- SetTrim(B1,Line);
+ Line = new Geom2d_TrimmedCurve(Line1,0.,Precision::Infinite());
+ SetTrim(B1,Line);
}
if (!Line2.IsNull()) {
- Line = new Geom2d_TrimmedCurve(Line2,0.,Precision::Infinite());
- SetTrim(B1,Line);
+ Line = new Geom2d_TrimmedCurve(Line2,0.,Precision::Infinite());
+ SetTrim(B1,Line);
}
}
}
Handle(Geom2d_TrimmedCurve)
bisector = Handle(Geom2d_TrimmedCurve)
- ::DownCast(ChangeGeomBis(abisector->BisectorNumber()).ChangeValue());
-
+ ::DownCast(ChangeGeomBis(abisector->BisectorNumber()).ChangeValue());
+
if(bisector->BasisCurve()->IsPeriodic() && param == Precision::Infinite()) {
param = bisector->FirstParameter() + 2*M_PI;
}
if (param > bisector->BasisCurve()->LastParameter()) {
- param = bisector->BasisCurve()->LastParameter();
+ param = bisector->BasisCurve()->LastParameter();
}
if(bisector->FirstParameter() == param) return Standard_False;
//=============================================================================
Standard_Boolean MAT2d_Tool2d::TrimBisector
(const Handle(MAT_Bisector)& abisector,
- const Standard_Integer apoint)
+ const Standard_Integer apoint)
{
Standard_Real Param;
Handle(Geom2d_TrimmedCurve)
Bisector = Handle(Geom2d_TrimmedCurve)::
- DownCast(ChangeGeomBis(abisector->BisectorNumber()).ChangeValue());
+ DownCast(ChangeGeomBis(abisector->BisectorNumber()).ChangeValue());
Handle(Bisector_Curve) Bis = Handle(Bisector_Curve)::
DownCast(Bisector->BasisCurve());
-// Param = ParameterOnCurve(Bisector,theGeomPnts.Value(apoint));
+ // Param = ParameterOnCurve(Bisector,theGeomPnts.Value(apoint));
Param = Bis->Parameter(GeomPnt (apoint));
if (Bisector->BasisCurve()->IsPeriodic()) {
//purpose :
//=============================================================================
Standard_Boolean MAT2d_Tool2d::Projection (const Standard_Integer IEdge ,
- const gp_Pnt2d& PCom ,
- Standard_Real& Distance)
- const
+ const gp_Pnt2d& PCom ,
+ Standard_Real& Distance)
+ const
{
gp_Pnt2d PEdge;
Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge);
if (theCircuit->ConnexionOn(INext)) {
ParamMax = theCircuit->Connexion(INext)->ParameterOnFirst();
if (Curve->BasisCurve()->IsPeriodic()){
- ElCLib::AdjustPeriodic(0.,2*M_PI,Eps,ParamMin,ParamMax);
+ ElCLib::AdjustPeriodic(0.,2*M_PI,Eps,ParamMin,ParamMax);
}
}
//---------------------------------------------------------------------
GeomAbs_CurveType TypeC1 = C1.GetType();
if (TypeC1 == GeomAbs_Circle) {
Standard_Real R = C1.Circle().Radius();
- Standard_Real EpsCirc = Eps;
+ Standard_Real EpsCirc = 100.*Eps;
if ( R < 1.) EpsCirc = Eps/R;
- if (!((ParamMax - ParamMin + 2*EpsCirc) < 2*M_PI)) {
- ParamMax = ParamMax + EpsCirc; ParamMin = ParamMin - EpsCirc;
+ if (((ParamMax - ParamMin + 2*EpsCirc) < 2*M_PI)) {
+ ParamMax = ParamMax + EpsCirc; ParamMin = ParamMin - EpsCirc;
}
}
else {
//-----------------------------------------------------
Extrema_ExtPC2d Extremas(PCom,C1,ParamMin,ParamMax);
if (Extremas.IsDone()){
- if (Extremas.NbExt() == 0 ) return Standard_False; // Pas de solution!
+ Distance = Precision::Infinite();
+ if(Extremas.NbExt() < 1)
+ {
+ return Standard_False;
+ }
for (Standard_Integer i = 1; i <= Extremas.NbExt(); i++) {
- if (Extremas.SquareDistance(i) < Distance * Distance) {
- Distance = sqrt (Extremas.SquareDistance(i));
- }
+ if (Extremas.SquareDistance(i) < Distance) {
+ Distance = Extremas.SquareDistance(i);
+ }
}
+ Distance = Sqrt(Distance);
}
else {
if (TypeC1 == GeomAbs_Circle) {
- Distance = C1.Circle().Radius();
+ Distance = C1.Circle().Radius();
}
}
}
// purpose :
//=============================================================================
Standard_Boolean MAT2d_Tool2d::IsSameDistance (
- const Handle(MAT_Bisector)& BisectorOne,
- const Handle(MAT_Bisector)& BisectorTwo,
- const gp_Pnt2d& PCom,
- Standard_Real& Distance) const
+ const Handle(MAT_Bisector)& BisectorOne,
+ const Handle(MAT_Bisector)& BisectorTwo,
+ const gp_Pnt2d& PCom,
+ Standard_Real& Distance) const
{
TColStd_Array1OfReal Dist(1,4);
+ const Standard_Real eps = 1.e-7;
Standard_Integer IEdge1,IEdge2,IEdge3,IEdge4;
IEdge1 = BisectorOne->FirstEdge() ->EdgeNumber();
IEdge3 = BisectorTwo->FirstEdge() ->EdgeNumber();
IEdge4 = BisectorTwo->SecondEdge()->EdgeNumber();
- Projection(IEdge1,PCom,Dist(1));
- Projection(IEdge2,PCom,Dist(2));
+ Standard_Boolean isDone1 = Projection(IEdge1,PCom,Dist(1));
+ Standard_Boolean isDone2 = Projection(IEdge2,PCom,Dist(2));
+
+ if(isDone1)
+ {
+ if(!isDone2)
+ {
+ Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge2);
+ Standard_Real Tol = Max(Precision::Confusion(), eps*Dist(1));
+ if(CheckEnds (Elt, PCom, Dist(1), Tol))
+ {
+ Dist(2) = Dist(1);
+ }
+ }
+ }
+ else
+ {
+ if(isDone2)
+ {
+ Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge1);
+ Standard_Real Tol = Max(Precision::Confusion(), eps*Dist(2));
+ if(CheckEnds (Elt, PCom, Dist(2), Tol))
+ {
+ Dist(1) = Dist(2);
+ }
+ }
+ }
+ Standard_Boolean isDone3 = Standard_True, isDone4 = Standard_True;
if (IEdge3 == IEdge1) Dist(3) = Dist(1);
else if (IEdge3 == IEdge2) Dist(3) = Dist(2);
- else Projection(IEdge3,PCom,Dist(3));
+ else isDone3 = Projection(IEdge3,PCom,Dist(3));
if (IEdge4 == IEdge1) Dist(4) = Dist(1);
else if (IEdge4 == IEdge2) Dist(4) = Dist(2);
- else Projection(IEdge4,PCom,Dist(4));
+ else isDone4 = Projection(IEdge4,PCom,Dist(4));
+ //
+ if(isDone3)
+ {
+ if(!isDone4)
+ {
+ Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge4);
+ Standard_Real Tol = Max(Precision::Confusion(), eps*Dist(3));
+ if(CheckEnds (Elt, PCom, Dist(3), Tol))
+ {
+ Dist(4) = Dist(3);
+ }
+ }
+ }
+ else
+ {
+ if(isDone4)
+ {
+ Handle(Geom2d_Geometry) Elt = theCircuit->Value(IEdge3);
+ Standard_Real Tol = Max(Precision::Confusion(), eps*Dist(4));
+ if(CheckEnds (Elt, PCom, Dist(4), Tol))
+ {
+ Dist(3) = Dist(4);
+ }
+ }
+ }
#ifdef OCCT_DEBUG
- Standard_Boolean Affich = Standard_False;
- if (Affich)
+ if (AffichDist)
for (Standard_Integer j = 1; j <= 4;j++){
cout <<"Distance number : "<<j<<" is :"<< Dist(j)<<endl;
}
#endif
- Standard_Real EpsDist = MAT2d_TOLCONF*100. ;
- Distance = Dist(1);
- for (Standard_Integer i = 1; i <= 4; i++){
+ Standard_Real EpsDist = MAT2d_TOLCONF*300. ;
+ Distance = Dist(1);
+ for (Standard_Integer i = 1; i <= 4; i++){
if (theJoinType == GeomAbs_Intersection &&
Precision::IsInfinite(Dist(i)))
continue;
- if (Abs(Dist(i) - Distance) > EpsDist) {
- Distance = Precision::Infinite();
- return Standard_False;
+ if (Abs(Dist(i) - Distance) > EpsDist) {
+ Distance = Precision::Infinite();
+ return Standard_False;
+ }
}
- }
- return Standard_True;
+ return Standard_True;
}
//=============================================================================
//purpose :
//=============================================================================
Standard_Real MAT2d_Tool2d::IntersectBisector (
- const Handle(MAT_Bisector)& BisectorOne,
- const Handle(MAT_Bisector)& BisectorTwo,
- Standard_Integer& IntPnt)
+ const Handle(MAT_Bisector)& BisectorOne,
+ const Handle(MAT_Bisector)& BisectorTwo,
+ Standard_Integer& IntPnt)
{
Standard_Real Tolerance = MAT2d_TOLCONF;
Standard_Real Param1,Param2;
Handle(Geom2d_TrimmedCurve)
Bisector1 = Handle(Geom2d_TrimmedCurve)
- ::DownCast(ChangeGeomBis(BisectorOne->BisectorNumber()).ChangeValue());
+ ::DownCast(ChangeGeomBis(BisectorOne->BisectorNumber()).ChangeValue());
Handle(Geom2d_TrimmedCurve)
Bisector2 = Handle(Geom2d_TrimmedCurve)
- ::DownCast(ChangeGeomBis(BisectorTwo->BisectorNumber()).ChangeValue());
+ ::DownCast(ChangeGeomBis(BisectorTwo->BisectorNumber()).ChangeValue());
if(Bisector1.IsNull() || Bisector2.IsNull()) return Precision::Infinite();
Standard_Integer IS2 = BisectorTwo->SecondEdge()->EdgeNumber();
Standard_Integer IF1 = BisectorOne->FirstEdge() ->EdgeNumber();
Standard_Integer IF2 = BisectorTwo->FirstEdge() ->EdgeNumber();
-
+
if (AreNeighbours(IF1,IS1,NumberOfItems()) &&
- AreNeighbours(IF2,IS2,NumberOfItems()) &&
- theCircuit->ConnexionOn(IS2) &&
- theCircuit->ConnexionOn(IS1) ) {
- Handle(MAT2d_Connexion) C1,C2;
- C1 = theCircuit->Connexion(IS1);
- C2 = theCircuit->Connexion(IS2);
- if (C2->IndexFirstLine() == C1->IndexSecondLine() &&
- C1->IndexFirstLine() == C2->IndexSecondLine() )
- return Precision::Infinite();
+ AreNeighbours(IF2,IS2,NumberOfItems()) &&
+ theCircuit->ConnexionOn(IS2) &&
+ theCircuit->ConnexionOn(IS1) ) {
+ Handle(MAT2d_Connexion) C1,C2;
+ C1 = theCircuit->Connexion(IS1);
+ C2 = theCircuit->Connexion(IS2);
+ if (C2->IndexFirstLine() == C1->IndexSecondLine() &&
+ C1->IndexFirstLine() == C2->IndexSecondLine() )
+ return Precision::Infinite();
}
// -----------------------------------------
IntRes2d_Domain Domain2 = Domain(Bisector2,Tolerance);
if (Domain1.LastParameter() - Domain1.FirstParameter() < Tolerance)
- return Precision::Infinite();
+ return Precision::Infinite();
if (Domain2.LastParameter() - Domain2.FirstParameter() < Tolerance)
- return Precision::Infinite();
+ return Precision::Infinite();
#ifdef OCCT_DEBUG
Standard_Boolean Affich = Standard_False;
if (Affich) {
cout<<endl;
cout<<"INTERSECTION de "<<BisectorOne->BisectorNumber()<<
- " et de "<<BisectorTwo->BisectorNumber()<<endl;
+ " et de "<<BisectorTwo->BisectorNumber()<<endl;
cout<<" Bisector 1 : "<<endl;
-// (Bisector1->BasisCurve())->Dump(-1,1);
+ // (Bisector1->BasisCurve())->Dump(-1,1);
cout<<endl;
Debug(Domain1.FirstParameter());
Debug(Domain1.LastParameter());
cout<<"-----------------"<<endl;
cout<<" Bisector 2 : "<<endl;
-// (Bisector2->BasisCurve())->Dump(-1,1);
+ // (Bisector2->BasisCurve())->Dump(-1,1);
cout<<endl;
Debug(Domain2.FirstParameter());
Debug(Domain2.LastParameter());
}
#endif
-// -------------------------
-// Calcul de l intersection.
-// -------------------------
+ // -------------------------
+ // Calcul de l intersection.
+ // -------------------------
Bisector_Inter Intersect;
Intersect.Perform (GeomBis(BisectorOne->BisectorNumber()),Domain1,
- GeomBis(BisectorTwo->BisectorNumber()),Domain2,
- Tolerance,Tolerance,Standard_True);
+ GeomBis(BisectorTwo->BisectorNumber()),Domain2,
+ Tolerance,Tolerance,Standard_True);
-// Geom2dInt_GInter Intersect;
-// Intersect.Perform(Bisector1,Domain1,Bisector2,Domain2,Tolerance,Tolerance);
+ // Geom2dInt_GInter Intersect;
+ // Intersect.Perform(Bisector1,Domain1,Bisector2,Domain2,Tolerance,Tolerance);
-// -------------------------------------------------------------------------
-// Exploitation du resultat de l intersection et selection du point solution
-// equidistant des deux edges et le plus proche en parametre de l origine
-// des bissectrices.
-// -------------------------------------------------------------------------
+ // -------------------------------------------------------------------------
+ // Exploitation du resultat de l intersection et selection du point solution
+ // equidistant des deux edges et le plus proche en parametre de l origine
+ // des bissectrices.
+ // -------------------------------------------------------------------------
if(!Intersect.IsDone()) return Precision::Infinite();
// equidistants des edges.
// ----------------------------------------------------------------
if ((Segment.HasFirstPoint() && Segment.HasLastPoint())) {
- gp_Pnt2d P1,P2;
- Standard_Real SegmentLength;
- P1 = Segment.FirstPoint().Value();
- P2 = Segment.LastPoint().Value();
- SegmentLength = P1.Distance(P2);
- if (SegmentLength <= Tolerance) {
- PointOnSegment = P1;
- if(IsSameDistance(BisectorOne,BisectorTwo,
- PointOnSegment,Distance))
- PointRetenu = Standard_True;
- }
- else if (SegmentLength <= MaxSegmentLength) {
- gp_Dir2d Dir(P2.X()-P1.X(),P2.Y()-P1.Y());
- Standard_Real Dist = 0.;
- while (Dist <= SegmentLength + Tolerance){
- PointOnSegment = P1.Translated(Dist*Dir);
- if(IsSameDistance(BisectorOne,BisectorTwo,
- PointOnSegment,Distance)) {
- PointRetenu = Standard_True;
- break;
- }
- Dist = Dist + Tolerance;
- }
- }
+ gp_Pnt2d P1,P2;
+ Standard_Real SegmentLength;
+ P1 = Segment.FirstPoint().Value();
+ P2 = Segment.LastPoint().Value();
+ SegmentLength = P1.Distance(P2);
+ if (SegmentLength <= Tolerance) {
+ PointOnSegment = P1;
+ if(IsSameDistance(BisectorOne,BisectorTwo,
+ PointOnSegment,Distance))
+ PointRetenu = Standard_True;
+ }
+ else if (SegmentLength <= MaxSegmentLength) {
+ gp_Dir2d Dir(P2.X()-P1.X(),P2.Y()-P1.Y());
+ Standard_Real Dist = 0.;
+ while (Dist <= SegmentLength + Tolerance){
+ PointOnSegment = P1.Translated(Dist*Dir);
+ if(IsSameDistance(BisectorOne,BisectorTwo,
+ PointOnSegment,Distance)) {
+ PointRetenu = Standard_True;
+ break;
+ }
+ Dist = Dist + Tolerance;
+ }
+ }
}
// ----------------------------------------------------------------
// parametre sur les bissectrices.
// ----------------------------------------------------------------
if(PointRetenu) {
- Parama = Handle(Bisector_Curve)::DownCast(Bisector1->BasisCurve())
- ->Parameter(PointOnSegment);
- Paramb = Handle(Bisector_Curve)::DownCast(Bisector2->BasisCurve())
- ->Parameter(PointOnSegment);
- if(Parama < Param1 && Paramb < Param2) {
- Param1 = Parama;
- Param2 = Paramb;
- DistanceMini = Distance;
- PointSolution = PointOnSegment;
- SolutionValide = Standard_True;
- }
+ Parama = Handle(Bisector_Curve)::DownCast(Bisector1->BasisCurve())
+ ->Parameter(PointOnSegment);
+ Paramb = Handle(Bisector_Curve)::DownCast(Bisector2->BasisCurve())
+ ->Parameter(PointOnSegment);
+ if(Parama < Param1 && Paramb < Param2) {
+ Param1 = Parama;
+ Param2 = Paramb;
+ DistanceMini = Distance;
+ PointSolution = PointOnSegment;
+ SolutionValide = Standard_True;
+ }
}
}
}
if(Intersect.NbPoints() != 1) {
for(Standard_Integer i=1; i<=Intersect.NbPoints(); i++) {
if(IsSameDistance(BisectorOne,BisectorTwo,
- Intersect.Point(i).Value(),Distance) &&
- Distance > Tolerance ) {
- Parama = Intersect.Point(i).ParamOnFirst();
- Paramb = Intersect.Point(i).ParamOnSecond();
- if (Parama < Param1 && Paramb < Param2) {
- Param1 = Parama;
- Param2 = Paramb;
- DistanceMini = Distance;
- PointSolution = Intersect.Point(i).Value();
- SolutionValide = Standard_True;
- }
+ Intersect.Point(i).Value(),Distance) &&
+ Distance > Tolerance ) {
+ Parama = Intersect.Point(i).ParamOnFirst();
+ Paramb = Intersect.Point(i).ParamOnSecond();
+ if (Parama < Param1 && Paramb < Param2) {
+ Param1 = Parama;
+ Param2 = Paramb;
+ DistanceMini = Distance;
+ PointSolution = Intersect.Point(i).Value();
+ SolutionValide = Standard_True;
+ }
}
}
}
Param1 = Intersect.Point(1).ParamOnFirst();
Param2 = Intersect.Point(1).ParamOnSecond();
SolutionValide = IsSameDistance(BisectorOne,BisectorTwo,
- PointSolution,DistanceMini);
+ PointSolution,DistanceMini);
}
if (!SolutionValide) return Precision::Infinite();
IndexEdge2 = BisectorOne->SecondEdge()->EdgeNumber();
IndexEdge3 = BisectorTwo->FirstEdge() ->EdgeNumber();
IndexEdge4 = BisectorTwo->SecondEdge()->EdgeNumber();
-
+
if (theCircuit->ConnexionOn(IndexEdge2)){
// --------------------------------------
// BisectorOne est issue d une connexion.
// --------------------------------------
- if (AreNeighbours(IndexEdge1,IndexEdge2,NumberOfItems()) &&
- AreNeighbours(IndexEdge3,IndexEdge4,NumberOfItems()) &&
- IndexEdge2 == IndexEdge3 ){
- ExtremiteControle = Standard_False;
- Param1 = Param1 + Tolerance;
+ if (AreNeighbours(IndexEdge1,IndexEdge2,NumberOfItems()) &&
+ AreNeighbours(IndexEdge3,IndexEdge4,NumberOfItems()) &&
+ IndexEdge2 == IndexEdge3 ){
+ ExtremiteControle = Standard_False;
+ Param1 = Param1 + Tolerance;
}
}
-
+
if (theCircuit->ConnexionOn(IndexEdge4)){
- // --------------------------------------
- // BisectorTwo est issue d une connexion.
- // --------------------------------------
+ //--------------------------------------
+ //BisectorTwo est issue d une connexion.
+ //--------------------------------------
if (AreNeighbours(IndexEdge1,IndexEdge2,NumberOfItems()) &&
- AreNeighbours(IndexEdge3,IndexEdge4,NumberOfItems()) &&
- IndexEdge2 == IndexEdge3 ){
- ExtremiteControle = Standard_False;
- Param2 = Param2 + Tolerance;
+ AreNeighbours(IndexEdge3,IndexEdge4,NumberOfItems()) &&
+ IndexEdge2 == IndexEdge3 ){
+ ExtremiteControle = Standard_False;
+ Param2 = Param2 + Tolerance;
}
}
-
- if (ExtremiteControle) {
- if(Bisector1->StartPoint().Distance(PointSolution) < Tolerance ||
- Bisector2->StartPoint().Distance(PointSolution) < Tolerance )
+
+ //if (ExtremiteControle) {
+ // if(Bisector1->StartPoint().Distance(PointSolution) < Tolerance ||
+ // Bisector2->StartPoint().Distance(PointSolution) < Tolerance )
+ // return Precision::Infinite();
+ //}
+
+ if(ExtremiteControle)
+ {
+ if(Bisector1->StartPoint().Distance(PointSolution) < Tolerance)
+ {
+#ifdef DRAW
+ if(AffichBis)
+ {
+ DrawTrSurf::Set("Bis1", Bisector1);
+ DrawTrSurf::Set("Bis2", Bisector2);
+ }
+#endif
return Precision::Infinite();
+ }
+ if(Bisector2->StartPoint().Distance(PointSolution) < Tolerance)
+ {
+
+#ifdef DRAW
+ if(AffichBis)
+ {
+ DrawTrSurf::Set("Bis1", Bisector1);
+ DrawTrSurf::Set("Bis2", Bisector2);
+ }
+#endif
+ return Precision::Infinite();
+ }
}
+
+
if(BisectorOne->SecondParameter() < Precision::Infinite() &&
- BisectorOne->SecondParameter() < Param1*(1. - Tolerance ))
+ BisectorOne->SecondParameter() < Param1*(1. - Tolerance ))
return Precision::Infinite();
-
+
if(BisectorTwo->FirstParameter() < Precision::Infinite() &&
- BisectorTwo->FirstParameter() < Param2*(1.- Tolerance))
+ BisectorTwo->FirstParameter() < Param2*(1.- Tolerance))
return Precision::Infinite();
BisectorOne->SecondParameter(Param1);
BisectorTwo->FirstParameter (Param2);
+
#ifdef OCCT_DEBUG
if (Affich) {
cout<<" coordonnees : "<<GeomPnt (IntPnt).X()<<" "
- <<GeomPnt (IntPnt).Y()<<endl;
+ <<GeomPnt (IntPnt).Y()<<endl;
cout<<" parametres : "<<Param1<<" "<<Param2<<endl;
cout<<" distancemini : "<<DistanceMini<<endl;
}
#endif
-
+
return DistanceMini;
}
//purpose :
//=============================================================================
Standard_Real MAT2d_Tool2d::Distance(const Handle(MAT_Bisector)& Bis,
- const Standard_Real Param1,
- const Standard_Real Param2) const
+ const Standard_Real Param1,
+ const Standard_Real Param2) const
{
Standard_Real Dist = Precision::Infinite();
//=============================================================================
#ifndef OCCT_DEBUG
void MAT2d_Tool2d::Dump(const Standard_Integer ,
- const Standard_Integer ) const
+ const Standard_Integer ) const
{
Standard_NotImplemented::Raise();
#else
void MAT2d_Tool2d::Dump(const Standard_Integer bisector,
- const Standard_Integer) const
+ const Standard_Integer) const
{
if(bisector == -1) return;
if(bisector > theNumberOfBisectors) return;
//purpose :
//=============================================================================
const Bisector_Bisec& MAT2d_Tool2d::GeomBis (const Standard_Integer Index)
- const
+ const
{
return theGeomBisectors.Find(Index);
}
//purpose :
//=============================================================================
Handle(Geom2d_Geometry) MAT2d_Tool2d::GeomElt(const Standard_Integer Index)
- const
+ const
{
return theCircuit->Value(Index);
}
//purpose :
//=============================================================================
void MAT2d_Tool2d::BisecFusion(const Standard_Integer I1,
- const Standard_Integer I2)
+ const Standard_Integer I2)
{
Standard_Real DU,UL1,UF1;
Handle(Geom2d_TrimmedCurve) Bisector1;
Handle(Bisector_BisecCC) BCC1 = Handle(Bisector_BisecCC)::DownCast(Bisector1->BasisCurve());
Bis.Perform(BCC1->Curve(2), BCC1->Curve(1), P2, VBid, VBid,
- theDirection, Tolerance, Standard_False);
+ theDirection, Tolerance, Standard_False);
Bisector1 = Handle(Geom2d_TrimmedCurve)::DownCast(Bis.Value());
BCC1 = Handle(Bisector_BisecCC) ::DownCast(Bisector1->BasisCurve());
UF1 = UF1 - DU;
Handle(Bisector_BisecAna) BAna = Handle(Bisector_BisecAna)::DownCast(Bisector1->BasisCurve());
-//---------------------------- uncomment if new method Bisector_BisecAna::SetTrim(f,l) is not used
-// Handle(Geom2d_Curve) C2d = BAna->Geom2dCurve();
-// Handle(Geom2d_TrimmedCurve) trimC2d = new Geom2d_TrimmedCurve(C2d, UF1, UL1);
-// BAna->Init(trimC2d);
-//--------------------------- end
+ //---------------------------- uncomment if new method Bisector_BisecAna::SetTrim(f,l) is not used
+ // Handle(Geom2d_Curve) C2d = BAna->Geom2dCurve();
+ // Handle(Geom2d_TrimmedCurve) trimC2d = new Geom2d_TrimmedCurve(C2d, UF1, UL1);
+ // BAna->Init(trimC2d);
+ //--------------------------- end
BAna->SetTrim(UF1,UL1); // put comment if SetTrim(f,l) is not used
Bisector1->SetTrim(UF1,UL1);
// consecutifs sur un contour ferme de NbEdge elements.
//==========================================================================
Standard_Boolean AreNeighbours(const Standard_Integer IEdge1,
- const Standard_Integer IEdge2,
- const Standard_Integer NbEdge)
+ const Standard_Integer IEdge2,
+ const Standard_Integer NbEdge)
{
if (Abs(IEdge1 - IEdge2) == 1) return Standard_True;
else if (Abs(IEdge1 - IEdge2) == NbEdge -1) return Standard_True;
IntRes2d_Domain Domain1 = Domain(Bisector,Tolerance);
Standard_Real UB1 = Bisector->FirstParameter();
Standard_Real UB2 = Bisector->LastParameter();
-
+
gp_Pnt2d FirstPointBisector = Bisector->Value(UB1);
Standard_Real UTrim = Precision::Infinite();
Geom2dAdaptor_Curve AdapBisector(Bisector);
Geom2dAdaptor_Curve AdapLine1 (Line1);
Intersect.Perform(AdapBisector, Domain1,
- AdapLine1, Tolerance, Tolerance);
+ AdapLine1, Tolerance, Tolerance);
if (Intersect.IsDone() && !Intersect.IsEmpty()) {
for (Standard_Integer i = 1; i <= Intersect.NbPoints(); i++) {
gp_Pnt2d PInt = Intersect.Point(i).Value();
Distance = FirstPointBisector.Distance(PInt);
if (Distance > 10.*Tolerance &&
- Intersect.Point(i).ParamOnFirst() < UTrim ) {
- UTrim = Intersect.Point(i).ParamOnFirst();
+ Intersect.Point(i).ParamOnFirst() < UTrim ) {
+ UTrim = Intersect.Point(i).ParamOnFirst();
}
}
}
//purpose :
//==========================================================================
IntRes2d_Domain Domain(const Handle(Geom2d_TrimmedCurve)& Bisector1,
- const Standard_Real Tolerance)
+ const Standard_Real Tolerance)
{
Standard_Real Param1 = Bisector1->FirstParameter();
Standard_Real Param2 = Bisector1->LastParameter();
Handle(Geom2d_Curve) BasisCurve;
if (Type1 == STANDARD_TYPE(Bisector_BisecAna)) {
BasisCurve = Handle(Bisector_BisecAna)
- ::DownCast(Bisector1->BasisCurve())->Geom2dCurve();
+ ::DownCast(Bisector1->BasisCurve())->Geom2dCurve();
Type1 = BasisCurve->DynamicType();
}
gp_Parab2d gpParabola;
Param2 = (Val1 <= Val2 ? Val1:Val2);
}
}
-
+
IntRes2d_Domain Domain1(Bisector1->Value(Param1),Param1,Tolerance,
- Bisector1->Value(Param2),Param2,Tolerance);
+ Bisector1->Value(Param2),Param2,Tolerance);
if(Bisector1->BasisCurve()->IsPeriodic()) {
Domain1.SetEquivalentParameters(0.,2.*M_PI);
}
return Domain1;
}
+//=============================================================================
+//function : CheckEnds
+//purpose :
+//=============================================================================
+Standard_Boolean CheckEnds (const Handle(Geom2d_Geometry)& Elt ,
+ const gp_Pnt2d& PCom ,
+ const Standard_Real Distance,
+ const Standard_Real Tol)
+
+{
+ Handle(Standard_Type) Type = Elt->DynamicType();
+ Handle(Geom2d_TrimmedCurve) Curve;
+
+ if (Type == STANDARD_TYPE(Geom2d_CartesianPoint)) {
+ return Standard_False;
+ }
+ else {
+ Curve = Handle(Geom2d_TrimmedCurve)::DownCast(Elt);
+ gp_Pnt2d aPf = Curve->StartPoint();
+ gp_Pnt2d aPl = Curve->EndPoint();
+ Standard_Real df = PCom.Distance(aPf);
+ Standard_Real dl = PCom.Distance(aPl);
+ if(Abs(df - Distance) <= Tol)
+ return Standard_True;
+ if(Abs(dl - Distance) <= Tol)
+ return Standard_True;
+ }
+ return Standard_False;
+}
+
+
#ifdef OCCT_DEBUG
//==========================================================================
//function : MAT2d_DrawCurve
// Indice = 4 vert.
//==========================================================================
void MAT2d_DrawCurve(const Handle(Geom2d_Curve)& aCurve,
- const Standard_Integer /*Indice*/)
+ const Standard_Integer /*Indice*/)
{
Handle(Standard_Type) type = aCurve->DynamicType();
Handle(Geom2d_Curve) curve,CurveDraw;
// PB de representation des courbes semi_infinies.
if (aCurve->LastParameter() == Precision::Infinite()) {
-
+
if (type == STANDARD_TYPE(Geom2d_Parabola)) {
- gpParabola = Handle(Geom2d_Parabola)::DownCast(curve)->Parab2d();
- Focus = gpParabola.Focal();
- Standard_Real Val1 = Sqrt(Limit*Focus);
- Standard_Real Val2 = Sqrt(Limit*Limit);
- delta= (Val1 <= Val2 ? Val1:Val2);
+ gpParabola = Handle(Geom2d_Parabola)::DownCast(curve)->Parab2d();
+ Focus = gpParabola.Focal();
+ Standard_Real Val1 = Sqrt(Limit*Focus);
+ Standard_Real Val2 = Sqrt(Limit*Limit);
+ delta= (Val1 <= Val2 ? Val1:Val2);
}
else if (type == STANDARD_TYPE(Geom2d_Hyperbola)) {
- gpHyperbola = Handle(Geom2d_Hyperbola)::DownCast(curve)->Hypr2d();
- Standard_Real Majr = gpHyperbola.MajorRadius();
- Standard_Real Minr = gpHyperbola.MinorRadius();
- Standard_Real Valu1 = Limit/Majr;
- Standard_Real Valu2 = Limit/Minr;
- Standard_Real Val1 = Log(Valu1+Sqrt(Valu1*Valu1-1));
- Standard_Real Val2 = Log(Valu2+Sqrt(Valu2*Valu2+1));
- delta = (Val1 <= Val2 ? Val1:Val2);
+ gpHyperbola = Handle(Geom2d_Hyperbola)::DownCast(curve)->Hypr2d();
+ Standard_Real Majr = gpHyperbola.MajorRadius();
+ Standard_Real Minr = gpHyperbola.MinorRadius();
+ Standard_Real Valu1 = Limit/Majr;
+ Standard_Real Valu2 = Limit/Minr;
+ Standard_Real Val1 = Log(Valu1+Sqrt(Valu1*Valu1-1));
+ Standard_Real Val2 = Log(Valu2+Sqrt(Valu2*Valu2+1));
+ delta = (Val1 <= Val2 ? Val1:Val2);
}
CurveDraw = new Geom2d_TrimmedCurve(aCurve,
- aCurve->FirstParameter(),
- aCurve->FirstParameter() + delta);
+ aCurve->FirstParameter(),
+ aCurve->FirstParameter() + delta);
}
else {
CurveDraw = aCurve;
}
#ifdef DRAW
+ Standard_Integer Indice = 1;
if (Indice == 1) Couleur = Draw_jaune;
else if (Indice == 2) Couleur = Draw_bleu;
else if (Indice == 3) Couleur = Draw_rouge;
else
dr = new DrawTrSurf_Curve2d(CurveDraw,Couleur,500);
- dout << dr;
- dout.Flush();
+ //dout << dr;
+ //dout.Flush();
#endif
}
projects / occt.git / blobdiff