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

Modified files of CR25334, CR25406 for 6.6.0

Browse Source
This commit is contained in:
bugmaster
2014-10-23 17:38:58 +04:00
parent 8d7bdc9457
commit c4a04c30f4
9 changed files with 1213 additions and 796 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/BRepFill/BRepFill_OffsetWire.cxx
View File

@@ -648,9 +648,11 @@ void BRepFill_OffsetWire::Perform (const Standard_Real Offset,
{
myShape.Nullify();
myIsDone = Standard_False;
#ifdef BREPFILL_DEB
cout<<"An exception was caught in BRepFill_OffsetWire::Perform : ";
Standard_Failure::Caught()->Print(cout);
cout<<endl;
#endif
return;
}
@@ -799,8 +801,9 @@ void BRepFill_OffsetWire::PerformWithBiLo
for (Standard_Integer ie = 1; ie <= Locus.NumberOfElts(ic); ie++) {
const TopoDS_Shape& SE = Link.GeneratingShape(Locus.BasicElt(ic,ie));
if (SE.ShapeType() == TopAbs_VERTEX) {
MakeCircle (TopoDS::Edge(PE),TopoDS::Vertex(SE),
myWorkSpine,myOffset,myMap,RefPlane);
if (!SE.IsSame(Ends[0]) && !SE.IsSame(Ends[1]))
MakeCircle (TopoDS::Edge(PE),TopoDS::Vertex(SE),
myWorkSpine,myOffset,myMap,RefPlane);
}
else {
MakeOffset (TopoDS::Edge(SE),myWorkSpine,myOffset,myMap,RefPlane,

990
src/BRepOffset/BRepOffset_MakeOffset.cxx
View File

File diff suppressed because it is too large Load Diff

278
src/BRepOffset/BRepOffset_Offset.cxx
View File

@@ -530,8 +530,12 @@ void BRepOffset_Offset::Init(const TopoDS_Face& Face,
BRepOffset::Surface( S, myOffset, myStatus);
//processing offsets of faces with possible degenerated edges
Standard_Boolean UminDegen = Standard_False;
Standard_Boolean UmaxDegen = Standard_False;
Standard_Boolean VminDegen = Standard_False;
Standard_Boolean VmaxDegen = Standard_False;
Standard_Boolean UisoDegen = Standard_False;
Standard_Boolean VisoDegen = Standard_False;
gp_Pnt MinApex, MaxApex;
Standard_Boolean HasSingularity = Standard_False;
Standard_Real uf1, uf2, vf1, vf2, fpar, lpar;
@@ -551,20 +555,41 @@ void BRepOffset_Offset::Init(const TopoDS_Face& Face,
if (!DegEdges.IsEmpty())
{
const Standard_Real TolApex = 1.e-5;
//define the iso of singularity (u or v)
const TopoDS_Edge& theDegEdge = TopoDS::Edge(DegEdges(1));
Handle(Geom2d_Curve) aCurve = BRep_Tool::CurveOnSurface(theDegEdge, Face, fpar, lpar);
gp_Pnt2d fp2d = aCurve->Value(fpar);
gp_Pnt2d lp2d = aCurve->Value(lpar);
if (Abs(fp2d.X() - lp2d.X()) <= Precision::PConfusion())
UisoDegen = Standard_True;
else
VisoDegen = Standard_True;
if (DegEdges.Length() == 2)
{
VminDegen = Standard_True;
VmaxDegen = Standard_True;
if (UisoDegen)
{ UminDegen = Standard_True; UmaxDegen = Standard_True; }
else
{ VminDegen = Standard_True; VmaxDegen = Standard_True; }
}
else //DegEdges.Length() == 1
{
const TopoDS_Edge& theDegEdge = TopoDS::Edge(DegEdges(1));
Handle(Geom2d_Curve) aCurve = BRep_Tool::CurveOnSurface(theDegEdge, Face, fpar, lpar);
gp_Pnt2d aPnt2d = aCurve->Value(fpar);
if (Abs(aPnt2d.Y() - vf1) <= Precision::Confusion())
VminDegen = Standard_True;
else
VmaxDegen = Standard_True;
if (UisoDegen)
{
if (Abs(fp2d.X() - uf1) <= Precision::Confusion())
UminDegen = Standard_True;
else
UmaxDegen = Standard_True;
}
else
{
if (Abs(fp2d.Y() - vf1) <= Precision::Confusion())
VminDegen = Standard_True;
else
VmaxDegen = Standard_True;
}
}
if (TheSurf->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface))
{
@@ -587,94 +612,171 @@ void BRepOffset_Offset::Init(const TopoDS_Face& Face,
}
else //TheSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface)
{
if (UminDegen)
{
Handle(Geom_Curve) uiso = TheSurf->UIso( uf1 );
if (BRepOffset_Tool::Gabarit( uiso ) > TolApex)
{
Handle(Geom_Surface) BasisSurf = (*((Handle(Geom_OffsetSurface)*)&TheSurf))->BasisSurface();
gp_Pnt Papex, Pfirst, Pquart, Pmid;
Papex = BasisSurf->Value( uf1, vf1 );
Pfirst = TheSurf->Value( uf1, vf1 );
Pquart = TheSurf->Value( uf1, 0.75*vf1+0.25*vf2 );
Pmid = TheSurf->Value( uf1, 0.5*(vf1+vf2) );
gp_Vec DirApex = gp_Vec(Pfirst,Pquart) ^ gp_Vec(Pfirst,Pmid);
Handle(Geom_Line) LineApex = new Geom_Line( Papex, DirApex );
gp_Vec DirGeneratrix = BasisSurf->DN( uf1, vf1, 1, 0 );
Handle(Geom_Line) LineGeneratrix = new Geom_Line( Pfirst, DirGeneratrix );
GeomAPI_ExtremaCurveCurve theExtrema( LineGeneratrix, LineApex );
gp_Pnt Pint1, Pint2;
theExtrema.NearestPoints(Pint1, Pint2);
Standard_Real length = Pfirst.Distance(Pint1);
if (OffsetOutside)
{
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, vf2);
GeomLib::ExtendSurfByLength(*((Handle(Geom_BoundedSurface)*)&TheSurf), length, 1,
Standard_True, Standard_False);
Standard_Real u1, u2, v1, v2;
TheSurf->Bounds( u1, u2, v1, v2 );
MinApex = TheSurf->Value( u1, vf1 );
}
else
{
Handle(Geom_Curve) viso = TheSurf->VIso( vf1 );
GeomAPI_ProjectPointOnCurve Projector( Pint1, viso );
Standard_Real NewFirstU = Projector.LowerDistanceParameter();
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, NewFirstU, uf2, vf1, vf2);
MinApex = TheSurf->Value( NewFirstU, vf1 );
}
HasSingularity = Standard_True;
}
} //end of if (UminDegen)
if (UmaxDegen)
{
Handle(Geom_Curve) uiso = TheSurf->UIso( uf2 );
if (BRepOffset_Tool::Gabarit( uiso ) > TolApex)
{
Handle(Geom_Surface) BasisSurf = (*((Handle(Geom_OffsetSurface)*)&TheSurf))->BasisSurface();
gp_Pnt Papex, Pfirst, Pquart, Pmid;
Papex = BasisSurf->Value( uf2, vf1 );
Pfirst = TheSurf->Value( uf2, vf1 );
Pquart = TheSurf->Value( uf2, 0.75*vf1+0.25*vf2 );
Pmid = TheSurf->Value( uf2, 0.5*(vf1+vf2) );
gp_Vec DirApex = gp_Vec(Pfirst,Pquart) ^ gp_Vec(Pfirst,Pmid);
Handle(Geom_Line) LineApex = new Geom_Line( Papex, DirApex );
gp_Vec DirGeneratrix = BasisSurf->DN( uf2, vf1, 1, 0 );
Handle(Geom_Line) LineGeneratrix = new Geom_Line( Pfirst, DirGeneratrix );
GeomAPI_ExtremaCurveCurve theExtrema( LineGeneratrix, LineApex );
gp_Pnt Pint1, Pint2;
theExtrema.NearestPoints(Pint1, Pint2);
Standard_Real length = Pfirst.Distance(Pint1);
if (OffsetOutside)
{
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, vf2);
GeomLib::ExtendSurfByLength(*((Handle(Geom_BoundedSurface)*)&TheSurf), length, 1,
Standard_True, Standard_True);
Standard_Real u1, u2, v1, v2;
TheSurf->Bounds( u1, u2, v1, v2 );
MaxApex = TheSurf->Value( u2, vf1 );
}
else
{
Handle(Geom_Curve) viso = TheSurf->VIso( vf1 );
GeomAPI_ProjectPointOnCurve Projector( Pint1, viso );
Standard_Real NewLastU = Projector.LowerDistanceParameter();
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, NewLastU, vf1, vf2);
MaxApex = TheSurf->Value( NewLastU, vf1 );
}
HasSingularity = Standard_True;
}
} //end of if (UmaxDegen)
if (VminDegen)
{
Handle(Geom_Curve) viso = TheSurf->VIso( vf1 );
if (BRepOffset_Tool::Gabarit( viso ) > TolApex)
{
Handle(Geom_Surface) BasisSurf = (*((Handle(Geom_OffsetSurface)*)&TheSurf))->BasisSurface();
gp_Pnt Papex, Pfirst, Plast, Pmid;
Papex = BasisSurf->Value( uf1, vf1 );
Pfirst = TheSurf->Value( uf1, vf1 );
Plast = TheSurf->Value( uf2, vf1 );
Pmid = TheSurf->Value( (uf1+uf2)/2., vf1 );
gp_Vec DirApex = gp_Vec(Pfirst,Pmid) ^ gp_Vec(Pfirst,Plast);
Handle(Geom_Line) LineApex = new Geom_Line( Papex, DirApex );
gp_Vec DirGeneratrix = BasisSurf->DN( uf1, vf1, 0, 1 );
Handle(Geom_Line) LineGeneratrix = new Geom_Line( Pfirst, DirGeneratrix );
GeomAPI_ExtremaCurveCurve theExtrema( LineGeneratrix, LineApex );
gp_Pnt Pint1, Pint2;
theExtrema.NearestPoints(Pint1, Pint2);
Standard_Real length = Pfirst.Distance(Pint1);
if (OffsetOutside)
{
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, vf2);
GeomLib::ExtendSurfByLength(*((Handle(Geom_BoundedSurface)*)&TheSurf), length, 1,
Standard_False, Standard_False);
Standard_Real u1, u2, v1, v2;
TheSurf->Bounds( u1, u2, v1, v2 );
MinApex = TheSurf->Value( uf1, v1 );
}
else
{
Handle(Geom_Curve) uiso = TheSurf->UIso( uf1 );
GeomAPI_ProjectPointOnCurve Projector( Pint1, uiso );
Standard_Real NewFirstV = Projector.LowerDistanceParameter();
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, NewFirstV, vf2);
MinApex = TheSurf->Value( uf1, NewFirstV );
//TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1+length, vf2);
//MinApex = TheSurf->Value( uf1, vf1+length );
}
HasSingularity = Standard_True;
}
} //end of if (VminDegen)
{
Handle(Geom_Curve) viso = TheSurf->VIso( vf1 );
if (BRepOffset_Tool::Gabarit( viso ) > TolApex)
{
Handle(Geom_Surface) BasisSurf = (*((Handle(Geom_OffsetSurface)*)&TheSurf))->BasisSurface();
gp_Pnt Papex, Pfirst, Pquart, Pmid;
Papex = BasisSurf->Value( uf1, vf1 );
Pfirst = TheSurf->Value( uf1, vf1 );
Pquart = TheSurf->Value( 0.75*uf1+0.25*uf2, vf1 );
Pmid = TheSurf->Value( 0.5*(uf1+uf2), vf1 );
gp_Vec DirApex = gp_Vec(Pfirst,Pquart) ^ gp_Vec(Pfirst,Pmid);
Handle(Geom_Line) LineApex = new Geom_Line( Papex, DirApex );
gp_Vec DirGeneratrix = BasisSurf->DN( uf1, vf1, 0, 1 );
Handle(Geom_Line) LineGeneratrix = new Geom_Line( Pfirst, DirGeneratrix );
GeomAPI_ExtremaCurveCurve theExtrema( LineGeneratrix, LineApex );
gp_Pnt Pint1, Pint2;
theExtrema.NearestPoints(Pint1, Pint2);
Standard_Real length = Pfirst.Distance(Pint1);
if (OffsetOutside)
{
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, vf2);
GeomLib::ExtendSurfByLength(*((Handle(Geom_BoundedSurface)*)&TheSurf), length, 1,
Standard_False, Standard_False);
Standard_Real u1, u2, v1, v2;
TheSurf->Bounds( u1, u2, v1, v2 );
MinApex = TheSurf->Value( uf1, v1 );
}
else
{
Handle(Geom_Curve) uiso = TheSurf->UIso( uf1 );
GeomAPI_ProjectPointOnCurve Projector( Pint1, uiso );
Standard_Real NewFirstV = Projector.LowerDistanceParameter();
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, NewFirstV, vf2);
MinApex = TheSurf->Value( uf1, NewFirstV );
//TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1+length, vf2);
//MinApex = TheSurf->Value( uf1, vf1+length );
}
HasSingularity = Standard_True;
}
} //end of if (VminDegen)
if (VmaxDegen)
{
Handle(Geom_Curve) viso = TheSurf->VIso( vf2 );
if (BRepOffset_Tool::Gabarit( viso ) > TolApex)
{
Handle(Geom_Surface) BasisSurf = (*((Handle(Geom_OffsetSurface)*)&TheSurf))->BasisSurface();
gp_Pnt Papex, Pfirst, Plast, Pmid;
Papex = BasisSurf->Value( uf1, vf2 );
Pfirst = TheSurf->Value( uf1, vf2 );
Plast = TheSurf->Value( uf2, vf2 );
Pmid = TheSurf->Value( (uf1+uf2)/2., vf2 );
gp_Vec DirApex = gp_Vec(Pfirst,Pmid) ^ gp_Vec(Pfirst,Plast);
Handle(Geom_Line) LineApex = new Geom_Line( Papex, DirApex );
gp_Vec DirGeneratrix = BasisSurf->DN( uf1, vf2, 0, 1 );
Handle(Geom_Line) LineGeneratrix = new Geom_Line( Pfirst, DirGeneratrix );
GeomAPI_ExtremaCurveCurve theExtrema( LineGeneratrix, LineApex );
gp_Pnt Pint1, Pint2;
theExtrema.NearestPoints(Pint1, Pint2);
Standard_Real length = Pfirst.Distance(Pint1);
if (OffsetOutside)
{
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, vf2);
GeomLib::ExtendSurfByLength(*((Handle(Geom_BoundedSurface)*)&TheSurf), length, 1,
Standard_False, Standard_True);
Standard_Real u1, u2, v1, v2;
TheSurf->Bounds( u1, u2, v1, v2 );
MaxApex = TheSurf->Value( uf1, v2 );
}
else
{
Handle(Geom_Curve) uiso = TheSurf->UIso( uf1 );
GeomAPI_ProjectPointOnCurve Projector( Pint1, uiso );
Standard_Real NewLastV = Projector.LowerDistanceParameter();
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, NewLastV);
MaxApex = TheSurf->Value( uf1, NewLastV );
//TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, vf2-length);
//MaxApex = TheSurf->Value( uf1, vf2-length );
}
HasSingularity = Standard_True;
}
} //end of if (VmaxDegen)
{
Handle(Geom_Curve) viso = TheSurf->VIso( vf2 );
if (BRepOffset_Tool::Gabarit( viso ) > TolApex)
{
Handle(Geom_Surface) BasisSurf = (*((Handle(Geom_OffsetSurface)*)&TheSurf))->BasisSurface();
gp_Pnt Papex, Pfirst, Pquart, Pmid;
Papex = BasisSurf->Value( uf1, vf2 );
Pfirst = TheSurf->Value( uf1, vf2 );
Pquart = TheSurf->Value( 0.75*uf1+0.25*uf2, vf2 );
Pmid = TheSurf->Value( 0.5*(uf1+uf2), vf2 );
gp_Vec DirApex = gp_Vec(Pfirst,Pquart) ^ gp_Vec(Pfirst,Pmid);
Handle(Geom_Line) LineApex = new Geom_Line( Papex, DirApex );
gp_Vec DirGeneratrix = BasisSurf->DN( uf1, vf2, 0, 1 );
Handle(Geom_Line) LineGeneratrix = new Geom_Line( Pfirst, DirGeneratrix );
GeomAPI_ExtremaCurveCurve theExtrema( LineGeneratrix, LineApex );
gp_Pnt Pint1, Pint2;
theExtrema.NearestPoints(Pint1, Pint2);
Standard_Real length = Pfirst.Distance(Pint1);
if (OffsetOutside)
{
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, vf2);
GeomLib::ExtendSurfByLength(*((Handle(Geom_BoundedSurface)*)&TheSurf), length, 1,
Standard_False, Standard_True);
Standard_Real u1, u2, v1, v2;
TheSurf->Bounds( u1, u2, v1, v2 );
MaxApex = TheSurf->Value( uf1, v2 );
}
else
{
Handle(Geom_Curve) uiso = TheSurf->UIso( uf1 );
GeomAPI_ProjectPointOnCurve Projector( Pint1, uiso );
Standard_Real NewLastV = Projector.LowerDistanceParameter();
TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, NewLastV);
MaxApex = TheSurf->Value( uf1, NewLastV );
//TheSurf = new Geom_RectangularTrimmedSurface(TheSurf, uf1, uf2, vf1, vf2-length);
//MaxApex = TheSurf->Value( uf1, vf2-length );
}
HasSingularity = Standard_True;
}
} //end of if (VmaxDegen)
} //end of else (case of Geom_OffsetSurface)
} //end of if (!DegEdges.IsEmpty())
} //end of processing offsets of faces with possible degenerated edges
// find the PCurves of the edges of <Faces>
BRep_Builder myBuilder;
myBuilder.MakeFace(myFace);
myBuilder.UpdateFace(myFace,TheSurf,L,BRep_Tool::Tolerance(Face));

8
src/MAT/MAT_Mat.cdl
View File

@@ -34,7 +34,7 @@ uses
is
Create
Create(IsOpenResult : Boolean from Standard = Standard_False)
---Purpose: Empty construtor.
returns Mat from MAT;
@@ -44,6 +44,11 @@ is
---Purpose: Algoritm of computation of the bisecting locus.
is static;
CreateMatOpen(me : in out ; aTool : in out Tool)
---Purpose: Algoritm of computation of the bisecting locus for
-- open wire.
is static;
IsDone(me) returns Boolean from Standard
---Purpose: Returns <TRUE> if CreateMat has succeeded.
is static;
@@ -98,6 +103,7 @@ is
fields
myIsOpenResult : Boolean;
thenumberofbisectors : Integer;
thenumberofedges : Integer;
semiInfinite : Boolean;

671
src/MAT/MAT_Mat.gxx
View File

@@ -34,8 +34,9 @@
// purpose :
//========================================================================
MAT_Mat::MAT_Mat()
MAT_Mat::MAT_Mat(const Standard_Boolean IsOpenResult)
{
myIsOpenResult = IsOpenResult;
thenumberofbisectors = 0;
thenumberofedges = 0;
}
@@ -123,6 +124,670 @@ MAT_Mat::MAT_Mat()
// dans la boucle.
//
//========================================================================
void MAT2d_Mat2d::CreateMatOpen(Tool& atool)
{
#ifdef ICONTINUE
Standard_Boolean Icontinue;
#endif
Standard_Boolean interrupt = Standard_False;
Handle(MAT_Edge) edgetoremove;
Handle(MAT_Edge) previousedge,currentedge;
Standard_Integer noofbisectorstoremove;
Handle(MAT_Bisector) firstbisector,secondbisector;
Handle(MAT_Edge) edge;
Standard_Integer intersectionpoint;
Standard_Integer beginbisector;
Standard_Integer noofbisectors;
Standard_Integer NbIterBis = 0;
Standard_Integer EvenNbIterBis = 10;
TColStd_Array1OfInteger EdgeNumbers(1, EvenNbIterBis+1);
EdgeNumbers.Init(-1);
Standard_Boolean ToNullifyNoofbisectorstoremove = Standard_False;
Handle(MAT_ListOfBisector) currentbisectorlist;
Handle(MAT_Bisector) bisectortoremove,lastbisector,currentbisector;
Handle(MAT_Bisector) previousbisector;
Standard_Integer i,j,k,narea,shift,compact,all;
Standard_Integer noofedges;
Standard_Integer NumberMaxOfIte;
Standard_Real toleranceofconfusion;
noofedges = atool.NumberOfItems();
toleranceofconfusion = atool.ToleranceOfConfusion();
NumberMaxOfIte = noofedges*noofedges;
TColStd_Array1OfInteger firstarea(0, noofedges);
TColStd_Array1OfInteger lastarea(0, noofedges);
TColStd_Array1OfInteger noofarea(0, noofedges);
Standard_Integer parama[2];
Standard_Integer paramb[2];
// -----------------------------------------
// Initialisation et remise a zero des maps.
// -----------------------------------------
bisectoronetoremove.Clear();
bisectortwotoremove.Clear();
typeofbisectortoremove.Clear();
bisectormap.Clear();
isDone = Standard_True;
noofbisectors = noofedges-1;
beginbisector = 0;
// --------------------------------------------------------------------
// Construction de <theedgelist> un edge correspond a un element simple
// du contour.
// --------------------------------------------------------------------
theedgelist = new MAT_ListOfEdge();
for(i=0; i<noofedges; i++) {
edge = new MAT_Edge();
edge->EdgeNumber(i+1);
edge->Distance(-1);
theedgelist->BackAdd(edge);
}
theedgelist->Loop();
//---------------------------------------------------
// Initialisation des bissectrices issues du contour.
//---------------------------------------------------
Standard_Real Dist;
theedgelist->First();
for(i=0; i<theedgelist->Number()-1; i++) {
bisectormap.Bind(i,new MAT_Bisector());
bisectormap(i)->IndexNumber(i);
bisectormap(i)->FirstEdge(theedgelist->Current());
bisectormap(i)->FirstVector
(atool.TangentBefore(theedgelist->Current()->EdgeNumber(), myIsOpenResult));
theedgelist->Next();
bisectormap(i)->SecondEdge(theedgelist->Current());
bisectormap(i)->IssuePoint
(atool.FirstPoint(theedgelist->Current()->EdgeNumber(),Dist));
bisectormap(i)->DistIssuePoint(Dist);
bisectormap(i)->SecondVector
(atool.TangentAfter(theedgelist->Current()->EdgeNumber(), myIsOpenResult));
}
//----------------------------------------------------
// Affectation a chaque edge de ses deux bissectrices.
//----------------------------------------------------
theedgelist->First();
theedgelist->Current()->FirstBisector(bisectormap(0));
theedgelist->Current()->SecondBisector(bisectormap(0));
theedgelist->Next();
for(i=1; i<theedgelist->Number()-1; i++) {
theedgelist->Current()->FirstBisector
(bisectormap(i-1));
theedgelist->Current()->SecondBisector
(bisectormap(i));
theedgelist->Next();
}
theedgelist->Current()->FirstBisector(bisectormap(theedgelist->Number()-2));
theedgelist->Current()->SecondBisector(bisectormap(theedgelist->Number()-2));
//===========================================================================
// Boucle Principale (etape 2)
//===========================================================================
Standard_Integer NumberOfIte = 0;
while(theedgelist->Number()>1) {
// ------------------------------------------------------------------
// Creation des geometries des bissectrices via le tool. (etape 2.1)
// -------------------------------------------------------------------
for(i=beginbisector; i<noofbisectors; i++) {
atool.CreateBisector(bisectormap(i));
thenumberofbisectors++;
#ifdef DEBUG_Mat
atool.Dump(bisectormap(i)->BisectorNumber(),1);
#ifdef ICONTINUE
cin>>Icontinue;
#endif
#endif
}
// ---------------------------------------------
// Condition de sortie de la boucle principale.
// ---------------------------------------------
// Modified by Sergey KHROMOV - Fri Nov 17 10:28:28 2000 Begin
if (theedgelist->Number() < 3)
break;
// Modified by Sergey KHROMOV - Fri Nov 17 10:28:37 2000 End
//---------------------------------------------------
// boucle 2 Tant qu il y a des bisectrices a effacer.
//---------------------------------------------------
for(;;) {
NbIterBis++;
noofbisectorstoremove = 0;
theedgelist->First();
theedgelist->Next();
//--------------------------------------------------------------
// Calcul des intersections des bisectrices voisines.(etape 2.2)
//--------------------------------------------------------------
if (NbIterBis <= EvenNbIterBis+1)
EdgeNumbers(NbIterBis) = theedgelist->Number();
else
{
for (k = 1; k <= EvenNbIterBis; k++)
EdgeNumbers(k) = EdgeNumbers(k+1);
EdgeNumbers(EvenNbIterBis+1) = theedgelist->Number();
}
if (EdgeNumbers(EvenNbIterBis+1) == EdgeNumbers(1))
ToNullifyNoofbisectorstoremove = Standard_True;
for(i=1; i<theedgelist->Number()-1; i++) {
edge = theedgelist->Current();
if(edge->Distance() == -1.) {
firstbisector = edge->FirstBisector();
secondbisector = edge->SecondBisector();
edge->Distance(atool.IntersectBisector
(firstbisector,secondbisector,intersectionpoint));
edge->IntersectionPoint(intersectionpoint);
if(edge->Distance() == Precision::Infinite()) {
if(firstbisector->IndexNumber() >= beginbisector ||
secondbisector->IndexNumber() >= beginbisector)
Intersect(atool,0,noofbisectorstoremove,
firstbisector,secondbisector );
}
else {
if(firstbisector->IndexNumber() >= beginbisector) {
Intersect(atool,1,noofbisectorstoremove,
firstbisector,secondbisector );
}
if(secondbisector->IndexNumber() >= beginbisector) {
Intersect(atool,2,noofbisectorstoremove,
firstbisector,secondbisector );
}
}
}
theedgelist->Next();
}
//-------------------------------
// Test de sortie de la boucle 2.
//-------------------------------
if (ToNullifyNoofbisectorstoremove)
noofbisectorstoremove = 0;
if(noofbisectorstoremove == 0) break;
//---------------------------------------------------
// Annulation des bissectrices a effacer. (etape 2.4)
//---------------------------------------------------
for(i=0; i<noofbisectorstoremove; i++) {
bisectortoremove = bisectoronetoremove(i);
//---------------------------------------------------------------
// Destruction des bisectrices descendantes de <bisectortoremove>
// On descend dans l arbre jusqu a ce qu on atteigne
// <bisectortwotoremove(i).
//---------------------------------------------------------------
for(;;){
#ifdef DEBUG_Mat
atool.Dump(bisectortoremove->BisectorNumber(),0);
#endif
// ----------------------------------
// Annulation de <bisectortoremove>.
// ----------------------------------
thenumberofbisectors--;
currentbisectorlist = bisectortoremove->List();
currentbisectorlist->First();
currentbisector = currentbisectorlist->FirstItem();
previousedge = currentbisector->FirstEdge();
theedgelist->Init(previousedge);
previousedge->Distance(-1.);
previousedge->FirstBisector()->SecondParameter(Precision::Infinite());
previousedge->SecondBisector()->FirstParameter(Precision::Infinite());
//------------------------------------------
// Annulation des fils de <currentbisector>.
//------------------------------------------
while(currentbisectorlist->More()) {
currentbisector = currentbisectorlist->Current();
currentedge = currentbisector->SecondEdge();
//---------------------------------------
// Reinsertion de l edge dans le contour.
//---------------------------------------
theedgelist->LinkAfter(currentedge);
theedgelist->Next();
currentedge->FirstBisector(currentbisector);
previousedge->SecondBisector(currentbisector);
#ifdef DEBUG_Mat
atool.Dump(currentbisector->BisectorNumber(),0);
#endif
//------------------------------------------------------
// Annulation de l intersection ie les fils qui
// ont generes l intersection sont prolonges a l infini.
//------------------------------------------------------
currentbisector->FirstParameter (Precision::Infinite());
currentbisector->SecondParameter(Precision::Infinite());
atool.TrimBisector(currentbisector);
#ifdef DEBUG_Mat
atool.Dump(currentbisector->BisectorNumber(),1);
#endif
currentedge->Distance(-1.);
currentedge->FirstBisector()->SecondParameter(Precision::Infinite());
currentedge->SecondBisector()->FirstParameter(Precision::Infinite());
previousedge = currentedge;
currentbisectorlist->Next();
}
theedgelist->Unlink();
//-----------------------------------------------------------
// Test de sortie de la boucle d annulation des bissectrices.
//-----------------------------------------------------------
if(bisectortoremove->BisectorNumber() ==
bisectortwotoremove(i)->BisectorNumber()) break;
//-----------------------
// Descente dans l arbre.
//-----------------------
if(typeofbisectortoremove(i) == 1)
bisectortoremove = bisectortoremove->FirstBisector();
else
bisectortoremove = bisectortoremove->LastBisector();
} //----------------------------------------------------
// Fin boucle d annulation des bissectrices issue de
// <bisectoronetoremove(i)>.
//----------------------------------------------------
} //------------------------------------------
// Fin boucle d annulation des bissectrices.
//-------------------------------------------
#ifdef ICONTINUE
cin>>Icontinue;
#endif
} //--------------
// Fin Boucle 2.
//--------------
// ----------------------------------------------------------------------
// Analyse des parametres des intersections sur les bisectrices de chaque
// edge et determination des portions de contour a supprimees. (etape 2.5)
// ----------------------------------------------------------------------
theedgelist->First();
theedgelist->Next();
currentbisector = theedgelist->Current()->FirstBisector();
if (currentbisector->FirstParameter() == Precision::Infinite() &&
currentbisector->SecondParameter() == Precision::Infinite()) {
parama[0] = -1;
paramb[0] = -1;
}
else if(currentbisector->FirstParameter() == Precision::Infinite()) {
parama[0] = -1;
paramb[0] = 1;
}
else if(currentbisector->SecondParameter() == Precision::Infinite()) {
paramb[0] = -1;
parama[0] = 1;
}
else if (atool.Distance(currentbisector,
currentbisector->FirstParameter(),
currentbisector->SecondParameter())
> toleranceofconfusion) {
if((currentbisector->FirstParameter() -
currentbisector->SecondParameter())
*currentbisector->Sense() > 0.) {
parama[0] = -1;
paramb[0] = 1;
}
else {
paramb[0] = -1;
parama[0] = 1;
}
}
else {
parama[0] = 1;
paramb[0] = 1;
}
narea = -1;
for(i=1; i<theedgelist->Number()-1; i++) {
currentbisector = theedgelist->Current()->SecondBisector();
if (currentbisector->FirstParameter() == Precision::Infinite() &&
currentbisector->SecondParameter() == Precision::Infinite()) {
parama[1] = -1;
paramb[1] = -1;
}
else if(currentbisector->FirstParameter() == Precision::Infinite()) {
parama[1] = -1;
paramb[1] = 1;
}
else if(currentbisector->SecondParameter() == Precision::Infinite()) {
paramb[1] = -1;
parama[1] = 1;
}
else if (atool.Distance(currentbisector,
currentbisector->FirstParameter(),
currentbisector->SecondParameter())
> toleranceofconfusion) {
if((currentbisector->FirstParameter() -
currentbisector->SecondParameter())
*currentbisector->Sense() > 0.) {
parama[1] = -1;
paramb[1] = 1;
}
else {
paramb[1] = -1;
parama[1] = 1;
}
}
else {
parama[1] = 1;
paramb[1] = 1;
}
//-----------------------------------------------------------------
// Test si l edge est a enlever du contour
// Construction des portions de contour a eliminer.
//
// narea : nombre de portions continues du contour a eliminer.
// firstarea[i] : indice premier edge de la portion i.
// lastarea[i] : indice dernier edge de la portion i.
//-----------------------------------------------------------------
#ifdef DEBUG_Mat
cout <<" Test sur les parametres pour elimination"<<endl;
cout << " Edge number :"<<theedgelist->Current()->EdgeNumber()<<endl;
#endif
if(paramb[0] > 0 && parama[1] > 0) {
#ifdef DEBUG_Mat
cout <<" A ELIMINER "<<endl;
#endif
if(narea < 0) {
firstarea(++narea) = theedgelist->Index();
lastarea(narea) = firstarea(narea);
noofarea(narea) = 1;
}
else {
if(theedgelist->Index() == lastarea(narea)+1) {
lastarea(narea)++;
noofarea(narea)++;
}
else {
firstarea(++narea) = theedgelist->Index();
lastarea(narea) = firstarea(narea);
noofarea(narea) = 1;
}
}
}
parama[0] = parama[1];
paramb[0] = paramb[1];
theedgelist->Next();
}
compact = 0;
if(narea > 0) {
if(lastarea(narea) == theedgelist->Number() && firstarea(0) == 1) {
firstarea(0) = firstarea(narea);
noofarea(0) = noofarea(0)+noofarea(narea);
compact = noofarea(narea);
narea--;
}
}
narea++;
//------------------------------------------------------------------
// Sortie de la boucle principale si il n y a pas d edge a eliminer.
// (etape 2.6)
//------------------------------------------------------------------
if(narea == 0) {
interrupt = Standard_True;
break;
}
//----------------------------------------------------------------
// Elimination des edges a enlever du contour
// => Mise a jour du nouveau contour.
// => Creation des bissectrices entre les nouvelles edges voisines.
//----------------------------------------------------------------
beginbisector = noofbisectors;
shift = 0;
all = 0;
if(narea == 1 && noofarea(0) == theedgelist->Number()) all = 1;
for(i=0; i<narea; i++) {
if(i == 1)shift = shift-compact;
theedgelist->First();
theedgelist->Next();
edgetoremove = theedgelist->Brackets(firstarea(i)-shift);
edgetoremove->FirstBisector()->EndPoint(edgetoremove
->IntersectionPoint());
#ifdef DEBUG_Mat
atool.Dump(edgetoremove->FirstBisector()->BisectorNumber(),0);
#endif
edgetoremove->FirstBisector()->FirstParameter
(edgetoremove->FirstBisector()->SecondParameter());
#ifdef DEBUG_Mat
if(atool.TrimBisector(edgetoremove->FirstBisector()))
atool.Dump(edgetoremove->FirstBisector()->BisectorNumber(),1);
#else
atool.TrimBisector(edgetoremove->FirstBisector());
#endif
bisectormap.Bind(noofbisectors,new MAT_Bisector());
bisectormap(noofbisectors)->IndexNumber(noofbisectors);
bisectormap(noofbisectors)->DistIssuePoint(edgetoremove->Distance());
bisectormap(noofbisectors)->IssuePoint(edgetoremove
->IntersectionPoint());
bisectormap(noofbisectors)->FirstEdge(theedgelist->PreviousItem());
bisectormap(noofbisectors)->AddBisector(edgetoremove
->FirstBisector());
for(j=0; j<noofarea(i); j++) {
theedgelist->Unlink();
theedgelist->Next();
shift++;
#ifdef DEBUG_Mat
cout<<" Suppression de l'arete : "<<edgetoremove->EdgeNumber()<<endl;
#endif
if(all == 0 || j+1 != noofarea(i)) {
bisectormap(noofbisectors)->AddBisector(edgetoremove
->SecondBisector());
}
edgetoremove->SecondBisector()->EndPoint(edgetoremove
->IntersectionPoint());
#ifdef DEBUG_Mat
atool.Dump(edgetoremove->SecondBisector()->BisectorNumber(),0);
#endif
edgetoremove->SecondBisector()->SecondParameter
(edgetoremove->SecondBisector()->FirstParameter());
#ifdef DEBUG_Mat
if(atool.TrimBisector(edgetoremove->SecondBisector()))
atool.Dump(edgetoremove->SecondBisector()->BisectorNumber(),1);
#else
atool.TrimBisector(edgetoremove->SecondBisector());
#endif
edgetoremove = theedgelist->Current();
}
bisectormap(noofbisectors)->SecondEdge(theedgelist->Current());
theedgelist->PreviousItem()
->SecondBisector(bisectormap(noofbisectors));
theedgelist->Current()->FirstBisector(bisectormap(noofbisectors));
bisectormap(noofbisectors)->FirstVector
(atool.Tangent
(bisectormap(noofbisectors)->FirstBisector()
->BisectorNumber()));
bisectormap(noofbisectors)->SecondVector
(atool.Tangent
(bisectormap(noofbisectors)->LastBisector()
->BisectorNumber()));
noofbisectors++;
theedgelist->PreviousItem()->Distance(-1);
theedgelist->Current()->Distance(-1);
theedgelist->PreviousItem()->FirstBisector()
->SecondParameter(Precision::Infinite());
theedgelist->Current()->SecondBisector()->FirstParameter(Precision::Infinite());
}
//-----------------------------------------------------------------------
// Test sur le nombre d iterations :
// A chaque iteration est elimine un element du contour qui ne sera plus
// reinsere par la suite => le nombre d iterartions doit etre < au nombre
// d elements.
// Le nombre d iteration maximum est fixe a numberofedges*numberofedges.
//-----------------------------------------------------------------------
if (NumberOfIte > NumberMaxOfIte) {
isDone = Standard_False; //Echec calcul de la carte.
break;
}
NumberOfIte++;
} //===============================================
// Fin Boucle Principale.
//===============================================
//----------
// etape 3.
//----------
//----------------------------------------------
// interupt = True => bissectrices semi_infinies.
//----------------------------------------------
if(interrupt)
semiInfinite = Standard_True;
else {
semiInfinite = Standard_False;
//------------------------------------------------------------------
// Si le nombre d edge > 1 => le nombre d edge = 2
// (cf test sortie boucle principale)
// Les deux dernieres bisectrices separent les memes edges .
// Soit elles sont confondues si calcul a l interieur, soit elles
// sont semi-Infinies (exemple : contour compose seulement de deux
// arcs de cercles).
//------------------------------------------------------------------
if(theedgelist->Number() > 1) { //Now this branch is never reachable
//because the case edgenumber = 2 is processed in the main loop
theedgelist->First();
edge = theedgelist->Current();
if(edge->FirstBisector()->IndexNumber() == noofbisectors-1) {
// Modified by skv - Tue Sep 13 12:13:28 2005 IDEM Begin
if (atool.TrimBisector(edge->SecondBisector(),
edge->FirstBisector()->IssuePoint())) {
if (edge->SecondBisector()->EndPoint() == 0)
edge->SecondBisector()->EndPoint(edge->FirstBisector()->IssuePoint());
bisectormap(noofbisectors-1)->AddBisector(edge->SecondBisector());
} else
semiInfinite = Standard_True;
// Modified by skv - Tue Sep 13 12:13:28 2005 IDEM End
}
else {
// Modified by skv - Tue Sep 13 12:13:28 2005 IDEM Begin
if (atool.TrimBisector(edge->FirstBisector(),
edge->SecondBisector()->IssuePoint())) {
if (edge->FirstBisector()->EndPoint() == 0)
edge->FirstBisector()->EndPoint(edge->SecondBisector()->IssuePoint());
bisectormap(noofbisectors-1)->AddBisector(edge->FirstBisector());
} else
semiInfinite = Standard_True;
// Modified by skv - Tue Sep 13 12:13:28 2005 IDEM End
}
if (!semiInfinite) {
thenumberofbisectors--;
bisectormap(noofbisectors-1)->SecondEdge(edge);
bisectormap(noofbisectors-1)->BisectorNumber(-1);
}
}
}
if(semiInfinite) {
beginbisector = noofbisectors;
theedgelist->First();
for(i=1; i<theedgelist->Number(); i++) {
edge = theedgelist->Current();
bisectormap.Bind(noofbisectors,edge->SecondBisector());
noofbisectors++;
theedgelist->Next();
}
}
//---------------------------
// Recuperations des racines.
//---------------------------
roots = new MAT_ListOfBisector;
if (bisectormap(noofbisectors-1)->BisectorNumber() == -1) {
roots = bisectormap(noofbisectors-1)->List();
roots->First();
roots->Current()->FirstEdge()
->Distance(bisectormap(noofbisectors-1)->DistIssuePoint());
}
else {
for (i=beginbisector;i<noofbisectors;i++) {
roots->BackAdd(bisectormap(i));
}
}
}
void MAT_Mat::CreateMat(Tool& atool)
{
@@ -207,14 +872,14 @@ void MAT_Mat::CreateMat(Tool& atool)
bisectormap(i)->IndexNumber(i);
bisectormap(i)->FirstEdge(theedgelist->Current());
bisectormap(i)->FirstVector
(atool.TangentBefore(theedgelist->Current()->EdgeNumber()));
(atool.TangentBefore(theedgelist->Current()->EdgeNumber(), myIsOpenResult));
theedgelist->Next();
bisectormap(i)->SecondEdge(theedgelist->Current());
bisectormap(i)->IssuePoint
(atool.FirstPoint(theedgelist->Current()->EdgeNumber(),Dist));
bisectormap(i)->DistIssuePoint(Dist);
bisectormap(i)->SecondVector
(atool.TangentAfter(theedgelist->Current()->EdgeNumber()));
(atool.TangentAfter(theedgelist->Current()->EdgeNumber(), myIsOpenResult));
}
//----------------------------------------------------

7
src/MAT2d/MAT2d_BisectingLocus.gxx
View File

@@ -65,7 +65,7 @@ void MAT2d_BisectingLocus::Compute(Explorer& anExplo,
const GeomAbs_JoinType aJoinType,
const Standard_Boolean IsOpenResult)
{
MAT2d_Mat2d TheMAT;
MAT2d_Mat2d TheMAT( IsOpenResult );
Handle(MAT_ListOfBisector) TheRoots = new MAT_ListOfBisector();
MAT2d_SequenceOfSequenceOfGeometry Figure;
Standard_Integer i;
@@ -108,7 +108,10 @@ void MAT2d_BisectingLocus::Compute(Explorer& anExplo,
// --------------------------------------------
// Initialisation et execution de l algorithme.
// --------------------------------------------
TheMAT.CreateMat(theTool);
if (IsOpenResult)
TheMAT.CreateMatOpen(theTool);
else
TheMAT.CreateMat(theTool);
isDone = TheMAT.IsDone(); if (!isDone) return;

16
src/MAT2d/MAT2d_Circuit.cxx
View File

@@ -485,16 +485,12 @@ void MAT2d_Circuit::InitOpen (TColGeom2d_SequenceOfGeometry& Line) const
Handle(Geom2d_TrimmedCurve) Curve;
Standard_Real DotProd;
if (!myIsOpenResult)
{
Curve = Handle(Geom2d_TrimmedCurve)::DownCast(Line.First());
Line.InsertBefore(1,new Geom2d_CartesianPoint(Curve->StartPoint()));
Curve = Handle(Geom2d_TrimmedCurve)::DownCast(Line.Last());
Line.Append(new Geom2d_CartesianPoint(Curve->EndPoint()));
}
Standard_Integer addition = (myIsOpenResult)? 1 : 2;
for ( Standard_Integer i = addition; i <= Line.Length() - addition; i++) {
Curve = Handle(Geom2d_TrimmedCurve)::DownCast(Line.First());
Line.InsertBefore(1,new Geom2d_CartesianPoint(Curve->StartPoint()));
Curve = Handle(Geom2d_TrimmedCurve)::DownCast(Line.Last());
Line.Append(new Geom2d_CartesianPoint(Curve->EndPoint()));
for ( Standard_Integer i = 2; i <= Line.Length() - 2; i++) {
if ( Abs(CrossProd(Line.Value(i),Line.Value(i+1),DotProd)) > 1.E-8 ||
DotProd < 0. ) {
Curve = Handle(Geom2d_TrimmedCurve)::DownCast(Line.Value(i));

6
src/MAT2d/MAT2d_Tool2d.cdl
View File

@@ -82,13 +82,15 @@ is
-- Returns the index of this point in <theGeomPnts>.
returns Integer is static;
TangentBefore(me : in out ; anitem : Integer)
TangentBefore(me : in out ; anitem : Integer;
IsOpenResult : Boolean)
--- Purpose : Creates the Tangent at the end of the Item defined
-- by <anitem>. Returns the index of this vector in
-- <theGeomVecs>
returns Integer is static;
TangentAfter(me : in out ; anitem : Integer)
TangentAfter(me : in out ; anitem : Integer;
IsOpenResult : Boolean)
--- Purpose : Creates the Reversed Tangent at the origin of the Item
-- defined by <anitem>. Returns the index of this vector in
-- <theGeomVecs>

26
src/MAT2d/MAT2d_Tool2d.cxx
View File

@@ -199,13 +199,17 @@ Standard_Integer MAT2d_Tool2d::FirstPoint(const Standard_Integer anitem,
//function : TangentBefore
//purpose :
//=============================================================================
Standard_Integer MAT2d_Tool2d::TangentBefore(const Standard_Integer anitem)
Standard_Integer MAT2d_Tool2d::TangentBefore(const Standard_Integer anitem,
const Standard_Boolean IsOpenResult)
{
Standard_Integer item;
Handle(Geom2d_Curve) curve;
theNumberOfVecs++;
item = (anitem == theCircuit->NumberOfItems()) ? 1 : (anitem + 1);
if (!IsOpenResult)
item = (anitem == theCircuit->NumberOfItems()) ? 1 : (anitem + 1);
else
item = (anitem == theCircuit->NumberOfItems()) ? (anitem - 1) : (anitem + 1);
if (theCircuit->ConnexionOn(item)){
Standard_Real x1,y1,x2,y2;
theCircuit->Connexion(item)->PointOnFirst().Coord(x1,y1);
@@ -222,7 +226,9 @@ Standard_Integer MAT2d_Tool2d::TangentBefore(const Standard_Integer anitem)
}
else {
curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(item));
theGeomVecs.Bind(theNumberOfVecs,curve->DN(curve->FirstParameter(),1));
Standard_Real param = (IsOpenResult && anitem == theCircuit->NumberOfItems())?
curve->LastParameter() : curve->FirstParameter();
theGeomVecs.Bind(theNumberOfVecs,curve->DN(param,1));
}
return theNumberOfVecs;
@@ -232,7 +238,8 @@ Standard_Integer MAT2d_Tool2d::TangentBefore(const Standard_Integer anitem)
//function : TangentAfter
//purpose :
//=============================================================================
Standard_Integer MAT2d_Tool2d::TangentAfter(const Standard_Integer anitem)
Standard_Integer MAT2d_Tool2d::TangentAfter(const Standard_Integer anitem,
const Standard_Boolean IsOpenResult)
{
Standard_Integer item;
Handle(Geom2d_Curve) curve;
@@ -254,9 +261,14 @@ Standard_Integer MAT2d_Tool2d::TangentAfter(const Standard_Integer anitem)
thevector = curve->DN(curve->FirstParameter(),1);
}
else {
item = (anitem == 1) ? theCircuit->NumberOfItems() : (anitem - 1);
if (!IsOpenResult)
item = (anitem == 1) ? theCircuit->NumberOfItems() : (anitem - 1);
else
item = (anitem == 1) ? 2 : (anitem - 1);
curve = Handle(Geom2d_Curve)::DownCast(theCircuit->Value(item));
thevector = curve->DN(curve->LastParameter(),1);
Standard_Real param = (IsOpenResult && anitem == 1)?
curve->FirstParameter() : curve->LastParameter();
thevector = curve->DN(param,1);
}
theGeomVecs.Bind(theNumberOfVecs,thevector.Reversed());
return theNumberOfVecs;