OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-10 18:51:21 +03:00
Code

0022887: Request to make Intf_InterferencePolygon2d class thread-safe.

Browse Source
This commit is contained in:
azn 2012-03-12 18:31:11 +04:00 committed by bugmaster
parent d64e6d05d9
commit 9530af2780
34 changed files with 1054 additions and 1332 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/IntCurve/FILES
View File

@ -3,6 +3,5 @@ IntCurve_IntConicConic_1.cxx
IntCurve_IntConicConic_Tool.cxx
IntCurve_IntConicConic_Tool.cxx
IntCurve_IntConicConic_Tool.cxx
IntCurve_ToolPolygon.gxx
IntCurve_IntConicConic_1.hxx
IntCurve_IntConicConic_Tool.hxx

5
src/IntCurve/IntCurve.cdl
View File

@ -43,7 +43,6 @@ package IntCurve
-- ProjPCurGen,
-- UserIntConicCurveGen,
-- IntPolyPolyGen,
-- ToolPolygon,
-- Polygon2dGen,
-- DistBetweenPCurvesGen> are Internal
--
@ -67,11 +66,7 @@ is
generic class Polygon2dGen;
generic class ToolPolygon;
generic class IntPolyPolyGen,ThePolygon2d,
ThePolygon2dTool,
InterferencePoly2d,
TheDistBetweenPCurves,
ExactIntersectionPoint;

13
src/IntCurve/IntCurve_IntPolyPolyGen.cdl
View File

@ -1,7 +1,6 @@
-- File: IntPolyPolyGen.cdl
-- Created: Mon Oct 19 12:03:29 1992
-- Author: Laurent BUCHARD
-- <lbr@sdsun2>
---Copyright: Matra Datavision 1992
@ -24,22 +23,10 @@ uses Domain from IntRes2d
(TheCurve,
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);
class ExactIntersectionPoint
uses Vector from math ,

6
src/IntCurve/IntCurve_IntPolyPolyGen.gxx
View File

@ -1,7 +1,6 @@
// 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
@ -26,6 +25,7 @@
#include <Intf_SectionPoint.hxx>
#include <Intf_SectionLine.hxx>
#include <Intf_TangentZone.hxx>
#include <Intf_InterferencePolygon2d.hxx>
#include <gp_Vec2d.hxx>
@ -387,7 +387,7 @@ void IntCurve_IntPolyPolyGen::Perform( const TheCurve& C1
Poly1.SetDeflectionOverEstimation(TolConf);
}
IntCurve_InterferencePoly2d InterPP(Poly1);
Intf_InterferencePolygon2d InterPP(Poly1);
IntCurve_ExactIntersectionPoint EIP(C1,C1,TolConf);
Standard_Real U,V;
@ -843,7 +843,7 @@ void IntCurve_IntPolyPolyGen::Perform( const TheCurve& C1
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;

50
src/IntCurve/IntCurve_Polygon2dGen.cdl
View File

@ -1,7 +1,6 @@
-- File: Polygon2dGen.cdl
-- Created: Mon Oct 19 11:51:16 1992
-- Author: Laurent BUCHARD
-- <lbr@sdsun2>
---Copyright: Matra Datavision 1992
@ -12,9 +11,10 @@ generic class Polygon2dGen from IntCurve (
---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,
@ -22,10 +22,8 @@ uses Pnt2d from gp,
Array1OfInteger from TColStd,
Domain from IntRes2d
raises OutOfRange from Standard
is
Create (Curve : TheCurve;
@ -63,17 +61,10 @@ is
-- 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
@ -83,34 +74,16 @@ is
---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 :
@ -165,8 +138,7 @@ is
is static;
fields TheBnd : Box2d from Bnd;
TheDeflection : Real from Standard;
fields TheDeflection : Real from Standard;
NbPntIn : Integer from Standard;
TheMaxNbPoints: Integer from Standard;
ThePnts : Array1OfPnt2d from TColgp;
@ -179,8 +151,4 @@ fields TheBnd : Box2d from Bnd;
Binf : Real from Standard;
Bsup : Real from Standard;
end Polygon2dGen;

47
src/IntCurve/IntCurve_Polygon2dGen.gxx
View File

@ -1,11 +1,9 @@
// 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>
@ -14,8 +12,6 @@
#include <gp_Dir2d.hxx>
#define MAJORATION_DEFLECTION 1.5
//======================================================================
//== On echantillonne sur le Domain de la Curve NbPts Points
@ -57,7 +53,7 @@ IntCurve_Polygon2dGen::IntCurve_Polygon2dGen(const TheCurve& C,
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);
@ -100,7 +96,7 @@ IntCurve_Polygon2dGen::IntCurve_Polygon2dGen(const TheCurve& C,
}
while(i<NbPts);
TheBnd.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
myBox.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
ClosedPolygon = Standard_False;
}
//======================================================================
@ -130,7 +126,7 @@ IntCurve_Polygon2dGen::IntCurve_Polygon2dGen(const TheCurve& C,
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);
@ -171,7 +167,7 @@ IntCurve_Polygon2dGen::IntCurve_Polygon2dGen(const TheCurve& C,
}
while(i<NbPts);
TheBnd.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
myBox.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
ClosedPolygon = Standard_False;
//-------------------------------------------------------
//-- On supprime les points alignes
@ -209,9 +205,9 @@ IntCurve_Polygon2dGen::IntCurve_Polygon2dGen(const TheCurve& C,
//======================================================================
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;
@ -264,12 +260,12 @@ void IntCurve_Polygon2dGen::ComputeWithBox(const TheCurve& C,
}
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;
@ -285,7 +281,7 @@ void IntCurve_Polygon2dGen::ComputeWithBox(const TheCurve& C,
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) {
@ -346,7 +342,7 @@ void IntCurve_Polygon2dGen::ComputeWithBox(const TheCurve& C,
}
TheDeflection*=MAJORATION_DEFLECTION;
TheBnd.Enlarge(TheDeflection);
myBox.Enlarge(TheDeflection);
}
ClosedPolygon = Standard_False;
Dump();
@ -403,8 +399,8 @@ extern void DrawSegment(const gp_Pnt2d& _P1,const gp_Pnt2d& _P2);
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));
@ -422,11 +418,11 @@ void IntCurve_Polygon2dGen::Dump(void) const {
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;
@ -441,5 +437,16 @@ void IntCurve_Polygon2dGen::Dump(void) const {
}
#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));
}
//======================================================================

25
src/IntCurve/IntCurve_Polygon2dGen.lxx
View File

@ -1,14 +1,9 @@
// 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);
@ -16,35 +11,17 @@ inline Standard_Real IntCurve_Polygon2dGen::DeflectionOverEstimation() const {
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)));
}

58
src/IntCurve/IntCurve_ToolPolygon.cdl
View File

@ -1,58 +0,0 @@
-- 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;

5
src/IntCurve/IntCurve_ToolPolygon.gxx
View File

@ -1,5 +0,0 @@
// File: IntCurve_ToolPolygon.gxx
// Created: Tue Jun 4 16:14:49 1996
// Author: Laurent BUCHARD
// <lbr@sherlox.paris1.matra-dtv.fr>

49
src/IntCurve/IntCurve_ToolPolygon.lxx
View File

@ -1,49 +0,0 @@
// 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);
}
//=================================================================

5
src/IntPatch/IntPatch.cdl
View File

@ -52,8 +52,6 @@ is
class PolyArc; -- inherits Polygo from IntPatch
class PolygoTool;
class RstInt;
@ -143,8 +141,7 @@ is
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,

11
src/IntPatch/IntPatch_PolyArc.cdl
View File

@ -31,14 +31,7 @@ is
--- 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;
@ -53,8 +46,6 @@ fields
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;

43
src/IntPatch/IntPatch_PolyArc.cxx
View File

@ -72,10 +72,10 @@ IntPatch_PolyArc::IntPatch_PolyArc(const Handle(Adaptor2d_HCurve2d)& Line ,
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;
@ -111,12 +111,12 @@ IntPatch_PolyArc::IntPatch_PolyArc(const Handle(Adaptor2d_HCurve2d)& Line ,
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;
}
@ -145,25 +145,14 @@ IntPatch_PolyArc::IntPatch_PolyArc(const Handle(Adaptor2d_HCurve2d)& Line ,
}
}
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();}
@ -183,16 +172,16 @@ Standard_Real IntPatch_PolyArc::Parameter(const Standard_Integer Index ) const
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);
}

10
src/IntPatch/IntPatch_PolyLine.cdl
View File

@ -32,14 +32,6 @@ is
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)
@ -48,12 +40,10 @@ is
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;

49
src/IntPatch/IntPatch_PolyLine.cxx
View File

@ -18,7 +18,7 @@
//=======================================================================
IntPatch_PolyLine::IntPatch_PolyLine ()
: defle(INITDEFLE)
: IntPatch_Polygo(INITDEFLE)
{}
//=======================================================================
@ -27,7 +27,7 @@ IntPatch_PolyLine::IntPatch_PolyLine ()
//=======================================================================
IntPatch_PolyLine::IntPatch_PolyLine (const Standard_Real InitDefle)
: defle(InitDefle)
: IntPatch_Polygo(InitDefle)
{}
//=======================================================================
@ -64,9 +64,9 @@ void IntPatch_PolyLine::SetRLine(const Standard_Boolean OnFirst, const Handle(In
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) {
@ -82,7 +82,7 @@ void IntPatch_PolyLine::Prepare()
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();
@ -119,13 +119,13 @@ void IntPatch_PolyLine::Prepare()
// 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);
}
//=======================================================================
@ -135,38 +135,7 @@ void IntPatch_PolyLine::Prepare()
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;
}
//=======================================================================

46
src/IntPatch/IntPatch_Polygo.cdl
View File

@ -1,7 +1,6 @@
-- File: IntPatch_Polygo.cdl
-- Created: Thu May 6 17:49:16 1993
-- Author: Jacques GOUSSARD
-- <jag@form4>
---Copyright: Matra Datavision 1993
@ -9,30 +8,45 @@ 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() ; }"
Initialize (theError : Real from Standard = 0.0)
returns Polygo from IntPatch;
Bounding (me)
---C++: return const &
returns Box2d from Bnd
is deferred;
Error (me) returns Real from Standard;
---C++: inline
Error(me) returns Real from Standard
is deferred;
NbPoints (me) returns Integer is deferred;
Closed(me) returns Boolean from Standard
is deferred;
Point (me; Index : Integer) returns Pnt2d from gp is deferred;
NbPoints(me) returns Integer
is deferred;
DeflectionOverEstimation (me)
returns Real from Standard is redefined virtual;
---C++: inline
---Purpose: Returns the tolerance of the polygon.
Point(me; Index : Integer)
returns Pnt2d from gp
is deferred;
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;

38
src/IntPatch/IntPatch_Polygo.cxx
View File

@ -1,4 +1,40 @@
// 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;
}

47
src/IntPatch/IntPatch_Polygo.lxx Normal file
View File

@ -0,0 +1,47 @@
// 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);
}

65
src/IntPatch/IntPatch_PolygoTool.cdl
View File

@ -1,65 +0,0 @@
-- 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;

24
src/IntPatch/IntPatch_PolygoTool.cxx
View File

@ -1,24 +0,0 @@
#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;
}

34
src/IntPatch/IntPatch_PolygoTool.lxx
View File

@ -1,34 +0,0 @@
#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);}

1
src/IntPatch/IntPatch_RstInt.cdl
View File

@ -9,7 +9,6 @@ class RstInt from IntPatch
-- cheminement et les arcs de restriction
uses Polygo from IntPatch,
PolygoTool from IntPatch,
Line from IntPatch,
HSurface from Adaptor3d,
TopolTool from Adaptor3d

7
src/IntPatch/IntPatch_RstInt.cxx
View File

@ -26,7 +26,6 @@
#include <Precision.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <IntPatch_PolygoTool.hxx>
#include <IntPatch_WLine.hxx>
#include <IntPatch_RLine.hxx>
#include <IntPatch_HInterTool.hxx>
@ -572,7 +571,7 @@ void IntPatch_RstInt::PutVertexOnLine (Handle(IntPatch_Line)& L,
}
}
Bnd_Box2d BPLin = IntPatch_PolygoTool::Bounding(PLin);
Bnd_Box2d BPLin = PLin.Bounding();
if(SurfaceIsPeriodic) {
Standard_Real xmin,ymin,xmax,ymax,g;
@ -642,8 +641,8 @@ void IntPatch_RstInt::PutVertexOnLine (Handle(IntPatch_Line)& L,
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);

9
src/Intf/Intf.cdl
View File

@ -1,7 +1,6 @@
-- File: Intf.cdl
-- Created: Thu May 23 11:21:00 1991
-- Author: Didier PIFFAULT
-- <dpf@topsn3>
---Copyright: Matra Datavision 1991, 1992
@ -27,9 +26,9 @@ is
-- 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
@ -83,7 +82,7 @@ is
generic class InterferencePolygon2d;
class InterferencePolygon2d;
---Purpose: Computes the interference between two polygons in 2d.
-- Result : points of intersections and zones of tangence.

13
src/Intf/Intf_Interference.cdl
View File

@ -1,7 +1,6 @@
-- File: Interference.cdl
-- Created: Mon Jun 24 10:15:49 1991
-- Author: Didier PIFFAULT
-- <dpf@phobox>
---Copyright: Matra Datavision 1991, 1992
@ -31,6 +30,7 @@ is Initialize(Self : Boolean from Standard);
returns Integer is static;
---Purpose: Gives the number of points of intersection in the
-- interference.
---C++: inline
PntValue (me;
Index : in Integer)
@ -41,12 +41,13 @@ is Initialize(Self : Boolean from Standard);
-- 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)
@ -57,12 +58,12 @@ is Initialize(Self : Boolean from Standard);
-- 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)
@ -73,13 +74,13 @@ is Initialize(Self : Boolean from Standard);
-- interference.
--
---C++: return const &
---C++: inline
GetTolerance (me)
returns Real
is static;
---Purpose: Gives the tolerance used for the calculation.
---C++: inline
-- Implementation functions :

64
src/Intf/Intf_Interference.cxx
View File

@ -1,7 +1,6 @@
// 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>
@ -31,69 +30,6 @@ void Intf_Interference::SelfInterference (const Standard_Boolean Self)
}
//---------------------------------------------------------
// 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

67
src/Intf/Intf_Interference.lxx Normal file
View File

@ -0,0 +1,67 @@
// 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;
}

43
src/Intf/Intf_InterferencePolygon2d.cdl
View File

@ -1,29 +1,23 @@
-- File: InterferencePolygon2d.cdl
-- File: Intf_InterferencePolygon2d.cdl
-- Created: Mon Sep 28 17:09:45 1992
-- Author: Didier PIFFAULT
-- <dpf@phylox>
---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
@ -35,23 +29,23 @@ is
---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.
@ -66,30 +60,25 @@ is
-- 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;

675
src/Intf/Intf_InterferencePolygon2d.cxx Normal file
View File

@ -0,0 +1,675 @@
// 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
}
}

698
src/Intf/Intf_InterferencePolygon2d.gxx
View File

@ -1,698 +0,0 @@
// 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

43
src/Intf/Intf_Polygon2d.cdl Normal file
View File

@ -0,0 +1,43 @@
-- 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;

16
src/Intf/Intf_Polygon2d.cxx Normal file
View File

@ -0,0 +1,16 @@
// 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;
}

15
src/Intf/Intf_Polygon2d.lxx Normal file
View File

@ -0,0 +1,15 @@
// 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;
}

50
src/Intf/Intf_ToolPolygon.cdl
View File

@ -1,50 +0,0 @@
-- 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;