OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0024427: Wrong section curves

Browse Source 
Incorrect curve is got after Decompose method applying. This method's using should be restrict.
Decomposition is required if intersection curve contains some parts, where U-parameter on quadric surface changes too sharply.

Decompose method is called for Cone and Sphere only (it does not require for Cylinder).

Comments are changed by jgv.

Test case for issue CR24427

Added test case bugs/moddata_3/bug24427_2

Compiler warning is liquidated.
Test is corrected.
This commit is contained in:
nbv 2014-01-15 10:56:16 +04:00 committed by bugmaster
parent e92240458e
commit 191478a581
5 changed files with 1520 additions and 1389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

554
src/IntPatch/IntPatch_ImpPrmIntersection.cxx
View File

@ -35,12 +35,54 @@
#include <IntPatch_WLine.hxx>
#include <IntPatch_ArcFunction.hxx>
#include <IntPatch_RstInt.hxx>
#ifndef DEB
#define No_Standard_RangeError
#define No_Standard_OutOfRange
#endif
#include <math_Vector.hxx>
#include <math_Matrix.hxx>
#include <TopTrans_CurveTransition.hxx>
#include <TopAbs_State.hxx>
#include <TopAbs_Orientation.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <IntSurf_SequenceOfInteriorPoint.hxx>
#include <IntSurf_QuadricTool.hxx>
#include <GeomAbs_SurfaceType.hxx>
static Standard_Boolean DecomposeResult(const Handle(IntPatch_Line)& Line,
const Standard_Boolean IsReversed,
const IntSurf_Quadric& Quad,
const Handle(Adaptor3d_TopolTool)& PDomain,
const Handle(Adaptor3d_HSurface)& QSurf,
const Standard_Real ArcTol,
IntPatch_SequenceOfLine& Lines);
static
void ComputeTangency (const IntPatch_TheSOnBounds& solrst,
IntSurf_SequenceOfPathPoint& seqpdep,
const Handle(Adaptor3d_TopolTool)& Domain,
IntPatch_TheSurfFunction& Func,
const Handle(Adaptor3d_HSurface)& PSurf,
TColStd_Array1OfInteger& Destination);
static
void Recadre(const Standard_Boolean ,
GeomAbs_SurfaceType typeS1,
GeomAbs_SurfaceType typeS2,
IntPatch_Point& pt,
const Handle(IntPatch_TheIWLineOfTheIWalking)& iwline,
Standard_Integer Param,
Standard_Real U1,
Standard_Real V1,
Standard_Real U2,
Standard_Real V2);
//=======================================================================
//function : IntPatch_ImpPrmIntersection
//purpose :
//=======================================================================
IntPatch_ImpPrmIntersection::IntPatch_ImpPrmIntersection ()
: done(Standard_False),
empt(Standard_False),
@ -86,51 +128,6 @@ void IntPatch_ImpPrmIntersection::SetStartPoint(const Standard_Real U,
myUStart = U; myVStart = V;
}
#ifndef DEB
#define No_Standard_RangeError
#define No_Standard_OutOfRange
#endif
#include <math_Vector.hxx>
#include <math_Matrix.hxx>
#include <TopTrans_CurveTransition.hxx>
#include <TopAbs_State.hxx>
#include <TopAbs_Orientation.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <IntSurf_SequenceOfInteriorPoint.hxx>
#include <IntSurf_QuadricTool.hxx>
#include <GeomAbs_SurfaceType.hxx>
static void DecomposeResult(Handle(IntPatch_Line)& Line,
Standard_Boolean IsReversed,
IntSurf_Quadric& Quad,
Handle(Adaptor3d_TopolTool)& PDomain,
Handle(Adaptor3d_HSurface)& QSurf,
Standard_Real TolArc,
IntPatch_SequenceOfLine& Lines);
static
void ComputeTangency (const IntPatch_TheSOnBounds& solrst,
IntSurf_SequenceOfPathPoint& seqpdep,
const Handle(Adaptor3d_TopolTool)& Domain,
IntPatch_TheSurfFunction& Func,
const Handle(Adaptor3d_HSurface)& PSurf,
TColStd_Array1OfInteger& Destination);
static
void Recadre(const Standard_Boolean ,
GeomAbs_SurfaceType typeS1,
GeomAbs_SurfaceType typeS2,
IntPatch_Point& pt,
const Handle(IntPatch_TheIWLineOfTheIWalking)& iwline,
Standard_Integer Param,
Standard_Real U1,
Standard_Real V1,
Standard_Real U2,
Standard_Real V2);
//=======================================================================
//function : ComputeTangency
//purpose :
@ -447,7 +444,8 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
spnt.Clear();
//
reversed = Standard_False;
switch (typeS1) {
switch (typeS1)
{
case GeomAbs_Plane:
Quad.SetValue(Surf1->Plane());
break;
@ -464,9 +462,11 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
Quad.SetValue(Surf1->Cone());
break;
default: {
default:
{
reversed = Standard_True;
switch (typeS2) {
switch (typeS2)
{
case GeomAbs_Plane:
Quad.SetValue(Surf2->Plane());
break;
@ -482,7 +482,8 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
case GeomAbs_Cone:
Quad.SetValue(Surf2->Cone());
break;
default: {
default:
{
Standard_ConstructionError::Raise();
break;
}
@ -1259,87 +1260,38 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
}
empt = (slin.Length() == 0 && spnt.Length() == 0);
done = Standard_True;
//
// post processing for cones and spheres
if((Quad.TypeQuadric() == GeomAbs_Cone ||
Quad.TypeQuadric() == GeomAbs_Sphere) &&
slin.Length()) {
Handle(Adaptor3d_TopolTool) PDomain = (reversed) ? D1 : D2;
Handle(Adaptor3d_HSurface) QSurf = (reversed) ? Surf2 : Surf1;
// post processing for cones and spheres
if(slin.Length() == 0)
return;
Standard_Boolean isDecomposeRequired = (Quad.TypeQuadric() == GeomAbs_Cone) ||
(Quad.TypeQuadric() == GeomAbs_Sphere);
if(!isDecomposeRequired)
return;
const Handle(Adaptor3d_TopolTool)& PDomain = (reversed) ? D1 : D2;
const Handle(Adaptor3d_HSurface)& aQSurf = (reversed) ? Surf2 : Surf1;
IntPatch_SequenceOfLine dslin;
Standard_Boolean isDecompose = Standard_False;
for(i = 1; i <= slin.Length(); i++ )
DecomposeResult(slin(i),reversed,Quad,PDomain,QSurf,TolArc,dslin);
{
if(DecomposeResult(slin(i),reversed,Quad,PDomain,aQSurf,TolArc,dslin))
{
isDecompose = Standard_True;
}
}
if(!isDecompose)
return;
slin.Clear();
for(i = 1; i <= dslin.Length(); i++ )
slin.Append(dslin(i));
}
}
//==================================================================
// Decomposition of WLine goes through seam and/or apex routines
//==================================================================
// reject all points and vertices not in V range on Quadric
static Handle(IntSurf_LineOn2S) VSplitLine(Handle(IntSurf_LineOn2S)& Line,
Standard_Boolean IsReversed,
Handle(Adaptor3d_HSurface)& QSurf,
Handle(IntSurf_LineOn2S)& Vertices)
{
Handle(IntSurf_LineOn2S) line = new IntSurf_LineOn2S();
Standard_Real VF = QSurf->FirstVParameter();
Standard_Real VL = QSurf->LastVParameter();
Standard_Integer i = 0;
Standard_Real U = 0., V = 0.;
for(i = 1; i <= Line->NbPoints(); i++) {
const IntSurf_PntOn2S& aP = Line->Value(i);
if(IsReversed)
aP.ParametersOnS2(U,V); // S2 - quadric
else
aP.ParametersOnS1(U,V); // S1 - quadric
if(VF <= V && V <= VL)
line->Add(aP);
}
Standard_Boolean isDeleted = Standard_True;
Standard_Integer k = 0;
while(isDeleted) {
isDeleted = Standard_False;
k = 0;
for(i = 1; i <= Vertices->NbPoints(); i++) {
const IntSurf_PntOn2S& aV = Vertices->Value(i);
if(IsReversed)
aV.ParametersOnS2(U,V); // S2 - quadric
else
aV.ParametersOnS1(U,V); // S1 - quadric
if(VF <= V && V <= VL)
continue;
else {
k = i;
break;
}
}
if(k != 0) {
isDeleted = Standard_True;
Vertices->RemovePoint(k);
}
else
break;
}
return line;
}
// correct U parameter of the start point of line on Quadric
@ -1399,11 +1351,10 @@ static Standard_Real AdjustUFirst(Standard_Real U1,Standard_Real U2)
// collect vertices, reject equals
static Handle(IntSurf_LineOn2S) GetVertices(const Handle(IntPatch_WLine)& WLine,
const Standard_Boolean ,//IsReversed,
const Standard_Real TOL3D,
const Standard_Real TOL2D)
{
// Standard_Real TOL3D = 1.e-12, TOL2D = 1.e-8;
// Standard_Real TOL3D = 1.e-12, TOL2D = 1.e-8;
Handle(IntSurf_LineOn2S) vertices = new IntSurf_LineOn2S();
@ -1484,9 +1435,9 @@ static Standard_Boolean AreSamePoints(const IntSurf_PntOn2S& P1,
return result;
}
static void ForcedPurgePoints(Handle(IntSurf_LineOn2S)& Result,
Standard_Boolean IsReversed,
IntSurf_Quadric& Quad)
static void ForcedPurgePoints(const Handle(IntSurf_LineOn2S)& Result,
const Standard_Boolean IsReversed,
const IntSurf_Quadric& Quad)
{
if(Result->NbPoints() <= 30) return;
Standard_Integer Index = 0, IndexLimF = 8, IndexLimL = 8;
@ -1742,11 +1693,11 @@ static Standard_Boolean InsertSeamVertices(Handle(IntSurf_LineOn2S)& Line,
break;
}
else {
// Line->InsertBefore(ip,Line->Value(ipn));
// Line->RemovePoint(ip+2);
// result = Standard_True;
// cout << "swap vertex " << endl;
// break;
// Line->InsertBefore(ip,Line->Value(ipn));
// Line->RemovePoint(ip+2);
// result = Standard_True;
// cout << "swap vertex " << endl;
// break;
}
}
}
@ -1756,10 +1707,10 @@ static Standard_Boolean InsertSeamVertices(Handle(IntSurf_LineOn2S)& Line,
return result;
}
static void ToSmooth(Handle(IntSurf_LineOn2S)& Line,
Standard_Boolean IsReversed,
IntSurf_Quadric& Quad,
Standard_Boolean IsFirst,
static void ToSmooth( const Handle(IntSurf_LineOn2S)& Line,
const Standard_Boolean IsReversed,
const IntSurf_Quadric& Quad,
const Standard_Boolean IsFirst,
Standard_Real& D3D)
{
if(Line->NbPoints() <= 10)
@ -1856,7 +1807,7 @@ static Standard_Boolean TestMiddleOnPrm(const IntSurf_PntOn2S& aP,
const IntSurf_PntOn2S& aV,
const Standard_Boolean IsReversed,
const Standard_Real ArcTol,
Handle(Adaptor3d_TopolTool)& PDomain)
const Handle(Adaptor3d_TopolTool)& PDomain)
{
Standard_Boolean result = Standard_False;
@ -1877,12 +1828,12 @@ static Standard_Boolean TestMiddleOnPrm(const IntSurf_PntOn2S& aP,
return result;
}
static void VerifyVertices(Handle(IntSurf_LineOn2S)& Line,
Standard_Boolean IsReversed,
Handle(IntSurf_LineOn2S)& Vertices,
Standard_Real TOL2D,
static void VerifyVertices( const Handle(IntSurf_LineOn2S)& Line,
const Standard_Boolean IsReversed,
const Handle(IntSurf_LineOn2S)& Vertices,
const Standard_Real TOL2D,
const Standard_Real ArcTol,
Handle(Adaptor3d_TopolTool)& PDomain,
const Handle(Adaptor3d_TopolTool)& PDomain,
IntSurf_PntOn2S& VrtF,
Standard_Boolean& AddFirst,
IntSurf_PntOn2S& VrtL,
@ -2220,12 +2171,15 @@ static Standard_Boolean SplitOnSegments(Handle(IntPatch_WLine)& WLine,
if(nbv > 3) {
Standard_Integer iv = 0;
for(iv = 1; iv < nbv; iv++) {
Standard_Integer firstPar = (Standard_Integer) WLine->Vertex(iv).ParameterOnLine();
Standard_Integer lastPar = (Standard_Integer) WLine->Vertex(iv+1).ParameterOnLine();
Standard_Integer firstPar =
(Standard_Integer) WLine->Vertex(iv).ParameterOnLine();
Standard_Integer lastPar =
(Standard_Integer) WLine->Vertex(iv+1).ParameterOnLine();
if((lastPar - firstPar) <= 1)
continue;
else {
Handle(IntPatch_WLine) splitwline = MakeSplitWLine(WLine,Tang,Trans1,Trans2,ArcTol,firstPar,lastPar);
Handle(IntPatch_WLine) splitwline = MakeSplitWLine(WLine,Tang,Trans1,Trans2,
ArcTol,firstPar,lastPar);
Segments.Append(splitwline);
if(!result)
result = Standard_True;
@ -2235,241 +2189,217 @@ static Standard_Boolean SplitOnSegments(Handle(IntPatch_WLine)& WLine,
return result;
}
void DecomposeResult(Handle(IntPatch_Line)& Line,
Standard_Boolean IsReversed,
IntSurf_Quadric& Quad,
Handle(Adaptor3d_TopolTool)& PDomain,
Handle(Adaptor3d_HSurface)& QSurf,
Standard_Real ArcTol,
IntPatch_SequenceOfLine& Lines)
static Standard_Boolean DecomposeResult(const Handle(IntPatch_Line)& theLine,
const Standard_Boolean IsReversed,
const IntSurf_Quadric& theQuad,
const Handle(Adaptor3d_TopolTool)& thePDomain,
const Handle(Adaptor3d_HSurface)& theQSurf,
const Standard_Real theArcTol,
IntPatch_SequenceOfLine& theLines)
{
if( Line->ArcType() != IntPatch_Walking ) {
Lines.Append(Line);
return;
// Split <theLine> in the places where it passes through seam edge or singularity
// (apex of cone or pole of sphere). This passage is detected by jump of U-parameter
// from point to point.
const Standard_Real aDeltaUmax = 0.5*M_PI;
const Standard_Real aTOL3D = 1.e-10,
aTOL2D = Precision::PConfusion(),
aTOL2DS = Precision::PConfusion();
if( theLine->ArcType() != IntPatch_Walking )
{
return Standard_False;
}
Handle(IntPatch_WLine)& WLine = (*((Handle(IntPatch_WLine)*)&Line));
Handle(IntSurf_LineOn2S) SLine = WLine->Curve();
const Handle(IntPatch_WLine)& aWLine = (*((Handle(IntPatch_WLine)*)&theLine));
const Handle(IntSurf_LineOn2S)& aSLine = aWLine->Curve();
if(SLine->NbPoints() <= 2) {
Lines.Append(Line);
return;
if(aSLine->NbPoints() <= 2)
{
return Standard_False;
}
Standard_Real TOL3D = 1.e-10, TOL2D = 1.e-8, TOL2DS = 1.e-5;
//Deletes repeated vertices
Handle(IntSurf_LineOn2S) aVLine = GetVertices(aWLine,aTOL3D,aTOL2D);
Handle(IntSurf_LineOn2S) vline = GetVertices(WLine,IsReversed,TOL3D,TOL2D);
Handle(IntSurf_LineOn2S) SSLine = VSplitLine(SLine,IsReversed,QSurf,vline);
Handle(IntSurf_LineOn2S) aSSLine(aSLine);
if(SSLine->NbPoints() <= 1)
return;
if(aSSLine->NbPoints() <= 1)
return Standard_False;
AdjustLine(SSLine,IsReversed,QSurf,TOL2D);
AdjustLine(aSSLine,IsReversed,theQSurf,aTOL2D);
{
Standard_Boolean isInserted = Standard_True;
while(isInserted) {
Standard_Integer NbPnts = SSLine->NbPoints();
TColStd_Array1OfInteger ptypes(1,NbPnts);
SearchVertices(SSLine,vline,ptypes);
isInserted = InsertSeamVertices(SSLine,IsReversed,vline,ptypes,TOL2D);
while(isInserted)
{
const Standard_Integer aNbPnts = aSSLine->NbPoints();
TColStd_Array1OfInteger aPTypes(1,aNbPnts);
SearchVertices(aSSLine,aVLine,aPTypes);
isInserted = InsertSeamVertices(aSSLine,IsReversed,aVLine,aPTypes,aTOL2D);
}
}
if(SSLine->NbPoints() == 2) {
Standard_Real uu1 = 0., vv1 = 0., uu2 = 0., vv2 = 0.;
if(IsReversed) {
SSLine->Value(1).ParametersOnS2(uu1,vv1);
SSLine->Value(2).ParametersOnS2(uu2,vv2);
}
else {
SSLine->Value(1).ParametersOnS1(uu1,vv1);
SSLine->Value(2).ParametersOnS1(uu2,vv2);
}
gp_Pnt2d p1(uu1,vv1);
gp_Pnt2d p2(uu2,vv2);
if(p1.Distance(p2) > 2.e-7) {
Standard_Real Dist3D = SSLine->Value(1).Value().Distance(SSLine->Value(2).Value());
if(Dist3D > 3.e-7) {
gp_Pnt aSPnt;
IntPatch_Point TPntF,TPntL;
Handle(IntPatch_WLine) wline = new IntPatch_WLine(SSLine,Standard_False,Line->TransitionOnS1(),Line->TransitionOnS2());
aSPnt = SSLine->Value(1).Value();
SSLine->Value(1).ParametersOnS1(uu1,vv1);
SSLine->Value(1).ParametersOnS2(uu2,vv2);
TPntF.SetValue(aSPnt,ArcTol,Standard_False);
TPntF.SetParameters(uu1,vv1,uu2,vv2);
TPntF.SetParameter(1.);
wline->AddVertex(TPntF);
wline->SetFirstPoint(1);
aSPnt = SSLine->Value(SSLine->NbPoints()).Value();
SSLine->Value(SSLine->NbPoints()).ParametersOnS1(uu1,vv1);
SSLine->Value(SSLine->NbPoints()).ParametersOnS2(uu2,vv2);
TPntL.SetValue(aSPnt,ArcTol,Standard_False);
TPntL.SetParameters(uu1,vv1,uu2,vv2);
TPntL.SetParameter(SSLine->NbPoints());
wline->AddVertex(TPntL);
wline->SetLastPoint(SSLine->NbPoints());
Lines.Append(wline);
return;
}
else
return;
}
else
return;
}
const Standard_Integer aLindex = aSSLine->NbPoints();
Standard_Integer aFindex = 1, aBindex = 0;
Standard_Integer NbPnts = SSLine->NbPoints();
Standard_Real BSEAM = 1.5*M_PI; // delta U crossing seam
Standard_Real BAPEX = M_PI/16.; // delta U crossing apex
Standard_Integer k = 0;
Standard_Real U1 = 0., U2 = 0., V1 = 0., V2 = 0., AnU1 = 0.;
Standard_Integer Findex = 1, Lindex = NbPnts, Bindex = 0;
gp_Pnt aPnt, aSPnt;
IntPatch_Point TPntF,TPntL,TPntS;
Handle(IntSurf_LineOn2S) sline = new IntSurf_LineOn2S();
Handle(IntPatch_WLine) wline;
IntPatch_SequenceOfLine lines;
IntPatch_Point aTPntF, aTPntL;
// build WLine parts (if any)
nextline:;
Standard_Boolean flNextLine = Standard_True;
Standard_Boolean hasBeenDecomposed = Standard_False;
while(flNextLine)
{
// reset variables
flNextLine = Standard_False;
Standard_Boolean isDecomposited = Standard_False;
Standard_Real U1 = 0., U2 = 0., V1 = 0., V2 = 0., AnU1 = 0.;
Handle(IntSurf_LineOn2S) sline = new IntSurf_LineOn2S();
//if((Lindex-Findex+1) <= 2 )
if((Lindex-Findex+1) <= 1 )
return;
// reset variables
Standard_Boolean isDecomposited = Standard_False;
U1 = 0.; V1 = 0.; U2 = 0.; V2 = 0.; AnU1 = 0.;
if(aLindex <= aFindex)
return hasBeenDecomposed;
// analyze other points
for(k = Findex; k <= Lindex; k++) {
if( k == Findex ) {
if(IsReversed) {
SSLine->Value(k).ParametersOnS2(AnU1,V1); // S2 - quadric, set U,V by Pnt3D
for(Standard_Integer k = aFindex; k <= aLindex; k++)
{
if( k == aFindex )
{
if(IsReversed)
{
aSSLine->Value(k).ParametersOnS2(AnU1,V1); // S2 - quadric, set U,V by Pnt3D
}
else {
SSLine->Value(k).ParametersOnS1(AnU1,V1); // S1 - quadric, set U,V by Pnt3D
else
{
aSSLine->Value(k).ParametersOnS1(AnU1,V1); // S1 - quadric, set U,V by Pnt3D
}
sline->Add(SSLine->Value(k));
sline->Add(aSSLine->Value(k));
continue;
}
if(IsReversed) {
SSLine->Value(k).ParametersOnS2(U1,V1); // S2 - quadric, set U,V by Pnt3D
if(IsReversed)
{
aSSLine->Value(k).ParametersOnS2(U1,V1); // S2 - quadric, set U,V by Pnt3D
}
else {
SSLine->Value(k).ParametersOnS1(U1,V1); // S1 - quadric, set U,V by Pnt3D
else
{
aSSLine->Value(k).ParametersOnS1(U1,V1); // S1 - quadric, set U,V by Pnt3D
}
Standard_Real DeltaU = fabs(U1-AnU1);
if(DeltaU > BSEAM) {
Bindex = k;
if(Abs(U1-AnU1) > aDeltaUmax)
{
aBindex = k;
isDecomposited = Standard_True;
break;
}
else if((DeltaU > BAPEX) && (k >= (Findex+10) && k <= (Lindex-10))) {
Bindex = k;
isDecomposited = Standard_True;
break;
}
else {}
sline->Add(SSLine->Value(k));
sline->Add(aSSLine->Value(k));
AnU1=U1;
}
IntSurf_PntOn2S aVF,aVL;
IntSurf_PntOn2S aVF, aVL;
Standard_Boolean addVF = Standard_False, addVL = Standard_False;
VerifyVertices(sline,IsReversed,vline,TOL2DS,ArcTol,PDomain,aVF,addVF,aVL,addVL);
VerifyVertices(sline,IsReversed,aVLine,aTOL2DS,theArcTol,
thePDomain,aVF,addVF,aVL,addVL);
Standard_Boolean hasInternals = HasInternals(sline,vline);
Standard_Boolean hasInternals = HasInternals(sline,aVLine);
Standard_Real D3F = 0., D3L = 0.;
ToSmooth(sline,IsReversed,Quad,Standard_True,D3F);
ToSmooth(sline,IsReversed,Quad,Standard_False,D3L);
ToSmooth(sline,IsReversed,theQuad,Standard_True,D3F);
ToSmooth(sline,IsReversed,theQuad,Standard_False,D3L);
if(D3F <= 1.5e-7 && sline->NbPoints() >=3) {
D3F = sline->Value(2).Value().Distance(sline->Value(3).Value());
}
if(D3L <= 1.5e-7 && sline->NbPoints() >=3) {
D3L = sline->Value(sline->NbPoints()-1).Value().Distance(sline->Value(sline->NbPoints()-2).Value());
}
//if(D3F <= 1.5e-7 && sline->NbPoints() >=3) {
// D3F = sline->Value(2).Value().Distance(sline->Value(3).Value());
//}
//if(D3L <= 1.5e-7 && sline->NbPoints() >=3) {
// D3L = sline->Value(sline->NbPoints()-1).Value().Distance(sline->
// Value(sline->NbPoints()-2).Value());
//}
if(addVF || addVL) {
if(addVF || addVL)
{
Standard_Boolean isAdded = AddVertices(sline,aVF,addVF,aVL,addVL,D3F,D3L);
if(isAdded) {
ToSmooth(sline,IsReversed,Quad,Standard_True,D3F);
ToSmooth(sline,IsReversed,Quad,Standard_False,D3L);
if(isAdded)
{
ToSmooth(sline,IsReversed,theQuad,Standard_True,D3F);
ToSmooth(sline,IsReversed,theQuad,Standard_False,D3L);
}
}
if(!hasInternals) {
ForcedPurgePoints(sline,IsReversed,Quad);
if(!hasInternals)
{
ForcedPurgePoints(sline,IsReversed,theQuad);
}
wline = new IntPatch_WLine(sline,Standard_False,Line->TransitionOnS1(),Line->TransitionOnS2());
Handle(IntPatch_WLine) wline =
new IntPatch_WLine(sline,Standard_False,
theLine->TransitionOnS1(),theLine->TransitionOnS2());
aSPnt = sline->Value(1).Value();
gp_Pnt aSPnt(sline->Value(1).Value());
sline->Value(1).ParametersOnS1(U1,V1);
sline->Value(1).ParametersOnS2(U2,V2);
TPntF.SetValue(aSPnt,ArcTol,Standard_False);
TPntF.SetParameters(U1,V1,U2,V2);
TPntF.SetParameter(1.);
wline->AddVertex(TPntF);
aTPntF.SetValue(aSPnt,theArcTol,Standard_False);
aTPntF.SetParameters(U1,V1,U2,V2);
aTPntF.SetParameter(1.);
wline->AddVertex(aTPntF);
wline->SetFirstPoint(1);
if(hasInternals) {
PutIntVertices(wline,sline,IsReversed,vline,ArcTol);
if(hasInternals)
{
PutIntVertices(wline,sline,IsReversed,aVLine,theArcTol);
}
aSPnt = sline->Value(sline->NbPoints()).Value();
sline->Value(sline->NbPoints()).ParametersOnS1(U1,V1);
sline->Value(sline->NbPoints()).ParametersOnS2(U2,V2);
TPntL.SetValue(aSPnt,ArcTol,Standard_False);
TPntL.SetParameters(U1,V1,U2,V2);
TPntL.SetParameter(sline->NbPoints());
wline->AddVertex(TPntL);
aTPntL.SetValue(aSPnt,theArcTol,Standard_False);
aTPntL.SetParameters(U1,V1,U2,V2);
aTPntL.SetParameter(sline->NbPoints());
wline->AddVertex(aTPntL);
wline->SetLastPoint(sline->NbPoints());
IntPatch_SequenceOfLine segm;
Standard_Boolean isSplited = SplitOnSegments(wline,Standard_False,Line->TransitionOnS1(),Line->TransitionOnS2(),ArcTol,segm);
Standard_Boolean isSplited = SplitOnSegments(wline,Standard_False,
theLine->TransitionOnS1(),theLine->TransitionOnS2(),theArcTol,segm);
if(!isSplited)
Lines.Append(wline);
else {
{
theLines.Append(wline);
}
else
{
Standard_Integer nbsegms = segm.Length();
Standard_Integer iseg = 0;
for(iseg = 1; iseg <= nbsegms; iseg++)
Lines.Append(segm(iseg));
theLines.Append(segm(iseg));
}
if(isDecomposited) {
Findex = Bindex;
sline = new IntSurf_LineOn2S();
goto nextline;
if(isDecomposited)
{
aFindex = aBindex;
flNextLine = hasBeenDecomposed = Standard_True;
}
}
return hasBeenDecomposed;
}
/*
// <-A
{
Standard_Integer aNbPnts;
Standard_Real aU1,aV1,aU2,aV2;
gp_Pnt aPx;
//
aNbPnts=thelin->NbPoints();
printf(" WLine: aNbPnts=%d\n", aNbPnts);
for(i=1; i <= aNbPnts; ++i) {
const IntSurf_PntOn2S& aPoint = thelin->Value(i);
aPx=aPoint.Value();
aPoint.Parameters(aU1, aV1, aU2, aV2);
printf(" point %d %lf %lf %lf %lf %lf %lf %lf\n",
i, aPx.X(), aPx.Y(), aPx.Z(), aU1, aV1, aU2, aV2);
}
}
{
Standard_Integer aNbPnts;
Standard_Real aU1,aV1,aU2,aV2;
gp_Pnt aPx;
//
aNbPnts=thelin->NbPoints();
printf(" WLine: aNbPnts=%d\n", aNbPnts);
for(i=1; i <= aNbPnts; ++i) {
const IntSurf_PntOn2S& aPoint = thelin->Value(i);
aPx=aPoint.Value();
aPoint.Parameters(aU1, aV1, aU2, aV2);
printf(" point %d %lf %lf %lf %lf %lf %lf %lf\n",
i, aPx.X(), aPx.Y(), aPx.Z(), aU1, aV1, aU2, aV2);
}
}
*/

4
src/IntStart/IntStart_SearchOnBoundaries.gxx
View File

@ -475,7 +475,9 @@ void BoundedArc (const TheArc& A,
}
if (Nbi==1) {
if (pardeb == Pdeb && parfin == Pfin) {
if ( (Abs(pardeb - Pdeb) < Precision::PConfusion()) &&
(Abs(parfin - Pfin) < Precision::PConfusion()))
{
Arcsol=Standard_True;
}
}

41
tests/bugs/modalg_4/bug825
View File

@ -30,6 +30,47 @@ if { [ catch { set info_result [OCC825 a1 a2 a3 res1 res2 0] } ] } {
puts "Faulty OCC825"
}
checkshape res1
set nbFace_exp 0
set nbShell_exp 0
set nbSolid_exp 0
set nbCompSolid_exp 0
set nbCompound_exp 1
set nbShape_exp 1
set nb_info [nbshapes res1]
regexp {FACE +: +([-0-9.+eE]+)} $nb_info full nb_face
regexp {SHELL +: +([-0-9.+eE]+)} $nb_info full nb_shell
regexp {SOLID +: +([-0-9.+eE]+)} $nb_info full nb_solid
regexp {COMPSOLID +: +([-0-9.+eE]+)} $nb_info full nbCompSolid
regexp {COMPOUND +: +([-0-9.+eE]+)} $nb_info full nb_compound
regexp {SHAPE +: +([-0-9.+eE]+)} $nb_info full nb_Shape
if { $nb_face != $nbFace_exp } {
puts [format "Faulty : result must contain %s FACE(S), but it contains %s only." $nbFace_exp $nb_face]
}
if { $nb_shell != $nbShell_exp } {
puts [format "Faulty : result must contain %s SHELL(S), but it contains %s only." $nbShell_exp $nb_shell]
}
if { $nb_solid != $nbSolid_exp } {
puts [format "Faulty : result must contain %s SOLID(S), but it contains %s only." $nbSolid_exp $nb_solid]
}
if { $nbCompSolid != $nbCompSolid_exp } {
puts [format "Faulty : result must contain %s COMPSOLID(S), but it contains %s only." $nbCompSolid_exp $nbCompSolid]
}
if { $nb_compound != $nbCompound_exp } {
puts [format "Faulty : result must contain %s COMPOUND(S), but it contains %s only." $nbCompound_exp $nb_compound]
}
if { $nb_Shape != $nbShape_exp } {
puts [format "Faulty : result must contain %s SHAPE(S), but it contains %s only." $nbShape_exp $nb_Shape]
}
renamevar res2 result
}

79
tests/bugs/moddata_3/bug24427_1 Normal file
View File

@ -0,0 +1,79 @@
puts "========="
puts "CR24427"
puts "========="
puts ""
###############################
## Wrong section curves
###############################
restore [locate_data_file bug24427_b1.brep] b1
restore [locate_data_file bug24427_b2.brep] b2
mksurface s1 b1
mksurface s2 b2
bop b1 b2
bopsection ressec
explode ressec e
mkcurve rr ressec_1
puts "First test"
dlog reset
dlog on
xdistcs rr s1 0 1 100
set Log1 [dlog get]
set List1 [split ${Log1} {TD= \t\n}]
set L1 [llength ${List1}]
set L2 10
set L3 5
set N [expr (${L1} - ${L2})/${L3} + 1]
set Tolerance 1.0e-7
set D_good 0.
for {set i 1} {${i} <= ${N}} {incr i} {
set j1 [expr ${L2} + (${i}-1)*${L3}]
set j2 [expr ${j1} + 2]
set T [lindex ${List1} ${j1}]
set D [lindex ${List1} ${j2}]
puts "i=${i} j1=${j1} j2=${j2} T=${T} D=${D}"
if { [expr abs(${D} - ${D_good})] > ${Tolerance} } {
puts "Error: i=${i} T=${T} D=${D}"
}
}
puts "Second test"
dlog reset
dlog on
xdistcs rr s2 0 1 100
set Log2 [dlog get]
set List2 [split ${Log2} {TD= \t\n}]
set L1 [llength ${List2}]
set L2 10
set L3 5
set N [expr (${L1} - ${L2})/${L3} + 1]
set Tolerance 1.0e-7
set D_good 0.
for {set i 1} {${i} <= ${N}} {incr i} {
set j1 [expr ${L2} + (${i}-1)*${L3}]
set j2 [expr ${j1} + 2]
set T [lindex ${List2} ${j1}]
set D [lindex ${List2} ${j2}]
puts "i=${i} j1=${j1} j2=${j2} T=${T} D=${D}"
if { [expr abs(${D} - ${D_good})] > ${Tolerance} } {
puts "Error: i=${i} T=${T} D=${D}"
}
}
donly rr s1t s2t
smallview
fit
set only_screen_axo 1

79
tests/bugs/moddata_3/bug24427_2 Normal file
View File

@ -0,0 +1,79 @@
puts "========="
puts "CR24427"
puts "========="
puts ""
###############################
## Wrong section curves
###############################
restore [locate_data_file bug24427_b1.brep] b1
restore [locate_data_file bug24427_b2.brep] b2
mksurface s1 b1
mksurface s2 b2
trim s1t s1 0 3.1415926535897931 3.3684854563490672 3.9269908169872507
trim s2t s2 0 3.1415926535897931 -1.0598124096115453e-015 0.013271150216666670
intersect i s1t s2t
don s1t s2t i
puts "First test"
dlog reset
dlog on
xdistcs i s1 0 1 10
set Log1 [dlog get]
set List1 [split ${Log1} {TD= \t\n}]
set L1 [llength ${List1}]
set L2 10
set L3 5
set N [expr (${L1} - ${L2})/${L3} + 1]
set Tolerance 1.0e-7
set D_good 0.
for {set i 1} {${i} <= ${N}} {incr i} {
set j1 [expr ${L2} + (${i}-1)*${L3}]
set j2 [expr ${j1} + 2]
set T [lindex ${List1} ${j1}]
set D [lindex ${List1} ${j2}]
puts "i=${i} j1=${j1} j2=${j2} T=${T} D=${D}"
if { [expr abs(${D} - ${D_good})] > ${Tolerance} } {
puts "Error: i=${i} T=${T} D=${D}"
}
}
puts "Second test"
dlog reset
dlog on
xdistcs i s2 0 1 10
set Log2 [dlog get]
set List2 [split ${Log2} {TD= \t\n}]
set L1 [llength ${List2}]
set L2 10
set L3 5
set N [expr (${L1} - ${L2})/${L3} + 1]
set Tolerance 1.0e-7
set D_good 0.
for {set i 1} {${i} <= ${N}} {incr i} {
set j1 [expr ${L2} + (${i}-1)*${L3}]
set j2 [expr ${j1} + 2]
set T [lindex ${List2} ${j1}]
set D [lindex ${List2} ${j2}]
puts "i=${i} j1=${j1} j2=${j2} T=${T} D=${D}"
if { [expr abs(${D} - ${D_good})] > ${Tolerance} } {
puts "Error: i=${i} T=${T} D=${D}"
}
}
donly i s1t s2t
smallview
fit
set only_screen_axo 1