mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-05 18:16:23 +03:00
a3f6f591fc
Remove extra semicolons and correct function prototypes for GCC -pedantic ISO compliance option
694 lines
20 KiB
C++
694 lines
20 KiB
C++
// Created on: 1991-06-24
|
|
// Created by: Didier PIFFAULT
|
|
// Copyright (c) -1999 Matra Datavision
|
|
// Copyright (c) 1991-1999 Matra Datavision
|
|
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
|
//
|
|
// This file is part of Open CASCADE Technology software library.
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify it under
|
|
// the terms of the GNU Lesser General Public License version 2.1 as published
|
|
// by the Free Software Foundation, with special exception defined in the file
|
|
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
|
// distribution for complete text of the license and disclaimer of any warranty.
|
|
//
|
|
// Alternatively, this file may be used under the terms of Open CASCADE
|
|
// commercial license or contractual agreement.
|
|
|
|
|
|
#include <Bnd_Box2d.hxx>
|
|
#include <gp_Pnt2d.hxx>
|
|
#include <Intf_InterferencePolygon2d.hxx>
|
|
#include <Intf_Polygon2d.hxx>
|
|
#include <Intf_SectionPoint.hxx>
|
|
#include <Intf_SeqOfSectionPoint.hxx>
|
|
#include <Intf_SeqOfTangentZone.hxx>
|
|
#include <Intf_TangentZone.hxx>
|
|
#include <Precision.hxx>
|
|
#include <Standard_OutOfRange.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, n1 = nbso, n2 = Obje2.NbSegments();
|
|
Standard_Real d1 = Obje1.DeflectionOverEstimation(),
|
|
d2 = Obje2.DeflectionOverEstimation();
|
|
|
|
gp_Pnt2d p1b, p1e, p2b, p2e;
|
|
for (iObje1=1; iObje1<=n1; iObje1++)
|
|
{
|
|
bSO.SetVoid();
|
|
Obje1.Segment(iObje1,p1b,p1e);
|
|
bSO.Add(p1b);
|
|
bSO.Add(p1e);
|
|
bSO.Enlarge(d1);
|
|
if (!Obje2.Bounding().IsOut(bSO)) {
|
|
for (iObje2=1; iObje2<=n2; iObje2++) {
|
|
bST.SetVoid();
|
|
Obje2.Segment(iObje2,p2b,p2e);
|
|
bST.Add(p2b);
|
|
bST.Add(p2e);
|
|
bST.Enlarge(d2);
|
|
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, n = Obje.NbSegments();
|
|
Standard_Real d = Obje.DeflectionOverEstimation();
|
|
|
|
gp_Pnt2d p1b, p1e, p2b, p2e;
|
|
for (iObje1=1; iObje1<=n; iObje1++) {
|
|
bSO.SetVoid();
|
|
Obje.Segment(iObje1,p1b,p1e);
|
|
bSO.Add(p1b);
|
|
bSO.Add(p1e);
|
|
bSO.Enlarge(d);
|
|
if (!Obje.Bounding().IsOut(bSO)) {
|
|
for (iObje2=iObje1+1;iObje2<=n;iObje2++){
|
|
bST.SetVoid();
|
|
Obje.Segment(iObje2,p2b,p2e);
|
|
bST.Add(p2b);
|
|
bST.Add(p2e);
|
|
bST.Enlarge(d);
|
|
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
|
|
}
|
|
}
|