IntCurve_IntConicConic_Tool.cxx
IntCurve_IntConicConic_Tool.cxx
IntCurve_IntConicConic_Tool.cxx
-IntCurve_ToolPolygon.gxx
IntCurve_IntConicConic_1.hxx
IntCurve_IntConicConic_Tool.hxx
-- ProjPCurGen,
-- UserIntConicCurveGen,
-- IntPolyPolyGen,
- -- ToolPolygon,
-- Polygon2dGen,
-- DistBetweenPCurvesGen> are Internal
--
generic class Polygon2dGen;
- generic class ToolPolygon;
-
generic class IntPolyPolyGen,ThePolygon2d,
- ThePolygon2dTool,
- InterferencePoly2d,
TheDistBetweenPCurves,
ExactIntersectionPoint;
-- File: IntPolyPolyGen.cdl
-- Created: Mon Oct 19 12:03:29 1992
-- Author: Laurent BUCHARD
--- <lbr@sdsun2>
---Copyright: Matra Datavision 1992
class ThePolygon2d instantiates Polygon2dGen from IntCurve
(TheCurve,
- TheCurveTool);
+ TheCurveTool);
- class ThePolygon2dTool instantiates ToolPolygon from IntCurve
- (Pnt2d from gp,
- ThePolygon2d,
- Box2d from Bnd);
-
- class InterferencePoly2d instantiates InterferencePolygon2d from Intf
- (ThePolygon2d,
- ThePolygon2dTool,
- ThePolygon2d,
- ThePolygon2dTool);
-
class TheDistBetweenPCurves instantiates DistBetweenPCurvesGen
(TheCurve,
- TheCurveTool);
-
+ TheCurveTool);
class ExactIntersectionPoint
// File: IntCurve_IntPolyPolyGen.gxx
// Created: Tue Oct 13 11:12:26 1992
// Author: Laurent BUCHARD
-// <lbr@sdsun2>
// Modified by skv - Tue Mar 1 14:22:09 2005 OCC8169
#include <Intf_SectionPoint.hxx>
#include <Intf_SectionLine.hxx>
#include <Intf_TangentZone.hxx>
+#include <Intf_InterferencePolygon2d.hxx>
#include <gp_Vec2d.hxx>
Poly1.SetDeflectionOverEstimation(TolConf);
}
- IntCurve_InterferencePoly2d InterPP(Poly1);
+ Intf_InterferencePolygon2d InterPP(Poly1);
IntCurve_ExactIntersectionPoint EIP(C1,C1,TolConf);
Standard_Real U,V;
if(PtrPoly2->DeflectionOverEstimation() < TolConf) {
PtrPoly2->SetDeflectionOverEstimation(TolConf);
}
- IntCurve_InterferencePoly2d InterPP(*PtrPoly1,*PtrPoly2);
+ Intf_InterferencePolygon2d InterPP(*PtrPoly1,*PtrPoly2);
IntCurve_ExactIntersectionPoint EIP(C1,C2,TolConf);
Standard_Real U,V;
-- File: Polygon2dGen.cdl
-- Created: Mon Oct 19 11:51:16 1992
-- Author: Laurent BUCHARD
--- <lbr@sdsun2>
---Copyright: Matra Datavision 1992
---Purpose: Describe a polyline as a topology to compute the
-- interference beetween two polylines 2 dimension.
-
---Level: Internal
+inherits Polygon2d from Intf
+
uses Pnt2d from gp,
Box2d from Bnd,
Array1OfPnt2d from TColgp,
- Array1OfReal from TColStd,
- Array1OfInteger from TColStd,
- Domain from IntRes2d
-
+ Array1OfReal from TColStd,
+ Array1OfInteger from TColStd,
+ Domain from IntRes2d
raises OutOfRange from Standard
-
is
Create (Curve : TheCurve;
-- a polygon inside or near the OtherBox.
is static;
- Bounding (me)
- returns Box2d from Bnd
- is static;
- ---C++: return const &
- ---C++: inline
- ---Purpose: Give the bounding box of the polygon.
-
DeflectionOverEstimation(me)
returns Real from Standard
---C++: inline
- is static;
+ is redefined virtual;
SetDeflectionOverEstimation(me: in out; x:Real from Standard)
---C++: inline
---C++: inline
is static;
- Closed (me)
- returns Boolean from Standard
- ---C++: inline
- is static;
-
NbSegments (me)
returns Integer
---C++: inline
- is static;
+ is redefined virtual;
---Purpose: Give the number of Segments in the polyline.
-
- BeginOfSeg (me;
- Index : in Integer)
- returns Pnt2d from gp
- raises OutOfRange from Standard
- is static;
- ---Purpose: Give the point of range Index in the Polygon.
- ---C++: inline
- ---C++: return const &
-
- EndOfSeg (me;
- Index : in Integer)
- returns Pnt2d from gp
- raises OutOfRange from Standard
- is static;
- ---Purpose: Give the point of range Index in the Polygon.
- ---C++: inline
- ---C++: return const &
+
+ Segment (me; theIndex : in Integer from Standard;
+ theBegin, theEnd : in out Pnt2d from gp)
+ raises OutOfRange from Standard is redefined virtual;
+ ---Purpose: Returns the points of the segment <Index> in the Polygon.
-- Implementation :
is static;
-fields TheBnd : Box2d from Bnd;
- TheDeflection : Real from Standard;
+fields TheDeflection : Real from Standard;
NbPntIn : Integer from Standard;
- TheMaxNbPoints: Integer from Standard;
+ TheMaxNbPoints: Integer from Standard;
ThePnts : Array1OfPnt2d from TColgp;
- TheParams : Array1OfReal from TColStd;
- TheIndex : Array1OfInteger from TColStd;
- ClosedPolygon : Boolean from Standard;
-
+ TheParams : Array1OfReal from TColStd;
+ TheIndex : Array1OfInteger from TColStd;
+ ClosedPolygon : Boolean from Standard;
+
--- To compute an approximate parameter on the Curve
--
Binf : Real from Standard;
Bsup : Real from Standard;
-
end Polygon2dGen;
-
-
-
// File: IntCurve_Polygon2dGen.gxx
// Created: Mon Oct 12 17:17:30 1992
// Author: Laurent BUCHARD
-// <lbr@sdsun2>
#define TEST 0
-
#include <Standard_ConstructionError.hxx>
#include <Bnd_Box2d.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <gp_Dir2d.hxx>
-
-
#define MAJORATION_DEFLECTION 1.5
//======================================================================
//== On echantillonne sur le Domain de la Curve NbPts Points
do {
gp_Pnt2d P=TheCurveTool::Value(C,u);
- TheBnd.Add(P);
+ myBox.Add(P);
TheIndex.SetValue(i,i);
ThePnts.SetValue(i,P);
TheParams.SetValue(i,u);
}
while(i<NbPts);
- TheBnd.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
+ myBox.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
ClosedPolygon = Standard_False;
}
//======================================================================
Standard_Integer i=1;
do {
gp_Pnt2d P=TheCurveTool::Value(C,u);
- TheBnd.Add(P);
+ myBox.Add(P);
ThePnts.SetValue(i,P);
TheParams.SetValue(i,u);
TheIndex.SetValue(i,i);
}
while(i<NbPts);
- TheBnd.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
+ myBox.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
ClosedPolygon = Standard_False;
//-------------------------------------------------------
//-- On supprime les points alignes
//======================================================================
void IntCurve_Polygon2dGen::ComputeWithBox(const TheCurve& C,
const Bnd_Box2d& BoxOtherPolygon) {
- if(TheBnd.IsOut(BoxOtherPolygon)) {
+ if(myBox.IsOut(BoxOtherPolygon)) {
NbPntIn=2;
- TheBnd.SetVoid();
+ myBox.SetVoid();
}
else {
Standard_Real bx0,bx1,by0,by1;
}
if(nbp==1) {
NbPntIn=2;
- TheBnd.SetVoid();
+ myBox.SetVoid();
}
else {
- TheBnd.SetVoid();
+ myBox.SetVoid();
if(nbp) {
- TheBnd.Add(ThePnts.Value(TheIndex.Value(1)));
+ myBox.Add(ThePnts.Value(TheIndex.Value(1)));
}
Standard_Real RatioDeflection;
Standard_Integer nbpassagedeflection = 0;
Standard_Integer Iim1= TheIndex.Value(i-1);
const gp_Pnt2d& Pi = ThePnts.Value(Ii);
const gp_Pnt2d& Pim1 = ThePnts.Value(Iim1);
- TheBnd.Add(Pi);
+ myBox.Add(Pi);
Standard_Integer Regi = CalculRegion(Pi.X(),Pi.Y(),bx0,bx1,by0,by1);
Standard_Integer Regim1 = CalculRegion(Pim1.X(),Pim1.Y(),bx0,bx1,by0,by1);
if((Regi & Regim1) == 0) {
}
TheDeflection*=MAJORATION_DEFLECTION;
- TheBnd.Enlarge(TheDeflection);
+ myBox.Enlarge(TheDeflection);
}
ClosedPolygon = Standard_False;
Dump();
void IntCurve_Polygon2dGen::Dump(void) const {
if(!DebugPolygon2d) return;
Standard_Real bx0,bx1,by0,by1;
- if(TheBnd.IsVoid()) return;
- TheBnd.Get(bx0,by0,bx1,by1);
+ if(myBox.IsVoid()) return;
+ myBox.Get(bx0,by0,bx1,by1);
DrawSegment(gp_Pnt2d(bx0,by0),gp_Pnt2d(bx1,by0));
DrawSegment(gp_Pnt2d(bx1,by0),gp_Pnt2d(bx1,by1));
DrawSegment(gp_Pnt2d(bx1,by1),gp_Pnt2d(bx0,by1));
Standard_Real bx0,bx1,by0,by1;
cout<<"\n ----- Dump de IntCurve_Polygon2dGen -----"<<endl;
- if(TheBnd.IsVoid()) {
+ if(myBox.IsVoid()) {
cout<<" Polygone Vide "<<endl;
return;
}
- TheBnd.Get(bx0,by0,bx1,by1);
+ myBox.Get(bx0,by0,bx1,by1);
cout<<" bx0:"<<bx0 <<endl;
cout<<" by0:"<<by0<<endl;
cout<<" bx1:"<<bx1<<endl;
}
#endif
//======================================================================
+void IntCurve_Polygon2dGen::Segment(const Standard_Integer theIndex,
+ gp_Pnt2d &theBegin, gp_Pnt2d &theEnd) const
+{
+ Standard_Integer ind = theIndex;
+ theBegin = ThePnts(TheIndex(theIndex));
+ if (theIndex >= NbPntIn) {
+ if (!ClosedPolygon)
+ Standard_OutOfRange::Raise("IntCurve_Polygon2dGen::Segment!");
+ ind = 0;
+ }
+ theEnd = ThePnts(TheIndex(ind+1));
+}
//======================================================================
-
// File: IntCurve_Polygon2dGen.lxx
// Created: Thu 3 Jun 1993
// Author: Laurent BUCHARD
-// <lbr@nonox>
#include <Standard_OutOfRange.hxx>
-//======================================================================
-inline const Bnd_Box2d& IntCurve_Polygon2dGen::Bounding(void) const {
- return(TheBnd);
-}
//======================================================================
inline Standard_Real IntCurve_Polygon2dGen::DeflectionOverEstimation() const {
return(TheDeflection);
inline void IntCurve_Polygon2dGen::SetDeflectionOverEstimation
(const Standard_Real x) {
TheDeflection = x;
- TheBnd.Enlarge(TheDeflection);
+ myBox.Enlarge(TheDeflection);
}
//======================================================================
inline void IntCurve_Polygon2dGen::Closed(const Standard_Boolean flag) {
ClosedPolygon = flag;
}
//======================================================================
-inline Standard_Boolean IntCurve_Polygon2dGen::Closed(void) const {
- return(Standard_False); //-- Voir si le cas Closed est traitable
-}
-//======================================================================
inline Standard_Integer IntCurve_Polygon2dGen::NbSegments(void) const {
return((ClosedPolygon)? NbPntIn : NbPntIn-1);
}
//======================================================================
-inline const gp_Pnt2d& IntCurve_Polygon2dGen::EndOfSeg(const Standard_Integer Index) const {
- Standard_Integer ind = Index;
- if (Index >= NbPntIn) {
- if (!ClosedPolygon)
- Standard_OutOfRange::Raise("OutOfRange Polygon2d::EndOfSeg !");
- ind = 0;
- }
- return ThePnts(TheIndex(ind+1));
-}
-//======================================================================
-inline const gp_Pnt2d& IntCurve_Polygon2dGen::BeginOfSeg(const Standard_Integer Index) const {
- return ThePnts(TheIndex(Index));
-}
-//======================================================================
inline Standard_Real IntCurve_Polygon2dGen::InfParameter() const {
return(TheParams.Value(TheIndex(1)));
}
--- File: ToolPolygon.cdl
--- Created: Fri Aug 2 08:18:37 1991
--- Author: Didier PIFFAULT
--- <dpf@sdsun2>
----Copyright: Matra Datavision 1991
-
-
-generic class ToolPolygon from IntCurve (Point as any;
- Polygon as any;
- BoundingBox as any)
-
- ---Purpose: Describe a polyline as a topology to compute the
- -- interference beetween two polylines.
-
-
- ---Level: Internal
-
-raises OutOfRange from Standard
-
-
-is Bounding (myclass; thePolygon : Polygon)
- returns BoundingBox;
- ---Purpose: Give the bounding box of the polygon.
- ---C++: inline
- ---C++: return const &
-
- DeflectionOverEstimation
- (myclass; thePolygon : Polygon)
- ---C++: inline
- returns Real from Standard;
-
- Closed (myclass; thePolygon : Polygon)
- ---C++: inline
- returns Boolean from Standard;
-
- NbSegments (myclass; thePolygon : Polygon)
- ---C++: inline
- returns Integer;
- ---Purpose: Give the number of Segments in the polyline.
-
- BeginOfSeg (myclass; thePolygon : Polygon;
- Index : in Integer)
- ---C++: inline
- returns Point
- raises OutOfRange from Standard;
- ---C++: return const &
- ---Purpose: Give the point of range Index in the Polygon.
-
- EndOfSeg (myclass; thePolygon : Polygon;
- Index : in Integer)
- ---C++: inline
- returns Point
- raises OutOfRange from Standard;
- ---C++: return const &
- ---Purpose: Give the point of range Index in the Polygon.
-
-
-end ToolPolygon;
-// File: IntCurve_ToolPolygon.gxx
-// Created: Tue Jun 4 16:14:49 1996
-// Author: Laurent BUCHARD
-// <lbr@sherlox.paris1.matra-dtv.fr>
-
-// File: IntCurve_ToolPolygon.gxx
-// Created: Thu Jun 3 14:52:18 1993
-// Author: Laurent BUCHARD
-// <lbr@nonox>
-
-
-#include Polygon_hxx
-
-
-//=================================================================
-inline const BoundingBox& IntCurve_ToolPolygon::Bounding
- (const Polygon& thePolygon)
-{
- return thePolygon.Bounding();
-}
-//=================================================================
-inline Standard_Real IntCurve_ToolPolygon::DeflectionOverEstimation
- (const Polygon& thePolygon)
-{
- return thePolygon.DeflectionOverEstimation();
-}
-//=================================================================
-inline Standard_Boolean IntCurve_ToolPolygon::Closed
- (const Polygon& thePolygon)
-{
- return thePolygon.Closed();
-}
-//=================================================================
-inline Standard_Integer IntCurve_ToolPolygon::NbSegments
- (const Polygon& thePolygon)
-{
- return thePolygon.NbSegments();
-}
-//=================================================================
-inline const Point& IntCurve_ToolPolygon::BeginOfSeg
- (const Polygon& thePolygon,
- const Standard_Integer Index)
-{
- return thePolygon.BeginOfSeg(Index);
-}
-//=================================================================
-inline const Point& IntCurve_ToolPolygon::EndOfSeg
- (const Polygon& thePolygon,
- const Standard_Integer Index)
-{
- return thePolygon.EndOfSeg(Index);
-}
-//=================================================================
-
class PolyArc; -- inherits Polygo from IntPatch
- class PolygoTool;
-
class RstInt;
HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d);
- class SearchPnt instantiates InterferencePolygon2d from Intf
- (Polygo, PolygoTool, Polygo, PolygoTool);
+ alias SearchPnt is InterferencePolygon2d from Intf;
class CSFunction instantiates ZerCOnSSParFunc from IntImp
(HSurface from Adaptor3d,
--- This exception is raised if Pfirst=RealFirst or Plast=RealLast or
-- NbSample<=1.
-
- Bounding(me)
- ---C++: return const&
- returns Box2d from Bnd;
-
- Error(me) returns Real from Standard;
-
- Closed(me) returns Boolean from Standard;
+ Closed(me) returns Boolean from Standard is redefined virtual;
NbPoints(me) returns Integer;
brise : Array1OfPnt2d from TColgp;
param : Array1OfReal from TColStd;
- boite : Box2d from Bnd;
- fleche : Real from Standard;
offsetx: Real from Standard;
offsety: Real from Standard;
ferme : Boolean from Standard;
Xs = p2d.X(); Ys = p2d.Y();
brise(1).SetCoord(Xs,Ys);
- boite.SetVoid();
+ myBox.SetVoid();
- boite.Add(brise(1));
- fleche =0.;
+ myBox.Add(brise(1));
+ myError =0.;
for (Standard_Integer i =2; i<=NbSample;i++) {
param(i) = Pdeb + (i-1)*Pas;
if(IndexSup<i) IndexSup=Min(i+1,NbSample);
}
- boite.Add(brise(i));
+ myBox.Add(brise(i));
Line->D0(param(i)-Pas*0.5,p2d);
Xm = p2d.X() - XXs;
Ym = p2d.Y() - YYs;
Xm = Sqrt(Xm*Xm+Ym*Ym);
- fleche =Max (fleche , Xm);
+ myError =Max (myError , Xm);
Xs = X;
Ys = Y;
}
}
}
while((IndexInf > IndexSup) && nbloop<=10);
- fleche*=1.2;
- if(fleche<0.00000001)
- fleche = 0.00000001;
- boite.Enlarge(fleche);
+ myError*=1.2;
+ if(myError<0.00000001)
+ myError = 0.00000001;
+ myBox.Enlarge(myError);
- if(Line->Value(aPdeb).Distance(Line->Value(aPfin))<=1e-7) {
- ferme=Standard_True;
- }
- else {
- ferme=Standard_False;
- }
+ ferme = (Line->Value(aPdeb).Distance(Line->Value(aPfin)) <= 1e-7);
}
-const Bnd_Box2d& IntPatch_PolyArc::Bounding() const {
- return(boite);
-}
-
-Standard_Real IntPatch_PolyArc::Error() const {return fleche;}
-
Standard_Boolean IntPatch_PolyArc::Closed() const { return ferme;}
Standard_Integer IntPatch_PolyArc::NbPoints() const {return brise.Length();}
void IntPatch_PolyArc::SetOffset(const Standard_Real ox,const Standard_Real oy) {
Standard_Real xmin,ymin,xmax,ymax,g;
- boite.Get(xmin,ymin,xmax,ymax);
- g = boite.GetGap();
+ myBox.Get(xmin,ymin,xmax,ymax);
+ g = myBox.GetGap();
- boite.SetVoid();
+ myBox.SetVoid();
- boite.Update(xmin-offsetx,ymin-offsety,
+ myBox.Update(xmin-offsetx,ymin-offsety,
xmax-offsetx,ymax-offsety);
offsetx = ox;
offsety = oy;
- boite.Update(xmin+offsetx,ymin+offsety,
+ myBox.Update(xmin+offsetx,ymin+offsety,
xmax+offsetx,ymax+offsety);
- boite.SetGap(g);
+ myBox.SetGap(g);
}
ResetError(me: in out);
- Bounding (me)
- ---C++: return const &
- returns Box2d from Bnd;
-
- Error(me) returns Real from Standard;
-
- Closed(me) returns Boolean from Standard;
-
NbPoints(me) returns Integer;
Point(me; Index : Integer)
fields
- box : Box2d from Bnd;
pnt : Pnt2d from gp;
typ : IType from IntPatch;
onfirst : Boolean from Standard;
wpoly : WLine from IntPatch;
rpoly : RLine from IntPatch;
- defle : Real from Standard;
end PolyLine;
//=======================================================================
IntPatch_PolyLine::IntPatch_PolyLine ()
- : defle(INITDEFLE)
+ : IntPatch_Polygo(INITDEFLE)
{}
//=======================================================================
//=======================================================================
IntPatch_PolyLine::IntPatch_PolyLine (const Standard_Real InitDefle)
- : defle(InitDefle)
+ : IntPatch_Polygo(InitDefle)
{}
//=======================================================================
void IntPatch_PolyLine::Prepare()
{
Standard_Integer i;
- box.SetVoid();
+ myBox.SetVoid();
Standard_Integer n=NbPoints();
- Standard_Real eps = defle;
+ Standard_Real eps = myError;
gp_Pnt2d P1, P2;
if (n >= 3) {
d = V13.CrossMagnitude(V12) / d13;
else
d = eps;
- if (d > defle) {
+ if (d > myError) {
// try to compute deflection more precisely using parabola interpolation
gp_XY V23 = P3.XY() - P2.XY();
Standard_Real d12 = V12.Modulus(), d23 = V23.Modulus();
// select min deflection from linear and parabolic ones
if (d1 < d) d = d1;
}
- if (d > defle) defle=d;
+ if (d > myError) myError=d;
}
P1 = P2; P2 = P3;
}
- box.Add(P3);
+ myBox.Add(P3);
}
- box.Enlarge(defle);
+ myBox.Enlarge(myError);
}
//=======================================================================
void IntPatch_PolyLine::ResetError()
{
- defle = INITDEFLE;
-}
-
-//=======================================================================
-//function : Bounding
-//purpose :
-//=======================================================================
-
-const Bnd_Box2d& IntPatch_PolyLine::Bounding() const
-{
- return box;
-}
-
-//=======================================================================
-//function : Error
-//purpose :
-//=======================================================================
-
-Standard_Real IntPatch_PolyLine::Error() const
-{
- // return 0.0000001;
- return defle;
-}
-
-//=======================================================================
-//function : Closed
-//purpose :
-//=======================================================================
-
-Standard_Boolean IntPatch_PolyLine::Closed() const
-{
- return Standard_False;
+ myError = INITDEFLE;
}
//=======================================================================
--- File: IntPatch_Polygo.cdl
--- Created: Thu May 6 17:49:16 1993
--- Author: Jacques GOUSSARD
--- <jag@form4>
----Copyright: Matra Datavision 1993
+-- File: IntPatch_Polygo.cdl
+-- Created: Thu May 6 17:49:16 1993
+-- Author: Jacques GOUSSARD
+---Copyright: Matra Datavision 1993
deferred class Polygo from IntPatch
---Purpose:
+inherits Polygon2d from Intf
+
uses Pnt2d from gp,
Box2d from Bnd
+raises OutOfRange from Standard
+
is
- Delete(me:out) is virtual;
- ---C++: alias "Standard_EXPORT virtual ~IntPatch_Polygo(){Delete() ; }"
-
- Bounding (me)
- ---C++: return const &
- returns Box2d from Bnd
- is deferred;
-
- Error(me) returns Real from Standard
- is deferred;
-
- Closed(me) returns Boolean from Standard
- is deferred;
-
- NbPoints(me) returns Integer
- is deferred;
-
- Point(me; Index : Integer)
- returns Pnt2d from gp
- is deferred;
-
+ Initialize (theError : Real from Standard = 0.0)
+ returns Polygo from IntPatch;
+
+ Error (me) returns Real from Standard;
+ ---C++: inline
+
+ NbPoints (me) returns Integer is deferred;
+
+ Point (me; Index : Integer) returns Pnt2d from gp is deferred;
+
+ DeflectionOverEstimation (me)
+ returns Real from Standard is redefined virtual;
+ ---C++: inline
+ ---Purpose: Returns the tolerance of the polygon.
+
+ NbSegments (me)
+ returns Integer from Standard is redefined virtual;
+ ---C++: inline
+ ---Purpose: Returns the number of Segments in the polyline.
+
+ Segment (me; theIndex : in Integer from Standard;
+ theBegin, theEnd : in out Pnt2d from gp)
+ raises OutOfRange from Standard is redefined virtual;
+ ---C++: inline
+ ---Purpose: Returns the points of the segment <Index> in the Polygon.
+
+ Dump (me);
+
+fields
+
+ myError : Real from Standard is protected;
+
end Polygo;
+// File: IntPatch_Polygo.cxx
+// Created: Thu May 6 17:49:16 1993
+// Author: Jacques GOUSSARD
+// Copyright: Matra Datavision 1993
+
#include <IntPatch_Polygo.ixx>
-void IntPatch_Polygo::Delete()
+//=======================================================================
+//function : Initialize
+//purpose :
+//=======================================================================
+
+IntPatch_Polygo::IntPatch_Polygo (const Standard_Real theError)
+: myError(theError)
{}
+
+//=======================================================================
+//function : Dump
+//purpose :
+//=======================================================================
+
+void IntPatch_Polygo::Dump () const
+{
+ static int num=0;
+ num++;
+ cout<<"\n#------------- D u m p B o x 2 d ("<<num<<")"<<endl;
+ Bounding().Dump();
+ cout<<"\n#-----------------------------------------------"<<endl;
+
+ const Standard_Integer nbs = NbSegments();
+ cout<<"\npol2d "<<num<<" "<<nbs<<" ";
+ cout<<DeflectionOverEstimation()<<endl;
+
+ gp_Pnt2d P, PF;
+ for(Standard_Integer i=1;i<=nbs;i++) {
+ Segment(i,P,PF);
+ cout<<"pnt2d "<<num<<" "<< P.X()<<" "<<P.Y()<<endl;
+ }
+ cout<<"pnt2d "<<num<<" "<< PF.X()<<" "<<PF.Y()<<endl;
+}
--- /dev/null
+// File: IntPatch_Polygo.lxx
+// Created: Fri Feb 10 08:18:37 2012
+// Author: Sergey ZERCHANINOV
+// Copyright: OPEN CASCADE SAS 2012
+
+
+//=======================================================================
+//function : Error
+//purpose :
+//=======================================================================
+
+inline Standard_Real IntPatch_Polygo::Error () const
+{
+ return myError;
+}
+
+//=======================================================================
+//function : DeflectionOverEstimation
+//purpose :
+//=======================================================================
+
+inline Standard_Real IntPatch_Polygo::DeflectionOverEstimation () const
+{
+ return myError;
+}
+
+//=======================================================================
+//function : NbSegments
+//purpose :
+//=======================================================================
+
+inline Standard_Integer IntPatch_Polygo::NbSegments () const
+{
+ return NbPoints()-1;
+}
+
+//=======================================================================
+//function : BeginOfSeg
+//purpose :
+//=======================================================================
+
+inline void IntPatch_Polygo::Segment (const Standard_Integer theIndex,
+ gp_Pnt2d &theBegin, gp_Pnt2d &theEnd) const
+{
+ theBegin = Point(theIndex);
+ theEnd = Point(theIndex+1);
+}
--- File: IntPatch_PolygoTool.cdl
--- Created: Thu May 6 17:50:02 1993
--- Author: Jacques GOUSSARD
--- <jag@form4>
----Copyright: Matra Datavision 1993
-
-
-
-class PolygoTool from IntPatch
-
- ---Purpose: Tool an a polygon to instantiates the Interference
- -- between 2 polygons.
-
-
-uses Box2d from Bnd,
- Pnt2d from gp,
- Polygo from IntPatch
-
-
-is
-
- Bounding (myclass; Line : Polygo from IntPatch )
-
- returns Box2d from Bnd;
- ---C++: return const &
- ---C++: inline
-
-
- DeflectionOverEstimation(myclass; Line :Polygo from IntPatch)
-
- returns Real from Standard;
- ---C++: inline
-
-
- Closed(myclass; Line : Polygo from IntPatch )
-
- returns Boolean from Standard;
- ---C++: inline
-
-
- NbSegments(myclass; Line : Polygo from IntPatch )
-
- returns Integer from Standard;
- ---C++: inline
-
-
- BeginOfSeg(myclass; Line : Polygo from IntPatch;
- Index : Integer from Standard)
-
- returns Pnt2d from gp;
- ---C++: inline
-
-
- EndOfSeg(myclass; Line : Polygo from IntPatch ;
- Index : Integer from Standard)
-
- returns Pnt2d from gp;
- ---C++: inline
-
-
- Dump(myclass; Line : Polygo from IntPatch);
-
-
-end PolygoTool;
-
-#include <IntPatch_PolygoTool.ixx>
-
-
-
-void IntPatch_PolygoTool::Dump(const IntPatch_Polygo& L) {
- static int num=0;
- num++;
- cout<<"\n#------------- D u m p B o x 2 d ("<<num<<")"<<endl;
- IntPatch_PolygoTool::Bounding(L).Dump();
- cout<<"\n#-----------------------------------------------"<<endl;
-
- Standard_Integer nbs = IntPatch_PolygoTool::NbSegments(L);
- cout<<"\npol2d "<<num<<" "<<nbs<<" ";
- cout<<IntPatch_PolygoTool::DeflectionOverEstimation(L)<<endl;
-
- for(Standard_Integer i=1;i<=nbs;i++) {
- gp_Pnt2d P(IntPatch_PolygoTool::BeginOfSeg(L,i));
- cout<<"pnt2d "<<num<<" "<< P.X()<<" "<<P.Y()<<endl;
- }
- gp_Pnt2d PF(IntPatch_PolygoTool::EndOfSeg(L,nbs));
- cout<<"pnt2d "<<num<<" "<< PF.X()<<" "<<PF.Y()<<endl;
-}
-
-
-#ifndef IntPatch_Polygo_HeaderFile
-#include <IntPatch_Polygo.hxx>
-#endif
-#ifndef Bnd_Box2d_HeaderFile
-#include <Bnd_Box2d.hxx>
-#endif
-#ifndef gp_Pnt2d_HeaderFile
-#include <gp_Pnt2d.hxx>
-#endif
-
-inline const Bnd_Box2d& IntPatch_PolygoTool::Bounding(const IntPatch_Polygo& Line)
-{ return Line.Bounding(); }
-
-
-inline Standard_Real IntPatch_PolygoTool::DeflectionOverEstimation
- (const IntPatch_Polygo& Line)
-{ return Line.Error();} // fleche non calculable
-
-inline Standard_Boolean IntPatch_PolygoTool::Closed(const IntPatch_Polygo& Line)
-{ return Line.Closed();}
-
-inline Standard_Integer IntPatch_PolygoTool::NbSegments(const IntPatch_Polygo& Line)
-{ return Line.NbPoints()-1;}
-
-inline gp_Pnt2d IntPatch_PolygoTool::BeginOfSeg(const IntPatch_Polygo& Line,
- const Standard_Integer Index)
-{ return Line.Point(Index);}
-
-
-inline gp_Pnt2d IntPatch_PolygoTool::EndOfSeg(const IntPatch_Polygo& Line,
- const Standard_Integer Index)
-{ return Line.Point(Index+1);}
-
-
-- cheminement et les arcs de restriction
uses Polygo from IntPatch,
- PolygoTool from IntPatch,
Line from IntPatch,
HSurface from Adaptor3d,
TopolTool from Adaptor3d
#include <Precision.hxx>
#include <Adaptor2d_HCurve2d.hxx>
-#include <IntPatch_PolygoTool.hxx>
#include <IntPatch_WLine.hxx>
#include <IntPatch_RLine.hxx>
#include <IntPatch_HInterTool.hxx>
}
}
- Bnd_Box2d BPLin = IntPatch_PolygoTool::Bounding(PLin);
+ Bnd_Box2d BPLin = PLin.Bounding();
if(SurfaceIsPeriodic) {
Standard_Real xmin,ymin,xmax,ymax,g;
static int debug_polygon2d =0;
if(debug_polygon2d) {
cout<<" ***** Numero Restriction : "<<NumeroEdge<<" *****"<<endl;
- IntPatch_PolygoTool::Dump(PLin);
- IntPatch_PolygoTool::Dump(Brise);
+ PLin.Dump();
+ Brise.Dump();
}
Commun.Perform(PLin,Brise);
--- File: Intf.cdl
--- Created: Thu May 23 11:21:00 1991
--- Author: Didier PIFFAULT
--- <dpf@topsn3>
----Copyright: Matra Datavision 1991, 1992
+-- File: Intf.cdl
+-- Created: Thu May 23 11:21:00 1991
+-- Author: Didier PIFFAULT
+---Copyright: Matra Datavision 1991, 1992
package Intf
-- Classes input data :
- generic class ToolPolygon; -- Signature
- ---Purpose: Describes the necessary polygon information to compute the
- -- interferences.
+ deferred class Polygon2d;
+ ---Purpose: Describes the necessary polygon information to compute
+ -- the interferences.
generic class ToolPolyhedron; -- Signature
---Purpose: Describes the necessary polyhedron information to compute
- generic class InterferencePolygon2d;
+ class InterferencePolygon2d;
---Purpose: Computes the interference between two polygons in 2d.
-- Result : points of intersections and zones of tangence.
-- File: Interference.cdl
-- Created: Mon Jun 24 10:15:49 1991
-- Author: Didier PIFFAULT
--- <dpf@phobox>
---Copyright: Matra Datavision 1991, 1992
returns Integer is static;
---Purpose: Gives the number of points of intersection in the
-- interference.
+ ---C++: inline
PntValue (me;
Index : in Integer)
-- the interference.
--
---C++: return const &
-
+ ---C++: inline
NbSectionLines (me)
returns Integer is static;
---Purpose: Gives the number of polylines of intersection in the
-- interference.
+ ---C++: inline
LineValue (me;
Index : in Integer)
-- the interference.
--
---C++: return const &
-
-
+ ---C++: inline
NbTangentZones (me)
returns Integer is static;
---Purpose: Gives the number of zones of tangence in the interference.
+ ---C++: inline
ZoneValue (me;
Index : in Integer)
-- interference.
--
---C++: return const &
-
+ ---C++: inline
GetTolerance (me)
returns Real
is static;
---Purpose: Gives the tolerance used for the calculation.
-
+ ---C++: inline
-- Implementation functions :
mySLines : SeqOfSectionLine from Intf is protected;
myTZones : SeqOfTangentZone from Intf is protected;
SelfIntf : Boolean from Standard is protected;
- Tolerance : Real from Standard is protected;
+ Tolerance : Real from Standard is protected;
end Interference;
// File: Intf_Interference.cxx
// Created: Mon Jun 24 11:52:34 1991
// Author: Didier PIFFAULT
-// <dpf@phobox>
#include <Intf_Interference.ixx>
#include <gp_Pnt2d.hxx>
}
-//---------------------------------------------------------
-// Return the number of sections points in an interference.
-//---------------------------------------------------------
-Standard_Integer Intf_Interference::NbSectionPoints () const
-{
- return mySPoins.Length();
-}
-
-//-----------------------------------------------------------
-// Give the section point of range Index in the interference.
-//-----------------------------------------------------------
-const Intf_SectionPoint& Intf_Interference::PntValue
- (const Standard_Integer Index) const
-{
- return mySPoins(Index);
-}
-
-//--------------------------------------------------------
-// Return the number of sections lines in an interference.
-//--------------------------------------------------------
-Standard_Integer Intf_Interference::NbSectionLines () const
-{
- return mySLines.Length();
-}
-
-//----------------------------------------------------------
-// Give the section line of range Index in the interference.
-//----------------------------------------------------------
-const Intf_SectionLine& Intf_Interference::LineValue
- (const Standard_Integer Index) const
-{
- return mySLines(Index);
-}
-
-
-//---------------------------------------------------------------
-// Return the number of sections TangentZones in an interference.
-//---------------------------------------------------------------
-Standard_Integer Intf_Interference::NbTangentZones () const
-{
- return myTZones.Length();
-}
-
-//---------------------------------------------------------
-// Give the tangentzone of range Index in the interference.
-//---------------------------------------------------------
-const Intf_TangentZone& Intf_Interference::ZoneValue
- (const Standard_Integer Index) const
-{
- return myTZones(Index);
-}
-
-//=======================================================================
-//function : GetTolerance
-//purpose :
-//=======================================================================
-
-Standard_Real Intf_Interference::GetTolerance () const
-{
- return Tolerance;
-}
-
-
//=======================================================================
//function : Insert
//purpose : Insert a tangent zone in the list of the interference
--- /dev/null
+// File: Intf_Interference.lxx
+// Created: Mon Jun 24 11:52:34 1991
+// Author: Didier PIFFAULT
+
+//=======================================================================
+// Return the number of sections points in an interference.
+//=======================================================================
+
+inline Standard_Integer Intf_Interference::NbSectionPoints () const
+{
+ return mySPoins.Length();
+}
+
+//=======================================================================
+// Give the section point of range Index in the interference.
+//=======================================================================
+
+inline const Intf_SectionPoint& Intf_Interference::PntValue (const Standard_Integer Index) const
+{
+ return mySPoins(Index);
+}
+
+//=======================================================================
+// Return the number of sections lines in an interference.
+//=======================================================================
+
+inline Standard_Integer Intf_Interference::NbSectionLines () const
+{
+ return mySLines.Length();
+}
+
+//=======================================================================
+// Give the section line of range Index in the interference.
+//=======================================================================
+
+inline const Intf_SectionLine& Intf_Interference::LineValue (const Standard_Integer Index) const
+{
+ return mySLines(Index);
+}
+
+//=======================================================================
+// Return the number of sections TangentZones in an interference.
+//=======================================================================
+
+inline Standard_Integer Intf_Interference::NbTangentZones () const
+{
+ return myTZones.Length();
+}
+
+//=======================================================================
+// Give the tangentzone of range Index in the interference.
+//=======================================================================
+
+inline const Intf_TangentZone& Intf_Interference::ZoneValue (const Standard_Integer Index) const
+{
+ return myTZones(Index);
+}
+
+//=======================================================================
+//function : GetTolerance
+//purpose :
+//=======================================================================
+
+inline Standard_Real Intf_Interference::GetTolerance () const
+{
+ return Tolerance;
+}
--- File: InterferencePolygon2d.cdl
--- Created: Mon Sep 28 17:09:45 1992
--- Author: Didier PIFFAULT
--- <dpf@phylox>
----Copyright: Matra Datavision 1992
+-- File: Intf_InterferencePolygon2d.cdl
+-- Created: Mon Sep 28 17:09:45 1992
+-- Author: Didier PIFFAULT
+---Copyright: Matra Datavision 1992
-generic class InterferencePolygon2d from Intf
- (Polygon2d1 as any;
- ToolPolygon2d1 as any; -- as ToolPolygon(Pnt2d, Polygon2d1, Box2d)
- Polygon2d2 as any;
- ToolPolygon2d2 as any) -- as ToolPolygon(Pnt2d, Polygon2d2, Box2d)
- inherits Interference from Intf
+class InterferencePolygon2d from Intf
+inherits Interference from Intf
---Purpose: Computes the interference between two polygons or
-- the self intersection of a polygon in two
-- dimensions.
-
uses Pnt2d from gp,
SectionPoint from Intf,
SeqOfSectionPoint from Intf,
TangentZone from Intf,
- SeqOfTangentZone from Intf
-
+ SeqOfTangentZone from Intf,
+ Polygon2d from Intf
raises OutOfRange from Standard
---Purpose: Constructs an empty interference of Polygon.
- Create (Obje1: in Polygon2d1 ;Obje2 : in Polygon2d2)
+ Create (Obje1, Obje2 : in Polygon2d)
returns InterferencePolygon2d from Intf;
---Purpose: Constructs and computes an interference between two Polygons.
- Create (Obje : in Polygon2d1)
+ Create (Obje : in Polygon2d)
returns InterferencePolygon2d from Intf;
---Purpose: Constructs and computes the auto interference of a Polygon.
Perform (me : in out;
- Obje1: Polygon2d1 ;Obje2 : in Polygon2d2);
+ Obje1, Obje2 : in Polygon2d);
---Purpose: Computes an interference between two Polygons.
Perform (me : in out;
- Obje : in Polygon2d1);
+ Obje : in Polygon2d);
---Purpose: Computes the self interference of a Polygon.
-- Implementation :
- Interference (me : in out;
- Obje1 : in Polygon2d1;
- Obje2 : in Polygon2d2)
+ Interference (me : in out; Obje1, Obje2 : in Polygon2d)
is private;
- Interference (me : in out;
- Obje : in Polygon2d1)
+ Interference (me : in out; Obje : in Polygon2d)
is private;
Clean (me : in out) is private;
Intersect (me : in out;
- BegO : in Pnt2d from gp;
- EndO : in Pnt2d from gp;
- BegT : in Pnt2d from gp;
- EndT : in Pnt2d from gp)
+ iO, iT : Integer from Standard;
+ BegO, EndO : in Pnt2d from gp;
+ BegT, EndT : in Pnt2d from gp)
is private;
---Purpose: Computes the intersection between two segments
-- <BegO><EndO> et <BegT><EndT>.
fields
+
oClos, tClos : Boolean from Standard;
- iObje1, iObje2, nbso : Integer from Standard;
- BeginOfNotClosedObje1: Boolean from Standard;
- BeginOfNotClosedObje2: Boolean from Standard;
+ nbso : Integer from Standard;
end InterferencePolygon2d;
--- /dev/null
+// File: Intf_InterferencePolygon2d.cxx
+// Created: Mon Jun 24 11:52:34 1991
+// Author: Didier PIFFAULT
+
+#include <Intf_InterferencePolygon2d.ixx>
+
+#include <gp_Pnt2d.hxx>
+#include <Bnd_Box2d.hxx>
+#include <Intf_SectionPoint.hxx>
+#include <Intf_SeqOfSectionPoint.hxx>
+#include <Intf_TangentZone.hxx>
+#include <Intf_SeqOfTangentZone.hxx>
+#include <Precision.hxx>
+#include <TColStd_ListOfInteger.hxx>
+
+// Angular precision (sinus) below that value two right segments
+// are considered as having a potential zone of tangency.
+namespace
+{
+ static const Standard_Real PRCANG = Precision::Angular();
+};
+
+//=======================================================================
+//function : Intf_InterferencePolygon2d
+//purpose : constructor empty
+//=======================================================================
+
+Intf_InterferencePolygon2d::Intf_InterferencePolygon2d()
+: Intf_Interference (Standard_False),
+ oClos (Standard_False),
+ tClos (Standard_False),
+ nbso (0)
+{}
+
+//=======================================================================
+//function : Intf_InterferencePolygon2d
+//purpose : Constructor of the interference beetween two Polygon.
+//=======================================================================
+
+Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
+ (const Intf_Polygon2d& Obje1, const Intf_Polygon2d& Obje2)
+: Intf_Interference (Standard_False),
+ oClos (Standard_False),
+ tClos (Standard_False),
+ nbso (0)
+{
+ if (!Obje1.Bounding().IsOut(Obje2.Bounding())) {
+ Tolerance=Obje1.DeflectionOverEstimation()+
+ Obje2.DeflectionOverEstimation();
+ if (Tolerance==0.)
+ Tolerance=Epsilon(1000.);
+ nbso=Obje1.NbSegments();
+ oClos=Obje1.Closed();
+ tClos=Obje2.Closed();
+ Interference(Obje1, Obje2);
+ Clean();
+ }
+}
+
+
+//=======================================================================
+//function : Intf_InterferencePolygon2d
+//purpose : Constructor of the auto interference of a Polygon.
+//=======================================================================
+
+Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
+ (const Intf_Polygon2d& Obje)
+: Intf_Interference (Standard_True),
+ oClos (Standard_False),
+ tClos (Standard_False),
+ nbso (0)
+{
+ Tolerance=Obje.DeflectionOverEstimation()*2;
+ if (Tolerance==0.)
+ Tolerance=Epsilon(1000.);
+ oClos=Obje.Closed();
+ tClos=oClos;
+ Interference(Obje);
+ Clean();
+}
+
+//=======================================================================
+//function : Perform
+//purpose :
+//=======================================================================
+
+void Intf_InterferencePolygon2d::Perform
+ (const Intf_Polygon2d& Obje1, const Intf_Polygon2d& Obje2)
+{
+ SelfInterference(Standard_False);
+ if (!Obje1.Bounding().IsOut(Obje2.Bounding())) {
+ Tolerance=Obje1.DeflectionOverEstimation()+
+ Obje2.DeflectionOverEstimation();
+ if (Tolerance==0.)
+ Tolerance=Epsilon(1000.);
+ nbso=Obje1.NbSegments();
+ oClos=Obje1.Closed();
+ tClos=Obje2.Closed();
+ Interference(Obje1, Obje2);
+ Clean();
+ }
+}
+
+//=======================================================================
+//function : Perform
+//purpose :
+//=======================================================================
+
+void Intf_InterferencePolygon2d::Perform
+ (const Intf_Polygon2d& Obje)
+{
+ SelfInterference(Standard_True);
+ Tolerance=Obje.DeflectionOverEstimation()*2;
+ if (Tolerance==0.)
+ Tolerance=Epsilon(1000.);
+ oClos=Obje.Closed();
+ tClos=oClos;
+ Interference(Obje);
+ Clean();
+}
+
+//=======================================================================
+//function : Pnt2dValue
+//purpose : Give the section point of range Index in the interference.
+//=======================================================================
+
+gp_Pnt2d Intf_InterferencePolygon2d::Pnt2dValue
+ (const Standard_Integer Index) const
+{
+ return gp_Pnt2d((mySPoins(Index)).Pnt().X(),
+ (mySPoins(Index)).Pnt().Y());
+}
+
+
+//=======================================================================
+//function : Interference
+//purpose :
+//=======================================================================
+
+void Intf_InterferencePolygon2d::Interference
+ (const Intf_Polygon2d& Obje1,
+ const Intf_Polygon2d& Obje2)
+{
+ Bnd_Box2d bSO;
+ Bnd_Box2d bST;
+
+ Standard_Integer iObje1, iObje2;
+
+ gp_Pnt2d p1b, p1e, p2b, p2e;
+ for (iObje1=1; iObje1<=Obje1.NbSegments(); iObje1++)
+ {
+ bSO.SetVoid();
+ Obje1.Segment(iObje1,p1b,p1e);
+ bSO.Add(p1b);
+ bSO.Add(p1e);
+ bSO.Enlarge(Obje1.DeflectionOverEstimation());
+ if (!Obje2.Bounding().IsOut(bSO)) {
+ for (iObje2=1; iObje2<=Obje2.NbSegments(); iObje2++) {
+ bST.SetVoid();
+ Obje2.Segment(iObje2,p2b,p2e);
+ bST.Add(p2b);
+ bST.Add(p2e);
+ bST.Enlarge(Obje2.DeflectionOverEstimation());
+ if (!bSO.IsOut(bST))
+ Intersect(iObje1, iObje2, p1b, p1e, p2b, p2e);
+ }
+ }
+ }
+}
+
+//=======================================================================
+//function : Interference
+//purpose :
+//=======================================================================
+
+void Intf_InterferencePolygon2d::Interference
+ (const Intf_Polygon2d& Obje)
+{
+ Bnd_Box2d bSO;
+ Bnd_Box2d bST;
+
+ Standard_Integer iObje1, iObje2;
+
+ gp_Pnt2d p1b, p1e, p2b, p2e;
+ for (iObje1=1; iObje1<=Obje.NbSegments(); iObje1++) {
+ bSO.SetVoid();
+ Obje.Segment(iObje1,p1b,p1e);
+ bSO.Add(p1b);
+ bSO.Add(p1e);
+ bSO.Enlarge(Obje.DeflectionOverEstimation());
+ if (!Obje.Bounding().IsOut(bSO)) {
+ for (iObje2=iObje1+1;iObje2<=Obje.NbSegments();iObje2++){
+ bST.SetVoid();
+ Obje.Segment(iObje2,p2b,p2e);
+ bST.Add(p2b);
+ bST.Add(p2e);
+ bST.Enlarge(Obje.DeflectionOverEstimation());
+ if (!bSO.IsOut(bST))
+ Intersect(iObje1, iObje2, p1b, p1e, p2b, p2e);
+ }
+ }
+ }
+}
+
+
+//=======================================================================
+//function : Clean
+//purpose :
+//=======================================================================
+
+void Intf_InterferencePolygon2d::Clean()
+{
+
+// The zones of tangency that concerns only one couple of segments are
+// conserved if the angle between the segments is less than <PRCANG> and
+// if there is no real point of intersection EDGE/EDGE:
+ Standard_Integer nbIt=myTZones.Length();
+ Standard_Integer decal=0;
+ Standard_Integer addr1, addr2;
+ Intf_PIType dim1, dim2;
+ Standard_Real par;
+ Standard_Integer tsp, tsps;
+ Standard_Integer lpi, ltz;
+ Standard_Boolean Only1Seg=Standard_False;
+
+#define PI1 (myTZones(ltz-decal).GetPoint(lpi))
+#define PI2 (myTZones(ltz-decal).GetPoint(tsp))
+
+ for (ltz=1; ltz<=nbIt; ltz++) {
+ tsp=tsps=0;
+ Standard_Real pr1mi,pr1ma,pr2mi,pr2ma,delta1,delta2;
+ myTZones(ltz-decal).ParamOnFirst(pr1mi,pr1ma);
+ delta1=pr1ma-pr1mi;
+ myTZones(ltz-decal).ParamOnSecond(pr2mi,pr2ma);
+ delta2=pr2ma-pr2mi;
+ if (delta1<1. && delta2<1.) Only1Seg=Standard_True;
+ if (delta1==0. || delta2==0.) Only1Seg=Standard_True;
+
+ for (lpi=1; lpi<=myTZones(ltz-decal).NumberOfPoints(); lpi++) {
+ if (PI1.Incidence()<=PRCANG) {tsp=tsps=0;break;}
+ PI1.InfoFirst(dim1,addr1,par);
+ PI1.InfoSecond(dim2,addr2,par);
+ if (dim1==Intf_EDGE && dim2==Intf_EDGE) {
+ tsps=0;
+ if (tsp>0) {
+ tsp=0;
+ Only1Seg=Standard_False;
+ break;
+ }
+ tsp=lpi;
+ }
+ else if (dim1!=Intf_EXTERNAL && dim2!=Intf_EXTERNAL) {
+ tsps=lpi;
+ }
+ }
+ if (tsp>0) {
+ mySPoins.Append(myTZones(ltz-decal).GetPoint(tsp));
+ myTZones.Remove(ltz-decal);
+ decal++;
+ }
+ else if (Only1Seg && tsps!=0) {
+ mySPoins.Append(myTZones(ltz-decal).GetPoint(tsps));
+ myTZones.Remove(ltz-decal);
+ decal++;
+ }
+ }
+
+
+// The points of intersection located in the tangency zone are
+// removed from the list :
+ nbIt=mySPoins.Length();
+ decal=0;
+
+ for (lpi=1; lpi<=nbIt; lpi++) {
+ for (ltz=1; ltz<=myTZones.Length(); ltz++) {
+ if (myTZones(ltz).RangeContains(mySPoins(lpi-decal))) {
+ mySPoins.Remove(lpi-decal);
+ decal++;
+ break;
+ }
+ }
+ }
+}
+
+
+//=======================================================================
+//function : Intersect
+//purpose :
+//=======================================================================
+
+void Intf_InterferencePolygon2d::Intersect
+ (const Standard_Integer iObje1, const Standard_Integer iObje2,
+ const gp_Pnt2d& BegO, const gp_Pnt2d& EndO,
+ const gp_Pnt2d& BegT, const gp_Pnt2d& EndT)
+{
+ if(SelfIntf) {
+ if(Abs(iObje1-iObje2)<=1) return; //-- Ajout du 15 jan 98
+ }
+
+ Standard_Integer nbpi=0;
+ Standard_Real parO[8];
+ Standard_Real parT[8];
+ Intf_SeqOfSectionPoint thePi;
+ gp_XY segT =EndT.XY()-BegT.XY();
+ gp_XY segO =EndO.XY()-BegO.XY();
+
+// If the length of segment is zero, nothing is done
+ Standard_Real lgT =Sqrt(segT*segT);
+ if (lgT<=0.) return;
+ Standard_Real lgO =Sqrt(segO*segO);
+ if (lgO<=0.) return;
+
+// Direction of parsing of segments
+ Standard_Real sigPS=(segO*segT)>0.0 ? 1.0 : -1.0;
+
+// Precision of calculation
+ Standard_Real floatgap=Epsilon(lgO+lgT);
+
+// Angle between two straight lines and radius of interference
+ Standard_Real sinTeta=(segO.CrossMagnitude(segT)/lgO)/lgT;
+ Standard_Real rayIntf=0.;
+ if (sinTeta>0.) rayIntf=Tolerance/sinTeta;
+
+// Interference <begO> <segT>
+ Standard_Real dbOT=((BegO.XY()-BegT.XY())^segT)/lgT;
+ Standard_Real dbObT=BegO.Distance(BegT);
+ Standard_Real dbOeT=BegO.Distance(EndT);
+ if (Abs(dbOT)<=Tolerance) {
+ if (dbObT<=Tolerance) {
+ nbpi++;
+ parO[nbpi]=0.;parT[nbpi]=0.;
+ thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
+ Intf_VERTEX,iObje2,0.,sinTeta));
+ }
+ if (dbOeT<=Tolerance) {
+ nbpi++;
+ parO[nbpi]=0.;parT[nbpi]=1.;
+ thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
+ Intf_VERTEX,iObje2+1,0.,sinTeta));
+ }
+ if (dbObT>Tolerance && dbOeT>Tolerance &&
+ dbObT+dbOeT<=(lgT+Tolerance)) {
+ nbpi++;
+ parO[nbpi]=0.;parT[nbpi]=dbObT/lgT;
+ thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
+ Intf_EDGE,iObje2,parT[nbpi],sinTeta));
+ }
+ }
+
+// Interference <endO> <segT>
+ Standard_Real deOT=((EndO.XY()-BegT.XY())^segT)/lgT;
+ Standard_Real deObT=EndO.Distance(BegT);
+ Standard_Real deOeT=EndO.Distance(EndT);
+ if (Abs(deOT)<=Tolerance) {
+ if (deObT<=Tolerance) {
+ nbpi++;
+ parO[nbpi]=1.;parT[nbpi]=0.;
+ thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
+ Intf_VERTEX,iObje2,0.,sinTeta));
+ }
+ if (deOeT<=Tolerance) {
+ nbpi++;
+ parO[nbpi]=1.;parT[nbpi]=1.;
+ thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
+ Intf_VERTEX,iObje2+1,0.,sinTeta));
+ }
+ if (deObT>Tolerance && deOeT>Tolerance &&
+ deObT+deOeT<=(lgT+Tolerance)) {
+ nbpi++;
+ parO[nbpi]=1.;parT[nbpi]=deObT/lgT;
+ thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
+ Intf_EDGE,iObje2,parT[nbpi],sinTeta));
+ }
+ }
+
+// Interference <begT> <segO>
+ Standard_Real dbTO=((BegT.XY()-BegO.XY())^segO)/lgO;
+ if (Abs(dbTO)<=Tolerance) {
+ if (dbObT>Tolerance && deObT>Tolerance &&
+ dbObT+deObT<=(lgO+Tolerance)) {
+ nbpi++;
+ parO[nbpi]=dbObT/lgO;parT[nbpi]=0.;
+ thePi.Append(Intf_SectionPoint(BegT,Intf_EDGE,iObje1,parO[nbpi],
+ Intf_VERTEX,iObje2,0.,sinTeta));
+ }
+ }
+
+// Interference <endT> <segO>
+ Standard_Real deTO=((EndT.XY()-BegO.XY())^segO)/lgO;
+ if (Abs(deTO)<=Tolerance) {
+ if (dbOeT>Tolerance && deOeT>Tolerance &&
+ dbOeT+deOeT<=(lgO+Tolerance)) {
+ nbpi++;
+ parO[nbpi]=dbOeT/lgO;parT[nbpi]=1.;
+ thePi.Append(Intf_SectionPoint(EndT,Intf_EDGE,iObje1,parO[nbpi],
+ Intf_VERTEX,iObje2+1,0.,sinTeta));
+ }
+ }
+
+ Standard_Boolean edgeSP=Standard_False;
+ Standard_Real parOSP=0, parTSP=0;
+
+ if (Abs(dbOT-deOT)>floatgap && Abs(dbTO-deTO)>floatgap) {
+ parOSP=dbOT/(dbOT-deOT);
+ parTSP=dbTO/(dbTO-deTO);
+ if (dbOT*deOT<=0. && dbTO*deTO<=0.) {
+ edgeSP=Standard_True;
+ }
+ else if (nbpi==0) return;
+
+// If there is no interference it is necessary to take the points segment by segment
+ if (nbpi==0 && sinTeta>PRCANG) {
+ nbpi++;
+ parO[nbpi]=parOSP;
+ parT[nbpi]=parTSP;
+ thePi.Append(Intf_SectionPoint(gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
+ BegO.Y()+ (segO.Y()*parOSP)),
+ Intf_EDGE,iObje1,parOSP,
+ Intf_EDGE,iObje2,parTSP,sinTeta));
+ }
+
+// Otherwise it is required to check if there is no other
+ else if (rayIntf>=Tolerance) {
+ Standard_Real deltaO=rayIntf/lgO;
+ Standard_Real deltaT=rayIntf/lgT;
+ Standard_Real x, y;
+ Standard_Real parOdeb=parOSP-deltaO;
+ Standard_Real parOfin=parOSP+deltaO;
+ Standard_Real parTdeb=parTSP-sigPS*deltaT;
+ Standard_Real parTfin=parTSP+sigPS*deltaT;
+ if (nbpi==0) {
+ parO[1]=parOdeb;
+ parO[2]=parOfin;
+ parT[1]=parTdeb;
+ parT[2]=parTfin;
+ while (nbpi<2) {
+ nbpi++;
+ x=BegO.X()+ (segO.X()*parO[nbpi]);
+ y=BegO.Y()+ (segO.Y()*parO[nbpi]);
+ thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
+ Intf_EXTERNAL, iObje1, parO[nbpi],
+ Intf_EXTERNAL, iObje2, parT[nbpi],
+ sinTeta));
+ }
+ }
+ else { //nbpi>0
+ if (nbpi==1) {
+ Standard_Boolean ok=Standard_True;
+ if (0.<parOdeb && parOdeb<1. && 0.<parTdeb && parTdeb<1. ) {
+ parO[nbpi+1]=parOdeb;
+ parT[nbpi+1]=parTdeb;
+ }
+ else if (0.<parOfin && parOfin<1. && 0.<parTfin && parTfin<1. ) {
+ parO[nbpi+1]= parOfin;
+ parT[nbpi+1]= parTfin;
+ }
+ else {
+ ok=Standard_False;
+ }
+
+ if (ok) {
+ x=BegO.X()+ (segO.X()*parO[nbpi+1]);
+ y=BegO.Y()+ (segO.Y()*parO[nbpi+1]);
+ if (thePi(1).Pnt().Distance(gp_Pnt(x, y, 0)) >= (Tolerance/4.)) {
+ nbpi++;
+ thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
+ Intf_EXTERNAL, iObje1, parO[nbpi],
+ Intf_EXTERNAL, iObje2, parT[nbpi],
+ sinTeta));
+ }
+ }
+ }
+ else { // plus d une singularite
+ Standard_Real parOmin=parO[1];
+ Standard_Real parOmax=parO[1];
+ Standard_Real parTmin=parT[1];
+ Standard_Real parTmax=parT[1];
+ for (Standard_Integer i=2; i<=nbpi; i++) {
+ parOmin=Min(parOmin, parO[i]);
+ parOmax=Max(parOmax, parO[i]);
+ parTmin=Min(parTmin, parT[i]);
+ parTmax=Max(parTmax, parT[i]);
+ }
+
+ Standard_Real delta;
+ if (parOdeb<0.) {
+ delta=-parOdeb;
+ parOdeb=0.;
+ parTdeb=parTdeb+sigPS*(delta*(deltaT/deltaO));
+ }
+ if (parOfin>1.) {
+ delta=parOfin-1.;
+ parOfin=1.;
+ parTfin=parTfin-sigPS*(delta*(deltaT/deltaO));
+ }
+ if (sigPS>0.) {
+ if (parTdeb<0.) {
+ delta=-parTdeb;
+ parTdeb=0.;
+ parOdeb=parOdeb+delta*(deltaO/deltaT);
+ }
+ if (parTfin>1.) {
+ delta=parTfin-1.;
+ parTfin=1.;
+ parOfin=parOfin-delta*(deltaO/deltaT);
+ }
+ }
+ else {
+ if (parTdeb>1.) {
+ delta=parTdeb-1.;
+ parTdeb=1.;
+ parOdeb=parOdeb+delta*(deltaO/deltaT);
+ }
+ if (parTfin<0.) {
+ delta=-parTfin;
+ parTfin=0.;
+ parOfin=parOfin-delta*(deltaO/deltaT);
+ }
+ }
+
+ if ((parOdeb<parOmin && parOmin>0.) ||
+ (sigPS>0. && parTdeb<parTmin && parTmin>0.) ||
+ (sigPS<0. && parTdeb>parTmax && parTmax<1.)) {
+ nbpi++;
+ parO[nbpi]=Max(0., Min(1., parOdeb));
+ parT[nbpi]=Max(0., Min(1., parTdeb));
+ x=BegO.X()+ (segO.X()*parO[nbpi]);
+ y=BegO.Y()+ (segO.Y()*parO[nbpi]);
+ thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
+ Intf_EXTERNAL, iObje1, parO[nbpi],
+ Intf_EXTERNAL, iObje2, parT[nbpi],
+ sinTeta));
+ }
+
+ if ((parOfin>parOmax && parOmax<1.) ||
+ (sigPS<0. && parTfin<parTmin && parTmin>0.) ||
+ (sigPS>0. && parTfin>parTmax && parTmax<1.)) {
+ nbpi++;
+ parO[nbpi]=Min(1., Max(0., parOfin));
+ parT[nbpi]=Min(1., Max(0., parTfin));
+ x=BegO.X()+ (segO.X()*parO[nbpi]);
+ y=BegO.Y()+ (segO.Y()*parO[nbpi]);
+ thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
+ Intf_EXTERNAL, iObje1, parO[nbpi],
+ Intf_EXTERNAL, iObje2, parT[nbpi],
+ sinTeta));
+ }
+ }
+ }
+ }
+ }
+
+ //-- lbr : The points too close to each other are suspended
+ Standard_Boolean suppr;
+ do {
+ suppr=Standard_False;
+ for(Standard_Integer i=2; suppr==Standard_False && i<=nbpi; i++) {
+ const gp_Pnt& Pim1 = thePi(i-1).Pnt();
+ const gp_Pnt& Pi = thePi(i).Pnt();
+ Standard_Real d=Pi.Distance(Pim1);
+ d*=50.0;
+ if(d<lgT && d<lgO) {
+ for(Standard_Integer j=i; j<nbpi; j++) {
+ thePi(j)=thePi(j+1);
+ }
+ nbpi--;
+ suppr=Standard_True;
+ }
+ }
+ }
+ while(suppr==Standard_True);
+
+
+
+
+
+
+ if (nbpi==1) {
+ if (edgeSP) {
+ thePi(1)=Intf_SectionPoint(gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
+ BegO.Y()+ (segO.Y()*parOSP)),
+ Intf_EDGE,iObje1,parOSP,
+ Intf_EDGE,iObje2,parTSP,sinTeta);
+ parO[1]=parOSP;
+ parT[1]=parTSP;
+ }
+ if (!SelfIntf) {
+ Standard_Boolean contains = Standard_False;
+ for (Standard_Integer i = 1; i <= mySPoins.Length(); i++)
+ if (thePi(1).IsEqual(mySPoins(i))) {
+ contains = Standard_True;
+ break;
+ }
+ if (!contains)
+ mySPoins.Append(thePi(1));
+ }
+ else if (iObje2-iObje1!=1 &&
+ (!oClos || (iObje1!=1 && iObje2!=nbso))) {
+ mySPoins.Append(thePi(1));
+ }
+ }
+
+ else if (nbpi>=2) {
+ Intf_TangentZone TheTZ;
+ if (nbpi==2) {
+ TheTZ.PolygonInsert(thePi(1));
+ TheTZ.PolygonInsert(thePi(2));
+ }
+ else {
+ Standard_Integer lpj;
+ Standard_Integer lmin=1;
+ Standard_Integer lmax=1;
+ for (lpj=2; lpj<=nbpi; lpj++) {
+ if (parO[lpj]<parO[lmin]) lmin=lpj;
+ else if (parO[lpj]>parO[lmax]) lmax=lpj;
+ }
+ TheTZ.PolygonInsert(thePi(lmin));
+ TheTZ.PolygonInsert(thePi(lmax));
+
+ Standard_Integer ltmin=1;
+ Standard_Integer ltmax=1;
+ for (lpj=2; lpj<=nbpi; lpj++) {
+ if (parT[lpj]<parT[ltmin]) ltmin=lpj;
+ else if (parT[lpj]>parT[ltmax]) ltmax=lpj;
+ }
+ if (ltmin!=lmin && ltmin!=lmax) TheTZ.PolygonInsert(thePi(ltmin));
+ if (ltmax!=lmin && ltmax!=lmax) TheTZ.PolygonInsert(thePi(ltmax));
+ }
+
+ if (edgeSP) TheTZ.PolygonInsert(Intf_SectionPoint
+ (gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
+ BegO.Y()+ (segO.Y()*parOSP)),
+ Intf_EDGE,iObje1,parOSP,
+ Intf_EDGE,iObje2,parTSP,sinTeta));
+
+ Standard_Integer nbtz=myTZones.Length();
+#if 0
+ Standard_Integer decaltz=0;
+ for (Standard_Integer ltz=1; ltz<=nbtz; ltz++) {
+ if (TheTZ.HasCommonRange(myTZones(ltz-decaltz))) {
+ TheTZ.Append(myTZones(ltz-decaltz));
+ myTZones.Remove(ltz-decaltz);
+ decaltz++;
+ }
+ }
+ myTZones.Append(TheTZ);
+#else
+ TColStd_ListOfInteger LIndex;
+ for (Standard_Integer ltz=1; ltz<=nbtz; ltz++) {
+ if (TheTZ.HasCommonRange(myTZones(ltz))) {
+ LIndex.Append(ltz);
+ }
+ }
+ //------------------------------------------------------------------------
+ //-- The list is parsed in ascending order by index, zone and tg
+ //--
+ if(LIndex.IsEmpty()) {
+ myTZones.Append(TheTZ);
+ }
+ else {
+ Standard_Integer indexfirst = LIndex.First();
+ LIndex.RemoveFirst();
+ Standard_Integer decal = 0;
+ myTZones(indexfirst).Append(TheTZ);
+ while(!LIndex.IsEmpty()) {
+ Standard_Integer index = LIndex.First();
+ LIndex.RemoveFirst();
+ myTZones(indexfirst).Append(myTZones(index-decal));
+ myTZones.Remove(index-decal);
+ decal++;
+ }
+ }
+#endif
+ }
+}
-// File: Intf_InterferencePolygon2d.gxx
-// Created: Mon Jun 24 11:52:34 1991
-// Author: Didier PIFFAULT
-// <dpf@phobox>
-
-#include <gp_Pnt2d.hxx>
-#include <Bnd_Box2d.hxx>
-#include <Intf_SectionPoint.hxx>
-#include <Intf_SeqOfSectionPoint.hxx>
-#include <Intf_TangentZone.hxx>
-#include <Intf_SeqOfTangentZone.hxx>
-#include <Precision.hxx>
-#include <TColStd_ListOfInteger.hxx>
-
-// Angular precision (sinus) below that value two right segments
-// are considered as having a potential zone of tangency.
-namespace
-{
- static const Standard_Real PRCANG = Precision::Angular();
-};
-
-//=======================================================================
-//function : Intf_InterferencePolygon2d
-//purpose : constructor empty
-//=======================================================================
-
-Intf_InterferencePolygon2d::Intf_InterferencePolygon2d()
-: Intf_Interference (Standard_False),
- oClos (Standard_False),
- tClos (Standard_False),
- iObje1 (0),
- iObje2 (0),
- nbso (0),
- BeginOfNotClosedObje1 (Standard_False),
- BeginOfNotClosedObje2 (Standard_False)
-{}
-
-//=======================================================================
-//function : Intf_InterferencePolygon2d
-//purpose : Constructor of the interference beetween two Polygon.
-//=======================================================================
-
-Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
- (const Polygon2d1& Obje1, const Polygon2d2& Obje2)
-: Intf_Interference (Standard_False),
- oClos (Standard_False),
- tClos (Standard_False),
- iObje1 (0),
- iObje2 (0),
- nbso (0),
- BeginOfNotClosedObje1 (Standard_False),
- BeginOfNotClosedObje2 (Standard_False)
-{
- if (!ToolPolygon2d1::Bounding(Obje1).IsOut
- (ToolPolygon2d2::Bounding(Obje2))) {
- Tolerance=ToolPolygon2d1::DeflectionOverEstimation(Obje1)+
- ToolPolygon2d2::DeflectionOverEstimation(Obje2);
- if (Tolerance==0.)
- Tolerance=Epsilon(1000.);
- nbso=ToolPolygon2d1::NbSegments(Obje1);
- oClos=ToolPolygon2d1::Closed(Obje1);
- tClos=ToolPolygon2d2::Closed(Obje2);
- Interference(Obje1, Obje2);
- Clean();
- }
-}
-
-
-//=======================================================================
-//function : Intf_InterferencePolygon2d
-//purpose : Constructor of the auto interference of a Polygon.
-//=======================================================================
-
-Intf_InterferencePolygon2d::Intf_InterferencePolygon2d
- (const Polygon2d1& Obje)
-: Intf_Interference (Standard_True),
- oClos (Standard_False),
- tClos (Standard_False),
- iObje1 (0),
- iObje2 (0),
- nbso (0),
- BeginOfNotClosedObje1 (Standard_False),
- BeginOfNotClosedObje2 (Standard_False)
-{
- Tolerance=ToolPolygon2d1::DeflectionOverEstimation(Obje)*2;
- if (Tolerance==0.)
- Tolerance=Epsilon(1000.);
- oClos=ToolPolygon2d1::Closed(Obje);
- tClos=oClos;
- Interference(Obje);
- Clean();
-}
-
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
-
-void Intf_InterferencePolygon2d::Perform
- (const Polygon2d1& Obje1, const Polygon2d2& Obje2)
-{
- SelfInterference(Standard_False);
- if (!ToolPolygon2d1::Bounding(Obje1).IsOut(ToolPolygon2d2::Bounding(Obje2))) {
- Tolerance=ToolPolygon2d1::DeflectionOverEstimation(Obje1)+
- ToolPolygon2d2::DeflectionOverEstimation(Obje2);
- if (Tolerance==0.)
- Tolerance=Epsilon(1000.);
- nbso=ToolPolygon2d1::NbSegments(Obje1);
- oClos=ToolPolygon2d1::Closed(Obje1);
- tClos=ToolPolygon2d2::Closed(Obje2);
- Interference(Obje1, Obje2);
- Clean();
- }
-}
-
-//=======================================================================
-//function : Perform
-//purpose :
-//=======================================================================
-
-void Intf_InterferencePolygon2d::Perform
- (const Polygon2d1& Obje)
-{
- SelfInterference(Standard_True);
- Tolerance=ToolPolygon2d1::DeflectionOverEstimation(Obje)*2;
- if (Tolerance==0.)
- Tolerance=Epsilon(1000.);
- oClos=ToolPolygon2d1::Closed(Obje);
- tClos=oClos;
- Interference(Obje);
- Clean();
-}
-
-//=======================================================================
-//function : Pnt2dValue
-//purpose : Give the section point of range Index in the interference.
-//=======================================================================
-
-gp_Pnt2d Intf_InterferencePolygon2d::Pnt2dValue
- (const Standard_Integer Index) const
-{
- return gp_Pnt2d((mySPoins(Index)).Pnt().X(),
- (mySPoins(Index)).Pnt().Y());
-}
-
-
-//=======================================================================
-//function : Interference
-//purpose :
-//=======================================================================
-
-void Intf_InterferencePolygon2d::Interference
- (const Polygon2d1& Obje1,
- const Polygon2d2& Obje2)
-{
- Bnd_Box2d bSO;
- Bnd_Box2d bST;
-
- BeginOfNotClosedObje1=!oClos;
- for (iObje1=1; iObje1<=ToolPolygon2d1::NbSegments(Obje1); iObje1++) {
- bSO.SetVoid();
- bSO.Add(ToolPolygon2d1::BeginOfSeg(Obje1, iObje1));
- bSO.Add(ToolPolygon2d1::EndOfSeg(Obje1, iObje1));
- bSO.Enlarge(ToolPolygon2d1::DeflectionOverEstimation(Obje1));
- if (!ToolPolygon2d2::Bounding(Obje2).IsOut(bSO)) {
- BeginOfNotClosedObje2=!tClos;
- for (iObje2=1; iObje2<=ToolPolygon2d2::NbSegments(Obje2); iObje2++) {
- bST.SetVoid();
- bST.Add(ToolPolygon2d2::BeginOfSeg(Obje2, iObje2));
- bST.Add(ToolPolygon2d2::EndOfSeg(Obje2, iObje2));
- bST.Enlarge(ToolPolygon2d2::DeflectionOverEstimation(Obje2));
- if (!bSO.IsOut(bST))
- Intersect(ToolPolygon2d1::BeginOfSeg(Obje1, iObje1),
- ToolPolygon2d1::EndOfSeg(Obje1, iObje1),
- ToolPolygon2d2::BeginOfSeg(Obje2, iObje2),
- ToolPolygon2d2::EndOfSeg(Obje2, iObje2));
- }
- BeginOfNotClosedObje2=Standard_False;
- }
- BeginOfNotClosedObje1=Standard_False;
- }
-}
-
-//=======================================================================
-//function : Interference
-//purpose :
-//=======================================================================
-
-void Intf_InterferencePolygon2d::Interference
- (const Polygon2d1& Obje)
-{
- Bnd_Box2d bSO;
- Bnd_Box2d bST;
-
- BeginOfNotClosedObje1=!oClos;
- for (iObje1=1; iObje1<=ToolPolygon2d1::NbSegments(Obje); iObje1++) {
- bSO.SetVoid();
- bSO.Add(ToolPolygon2d1::BeginOfSeg(Obje, iObje1));
- bSO.Add(ToolPolygon2d1::EndOfSeg(Obje, iObje1));
- bSO.Enlarge(ToolPolygon2d1::DeflectionOverEstimation(Obje));
- if (!ToolPolygon2d1::Bounding(Obje).IsOut(bSO)) {
- BeginOfNotClosedObje2=!tClos;
- for (iObje2=iObje1+1;iObje2<=ToolPolygon2d1::NbSegments(Obje);iObje2++){
- bST.SetVoid();
- bST.Add(ToolPolygon2d1::BeginOfSeg(Obje, iObje2));
- bST.Add(ToolPolygon2d1::EndOfSeg(Obje, iObje2));
- bST.Enlarge(ToolPolygon2d1::DeflectionOverEstimation(Obje));
- if (!bSO.IsOut(bST))
- Intersect(ToolPolygon2d1::BeginOfSeg(Obje, iObje1),
- ToolPolygon2d1::EndOfSeg(Obje, iObje1),
- ToolPolygon2d1::BeginOfSeg(Obje, iObje2),
- ToolPolygon2d1::EndOfSeg(Obje, iObje2));
- }
- BeginOfNotClosedObje2=Standard_False;
- }
- BeginOfNotClosedObje1=Standard_False;
- }
-}
-
-
-//=======================================================================
-//function : Clean
-//purpose :
-//=======================================================================
-
-void Intf_InterferencePolygon2d::Clean()
-{
-
-// The zones of tangency that concerns only one couple of segments are
-// conserved if the angle between the segments is less than <PRCANG> and
-// if there is no real point of intersection EDGE/EDGE:
- Standard_Integer nbIt=myTZones.Length();
- Standard_Integer decal=0;
- Standard_Integer addr1, addr2;
- Intf_PIType dim1, dim2;
- Standard_Real par;
- Standard_Integer tsp, tsps;
- Standard_Integer lpi, ltz;
- Standard_Boolean Only1Seg=Standard_False;
-
-#define PI1 (myTZones(ltz-decal).GetPoint(lpi))
-#define PI2 (myTZones(ltz-decal).GetPoint(tsp))
-
- for (ltz=1; ltz<=nbIt; ltz++) {
- tsp=tsps=0;
- Standard_Real pr1mi,pr1ma,pr2mi,pr2ma,delta1,delta2;
- myTZones(ltz-decal).ParamOnFirst(pr1mi,pr1ma);
- delta1=pr1ma-pr1mi;
- myTZones(ltz-decal).ParamOnSecond(pr2mi,pr2ma);
- delta2=pr2ma-pr2mi;
- if (delta1<1. && delta2<1.) Only1Seg=Standard_True;
- if (delta1==0. || delta2==0.) Only1Seg=Standard_True;
-
- for (lpi=1; lpi<=myTZones(ltz-decal).NumberOfPoints(); lpi++) {
- if (PI1.Incidence()<=PRCANG) {tsp=tsps=0;break;}
- PI1.InfoFirst(dim1,addr1,par);
- PI1.InfoSecond(dim2,addr2,par);
- if (dim1==Intf_EDGE && dim2==Intf_EDGE) {
- tsps=0;
- if (tsp>0) {
- tsp=0;
- Only1Seg=Standard_False;
- break;
- }
- tsp=lpi;
- }
- else if (dim1!=Intf_EXTERNAL && dim2!=Intf_EXTERNAL) {
- tsps=lpi;
- }
- }
- if (tsp>0) {
- mySPoins.Append(myTZones(ltz-decal).GetPoint(tsp));
- myTZones.Remove(ltz-decal);
- decal++;
- }
- else if (Only1Seg && tsps!=0) {
- mySPoins.Append(myTZones(ltz-decal).GetPoint(tsps));
- myTZones.Remove(ltz-decal);
- decal++;
- }
- }
-
-
-// The points of intersection located in the tangency zone are
-// removed from the list :
- nbIt=mySPoins.Length();
- decal=0;
-
- for (lpi=1; lpi<=nbIt; lpi++) {
- for (ltz=1; ltz<=myTZones.Length(); ltz++) {
- if (myTZones(ltz).RangeContains(mySPoins(lpi-decal))) {
- mySPoins.Remove(lpi-decal);
- decal++;
- break;
- }
- }
- }
-}
-
-
-//=======================================================================
-//function : Intersect
-//purpose :
-//=======================================================================
-
-void Intf_InterferencePolygon2d::Intersect
- (const gp_Pnt2d& BegO, const gp_Pnt2d& EndO,
- const gp_Pnt2d& BegT, const gp_Pnt2d& EndT)
-{
-
-
- if(SelfIntf) {
- if(Abs(iObje1-iObje2)<=1) return; //-- Ajout du 15 jan 98
- }
-
- Standard_Integer nbpi=0;
- Standard_Real parO[8];
- Standard_Real parT[8];
- Intf_SeqOfSectionPoint thePi;
- gp_XY segT =EndT.XY()-BegT.XY();
- gp_XY segO =EndO.XY()-BegO.XY();
-
-// If the length of segment is zero, nothing is done
- Standard_Real lgT =Sqrt(segT*segT);
- if (lgT<=0.) return;
- Standard_Real lgO =Sqrt(segO*segO);
- if (lgO<=0.) return;
-
-// Direction of parsing of segments
- Standard_Real sigPS=(segO*segT)>0.0 ? 1.0 : -1.0;
-
-// Precision of calculation
- Standard_Real floatgap=Epsilon(lgO+lgT);
-
-// Angle between two straight lines and radius of interference
- Standard_Real sinTeta=(segO.CrossMagnitude(segT)/lgO)/lgT;
- Standard_Real rayIntf=0.;
- if (sinTeta>0.) rayIntf=Tolerance/sinTeta;
-
-// Interference <begO> <segT>
- Standard_Real dbOT=((BegO.XY()-BegT.XY())^segT)/lgT;
- Standard_Real dbObT=BegO.Distance(BegT);
- Standard_Real dbOeT=BegO.Distance(EndT);
- if (Abs(dbOT)<=Tolerance) {
- if (dbObT<=Tolerance) {
- nbpi++;
- parO[nbpi]=0.;parT[nbpi]=0.;
- thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
- Intf_VERTEX,iObje2,0.,sinTeta));
- }
- if (dbOeT<=Tolerance) {
- nbpi++;
- parO[nbpi]=0.;parT[nbpi]=1.;
- thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
- Intf_VERTEX,iObje2+1,0.,sinTeta));
- }
- if (dbObT>Tolerance && dbOeT>Tolerance &&
- dbObT+dbOeT<=(lgT+Tolerance)) {
- nbpi++;
- parO[nbpi]=0.;parT[nbpi]=dbObT/lgT;
- thePi.Append(Intf_SectionPoint(BegO,Intf_VERTEX,iObje1,0.,
- Intf_EDGE,iObje2,parT[nbpi],sinTeta));
- }
- }
-
-// Interference <endO> <segT>
- Standard_Real deOT=((EndO.XY()-BegT.XY())^segT)/lgT;
- Standard_Real deObT=EndO.Distance(BegT);
- Standard_Real deOeT=EndO.Distance(EndT);
- if (Abs(deOT)<=Tolerance) {
- if (deObT<=Tolerance) {
- nbpi++;
- parO[nbpi]=1.;parT[nbpi]=0.;
- thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
- Intf_VERTEX,iObje2,0.,sinTeta));
- }
- if (deOeT<=Tolerance) {
- nbpi++;
- parO[nbpi]=1.;parT[nbpi]=1.;
- thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
- Intf_VERTEX,iObje2+1,0.,sinTeta));
- }
- if (deObT>Tolerance && deOeT>Tolerance &&
- deObT+deOeT<=(lgT+Tolerance)) {
- nbpi++;
- parO[nbpi]=1.;parT[nbpi]=deObT/lgT;
- thePi.Append(Intf_SectionPoint(EndO,Intf_VERTEX,iObje1+1,0.,
- Intf_EDGE,iObje2,parT[nbpi],sinTeta));
- }
- }
-
-// Interference <begT> <segO>
- Standard_Real dbTO=((BegT.XY()-BegO.XY())^segO)/lgO;
- if (Abs(dbTO)<=Tolerance) {
- if (dbObT>Tolerance && deObT>Tolerance &&
- dbObT+deObT<=(lgO+Tolerance)) {
- nbpi++;
- parO[nbpi]=dbObT/lgO;parT[nbpi]=0.;
- thePi.Append(Intf_SectionPoint(BegT,Intf_EDGE,iObje1,parO[nbpi],
- Intf_VERTEX,iObje2,0.,sinTeta));
- }
- }
-
-// Interference <endT> <segO>
- Standard_Real deTO=((EndT.XY()-BegO.XY())^segO)/lgO;
- if (Abs(deTO)<=Tolerance) {
- if (dbOeT>Tolerance && deOeT>Tolerance &&
- dbOeT+deOeT<=(lgO+Tolerance)) {
- nbpi++;
- parO[nbpi]=dbOeT/lgO;parT[nbpi]=1.;
- thePi.Append(Intf_SectionPoint(EndT,Intf_EDGE,iObje1,parO[nbpi],
- Intf_VERTEX,iObje2+1,0.,sinTeta));
- }
- }
-
- Standard_Boolean edgeSP=Standard_False;
- Standard_Real parOSP=0, parTSP=0;
-
- if (Abs(dbOT-deOT)>floatgap && Abs(dbTO-deTO)>floatgap) {
- parOSP=dbOT/(dbOT-deOT);
- parTSP=dbTO/(dbTO-deTO);
- if (dbOT*deOT<=0. && dbTO*deTO<=0.) {
- edgeSP=Standard_True;
- }
- else if (nbpi==0) return;
-
-// If there is no interference it is necessary to take the points segment by segment
- if (nbpi==0 && sinTeta>PRCANG) {
- nbpi++;
- parO[nbpi]=parOSP;
- parT[nbpi]=parTSP;
- thePi.Append(Intf_SectionPoint(gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
- BegO.Y()+ (segO.Y()*parOSP)),
- Intf_EDGE,iObje1,parOSP,
- Intf_EDGE,iObje2,parTSP,sinTeta));
- }
-
-// Otherwise it is required to check if there is no other
- else if (rayIntf>=Tolerance) {
- Standard_Real deltaO=rayIntf/lgO;
- Standard_Real deltaT=rayIntf/lgT;
- Standard_Real x, y;
- Standard_Real parOdeb=parOSP-deltaO;
- Standard_Real parOfin=parOSP+deltaO;
- Standard_Real parTdeb=parTSP-sigPS*deltaT;
- Standard_Real parTfin=parTSP+sigPS*deltaT;
- if (nbpi==0) {
- parO[1]=parOdeb;
- parO[2]=parOfin;
- parT[1]=parTdeb;
- parT[2]=parTfin;
- while (nbpi<2) {
- nbpi++;
- x=BegO.X()+ (segO.X()*parO[nbpi]);
- y=BegO.Y()+ (segO.Y()*parO[nbpi]);
- thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
- Intf_EXTERNAL, iObje1, parO[nbpi],
- Intf_EXTERNAL, iObje2, parT[nbpi],
- sinTeta));
- }
- }
- else { //nbpi>0
- if (nbpi==1) {
- Standard_Boolean ok=Standard_True;
- if (0.<parOdeb && parOdeb<1. && 0.<parTdeb && parTdeb<1. ) {
- parO[nbpi+1]=parOdeb;
- parT[nbpi+1]=parTdeb;
- }
- else if (0.<parOfin && parOfin<1. && 0.<parTfin && parTfin<1. ) {
- parO[nbpi+1]= parOfin;
- parT[nbpi+1]= parTfin;
- }
- else {
- ok=Standard_False;
- }
-
- if (ok) {
- x=BegO.X()+ (segO.X()*parO[nbpi+1]);
- y=BegO.Y()+ (segO.Y()*parO[nbpi+1]);
- if (thePi(1).Pnt().Distance(gp_Pnt(x, y, 0)) >= (Tolerance/4.)) {
- nbpi++;
- thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
- Intf_EXTERNAL, iObje1, parO[nbpi],
- Intf_EXTERNAL, iObje2, parT[nbpi],
- sinTeta));
- }
- }
- }
- else { // plus d une singularite
- Standard_Real parOmin=parO[1];
- Standard_Real parOmax=parO[1];
- Standard_Real parTmin=parT[1];
- Standard_Real parTmax=parT[1];
- for (Standard_Integer i=2; i<=nbpi; i++) {
- parOmin=Min(parOmin, parO[i]);
- parOmax=Max(parOmax, parO[i]);
- parTmin=Min(parTmin, parT[i]);
- parTmax=Max(parTmax, parT[i]);
- }
-
- Standard_Real delta;
- if (parOdeb<0.) {
- delta=-parOdeb;
- parOdeb=0.;
- parTdeb=parTdeb+sigPS*(delta*(deltaT/deltaO));
- }
- if (parOfin>1.) {
- delta=parOfin-1.;
- parOfin=1.;
- parTfin=parTfin-sigPS*(delta*(deltaT/deltaO));
- }
- if (sigPS>0.) {
- if (parTdeb<0.) {
- delta=-parTdeb;
- parTdeb=0.;
- parOdeb=parOdeb+delta*(deltaO/deltaT);
- }
- if (parTfin>1.) {
- delta=parTfin-1.;
- parTfin=1.;
- parOfin=parOfin-delta*(deltaO/deltaT);
- }
- }
- else {
- if (parTdeb>1.) {
- delta=parTdeb-1.;
- parTdeb=1.;
- parOdeb=parOdeb+delta*(deltaO/deltaT);
- }
- if (parTfin<0.) {
- delta=-parTfin;
- parTfin=0.;
- parOfin=parOfin-delta*(deltaO/deltaT);
- }
- }
-
- if ((parOdeb<parOmin && parOmin>0.) ||
- (sigPS>0. && parTdeb<parTmin && parTmin>0.) ||
- (sigPS<0. && parTdeb>parTmax && parTmax<1.)) {
- nbpi++;
- parO[nbpi]=Max(0., Min(1., parOdeb));
- parT[nbpi]=Max(0., Min(1., parTdeb));
- x=BegO.X()+ (segO.X()*parO[nbpi]);
- y=BegO.Y()+ (segO.Y()*parO[nbpi]);
- thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
- Intf_EXTERNAL, iObje1, parO[nbpi],
- Intf_EXTERNAL, iObje2, parT[nbpi],
- sinTeta));
- }
-
- if ((parOfin>parOmax && parOmax<1.) ||
- (sigPS<0. && parTfin<parTmin && parTmin>0.) ||
- (sigPS>0. && parTfin>parTmax && parTmax<1.)) {
- nbpi++;
- parO[nbpi]=Min(1., Max(0., parOfin));
- parT[nbpi]=Min(1., Max(0., parTfin));
- x=BegO.X()+ (segO.X()*parO[nbpi]);
- y=BegO.Y()+ (segO.Y()*parO[nbpi]);
- thePi.Append(Intf_SectionPoint(gp_Pnt2d(x, y),
- Intf_EXTERNAL, iObje1, parO[nbpi],
- Intf_EXTERNAL, iObje2, parT[nbpi],
- sinTeta));
- }
- }
- }
- }
- }
-
- //-- lbr : The points too close to each other are suspended
- Standard_Boolean suppr;
- do {
- suppr=Standard_False;
- for(Standard_Integer i=2; suppr==Standard_False && i<=nbpi; i++) {
- const gp_Pnt& Pim1 = thePi(i-1).Pnt();
- const gp_Pnt& Pi = thePi(i).Pnt();
- Standard_Real d=Pi.Distance(Pim1);
- d*=50.0;
- if(d<lgT && d<lgO) {
- for(Standard_Integer j=i; j<nbpi; j++) {
- thePi(j)=thePi(j+1);
- }
- nbpi--;
- suppr=Standard_True;
- }
- }
- }
- while(suppr==Standard_True);
-
-
-
-
-
-
- if (nbpi==1) {
- if (edgeSP) {
- thePi(1)=Intf_SectionPoint(gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
- BegO.Y()+ (segO.Y()*parOSP)),
- Intf_EDGE,iObje1,parOSP,
- Intf_EDGE,iObje2,parTSP,sinTeta);
- parO[1]=parOSP;
- parT[1]=parTSP;
- }
- if (!SelfIntf) {
-// if ((BeginOfNotClosedObje1 && parO[1]==0.) ||
-// (BeginOfNotClosedObje2 && parT[1]==0.) ||
-// (parO[1]>0. && parT[1]>0.)) {
- {
- Standard_Boolean contains = Standard_False;
- for (Standard_Integer i = 1; i <= mySPoins.Length(); i++)
- if (thePi(1).IsEqual(mySPoins(i))) {
- contains = Standard_True;
- break;
- }
- if (!contains)
- mySPoins.Append(thePi(1));
- }
- }
- else if (iObje2-iObje1!=1 &&
- (!oClos || (iObje1!=1 && iObje2!=nbso))) {
- mySPoins.Append(thePi(1));
- }
- }
-
- else if (nbpi>=2) {
- Intf_TangentZone TheTZ;
- if (nbpi==2) {
- TheTZ.PolygonInsert(thePi(1));
- TheTZ.PolygonInsert(thePi(2));
- }
- else {
- Standard_Integer lpj;
- Standard_Integer lmin=1;
- Standard_Integer lmax=1;
- for (lpj=2; lpj<=nbpi; lpj++) {
- if (parO[lpj]<parO[lmin]) lmin=lpj;
- else if (parO[lpj]>parO[lmax]) lmax=lpj;
- }
- TheTZ.PolygonInsert(thePi(lmin));
- TheTZ.PolygonInsert(thePi(lmax));
-
- Standard_Integer ltmin=1;
- Standard_Integer ltmax=1;
- for (lpj=2; lpj<=nbpi; lpj++) {
- if (parT[lpj]<parT[ltmin]) ltmin=lpj;
- else if (parT[lpj]>parT[ltmax]) ltmax=lpj;
- }
- if (ltmin!=lmin && ltmin!=lmax) TheTZ.PolygonInsert(thePi(ltmin));
- if (ltmax!=lmin && ltmax!=lmax) TheTZ.PolygonInsert(thePi(ltmax));
- }
-
- if (edgeSP) TheTZ.PolygonInsert(Intf_SectionPoint
- (gp_Pnt2d (BegO.X()+ (segO.X()*parOSP),
- BegO.Y()+ (segO.Y()*parOSP)),
- Intf_EDGE,iObje1,parOSP,
- Intf_EDGE,iObje2,parTSP,sinTeta));
-
- Standard_Integer nbtz=myTZones.Length();
-#if 0
- Standard_Integer decaltz=0;
- for (Standard_Integer ltz=1; ltz<=nbtz; ltz++) {
- if (TheTZ.HasCommonRange(myTZones(ltz-decaltz))) {
- TheTZ.Append(myTZones(ltz-decaltz));
- myTZones.Remove(ltz-decaltz);
- decaltz++;
- }
- }
- myTZones.Append(TheTZ);
-#else
- TColStd_ListOfInteger LIndex;
- for (Standard_Integer ltz=1; ltz<=nbtz; ltz++) {
- if (TheTZ.HasCommonRange(myTZones(ltz))) {
- LIndex.Append(ltz);
- }
- }
- //------------------------------------------------------------------------
- //-- The list is parsed in ascending order by index, zone and tg
- //--
- if(LIndex.IsEmpty()) {
- myTZones.Append(TheTZ);
- }
- else {
- Standard_Integer indexfirst = LIndex.First();
- LIndex.RemoveFirst();
- Standard_Integer decal = 0;
- myTZones(indexfirst).Append(TheTZ);
- while(!LIndex.IsEmpty()) {
- Standard_Integer index = LIndex.First();
- LIndex.RemoveFirst();
- myTZones(indexfirst).Append(myTZones(index-decal));
- myTZones.Remove(index-decal);
- decal++;
- }
- }
-#endif
- }
-}
-
-// EOF File: Intf_InterferencePolygon2d.gxx
--- /dev/null
+-- File: Intf_Polygon2d.cdl
+-- Created: Fri Feb 10 17:49:16 2012
+-- Author: Serey ZERCHANINOV
+---Copyright: OPEN CASCADE SAS 2012
+
+
+deferred class Polygon2d from Intf
+
+ ---Purpose:
+
+uses Pnt2d from gp,
+ Box2d from Bnd
+
+raises OutOfRange from Standard
+
+is
+
+ Bounding (me)
+ returns Box2d from Bnd;
+ ---C++: return const &
+ ---C++: inline
+ ---Purpose: Returns the bounding box of the polygon.
+
+ Closed (me)
+ returns Boolean from Standard is virtual;
+ ---Purpose: Returns True if the polyline is closed.
+
+ DeflectionOverEstimation (me) returns Real from Standard is deferred;
+ ---Purpose: Returns the tolerance of the polygon.
+
+ NbSegments (me) returns Integer from Standard is deferred;
+ ---Purpose: Returns the number of Segments in the polyline.
+
+ Segment (me; theIndex : in Integer from Standard;
+ theBegin, theEnd : in out Pnt2d from gp)
+ raises OutOfRange from Standard is deferred;
+ ---Purpose: Returns the points of the segment <Index> in the Polygon.
+
+fields
+
+ myBox : Box2d from Bnd is protected;
+
+end Polygon2d;
--- /dev/null
+// File: Intf_Polygon2d.cxx
+// Created: Fri Feb 10 17:49:16 2012
+// Author: Sergey ZERCHANINOV
+// Copyright: OPEN CASCADE SAS 2012
+
+#include <Intf_Polygon2d.ixx>
+
+//=======================================================================
+//function : Closed
+//purpose :
+//=======================================================================
+
+Standard_Boolean Intf_Polygon2d::Closed () const
+{
+ return Standard_False;
+}
--- /dev/null
+// File: Intf_Polygon2d.lxx
+// Created: Fri Feb 10 17:49:16 2012
+// Author: Sergey ZERCHANINOV
+// Copyright: OPEN CASCADE SAS 2012
+
+
+//=======================================================================
+//function : Bounding
+//purpose :
+//=======================================================================
+
+inline const Bnd_Box2d& Intf_Polygon2d::Bounding () const
+{
+ return myBox;
+}
--- File: ToolPolygon.cdl
--- Created: Fri Aug 2 08:18:37 1991
--- Author: Didier PIFFAULT
--- <dpf@sdsun2>
----Copyright: Matra Datavision 1991, 1992
-
-
-generic class ToolPolygon from Intf
- (Point as any; -- as Pnt2d, Pnt from gp
- Polygon as any;
- BoundingBox as any) -- as Box2d, Box from Bnd
-
- ---Purpose: Describes the necessary information about a polyline to
- -- compute the interference between two polylines.
-
-raises OutOfRange from Standard
-
-
-is Bounding (myclass; thePolyg : Polygon)
- returns BoundingBox;
- ---Purpose: Returns the bounding box of the polygon.
-
- DeflectionOverEstimation
- (myclass; thePolyg : Polygon)
- returns Real from Standard;
- ---Purpose: Returns the tolerance of the polygon.
-
- Closed (myclass; thePolyg : Polygon)
- returns Boolean from Standard;
- ---Purpose: Returns True if the polyline is closed.
-
- NbSegments (myclass; thePolyg : Polygon)
- returns Integer;
- ---Purpose: Returns the number of Segments in the polyline.
-
- BeginOfSeg (myclass; thePolyg : Polygon;
- Index : in Integer)
- returns Point
- raises OutOfRange from Standard;
- ---Purpose: Returns the first point of segment of range <Index> in the
- -- Polygon.
-
- EndOfSeg (myclass; thePolyg : Polygon;
- Index : in Integer)
- returns Point
- raises OutOfRange from Standard;
- ---Purpose: Returns the Second point of the segment of range Index in
- -- the Polygon.
-
-end ToolPolygon;