OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-14 13:30:48 +03:00
Code Activity

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
Download Patch File Download Diff File Expand all files Collapse all files

17
src/Intf/Intf.cdl
View File

@@ -1,8 +1,7 @@
-- 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
@@ -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.

15
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 :
@@ -115,6 +116,6 @@ fields mySPoins : SeqOfSectionPoint from Intf is protected;
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;

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;
}

49
src/Intf/Intf_InterferencePolygon2d.cdl
View File

@@ -1,29 +1,23 @@
-- 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
@@ -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;