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

0026330: BRepOffsetAPI_ThruSections creates invalid shape

Browse Source 
Test case for issue CR26330
This commit is contained in:
ifv 2015-06-25 13:08:47 +03:00 committed by bugmaster
parent 539d3a1b7f
commit b77233473a
3 changed files with 276 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/BRep/BRep_Tool.cxx
View File

@ -337,22 +337,24 @@ Handle(Geom2d_Curve) BRep_Tool::CurveOnSurface(const TopoDS_Edge& E,
return nullPCurve; return nullPCurve;
} }
aCurveLocation = L.Predivided(aCurveLocation); aCurveLocation = aCurveLocation.Predivided(L);
First = f; Last = l; //Range of edge must not be modified
Handle(Geom_Plane) Plane = GP;
if (!aCurveLocation.IsIdentity()) if (!aCurveLocation.IsIdentity())
{ {
const gp_Trsf& T = aCurveLocation.Transformation(); const gp_Trsf& T = aCurveLocation.Transformation();
Handle(Geom_Geometry) GPT = GP->Transformed(T); Handle(Geom_Geometry) GC3d = C3d->Transformed(T);
Plane = *((Handle(Geom_Plane)*)&GPT); C3d = *((Handle(Geom_Curve)*)&GC3d);
f = C3d->TransformedParameter(f, T);
l = C3d->TransformedParameter(l, T);
} }
GeomAdaptor_Surface& GAS = HS->ChangeSurface(); GeomAdaptor_Surface& GAS = HS->ChangeSurface();
GAS.Load(Plane); GAS.Load(GP);
Handle(Geom_Curve) ProjOnPlane = Handle(Geom_Curve) ProjOnPlane =
GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d,f,l,Standard_True,Standard_False), GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d,f,l,Standard_True,Standard_False),
Plane, GP,
Plane->Position().Direction(), GP->Position().Direction(),
Standard_True); Standard_True);
GeomAdaptor_Curve& GAC = HC->ChangeCurve(); GeomAdaptor_Curve& GAC = HC->ChangeCurve();
@ -366,7 +368,7 @@ Handle(Geom2d_Curve) BRep_Tool::CurveOnSurface(const TopoDS_Edge& E,
(*((Handle(Geom2d_TrimmedCurve)*)&pc)); (*((Handle(Geom2d_TrimmedCurve)*)&pc));
pc = TC->BasisCurve(); pc = TC->BasisCurve();
} }
First = f; Last = l;
return pc; return pc;
} }

485
src/BRepCheck/BRepCheck_Edge.cxx
View File

@ -69,17 +69,17 @@
//modified by NIZNHY-PKV Thu May 05 09:01:57 2011f //modified by NIZNHY-PKV Thu May 05 09:01:57 2011f
static static
Standard_Boolean Validate(const Adaptor3d_Curve&, Standard_Boolean Validate(const Adaptor3d_Curve&,
const Adaptor3d_CurveOnSurface&, const Adaptor3d_CurveOnSurface&,
const Standard_Real, const Standard_Real,
const Standard_Boolean); const Standard_Boolean);
static static
void PrintProblematicPoint(const gp_Pnt&, void PrintProblematicPoint(const gp_Pnt&,
const Standard_Real, const Standard_Real,
const Standard_Real); const Standard_Real);
static static
Standard_Real Prec(const Adaptor3d_Curve& aAC3D, Standard_Real Prec(const Adaptor3d_Curve& aAC3D,
const Adaptor3d_CurveOnSurface& aACS); const Adaptor3d_CurveOnSurface& aACS);
static static
Standard_Real PrecCurve(const Adaptor3d_Curve& aAC3D); Standard_Real PrecCurve(const Adaptor3d_Curve& aAC3D);
static static
@ -125,27 +125,27 @@ void BRepCheck_Edge::Minimum()
Standard_Boolean unique = Standard_True; Standard_Boolean unique = Standard_True;
// Search for a 3D reference. If no existent one, creates it with the // Search for a 3D reference. If no existent one, creates it with the
// first encountered CurveOnSurf; if multiple, chooses the first one... // first encountered CurveOnSurf; if multiple, chooses the first one...
Standard_Boolean Degenerated = TE->Degenerated(); Standard_Boolean Degenerated = TE->Degenerated();
Standard_Boolean SameParameter = TE->SameParameter(); Standard_Boolean SameParameter = TE->SameParameter();
Standard_Boolean SameRange = TE->SameRange(); Standard_Boolean SameRange = TE->SameRange();
if (!SameRange && SameParameter) { if (!SameRange && SameParameter) {
BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag); BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
} }
// Handle(Geom_Curve) C3d; // Handle(Geom_Curve) C3d;
while (itcr.More()) { while (itcr.More()) {
const Handle(BRep_CurveRepresentation)& cr = itcr.Value(); const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
if (cr->IsCurve3D()) { if (cr->IsCurve3D()) {
if (!exist) { if (!exist) {
exist = Standard_True; exist = Standard_True;
} }
else { else {
unique = Standard_False; unique = Standard_False;
} }
if (myCref.IsNull() && !cr->Curve3D().IsNull()) { if (myCref.IsNull() && !cr->Curve3D().IsNull()) {
myCref = cr; myCref = cr;
} }
} }
itcr.Next(); itcr.Next();
} }
@ -161,12 +161,12 @@ void BRepCheck_Edge::Minimum()
if (myCref.IsNull() && !Degenerated) { if (myCref.IsNull() && !Degenerated) {
itcr.Initialize(TE->Curves()); itcr.Initialize(TE->Curves());
while (itcr.More()) { while (itcr.More()) {
const Handle(BRep_CurveRepresentation)& cr = itcr.Value(); const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
if (cr->IsCurveOnSurface()) { if (cr->IsCurveOnSurface()) {
myCref = cr; myCref = cr;
break; break;
} }
itcr.Next(); itcr.Next();
} }
} }
else if (!myCref.IsNull() && Degenerated){ else if (!myCref.IsNull() && Degenerated){
@ -178,32 +178,33 @@ void BRepCheck_Edge::Minimum()
Standard_Real First,Last; Standard_Real First,Last;
GCref->Range(First,Last); GCref->Range(First,Last);
if (Last<=First) { if (Last<=First) {
myCref.Nullify(); myCref.Nullify();
BRepCheck::Add(lst,BRepCheck_InvalidRange); BRepCheck::Add(lst,BRepCheck_InvalidRange);
} }
else { else {
if (myCref->IsCurve3D()) { if (myCref->IsCurve3D()) {
// eap 6 Jun 2002 occ332 // eap 6 Jun 2002 occ332
// better transform C3d instead of transforming Surf upto C3d initial location, // better transform C3d instead of transforming Surf upto C3d initial location,
// on transformed BSpline surface 'same parameter' may seem wrong // on transformed BSpline surface 'same parameter' may seem wrong
TopLoc_Location L = myShape.Location() * myCref->Location(); TopLoc_Location L = myShape.Location() * myCref->Location();
Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast
(myCref->Curve3D()->Transformed (myCref->Curve3D()->Transformed
(/*myCref->Location()*/L.Transformation())); (/*myCref->Location()*/L.Transformation()));
GeomAdaptor_Curve GAC3d(C3d,First,Last); GeomAdaptor_Curve GAC3d(C3d, C3d->TransformedParameter(First, L.Transformation()),
myHCurve = new GeomAdaptor_HCurve(GAC3d); C3d->TransformedParameter(Last, L.Transformation()));
} myHCurve = new GeomAdaptor_HCurve(GAC3d);
else { // curve on surface }
Handle(Geom_Surface) Sref = myCref->Surface(); else { // curve on surface
Sref = Handle(Geom_Surface)::DownCast Handle(Geom_Surface) Sref = myCref->Surface();
(Sref->Transformed(myCref->Location().Transformation())); Sref = Handle(Geom_Surface)::DownCast
const Handle(Geom2d_Curve)& PCref = myCref->PCurve(); (Sref->Transformed(myCref->Location().Transformation()));
Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref); const Handle(Geom2d_Curve)& PCref = myCref->PCurve();
Handle(Geom2dAdaptor_HCurve) GHPCref = Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref);
new Geom2dAdaptor_HCurve(PCref,First,Last); Handle(Geom2dAdaptor_HCurve) GHPCref =
Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref); new Geom2dAdaptor_HCurve(PCref,First,Last);
myHCurve = new Adaptor3d_HCurveOnSurface(ACSref); Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
} myHCurve = new Adaptor3d_HCurveOnSurface(ACSref);
}
} }
} }
if (lst.IsEmpty()) { if (lst.IsEmpty()) {
@ -232,7 +233,7 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
Standard_Real Tol = BRep_Tool::Tolerance(TopoDS::Edge(myShape)); Standard_Real Tol = BRep_Tool::Tolerance(TopoDS::Edge(myShape));
TopAbs_ShapeEnum styp = S.ShapeType(); TopAbs_ShapeEnum styp = S.ShapeType();
// for (TopExp_Explorer exp(S,TopAbs_EDGE); exp.More(); exp.Next()) { // for (TopExp_Explorer exp(S,TopAbs_EDGE); exp.More(); exp.Next()) {
TopExp_Explorer exp(S,TopAbs_EDGE) ; TopExp_Explorer exp(S,TopAbs_EDGE) ;
for ( ; exp.More(); exp.Next()) { for ( ; exp.More(); exp.Next()) {
if (exp.Current().IsSame(myShape)) { if (exp.Current().IsSame(myShape)) {
@ -243,7 +244,7 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
BRepCheck::Add(lst,BRepCheck_SubshapeNotInShape); BRepCheck::Add(lst,BRepCheck_SubshapeNotInShape);
return; return;
} }
switch (styp) switch (styp)
{ {
case TopAbs_WIRE: case TopAbs_WIRE:
@ -253,19 +254,19 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
case TopAbs_FACE: case TopAbs_FACE:
if (!myCref.IsNull()) { if (!myCref.IsNull()) {
Standard_Boolean SameParameter = TE->SameParameter(); Standard_Boolean SameParameter = TE->SameParameter();
Standard_Boolean SameRange = TE->SameRange(); Standard_Boolean SameRange = TE->SameRange();
// Modified by skv - Tue Apr 27 11:48:13 2004 Begin // Modified by skv - Tue Apr 27 11:48:13 2004 Begin
if (!SameParameter || !SameRange) { if (!SameParameter || !SameRange) {
if (!SameParameter) if (!SameParameter)
BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag); BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
if (!SameRange) if (!SameRange)
BRepCheck::Add(lst,BRepCheck_InvalidSameRangeFlag); BRepCheck::Add(lst,BRepCheck_InvalidSameRangeFlag);
return; return;
} }
// Modified by skv - Tue Apr 27 11:48:14 2004 End // Modified by skv - Tue Apr 27 11:48:14 2004 End
Standard_Real First = myHCurve->FirstParameter(); Standard_Real First = myHCurve->FirstParameter();
Standard_Real Last = myHCurve->LastParameter(); Standard_Real Last = myHCurve->LastParameter();
@ -274,121 +275,125 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
const TopLoc_Location& TFloc = TF->Location(); const TopLoc_Location& TFloc = TF->Location();
const Handle(Geom_Surface)& Su = TF->Surface(); const Handle(Geom_Surface)& Su = TF->Surface();
TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location()); TopLoc_Location L = (Floc * TFloc).Predivided(myShape.Location());
TopLoc_Location LE = myShape.Location() * myCref->Location();
const gp_Trsf& Etrsf = LE.Transformation();
Standard_Boolean pcurvefound = Standard_False; Standard_Boolean pcurvefound = Standard_False;
BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves()); BRep_ListIteratorOfListOfCurveRepresentation itcr(TE->Curves());
while (itcr.More()) { while (itcr.More()) {
const Handle(BRep_CurveRepresentation)& cr = itcr.Value(); const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
if (cr != myCref && cr->IsCurveOnSurface(Su,L)) { if (cr != myCref && cr->IsCurveOnSurface(Su,L)) {
pcurvefound = Standard_True; pcurvefound = Standard_True;
const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr); const Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
Standard_Real f,l; Standard_Real f,l;
GC->Range(f,l); GC->Range(f,l);
Standard_Real ff = f, ll = l;
if(myCref->IsCurve3D())
{
ff = myCref->Curve3D()->TransformedParameter(f, Etrsf);
ll = myCref->Curve3D()->TransformedParameter(l, Etrsf);
}
// gka OCC // gka OCC
// Modified by skv - Tue Apr 27 11:50:35 2004 Begin // Modified by skv - Tue Apr 27 11:50:35 2004 Begin
// if (SameRange && (fabs(f-First) > Precision::PConfusion() || fabs(l-Last)> Precision::PConfusion())) { //f != First || l != Last)) { gka OCC if (Abs(ff-First) > Precision::PConfusion() ||
if (Abs(f-First) > Precision::PConfusion() || Abs(ll-Last) > Precision::PConfusion()) {
Abs(l-Last) > Precision::PConfusion()) { BRepCheck::Add(lst,BRepCheck_InvalidSameRangeFlag);
BRepCheck::Add(lst,BRepCheck_InvalidSameRangeFlag); BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag); }
// if (SameParameter) { // Modified by skv - Tue Apr 27 11:50:37 2004 End
// BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag); if (myGctrl) {
// } Handle(Geom_Surface) Sb = cr->Surface();
} Sb = Handle(Geom_Surface)::DownCast
// Modified by skv - Tue Apr 27 11:50:37 2004 End // (Su->Transformed(L.Transformation()));
if (myGctrl) { (Su->Transformed(/*L*/(Floc * TFloc).Transformation()));
Handle(Geom_Surface) Sb = cr->Surface(); Handle(Geom2d_Curve) PC = cr->PCurve();
Sb = Handle(Geom_Surface)::DownCast Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(Sb);
// (Su->Transformed(L.Transformation())); Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve(PC,f,l);
(Su->Transformed(/*L*/(Floc * TFloc).Transformation())); Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
Handle(Geom2d_Curve) PC = cr->PCurve(); Standard_Boolean ok =
Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(Sb); Validate(myHCurve->Curve() ,ACS,Tol,SameParameter);
Handle(Geom2dAdaptor_HCurve) GHPC = new Geom2dAdaptor_HCurve(PC,f,l); if (!ok) {
Adaptor3d_CurveOnSurface ACS(GHPC,GAHS); if (cr->IsCurveOnClosedSurface()) {
Standard_Boolean ok = BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
Validate(myHCurve->Curve(),ACS,Tol,SameParameter); }
if (!ok) { else {
if (cr->IsCurveOnClosedSurface()) { BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface); }
} // Modified by skv - Tue Apr 27 11:53:00 2004 Begin
else { BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface); // if (SameParameter) {
} // BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
// Modified by skv - Tue Apr 27 11:53:00 2004 Begin // }
BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag); // Modified by skv - Tue Apr 27 11:53:01 2004 End
// if (SameParameter) { }
// BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag); if (cr->IsCurveOnClosedSurface()) {
// } GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds
// Modified by skv - Tue Apr 27 11:53:01 2004 End ACS.Load(GAHS); // sans doute inutile
} ACS.Load(GHPC); // meme remarque...
if (cr->IsCurveOnClosedSurface()) { ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter);
GHPC->ChangeCurve2d().Load(cr->PCurve2(),f,l); // same bounds if (!ok) {
ACS.Load(GAHS); // sans doute inutile BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface);
ACS.Load(GHPC); // meme remarque... // Modified by skv - Tue Apr 27 11:53:20 2004 Begin
ok = Validate(myHCurve->Curve(),ACS,Tol,SameParameter); if (SameParameter) {
if (!ok) { BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag);
BRepCheck::Add(lst,BRepCheck_InvalidCurveOnClosedSurface); }
// Modified by skv - Tue Apr 27 11:53:20 2004 Begin // Modified by skv - Tue Apr 27 11:53:23 2004 End
if (SameParameter) { }
BRepCheck::Add(lst,BRepCheck_InvalidSameParameterFlag); }
} }
// Modified by skv - Tue Apr 27 11:53:23 2004 End }
} itcr.Next();
}
}
}
itcr.Next();
} }
if (!pcurvefound) { if (!pcurvefound) {
Handle(Geom_Plane) P; Handle(Geom_Plane) P;
Handle(Standard_Type) dtyp = Su->DynamicType(); Handle(Standard_Type) dtyp = Su->DynamicType();
if (dtyp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) { if (dtyp == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
P = Handle(Geom_Plane)::DownCast P = Handle(Geom_Plane)::DownCast
(Handle(Geom_RectangularTrimmedSurface):: (Handle(Geom_RectangularTrimmedSurface)::
DownCast(Su)->BasisSurface()); DownCast(Su)->BasisSurface());
} }
else { else {
P = Handle(Geom_Plane)::DownCast(Su); P = Handle(Geom_Plane)::DownCast(Su);
} }
if (P.IsNull()) { // not a plane if (P.IsNull()) { // not a plane
BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface); BRepCheck::Add(lst,BRepCheck_NoCurveOnSurface);
} }
else { // on fait la projection a la volee, comme BRep_Tool else { // on fait la projection a la volee, comme BRep_Tool
// plan en position // plan en position
if (myGctrl) { if (myGctrl) {
P = Handle(Geom_Plane):: P = Handle(Geom_Plane)::
DownCast(P->Transformed(/*L*/(Floc * TFloc).Transformation()));// eap occ332 DownCast(P->Transformed(/*L*/(Floc * TFloc).Transformation()));// eap occ332
//on projette Cref sur ce plan //on projette Cref sur ce plan
Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P); Handle(GeomAdaptor_HSurface) GAHS = new GeomAdaptor_HSurface(P);
// Dub - Normalement myHCurve est une GeomAdaptor_HCurve // Dub - Normalement myHCurve est une GeomAdaptor_HCurve
GeomAdaptor_Curve& Gac = GeomAdaptor_Curve& Gac =
Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve(); Handle(GeomAdaptor_HCurve)::DownCast(myHCurve)->ChangeCurve();
Handle(Geom_Curve) C3d = Gac.Curve(); Handle(Geom_Curve) C3d = Gac.Curve();
Handle(Geom_Curve) ProjOnPlane = Handle(Geom_Curve) ProjOnPlane =
GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d,First,Last), GeomProjLib::ProjectOnPlane(new Geom_TrimmedCurve(C3d,First,Last),
P, P->Position().Direction(), P, P->Position().Direction(),
Standard_True); Standard_True);
Handle(GeomAdaptor_HCurve) aHCurve = Handle(GeomAdaptor_HCurve) aHCurve =
new GeomAdaptor_HCurve(ProjOnPlane); new GeomAdaptor_HCurve(ProjOnPlane);
ProjLib_ProjectedCurve proj(GAHS,aHCurve); ProjLib_ProjectedCurve proj(GAHS,aHCurve);
Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj); Handle(Geom2d_Curve) PC = Geom2dAdaptor::MakeCurve(proj);
Handle(Geom2dAdaptor_HCurve) GHPC = Handle(Geom2dAdaptor_HCurve) GHPC =
new Geom2dAdaptor_HCurve(PC, new Geom2dAdaptor_HCurve(PC,
myHCurve->FirstParameter(), myHCurve->FirstParameter(),
myHCurve->LastParameter()); myHCurve->LastParameter());
Adaptor3d_CurveOnSurface ACS(GHPC,GAHS); Adaptor3d_CurveOnSurface ACS(GHPC,GAHS);
Standard_Boolean ok = Validate(myHCurve->Curve(),ACS, Standard_Boolean ok = Validate(myHCurve->Curve(),ACS,
Tol,Standard_True); // voir dub... Tol,Standard_True); // voir dub...
if (!ok) { if (!ok) {
BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface); BRepCheck::Add(lst,BRepCheck_InvalidCurveOnSurface);
} }
} }
} }
} }
} }
break; break;
@ -398,22 +403,22 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
Standard_Integer nbconnection = 0; Standard_Integer nbconnection = 0;
//TopExp_Explorer exp; //TopExp_Explorer exp;
for (exp.Init(S,TopAbs_FACE); exp.More(); exp.Next()) { for (exp.Init(S,TopAbs_FACE); exp.More(); exp.Next()) {
const TopoDS_Face& fac = TopoDS::Face(exp.Current()); const TopoDS_Face& fac = TopoDS::Face(exp.Current());
TopExp_Explorer exp2; TopExp_Explorer exp2;
for (exp2.Init(fac,TopAbs_EDGE); exp2.More(); exp2.Next()) { for (exp2.Init(fac,TopAbs_EDGE); exp2.More(); exp2.Next()) {
if (exp2.Current().IsSame(myShape)) { if (exp2.Current().IsSame(myShape)) {
nbconnection++; nbconnection++;
} }
} }
} }
if (nbconnection < 2 && !TE->Degenerated()) { if (nbconnection < 2 && !TE->Degenerated()) {
BRepCheck::Add(myMap(S),BRepCheck_FreeEdge); BRepCheck::Add(myMap(S),BRepCheck_FreeEdge);
} }
else if (nbconnection > 2) { else if (nbconnection > 2) {
BRepCheck::Add(myMap(S),BRepCheck_InvalidMultiConnexity); BRepCheck::Add(myMap(S),BRepCheck_InvalidMultiConnexity);
} }
else { else {
BRepCheck::Add(myMap(S),BRepCheck_NoError); BRepCheck::Add(myMap(S),BRepCheck_NoError);
} }
} }
break; break;
@ -433,12 +438,12 @@ void BRepCheck_Edge::InContext(const TopoDS_Shape& S)
void BRepCheck_Edge::Blind() void BRepCheck_Edge::Blind()
{ {
// Modified by skv - Tue Apr 27 11:36:01 2004 Begin // Modified by skv - Tue Apr 27 11:36:01 2004 Begin
// The body of this function is removed because of its useless. // The body of this function is removed because of its useless.
if (!myBlind) { if (!myBlind) {
myBlind = Standard_True; myBlind = Standard_True;
} }
// Modified by skv - Tue Apr 27 11:36:02 2004 End // Modified by skv - Tue Apr 27 11:36:02 2004 End
} }
@ -469,7 +474,7 @@ Standard_Boolean BRepCheck_Edge::GeometricControls() const
//======================================================================= //=======================================================================
void BRepCheck_Edge::SetStatus(const BRepCheck_Status theStatus) void BRepCheck_Edge::SetStatus(const BRepCheck_Status theStatus)
{ {
BRepCheck::Add(myMap(myShape),theStatus); BRepCheck::Add(myMap(myShape),theStatus);
} }
@ -502,13 +507,13 @@ Standard_Real BRepCheck_Edge::Tolerance()
//// modified by jgv, 20.03.03 //// //// modified by jgv, 20.03.03 ////
TopLoc_Location Loc = myShape.Location() * cr->Location(); TopLoc_Location Loc = myShape.Location() * cr->Location();
Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast Handle(Geom_Curve) C3d = Handle(Geom_Curve)::DownCast
(cr->Curve3D()->Transformed( Loc.Transformation() )); (cr->Curve3D()->Transformed( Loc.Transformation() ));
/////////////////////////////////// ///////////////////////////////////
GeomAdaptor_Curve GAC3d(C3d,First,Last); GeomAdaptor_Curve GAC3d(C3d,First,Last);
it=iRep; it=iRep;
if (iRep>1) { if (iRep>1) {
theRep(iRep)=theRep(1); theRep(iRep)=theRep(1);
it=1; it=1;
} }
theRep(it) = new GeomAdaptor_HCurve(GAC3d); theRep(it) = new GeomAdaptor_HCurve(GAC3d);
iRep++; iRep++;
@ -516,11 +521,11 @@ Standard_Real BRepCheck_Edge::Tolerance()
else if (cr->IsCurveOnSurface()) { else if (cr->IsCurveOnSurface()) {
{ {
Handle(Geom_Surface) Sref = cr->Surface(); Handle(Geom_Surface) Sref = cr->Surface();
//// modified by jgv, 20.03.03 //// //// modified by jgv, 20.03.03 ////
TopLoc_Location Loc = myShape.Location() * cr->Location(); TopLoc_Location Loc = myShape.Location() * cr->Location();
Sref = Handle(Geom_Surface)::DownCast Sref = Handle(Geom_Surface)::DownCast
(Sref->Transformed( Loc.Transformation() )); (Sref->Transformed( Loc.Transformation() ));
/////////////////////////////////// ///////////////////////////////////
const Handle(Geom2d_Curve)& PCref = cr->PCurve(); const Handle(Geom2d_Curve)& PCref = cr->PCurve();
Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref); Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref);
Handle(Geom2dAdaptor_HCurve) GHPCref = Handle(Geom2dAdaptor_HCurve) GHPCref =
@ -530,17 +535,17 @@ Standard_Real BRepCheck_Edge::Tolerance()
iRep++; iRep++;
} }
if (cr->IsCurveOnClosedSurface()) { if (cr->IsCurveOnClosedSurface()) {
Handle(Geom_Surface) Sref = cr->Surface(); Handle(Geom_Surface) Sref = cr->Surface();
Sref = Handle(Geom_Surface)::DownCast Sref = Handle(Geom_Surface)::DownCast
(Sref->Transformed(cr->Location().Transformation())); (Sref->Transformed(cr->Location().Transformation()));
const Handle(Geom2d_Curve)& PCref = cr->PCurve2(); const Handle(Geom2d_Curve)& PCref = cr->PCurve2();
Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref); Handle(GeomAdaptor_HSurface) GAHSref = new GeomAdaptor_HSurface(Sref);
Handle(Geom2dAdaptor_HCurve) GHPCref = Handle(Geom2dAdaptor_HCurve) GHPCref =
new Geom2dAdaptor_HCurve(PCref,First,Last); new Geom2dAdaptor_HCurve(PCref,First,Last);
Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref); Adaptor3d_CurveOnSurface ACSref(GHPCref,GAHSref);
theRep(iRep) = new Adaptor3d_HCurveOnSurface(ACSref); theRep(iRep) = new Adaptor3d_HCurveOnSurface(ACSref);
iRep++; iRep++;
nbRep++; nbRep++;
} }
} }
else { else {
@ -574,10 +579,10 @@ Standard_Real BRepCheck_Edge::Tolerance()
//purpose : //purpose :
//======================================================================= //=======================================================================
BRepCheck_Status BRepCheck_Edge:: BRepCheck_Status BRepCheck_Edge::
CheckPolygonOnTriangulation(const TopoDS_Edge& theEdge) CheckPolygonOnTriangulation(const TopoDS_Edge& theEdge)
{ {
BRep_ListOfCurveRepresentation& aListOfCR = BRep_ListOfCurveRepresentation& aListOfCR =
(*((Handle(BRep_TEdge)*) &theEdge.TShape()))->ChangeCurves(); (*((Handle(BRep_TEdge)*) &theEdge.TShape()))->ChangeCurves();
BRep_ListIteratorOfListOfCurveRepresentation anITCR(aListOfCR); BRep_ListIteratorOfListOfCurveRepresentation anITCR(aListOfCR);
BRepAdaptor_Curve aBC; BRepAdaptor_Curve aBC;
@ -596,30 +601,30 @@ BRepCheck_Status BRepCheck_Edge::
const Handle(BRep_CurveRepresentation) aCR = anITCR.Value(); const Handle(BRep_CurveRepresentation) aCR = anITCR.Value();
const Handle(BRep_PolygonOnTriangulation)& aPT = const Handle(BRep_PolygonOnTriangulation)& aPT =
Handle(BRep_PolygonOnTriangulation)::DownCast(aCR); Handle(BRep_PolygonOnTriangulation)::DownCast(aCR);
const TopLoc_Location aLL = theEdge.Location() * aPT->Location(); const TopLoc_Location aLL = theEdge.Location() * aPT->Location();
const Handle(Poly_Triangulation) aTriang = aCR->Triangulation(); const Handle(Poly_Triangulation) aTriang = aCR->Triangulation();
const Handle(Poly_PolygonOnTriangulation) aPOnTriag = const Handle(Poly_PolygonOnTriangulation) aPOnTriag =
aCR->IsPolygonOnClosedTriangulation() ? aCR->IsPolygonOnClosedTriangulation() ?
aCR->PolygonOnTriangulation2() : aCR->PolygonOnTriangulation2() :
aCR->PolygonOnTriangulation(); aCR->PolygonOnTriangulation();
const TColStd_Array1OfInteger& anIndices = aPOnTriag->Nodes(); const TColStd_Array1OfInteger& anIndices = aPOnTriag->Nodes();
const TColgp_Array1OfPnt& Nodes = aTriang->Nodes(); const TColgp_Array1OfPnt& Nodes = aTriang->Nodes();
const Standard_Integer aNbNodes = anIndices.Length(); const Standard_Integer aNbNodes = anIndices.Length();
const Standard_Real aTol = aPOnTriag->Deflection() + const Standard_Real aTol = aPOnTriag->Deflection() +
BRep_Tool::Tolerance(theEdge); BRep_Tool::Tolerance(theEdge);
if(aPOnTriag->HasParameters()) if(aPOnTriag->HasParameters())
{ {
for(Standard_Integer i = aPOnTriag->Parameters()->Lower(); for(Standard_Integer i = aPOnTriag->Parameters()->Lower();
i <= aPOnTriag->Parameters()->Upper(); i++) i <= aPOnTriag->Parameters()->Upper(); i++)
{ {
const Standard_Real aParam = aPOnTriag->Parameters()->Value(i); const Standard_Real aParam = aPOnTriag->Parameters()->Value(i);
const gp_Pnt aPE(aBC.Value(aParam)), const gp_Pnt aPE(aBC.Value(aParam)),
aPT(Nodes(anIndices(i)).Transformed(aLL)); aPT(Nodes(anIndices(i)).Transformed(aLL));
const Standard_Real aSQDist = aPE.SquareDistance(aPT); const Standard_Real aSQDist = aPE.SquareDistance(aPT);
if(aSQDist > aTol*aTol) if(aSQDist > aTol*aTol)
@ -681,9 +686,9 @@ BRepCheck_Status BRepCheck_Edge::
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean Validate(const Adaptor3d_Curve& CRef, Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
const Adaptor3d_CurveOnSurface& Other, const Adaptor3d_CurveOnSurface& Other,
const Standard_Real Tol, const Standard_Real Tol,
const Standard_Boolean SameParameter) const Standard_Boolean SameParameter)
{ {
Standard_Boolean Status, proj; Standard_Boolean Status, proj;
Standard_Real aPC, First, Last, Error; Standard_Real aPC, First, Last, Error;
@ -693,11 +698,11 @@ Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
Error = 0.; Error = 0.;
First = CRef.FirstParameter(); First = CRef.FirstParameter();
Last = CRef.LastParameter(); Last = CRef.LastParameter();
aPC=Precision::PConfusion(); aPC=Precision::PConfusion();
proj = (!SameParameter || proj = (!SameParameter ||
Abs(Other.FirstParameter()-First) > aPC || Abs(Other.FirstParameter()-First) > aPC ||
Abs( Other.LastParameter()-Last) > aPC); Abs( Other.LastParameter()-Last) > aPC);
if (!proj) if (!proj)
{ {
Standard_Integer i; Standard_Integer i;
@ -710,17 +715,17 @@ Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
Tol2=Tol2*Tol2; Tol2=Tol2*Tol2;
//Tol2=Tol*Tol; //Tol2=Tol*Tol;
//modified by NIZNHY-PKV Thu May 05 09:06:47 2011t //modified by NIZNHY-PKV Thu May 05 09:06:47 2011t
for (i = 0; i < NCONTROL; ++i) { for (i = 0; i < NCONTROL; ++i) {
prm = ((NCONTROL-1-i)*First + i*Last)/(NCONTROL-1); prm = ((NCONTROL-1-i)*First + i*Last)/(NCONTROL-1);
pref = CRef.Value(prm); pref = CRef.Value(prm);
pother = Other.Value(prm); pother = Other.Value(prm);
if (pref.SquareDistance(pother) > Tol2) { if (pref.SquareDistance(pother) > Tol2) {
problematic_point = pref ; problematic_point = pref ;
Status = Standard_False; Status = Standard_False;
Error = pref.Distance(pother); Error = pref.Distance(pother);
PrintProblematicPoint(problematic_point, Error, Tol); PrintProblematicPoint(problematic_point, Error, Tol);
return Status; return Status;
//goto FINISH ; //goto FINISH ;
} }
} }
@ -761,44 +766,44 @@ Standard_Boolean Validate(const Adaptor3d_Curve& CRef,
gp_Pnt pother = Other.Value(oprm); gp_Pnt pother = Other.Value(oprm);
refd.Perform(pother,rprm); refd.Perform(pother,rprm);
if (!refd.IsDone() || refd.SquareDistance() > Tol * Tol) { if (!refd.IsDone() || refd.SquareDistance() > Tol * Tol) {
problematic_point = pref ; problematic_point = pref ;
Status = Standard_False ; Status = Standard_False ;
if (refd.IsDone()) { if (refd.IsDone()) {
Error = sqrt (refd.SquareDistance()); Error = sqrt (refd.SquareDistance());
} }
else { else {
Error = RealLast(); Error = RealLast();
} }
PrintProblematicPoint(problematic_point, Error, Tol); PrintProblematicPoint(problematic_point, Error, Tol);
return Status; return Status;
//goto FINISH ; //goto FINISH ;
} }
otherd.Perform(pref,oprm); otherd.Perform(pref,oprm);
if (!otherd.IsDone() || otherd.SquareDistance() > Tol * Tol) { if (!otherd.IsDone() || otherd.SquareDistance() > Tol * Tol) {
problematic_point = pref ; problematic_point = pref ;
Status = Standard_False ; Status = Standard_False ;
if (otherd.IsDone()) { if (otherd.IsDone()) {
Error = sqrt (otherd.SquareDistance()); Error = sqrt (otherd.SquareDistance());
} }
else { else {
Error = RealLast(); Error = RealLast();
} }
PrintProblematicPoint(problematic_point, Error, Tol); PrintProblematicPoint(problematic_point, Error, Tol);
return Status; return Status;
//goto FINISH ; //goto FINISH ;
} }
} }
} }
return Status ; return Status ;
} }
//======================================================================= //=======================================================================
//function : Prec //function : Prec
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Real Prec(const Adaptor3d_Curve& aAC3D, Standard_Real Prec(const Adaptor3d_Curve& aAC3D,
const Adaptor3d_CurveOnSurface& aACS) const Adaptor3d_CurveOnSurface& aACS)
{ {
Standard_Real aXEmax, aXC, aXS; Standard_Real aXEmax, aXC, aXS;
// //
@ -830,11 +835,11 @@ Standard_Real PrecCurve(const Adaptor3d_Curve& aAC3D)
aXEmax=-1.; aXEmax=-1.;
for (i=0; i<5; ++i) { for (i=0; i<5; ++i) {
if (aX[i]<0.) { if (aX[i]<0.) {
aX[i]=-aX[i]; aX[i]=-aX[i];
} }
aXE=Epsilon(aX[i]); aXE=Epsilon(aX[i]);
if (aXE>aXEmax) { if (aXE>aXEmax) {
aXEmax=aXE; aXEmax=aXE;
} }
} }
}//if (aCT=GeomAbs_Ellipse) { }//if (aCT=GeomAbs_Ellipse) {
@ -864,11 +869,11 @@ Standard_Real PrecSurface(const Adaptor3d_CurveOnSurface& aACS)
aXEmax=-1.; aXEmax=-1.;
for (i=0; i<4; ++i) { for (i=0; i<4; ++i) {
if (aX[i]<0.) { if (aX[i]<0.) {
aX[i]=-aX[i]; aX[i]=-aX[i];
} }
aXE=Epsilon(aX[i]); aXE=Epsilon(aX[i]);
if (aXE>aXEmax) { if (aXE>aXEmax) {
aXEmax=aXE; aXEmax=aXE;
} }
} }
}//if (aST==GeomAbs_Cone) { }//if (aST==GeomAbs_Cone) {
@ -880,8 +885,8 @@ Standard_Real PrecSurface(const Adaptor3d_CurveOnSurface& aACS)
//======================================================================= //=======================================================================
#ifdef OCCT_DEBUG #ifdef OCCT_DEBUG
void PrintProblematicPoint(const gp_Pnt& problematic_point, void PrintProblematicPoint(const gp_Pnt& problematic_point,
const Standard_Real Error, const Standard_Real Error,
const Standard_Real Tol) const Standard_Real Tol)
{ {
cout << " **** probleme de SameParameter au point :" << endl; cout << " **** probleme de SameParameter au point :" << endl;
cout << " " << problematic_point.Coord(1) << " " cout << " " << problematic_point.Coord(1) << " "
@ -890,8 +895,8 @@ void PrintProblematicPoint(const gp_Pnt& problematic_point,
} }
#else #else
void PrintProblematicPoint(const gp_Pnt&, void PrintProblematicPoint(const gp_Pnt&,
const Standard_Real, const Standard_Real,
const Standard_Real) const Standard_Real)
{ {
} }
#endif #endif

21
tests/bugs/modalg_6/bug26330 Normal file
View File

@ -0,0 +1,21 @@
puts "=========="
puts "OCC26330"
puts "=========="
puts ""
############################################################
# BRepOffsetAPI_ThruSections creates invalid shape
############################################################
restore [locate_data_file bug26330_s1.brep] s1
restore [locate_data_file bug26330_s2.brep] s2
# both wires seem okay
checkshape s1
checkshape s2
thrusections result 1 1 s1 s2
# check subshapes
checkshape result
set 3dviewer 1