mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-06-20 11:54:07 +03:00
0423218095
"endl" manipulator for Message_Messenger is renamed to "Message_EndLine". The following entities from std namespace are now used with std:: explicitly specified (from Standard_Stream.hxx): std::istream,std::ostream,std::ofstream,std::ifstream,std::fstream, std::filebuf,std::streambuf,std::streampos,std::ios,std::cout,std::cerr, std::cin,std::endl,std::ends,std::flush,std::setw,std::setprecision, std::hex,std::dec.
342 lines
10 KiB
Plaintext
342 lines
10 KiB
Plaintext
// Created on: 1992-10-12
|
|
// Created by: Laurent BUCHARD
|
|
// Copyright (c) 1992-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.
|
|
|
|
#define TEST 0
|
|
|
|
#include <Standard_ConstructionError.hxx>
|
|
#include <Bnd_Box2d.hxx>
|
|
#include <TColgp_Array1OfPnt2d.hxx>
|
|
#include <gp_Lin2d.hxx>
|
|
#include <gp_Vec2d.hxx>
|
|
#include <gp_Dir2d.hxx>
|
|
|
|
|
|
#define MAJORATION_DEFLECTION 1.5
|
|
//======================================================================
|
|
//== We take samples on the Domain of the Curve NbPts Points
|
|
//== with constant parameters.
|
|
//==
|
|
//== We estimate the maximum deflection taking the max distance between the
|
|
//== right Curve.Value(X(i))-->Curve.Value(X(i+1))
|
|
//== and the point Curve.Value(X(i+1/2))
|
|
//======================================================================
|
|
// Modified by Sergey KHROMOV - Mon Mar 24 12:02:43 2003 Begin
|
|
IntCurve_Polygon2dGen::IntCurve_Polygon2dGen(const TheCurve& C,
|
|
const Standard_Integer tNbPts,
|
|
const IntRes2d_Domain& D,
|
|
const Standard_Real Tol):
|
|
// Modified by Sergey KHROMOV - Mon Mar 24 12:02:45 2003 End
|
|
ThePnts(1,(tNbPts<3)? 6 : (tNbPts+tNbPts)),
|
|
TheParams(1,(tNbPts<3)? 6 : (tNbPts+tNbPts)),
|
|
TheIndex(1,(tNbPts<3)? 6 : (tNbPts+tNbPts))
|
|
{
|
|
|
|
Standard_Integer NbPts = (tNbPts<3)? 3 : tNbPts;
|
|
TheMaxNbPoints = NbPts+NbPts;
|
|
NbPntIn = NbPts;
|
|
//-----------------------------------------------------
|
|
//--- Initialization of the breaking with d_Parametre constant
|
|
//---
|
|
Binf = D.FirstParameter();
|
|
Bsup = D.LastParameter();
|
|
//-----------------------------------------------------
|
|
//-- IntRes2d Raise if HasFirst returns False
|
|
//-- and accesses First Parameter
|
|
//--
|
|
Standard_Real u=Binf;
|
|
Standard_Real u1=Bsup;
|
|
Standard_Real du=(u1-u)/(Standard_Real)(NbPts-1);
|
|
// Standard_Integer ip1,i=1;
|
|
Standard_Integer i=1;
|
|
|
|
do {
|
|
gp_Pnt2d P=TheCurveTool::Value(C,u);
|
|
myBox.Add(P);
|
|
TheIndex.SetValue(i,i);
|
|
ThePnts.SetValue(i,P);
|
|
TheParams.SetValue(i,u);
|
|
u+=du;
|
|
i++;
|
|
}
|
|
while(i<=NbPts);
|
|
|
|
|
|
//-----------------------------------------------------
|
|
//--- Calculate a maximal deflection
|
|
//---
|
|
// Modified by Sergey KHROMOV - Mon Mar 24 12:03:05 2003 Begin
|
|
// TheDeflection = 0.000000001;
|
|
TheDeflection = Min(0.000000001, Tol/100.);
|
|
// Modified by Sergey KHROMOV - Mon Mar 24 12:03:05 2003 End
|
|
i=1;
|
|
u=D.FirstParameter();
|
|
u+=du * 0.5;
|
|
|
|
do {
|
|
gp_Pnt2d Pm = TheCurveTool::Value(C,u);
|
|
const gp_Pnt2d& P1 = ThePnts.Value(i);
|
|
const gp_Pnt2d& P2 = ThePnts.Value(i+1);
|
|
|
|
u+=du;
|
|
i++;
|
|
|
|
|
|
Standard_Real dx,dy,t=0;
|
|
dx=P1.X()-P2.X(); if(dx<0) dx=-dx;
|
|
dy=P1.Y()-P2.Y(); if(dy<0) dy=-dy;
|
|
if(dx+dy>1e-12) {
|
|
gp_Lin2d L(P1,gp_Dir2d(gp_Vec2d(P1,P2)));
|
|
t = L.Distance(Pm);
|
|
if(t>TheDeflection) {
|
|
TheDeflection = t;
|
|
}
|
|
}
|
|
}
|
|
while(i<NbPts);
|
|
|
|
myBox.Enlarge(TheDeflection*MAJORATION_DEFLECTION);
|
|
ClosedPolygon = Standard_False;
|
|
}
|
|
//======================================================================
|
|
void IntCurve_Polygon2dGen::ComputeWithBox(const TheCurve& C,
|
|
const Bnd_Box2d& BoxOtherPolygon) {
|
|
if(myBox.IsOut(BoxOtherPolygon)) {
|
|
NbPntIn=2;
|
|
myBox.SetVoid();
|
|
}
|
|
else {
|
|
Standard_Real bx0,bx1,by0,by1;
|
|
BoxOtherPolygon.Get(bx0,by0,bx1,by1);
|
|
|
|
bx0-=TheDeflection;
|
|
by0-=TheDeflection;
|
|
bx1+=TheDeflection;
|
|
by1+=TheDeflection;
|
|
Standard_Integer MaxIndexUsed = 1;
|
|
Standard_Integer i,nbp;
|
|
Standard_Integer Rprec,Ri;
|
|
Standard_Real x,y;
|
|
|
|
nbp = 0;
|
|
x = ThePnts.Value(TheIndex.Value(1)).X();
|
|
y = ThePnts.Value(TheIndex.Value(1)).Y();
|
|
|
|
Rprec = CalculRegion(x,y,bx0,bx1,by0,by1);
|
|
for(i = 2; i<=NbPntIn; i++) {
|
|
const gp_Pnt2d& P2d = ThePnts.Value(TheIndex.Value(i));
|
|
Ri = CalculRegion(P2d.X(),P2d.Y(),bx0,bx1,by0,by1);
|
|
if((Ri & Rprec)==0) {
|
|
if(nbp) {
|
|
if(TheIndex.Value(nbp) != TheIndex.Value(i-1)) {
|
|
nbp++;
|
|
TheIndex.SetValue(nbp,TheIndex.Value(i-1));
|
|
}
|
|
}
|
|
else {
|
|
nbp++;
|
|
TheIndex.SetValue(nbp,TheIndex.Value(i-1));
|
|
}
|
|
nbp++;
|
|
TheIndex.SetValue(nbp,TheIndex.Value(i));
|
|
if(TheIndex.Value(i) > MaxIndexUsed) MaxIndexUsed = TheIndex.Value(i);
|
|
|
|
Rprec = Ri;
|
|
}//if((Ri & Rprec)==0) condition
|
|
|
|
Rprec = Ri;
|
|
}
|
|
if(nbp==1) {
|
|
NbPntIn=2;
|
|
myBox.SetVoid();
|
|
}
|
|
else {
|
|
myBox.SetVoid();
|
|
if(nbp) {
|
|
myBox.Add(ThePnts.Value(TheIndex.Value(1)));
|
|
}
|
|
Standard_Real RatioDeflection;
|
|
Standard_Integer nbpassagedeflection = 0;
|
|
// Standard_Integer PointHasBeenAdded = 0;
|
|
do {
|
|
nbpassagedeflection++;
|
|
// Modified by Sergey KHROMOV - Mon Mar 24 12:05:28 2003 Begin
|
|
// Standard_Real NewDeflection = 0.0000001;
|
|
Standard_Real NewDeflection = TheDeflection;
|
|
// Modified by Sergey KHROMOV - Mon Mar 24 12:05:29 2003 End
|
|
for(i=2; i<=nbp; i++) {
|
|
Standard_Integer Ii = TheIndex.Value(i);
|
|
Standard_Integer Iim1= TheIndex.Value(i-1);
|
|
const gp_Pnt2d& Pi = ThePnts.Value(Ii);
|
|
const gp_Pnt2d& Pim1 = ThePnts.Value(Iim1);
|
|
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) {
|
|
Standard_Real u = 0.5*( TheParams.Value(Ii)
|
|
+TheParams.Value(Iim1));
|
|
gp_Pnt2d Pm = TheCurveTool::Value(C,u);
|
|
Standard_Real dx,dy,t=0;
|
|
dx=Pim1.X()-Pi.X(); if(dx<0) dx=-dx;
|
|
dy=Pim1.Y()-Pi.Y(); if(dy<0) dy=-dy;
|
|
if(dx+dy>1e-12) {
|
|
gp_Lin2d L(Pim1,gp_Dir2d(gp_Vec2d(Pim1,Pi)));
|
|
t = L.Distance(Pm);
|
|
if((MaxIndexUsed<(TheMaxNbPoints-1)) && (t>(TheDeflection * 0.5))) {
|
|
const gp_Pnt2d& P1=Pim1;
|
|
nbp++;
|
|
for(Standard_Integer j=nbp; j>=i+1; j--) {
|
|
TheIndex.SetValue(j,TheIndex.Value(j-1));
|
|
}
|
|
MaxIndexUsed++;
|
|
TheIndex.SetValue(i,MaxIndexUsed);
|
|
ThePnts.SetValue(MaxIndexUsed,Pm);
|
|
TheParams.SetValue(MaxIndexUsed,u);
|
|
|
|
Standard_Real u1m = 0.5*(u+TheParams.Value(TheIndex.Value(i-1)));
|
|
gp_Pnt2d P1m = TheCurveTool::Value(C,u1m);
|
|
gp_Lin2d L1m(P1,gp_Dir2d(gp_Vec2d(P1,Pm)));
|
|
t = L1m.Distance(P1m);
|
|
i--;
|
|
}
|
|
}
|
|
else {
|
|
if(t>NewDeflection) {
|
|
NewDeflection = t;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(NewDeflection)
|
|
RatioDeflection = TheDeflection / NewDeflection;
|
|
else RatioDeflection = 10.0;
|
|
TheDeflection = NewDeflection;
|
|
NbPntIn = nbp;
|
|
}
|
|
while((RatioDeflection<3.0)
|
|
&& (nbpassagedeflection < 3)
|
|
&& (MaxIndexUsed<(TheMaxNbPoints-2)));
|
|
}
|
|
|
|
TheDeflection*=MAJORATION_DEFLECTION;
|
|
myBox.Enlarge(TheDeflection);
|
|
}
|
|
ClosedPolygon = Standard_False;
|
|
Dump();
|
|
}
|
|
|
|
|
|
Standard_Boolean IntCurve_Polygon2dGen::AutoIntersectionIsPossible() const {
|
|
|
|
gp_Vec2d VRef(ThePnts.Value(TheIndex.Value(1)),
|
|
ThePnts.Value(TheIndex.Value(2)));
|
|
for(Standard_Integer i=3; i<=NbPntIn; i++) {
|
|
gp_Vec2d V(ThePnts.Value(TheIndex.Value(i-1)),
|
|
ThePnts.Value(TheIndex.Value(i)));
|
|
if(V.Dot(VRef)<0.0) {
|
|
return(Standard_True);
|
|
}
|
|
}
|
|
return(Standard_False);
|
|
}
|
|
|
|
//======================================================================
|
|
Standard_Real IntCurve_Polygon2dGen::ApproxParamOnCurve( const Standard_Integer Aindex
|
|
,const Standard_Real TheParamOnLine)
|
|
const
|
|
{
|
|
Standard_Integer Indexp1,Index = Aindex;
|
|
Standard_Real ParamOnLine = TheParamOnLine;
|
|
if (Index > NbPntIn) {
|
|
std::cout << "OutOfRange Polygon2d::ApproxParamOnCurve " <<std::endl;
|
|
}
|
|
if((Index == NbPntIn) && (ParamOnLine == 0.0)) {
|
|
Index--; ParamOnLine=1.0;
|
|
}
|
|
if(Index==0) {
|
|
Index=1;
|
|
ParamOnLine = 0.0;
|
|
}
|
|
Indexp1 = TheIndex.Value(Index+1);
|
|
Index = TheIndex.Value(Index);
|
|
|
|
Standard_Real du = TheParams.Value(Indexp1)-TheParams.Value(Index);
|
|
Standard_Real u = TheParams.Value(Index) + ParamOnLine * du;
|
|
return(u);
|
|
}
|
|
|
|
|
|
//======================================================================
|
|
#if TEST
|
|
|
|
extern Standard_Boolean DebugPolygon2d;
|
|
extern void DrawSegmentBlanc(const gp_Pnt2d& _P1,const gp_Pnt2d& _P2);
|
|
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(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));
|
|
DrawSegment(gp_Pnt2d(bx0,by1),gp_Pnt2d(bx0,by0));
|
|
Standard_Integer i;
|
|
if(NbPntIn<=1) return;
|
|
for(i=2;i<=NbPntIn; i++) {
|
|
DrawSegmentBlanc(ThePnts.Value(TheIndex.Value(i-1)),ThePnts.Value(TheIndex.Value(i)));
|
|
}
|
|
}
|
|
#else
|
|
void IntCurve_Polygon2dGen::Dump(void) const {
|
|
static int debug = 0;
|
|
if(debug) {
|
|
Standard_Real bx0,bx1,by0,by1;
|
|
|
|
std::cout<<"\n ----- Dump of IntCurve_Polygon2dGen -----"<<std::endl;
|
|
if(myBox.IsVoid()) {
|
|
std::cout<<" Polygone Vide "<<std::endl;
|
|
return;
|
|
}
|
|
myBox.Get(bx0,by0,bx1,by1);
|
|
std::cout<<" bx0:"<<bx0 <<std::endl;
|
|
std::cout<<" by0:"<<by0<<std::endl;
|
|
std::cout<<" bx1:"<<bx1<<std::endl;
|
|
std::cout<<" by1:"<<by1<<std::endl;
|
|
|
|
Standard_Integer i;
|
|
for(i=1;i<=NbPntIn; i++) {
|
|
const gp_Pnt2d& P = ThePnts(TheIndex(i));
|
|
std::cout<<" ("<<i<<") u:"<<TheParams.Value(TheIndex(i))<<" X:"<<P.X()<<" Y:"<<P.Y()<<std::endl;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
//======================================================================
|
|
void IntCurve_Polygon2dGen::Segment(const Standard_Integer theIndex,
|
|
gp_Pnt2d &theBegin, gp_Pnt2d &theEnd) const
|
|
{
|
|
Standard_Integer ind = theIndex;
|
|
theBegin = ThePnts(TheIndex(theIndex));
|
|
if (theIndex >= NbPntIn) {
|
|
if (!ClosedPolygon)
|
|
throw Standard_OutOfRange("IntCurve_Polygon2dGen::Segment!");
|
|
ind = 0;
|
|
}
|
|
theEnd = ThePnts(TheIndex(ind+1));
|
|
}
|
|
//======================================================================
|