mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-09 18:50:54 +03:00
0032809: Sweep algorithm with Round Corner mode failed
Fix indentation within GeomFill_Sweep.cxx 0032809: Sweep algorithm with Round Corner mode failed Add fix what repair shipping at corner after circle edge at path Add fix test for bug 24909_3
This commit is contained in:
azv
smoskvin
parent
5078d0d84e
commit
a793b75e21
@ -861,7 +861,8 @@ static Standard_Boolean Filling(const TopoDS_Shape& EF,
|
||||
Prof2 = BRep_Tool::Curve(E2, f2, l2);
|
||||
|
||||
// Indeed, both Prof1 and Prof2 are the same curves but in different positions
|
||||
|
||||
// Prof1's param domain may equals to Prof2's param domain *(-1), which means EF.Orientation() == EL.Orientation()
|
||||
Standard_Boolean bSameCurveDomain = EF.Orientation() != EL.Orientation();
|
||||
gp_Pnt P1, P2, P;
|
||||
|
||||
// Choose the angle of opening
|
||||
@ -887,7 +888,8 @@ static Standard_Boolean Filling(const TopoDS_Shape& EF,
|
||||
}
|
||||
}
|
||||
|
||||
const gp_Pnt aP2 = Prof2->Value(aPrm[aMaxIdx]).Transformed(aTf);
|
||||
const Standard_Real aPrm2[] = { f2, 0.5*(f2 + l2), l2 };
|
||||
const gp_Pnt aP2 = Prof2->Value(aPrm2[bSameCurveDomain ? aMaxIdx : 2 - aMaxIdx]).Transformed(aTf);
|
||||
const gp_Vec2d aV1(aP1[aMaxIdx].Z(), aP1[aMaxIdx].X());
|
||||
const gp_Vec2d aV2(aP2.Z(), aP2.X());
|
||||
if (aV1.SquareMagnitude() <= gp::Resolution() ||
|
||||
|
||||
@ -76,29 +76,29 @@
|
||||
//=======================================================================
|
||||
class GeomFill_Sweep_Eval : public AdvApprox_EvaluatorFunction
|
||||
{
|
||||
public:
|
||||
GeomFill_Sweep_Eval (GeomFill_LocFunction& theTool)
|
||||
public:
|
||||
GeomFill_Sweep_Eval(GeomFill_LocFunction& theTool)
|
||||
: theAncore(theTool) {}
|
||||
|
||||
virtual void Evaluate (Standard_Integer *Dimension,
|
||||
virtual void Evaluate(Standard_Integer *Dimension,
|
||||
Standard_Real StartEnd[2],
|
||||
Standard_Real *Parameter,
|
||||
Standard_Integer *DerivativeRequest,
|
||||
Standard_Real *Result, // [Dimension]
|
||||
Standard_Integer *ErrorCode);
|
||||
|
||||
private:
|
||||
private:
|
||||
GeomFill_LocFunction& theAncore;
|
||||
};
|
||||
|
||||
void GeomFill_Sweep_Eval::Evaluate (Standard_Integer *,/*Dimension*/
|
||||
void GeomFill_Sweep_Eval::Evaluate(Standard_Integer *,/*Dimension*/
|
||||
Standard_Real StartEnd[2],
|
||||
Standard_Real *Parameter,
|
||||
Standard_Integer *DerivativeRequest,
|
||||
Standard_Real *Result,// [Dimension]
|
||||
Standard_Integer *ErrorCode)
|
||||
{
|
||||
theAncore.DN (*Parameter,
|
||||
theAncore.DN(*Parameter,
|
||||
StartEnd[0],
|
||||
StartEnd[1],
|
||||
*DerivativeRequest,
|
||||
@ -129,7 +129,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function : SetDomain
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
void GeomFill_Sweep::SetDomain(const Standard_Real LocFirst,
|
||||
void GeomFill_Sweep::SetDomain(const Standard_Real LocFirst,
|
||||
const Standard_Real LocLast,
|
||||
const Standard_Real SectionFirst,
|
||||
const Standard_Real SectionLast)
|
||||
@ -144,14 +144,14 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function : SetTolerance
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
void GeomFill_Sweep::SetTolerance(const Standard_Real Tolerance3d,
|
||||
void GeomFill_Sweep::SetTolerance(const Standard_Real Tolerance3d,
|
||||
const Standard_Real BoundTolerance,
|
||||
const Standard_Real Tolerance2d,
|
||||
const Standard_Real ToleranceAngular)
|
||||
{
|
||||
Tol3d = Tolerance3d;
|
||||
BoundTol = BoundTolerance;
|
||||
Tol2d =Tolerance2d;
|
||||
Tol2d = Tolerance2d;
|
||||
TolAngular = ToleranceAngular;
|
||||
}
|
||||
|
||||
@ -161,7 +161,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// a C1-continuous surface if a swept surface proved
|
||||
// to be C0.
|
||||
//=======================================================================
|
||||
void GeomFill_Sweep::SetForceApproxC1(const Standard_Boolean ForceApproxC1)
|
||||
void GeomFill_Sweep::SetForceApproxC1(const Standard_Boolean ForceApproxC1)
|
||||
{
|
||||
myForceApproxC1 = ForceApproxC1;
|
||||
}
|
||||
@ -171,7 +171,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function : ExchangeUV
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Standard_Boolean GeomFill_Sweep::ExchangeUV() const
|
||||
Standard_Boolean GeomFill_Sweep::ExchangeUV() const
|
||||
{
|
||||
return myExchUV;
|
||||
}
|
||||
@ -180,7 +180,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function : UReversed
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Standard_Boolean GeomFill_Sweep::UReversed() const
|
||||
Standard_Boolean GeomFill_Sweep::UReversed() const
|
||||
{
|
||||
return isUReversed;
|
||||
}
|
||||
@ -189,7 +189,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function : VReversed
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Standard_Boolean GeomFill_Sweep::VReversed() const
|
||||
Standard_Boolean GeomFill_Sweep::VReversed() const
|
||||
{
|
||||
return isVReversed;
|
||||
}
|
||||
@ -198,7 +198,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function : Build
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
void GeomFill_Sweep::Build(const Handle(GeomFill_SectionLaw)& Section,
|
||||
void GeomFill_Sweep::Build(const Handle(GeomFill_SectionLaw)& Section,
|
||||
const GeomFill_ApproxStyle Methode,
|
||||
const GeomAbs_Shape Continuity,
|
||||
const Standard_Integer Degmax,
|
||||
@ -230,7 +230,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
if ((!isKPart) && (Methode == GeomFill_Location)) {
|
||||
Handle(Geom_BSplineSurface) BS;
|
||||
BS = mySec->BSplineSurface();
|
||||
if (! BS.IsNull()) {
|
||||
if (!BS.IsNull()) {
|
||||
// Approx de la loi
|
||||
// isProduct = BuildProduct(Continuity, Degmax, Segmax);
|
||||
}
|
||||
@ -250,12 +250,9 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function ::Build2d
|
||||
// Purpose :A venir...
|
||||
//===============================================================
|
||||
// Standard_Boolean GeomFill_Sweep::Build2d(const GeomAbs_Shape Continuity,
|
||||
Standard_Boolean GeomFill_Sweep::Build2d(const GeomAbs_Shape ,
|
||||
// const Standard_Integer Degmax,
|
||||
const Standard_Integer ,
|
||||
// const Standard_Integer Segmax)
|
||||
const Standard_Integer )
|
||||
Standard_Boolean GeomFill_Sweep::Build2d(const GeomAbs_Shape,
|
||||
const Standard_Integer,
|
||||
const Standard_Integer)
|
||||
{
|
||||
Standard_Boolean Ok = Standard_False;
|
||||
if (myLoc->Nb2dCurves() == 0) {
|
||||
@ -268,7 +265,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function : BuildAll
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Standard_Boolean GeomFill_Sweep::BuildAll(const GeomAbs_Shape Continuity,
|
||||
Standard_Boolean GeomFill_Sweep::BuildAll(const GeomAbs_Shape Continuity,
|
||||
const Standard_Integer Degmax,
|
||||
const Standard_Integer Segmax)
|
||||
{
|
||||
@ -276,8 +273,8 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
|
||||
Handle(GeomFill_SweepFunction) Func
|
||||
= new (GeomFill_SweepFunction) (mySec, myLoc, First, SFirst,
|
||||
(SLast-SFirst)/(Last-First) );
|
||||
Approx_SweepApproximation Approx( Func );
|
||||
(SLast - SFirst) / (Last - First));
|
||||
Approx_SweepApproximation Approx(Func);
|
||||
|
||||
Approx.Perform(First, Last,
|
||||
Tol3d, BoundTol, Tol2d, TolAngular,
|
||||
@ -291,27 +288,27 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
#endif
|
||||
|
||||
// La surface
|
||||
Standard_Integer UDegree,VDegree,NbUPoles,
|
||||
NbVPoles,NbUKnots,NbVKnots;
|
||||
Approx.SurfShape(UDegree,VDegree,NbUPoles,
|
||||
NbVPoles,NbUKnots,NbVKnots);
|
||||
Standard_Integer UDegree, VDegree, NbUPoles,
|
||||
NbVPoles, NbUKnots, NbVKnots;
|
||||
Approx.SurfShape(UDegree, VDegree, NbUPoles,
|
||||
NbVPoles, NbUKnots, NbVKnots);
|
||||
|
||||
TColgp_Array2OfPnt Poles(1,NbUPoles, 1,NbVPoles);
|
||||
TColStd_Array2OfReal Weights(1,NbUPoles, 1,NbVPoles);
|
||||
TColStd_Array1OfReal UKnots(1, NbUKnots),VKnots(1, NbVKnots);
|
||||
TColgp_Array2OfPnt Poles(1, NbUPoles, 1, NbVPoles);
|
||||
TColStd_Array2OfReal Weights(1, NbUPoles, 1, NbVPoles);
|
||||
TColStd_Array1OfReal UKnots(1, NbUKnots), VKnots(1, NbVKnots);
|
||||
TColStd_Array1OfInteger UMults(1, NbUKnots), VMults(1, NbVKnots);
|
||||
|
||||
Approx.Surface(Poles, Weights,
|
||||
UKnots,VKnots,
|
||||
UMults,VMults);
|
||||
UKnots, VKnots,
|
||||
UMults, VMults);
|
||||
|
||||
mySurface = new (Geom_BSplineSurface)
|
||||
(Poles, Weights,
|
||||
UKnots,VKnots,
|
||||
UMults,VMults,
|
||||
UKnots, VKnots,
|
||||
UMults, VMults,
|
||||
Approx.UDegree(), Approx.VDegree(),
|
||||
mySec->IsUPeriodic());
|
||||
SError = Approx. MaxErrorOnSurf();
|
||||
SError = Approx.MaxErrorOnSurf();
|
||||
|
||||
if (myForceApproxC1 && !mySurface->IsCNv(1))
|
||||
{
|
||||
@ -321,15 +318,15 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
Standard_Integer nmax = 16;
|
||||
Standard_Integer thePrec = 1;
|
||||
|
||||
GeomConvert_ApproxSurface ConvertApprox(mySurface,theTol,theUCont,theVCont,
|
||||
degU,degV,nmax,thePrec);
|
||||
GeomConvert_ApproxSurface ConvertApprox(mySurface, theTol, theUCont, theVCont,
|
||||
degU, degV, nmax, thePrec);
|
||||
if (ConvertApprox.HasResult())
|
||||
{
|
||||
mySurface = ConvertApprox.Surface();
|
||||
myCurve2d = new (TColGeom2d_HArray1OfCurve) (1, 2);
|
||||
CError = new (TColStd_HArray2OfReal) (1,2, 1,2);
|
||||
CError = new (TColStd_HArray2OfReal) (1, 2, 1, 2);
|
||||
|
||||
Handle(Geom_BSplineSurface) BSplSurf (Handle(Geom_BSplineSurface)::DownCast(mySurface));
|
||||
Handle(Geom_BSplineSurface) BSplSurf(Handle(Geom_BSplineSurface)::DownCast(mySurface));
|
||||
|
||||
gp_Dir2d D(0., 1.);
|
||||
gp_Pnt2d P(BSplSurf->UKnot(1), 0);
|
||||
@ -357,9 +354,9 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Les Courbes 2d
|
||||
if (myCurve2d.IsNull())
|
||||
{
|
||||
myCurve2d = new (TColGeom2d_HArray1OfCurve) (1, 2+myLoc->TraceNumber());
|
||||
CError = new (TColStd_HArray2OfReal) (1,2, 1, 2+myLoc->TraceNumber());
|
||||
Standard_Integer kk,ii, ifin = 1, ideb;
|
||||
myCurve2d = new (TColGeom2d_HArray1OfCurve) (1, 2 + myLoc->TraceNumber());
|
||||
CError = new (TColStd_HArray2OfReal) (1, 2, 1, 2 + myLoc->TraceNumber());
|
||||
Standard_Integer kk, ii, ifin = 1, ideb;
|
||||
|
||||
if (myLoc->HasFirstRestriction()) {
|
||||
ideb = 1;
|
||||
@ -370,7 +367,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
ifin += myLoc->TraceNumber();
|
||||
if (myLoc->HasLastRestriction()) ifin++;
|
||||
|
||||
for (ii=ideb, kk=1; ii<=ifin; ii++, kk++) {
|
||||
for (ii = ideb, kk = 1; ii <= ifin; ii++, kk++) {
|
||||
Handle(Geom2d_BSplineCurve) C
|
||||
= new (Geom2d_BSplineCurve) (Approx.Curve2dPoles(kk),
|
||||
Approx.Curves2dKnots(),
|
||||
@ -383,7 +380,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
|
||||
// Si les courbes de restriction, ne sont pas calcules, on prend
|
||||
// les iso Bords.
|
||||
if (! myLoc->HasFirstRestriction()) {
|
||||
if (!myLoc->HasFirstRestriction()) {
|
||||
gp_Dir2d D(0., 1.);
|
||||
gp_Pnt2d P(UKnots(UKnots.Lower()), 0);
|
||||
Handle(Geom2d_Line) LC = new (Geom2d_Line) (P, D);
|
||||
@ -395,7 +392,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
CError->SetValue(2, 1, 0.);
|
||||
}
|
||||
|
||||
if (! myLoc->HasLastRestriction()) {
|
||||
if (!myLoc->HasLastRestriction()) {
|
||||
gp_Dir2d D(0., 1.);
|
||||
gp_Pnt2d P(UKnots(UKnots.Upper()), 0);
|
||||
Handle(Geom2d_Line) LC = new (Geom2d_Line) (P, D);
|
||||
@ -414,15 +411,13 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// Function : BuildProduct
|
||||
// Purpose : A venir...
|
||||
//===============================================================
|
||||
Standard_Boolean GeomFill_Sweep::BuildProduct(const GeomAbs_Shape Continuity,
|
||||
Standard_Boolean GeomFill_Sweep::BuildProduct(const GeomAbs_Shape Continuity,
|
||||
const Standard_Integer Degmax,
|
||||
const Standard_Integer Segmax)
|
||||
{
|
||||
Standard_Boolean Ok = Standard_False;
|
||||
|
||||
Handle(Geom_BSplineSurface) BSurf;
|
||||
BSurf = Handle(Geom_BSplineSurface)::DownCast(
|
||||
mySec->BSplineSurface()->Copy());
|
||||
Handle(Geom_BSplineSurface) BSurf = Handle(Geom_BSplineSurface)::DownCast(mySec->BSplineSurface()->Copy());
|
||||
if (BSurf.IsNull()) return Ok; // Ce mode de construction est impossible
|
||||
|
||||
|
||||
@ -431,19 +426,18 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
|
||||
NbIntervalC2 = myLoc->NbIntervals(GeomAbs_C2);
|
||||
NbIntervalC3 = myLoc->NbIntervals(GeomAbs_C3);
|
||||
TColStd_Array1OfReal Param_de_decoupeC2 (1, NbIntervalC2+1);
|
||||
TColStd_Array1OfReal Param_de_decoupeC2(1, NbIntervalC2 + 1);
|
||||
myLoc->Intervals(Param_de_decoupeC2, GeomAbs_C2);
|
||||
TColStd_Array1OfReal Param_de_decoupeC3 (1, NbIntervalC3+1);
|
||||
TColStd_Array1OfReal Param_de_decoupeC3(1, NbIntervalC3 + 1);
|
||||
myLoc->Intervals(Param_de_decoupeC3, GeomAbs_C3);
|
||||
|
||||
|
||||
AdvApprox_PrefAndRec Preferentiel(Param_de_decoupeC2,
|
||||
Param_de_decoupeC3);
|
||||
AdvApprox_PrefAndRec Preferentiel(Param_de_decoupeC2, Param_de_decoupeC3);
|
||||
|
||||
Handle(TColStd_HArray1OfReal) ThreeDTol = new (TColStd_HArray1OfReal) (1,4);
|
||||
Handle(TColStd_HArray1OfReal) ThreeDTol = new (TColStd_HArray1OfReal) (1, 4);
|
||||
ThreeDTol->Init(Tol3d); // A Affiner...
|
||||
|
||||
GeomFill_Sweep_Eval eval (Func);
|
||||
GeomFill_Sweep_Eval eval(Func);
|
||||
AdvApprox_ApproxAFunction Approx(0, 0, 4,
|
||||
ThreeDTol,
|
||||
ThreeDTol,
|
||||
@ -505,7 +499,7 @@ GeomFill_Sweep::GeomFill_Sweep(const Handle(GeomFill_LocationLaw)& Location,
|
||||
// * the type of section should be a line
|
||||
// * theLoc should represent a translation.
|
||||
|
||||
static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw) &theLoc,
|
||||
static Standard_Boolean IsSweepParallelSpine(const Handle(GeomFill_LocationLaw) &theLoc,
|
||||
const Handle(GeomFill_SectionLaw) &theSec,
|
||||
const Standard_Real theTol)
|
||||
{
|
||||
@ -522,25 +516,25 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
|
||||
theLoc->GetDomain(aFirst, aLast);
|
||||
|
||||
// Get the first transformation
|
||||
// Get the first transformation
|
||||
theLoc->D0(aFirst, M, VBegin);
|
||||
|
||||
GTfBegin.SetVectorialPart(M);
|
||||
GTfBegin.SetTranslationPart(VBegin.XYZ());
|
||||
|
||||
TfBegin.SetValues(GTfBegin(1,1), GTfBegin(1,2), GTfBegin(1,3), GTfBegin(1,4),
|
||||
GTfBegin(2,1), GTfBegin(2,2), GTfBegin(2,3), GTfBegin(2,4),
|
||||
GTfBegin(3,1), GTfBegin(3,2), GTfBegin(3,3), GTfBegin(3,4));
|
||||
TfBegin.SetValues(GTfBegin(1, 1), GTfBegin(1, 2), GTfBegin(1, 3), GTfBegin(1, 4),
|
||||
GTfBegin(2, 1), GTfBegin(2, 2), GTfBegin(2, 3), GTfBegin(2, 4),
|
||||
GTfBegin(3, 1), GTfBegin(3, 2), GTfBegin(3, 3), GTfBegin(3, 4));
|
||||
|
||||
// Get the last transformation
|
||||
// Get the last transformation
|
||||
theLoc->D0(aLast, M, VEnd);
|
||||
|
||||
GTfEnd.SetVectorialPart(M);
|
||||
GTfEnd.SetTranslationPart(VEnd.XYZ());
|
||||
|
||||
TfEnd.SetValues(GTfEnd(1,1), GTfEnd(1,2), GTfEnd(1,3), GTfEnd(1,4),
|
||||
GTfEnd(2,1), GTfEnd(2,2), GTfEnd(2,3), GTfEnd(2,4),
|
||||
GTfEnd(3,1), GTfEnd(3,2), GTfEnd(3,3), GTfEnd(3,4));
|
||||
TfEnd.SetValues(GTfEnd(1, 1), GTfEnd(1, 2), GTfEnd(1, 3), GTfEnd(1, 4),
|
||||
GTfEnd(2, 1), GTfEnd(2, 2), GTfEnd(2, 3), GTfEnd(2, 4),
|
||||
GTfEnd(3, 1), GTfEnd(3, 2), GTfEnd(3, 3), GTfEnd(3, 4));
|
||||
|
||||
Handle(Geom_Surface) aSurf = theSec->BSplineSurface();
|
||||
Standard_Real Umin;
|
||||
@ -566,8 +560,8 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
|
||||
aPntLastSec.Transform(TfEnd);
|
||||
|
||||
gp_Pnt aPntFirstSec = ElCLib::Value( UFirst, L );
|
||||
gp_Vec aVecSec( aPntFirstSec, aPntLastSec );
|
||||
gp_Pnt aPntFirstSec = ElCLib::Value(UFirst, L);
|
||||
gp_Vec aVecSec(aPntFirstSec, aPntLastSec);
|
||||
gp_Vec aVecSpine = VEnd - VBegin;
|
||||
|
||||
Standard_Boolean isParallel = aVecSec.IsParallel(aVecSpine, theTol);
|
||||
@ -580,7 +574,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
// Function : BuildKPart
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Standard_Boolean GeomFill_Sweep::BuildKPart()
|
||||
Standard_Boolean GeomFill_Sweep::BuildKPart()
|
||||
{
|
||||
Standard_Boolean Ok = Standard_False;
|
||||
Standard_Boolean isUPeriodic = Standard_False;
|
||||
@ -592,9 +586,9 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
GeomAbs_CurveType SectionType;
|
||||
gp_Vec V;
|
||||
gp_Mat M;
|
||||
Standard_Real levier, error = 0 ;
|
||||
Standard_Real UFirst=0, VFirst=First, ULast=0, VLast=Last;
|
||||
Standard_Real Tol = Min (Tol3d, BoundTol);
|
||||
Standard_Real levier, error = 0;
|
||||
Standard_Real UFirst = 0, VFirst = First, ULast = 0, VLast = Last;
|
||||
Standard_Real Tol = Min(Tol3d, BoundTol);
|
||||
|
||||
// (1) Trajectoire Rectilignes -------------------------
|
||||
if (myLoc->IsTranslation(error)) {
|
||||
@ -610,9 +604,9 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
Tf.SetTranslationPart(V.XYZ());
|
||||
try { // Pas joli mais il n'y as pas d'autre moyens de tester SetValues
|
||||
OCC_CATCH_SIGNALS
|
||||
Tf2.SetValues(Tf(1,1), Tf(1,2), Tf(1,3), Tf(1,4),
|
||||
Tf(2,1), Tf(2,2), Tf(2,3), Tf(2,4),
|
||||
Tf(3,1), Tf(3,2), Tf(3,3), Tf(3,4));
|
||||
Tf2.SetValues(Tf(1, 1), Tf(1, 2), Tf(1, 3), Tf(1, 4),
|
||||
Tf(2, 1), Tf(2, 2), Tf(2, 3), Tf(2, 4),
|
||||
Tf(3, 1), Tf(3, 2), Tf(3, 3), Tf(3, 4));
|
||||
}
|
||||
catch (Standard_ConstructionError const&) {
|
||||
IsTrsf = Standard_False;
|
||||
@ -630,47 +624,47 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
UFirst = AC.FirstParameter();
|
||||
ULast = AC.LastParameter();
|
||||
// (1.1.a) Cas Plan
|
||||
if ( (SectionType == GeomAbs_Line) && IsTrsf) {
|
||||
// Modified by skv - Thu Feb 5 11:39:06 2004 OCC5073 Begin
|
||||
if ((SectionType == GeomAbs_Line) && IsTrsf) {
|
||||
// Modified by skv - Thu Feb 5 11:39:06 2004 OCC5073 Begin
|
||||
if (!IsSweepParallelSpine(myLoc, mySec, Tol))
|
||||
return Standard_False;
|
||||
// Modified by skv - Thu Feb 5 11:39:08 2004 OCC5073 End
|
||||
// Modified by skv - Thu Feb 5 11:39:08 2004 OCC5073 End
|
||||
gp_Lin L = AC.Line();
|
||||
L.Transform(Tf2);
|
||||
DS.SetXYZ(L.Position().Direction().XYZ());
|
||||
DS.Normalize();
|
||||
levier = Abs(DS.Dot(DP));
|
||||
SError = error + levier * Abs(Last-First);
|
||||
SError = error + levier * Abs(Last - First);
|
||||
if (SError <= Tol) {
|
||||
Ok = Standard_True;
|
||||
gp_Ax2 AxisOfPlane (L.Location(), DS^DP, DS);
|
||||
gp_Ax2 AxisOfPlane(L.Location(), DS^DP, DS);
|
||||
S = new (Geom_Plane) (AxisOfPlane);
|
||||
}
|
||||
else SError = 0.;
|
||||
}
|
||||
|
||||
// (1.1.b) Cas Cylindrique
|
||||
if ( (SectionType == GeomAbs_Circle) && IsTrsf) {
|
||||
if ((SectionType == GeomAbs_Circle) && IsTrsf) {
|
||||
const Standard_Real TolProd = 1.e-6;
|
||||
|
||||
gp_Circ C = AC.Circle();
|
||||
C.Transform(Tf2);
|
||||
|
||||
DS.SetXYZ (C.Position().Direction().XYZ());
|
||||
DS.SetXYZ(C.Position().Direction().XYZ());
|
||||
DS.Normalize();
|
||||
levier = Abs(DS.CrossMagnitude(DP)) * C.Radius();
|
||||
SError = levier * Abs(Last - First);
|
||||
if (SError <= TolProd) {
|
||||
Ok = Standard_True;
|
||||
gp_Ax3 axe (C.Location(), DP, C.Position().XDirection());
|
||||
gp_Ax3 axe(C.Location(), DP, C.Position().XDirection());
|
||||
S = new (Geom_CylindricalSurface)
|
||||
(axe, C.Radius());
|
||||
if (C.Position().Direction().
|
||||
IsOpposite(axe.Direction(), 0.1) ) {
|
||||
IsOpposite(axe.Direction(), 0.1)) {
|
||||
Standard_Real f, l;
|
||||
// L'orientation parametrique est inversee
|
||||
l = 2*M_PI - UFirst;
|
||||
f = 2*M_PI - ULast;
|
||||
l = 2 * M_PI - UFirst;
|
||||
f = 2 * M_PI - ULast;
|
||||
UFirst = f;
|
||||
ULast = l;
|
||||
isUReversed = Standard_True;
|
||||
@ -723,7 +717,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
P1 = AC.Value(0);
|
||||
R1 = C.Radius();
|
||||
|
||||
Section = mySec->CirclSection(SFirst - First*(SLast-SFirst)/(Last-First));
|
||||
Section = mySec->CirclSection(SFirst - First*(SLast - SFirst) / (Last - First));
|
||||
Section->Transform(Tf2);
|
||||
AC.Load(Section);
|
||||
C = AC.Circle();
|
||||
@ -735,11 +729,11 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
gp_Vec Bis(Centre2, P2);
|
||||
N = Bis;
|
||||
}
|
||||
gp_Vec L(P1, P2), Dir(Centre1,Centre2);
|
||||
gp_Vec L(P1, P2), Dir(Centre1, Centre2);
|
||||
|
||||
Angle = L.Angle(Dir);
|
||||
if ((Angle > 0.01) && (Angle < M_PI/2-0.01)) {
|
||||
if (R2<R1) Angle = -Angle;
|
||||
if ((Angle > 0.01) && (Angle < M_PI / 2 - 0.01)) {
|
||||
if (R2 < R1) Angle = -Angle;
|
||||
SError = error;
|
||||
gp_Ax3 Axis(Centre0, Dir, N);
|
||||
S = new (Geom_ConicalSurface)
|
||||
@ -754,13 +748,13 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
gp_Vec diso;
|
||||
gp_Pnt pbis;
|
||||
S->VIso(VLast)->D1(0, pbis, diso);
|
||||
if (diso.Magnitude()>1.e-9 && dsection.Magnitude()>1.e-9)
|
||||
if (diso.Magnitude() > 1.e-9 && dsection.Magnitude() > 1.e-9)
|
||||
isUReversed = diso.IsOpposite(dsection, 0.1);
|
||||
if (isUReversed ) {
|
||||
if (isUReversed) {
|
||||
Standard_Real f, l;
|
||||
// L'orientation parametrique est inversee
|
||||
l = 2*M_PI - UFirst;
|
||||
f = 2*M_PI - ULast;
|
||||
l = 2 * M_PI - UFirst;
|
||||
f = 2 * M_PI - ULast;
|
||||
UFirst = f;
|
||||
ULast = l;
|
||||
}
|
||||
@ -776,7 +770,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
if (mySec->IsConstant(error)) {
|
||||
// La trajectoire
|
||||
gp_Pnt Centre;
|
||||
isVPeriodic = (Abs(Last-First -2*M_PI) < 1.e-15);
|
||||
isVPeriodic = (Abs(Last - First - 2 * M_PI) < 1.e-15);
|
||||
Standard_Real RotRadius;
|
||||
gp_Vec DP, DS, DN;
|
||||
myLoc->D0(0.1, M, DS);
|
||||
@ -799,9 +793,9 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
Tf.SetTranslationPart(V.XYZ());
|
||||
// try { // Pas joli mais il n'y as pas d'autre moyens de tester SetValues
|
||||
// OCC_CATCH_SIGNALS
|
||||
Tf2.SetValues(Tf(1,1), Tf(1,2), Tf(1,3), Tf(1,4),
|
||||
Tf(2,1), Tf(2,2), Tf(2,3), Tf(2,4),
|
||||
Tf(3,1), Tf(3,2), Tf(3,3), Tf(3,4));
|
||||
Tf2.SetValues(Tf(1, 1), Tf(1, 2), Tf(1, 3), Tf(1, 4),
|
||||
Tf(2, 1), Tf(2, 2), Tf(2, 3), Tf(2, 4),
|
||||
Tf(3, 1), Tf(3, 2), Tf(3, 3), Tf(3, 4));
|
||||
// }
|
||||
// catch (Standard_ConstructionError) {
|
||||
// IsTrsf = Standard_False;
|
||||
@ -827,12 +821,12 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
DC.SetXYZ(C.Location().XYZ() - Centre.XYZ());
|
||||
Radius = DC.Magnitude(); //grand Rayon du tore
|
||||
if ((Radius > Tol) && (DC.Dot(DS) < 0)) IsGoodSide = Standard_False;
|
||||
if (Radius < Tol/100) DC = DS; // Pour definir le tore
|
||||
if (Radius < Tol / 100) DC = DS; // Pour definir le tore
|
||||
|
||||
// On verifie d'abord que le plan de la section est // a
|
||||
// l'axe de rotation
|
||||
gp_Vec NC;
|
||||
NC.SetXYZ (C.Position().Direction().XYZ());
|
||||
NC.SetXYZ(C.Position().Direction().XYZ());
|
||||
NC.Normalize();
|
||||
error = Abs(NC.Dot(DN));
|
||||
// Puis on evalue l'erreur commise sur la section,
|
||||
@ -844,12 +838,12 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
error += Radius;
|
||||
if (Radius <= Tol) {
|
||||
// (2.1.a) Sphere
|
||||
Standard_Real f = UFirst , l = ULast, aRadius = 0.0;
|
||||
Standard_Real f = UFirst, l = ULast, aRadius = 0.0;
|
||||
SError = error;
|
||||
Centre.BaryCenter(1.0, C.Location(), 1.0);
|
||||
gp_Ax3 AxisOfSphere(Centre, DN, DS);
|
||||
aRadius = C.Radius();
|
||||
gp_Sphere theSphere( AxisOfSphere, aRadius );
|
||||
gp_Sphere theSphere(AxisOfSphere, aRadius);
|
||||
S = new Geom_SphericalSurface(theSphere);
|
||||
// Pour les spheres on ne peut pas controler le parametre
|
||||
// V (donc U car myExchUV = Standard_True)
|
||||
@ -886,7 +880,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
return Ok;
|
||||
}
|
||||
|
||||
if ( (f >= -M_PI/2) && (l <= M_PI/2)) {
|
||||
if ((f >= -M_PI / 2) && (l <= M_PI / 2)) {
|
||||
Ok = Standard_True;
|
||||
myExchUV = Standard_True;
|
||||
UFirst = f;
|
||||
@ -900,7 +894,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
// (2.1.b) Tore
|
||||
gp_Ax3 AxisOfTore(Centre, DN, DC);
|
||||
S = new (Geom_ToroidalSurface) (AxisOfTore,
|
||||
Radius , C.Radius());
|
||||
Radius, C.Radius());
|
||||
|
||||
// Pour les tores on ne peut pas controler le parametre
|
||||
// V (donc U car myExchUV = Standard_True)
|
||||
@ -911,11 +905,11 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
axeiso = Iso->Circ().Position();
|
||||
|
||||
if (C.Position().Direction().
|
||||
IsOpposite(axeiso.Direction(), 0.1) ) {
|
||||
IsOpposite(axeiso.Direction(), 0.1)) {
|
||||
Standard_Real f, l;
|
||||
// L'orientation parametrique est inversee
|
||||
l = 2*M_PI - UFirst;
|
||||
f = 2*M_PI - ULast;
|
||||
l = 2 * M_PI - UFirst;
|
||||
f = 2 * M_PI - ULast;
|
||||
UFirst = f;
|
||||
ULast = l;
|
||||
isUReversed = Standard_True;
|
||||
@ -930,7 +924,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
myExchUV = Standard_True;
|
||||
// Attention l'arete de couture dans le cas periodique
|
||||
// n'est peut etre pas a la bonne place...
|
||||
if (isUPeriodic && Abs(UFirst)>Precision::PConfusion())
|
||||
if (isUPeriodic && Abs(UFirst) > Precision::PConfusion())
|
||||
isUPeriodic = Standard_False; //Pour trimmer la surface...
|
||||
Ok = Standard_True;
|
||||
}
|
||||
@ -983,13 +977,13 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
else {
|
||||
// On evalue l'angle du cone
|
||||
Standard_Real Angle = Abs(Dir.Angle(L));
|
||||
if (Angle > M_PI/2) Angle = M_PI -Angle;
|
||||
if (Angle > M_PI / 2) Angle = M_PI - Angle;
|
||||
if (reverse) Angle = -Angle;
|
||||
aux = DS.Dot(DL);
|
||||
if (aux < 0) {
|
||||
Angle = - Angle;
|
||||
Angle = -Angle;
|
||||
}
|
||||
if (Abs(Abs(Angle) - M_PI/2) > 0.01) {
|
||||
if (Abs(Abs(Angle) - M_PI / 2) > 0.01) {
|
||||
// (2.2.b) Cone
|
||||
// si les 2 droites ne sont pas orthogonales
|
||||
Standard_Real Radius = CentreOfSurf.Distance(L.Location());
|
||||
@ -1010,9 +1004,12 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
Handle(Geom_Line) CL = new (Geom_Line)(L);
|
||||
uf = CL->ReversedParameter(ULast);
|
||||
ul = CL->ReversedParameter(UFirst);
|
||||
UFirst = uf;
|
||||
ULast = ul;
|
||||
isUReversed = Standard_True;
|
||||
|
||||
// Following the example of the code for the sphere:
|
||||
// "we cannot control U because myExchUV = Standard_True,
|
||||
// so it is necessary to change UFirst and ULast"
|
||||
UFirst = ul;
|
||||
ULast = uf;
|
||||
}
|
||||
}
|
||||
else SError = 0.;
|
||||
@ -1022,7 +1019,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
if (!Ok) {
|
||||
if (IsTrsf) {
|
||||
Section->Transform(Tf2);
|
||||
gp_Ax1 Axis (Centre, DN);
|
||||
gp_Ax1 Axis(Centre, DN);
|
||||
S = new (Geom_SurfaceOfRevolution)
|
||||
(Section, Axis);
|
||||
myExchUV = Standard_True;
|
||||
@ -1053,29 +1050,29 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
}
|
||||
else
|
||||
mySurface = new (Geom_RectangularTrimmedSurface)
|
||||
(S,UFirst, ULast, Standard_True);
|
||||
(S, UFirst, ULast, Standard_True);
|
||||
|
||||
#ifdef OCCT_DEBUG
|
||||
if (isUPeriodic && !mySurface->IsUPeriodic())
|
||||
std::cout<<"Pb de periodicite en U" << std::endl;
|
||||
std::cout << "Pb de periodicite en U" << std::endl;
|
||||
if (isUPeriodic && !mySurface->IsUClosed())
|
||||
std::cout<<"Pb de fermeture en U" << std::endl;
|
||||
std::cout << "Pb de fermeture en U" << std::endl;
|
||||
if (isVPeriodic && !mySurface->IsVPeriodic())
|
||||
std::cout << "Pb de periodicite en V" << std::endl;
|
||||
if (isVPeriodic && !mySurface->IsVClosed())
|
||||
std::cout<<"Pb de fermeture en V" << std::endl;
|
||||
std::cout << "Pb de fermeture en V" << std::endl;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
return Ok;
|
||||
}
|
||||
}
|
||||
|
||||
//===============================================================
|
||||
// Function : IsDone
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Standard_Boolean GeomFill_Sweep::IsDone() const
|
||||
Standard_Boolean GeomFill_Sweep::IsDone() const
|
||||
{
|
||||
return done;
|
||||
}
|
||||
@ -1084,7 +1081,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
// Function :ErrorOnSurface
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Standard_Real GeomFill_Sweep::ErrorOnSurface() const
|
||||
Standard_Real GeomFill_Sweep::ErrorOnSurface() const
|
||||
{
|
||||
return SError;
|
||||
}
|
||||
@ -1093,12 +1090,12 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
// Function ::ErrorOnRestriction
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
void GeomFill_Sweep::ErrorOnRestriction(const Standard_Boolean IsFirst,
|
||||
void GeomFill_Sweep::ErrorOnRestriction(const Standard_Boolean IsFirst,
|
||||
Standard_Real& UError,
|
||||
Standard_Real& VError) const
|
||||
{
|
||||
Standard_Integer ind;
|
||||
if (IsFirst) ind=1;
|
||||
if (IsFirst) ind = 1;
|
||||
else ind = myCurve2d->Length();
|
||||
|
||||
UError = CError->Value(1, ind);
|
||||
@ -1109,11 +1106,11 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
// Function :ErrorOnTrace
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
void GeomFill_Sweep::ErrorOnTrace(const Standard_Integer IndexOfTrace,
|
||||
void GeomFill_Sweep::ErrorOnTrace(const Standard_Integer IndexOfTrace,
|
||||
Standard_Real& UError,
|
||||
Standard_Real& VError) const
|
||||
{
|
||||
Standard_Integer ind = IndexOfTrace+1;
|
||||
Standard_Integer ind = IndexOfTrace + 1;
|
||||
if (IndexOfTrace > myLoc->TraceNumber())
|
||||
throw Standard_OutOfRange(" GeomFill_Sweep::ErrorOnTrace");
|
||||
|
||||
@ -1125,7 +1122,7 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
// Function :Surface
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Handle(Geom_Surface) GeomFill_Sweep::Surface() const
|
||||
Handle(Geom_Surface) GeomFill_Sweep::Surface() const
|
||||
{
|
||||
return mySurface;
|
||||
}
|
||||
@ -1134,19 +1131,18 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
// Function ::Restriction
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Handle(Geom2d_Curve) GeomFill_Sweep::Restriction(const Standard_Boolean IsFirst) const
|
||||
Handle(Geom2d_Curve) GeomFill_Sweep::Restriction(const Standard_Boolean IsFirst) const
|
||||
{
|
||||
if (IsFirst)
|
||||
return myCurve2d->Value(1);
|
||||
return myCurve2d->Value(myCurve2d->Length());
|
||||
|
||||
}
|
||||
|
||||
//===============================================================
|
||||
// Function :
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Standard_Integer GeomFill_Sweep::NumberOfTrace() const
|
||||
Standard_Integer GeomFill_Sweep::NumberOfTrace() const
|
||||
{
|
||||
return myLoc->TraceNumber();
|
||||
}
|
||||
@ -1155,10 +1151,9 @@ static Standard_Boolean IsSweepParallelSpine (const Handle(GeomFill_LocationLaw)
|
||||
// Function :
|
||||
// Purpose :
|
||||
//===============================================================
|
||||
Handle(Geom2d_Curve)
|
||||
GeomFill_Sweep::Trace(const Standard_Integer IndexOfTrace) const
|
||||
Handle(Geom2d_Curve) GeomFill_Sweep::Trace(const Standard_Integer IndexOfTrace) const
|
||||
{
|
||||
Standard_Integer ind = IndexOfTrace+1;
|
||||
Standard_Integer ind = IndexOfTrace + 1;
|
||||
if (IndexOfTrace > myLoc->TraceNumber())
|
||||
throw Standard_OutOfRange(" GeomFill_Sweep::Trace");
|
||||
return myCurve2d->Value(ind);
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
puts "TODO OCC24909 ALL: TEST INCOMPLETE"
|
||||
puts "TODO OCC24909 ALL: Error: sweep failed"
|
||||
|
||||
puts "========"
|
||||
puts "OCC24909"
|
||||
@ -28,4 +28,8 @@ trotate Circle001 0 0 0 0.577350269189625731 0.577350269189625731 0.577350269189
|
||||
ttranslate Circle001 0 -71 203.5
|
||||
addsweep Circle001
|
||||
|
||||
buildsweep Sweep001 -C -S
|
||||
set result [buildsweep Sweep001 -C -S]
|
||||
|
||||
if {[regexp "Not Done" $result]} {
|
||||
puts "Error: sweep failed"
|
||||
}
|
||||
16
tests/pipe/bugs/bug32809
Normal file
16
tests/pipe/bugs/bug32809
Normal file
@ -0,0 +1,16 @@
|
||||
puts "========"
|
||||
puts "bug32809: Sweep algorithm with Round Corner doesnot work"
|
||||
puts "========"
|
||||
puts ""
|
||||
|
||||
restore [locate_data_file bug32809_path.brep] p
|
||||
restore [locate_data_file bug32809_profile.brep] pr
|
||||
|
||||
mksweep p
|
||||
setsweep -CF
|
||||
addsweep pr
|
||||
|
||||
buildsweep result -R -S
|
||||
|
||||
checkshape result
|
||||
checknbshapes result -vertex 140 -edge 285 -wire 140 -face 140 -shell 1
|
||||
1
tests/pipe/bugs/end
Normal file
1
tests/pipe/bugs/end
Normal file
@ -0,0 +1 @@
|
||||
puts "TEST COMPLETED"
|
||||
Loading…
x
Reference in New Issue
Block a user