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

Coding - Add clang-format configuration #246

Browse Source 
New clang-format configuration added to determinate code style.
The default version is 16.
Extend CMake to copy config file to build root.
Method/function separator deprecation:
  In case if function/method has declaration in header,
    definition must not have related comment.
    Only //==== [100 chars] ==== is allowed as a not connected
    separator.
  In case if function/method has  NOT declaration in header,
    definition must have related comment in doxygen style:
    // Descriptions
    // @param
    // @return
    Or just function/method separator:
    //==== [100 chars] ====
  All old separators with no description must be replaced to
    //==== [100 chars] ====
This commit is contained in:
dpasukhi 2025-01-06 12:35:56 +00:00
parent e9855c9335
commit fe1382f3c2
49 changed files with 5690 additions and 5029 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
.clang-format Normal file
View File

@ -0,0 +1,40 @@
# clang-format configuration file trying to apply OCCT coding style
#
# Clang formatting rules: https://clang.llvm.org/docs/ClangFormatStyleOptions.html
# The clang-format npm package (https://github.com/angular/clang-format) uses
# a pre-built clang-format.exe from http://llvm.org/builds/
#
# We use defaults from the Microsoft style
BasedOnStyle: Microsoft
#
# Style options
AllowAllParametersOfDeclarationOnNextLine: false
AllowAllArgumentsOnNextLine: false
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: Consecutive
AlignConsecutiveDeclarations: Consecutive
AlignTrailingComments: true
AllowShortFunctionsOnASingleLine: Inline
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: false
BinPackParameters: false
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeTernaryOperators: true
ColumnLimit: 100
ContinuationIndentWidth: 2
IndentCaseLabels: true
IndentPPDirectives: BeforeHash
IndentWidth: 2
IndentWrappedFunctionNames: true
PackConstructorInitializers: Never
PointerAlignment: Left
ReferenceAlignment: Left
SeparateDefinitionBlocks: Always
SortIncludes: true
UseTab: Never
#
# OCCT specific settings
StatementMacros:
- Standard_FALLTHROUGH
TypenameMacros:
- Handle

3
CMakeLists.txt
View File

@ -723,6 +723,9 @@ endif()
# the name of the project
project (OCCT)
# copying clang-format file to the root of the project
file(COPY ${CMAKE_SOURCE_DIR}/.clang-format DESTINATION ${CMAKE_SOURCE_DIR})
# Get all used variables: OS_WITH_BIT, COMPILER
OCCT_MAKE_OS_WITH_BITNESS()
OCCT_MAKE_COMPILER_SHORT_NAME()

1
src/Approx/Approx_Array1OfAdHSurface.hxx
View File

@ -22,5 +22,4 @@
typedef NCollection_Array1<Handle(Adaptor3d_Surface)> Approx_Array1OfAdHSurface;
#endif

3
src/Approx/Approx_Array1OfGTrsf2d.hxx
View File

@ -17,10 +17,9 @@
#ifndef Approx_Array1OfGTrsf2d_HeaderFile
#define Approx_Array1OfGTrsf2d_HeaderFile
#include <gp_GTrsf2d.hxx>
#include <NCollection_Array1.hxx>
#include <gp_GTrsf2d.hxx>
typedef NCollection_Array1<gp_GTrsf2d> Approx_Array1OfGTrsf2d;
#endif

205
src/Approx/Approx_Curve2d.cxx
View File

@ -14,7 +14,6 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor2d_Curve2d.hxx>
#include <AdvApprox_ApproxAFunction.hxx>
#include <AdvApprox_PrefAndRec.hxx>
@ -23,150 +22,172 @@
#include <Precision.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
//=======================================================================
//class : Approx_Curve2d_Eval
//purpose: evaluator class for approximation
//=======================================================================
//=================================================================================================
class Approx_Curve2d_Eval : public AdvApprox_EvaluatorFunction
{
public:
Approx_Curve2d_Eval (const Handle(Adaptor2d_Curve2d)& theFunc,
Standard_Real First, Standard_Real Last)
: fonct(theFunc) { StartEndSav[0] = First; StartEndSav[1] = Last; }
virtual void Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Parameter,
Standard_Integer *DerivativeRequest,
Standard_Real *Result, // [Dimension]
Standard_Integer *ErrorCode);
private:
public:
Approx_Curve2d_Eval(const Handle(Adaptor2d_Curve2d)& theFunc,
Standard_Real First,
Standard_Real Last)
: fonct(theFunc)
{
StartEndSav[0] = First;
StartEndSav[1] = Last;
}
virtual void Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Parameter,
Standard_Integer* DerivativeRequest,
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode);
private:
Handle(Adaptor2d_Curve2d) fonct;
Standard_Real StartEndSav[2];
Standard_Real StartEndSav[2];
};
void Approx_Curve2d_Eval::Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Param, // Parameter at which evaluation
Standard_Integer *Order, // Derivative Request
Standard_Real *Result,// [Dimension]
Standard_Integer *ErrorCode)
void Approx_Curve2d_Eval::Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Param, // Parameter at which evaluation
Standard_Integer* Order, // Derivative Request
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode)
{
*ErrorCode = 0;
*ErrorCode = 0;
Standard_Real par = *Param;
// Dimension is incorrect
if (*Dimension!=2) {
// Dimension is incorrect
if (*Dimension != 2)
{
*ErrorCode = 1;
}
// Parameter is incorrect
if ( par < StartEnd[0] || par > StartEnd[1] ) {
// Parameter is incorrect
if (par < StartEnd[0] || par > StartEnd[1])
{
*ErrorCode = 2;
}
if(StartEnd[0] != StartEndSav[0] || StartEnd[1]!= StartEndSav[1])
{
fonct = fonct->Trim(StartEnd[0],StartEnd[1],Precision::PConfusion());
StartEndSav[0]=StartEnd[0];
StartEndSav[1]=StartEnd[1];
}
if (StartEnd[0] != StartEndSav[0] || StartEnd[1] != StartEndSav[1])
{
fonct = fonct->Trim(StartEnd[0], StartEnd[1], Precision::PConfusion());
StartEndSav[0] = StartEnd[0];
StartEndSav[1] = StartEnd[1];
}
gp_Pnt2d pnt;
gp_Vec2d v1, v2;
switch (*Order) {
case 0:
pnt = fonct->Value(par);
Result[0] = pnt.X();
Result[1] = pnt.Y();
break;
case 1:
fonct->D1(par, pnt, v1);
Result[0] = v1.X();
Result[1] = v1.Y();
break;
case 2:
fonct->D2(par, pnt, v1, v2);
Result[0] = v2.X();
Result[1] = v2.Y();
break;
default:
Result[0] = Result[1] = 0.;
*ErrorCode = 3;
break;
switch (*Order)
{
case 0:
pnt = fonct->Value(par);
Result[0] = pnt.X();
Result[1] = pnt.Y();
break;
case 1:
fonct->D1(par, pnt, v1);
Result[0] = v1.X();
Result[1] = v1.Y();
break;
case 2:
fonct->D2(par, pnt, v1, v2);
Result[0] = v2.X();
Result[1] = v2.Y();
break;
default:
Result[0] = Result[1] = 0.;
*ErrorCode = 3;
break;
}
}
Approx_Curve2d::Approx_Curve2d(const Handle(Adaptor2d_Curve2d)& C2D,const Standard_Real First,const Standard_Real Last,const Standard_Real TolU,const Standard_Real TolV,const GeomAbs_Shape Continuity,const Standard_Integer MaxDegree,const Standard_Integer MaxSegments)
Approx_Curve2d::Approx_Curve2d(const Handle(Adaptor2d_Curve2d)& C2D,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real TolU,
const Standard_Real TolV,
const GeomAbs_Shape Continuity,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments)
{
C2D->Trim(First,Last,Precision::PConfusion());
C2D->Trim(First, Last, Precision::PConfusion());
Standard_Integer Num1DSS=2, Num2DSS=0, Num3DSS=0;
Handle(TColStd_HArray1OfReal) TwoDTolNul, ThreeDTolNul;
Handle(TColStd_HArray1OfReal) OneDTol = new TColStd_HArray1OfReal(1,Num1DSS);
OneDTol->ChangeValue(1) = TolU;
OneDTol->ChangeValue(2) = TolV;
Standard_Integer NbInterv_C2 = C2D->NbIntervals(GeomAbs_C2);
TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2+1);
Standard_Integer Num1DSS = 2, Num2DSS = 0, Num3DSS = 0;
Handle(TColStd_HArray1OfReal) TwoDTolNul, ThreeDTolNul;
Handle(TColStd_HArray1OfReal) OneDTol = new TColStd_HArray1OfReal(1, Num1DSS);
OneDTol->ChangeValue(1) = TolU;
OneDTol->ChangeValue(2) = TolV;
Standard_Integer NbInterv_C2 = C2D->NbIntervals(GeomAbs_C2);
TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2 + 1);
C2D->Intervals(CutPnts_C2, GeomAbs_C2);
Standard_Integer NbInterv_C3 = C2D->NbIntervals(GeomAbs_C3);
TColStd_Array1OfReal CutPnts_C3(1, NbInterv_C3+1);
Standard_Integer NbInterv_C3 = C2D->NbIntervals(GeomAbs_C3);
TColStd_Array1OfReal CutPnts_C3(1, NbInterv_C3 + 1);
C2D->Intervals(CutPnts_C3, GeomAbs_C3);
AdvApprox_PrefAndRec CutTool(CutPnts_C2,CutPnts_C3);
AdvApprox_PrefAndRec CutTool(CutPnts_C2, CutPnts_C3);
myMaxError2dU = 0;
myMaxError2dV = 0;
Approx_Curve2d_Eval ev (C2D, First, Last);
AdvApprox_ApproxAFunction aApprox (Num1DSS, Num2DSS, Num3DSS,
OneDTol, TwoDTolNul, ThreeDTolNul,
First, Last, Continuity,
MaxDegree, MaxSegments,
ev, CutTool);
Approx_Curve2d_Eval ev(C2D, First, Last);
AdvApprox_ApproxAFunction aApprox(Num1DSS,
Num2DSS,
Num3DSS,
OneDTol,
TwoDTolNul,
ThreeDTolNul,
First,
Last,
Continuity,
MaxDegree,
MaxSegments,
ev,
CutTool);
myIsDone = aApprox.IsDone();
myIsDone = aApprox.IsDone();
myHasResult = aApprox.HasResult();
if (myHasResult) {
TColgp_Array1OfPnt2d Poles2d(1,aApprox.NbPoles());
TColStd_Array1OfReal Poles1dU(1,aApprox.NbPoles());
if (myHasResult)
{
TColgp_Array1OfPnt2d Poles2d(1, aApprox.NbPoles());
TColStd_Array1OfReal Poles1dU(1, aApprox.NbPoles());
aApprox.Poles1d(1, Poles1dU);
TColStd_Array1OfReal Poles1dV(1,aApprox.NbPoles());
TColStd_Array1OfReal Poles1dV(1, aApprox.NbPoles());
aApprox.Poles1d(2, Poles1dV);
for(Standard_Integer i = 1; i <= aApprox.NbPoles(); i++)
for (Standard_Integer i = 1; i <= aApprox.NbPoles(); i++)
Poles2d.SetValue(i, gp_Pnt2d(Poles1dU.Value(i), Poles1dV.Value(i)));
Handle(TColStd_HArray1OfReal) Knots = aApprox.Knots();
Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
Standard_Integer Degree = aApprox.Degree();
myCurve = new Geom2d_BSplineCurve(Poles2d, Knots->Array1(), Mults->Array1(), Degree);
Handle(TColStd_HArray1OfReal) Knots = aApprox.Knots();
Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
Standard_Integer Degree = aApprox.Degree();
myCurve = new Geom2d_BSplineCurve(Poles2d, Knots->Array1(), Mults->Array1(), Degree);
myMaxError2dU = aApprox.MaxError(1, 1);
myMaxError2dV = aApprox.MaxError(1, 2);
}
}
}
Standard_Boolean Approx_Curve2d::IsDone() const
Standard_Boolean Approx_Curve2d::IsDone() const
{
return myIsDone;
}
Standard_Boolean Approx_Curve2d::HasResult() const
Standard_Boolean Approx_Curve2d::HasResult() const
{
return myHasResult;
}
Handle(Geom2d_BSplineCurve) Approx_Curve2d::Curve() const
Handle(Geom2d_BSplineCurve) Approx_Curve2d::Curve() const
{
return myCurve;
}
Standard_Real Approx_Curve2d::MaxError2dU() const
Standard_Real Approx_Curve2d::MaxError2dU() const
{
return myMaxError2dU;
}
Standard_Real Approx_Curve2d::MaxError2dV() const
Standard_Real Approx_Curve2d::MaxError2dV() const
{
return myMaxError2dV;
}

35
src/Approx/Approx_Curve2d.hxx
View File

@ -18,37 +18,40 @@
#define _Approx_Curve2d_HeaderFile
#include <Adaptor2d_Curve2d.hxx>
#include <GeomAbs_Shape.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <GeomAbs_Shape.hxx>
//! Makes an approximation for HCurve2d from Adaptor3d
class Approx_Curve2d
class Approx_Curve2d
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Approx_Curve2d(const Handle(Adaptor2d_Curve2d)& C2D, const Standard_Real First, const Standard_Real Last, const Standard_Real TolU, const Standard_Real TolV, const GeomAbs_Shape Continuity, const Standard_Integer MaxDegree, const Standard_Integer MaxSegments);
Standard_EXPORT Approx_Curve2d(const Handle(Adaptor2d_Curve2d)& C2D,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real TolU,
const Standard_Real TolV,
const GeomAbs_Shape Continuity,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments);
Standard_EXPORT Standard_Boolean IsDone() const;
Standard_EXPORT Standard_Boolean HasResult() const;
Standard_EXPORT Handle(Geom2d_BSplineCurve) Curve() const;
Standard_EXPORT Standard_Real MaxError2dU() const;
Standard_EXPORT Standard_Real MaxError2dV() const;
private:
Handle(Geom2d_BSplineCurve) myCurve;
Standard_Boolean myIsDone;
Standard_Boolean myHasResult;
Standard_Real myMaxError2dU;
Standard_Real myMaxError2dV;
Standard_Boolean myIsDone;
Standard_Boolean myHasResult;
Standard_Real myMaxError2dU;
Standard_Real myMaxError2dV;
};
#endif // _Approx_Curve2d_HeaderFile

211
src/Approx/Approx_Curve3d.cxx
View File

@ -19,158 +19,171 @@
#include <Adaptor3d_Curve.hxx>
#include <AdvApprox_ApproxAFunction.hxx>
#include <AdvApprox_PrefAndRec.hxx>
#include <Geom_BSplineCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Precision.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <Precision.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_HArray1OfReal.hxx>
//=======================================================================
//class : Approx_Curve3d_Eval
//purpose: evaluator class for approximation
//=======================================================================
//=================================================================================================
class Approx_Curve3d_Eval : public AdvApprox_EvaluatorFunction
{
public:
Approx_Curve3d_Eval (const Handle(Adaptor3d_Curve)& theFunc,
Standard_Real First, Standard_Real Last)
: fonct(theFunc) { StartEndSav[0] = First; StartEndSav[1] = Last; }
virtual void Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Parameter,
Standard_Integer *DerivativeRequest,
Standard_Real *Result, // [Dimension]
Standard_Integer *ErrorCode);
private:
public:
Approx_Curve3d_Eval(const Handle(Adaptor3d_Curve)& theFunc,
Standard_Real First,
Standard_Real Last)
: fonct(theFunc)
{
StartEndSav[0] = First;
StartEndSav[1] = Last;
}
virtual void Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Parameter,
Standard_Integer* DerivativeRequest,
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode);
private:
Handle(Adaptor3d_Curve) fonct;
Standard_Real StartEndSav[2];
Standard_Real StartEndSav[2];
};
void Approx_Curve3d_Eval::Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Param, // Parameter at which evaluation
Standard_Integer *Order, // Derivative Request
Standard_Real *Result,// [Dimension]
Standard_Integer *ErrorCode)
void Approx_Curve3d_Eval::Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Param, // Parameter at which evaluation
Standard_Integer* Order, // Derivative Request
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode)
{
*ErrorCode = 0;
*ErrorCode = 0;
Standard_Real par = *Param;
// Dimension is incorrect
if (*Dimension!=3) {
// Dimension is incorrect
if (*Dimension != 3)
{
*ErrorCode = 1;
}
if(StartEnd[0] != StartEndSav[0] || StartEnd[1]!= StartEndSav[1])
{
fonct = fonct->Trim(StartEnd[0],StartEnd[1],Precision::PConfusion());
StartEndSav[0]=StartEnd[0];
StartEndSav[1]=StartEnd[1];
}
if (StartEnd[0] != StartEndSav[0] || StartEnd[1] != StartEndSav[1])
{
fonct = fonct->Trim(StartEnd[0], StartEnd[1], Precision::PConfusion());
StartEndSav[0] = StartEnd[0];
StartEndSav[1] = StartEnd[1];
}
gp_Pnt pnt;
gp_Vec v1, v2;
switch (*Order) {
case 0:
pnt = fonct->Value(par);
Result[0] = pnt.X();
Result[1] = pnt.Y();
Result[2] = pnt.Z();
break;
case 1:
fonct->D1(par, pnt, v1);
Result[0] = v1.X();
Result[1] = v1.Y();
Result[2] = v1.Z();
break;
case 2:
fonct->D2(par, pnt, v1, v2);
Result[0] = v2.X();
Result[1] = v2.Y();
Result[2] = v2.Z();
break;
default:
Result[0] = Result[1] = Result[2] = 0.;
*ErrorCode = 3;
break;
switch (*Order)
{
case 0:
pnt = fonct->Value(par);
Result[0] = pnt.X();
Result[1] = pnt.Y();
Result[2] = pnt.Z();
break;
case 1:
fonct->D1(par, pnt, v1);
Result[0] = v1.X();
Result[1] = v1.Y();
Result[2] = v1.Z();
break;
case 2:
fonct->D2(par, pnt, v1, v2);
Result[0] = v2.X();
Result[1] = v2.Y();
Result[2] = v2.Z();
break;
default:
Result[0] = Result[1] = Result[2] = 0.;
*ErrorCode = 3;
break;
}
}
Approx_Curve3d::Approx_Curve3d(const Handle(Adaptor3d_Curve)& Curve,
const Standard_Real Tol3d,
const GeomAbs_Shape Order,
const Standard_Integer MaxSegments,
const Standard_Integer MaxDegree)
const Standard_Real Tol3d,
const GeomAbs_Shape Order,
const Standard_Integer MaxSegments,
const Standard_Integer MaxDegree)
{
// Initialisation of input parameters of AdvApprox
Standard_Integer Num1DSS=0, Num2DSS=0, Num3DSS=1;
Handle(TColStd_HArray1OfReal) OneDTolNul, TwoDTolNul;
Handle(TColStd_HArray1OfReal) ThreeDTol =
new TColStd_HArray1OfReal(1,Num3DSS);
ThreeDTol->Init(Tol3d);
Standard_Integer Num1DSS = 0, Num2DSS = 0, Num3DSS = 1;
Handle(TColStd_HArray1OfReal) OneDTolNul, TwoDTolNul;
Handle(TColStd_HArray1OfReal) ThreeDTol = new TColStd_HArray1OfReal(1, Num3DSS);
ThreeDTol->Init(Tol3d);
Standard_Real First = Curve->FirstParameter();
Standard_Real Last = Curve->LastParameter();
Standard_Integer NbInterv_C2 = Curve->NbIntervals(GeomAbs_C2);
TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2+1);
Curve->Intervals(CutPnts_C2,GeomAbs_C2);
Standard_Integer NbInterv_C3 = Curve->NbIntervals(GeomAbs_C3);
TColStd_Array1OfReal CutPnts_C3(1, NbInterv_C3+1);
Curve->Intervals(CutPnts_C3,GeomAbs_C3);
AdvApprox_PrefAndRec CutTool(CutPnts_C2,CutPnts_C3);
Standard_Integer NbInterv_C2 = Curve->NbIntervals(GeomAbs_C2);
TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2 + 1);
Curve->Intervals(CutPnts_C2, GeomAbs_C2);
Standard_Integer NbInterv_C3 = Curve->NbIntervals(GeomAbs_C3);
TColStd_Array1OfReal CutPnts_C3(1, NbInterv_C3 + 1);
Curve->Intervals(CutPnts_C3, GeomAbs_C3);
AdvApprox_PrefAndRec CutTool(CutPnts_C2, CutPnts_C3);
myMaxError = 0;
Approx_Curve3d_Eval ev (Curve, First, Last);
AdvApprox_ApproxAFunction aApprox (Num1DSS, Num2DSS, Num3DSS,
OneDTolNul, TwoDTolNul, ThreeDTol,
First, Last, Order,
MaxDegree, MaxSegments,
ev, CutTool);
Approx_Curve3d_Eval ev(Curve, First, Last);
AdvApprox_ApproxAFunction aApprox(Num1DSS,
Num2DSS,
Num3DSS,
OneDTolNul,
TwoDTolNul,
ThreeDTol,
First,
Last,
Order,
MaxDegree,
MaxSegments,
ev,
CutTool);
myIsDone = aApprox.IsDone();
myIsDone = aApprox.IsDone();
myHasResult = aApprox.HasResult();
if (myHasResult) {
TColgp_Array1OfPnt Poles(1,aApprox.NbPoles());
aApprox.Poles(1,Poles);
Handle(TColStd_HArray1OfReal) Knots = aApprox.Knots();
Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
Standard_Integer Degree = aApprox.Degree();
if (myHasResult)
{
TColgp_Array1OfPnt Poles(1, aApprox.NbPoles());
aApprox.Poles(1, Poles);
Handle(TColStd_HArray1OfReal) Knots = aApprox.Knots();
Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
Standard_Integer Degree = aApprox.Degree();
myBSplCurve = new Geom_BSplineCurve(Poles, Knots->Array1(), Mults->Array1(), Degree);
myMaxError = aApprox.MaxError(3, 1);
}
myMaxError = aApprox.MaxError(3, 1);
}
}
Handle(Geom_BSplineCurve) Approx_Curve3d::Curve() const
Handle(Geom_BSplineCurve) Approx_Curve3d::Curve() const
{
return myBSplCurve;
}
Standard_Boolean Approx_Curve3d::IsDone() const
Standard_Boolean Approx_Curve3d::IsDone() const
{
return myIsDone;
return myIsDone;
}
Standard_Boolean Approx_Curve3d::HasResult() const
Standard_Boolean Approx_Curve3d::HasResult() const
{
return myHasResult;
return myHasResult;
}
Standard_Real Approx_Curve3d::MaxError() const
Standard_Real Approx_Curve3d::MaxError() const
{
return myMaxError;
}
void Approx_Curve3d::Dump(Standard_OStream& o) const
void Approx_Curve3d::Dump(Standard_OStream& o) const
{
o << "******* Dump of ApproxCurve *******" << std::endl;
o << "*******Degree " << Curve()->Degree() << std::endl;

30
src/Approx/Approx_Curve3d.hxx
View File

@ -21,42 +21,42 @@
#include <GeomAbs_Shape.hxx>
#include <Geom_BSplineCurve.hxx>
class Approx_Curve3d
class Approx_Curve3d
{
public:
DEFINE_STANDARD_ALLOC
//! Approximation of a curve with respect of the
//! required tolerance Tol3D.
Standard_EXPORT Approx_Curve3d(const Handle(Adaptor3d_Curve)& Curve, const Standard_Real Tol3d, const GeomAbs_Shape Order, const Standard_Integer MaxSegments, const Standard_Integer MaxDegree);
Standard_EXPORT Approx_Curve3d(const Handle(Adaptor3d_Curve)& Curve,
const Standard_Real Tol3d,
const GeomAbs_Shape Order,
const Standard_Integer MaxSegments,
const Standard_Integer MaxDegree);
Standard_EXPORT Handle(Geom_BSplineCurve) Curve() const;
//! returns Standard_True if the approximation has
//! been done within required tolerance
Standard_EXPORT Standard_Boolean IsDone() const;
//! returns Standard_True if the approximation did come out
//! with a result that is not NECESSARELY within the required
//! tolerance
Standard_EXPORT Standard_Boolean HasResult() const;
//! returns the Maximum Error (>0 when an approximation
//! has been done, 0 if no approximation)
Standard_EXPORT Standard_Real MaxError() const;
//! Print on the stream o information about the object
Standard_EXPORT void Dump (Standard_OStream& o) const;
Standard_EXPORT void Dump(Standard_OStream& o) const;
private:
Standard_Boolean myIsDone;
Standard_Boolean myHasResult;
Standard_Boolean myIsDone;
Standard_Boolean myHasResult;
Handle(Geom_BSplineCurve) myBSplCurve;
Standard_Real myMaxError;
Standard_Real myMaxError;
};
#endif // _Approx_Curve3d_HeaderFile

644
src/Approx/Approx_CurveOnSurface.cxx
View File

@ -24,82 +24,84 @@
#include <AdvApprox_ApproxAFunction.hxx>
#include <AdvApprox_DichoCutting.hxx>
#include <AdvApprox_PrefAndRec.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomConvert.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <Precision.hxx>
#include <Standard_ConstructionError.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
//=======================================================================
//class : Approx_CurveOnSurface_Eval
//purpose: evaluator class for approximation of both 2d and 3d curves
//=======================================================================
//=================================================================================================
class Approx_CurveOnSurface_Eval : public AdvApprox_EvaluatorFunction
{
public:
Approx_CurveOnSurface_Eval (const Handle(Adaptor3d_Curve)& theFunc,
const Handle(Adaptor2d_Curve2d)& theFunc2d,
Standard_Real First, Standard_Real Last)
: fonct(theFunc), fonct2d(theFunc2d)
{ StartEndSav[0] = First; StartEndSav[1] = Last; }
virtual void Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Parameter,
Standard_Integer *DerivativeRequest,
Standard_Real *Result, // [Dimension]
Standard_Integer *ErrorCode);
private:
Handle(Adaptor3d_Curve) fonct;
public:
Approx_CurveOnSurface_Eval(const Handle(Adaptor3d_Curve)& theFunc,
const Handle(Adaptor2d_Curve2d)& theFunc2d,
Standard_Real First,
Standard_Real Last)
: fonct(theFunc),
fonct2d(theFunc2d)
{
StartEndSav[0] = First;
StartEndSav[1] = Last;
}
virtual void Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Parameter,
Standard_Integer* DerivativeRequest,
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode);
private:
Handle(Adaptor3d_Curve) fonct;
Handle(Adaptor2d_Curve2d) fonct2d;
Standard_Real StartEndSav[2];
Standard_Real StartEndSav[2];
};
void Approx_CurveOnSurface_Eval::Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Param, // Parameter at which evaluation
Standard_Integer *Order, // Derivative Request
Standard_Real *Result,// [Dimension]
Standard_Integer *ErrorCode)
void Approx_CurveOnSurface_Eval::Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Param, // Parameter at which evaluation
Standard_Integer* Order, // Derivative Request
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode)
{
*ErrorCode = 0;
*ErrorCode = 0;
Standard_Real par = *Param;
// Dimension is incorrect
if (*Dimension != 5) {
// Dimension is incorrect
if (*Dimension != 5)
{
*ErrorCode = 1;
}
// Parameter is incorrect
if(StartEnd[0] != StartEndSav[0] || StartEnd[1]!= StartEndSav[1])
{
fonct = fonct->Trim(StartEnd[0],StartEnd[1],Precision::PConfusion());
fonct2d = fonct2d->Trim(StartEnd[0],StartEnd[1],
Precision::PConfusion());
StartEndSav[0]=StartEnd[0];
StartEndSav[1]=StartEnd[1];
}
// Parameter is incorrect
if (StartEnd[0] != StartEndSav[0] || StartEnd[1] != StartEndSav[1])
{
fonct = fonct->Trim(StartEnd[0], StartEnd[1], Precision::PConfusion());
fonct2d = fonct2d->Trim(StartEnd[0], StartEnd[1], Precision::PConfusion());
StartEndSav[0] = StartEnd[0];
StartEndSav[1] = StartEnd[1];
}
gp_Pnt pnt;
gp_Pnt2d pnt2d;
switch (*Order) {
case 0:
{
switch (*Order)
{
case 0: {
fonct2d->D0(par, pnt2d);
fonct->D0(par, pnt);
Result[0] = pnt2d.X();
@ -109,25 +111,23 @@ void Approx_CurveOnSurface_Eval::Evaluate (Standard_Integer *Dimension,
Result[4] = pnt.Z();
break;
}
case 1:
{
gp_Vec v1;
case 1: {
gp_Vec v1;
gp_Vec2d v21;
fonct2d->D1(par, pnt2d, v21);
fonct->D1(par,pnt, v1);
fonct->D1(par, pnt, v1);
Result[0] = v21.X();
Result[1] = v21.Y();
Result[2] = v1.X();
Result[3] = v1.Y();
Result[4] = v1.Z();
break;
}
case 2:
{
gp_Vec v1, v2;
gp_Vec2d v21, v22;
}
case 2: {
gp_Vec v1, v2;
gp_Vec2d v21, v22;
fonct2d->D2(par, pnt2d, v21, v22);
fonct->D2(par, pnt, v1, v2);
fonct->D2(par, pnt, v1, v2);
Result[0] = v22.X();
Result[1] = v22.Y();
Result[2] = v2.X();
@ -135,71 +135,74 @@ void Approx_CurveOnSurface_Eval::Evaluate (Standard_Integer *Dimension,
Result[4] = v2.Z();
break;
}
default:
Result[0] = Result[1] = Result[2] = Result[3] = Result[4] = 0.;
*ErrorCode = 3;
break;
default:
Result[0] = Result[1] = Result[2] = Result[3] = Result[4] = 0.;
*ErrorCode = 3;
break;
}
}
//=======================================================================
//class : Approx_CurveOnSurface_Eval3d
//purpose: evaluator class for approximation of 3d curve
//=======================================================================
//=================================================================================================
class Approx_CurveOnSurface_Eval3d : public AdvApprox_EvaluatorFunction
{
public:
Approx_CurveOnSurface_Eval3d (const Handle(Adaptor3d_Curve)& theFunc,
Standard_Real First, Standard_Real Last)
: fonct(theFunc) { StartEndSav[0] = First; StartEndSav[1] = Last; }
virtual void Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Parameter,
Standard_Integer *DerivativeRequest,
Standard_Real *Result, // [Dimension]
Standard_Integer *ErrorCode);
private:
public:
Approx_CurveOnSurface_Eval3d(const Handle(Adaptor3d_Curve)& theFunc,
Standard_Real First,
Standard_Real Last)
: fonct(theFunc)
{
StartEndSav[0] = First;
StartEndSav[1] = Last;
}
virtual void Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Parameter,
Standard_Integer* DerivativeRequest,
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode);
private:
Handle(Adaptor3d_Curve) fonct;
Standard_Real StartEndSav[2];
Standard_Real StartEndSav[2];
};
void Approx_CurveOnSurface_Eval3d::Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Param, // Parameter at which evaluation
Standard_Integer *Order, // Derivative Request
Standard_Real *Result,// [Dimension]
Standard_Integer *ErrorCode)
void Approx_CurveOnSurface_Eval3d::Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Param, // Parameter at which evaluation
Standard_Integer* Order, // Derivative Request
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode)
{
*ErrorCode = 0;
*ErrorCode = 0;
Standard_Real par = *Param;
// Dimension is incorrect
if (*Dimension != 3) {
// Dimension is incorrect
if (*Dimension != 3)
{
*ErrorCode = 1;
}
// Parameter is incorrect
if(StartEnd[0] != StartEndSav[0] || StartEnd[1]!= StartEndSav[1])
{
fonct = fonct->Trim(StartEnd[0],StartEnd[1],Precision::PConfusion());
StartEndSav[0]=StartEnd[0];
StartEndSav[1]=StartEnd[1];
}
// Parameter is incorrect
if (StartEnd[0] != StartEndSav[0] || StartEnd[1] != StartEndSav[1])
{
fonct = fonct->Trim(StartEnd[0], StartEnd[1], Precision::PConfusion());
StartEndSav[0] = StartEnd[0];
StartEndSav[1] = StartEnd[1];
}
gp_Pnt pnt;
switch (*Order) {
case 0:
pnt = fonct->Value(par);
Result[0] = pnt.X();
Result[1] = pnt.Y();
Result[2] = pnt.Z();
break;
case 1:
{
switch (*Order)
{
case 0:
pnt = fonct->Value(par);
Result[0] = pnt.X();
Result[1] = pnt.Y();
Result[2] = pnt.Z();
break;
case 1: {
gp_Vec v1;
fonct->D1(par, pnt, v1);
Result[0] = v1.X();
@ -207,8 +210,7 @@ void Approx_CurveOnSurface_Eval3d::Evaluate (Standard_Integer *Dimension,
Result[2] = v1.Z();
break;
}
case 2:
{
case 2: {
gp_Vec v1, v2;
fonct->D2(par, pnt, v1, v2);
Result[0] = v2.X();
@ -216,160 +218,156 @@ void Approx_CurveOnSurface_Eval3d::Evaluate (Standard_Integer *Dimension,
Result[2] = v2.Z();
break;
}
default:
Result[0] = Result[1] = Result[2] = 0.;
*ErrorCode = 3;
break;
default:
Result[0] = Result[1] = Result[2] = 0.;
*ErrorCode = 3;
break;
}
}
//=======================================================================
//class : Approx_CurveOnSurface_Eval2d
//purpose: evaluator class for approximation of 2d curve
//=======================================================================
//=================================================================================================
class Approx_CurveOnSurface_Eval2d : public AdvApprox_EvaluatorFunction
{
public:
Approx_CurveOnSurface_Eval2d (const Handle(Adaptor2d_Curve2d)& theFunc2d,
Standard_Real First, Standard_Real Last)
: fonct2d(theFunc2d) { StartEndSav[0] = First; StartEndSav[1] = Last; }
virtual void Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Parameter,
Standard_Integer *DerivativeRequest,
Standard_Real *Result, // [Dimension]
Standard_Integer *ErrorCode);
private:
public:
Approx_CurveOnSurface_Eval2d(const Handle(Adaptor2d_Curve2d)& theFunc2d,
Standard_Real First,
Standard_Real Last)
: fonct2d(theFunc2d)
{
StartEndSav[0] = First;
StartEndSav[1] = Last;
}
virtual void Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Parameter,
Standard_Integer* DerivativeRequest,
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode);
private:
Handle(Adaptor2d_Curve2d) fonct2d;
Standard_Real StartEndSav[2];
Standard_Real StartEndSav[2];
};
void Approx_CurveOnSurface_Eval2d::Evaluate (Standard_Integer *Dimension,
Standard_Real StartEnd[2],
Standard_Real *Param, // Parameter at which evaluation
Standard_Integer *Order, // Derivative Request
Standard_Real *Result,// [Dimension]
Standard_Integer *ErrorCode)
void Approx_CurveOnSurface_Eval2d::Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Param, // Parameter at which evaluation
Standard_Integer* Order, // Derivative Request
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode)
{
*ErrorCode = 0;
*ErrorCode = 0;
Standard_Real par = *Param;
// Dimension is incorrect
if (*Dimension != 2) {
// Dimension is incorrect
if (*Dimension != 2)
{
*ErrorCode = 1;
}
// Parameter is incorrect
if(StartEnd[0] != StartEndSav[0] || StartEnd[1]!= StartEndSav[1])
{
fonct2d = fonct2d->Trim(StartEnd[0],StartEnd[1],Precision::PConfusion());
StartEndSav[0]=StartEnd[0];
StartEndSav[1]=StartEnd[1];
}
// Parameter is incorrect
if (StartEnd[0] != StartEndSav[0] || StartEnd[1] != StartEndSav[1])
{
fonct2d = fonct2d->Trim(StartEnd[0], StartEnd[1], Precision::PConfusion());
StartEndSav[0] = StartEnd[0];
StartEndSav[1] = StartEnd[1];
}
gp_Pnt2d pnt;
switch (*Order) {
case 0:
{
pnt = fonct2d->Value(par);
switch (*Order)
{
case 0: {
pnt = fonct2d->Value(par);
Result[0] = pnt.X();
Result[1] = pnt.Y();
break;
}
case 1:
{
case 1: {
gp_Vec2d v1;
fonct2d->D1(par, pnt, v1);
Result[0] = v1.X();
Result[1] = v1.Y();
break;
}
case 2:
{
case 2: {
gp_Vec2d v1, v2;
fonct2d->D2(par, pnt, v1, v2);
Result[0] = v2.X();
Result[1] = v2.Y();
break;
}
default:
Result[0] = Result[1] = 0.;
*ErrorCode = 3;
break;
default:
Result[0] = Result[1] = 0.;
*ErrorCode = 3;
break;
}
}
//=============================================================================
//function : Approx_CurveOnSurface
//purpose : Constructor
//=============================================================================
Approx_CurveOnSurface::Approx_CurveOnSurface(const Handle(Adaptor2d_Curve2d)& C2D,
const Handle(Adaptor3d_Surface)& Surf,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol,
const GeomAbs_Shape S,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments,
const Standard_Boolean only3d,
const Standard_Boolean only2d)
: myC2D(C2D),
mySurf(Surf),
myFirst(First),
myLast(Last),
myTol(Tol),
myIsDone(Standard_False),
myHasResult(Standard_False),
myError3d(0.0),
myError2dU(0.0),
myError2dV(0.0)
{
Perform(MaxSegments, MaxDegree, S, only3d, only2d);
}
//=================================================================================================
//=============================================================================
//function : Approx_CurveOnSurface
//purpose : Constructor
//=============================================================================
Approx_CurveOnSurface::Approx_CurveOnSurface(const Handle(Adaptor2d_Curve2d)& theC2D,
const Handle(Adaptor3d_Surface)& theSurf,
const Standard_Real theFirst,
const Standard_Real theLast,
const Standard_Real theTol)
: myC2D(theC2D),
mySurf(theSurf),
myFirst(theFirst),
myLast(theLast),
myTol(theTol),
myIsDone(Standard_False),
myHasResult(Standard_False),
myError3d(0.0),
myError2dU(0.0),
myError2dV(0.0)
Approx_CurveOnSurface::Approx_CurveOnSurface(const Handle(Adaptor2d_Curve2d)& C2D,
const Handle(Adaptor3d_Surface)& Surf,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol,
const GeomAbs_Shape S,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments,
const Standard_Boolean only3d,
const Standard_Boolean only2d)
: myC2D(C2D),
mySurf(Surf),
myFirst(First),
myLast(Last),
myTol(Tol),
myIsDone(Standard_False),
myHasResult(Standard_False),
myError3d(0.0),
myError2dU(0.0),
myError2dV(0.0)
{
Perform(MaxSegments, MaxDegree, S, only3d, only2d);
}
//=================================================================================================
Approx_CurveOnSurface::Approx_CurveOnSurface(const Handle(Adaptor2d_Curve2d)& theC2D,
const Handle(Adaptor3d_Surface)& theSurf,
const Standard_Real theFirst,
const Standard_Real theLast,
const Standard_Real theTol)
: myC2D(theC2D),
mySurf(theSurf),
myFirst(theFirst),
myLast(theLast),
myTol(theTol),
myIsDone(Standard_False),
myHasResult(Standard_False),
myError3d(0.0),
myError2dU(0.0),
myError2dV(0.0)
{
}
//=============================================================================
//function : Perform
//purpose :
//=============================================================================
//=================================================================================================
void Approx_CurveOnSurface::Perform(const Standard_Integer theMaxSegments,
const Standard_Integer theMaxDegree,
const GeomAbs_Shape theContinuity,
const Standard_Boolean theOnly3d,
const Standard_Boolean theOnly2d)
{
myIsDone = Standard_False;
myIsDone = Standard_False;
myHasResult = Standard_False;
myError2dU = 0.0;
myError2dV = 0.0;
myError3d = 0.0;
myError2dU = 0.0;
myError2dV = 0.0;
myError3d = 0.0;
if(theOnly3d && theOnly2d) throw Standard_ConstructionError();
if (theOnly3d && theOnly2d)
throw Standard_ConstructionError();
GeomAbs_Shape aContinuity = theContinuity;
if (aContinuity == GeomAbs_G1)
@ -377,42 +375,46 @@ void Approx_CurveOnSurface::Perform(const Standard_Integer theMaxSegments,
else if (aContinuity == GeomAbs_G2)
aContinuity = GeomAbs_C2;
else if (aContinuity > GeomAbs_C2)
aContinuity = GeomAbs_C2; //Restriction of AdvApprox_ApproxAFunction
aContinuity = GeomAbs_C2; // Restriction of AdvApprox_ApproxAFunction
Handle( Adaptor2d_Curve2d ) TrimmedC2D = myC2D->Trim( myFirst, myLast, Precision::PConfusion() );
Handle(Adaptor2d_Curve2d) TrimmedC2D = myC2D->Trim(myFirst, myLast, Precision::PConfusion());
Standard_Boolean isU, isForward;
Standard_Real aParam;
Standard_Real aParam;
if (theOnly3d && isIsoLine(TrimmedC2D, isU, aParam, isForward))
{
if (buildC3dOnIsoLine(TrimmedC2D, isU, aParam, isForward))
{
myIsDone = Standard_True;
myIsDone = Standard_True;
myHasResult = Standard_True;
return;
}
}
Handle(Adaptor3d_CurveOnSurface) HCOnS = new Adaptor3d_CurveOnSurface (TrimmedC2D, mySurf);
Handle(Adaptor3d_CurveOnSurface) HCOnS = new Adaptor3d_CurveOnSurface(TrimmedC2D, mySurf);
Standard_Integer Num1DSS = 0, Num2DSS=0, Num3DSS=0;
Standard_Integer Num1DSS = 0, Num2DSS = 0, Num3DSS = 0;
Handle(TColStd_HArray1OfReal) OneDTol;
Handle(TColStd_HArray1OfReal) TwoDTolNul;
Handle(TColStd_HArray1OfReal) ThreeDTol;
// create evaluators and choose appropriate one
Approx_CurveOnSurface_Eval3d Eval3dCvOnSurf (HCOnS, myFirst, myLast);
Approx_CurveOnSurface_Eval2d Eval2dCvOnSurf ( TrimmedC2D, myFirst, myLast);
Approx_CurveOnSurface_Eval EvalCvOnSurf (HCOnS, TrimmedC2D, myFirst, myLast);
Approx_CurveOnSurface_Eval3d Eval3dCvOnSurf(HCOnS, myFirst, myLast);
Approx_CurveOnSurface_Eval2d Eval2dCvOnSurf(TrimmedC2D, myFirst, myLast);
Approx_CurveOnSurface_Eval EvalCvOnSurf(HCOnS, TrimmedC2D, myFirst, myLast);
AdvApprox_EvaluatorFunction* EvalPtr;
if ( theOnly3d ) EvalPtr = &Eval3dCvOnSurf;
else if ( theOnly2d ) EvalPtr = &Eval2dCvOnSurf;
else EvalPtr = &EvalCvOnSurf;
if (theOnly3d)
EvalPtr = &Eval3dCvOnSurf;
else if (theOnly2d)
EvalPtr = &Eval2dCvOnSurf;
else
EvalPtr = &EvalCvOnSurf;
// Initialization for 2d approximation
if(!theOnly3d) {
if (!theOnly3d)
{
Num1DSS = 2;
OneDTol = new TColStd_HArray1OfReal(1,Num1DSS);
OneDTol = new TColStd_HArray1OfReal(1, Num1DSS);
Standard_Real TolU, TolV;
@ -435,144 +437,150 @@ void Approx_CurveOnSurface::Perform(const Standard_Integer theMaxSegments,
TolV = Min(1.e-3, 1.e2 * TolV);
}
OneDTol->SetValue(1,TolU);
OneDTol->SetValue(2,TolV);
OneDTol->SetValue(1, TolU);
OneDTol->SetValue(2, TolV);
}
if(!theOnly2d) {
Num3DSS=1;
ThreeDTol = new TColStd_HArray1OfReal(1,Num3DSS);
ThreeDTol->Init(myTol/2);
if (!theOnly2d)
{
Num3DSS = 1;
ThreeDTol = new TColStd_HArray1OfReal(1, Num3DSS);
ThreeDTol->Init(myTol / 2);
}
AdvApprox_Cutting* CutTool;
if (aContinuity <= myC2D->Continuity() &&
aContinuity <= mySurf->UContinuity() &&
aContinuity <= mySurf->VContinuity())
if (aContinuity <= myC2D->Continuity() && aContinuity <= mySurf->UContinuity()
&& aContinuity <= mySurf->VContinuity())
{
CutTool = new AdvApprox_DichoCutting();
}
else if (aContinuity == GeomAbs_C1)
{
Standard_Integer NbInterv_C1 = HCOnS->NbIntervals(GeomAbs_C1);
Standard_Integer NbInterv_C1 = HCOnS->NbIntervals(GeomAbs_C1);
TColStd_Array1OfReal CutPnts_C1(1, NbInterv_C1 + 1);
HCOnS->Intervals(CutPnts_C1, GeomAbs_C1);
Standard_Integer NbInterv_C2 = HCOnS->NbIntervals(GeomAbs_C2);
Standard_Integer NbInterv_C2 = HCOnS->NbIntervals(GeomAbs_C2);
TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2 + 1);
HCOnS->Intervals(CutPnts_C2, GeomAbs_C2);
CutTool = new AdvApprox_PrefAndRec (CutPnts_C1, CutPnts_C2);
CutTool = new AdvApprox_PrefAndRec(CutPnts_C1, CutPnts_C2);
}
else
{
Standard_Integer NbInterv_C2 = HCOnS->NbIntervals(GeomAbs_C2);
Standard_Integer NbInterv_C2 = HCOnS->NbIntervals(GeomAbs_C2);
TColStd_Array1OfReal CutPnts_C2(1, NbInterv_C2 + 1);
HCOnS->Intervals(CutPnts_C2, GeomAbs_C2);
Standard_Integer NbInterv_C3 = HCOnS->NbIntervals(GeomAbs_C3);
Standard_Integer NbInterv_C3 = HCOnS->NbIntervals(GeomAbs_C3);
TColStd_Array1OfReal CutPnts_C3(1, NbInterv_C3 + 1);
HCOnS->Intervals(CutPnts_C3, GeomAbs_C3);
CutTool = new AdvApprox_PrefAndRec (CutPnts_C2, CutPnts_C3);
CutTool = new AdvApprox_PrefAndRec(CutPnts_C2, CutPnts_C3);
}
AdvApprox_ApproxAFunction aApprox (Num1DSS, Num2DSS, Num3DSS,
OneDTol, TwoDTolNul, ThreeDTol,
myFirst, myLast, aContinuity,
theMaxDegree, theMaxSegments,
*EvalPtr, *CutTool);
AdvApprox_ApproxAFunction aApprox(Num1DSS,
Num2DSS,
Num3DSS,
OneDTol,
TwoDTolNul,
ThreeDTol,
myFirst,
myLast,
aContinuity,
theMaxDegree,
theMaxSegments,
*EvalPtr,
*CutTool);
delete CutTool;
myIsDone = aApprox.IsDone();
myIsDone = aApprox.IsDone();
myHasResult = aApprox.HasResult();
if (myHasResult) {
Handle(TColStd_HArray1OfReal) Knots = aApprox.Knots();
Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
Standard_Integer Degree = aApprox.Degree();
if(!theOnly2d)
{
TColgp_Array1OfPnt Poles(1,aApprox.NbPoles());
aApprox.Poles(1,Poles);
myCurve3d = new Geom_BSplineCurve(Poles, Knots->Array1(), Mults->Array1(), Degree);
myError3d = aApprox.MaxError(3, 1);
}
if(!theOnly3d)
{
TColgp_Array1OfPnt2d Poles2d(1,aApprox.NbPoles());
TColStd_Array1OfReal Poles1dU(1,aApprox.NbPoles());
aApprox.Poles1d(1, Poles1dU);
TColStd_Array1OfReal Poles1dV(1,aApprox.NbPoles());
aApprox.Poles1d(2, Poles1dV);
for(Standard_Integer i = 1; i <= aApprox.NbPoles(); i++)
Poles2d.SetValue(i, gp_Pnt2d(Poles1dU.Value(i), Poles1dV.Value(i)));
myCurve2d = new Geom2d_BSplineCurve(Poles2d, Knots->Array1(), Mults->Array1(), Degree);
myError2dU = aApprox.MaxError(1, 1);
myError2dV = aApprox.MaxError(1, 2);
}
if (myHasResult)
{
Handle(TColStd_HArray1OfReal) Knots = aApprox.Knots();
Handle(TColStd_HArray1OfInteger) Mults = aApprox.Multiplicities();
Standard_Integer Degree = aApprox.Degree();
if (!theOnly2d)
{
TColgp_Array1OfPnt Poles(1, aApprox.NbPoles());
aApprox.Poles(1, Poles);
myCurve3d = new Geom_BSplineCurve(Poles, Knots->Array1(), Mults->Array1(), Degree);
myError3d = aApprox.MaxError(3, 1);
}
if (!theOnly3d)
{
TColgp_Array1OfPnt2d Poles2d(1, aApprox.NbPoles());
TColStd_Array1OfReal Poles1dU(1, aApprox.NbPoles());
aApprox.Poles1d(1, Poles1dU);
TColStd_Array1OfReal Poles1dV(1, aApprox.NbPoles());
aApprox.Poles1d(2, Poles1dV);
for (Standard_Integer i = 1; i <= aApprox.NbPoles(); i++)
Poles2d.SetValue(i, gp_Pnt2d(Poles1dU.Value(i), Poles1dV.Value(i)));
myCurve2d = new Geom2d_BSplineCurve(Poles2d, Knots->Array1(), Mults->Array1(), Degree);
myError2dU = aApprox.MaxError(1, 1);
myError2dV = aApprox.MaxError(1, 2);
}
}
}
Standard_Boolean Approx_CurveOnSurface::IsDone() const
Standard_Boolean Approx_CurveOnSurface::IsDone() const
{
return myIsDone;
}
Standard_Boolean Approx_CurveOnSurface::HasResult() const
Standard_Boolean Approx_CurveOnSurface::HasResult() const
{
return myHasResult;
}
Handle(Geom_BSplineCurve) Approx_CurveOnSurface::Curve3d() const
Handle(Geom_BSplineCurve) Approx_CurveOnSurface::Curve3d() const
{
return myCurve3d;
}
Handle(Geom2d_BSplineCurve) Approx_CurveOnSurface::Curve2d() const
Handle(Geom2d_BSplineCurve) Approx_CurveOnSurface::Curve2d() const
{
return myCurve2d;
}
Standard_Real Approx_CurveOnSurface::MaxError3d() const
Standard_Real Approx_CurveOnSurface::MaxError3d() const
{
return myError3d;
}
Standard_Real Approx_CurveOnSurface::MaxError2dU() const
Standard_Real Approx_CurveOnSurface::MaxError2dU() const
{
return myError2dU;
}
Standard_Real Approx_CurveOnSurface::MaxError2dV() const
Standard_Real Approx_CurveOnSurface::MaxError2dV() const
{
return myError2dV;
}
//=============================================================================
//function : isIsoLine
//purpose :
//=============================================================================
//=================================================================================================
Standard_Boolean Approx_CurveOnSurface::isIsoLine(const Handle(Adaptor2d_Curve2d)& theC2D,
Standard_Boolean& theIsU,
Standard_Real& theParam,
Standard_Boolean& theIsForward) const
Standard_Boolean& theIsForward) const
{
// These variables are used to check line state (vertical or horizontal).
Standard_Boolean isAppropriateType = Standard_False;
gp_Pnt2d aLoc2d;
gp_Dir2d aDir2d;
gp_Pnt2d aLoc2d;
gp_Dir2d aDir2d;
// Test type.
const GeomAbs_CurveType aType = theC2D->GetType();
if (aType == GeomAbs_Line)
{
gp_Lin2d aLin2d = theC2D->Line();
aLoc2d = aLin2d.Location();
aDir2d = aLin2d.Direction();
gp_Lin2d aLin2d = theC2D->Line();
aLoc2d = aLin2d.Location();
aDir2d = aLin2d.Direction();
isAppropriateType = Standard_True;
}
else if (aType == GeomAbs_BSplineCurve)
@ -615,16 +623,16 @@ Standard_Boolean Approx_CurveOnSurface::isIsoLine(const Handle(Adaptor2d_Curve2d
if (aDir2d.IsParallel(gp::DX2d(), Precision::Angular()))
{
// Horizontal line. V = const.
theIsU = Standard_False;
theParam = aLoc2d.Y();
theIsU = Standard_False;
theParam = aLoc2d.Y();
theIsForward = aDir2d.Dot(gp::DX2d()) > 0.0;
return Standard_True;
}
else if (aDir2d.IsParallel(gp::DY2d(), Precision::Angular()))
{
// Vertical line. U = const.
theIsU = Standard_True;
theParam = aLoc2d.X();
theIsU = Standard_True;
theParam = aLoc2d.X();
theIsForward = aDir2d.Dot(gp::DY2d()) > 0.0;
return Standard_True;
}
@ -634,14 +642,12 @@ Standard_Boolean Approx_CurveOnSurface::isIsoLine(const Handle(Adaptor2d_Curve2d
#include <GeomLib.hxx>
//=============================================================================
//function : buildC3dOnIsoLine
//purpose :
//=============================================================================
//=================================================================================================
Standard_Boolean Approx_CurveOnSurface::buildC3dOnIsoLine(const Handle(Adaptor2d_Curve2d)& theC2D,
const Standard_Boolean theIsU,
const Standard_Real theParam,
const Standard_Boolean theIsForward)
const Standard_Boolean theIsForward)
{
// Convert adapter to the appropriate type.
Handle(GeomAdaptor_Surface) aGeomAdapter = Handle(GeomAdaptor_Surface)::DownCast(mySurf);
@ -653,13 +659,13 @@ Standard_Boolean Approx_CurveOnSurface::buildC3dOnIsoLine(const Handle(Adaptor2d
// Extract isoline
Handle(Geom_Surface) aSurf = aGeomAdapter->Surface();
Handle(Geom_Curve) aC3d;
Handle(Geom_Curve) aC3d;
gp_Pnt2d aF2d = theC2D->Value(theC2D->FirstParameter());
gp_Pnt2d aL2d = theC2D->Value(theC2D->LastParameter());
Standard_Boolean isToTrim = Standard_True;
Standard_Real U1, U2, V1, V2;
Standard_Real U1, U2, V1, V2;
aSurf->Bounds(U1, U2, V1, V2);
if (theIsU)
@ -676,7 +682,7 @@ Standard_Boolean Approx_CurveOnSurface::buildC3dOnIsoLine(const Handle(Adaptor2d
{
return Standard_False;
}
aSurf = new Geom_RectangularTrimmedSurface(aSurf, U1, U2, aV1Param, aV2Param);
aSurf = new Geom_RectangularTrimmedSurface(aSurf, U1, U2, aV1Param, aV2Param);
isToTrim = Standard_False;
}
else
@ -706,7 +712,7 @@ Standard_Boolean Approx_CurveOnSurface::buildC3dOnIsoLine(const Handle(Adaptor2d
{
return Standard_False;
}
aSurf = new Geom_RectangularTrimmedSurface(aSurf, aU1Param, aU2Param, V1, V2);
aSurf = new Geom_RectangularTrimmedSurface(aSurf, aU1Param, aU2Param, V1, V2);
isToTrim = Standard_False;
}
else
@ -729,7 +735,7 @@ Standard_Boolean Approx_CurveOnSurface::buildC3dOnIsoLine(const Handle(Adaptor2d
myCurve3d->Reverse();
// Rebuild parameterization for the 3d curve to have the same parameterization with
// a two-dimensional curve.
// a two-dimensional curve.
TColStd_Array1OfReal aKnots = myCurve3d->Knots();
BSplCLib::Reparametrize(theC2D->FirstParameter(), theC2D->LastParameter(), aKnots);
myCurve3d->SetKnots(aKnots);
@ -737,10 +743,10 @@ Standard_Boolean Approx_CurveOnSurface::buildC3dOnIsoLine(const Handle(Adaptor2d
// Evaluate error.
myError3d = 0.0;
const Standard_Real aParF = myFirst;
const Standard_Real aParL = myLast;
const Standard_Real aParF = myFirst;
const Standard_Real aParL = myLast;
const Standard_Integer aNbPnt = 23;
for(Standard_Integer anIdx = 0; anIdx <= aNbPnt; ++anIdx)
for (Standard_Integer anIdx = 0; anIdx <= aNbPnt; ++anIdx)
{
const Standard_Real aPar = aParF + ((aParL - aParF) * anIdx) / aNbPnt;
@ -750,7 +756,7 @@ Standard_Boolean Approx_CurveOnSurface::buildC3dOnIsoLine(const Handle(Adaptor2d
const gp_Pnt aPntC2D = mySurf->Value(aPnt2d.X(), aPnt2d.Y());
const Standard_Real aSqDeviation = aPntC3D.SquareDistance(aPntC2D);
myError3d = Max(aSqDeviation, myError3d);
myError3d = Max(aSqDeviation, myError3d);
}
myError3d = Sqrt(myError3d);
@ -758,7 +764,7 @@ Standard_Boolean Approx_CurveOnSurface::buildC3dOnIsoLine(const Handle(Adaptor2d
// Target tolerance is not obtained. This situation happens for isolines on the sphere.
// OCCT is unable to convert it keeping original parameterization, while the geometric
// form of the result is entirely identical. In that case, it is better to utilize
// a general-purpose approach.
// a general-purpose approach.
if (myError3d > myTol)
return Standard_False;

56
src/Approx/Approx_CurveOnSurface.hxx
View File

@ -25,15 +25,24 @@ class Geom_BSplineCurve;
class Geom2d_BSplineCurve;
//! Approximation of curve on surface
class Approx_CurveOnSurface
class Approx_CurveOnSurface
{
public:
DEFINE_STANDARD_ALLOC
//! This constructor calls perform method. This constructor is deprecated.
Standard_DEPRECATED("This constructor is deprecated. Use other constructor and perform method instead.")
Standard_EXPORT Approx_CurveOnSurface(const Handle(Adaptor2d_Curve2d)& C2D, const Handle(Adaptor3d_Surface)& Surf, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol, const GeomAbs_Shape Continuity, const Standard_Integer MaxDegree, const Standard_Integer MaxSegments, const Standard_Boolean Only3d = Standard_False, const Standard_Boolean Only2d = Standard_False);
Standard_DEPRECATED(
"This constructor is deprecated. Use other constructor and perform method instead.")
Standard_EXPORT Approx_CurveOnSurface(const Handle(Adaptor2d_Curve2d)& C2D,
const Handle(Adaptor3d_Surface)& Surf,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol,
const GeomAbs_Shape Continuity,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments,
const Standard_Boolean Only3d = Standard_False,
const Standard_Boolean Only2d = Standard_False);
//! This constructor does not call perform method.
//! @param theC2D 2D Curve to be approximated in 3D.
@ -43,22 +52,22 @@ public:
//! @param theTol Computation tolerance.
Standard_EXPORT Approx_CurveOnSurface(const Handle(Adaptor2d_Curve2d)& theC2D,
const Handle(Adaptor3d_Surface)& theSurf,
const Standard_Real theFirst,
const Standard_Real theLast,
const Standard_Real theTol);
const Standard_Real theFirst,
const Standard_Real theLast,
const Standard_Real theTol);
Standard_EXPORT Standard_Boolean IsDone() const;
Standard_EXPORT Standard_Boolean HasResult() const;
Standard_EXPORT Handle(Geom_BSplineCurve) Curve3d() const;
Standard_EXPORT Standard_Real MaxError3d() const;
Standard_EXPORT Handle(Geom2d_BSplineCurve) Curve2d() const;
Standard_EXPORT Standard_Real MaxError2dU() const;
//! returns the maximum errors relatively to the U component or the V component of the
//! 2d Curve
Standard_EXPORT Standard_Real MaxError2dV() const;
@ -70,14 +79,13 @@ public:
//! @param theContinuity Resulting continuity.
//! @param theOnly3d Determines building only 3D curve.
//! @param theOnly2d Determines building only 2D curve.
Standard_EXPORT void Perform(const Standard_Integer theMaxSegments,
const Standard_Integer theMaxDegree,
Standard_EXPORT void Perform(const Standard_Integer theMaxSegments,
const Standard_Integer theMaxDegree,
const GeomAbs_Shape theContinuity,
const Standard_Boolean theOnly3d = Standard_False,
const Standard_Boolean theOnly2d = Standard_False);
protected:
//! Checks whether the 2d curve is a isoline. It can be represented by b-spline, bezier,
//! or geometric line. This line should have natural parameterization.
//! @param theC2D Trimmed curve to be checked.
@ -103,10 +111,9 @@ protected:
const Standard_Boolean theIsForward);
private:
Approx_CurveOnSurface& operator= (const Approx_CurveOnSurface&);
Approx_CurveOnSurface& operator=(const Approx_CurveOnSurface&);
private:
//! Input curve.
const Handle(Adaptor2d_Curve2d) myC2D;
@ -123,13 +130,12 @@ private:
Standard_Real myTol;
Handle(Geom2d_BSplineCurve) myCurve2d;
Handle(Geom_BSplineCurve) myCurve3d;
Standard_Boolean myIsDone;
Standard_Boolean myHasResult;
Standard_Real myError3d;
Standard_Real myError2dU;
Standard_Real myError2dV;
Handle(Geom_BSplineCurve) myCurve3d;
Standard_Boolean myIsDone;
Standard_Boolean myHasResult;
Standard_Real myError3d;
Standard_Real myError2dU;
Standard_Real myError2dV;
};
#endif // _Approx_CurveOnSurface_HeaderFile

747
src/Approx/Approx_CurvilinearParameter.cxx
View File

File diff suppressed because it is too large Load Diff

74
src/Approx/Approx_CurvilinearParameter.hxx
View File

@ -33,65 +33,81 @@
//! @code
//! 1/2(S1(C2D1(u) + S2(C2D2(u)))
//! @endcode
class Approx_CurvilinearParameter
class Approx_CurvilinearParameter
{
public:
DEFINE_STANDARD_ALLOC
//! case of a free 3D curve
Standard_EXPORT Approx_CurvilinearParameter(const Handle(Adaptor3d_Curve)& C3D, const Standard_Real Tol, const GeomAbs_Shape Order, const Standard_Integer MaxDegree, const Standard_Integer MaxSegments);
Standard_EXPORT Approx_CurvilinearParameter(const Handle(Adaptor3d_Curve)& C3D,
const Standard_Real Tol,
const GeomAbs_Shape Order,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments);
//! case of a curve on one surface
Standard_EXPORT Approx_CurvilinearParameter(const Handle(Adaptor2d_Curve2d)& C2D, const Handle(Adaptor3d_Surface)& Surf, const Standard_Real Tol, const GeomAbs_Shape Order, const Standard_Integer MaxDegree, const Standard_Integer MaxSegments);
Standard_EXPORT Approx_CurvilinearParameter(const Handle(Adaptor2d_Curve2d)& C2D,
const Handle(Adaptor3d_Surface)& Surf,
const Standard_Real Tol,
const GeomAbs_Shape Order,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments);
//! case of a curve on two surfaces
Standard_EXPORT Approx_CurvilinearParameter(const Handle(Adaptor2d_Curve2d)& C2D1, const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor2d_Curve2d)& C2D2, const Handle(Adaptor3d_Surface)& Surf2, const Standard_Real Tol, const GeomAbs_Shape Order, const Standard_Integer MaxDegree, const Standard_Integer MaxSegments);
Standard_EXPORT Approx_CurvilinearParameter(const Handle(Adaptor2d_Curve2d)& C2D1,
const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor2d_Curve2d)& C2D2,
const Handle(Adaptor3d_Surface)& Surf2,
const Standard_Real Tol,
const GeomAbs_Shape Order,
const Standard_Integer MaxDegree,
const Standard_Integer MaxSegments);
Standard_EXPORT Standard_Boolean IsDone() const;
Standard_EXPORT Standard_Boolean HasResult() const;
//! returns the Bspline curve corresponding to the reparametrized 3D curve
Standard_EXPORT Handle(Geom_BSplineCurve) Curve3d() const;
//! returns the maximum error on the reparametrized 3D curve
Standard_EXPORT Standard_Real MaxError3d() const;
//! returns the BsplineCurve representing the reparametrized 2D curve on the
//! first surface (case of a curve on one or two surfaces)
Standard_EXPORT Handle(Geom2d_BSplineCurve) Curve2d1() const;
//! returns the maximum error on the first reparametrized 2D curve
Standard_EXPORT Standard_Real MaxError2d1() const;
//! returns the BsplineCurve representing the reparametrized 2D curve on the
//! second surface (case of a curve on two surfaces)
Standard_EXPORT Handle(Geom2d_BSplineCurve) Curve2d2() const;
//! returns the maximum error on the second reparametrized 2D curve
Standard_EXPORT Standard_Real MaxError2d2() const;
//! print the maximum errors(s)
Standard_EXPORT void Dump (Standard_OStream& o) const;
Standard_EXPORT void Dump(Standard_OStream& o) const;
private:
Standard_EXPORT static void ToleranceComputation (const Handle(Adaptor2d_Curve2d)& C2D, const Handle(Adaptor3d_Surface)& S, const Standard_Integer MaxNumber, const Standard_Real Tol, Standard_Real& TolV, Standard_Real& TolW);
Standard_EXPORT static void ToleranceComputation(const Handle(Adaptor2d_Curve2d)& C2D,
const Handle(Adaptor3d_Surface)& S,
const Standard_Integer MaxNumber,
const Standard_Real Tol,
Standard_Real& TolV,
Standard_Real& TolW);
private:
Standard_Integer myCase;
Standard_Boolean myDone;
Standard_Boolean myHasResult;
Handle(Geom_BSplineCurve) myCurve3d;
Standard_Real myMaxError3d;
Standard_Integer myCase;
Standard_Boolean myDone;
Standard_Boolean myHasResult;
Handle(Geom_BSplineCurve) myCurve3d;
Standard_Real myMaxError3d;
Handle(Geom2d_BSplineCurve) myCurve2d1;
Standard_Real myMaxError2d1;
Standard_Real myMaxError2d1;
Handle(Geom2d_BSplineCurve) myCurve2d2;
Standard_Real myMaxError2d2;
Standard_Real myMaxError2d2;
};
#endif // _Approx_CurvilinearParameter_HeaderFile

854
src/Approx/Approx_CurvlinFunc.cxx
View File

File diff suppressed because it is too large Load Diff

152
src/Approx/Approx_CurvlinFunc.hxx
View File

@ -31,112 +31,118 @@ class Approx_CurvlinFunc : public Standard_Transient
{
public:
Standard_EXPORT Approx_CurvlinFunc(const Handle(Adaptor3d_Curve)& C, const Standard_Real Tol);
Standard_EXPORT Approx_CurvlinFunc(const Handle(Adaptor2d_Curve2d)& C2D, const Handle(Adaptor3d_Surface)& S, const Standard_Real Tol);
Standard_EXPORT Approx_CurvlinFunc(const Handle(Adaptor2d_Curve2d)& C2D1, const Handle(Adaptor2d_Curve2d)& C2D2, const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Standard_Real Tol);
Standard_EXPORT Approx_CurvlinFunc(const Handle(Adaptor2d_Curve2d)& C2D,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real Tol);
Standard_EXPORT Approx_CurvlinFunc(const Handle(Adaptor2d_Curve2d)& C2D1,
const Handle(Adaptor2d_Curve2d)& C2D2,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Standard_Real Tol);
//! ---Purpose Update the tolerance to used
Standard_EXPORT void SetTol (const Standard_Real Tol);
Standard_EXPORT void SetTol(const Standard_Real Tol);
Standard_EXPORT Standard_Real FirstParameter() const;
Standard_EXPORT Standard_Real LastParameter() const;
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals (const GeomAbs_Shape S) const;
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const;
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const;
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const;
//! if First < 0 or Last > 1
Standard_EXPORT void Trim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
Standard_EXPORT void Trim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol);
//! Computes length of the curve.
Standard_EXPORT void Length();
//! Computes length of the curve segment.
Standard_EXPORT Standard_Real Length (Adaptor3d_Curve& C, const Standard_Real FirstU, const Standard_Real LasrU) const;
Standard_EXPORT Standard_Real Length(Adaptor3d_Curve& C,
const Standard_Real FirstU,
const Standard_Real LasrU) const;
Standard_EXPORT Standard_Real GetLength() const;
//! returns original parameter corresponding S. if
//! Case == 1 computation is performed on myC2D1 and mySurf1,
//! otherwise it is done on myC2D2 and mySurf2.
Standard_EXPORT Standard_Real GetUParameter (Adaptor3d_Curve& C, const Standard_Real S, const Standard_Integer NumberOfCurve) const;
Standard_EXPORT Standard_Real GetUParameter(Adaptor3d_Curve& C,
const Standard_Real S,
const Standard_Integer NumberOfCurve) const;
//! returns original parameter corresponding S.
Standard_EXPORT Standard_Real GetSParameter (const Standard_Real U) const;
Standard_EXPORT Standard_Real GetSParameter(const Standard_Real U) const;
//! if myCase != 1
Standard_EXPORT Standard_Boolean EvalCase1 (const Standard_Real S, const Standard_Integer Order, TColStd_Array1OfReal& Result) const;
Standard_EXPORT Standard_Boolean EvalCase1(const Standard_Real S,
const Standard_Integer Order,
TColStd_Array1OfReal& Result) const;
//! if myCase != 2
Standard_EXPORT Standard_Boolean EvalCase2 (const Standard_Real S, const Standard_Integer Order, TColStd_Array1OfReal& Result) const;
Standard_EXPORT Standard_Boolean EvalCase2(const Standard_Real S,
const Standard_Integer Order,
TColStd_Array1OfReal& Result) const;
//! if myCase != 3
Standard_EXPORT Standard_Boolean EvalCase3 (const Standard_Real S, const Standard_Integer Order, TColStd_Array1OfReal& Result);
Standard_EXPORT Standard_Boolean EvalCase3(const Standard_Real S,
const Standard_Integer Order,
TColStd_Array1OfReal& Result);
DEFINE_STANDARD_RTTIEXT(Approx_CurvlinFunc,Standard_Transient)
DEFINE_STANDARD_RTTIEXT(Approx_CurvlinFunc, Standard_Transient)
protected:
private:
Standard_EXPORT void Init();
Standard_EXPORT void Init (Adaptor3d_Curve& C, Handle(TColStd_HArray1OfReal)& Si, Handle(TColStd_HArray1OfReal)& Ui) const;
//! returns curvilinear parameter corresponding U.
Standard_EXPORT Standard_Real GetSParameter (Adaptor3d_Curve& C, const Standard_Real U, const Standard_Real Length) const;
Standard_EXPORT Standard_Boolean EvalCurOnSur (const Standard_Real S, const Standard_Integer Order, TColStd_Array1OfReal& Result, const Standard_Integer NumberOfCurve) const;
Handle(Adaptor3d_Curve) myC3D;
Handle(Adaptor2d_Curve2d) myC2D1;
Handle(Adaptor2d_Curve2d) myC2D2;
Handle(Adaptor3d_Surface) mySurf1;
Handle(Adaptor3d_Surface) mySurf2;
Standard_Integer myCase;
Standard_Real myFirstS;
Standard_Real myLastS;
Standard_Real myFirstU1;
Standard_Real myLastU1;
Standard_Real myFirstU2;
Standard_Real myLastU2;
Standard_Real myLength;
Standard_Real myLength1;
Standard_Real myLength2;
Standard_Real myTolLen;
Standard_Real myPrevS;
Standard_Real myPrevU;
Standard_EXPORT void Init(Adaptor3d_Curve& C,
Handle(TColStd_HArray1OfReal)& Si,
Handle(TColStd_HArray1OfReal)& Ui) const;
//! returns curvilinear parameter corresponding U.
Standard_EXPORT Standard_Real GetSParameter(Adaptor3d_Curve& C,
const Standard_Real U,
const Standard_Real Length) const;
Standard_EXPORT Standard_Boolean EvalCurOnSur(const Standard_Real S,
const Standard_Integer Order,
TColStd_Array1OfReal& Result,
const Standard_Integer NumberOfCurve) const;
Handle(Adaptor3d_Curve) myC3D;
Handle(Adaptor2d_Curve2d) myC2D1;
Handle(Adaptor2d_Curve2d) myC2D2;
Handle(Adaptor3d_Surface) mySurf1;
Handle(Adaptor3d_Surface) mySurf2;
Standard_Integer myCase;
Standard_Real myFirstS;
Standard_Real myLastS;
Standard_Real myFirstU1;
Standard_Real myLastU1;
Standard_Real myFirstU2;
Standard_Real myLastU2;
Standard_Real myLength;
Standard_Real myLength1;
Standard_Real myLength2;
Standard_Real myTolLen;
Standard_Real myPrevS;
Standard_Real myPrevU;
Handle(TColStd_HArray1OfReal) myUi_1;
Handle(TColStd_HArray1OfReal) mySi_1;
Handle(TColStd_HArray1OfReal) myUi_2;
Handle(TColStd_HArray1OfReal) mySi_2;
};
#endif // _Approx_CurvlinFunc_HeaderFile

141
src/Approx/Approx_FitAndDivide.hxx
View File

@ -20,47 +20,61 @@
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <AppParCurves_SequenceOfMultiCurve.hxx>
#include <TColStd_SequenceOfReal.hxx>
#include <AppParCurves_MultiCurve.hxx>
#include <Standard_Integer.hxx>
#include <AppParCurves_Constraint.hxx>
#include <AppCont_Function.hxx>
#include <AppParCurves_Constraint.hxx>
#include <AppParCurves_MultiCurve.hxx>
#include <AppParCurves_SequenceOfMultiCurve.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_SequenceOfReal.hxx>
class AppParCurves_MultiCurve;
class Approx_FitAndDivide
class Approx_FitAndDivide
{
public:
DEFINE_STANDARD_ALLOC
//! The MultiLine <Line> will be approximated until tolerances
//! will be reached.
//! The approximation will be done from degreemin to degreemax
//! with a cutting if the corresponding boolean is True.
Standard_EXPORT Approx_FitAndDivide(const AppCont_Function& Line, const Standard_Integer degreemin = 3, const Standard_Integer degreemax = 8, const Standard_Real Tolerance3d = 1.0e-5, const Standard_Real Tolerance2d = 1.0e-5, const Standard_Boolean cutting = Standard_False, const AppParCurves_Constraint FirstC = AppParCurves_TangencyPoint, const AppParCurves_Constraint LastC = AppParCurves_TangencyPoint);
Standard_EXPORT Approx_FitAndDivide(
const AppCont_Function& Line,
const Standard_Integer degreemin = 3,
const Standard_Integer degreemax = 8,
const Standard_Real Tolerance3d = 1.0e-5,
const Standard_Real Tolerance2d = 1.0e-5,
const Standard_Boolean cutting = Standard_False,
const AppParCurves_Constraint FirstC = AppParCurves_TangencyPoint,
const AppParCurves_Constraint LastC = AppParCurves_TangencyPoint);
//! Initializes the fields of the algorithm.
Standard_EXPORT Approx_FitAndDivide(const Standard_Integer degreemin = 3, const Standard_Integer degreemax = 8, const Standard_Real Tolerance3d = 1.0e-05, const Standard_Real Tolerance2d = 1.0e-05, const Standard_Boolean cutting = Standard_False, const AppParCurves_Constraint FirstC = AppParCurves_TangencyPoint, const AppParCurves_Constraint LastC = AppParCurves_TangencyPoint);
Standard_EXPORT Approx_FitAndDivide(
const Standard_Integer degreemin = 3,
const Standard_Integer degreemax = 8,
const Standard_Real Tolerance3d = 1.0e-05,
const Standard_Real Tolerance2d = 1.0e-05,
const Standard_Boolean cutting = Standard_False,
const AppParCurves_Constraint FirstC = AppParCurves_TangencyPoint,
const AppParCurves_Constraint LastC = AppParCurves_TangencyPoint);
//! runs the algorithm after having initialized the fields.
Standard_EXPORT void Perform (const AppCont_Function& Line);
Standard_EXPORT void Perform(const AppCont_Function& Line);
//! changes the degrees of the approximation.
Standard_EXPORT void SetDegrees (const Standard_Integer degreemin, const Standard_Integer degreemax);
Standard_EXPORT void SetDegrees(const Standard_Integer degreemin,
const Standard_Integer degreemax);
//! Changes the tolerances of the approximation.
Standard_EXPORT void SetTolerances (const Standard_Real Tolerance3d, const Standard_Real Tolerance2d);
Standard_EXPORT void SetTolerances(const Standard_Real Tolerance3d,
const Standard_Real Tolerance2d);
//! Changes the constraints of the approximation.
Standard_EXPORT void SetConstraints (const AppParCurves_Constraint FirstC, const AppParCurves_Constraint LastC);
Standard_EXPORT void SetConstraints(const AppParCurves_Constraint FirstC,
const AppParCurves_Constraint LastC);
//! Changes the max number of segments, which is allowed for cutting.
Standard_EXPORT void SetMaxSegments (const Standard_Integer theMaxSegments);
Standard_EXPORT void SetMaxSegments(const Standard_Integer theMaxSegments);
//! Set inverse order of degree selection:
//! if theInvOrdr = true, current degree is chosen by inverse order -
//! from maxdegree to mindegree.
@ -77,66 +91,55 @@ public:
//! the status NoApproximation has been sent by the user
//! when more points were needed.
Standard_EXPORT Standard_Boolean IsAllApproximated() const;
//! returns False if the status NoPointsAdded has been sent.
Standard_EXPORT Standard_Boolean IsToleranceReached() const;
//! returns the tolerances 2d and 3d of the <Index> MultiCurve.
Standard_EXPORT void Error (const Standard_Integer Index, Standard_Real& tol3d, Standard_Real& tol2d) const;
Standard_EXPORT void Error(const Standard_Integer Index,
Standard_Real& tol3d,
Standard_Real& tol2d) const;
//! Returns the number of MultiCurve doing the approximation
//! of the MultiLine.
Standard_EXPORT Standard_Integer NbMultiCurves() const;
//! returns the approximation MultiCurve of range <Index>.
Standard_EXPORT AppParCurves_MultiCurve Value (const Standard_Integer Index = 1) const;
Standard_EXPORT void Parameters (const Standard_Integer Index, Standard_Real& firstp, Standard_Real& lastp) const;
Standard_EXPORT AppParCurves_MultiCurve Value(const Standard_Integer Index = 1) const;
Standard_EXPORT void Parameters(const Standard_Integer Index,
Standard_Real& firstp,
Standard_Real& lastp) const;
protected:
private:
//! is internally used by the algorithms.
Standard_EXPORT Standard_Boolean Compute (const AppCont_Function& Line, const Standard_Real Ufirst, const Standard_Real Ulast, Standard_Real& TheTol3d, Standard_Real& TheTol2d);
Standard_EXPORT Standard_Boolean Compute(const AppCont_Function& Line,
const Standard_Real Ufirst,
const Standard_Real Ulast,
Standard_Real& TheTol3d,
Standard_Real& TheTol2d);
AppParCurves_SequenceOfMultiCurve myMultiCurves;
TColStd_SequenceOfReal myfirstparam;
TColStd_SequenceOfReal mylastparam;
AppParCurves_MultiCurve TheMultiCurve;
Standard_Boolean alldone;
Standard_Boolean tolreached;
TColStd_SequenceOfReal Tolers3d;
TColStd_SequenceOfReal Tolers2d;
Standard_Integer mydegremin;
Standard_Integer mydegremax;
Standard_Real mytol3d;
Standard_Real mytol2d;
Standard_Real currenttol3d;
Standard_Real currenttol2d;
Standard_Boolean mycut;
AppParCurves_Constraint myfirstC;
AppParCurves_Constraint mylastC;
Standard_Integer myMaxSegments;
Standard_Boolean myInvOrder;
Standard_Boolean myHangChecking;
TColStd_SequenceOfReal myfirstparam;
TColStd_SequenceOfReal mylastparam;
AppParCurves_MultiCurve TheMultiCurve;
Standard_Boolean alldone;
Standard_Boolean tolreached;
TColStd_SequenceOfReal Tolers3d;
TColStd_SequenceOfReal Tolers2d;
Standard_Integer mydegremin;
Standard_Integer mydegremax;
Standard_Real mytol3d;
Standard_Real mytol2d;
Standard_Real currenttol3d;
Standard_Real currenttol2d;
Standard_Boolean mycut;
AppParCurves_Constraint myfirstC;
AppParCurves_Constraint mylastC;
Standard_Integer myMaxSegments;
Standard_Boolean myInvOrder;
Standard_Boolean myHangChecking;
};
#endif // _Approx_FitAndDivide_HeaderFile

142
src/Approx/Approx_FitAndDivide2d.hxx
View File

@ -20,47 +20,61 @@
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <AppParCurves_SequenceOfMultiCurve.hxx>
#include <TColStd_SequenceOfReal.hxx>
#include <AppParCurves_MultiCurve.hxx>
#include <Standard_Integer.hxx>
#include <AppParCurves_Constraint.hxx>
#include <AppCont_Function.hxx>
#include <AppParCurves_Constraint.hxx>
#include <AppParCurves_MultiCurve.hxx>
#include <AppParCurves_SequenceOfMultiCurve.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_SequenceOfReal.hxx>
class AppParCurves_MultiCurve;
class Approx_FitAndDivide2d
class Approx_FitAndDivide2d
{
public:
DEFINE_STANDARD_ALLOC
//! The MultiLine <Line> will be approximated until tolerances
//! will be reached.
//! The approximation will be done from degreemin to degreemax
//! with a cutting if the corresponding boolean is True.
Standard_EXPORT Approx_FitAndDivide2d(const AppCont_Function& Line, const Standard_Integer degreemin = 3, const Standard_Integer degreemax = 8, const Standard_Real Tolerance3d = 1.0e-5, const Standard_Real Tolerance2d = 1.0e-5, const Standard_Boolean cutting = Standard_False, const AppParCurves_Constraint FirstC = AppParCurves_TangencyPoint, const AppParCurves_Constraint LastC = AppParCurves_TangencyPoint);
Standard_EXPORT Approx_FitAndDivide2d(
const AppCont_Function& Line,
const Standard_Integer degreemin = 3,
const Standard_Integer degreemax = 8,
const Standard_Real Tolerance3d = 1.0e-5,
const Standard_Real Tolerance2d = 1.0e-5,
const Standard_Boolean cutting = Standard_False,
const AppParCurves_Constraint FirstC = AppParCurves_TangencyPoint,
const AppParCurves_Constraint LastC = AppParCurves_TangencyPoint);
//! Initializes the fields of the algorithm.
Standard_EXPORT Approx_FitAndDivide2d(const Standard_Integer degreemin = 3, const Standard_Integer degreemax = 8, const Standard_Real Tolerance3d = 1.0e-05, const Standard_Real Tolerance2d = 1.0e-05, const Standard_Boolean cutting = Standard_False, const AppParCurves_Constraint FirstC = AppParCurves_TangencyPoint, const AppParCurves_Constraint LastC = AppParCurves_TangencyPoint);
Standard_EXPORT Approx_FitAndDivide2d(
const Standard_Integer degreemin = 3,
const Standard_Integer degreemax = 8,
const Standard_Real Tolerance3d = 1.0e-05,
const Standard_Real Tolerance2d = 1.0e-05,
const Standard_Boolean cutting = Standard_False,
const AppParCurves_Constraint FirstC = AppParCurves_TangencyPoint,
const AppParCurves_Constraint LastC = AppParCurves_TangencyPoint);
//! runs the algorithm after having initialized the fields.
Standard_EXPORT void Perform (const AppCont_Function& Line);
Standard_EXPORT void Perform(const AppCont_Function& Line);
//! changes the degrees of the approximation.
Standard_EXPORT void SetDegrees (const Standard_Integer degreemin, const Standard_Integer degreemax);
Standard_EXPORT void SetDegrees(const Standard_Integer degreemin,
const Standard_Integer degreemax);
//! Changes the tolerances of the approximation.
Standard_EXPORT void SetTolerances (const Standard_Real Tolerance3d, const Standard_Real Tolerance2d);
Standard_EXPORT void SetTolerances(const Standard_Real Tolerance3d,
const Standard_Real Tolerance2d);
//! Changes the constraints of the approximation.
Standard_EXPORT void SetConstraints (const AppParCurves_Constraint FirstC, const AppParCurves_Constraint LastC);
Standard_EXPORT void SetConstraints(const AppParCurves_Constraint FirstC,
const AppParCurves_Constraint LastC);
//! Changes the max number of segments, which is allowed for cutting.
Standard_EXPORT void SetMaxSegments (const Standard_Integer theMaxSegments);
Standard_EXPORT void SetMaxSegments(const Standard_Integer theMaxSegments);
//! Set inverse order of degree selection:
//! if theInvOrdr = true, current degree is chosen by inverse order -
//! from maxdegree to mindegree.
@ -72,70 +86,60 @@ public:
//! and algorithm is forced to stop.
//! By default hang checking is used.
Standard_EXPORT void SetHangChecking(const Standard_Boolean theHangChecking);
//! returns False if at a moment of the approximation,
//! the status NoApproximation has been sent by the user
//! when more points were needed.
Standard_EXPORT Standard_Boolean IsAllApproximated() const;
//! returns False if the status NoPointsAdded has been sent.
Standard_EXPORT Standard_Boolean IsToleranceReached() const;
//! returns the tolerances 2d and 3d of the <Index> MultiCurve.
Standard_EXPORT void Error (const Standard_Integer Index, Standard_Real& tol3d, Standard_Real& tol2d) const;
Standard_EXPORT void Error(const Standard_Integer Index,
Standard_Real& tol3d,
Standard_Real& tol2d) const;
//! Returns the number of MultiCurve doing the approximation
//! of the MultiLine.
Standard_EXPORT Standard_Integer NbMultiCurves() const;
//! returns the approximation MultiCurve of range <Index>.
Standard_EXPORT AppParCurves_MultiCurve Value (const Standard_Integer Index = 1) const;
Standard_EXPORT void Parameters (const Standard_Integer Index, Standard_Real& firstp, Standard_Real& lastp) const;
Standard_EXPORT AppParCurves_MultiCurve Value(const Standard_Integer Index = 1) const;
Standard_EXPORT void Parameters(const Standard_Integer Index,
Standard_Real& firstp,
Standard_Real& lastp) const;
protected:
private:
//! is internally used by the algorithms.
Standard_EXPORT Standard_Boolean Compute (const AppCont_Function& Line, const Standard_Real Ufirst, const Standard_Real Ulast, Standard_Real& TheTol3d, Standard_Real& TheTol2d);
Standard_EXPORT Standard_Boolean Compute(const AppCont_Function& Line,
const Standard_Real Ufirst,
const Standard_Real Ulast,
Standard_Real& TheTol3d,
Standard_Real& TheTol2d);
AppParCurves_SequenceOfMultiCurve myMultiCurves;
TColStd_SequenceOfReal myfirstparam;
TColStd_SequenceOfReal mylastparam;
AppParCurves_MultiCurve TheMultiCurve;
Standard_Boolean alldone;
Standard_Boolean tolreached;
TColStd_SequenceOfReal Tolers3d;
TColStd_SequenceOfReal Tolers2d;
Standard_Integer mydegremin;
Standard_Integer mydegremax;
Standard_Real mytol3d;
Standard_Real mytol2d;
Standard_Real currenttol3d;
Standard_Real currenttol2d;
Standard_Boolean mycut;
AppParCurves_Constraint myfirstC;
AppParCurves_Constraint mylastC;
Standard_Integer myMaxSegments;
Standard_Boolean myInvOrder;
Standard_Boolean myHangChecking;
TColStd_SequenceOfReal myfirstparam;
TColStd_SequenceOfReal mylastparam;
AppParCurves_MultiCurve TheMultiCurve;
Standard_Boolean alldone;
Standard_Boolean tolreached;
TColStd_SequenceOfReal Tolers3d;
TColStd_SequenceOfReal Tolers2d;
Standard_Integer mydegremin;
Standard_Integer mydegremax;
Standard_Real mytol3d;
Standard_Real mytol2d;
Standard_Real currenttol3d;
Standard_Real currenttol2d;
Standard_Boolean mycut;
AppParCurves_Constraint myfirstC;
AppParCurves_Constraint mylastC;
Standard_Integer myMaxSegments;
Standard_Boolean myInvOrder;
Standard_Boolean myHangChecking;
};
#endif // _Approx_FitAndDivide2d_HeaderFile

2
src/Approx/Approx_FitAndDivide2d_0.cxx
View File

@ -17,11 +17,9 @@
#include <Approx_FitAndDivide2d.hxx>
#include <AppParCurves_MultiCurve.hxx>
#define MultiLine AppCont_Function
#define MultiLine_hxx <AppCont_Function.hxx>
#define Approx_ComputeCLine Approx_FitAndDivide2d
#define Approx_ComputeCLine_hxx <Approx_FitAndDivide2d.hxx>
#include "../Approx/Approx_ComputeCLine.gxx"

2
src/Approx/Approx_FitAndDivide_0.cxx
View File

@ -17,11 +17,9 @@
#include <Approx_FitAndDivide.hxx>
#include <AppParCurves_MultiCurve.hxx>
#define MultiLine AppCont_Function
#define MultiLine_hxx <AppCont_Function.hxx>
#define Approx_ComputeCLine Approx_FitAndDivide
#define Approx_ComputeCLine_hxx <Approx_FitAndDivide.hxx>
#include "../Approx/Approx_ComputeCLine.gxx"

1
src/Approx/Approx_HArray1OfAdHSurface.hxx
View File

@ -23,5 +23,4 @@
DEFINE_HARRAY1(Approx_HArray1OfAdHSurface, Approx_Array1OfAdHSurface)
#endif

1
src/Approx/Approx_HArray1OfGTrsf2d.hxx
View File

@ -22,5 +22,4 @@
DEFINE_HARRAY1(Approx_HArray1OfGTrsf2d, Approx_Array1OfGTrsf2d)
#endif

268
src/Approx/Approx_MCurvesToBSpCurve.cxx
View File

@ -12,46 +12,49 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <AppParCurves_MultiPoint.hxx>
#include <Approx_MCurvesToBSpCurve.hxx>
#include <BSplCLib.hxx>
#include <Convert_CompBezierCurves2dToBSplineCurve2d.hxx>
#include <Convert_CompBezierCurvesToBSplineCurve.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#ifdef OCCT_DEBUG
static void DEBUG(const AppParCurves_MultiCurve& MC) {
Standard_Integer i, j;
Standard_Integer nbcu = MC.NbCurves();
Standard_Integer nbpoles = MC.NbPoles();
TColgp_Array1OfPnt Poles(1, nbpoles);
static void DEBUG(const AppParCurves_MultiCurve& MC)
{
Standard_Integer i, j;
Standard_Integer nbcu = MC.NbCurves();
Standard_Integer nbpoles = MC.NbPoles();
TColgp_Array1OfPnt Poles(1, nbpoles);
TColgp_Array1OfPnt2d Poles2d(1, nbpoles);
for (i = 1; i <= nbcu; i++) {
for (i = 1; i <= nbcu; i++)
{
std::cout << " Curve No. " << i << std::endl;
if (MC.Dimension(i) == 3) {
if (MC.Dimension(i) == 3)
{
MC.Curve(i, Poles);
for (j = 1; j <= nbpoles; j++) {
std::cout<< " Pole = " << Poles(j).X() <<" "<<Poles(j).Y()<<" "<<Poles(j).Z()<< std::endl;
for (j = 1; j <= nbpoles; j++)
{
std::cout << " Pole = " << Poles(j).X() << " " << Poles(j).Y() << " " << Poles(j).Z()
<< std::endl;
}
}
else {
else
{
MC.Curve(i, Poles2d);
for (j = 1; j <= nbpoles; j++) {
std::cout<< " Pole = " << Poles2d(j).X() <<" "<<Poles2d(j).Y()<< std::endl;
for (j = 1; j <= nbpoles; j++)
{
std::cout << " Pole = " << Poles2d(j).X() << " " << Poles2d(j).Y() << std::endl;
}
}
}
}
#endif
Approx_MCurvesToBSpCurve::Approx_MCurvesToBSpCurve()
{
myDone = Standard_False;
@ -68,181 +71,210 @@ void Approx_MCurvesToBSpCurve::Append(const AppParCurves_MultiCurve& MC)
myCurves.Append(MC);
}
void Approx_MCurvesToBSpCurve::Perform()
{
Perform(myCurves);
}
void Approx_MCurvesToBSpCurve::Perform
(const AppParCurves_SequenceOfMultiCurve& TheSeq)
void Approx_MCurvesToBSpCurve::Perform(const AppParCurves_SequenceOfMultiCurve& TheSeq)
{
Standard_Integer i, j, deg=0;
Standard_Integer nbcu = TheSeq.Length();
Standard_Integer i, j, deg = 0;
Standard_Integer nbcu = TheSeq.Length();
AppParCurves_MultiCurve CU;
Standard_Integer nbpolesspl=0, nbknots=0;
Standard_Integer nbpolesspl = 0, nbknots = 0;
#ifdef OCCT_DEBUG
Standard_Boolean debug = Standard_False;
#endif
#endif
if (nbcu == 1) {
CU = TheSeq.Value(1);
if (nbcu == 1)
{
CU = TheSeq.Value(1);
deg = CU.Degree();
TColStd_Array1OfReal Knots(1, 2);
TColStd_Array1OfReal Knots(1, 2);
TColStd_Array1OfInteger Mults(1, 2);
Knots(1) = 0.0;
Knots(2) = 1.0;
Mults(1) = Mults(2) = deg+1;
mySpline = AppParCurves_MultiBSpCurve (CU, Knots, Mults);
Mults(1) = Mults(2) = deg + 1;
mySpline = AppParCurves_MultiBSpCurve(CU, Knots, Mults);
}
else {
else
{
AppParCurves_MultiPoint P = TheSeq.Value(nbcu).Value(1);
Standard_Integer nb3d = P.NbPoints();
Standard_Integer nb2d = P.NbPoints2d();
AppParCurves_MultiPoint P = TheSeq.Value(nbcu).Value(1);
Standard_Integer nb3d = P.NbPoints();
Standard_Integer nb2d = P.NbPoints2d();
Convert_CompBezierCurvesToBSplineCurve conv;
Convert_CompBezierCurvesToBSplineCurve conv;
Convert_CompBezierCurves2dToBSplineCurve2d conv2d;
if (nb3d != 0) {
for (i = 1; i <= nbcu; i++) {
CU = TheSeq.Value(i);
TColgp_Array1OfPnt ThePoles3d(1, CU.NbPoles());
CU.Curve(1, ThePoles3d);
conv.AddCurve(ThePoles3d);
if (nb3d != 0)
{
for (i = 1; i <= nbcu; i++)
{
CU = TheSeq.Value(i);
TColgp_Array1OfPnt ThePoles3d(1, CU.NbPoles());
CU.Curve(1, ThePoles3d);
conv.AddCurve(ThePoles3d);
}
conv.Perform();
}
else if (nb2d != 0) {
for (i = 1; i <= nbcu; i++) {
CU = TheSeq.Value(i);
TColgp_Array1OfPnt2d ThePoles2d(1, CU.NbPoles());
CU.Curve(1+nb3d, ThePoles2d);
conv2d.AddCurve(ThePoles2d);
else if (nb2d != 0)
{
for (i = 1; i <= nbcu; i++)
{
CU = TheSeq.Value(i);
TColgp_Array1OfPnt2d ThePoles2d(1, CU.NbPoles());
CU.Curve(1 + nb3d, ThePoles2d);
conv2d.AddCurve(ThePoles2d);
}
conv2d.Perform();
}
// Recuperation:
if (nb3d != 0) {
if (nb3d != 0)
{
nbpolesspl = conv.NbPoles();
nbknots = conv.NbKnots();
nbknots = conv.NbKnots();
}
else if (nb2d != 0) {
else if (nb2d != 0)
{
nbpolesspl = conv2d.NbPoles();
nbknots = conv2d.NbKnots();
}
nbknots = conv2d.NbKnots();
}
AppParCurves_Array1OfMultiPoint tabMU(1, nbpolesspl);
TColgp_Array1OfPnt PolesSpl(1, nbpolesspl);
TColgp_Array1OfPnt2d PolesSpl2d(1, nbpolesspl);
TColStd_Array1OfInteger TheMults(1, nbknots);
TColStd_Array1OfReal TheKnots(1, nbknots);
if (nb3d != 0) {
TColgp_Array1OfPnt PolesSpl(1, nbpolesspl);
TColgp_Array1OfPnt2d PolesSpl2d(1, nbpolesspl);
TColStd_Array1OfInteger TheMults(1, nbknots);
TColStd_Array1OfReal TheKnots(1, nbknots);
if (nb3d != 0)
{
conv.KnotsAndMults(TheKnots, TheMults);
conv.Poles(PolesSpl);
deg = conv.Degree();
}
else if (nb2d != 0) {
else if (nb2d != 0)
{
conv2d.KnotsAndMults(TheKnots, TheMults);
conv2d.Poles(PolesSpl2d);
deg = conv2d.Degree();
}
for (j = 1; j <= nbpolesspl; j++) {
for (j = 1; j <= nbpolesspl; j++)
{
AppParCurves_MultiPoint MP(nb3d, nb2d);
if (nb3d!=0) {
MP.SetPoint(1, PolesSpl(j));
if (nb3d != 0)
{
MP.SetPoint(1, PolesSpl(j));
}
else if (nb2d!=0) {
MP.SetPoint2d(1+nb3d, PolesSpl2d(j));
else if (nb2d != 0)
{
MP.SetPoint2d(1 + nb3d, PolesSpl2d(j));
}
tabMU.SetValue(j, MP);
}
Standard_Integer kpol = 1, kpoles3d=1, kpoles2d=1;
Standard_Integer kpol = 1, kpoles3d = 1, kpoles2d = 1;
Standard_Integer mydegre, k;
Standard_Integer first, last, Inc, thefirst;
if (nb3d != 0) thefirst = 1;
else thefirst = 2;
if (nb3d != 0)
thefirst = 1;
else
thefirst = 2;
for (i = 1; i <= nbcu; i++) {
CU = TheSeq.Value(i);
for (i = 1; i <= nbcu; i++)
{
CU = TheSeq.Value(i);
mydegre = CU.Degree();
if (TheMults(i+1) == deg) last = deg+1; // Continuite C0
else last = deg; // Continuite C1
if (i==nbcu) {last = deg+1;}
if (TheMults(i + 1) == deg)
last = deg + 1; // Continuite C0
else
last = deg; // Continuite C1
if (i == nbcu)
{
last = deg + 1;
}
first = 1;
if (i==1) first = 1;
else if ((TheMults(i)== deg-1) || (TheMults(i)==deg)) first = 2;
if (i == 1)
first = 1;
else if ((TheMults(i) == deg - 1) || (TheMults(i) == deg))
first = 2;
for (j = 2; j <= nb3d; j++) {
kpol = kpoles3d;
TColgp_Array1OfPnt ThePoles(1, CU.NbPoles());
CU.Curve(j, ThePoles);
for (j = 2; j <= nb3d; j++)
{
kpol = kpoles3d;
TColgp_Array1OfPnt ThePoles(1, CU.NbPoles());
CU.Curve(j, ThePoles);
Inc = deg-mydegre;
TColgp_Array1OfPnt Points(1, deg+1);
if (Inc > 0) {
BSplCLib::IncreaseDegree(deg, ThePoles, BSplCLib::NoWeights(),
Points, BSplCLib::NoWeights());
}
else {
Points = ThePoles;
}
Inc = deg - mydegre;
TColgp_Array1OfPnt Points(1, deg + 1);
if (Inc > 0)
{
BSplCLib::IncreaseDegree(deg,
ThePoles,
BSplCLib::NoWeights(),
Points,
BSplCLib::NoWeights());
}
else
{
Points = ThePoles;
}
for (k = first; k <= last; k++) {
tabMU.ChangeValue(kpol++).SetPoint(j, Points(k));
}
for (k = first; k <= last; k++)
{
tabMU.ChangeValue(kpol++).SetPoint(j, Points(k));
}
}
kpoles3d = kpol;
for (j = thefirst; j <= nb2d; j++) {
kpol = kpoles2d;
TColgp_Array1OfPnt2d ThePoles2d(1, CU.NbPoles());
CU.Curve(j+nb3d, ThePoles2d);
Inc = deg-mydegre;
TColgp_Array1OfPnt2d Points2d(1, deg+1);
if (Inc > 0) {
BSplCLib::IncreaseDegree(deg, ThePoles2d, BSplCLib::NoWeights(),
Points2d, BSplCLib::NoWeights());
}
else {
Points2d = ThePoles2d;
}
for (k = first; k <= last; k++) {
tabMU.ChangeValue(kpol++).SetPoint2d(j+nb3d, Points2d(k));
}
for (j = thefirst; j <= nb2d; j++)
{
kpol = kpoles2d;
TColgp_Array1OfPnt2d ThePoles2d(1, CU.NbPoles());
CU.Curve(j + nb3d, ThePoles2d);
Inc = deg - mydegre;
TColgp_Array1OfPnt2d Points2d(1, deg + 1);
if (Inc > 0)
{
BSplCLib::IncreaseDegree(deg,
ThePoles2d,
BSplCLib::NoWeights(),
Points2d,
BSplCLib::NoWeights());
}
else
{
Points2d = ThePoles2d;
}
for (k = first; k <= last; k++)
{
tabMU.ChangeValue(kpol++).SetPoint2d(j + nb3d, Points2d(k));
}
}
kpoles2d = kpol;
}
mySpline = AppParCurves_MultiBSpCurve(tabMU, TheKnots, TheMults);
}
#ifdef OCCT_DEBUG
if(debug) DEBUG(mySpline);
if (debug)
DEBUG(mySpline);
#endif
myDone = Standard_True;
}
const AppParCurves_MultiBSpCurve& Approx_MCurvesToBSpCurve::Value() const
{
return mySpline;
}
const AppParCurves_MultiBSpCurve& Approx_MCurvesToBSpCurve::ChangeValue()
{
return mySpline;
}

45
src/Approx/Approx_MCurvesToBSpCurve.hxx
View File

@ -24,55 +24,32 @@
#include <AppParCurves_SequenceOfMultiCurve.hxx>
class AppParCurves_MultiCurve;
class Approx_MCurvesToBSpCurve
class Approx_MCurvesToBSpCurve
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Approx_MCurvesToBSpCurve();
Standard_EXPORT void Reset();
Standard_EXPORT void Append (const AppParCurves_MultiCurve& MC);
Standard_EXPORT void Append(const AppParCurves_MultiCurve& MC);
Standard_EXPORT void Perform();
Standard_EXPORT void Perform (const AppParCurves_SequenceOfMultiCurve& TheSeq);
Standard_EXPORT void Perform(const AppParCurves_SequenceOfMultiCurve& TheSeq);
//! return the composite MultiCurves as a MultiBSpCurve.
Standard_EXPORT const AppParCurves_MultiBSpCurve& Value() const;
//! return the composite MultiCurves as a MultiBSpCurve.
Standard_EXPORT const AppParCurves_MultiBSpCurve& ChangeValue();
protected:
private:
AppParCurves_MultiBSpCurve mySpline;
Standard_Boolean myDone;
AppParCurves_MultiBSpCurve mySpline;
Standard_Boolean myDone;
AppParCurves_SequenceOfMultiCurve myCurves;
};
#endif // _Approx_MCurvesToBSpCurve_HeaderFile

6
src/Approx/Approx_ParametrizationType.hxx
View File

@ -17,11 +17,11 @@
#ifndef _Approx_ParametrizationType_HeaderFile
#define _Approx_ParametrizationType_HeaderFile
enum Approx_ParametrizationType
{
Approx_ChordLength, //!< parameters of points are proportionate to distances between them
Approx_Centripetal, //!< parameters of points are proportionate to square roots of distances between them
Approx_ChordLength, //!< parameters of points are proportionate to distances between them
Approx_Centripetal, //!< parameters of points are proportionate to square roots of distances
//!< between them
Approx_IsoParametric //!< parameters of points are distributed uniformly
};

752
src/Approx/Approx_SameParameter.cxx
View File

File diff suppressed because it is too large Load Diff

129
src/Approx/Approx_SameParameter.hxx
View File

@ -27,90 +27,70 @@ class Geom_Surface;
//! Approximation of a PCurve on a surface to make its
//! parameter be the same that the parameter of a given 3d
//! reference curve.
class Approx_SameParameter
class Approx_SameParameter
{
public:
DEFINE_STANDARD_ALLOC
//! Warning: the C3D and C2D must have the same parametric domain.
Standard_EXPORT Approx_SameParameter(const Handle(Geom_Curve)& C3D,
Standard_EXPORT Approx_SameParameter(const Handle(Geom_Curve)& C3D,
const Handle(Geom2d_Curve)& C2D,
const Handle(Geom_Surface)& S,
const Standard_Real Tol);
const Standard_Real Tol);
//! Warning: the C3D and C2D must have the same parametric domain.
Standard_EXPORT Approx_SameParameter(const Handle(Adaptor3d_Curve)& C3D,
const Handle(Geom2d_Curve)& C2D,
Standard_EXPORT Approx_SameParameter(const Handle(Adaptor3d_Curve)& C3D,
const Handle(Geom2d_Curve)& C2D,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real Tol);
const Standard_Real Tol);
//! Warning: the C3D and C2D must have the same parametric domain.
Standard_EXPORT Approx_SameParameter(const Handle(Adaptor3d_Curve)& C3D,
Standard_EXPORT Approx_SameParameter(const Handle(Adaptor3d_Curve)& C3D,
const Handle(Adaptor2d_Curve2d)& C2D,
const Handle(Adaptor3d_Surface)& S,
const Standard_Real Tol);
const Standard_Real Tol);
//!@Returns .false. if calculations failed,
//! .true. if calculations succeed
Standard_Boolean IsDone() const
{
return myDone;
}
Standard_Boolean IsDone() const { return myDone; }
//!@Returns tolerance (maximal distance) between 3d curve
//! and curve on surface, generated by 2d curve and surface.
Standard_Real TolReached() const
{
return myTolReached;
}
//! and curve on surface, generated by 2d curve and surface.
Standard_Real TolReached() const { return myTolReached; }
//! Tells whether the original data had already the same
//! parameter up to the tolerance : in that case nothing
//! is done.
Standard_Boolean IsSameParameter() const
{
return mySameParameter;
}
Standard_Boolean IsSameParameter() const { return mySameParameter; }
//! Returns the 2D curve that has the same parameter as
//! the 3D curve once evaluated on the surface up to the
//! specified tolerance.
Handle(Geom2d_Curve) Curve2d() const
{
return myCurve2d;
}
Handle(Geom2d_Curve) Curve2d() const { return myCurve2d; }
//! Returns the 3D curve that has the same parameter as
//! the 3D curve once evaluated on the surface up to the
//! specified tolerance.
Handle(Adaptor3d_Curve) Curve3d() const
{
return myC3d;
}
Handle(Adaptor3d_Curve) Curve3d() const { return myC3d; }
//! Returns the 3D curve on surface that has the same parameter as
//! the 3D curve up to the specified tolerance.
Handle(Adaptor3d_CurveOnSurface) CurveOnSurface() const
{
return myCurveOnSurface;
}
Handle(Adaptor3d_CurveOnSurface) CurveOnSurface() const { return myCurveOnSurface; }
private:
//! Internal data structure to unify access to the most actively used data.
//! This structure is not intended to be class field since
//! a lot of memory is used in intermediate computations.
struct Approx_SameParameter_Data
{
Adaptor3d_CurveOnSurface myCOnS; // Curve on surface.
Standard_Integer myNbPnt; // Number of points.
Standard_Real *myPC3d; // Parameters on 3d curve.
Standard_Real *myPC2d; // Parameters on 2d curve.
Adaptor3d_CurveOnSurface myCOnS; // Curve on surface.
Standard_Integer myNbPnt; // Number of points.
Standard_Real* myPC3d; // Parameters on 3d curve.
Standard_Real* myPC2d; // Parameters on 2d curve.
// Second data arrays. Used in loop over poles.
Standard_Real *myNewPC3d; // Parameters on 3d curve.
Standard_Real *myNewPC2d; // Parameters on 2d curve.
Standard_Real* myNewPC3d; // Parameters on 3d curve.
Standard_Real* myNewPC2d; // Parameters on 2d curve.
// Parameters ranges.
Standard_Real myC3dPF; // Curve 3d Parameter First.
@ -124,73 +104,72 @@ private:
void Swap(const Standard_Integer theNewNbPoints)
{
myNbPnt = theNewNbPoints;
Standard_Real * temp;
Standard_Real* temp;
// 3-D
temp = myPC3d;
myPC3d = myNewPC3d;
temp = myPC3d;
myPC3d = myNewPC3d;
myNewPC3d = temp;
// 2-D
temp = myPC2d;
myPC2d = myNewPC2d;
temp = myPC2d;
myPC2d = myNewPC2d;
myNewPC2d = temp;
}
};
Approx_SameParameter(const Approx_SameParameter &);
Approx_SameParameter& operator=(const Approx_SameParameter &);
Approx_SameParameter(const Approx_SameParameter&);
Approx_SameParameter& operator=(const Approx_SameParameter&);
//! Computes the pcurve (internal use only).
Standard_EXPORT void Build (const Standard_Real Tol);
Standard_EXPORT void Build(const Standard_Real Tol);
//! Computes initial point distribution.
Standard_Boolean BuildInitialDistribution(Approx_SameParameter_Data &theData) const;
Standard_Boolean BuildInitialDistribution(Approx_SameParameter_Data& theData) const;
//! Increases initial number of samples in case of the C0 continuity.
//! Return new number of points and corresponding data arrays.
//@return true if new number of samples is good and false otherwise.
Standard_Boolean IncreaseInitialNbSamples(Approx_SameParameter_Data &theData) const;
Standard_Boolean IncreaseInitialNbSamples(Approx_SameParameter_Data& theData) const;
//! Computes tangents on boundary points.
//@return true if tangents are not null and false otherwise.
Standard_Boolean ComputeTangents(const Adaptor3d_CurveOnSurface & theCOnS,
Standard_Real &theFirstTangent,
Standard_Real &theLastTangent) const;
Standard_Boolean ComputeTangents(const Adaptor3d_CurveOnSurface& theCOnS,
Standard_Real& theFirstTangent,
Standard_Real& theLastTangent) const;
//! Method to check same parameter state
//! and build dependency between 2d and 3d curves.
//@return true if 2d and 3d curves have same parameter state and false otherwise.
Standard_Boolean CheckSameParameter(Approx_SameParameter_Data &theData,
Standard_Real &theSqDist) const;
Standard_Boolean CheckSameParameter(Approx_SameParameter_Data& theData,
Standard_Real& theSqDist) const;
//! Computes interpolated values.
//!@Returns .false. if computations failed;
Standard_Boolean Interpolate(const Approx_SameParameter_Data & theData,
const Standard_Real aTangFirst,
const Standard_Real aTangLast,
TColStd_Array1OfReal & thePoles,
TColStd_Array1OfReal & theFlatKnots) const;
Standard_Boolean Interpolate(const Approx_SameParameter_Data& theData,
const Standard_Real aTangFirst,
const Standard_Real aTangLast,
TColStd_Array1OfReal& thePoles,
TColStd_Array1OfReal& theFlatKnots) const;
//! Increases number of poles in poles loop.
//@return true if poles is changed and false otherwise.
Standard_Boolean IncreaseNbPoles(const TColStd_Array1OfReal & thePoles,
const TColStd_Array1OfReal & theFlatKnots,
Approx_SameParameter_Data & theData,
Standard_Real &theBestSqTol) const;
Standard_Boolean IncreaseNbPoles(const TColStd_Array1OfReal& thePoles,
const TColStd_Array1OfReal& theFlatKnots,
Approx_SameParameter_Data& theData,
Standard_Real& theBestSqTol) const;
static const Standard_Integer myNbSamples = 22; // To be consistent with "checkshape".
static const Standard_Integer myNbSamples = 22; // To be consistent with "checkshape".
static const Standard_Integer myMaxArraySize = 1000;
const Standard_Real myDeltaMin; // Initialization is allowed only for integral types.
const Standard_Real myDeltaMin; // Initialization is allowed only for integral types.
Standard_Boolean mySameParameter;
Standard_Boolean myDone;
Standard_Real myTolReached;
Handle(Geom2d_Curve) myCurve2d;
Handle(Adaptor2d_Curve2d) myHCurve2d;
Handle(Adaptor3d_Curve) myC3d;
Handle(Adaptor3d_Surface) mySurf;
Standard_Boolean mySameParameter;
Standard_Boolean myDone;
Standard_Real myTolReached;
Handle(Geom2d_Curve) myCurve2d;
Handle(Adaptor2d_Curve2d) myHCurve2d;
Handle(Adaptor3d_Curve) myC3d;
Handle(Adaptor3d_Surface) mySurf;
Handle(Adaptor3d_CurveOnSurface) myCurveOnSurface;
};

3
src/Approx/Approx_SequenceOfHArray1OfReal.hxx
View File

@ -17,10 +17,9 @@
#ifndef Approx_SequenceOfHArray1OfReal_HeaderFile
#define Approx_SequenceOfHArray1OfReal_HeaderFile
#include <TColStd_HArray1OfReal.hxx>
#include <NCollection_Sequence.hxx>
#include <TColStd_HArray1OfReal.hxx>
typedef NCollection_Sequence<Handle(TColStd_HArray1OfReal)> Approx_SequenceOfHArray1OfReal;
#endif

6
src/Approx/Approx_Status.hxx
View File

@ -20,9 +20,9 @@
//! It is an auxiliary flag being used in inner computations
enum Approx_Status
{
Approx_PointsAdded,
Approx_NoPointsAdded,
Approx_NoApproximation
Approx_PointsAdded,
Approx_NoPointsAdded,
Approx_NoApproximation
};
#endif // _Approx_Status_HeaderFile

1133
src/Approx/Approx_SweepApproximation.cxx
View File

File diff suppressed because it is too large Load Diff

281
src/Approx/Approx_SweepApproximation.hxx
View File

@ -21,30 +21,29 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <TColgp_HArray2OfPnt.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColgp_SequenceOfArray1OfPnt2d.hxx>
#include <AdvApprox_EvaluatorFunction.hxx>
#include <Approx_HArray1OfGTrsf2d.hxx>
#include <gp_Vec.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <Standard_OStream.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <TColgp_HArray1OfPnt.hxx>
#include <TColgp_HArray1OfPnt2d.hxx>
#include <TColgp_HArray1OfVec.hxx>
#include <TColgp_HArray1OfVec2d.hxx>
#include <GeomAbs_Shape.hxx>
#include <AdvApprox_EvaluatorFunction.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <Standard_OStream.hxx>
#include <TColgp_HArray2OfPnt.hxx>
#include <TColgp_SequenceOfArray1OfPnt2d.hxx>
#include <gp_Vec.hxx>
class Approx_SweepFunction;
class AdvApprox_Cutting;
//! Approximation of an Surface S(u,v)
//! (and eventually associate 2d Curves) defined
//! by section's law.
@ -54,15 +53,13 @@ class AdvApprox_Cutting;
//! To use this algorithme, you have to implement Ft(u)
//! as a derivative class of Approx_SweepFunction.
//! This algorithm can be used by blending, sweeping...
class Approx_SweepApproximation
class Approx_SweepApproximation
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Approx_SweepApproximation(const Handle(Approx_SweepFunction)& Func);
//! Perform the Approximation
//! [First, Last] : Approx_SweepApproximation.cdl
//! Tol3d : Tolerance to surface approximation
@ -78,138 +75,166 @@ public:
//! Segmax : The maximum number of span in v required on
//! the surface
//! Warning : The continuity ci can be obtained only if Ft is Ci
Standard_EXPORT void Perform (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol3d, const Standard_Real BoundTol, const Standard_Real Tol2d, const Standard_Real TolAngular, const GeomAbs_Shape Continuity = GeomAbs_C0, const Standard_Integer Degmax = 11, const Standard_Integer Segmax = 50);
Standard_EXPORT void Perform(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol3d,
const Standard_Real BoundTol,
const Standard_Real Tol2d,
const Standard_Real TolAngular,
const GeomAbs_Shape Continuity = GeomAbs_C0,
const Standard_Integer Degmax = 11,
const Standard_Integer Segmax = 50);
//! The EvaluatorFunction from AdvApprox;
Standard_EXPORT Standard_Integer Eval (const Standard_Real Parameter, const Standard_Integer DerivativeRequest, const Standard_Real First, const Standard_Real Last, Standard_Real& Result);
Standard_EXPORT Standard_Integer Eval(const Standard_Real Parameter,
const Standard_Integer DerivativeRequest,
const Standard_Real First,
const Standard_Real Last,
Standard_Real& Result);
//! returns if we have an result
Standard_Boolean IsDone() const;
Standard_EXPORT void SurfShape (Standard_Integer& UDegree, Standard_Integer& VDegree, Standard_Integer& NbUPoles, Standard_Integer& NbVPoles, Standard_Integer& NbUKnots, Standard_Integer& NbVKnots) const;
Standard_EXPORT void Surface (TColgp_Array2OfPnt& TPoles, TColStd_Array2OfReal& TWeights, TColStd_Array1OfReal& TUKnots, TColStd_Array1OfReal& TVKnots, TColStd_Array1OfInteger& TUMults, TColStd_Array1OfInteger& TVMults) const;
Standard_Integer UDegree() const;
Standard_Integer VDegree() const;
const TColgp_Array2OfPnt& SurfPoles() const;
const TColStd_Array2OfReal& SurfWeights() const;
const TColStd_Array1OfReal& SurfUKnots() const;
const TColStd_Array1OfReal& SurfVKnots() const;
const TColStd_Array1OfInteger& SurfUMults() const;
const TColStd_Array1OfInteger& SurfVMults() const;
Standard_Boolean IsDone() const;
Standard_EXPORT void SurfShape(Standard_Integer& UDegree,
Standard_Integer& VDegree,
Standard_Integer& NbUPoles,
Standard_Integer& NbVPoles,
Standard_Integer& NbUKnots,
Standard_Integer& NbVKnots) const;
Standard_EXPORT void Surface(TColgp_Array2OfPnt& TPoles,
TColStd_Array2OfReal& TWeights,
TColStd_Array1OfReal& TUKnots,
TColStd_Array1OfReal& TVKnots,
TColStd_Array1OfInteger& TUMults,
TColStd_Array1OfInteger& TVMults) const;
Standard_Integer UDegree() const;
Standard_Integer VDegree() const;
const TColgp_Array2OfPnt& SurfPoles() const;
const TColStd_Array2OfReal& SurfWeights() const;
const TColStd_Array1OfReal& SurfUKnots() const;
const TColStd_Array1OfReal& SurfVKnots() const;
const TColStd_Array1OfInteger& SurfUMults() const;
const TColStd_Array1OfInteger& SurfVMults() const;
//! returns the maximum error in the surface approximation.
Standard_EXPORT Standard_Real MaxErrorOnSurf() const;
//! returns the average error in the surface approximation.
Standard_EXPORT Standard_Real AverageErrorOnSurf() const;
Standard_Integer NbCurves2d() const;
Standard_EXPORT void Curves2dShape (Standard_Integer& Degree, Standard_Integer& NbPoles, Standard_Integer& NbKnots) const;
Standard_EXPORT void Curve2d (const Standard_Integer Index, TColgp_Array1OfPnt2d& TPoles, TColStd_Array1OfReal& TKnots, TColStd_Array1OfInteger& TMults) const;
Standard_Integer Curves2dDegree() const;
const TColgp_Array1OfPnt2d& Curve2dPoles (const Standard_Integer Index) const;
const TColStd_Array1OfReal& Curves2dKnots() const;
const TColStd_Array1OfInteger& Curves2dMults() const;
Standard_Integer NbCurves2d() const;
Standard_EXPORT void Curves2dShape(Standard_Integer& Degree,
Standard_Integer& NbPoles,
Standard_Integer& NbKnots) const;
Standard_EXPORT void Curve2d(const Standard_Integer Index,
TColgp_Array1OfPnt2d& TPoles,
TColStd_Array1OfReal& TKnots,
TColStd_Array1OfInteger& TMults) const;
Standard_Integer Curves2dDegree() const;
const TColgp_Array1OfPnt2d& Curve2dPoles(const Standard_Integer Index) const;
const TColStd_Array1OfReal& Curves2dKnots() const;
const TColStd_Array1OfInteger& Curves2dMults() const;
//! returns the maximum error of the <Index>
//! 2d curve approximation.
Standard_EXPORT Standard_Real Max2dError (const Standard_Integer Index) const;
Standard_EXPORT Standard_Real Max2dError(const Standard_Integer Index) const;
//! returns the average error of the <Index>
//! 2d curve approximation.
Standard_EXPORT Standard_Real Average2dError (const Standard_Integer Index) const;
Standard_EXPORT Standard_Real Average2dError(const Standard_Integer Index) const;
//! returns the maximum 3d error of the <Index>
//! 2d curve approximation on the Surface.
Standard_EXPORT Standard_Real TolCurveOnSurf (const Standard_Integer Index) const;
Standard_EXPORT Standard_Real TolCurveOnSurf(const Standard_Integer Index) const;
//! display information on approximation.
Standard_EXPORT void Dump (Standard_OStream& o) const;
Standard_EXPORT void Dump(Standard_OStream& o) const;
protected:
private:
Standard_EXPORT void Approximation(const Handle(TColStd_HArray1OfReal)& OneDTol,
const Handle(TColStd_HArray1OfReal)& TwoDTol,
const Handle(TColStd_HArray1OfReal)& ThreeDTol,
const Standard_Real BounTol,
const Standard_Real First,
const Standard_Real Last,
const GeomAbs_Shape Continuity,
const Standard_Integer Degmax,
const Standard_Integer Segmax,
const AdvApprox_EvaluatorFunction& TheApproxFunction,
const AdvApprox_Cutting& TheCuttingTool);
Standard_EXPORT void Approximation (const Handle(TColStd_HArray1OfReal)& OneDTol, const Handle(TColStd_HArray1OfReal)& TwoDTol, const Handle(TColStd_HArray1OfReal)& ThreeDTol, const Standard_Real BounTol, const Standard_Real First, const Standard_Real Last, const GeomAbs_Shape Continuity, const Standard_Integer Degmax, const Standard_Integer Segmax, const AdvApprox_EvaluatorFunction& TheApproxFunction, const AdvApprox_Cutting& TheCuttingTool);
Standard_EXPORT Standard_Boolean D0 (const Standard_Real Param, const Standard_Real First, const Standard_Real Last, Standard_Real& Result);
Standard_EXPORT Standard_Boolean D1 (const Standard_Real Param, const Standard_Real First, const Standard_Real Last, Standard_Real& Result);
Standard_EXPORT Standard_Boolean D2 (const Standard_Real Param, const Standard_Real First, const Standard_Real Last, Standard_Real& Result);
Standard_EXPORT Standard_Boolean D0(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
Standard_Real& Result);
Standard_EXPORT Standard_Boolean D1(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
Standard_Real& Result);
Handle(Approx_SweepFunction) myFunc;
Standard_Boolean done;
Standard_Integer Num1DSS;
Standard_Integer Num2DSS;
Standard_Integer Num3DSS;
Standard_Integer udeg;
Standard_Integer vdeg;
Standard_Integer deg2d;
Handle(TColgp_HArray2OfPnt) tabPoles;
Handle(TColStd_HArray2OfReal) tabWeights;
Handle(TColStd_HArray1OfReal) tabUKnots;
Handle(TColStd_HArray1OfReal) tabVKnots;
Handle(TColStd_HArray1OfReal) tab2dKnots;
Standard_EXPORT Standard_Boolean D2(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
Standard_Real& Result);
Handle(Approx_SweepFunction) myFunc;
Standard_Boolean done;
Standard_Integer Num1DSS;
Standard_Integer Num2DSS;
Standard_Integer Num3DSS;
Standard_Integer udeg;
Standard_Integer vdeg;
Standard_Integer deg2d;
Handle(TColgp_HArray2OfPnt) tabPoles;
Handle(TColStd_HArray2OfReal) tabWeights;
Handle(TColStd_HArray1OfReal) tabUKnots;
Handle(TColStd_HArray1OfReal) tabVKnots;
Handle(TColStd_HArray1OfReal) tab2dKnots;
Handle(TColStd_HArray1OfInteger) tabUMults;
Handle(TColStd_HArray1OfInteger) tabVMults;
Handle(TColStd_HArray1OfInteger) tab2dMults;
TColgp_SequenceOfArray1OfPnt2d seqPoles2d;
Handle(TColStd_HArray1OfReal) MError1d;
Handle(TColStd_HArray1OfReal) tab2dError;
Handle(TColStd_HArray1OfReal) MError3d;
Handle(TColStd_HArray1OfReal) AError1d;
Handle(TColStd_HArray1OfReal) Ave2dError;
Handle(TColStd_HArray1OfReal) AError3d;
Handle(Approx_HArray1OfGTrsf2d) AAffin;
Handle(TColStd_HArray1OfReal) COnSurfErr;
gp_Vec Translation;
Handle(TColgp_HArray1OfPnt) myPoles;
Handle(TColgp_HArray1OfPnt2d) myPoles2d;
Handle(TColStd_HArray1OfReal) myWeigths;
Handle(TColgp_HArray1OfVec) myDPoles;
Handle(TColgp_HArray1OfVec) myD2Poles;
Handle(TColgp_HArray1OfVec2d) myDPoles2d;
Handle(TColgp_HArray1OfVec2d) myD2Poles2d;
Handle(TColStd_HArray1OfReal) myDWeigths;
Handle(TColStd_HArray1OfReal) myD2Weigths;
Standard_Integer myOrder;
Standard_Real myParam;
Standard_Real first;
Standard_Real last;
TColgp_SequenceOfArray1OfPnt2d seqPoles2d;
Handle(TColStd_HArray1OfReal) MError1d;
Handle(TColStd_HArray1OfReal) tab2dError;
Handle(TColStd_HArray1OfReal) MError3d;
Handle(TColStd_HArray1OfReal) AError1d;
Handle(TColStd_HArray1OfReal) Ave2dError;
Handle(TColStd_HArray1OfReal) AError3d;
Handle(Approx_HArray1OfGTrsf2d) AAffin;
Handle(TColStd_HArray1OfReal) COnSurfErr;
gp_Vec Translation;
Handle(TColgp_HArray1OfPnt) myPoles;
Handle(TColgp_HArray1OfPnt2d) myPoles2d;
Handle(TColStd_HArray1OfReal) myWeigths;
Handle(TColgp_HArray1OfVec) myDPoles;
Handle(TColgp_HArray1OfVec) myD2Poles;
Handle(TColgp_HArray1OfVec2d) myDPoles2d;
Handle(TColgp_HArray1OfVec2d) myD2Poles2d;
Handle(TColStd_HArray1OfReal) myDWeigths;
Handle(TColStd_HArray1OfReal) myD2Weigths;
Standard_Integer myOrder;
Standard_Real myParam;
Standard_Real first;
Standard_Real last;
};
#include <Approx_SweepApproximation.lxx>
#endif // _Approx_SweepApproximation_HeaderFile

121
src/Approx/Approx_SweepApproximation.lxx
View File

@ -15,113 +15,152 @@
// commercial license or contractual agreement.
#include <StdFail_NotDone.hxx>
#include <TColgp_HArray2OfPnt.hxx>
#include <TColgp_HArray1OfPnt2d.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColgp_HArray1OfPnt2d.hxx>
#include <TColgp_HArray2OfPnt.hxx>
inline Standard_Boolean Approx_SweepApproximation::IsDone() const
inline Standard_Boolean Approx_SweepApproximation::IsDone() const
{
return done;
}
inline Standard_Integer Approx_SweepApproximation::UDegree() const
inline Standard_Integer Approx_SweepApproximation::UDegree() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return udeg;
}
inline Standard_Integer Approx_SweepApproximation::VDegree() const
inline Standard_Integer Approx_SweepApproximation::VDegree() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return vdeg;
}
inline const TColgp_Array2OfPnt& Approx_SweepApproximation::SurfPoles() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return tabPoles->Array2();
}
inline const TColStd_Array2OfReal& Approx_SweepApproximation::SurfWeights() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return tabWeights->Array2();
}
inline const TColStd_Array1OfReal& Approx_SweepApproximation::SurfUKnots() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return tabUKnots->Array1();
}
inline const TColStd_Array1OfReal& Approx_SweepApproximation::SurfVKnots() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return tabVKnots->Array1();
}
inline const TColStd_Array1OfInteger& Approx_SweepApproximation::SurfUMults() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return tabUMults->Array1();
}
inline const TColStd_Array1OfInteger& Approx_SweepApproximation::SurfVMults() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return tabVMults->Array1();
}
inline Standard_Integer Approx_SweepApproximation::NbCurves2d() const
inline Standard_Integer Approx_SweepApproximation::NbCurves2d() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
return Num2DSS;
}
inline Standard_Integer Approx_SweepApproximation::Curves2dDegree() const
inline Standard_Integer Approx_SweepApproximation::Curves2dDegree() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (seqPoles2d.Length() == 0) {throw Standard_DomainError();}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
if (seqPoles2d.Length() == 0)
{
throw Standard_DomainError();
}
return deg2d;
}
inline const TColgp_Array1OfPnt2d& Approx_SweepApproximation::Curve2dPoles(const Standard_Integer Index) const
inline const TColgp_Array1OfPnt2d& Approx_SweepApproximation::Curve2dPoles(
const Standard_Integer Index) const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (seqPoles2d.Length() == 0) {throw Standard_DomainError();}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
if (seqPoles2d.Length() == 0)
{
throw Standard_DomainError();
}
return seqPoles2d(Index)->Array1();
}
inline const TColStd_Array1OfReal& Approx_SweepApproximation::Curves2dKnots() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (seqPoles2d.Length() == 0) {throw Standard_DomainError();}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
if (seqPoles2d.Length() == 0)
{
throw Standard_DomainError();
}
return tab2dKnots->Array1();
}
inline const TColStd_Array1OfInteger& Approx_SweepApproximation::Curves2dMults() const
{
if (!done) {throw StdFail_NotDone(" Approx_SweepApproximation");}
if (seqPoles2d.Length() == 0) {throw Standard_DomainError();}
if (!done)
{
throw StdFail_NotDone(" Approx_SweepApproximation");
}
if (seqPoles2d.Length() == 0)
{
throw Standard_DomainError();
}
return tab2dMults->Array1();
}
/*
/*
inline void Approx_SweepApproximation::TolReached(Standard_Real& Tol3d,Standard_Real& Tol2d) const
{

63
src/Approx/Approx_SweepFunction.cxx
View File

@ -14,44 +14,73 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Approx_SweepFunction.hxx>
#include <gp_Pnt.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_Type.hxx>
#include <gp_Pnt.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Approx_SweepFunction,Standard_Transient)
IMPLEMENT_STANDARD_RTTIEXT(Approx_SweepFunction, Standard_Transient)
// Standard_Boolean Approx_SweepFunction::D1(const Standard_Real Param,const Standard_Real First,const Standard_Real Last,TColgp_Array1OfPnt& Poles,TColgp_Array1OfVec& DPoles,TColgp_Array1OfPnt2d& Poles2d,TColgp_Array1OfVec2d& DPoles2d,TColStd_Array1OfReal& Weigths,TColStd_Array1OfReal& DWeigths)
Standard_Boolean Approx_SweepFunction::D1(const Standard_Real ,const Standard_Real ,const Standard_Real ,TColgp_Array1OfPnt& ,TColgp_Array1OfVec& ,TColgp_Array1OfPnt2d& ,TColgp_Array1OfVec2d& ,TColStd_Array1OfReal& ,TColStd_Array1OfReal& )
// Standard_Boolean Approx_SweepFunction::D1(const Standard_Real Param,const Standard_Real
// First,const Standard_Real Last,TColgp_Array1OfPnt& Poles,TColgp_Array1OfVec&
// DPoles,TColgp_Array1OfPnt2d& Poles2d,TColgp_Array1OfVec2d& DPoles2d,TColStd_Array1OfReal&
// Weigths,TColStd_Array1OfReal& DWeigths)
Standard_Boolean Approx_SweepFunction::D1(const Standard_Real,
const Standard_Real,
const Standard_Real,
TColgp_Array1OfPnt&,
TColgp_Array1OfVec&,
TColgp_Array1OfPnt2d&,
TColgp_Array1OfVec2d&,
TColStd_Array1OfReal&,
TColStd_Array1OfReal&)
{
throw Standard_NotImplemented("Approx_SweepFunction::D1");
throw Standard_NotImplemented("Approx_SweepFunction::D1");
}
// Standard_Boolean Approx_SweepFunction::D2(const Standard_Real Param,const Standard_Real First,const Standard_Real Last,TColgp_Array1OfPnt& Poles,TColgp_Array1OfVec& DPoles,TColgp_Array1OfVec& D2Poles,TColgp_Array1OfPnt2d& Poles2d,TColgp_Array1OfVec2d& DPoles2d,TColgp_Array1OfVec2d& D2Poles2d,TColStd_Array1OfReal& Weigths,TColStd_Array1OfReal& DWeigths,TColStd_Array1OfReal& D2Weigths)
Standard_Boolean Approx_SweepFunction::D2(const Standard_Real ,const Standard_Real ,const Standard_Real ,TColgp_Array1OfPnt& ,TColgp_Array1OfVec& ,TColgp_Array1OfVec& ,TColgp_Array1OfPnt2d& ,TColgp_Array1OfVec2d& ,TColgp_Array1OfVec2d& ,TColStd_Array1OfReal& ,TColStd_Array1OfReal& ,TColStd_Array1OfReal& )
// Standard_Boolean Approx_SweepFunction::D2(const Standard_Real Param,const Standard_Real
// First,const Standard_Real Last,TColgp_Array1OfPnt& Poles,TColgp_Array1OfVec&
// DPoles,TColgp_Array1OfVec& D2Poles,TColgp_Array1OfPnt2d& Poles2d,TColgp_Array1OfVec2d&
// DPoles2d,TColgp_Array1OfVec2d& D2Poles2d,TColStd_Array1OfReal& Weigths,TColStd_Array1OfReal&
// DWeigths,TColStd_Array1OfReal& D2Weigths)
Standard_Boolean Approx_SweepFunction::D2(const Standard_Real,
const Standard_Real,
const Standard_Real,
TColgp_Array1OfPnt&,
TColgp_Array1OfVec&,
TColgp_Array1OfVec&,
TColgp_Array1OfPnt2d&,
TColgp_Array1OfVec2d&,
TColgp_Array1OfVec2d&,
TColStd_Array1OfReal&,
TColStd_Array1OfReal&,
TColStd_Array1OfReal&)
{
throw Standard_NotImplemented("Approx_SweepFunction::D2");
throw Standard_NotImplemented("Approx_SweepFunction::D2");
}
// void Approx_SweepFunction::Resolution(const Standard_Integer Index,const Standard_Real Tol,Standard_Real& TolU,Standard_Real& TolV) const
void Approx_SweepFunction::Resolution(const Standard_Integer ,const Standard_Real ,Standard_Real& ,Standard_Real& ) const
// void Approx_SweepFunction::Resolution(const Standard_Integer Index,const Standard_Real
// Tol,Standard_Real& TolU,Standard_Real& TolV) const
void Approx_SweepFunction::Resolution(const Standard_Integer,
const Standard_Real,
Standard_Real&,
Standard_Real&) const
{
throw Standard_NotImplemented("Approx_SweepFunction::Resolution");
throw Standard_NotImplemented("Approx_SweepFunction::Resolution");
}
gp_Pnt Approx_SweepFunction::BarycentreOfSurf() const
gp_Pnt Approx_SweepFunction::BarycentreOfSurf() const
{
throw Standard_NotImplemented("Approx_SweepFunction::BarycentreOfSurf");
throw Standard_NotImplemented("Approx_SweepFunction::BarycentreOfSurf");
}
Standard_Real Approx_SweepFunction::MaximalSection() const
Standard_Real Approx_SweepFunction::MaximalSection() const
{
throw Standard_NotImplemented("Approx_SweepFunction::MaximalSection()");
}
// void Approx_SweepFunction::GetMinimalWeight(TColStd_Array1OfReal& Weigths) const
void Approx_SweepFunction::GetMinimalWeight(TColStd_Array1OfReal& ) const
void Approx_SweepFunction::GetMinimalWeight(TColStd_Array1OfReal&) const
{
throw Standard_NotImplemented("Approx_SweepFunction::GetMinimalWeight");
throw Standard_NotImplemented("Approx_SweepFunction::GetMinimalWeight");
}

123
src/Approx/Approx_SweepFunction.hxx
View File

@ -19,19 +19,18 @@
#include <Standard.hxx>
#include <Standard_Transient.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Standard_Transient.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfVec2d.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <GeomAbs_Shape.hxx>
class gp_Pnt;
class Approx_SweepFunction;
DEFINE_STANDARD_HANDLE(Approx_SweepFunction, Standard_Transient)
@ -41,106 +40,120 @@ class Approx_SweepFunction : public Standard_Transient
{
public:
//! compute the section for v = param
Standard_EXPORT virtual Standard_Boolean D0 (const Standard_Real Param, const Standard_Real First, const Standard_Real Last, TColgp_Array1OfPnt& Poles, TColgp_Array1OfPnt2d& Poles2d, TColStd_Array1OfReal& Weigths) = 0;
Standard_EXPORT virtual Standard_Boolean D0(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
TColgp_Array1OfPnt& Poles,
TColgp_Array1OfPnt2d& Poles2d,
TColStd_Array1OfReal& Weigths) = 0;
//! compute the first derivative in v direction of the
//! section for v = param
//! Warning : It used only for C1 or C2 approximation
Standard_EXPORT virtual Standard_Boolean D1 (const Standard_Real Param, const Standard_Real First, const Standard_Real Last, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths);
Standard_EXPORT virtual Standard_Boolean D1(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
TColgp_Array1OfPnt& Poles,
TColgp_Array1OfVec& DPoles,
TColgp_Array1OfPnt2d& Poles2d,
TColgp_Array1OfVec2d& DPoles2d,
TColStd_Array1OfReal& Weigths,
TColStd_Array1OfReal& DWeigths);
//! compute the second derivative in v direction of the
//! section for v = param
//! Warning : It used only for C2 approximation
Standard_EXPORT virtual Standard_Boolean D2 (const Standard_Real Param, const Standard_Real First, const Standard_Real Last, TColgp_Array1OfPnt& Poles, TColgp_Array1OfVec& DPoles, TColgp_Array1OfVec& D2Poles, TColgp_Array1OfPnt2d& Poles2d, TColgp_Array1OfVec2d& DPoles2d, TColgp_Array1OfVec2d& D2Poles2d, TColStd_Array1OfReal& Weigths, TColStd_Array1OfReal& DWeigths, TColStd_Array1OfReal& D2Weigths);
Standard_EXPORT virtual Standard_Boolean D2(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
TColgp_Array1OfPnt& Poles,
TColgp_Array1OfVec& DPoles,
TColgp_Array1OfVec& D2Poles,
TColgp_Array1OfPnt2d& Poles2d,
TColgp_Array1OfVec2d& DPoles2d,
TColgp_Array1OfVec2d& D2Poles2d,
TColStd_Array1OfReal& Weigths,
TColStd_Array1OfReal& DWeigths,
TColStd_Array1OfReal& D2Weigths);
//! get the number of 2d curves to approximate.
Standard_EXPORT virtual Standard_Integer Nb2dCurves() const = 0;
//! get the format of an section
Standard_EXPORT virtual void SectionShape (Standard_Integer& NbPoles, Standard_Integer& NbKnots, Standard_Integer& Degree) const = 0;
Standard_EXPORT virtual void SectionShape(Standard_Integer& NbPoles,
Standard_Integer& NbKnots,
Standard_Integer& Degree) const = 0;
//! get the Knots of the section
Standard_EXPORT virtual void Knots (TColStd_Array1OfReal& TKnots) const = 0;
Standard_EXPORT virtual void Knots(TColStd_Array1OfReal& TKnots) const = 0;
//! get the Multplicities of the section
Standard_EXPORT virtual void Mults (TColStd_Array1OfInteger& TMults) const = 0;
Standard_EXPORT virtual void Mults(TColStd_Array1OfInteger& TMults) const = 0;
//! Returns if the sections are rational or not
Standard_EXPORT virtual Standard_Boolean IsRational() const = 0;
//! Returns the number of intervals for continuity
//! <S>.
//! May be one if Continuity(me) >= <S>
Standard_EXPORT virtual Standard_Integer NbIntervals (const GeomAbs_Shape S) const = 0;
Standard_EXPORT virtual Standard_Integer NbIntervals(const GeomAbs_Shape S) const = 0;
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT virtual void Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const = 0;
Standard_EXPORT virtual void Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const = 0;
//! Sets the bounds of the parametric interval on
//! the fonction
//! This determines the derivatives in these values if the
//! function is not Cn.
Standard_EXPORT virtual void SetInterval (const Standard_Real First, const Standard_Real Last) = 0;
Standard_EXPORT virtual void SetInterval(const Standard_Real First, const Standard_Real Last) = 0;
//! Returns the resolutions in the sub-space 2d <Index>
//! This information is usfull to find an good tolerance in
//! 2d approximation.
Standard_EXPORT virtual void Resolution (const Standard_Integer Index, const Standard_Real Tol, Standard_Real& TolU, Standard_Real& TolV) const;
Standard_EXPORT virtual void Resolution(const Standard_Integer Index,
const Standard_Real Tol,
Standard_Real& TolU,
Standard_Real& TolV) const;
//! Returns the tolerance to reach in approximation
//! to satisfy.
//! BoundTol error at the Boundary
//! AngleTol tangent error at the Boundary (in radian)
//! SurfTol error inside the surface.
Standard_EXPORT virtual void GetTolerance (const Standard_Real BoundTol, const Standard_Real SurfTol, const Standard_Real AngleTol, TColStd_Array1OfReal& Tol3d) const = 0;
Standard_EXPORT virtual void GetTolerance(const Standard_Real BoundTol,
const Standard_Real SurfTol,
const Standard_Real AngleTol,
TColStd_Array1OfReal& Tol3d) const = 0;
//! Is useful, if (me) have to run numerical algorithm to perform D0, D1 or D2
Standard_EXPORT virtual void SetTolerance (const Standard_Real Tol3d, const Standard_Real Tol2d) = 0;
Standard_EXPORT virtual void SetTolerance(const Standard_Real Tol3d,
const Standard_Real Tol2d) = 0;
//! Get the barycentre of Surface.
//! An very poor estimation is sufficient.
//! This information is useful to perform well conditioned rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual gp_Pnt BarycentreOfSurf() const;
//! Returns the length of the greater section.
//! Thisinformation is useful to G1's control.
//! Warning: With an little value, approximation can be slower.
Standard_EXPORT virtual Standard_Real MaximalSection() const;
//! Compute the minimal value of weight for each poles in all sections.
//! This information is useful to control error in rational approximation.
//! Warning: Used only if <me> IsRational
Standard_EXPORT virtual void GetMinimalWeight (TColStd_Array1OfReal& Weigths) const;
Standard_EXPORT virtual void GetMinimalWeight(TColStd_Array1OfReal& Weigths) const;
DEFINE_STANDARD_RTTIEXT(Approx_SweepFunction,Standard_Transient)
DEFINE_STANDARD_RTTIEXT(Approx_SweepFunction, Standard_Transient)
protected:
private:
};
#endif // _Approx_SweepFunction_HeaderFile

709
src/ApproxInt/ApproxInt_Approx.gxx
View File

File diff suppressed because it is too large Load Diff

1088
src/ApproxInt/ApproxInt_ImpPrmSvSurfaces.gxx
View File

File diff suppressed because it is too large Load Diff

461
src/ApproxInt/ApproxInt_KnotTools.cxx
View File

@ -12,29 +12,30 @@
// commercial license or contractual agreement.
#include <ApproxInt_KnotTools.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <math_Vector.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <GeomInt_TheMultiLineOfWLApprox.hxx>
#include <GeomInt_WLApprox.hxx>
#include <Geom_BSplineCurve.hxx>
#include <NCollection_Sequence.hxx>
#include <NCollection_Vector.hxx>
#include <PLib.hxx>
#include <Precision.hxx>
#include <NCollection_Vector.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <GeomInt_WLApprox.hxx>
#include <GeomInt_TheMultiLineOfWLApprox.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <math_Vector.hxx>
// (Sqrt(5.0) - 1.0) / 4.0
//static const Standard_Real aSinCoeff = 0.30901699437494742410229341718282;
// static const Standard_Real aSinCoeff = 0.30901699437494742410229341718282;
static const Standard_Real aSinCoeff2 = 0.09549150281252627; // aSinCoeff^2 = (3. - Sqrt(5.)) / 8.
static const Standard_Integer aMaxPntCoeff = 15;
//=======================================================================
//function : EvalCurv
//purpose : Evaluate curvature in dim-dimension point.
//=======================================================================
static Standard_Real EvalCurv(const Standard_Real dim,
//=================================================================================================
// function : EvalCurv
// purpose : Evaluate curvature in dim-dimension point.
//=================================================================================================
static Standard_Real EvalCurv(const Standard_Real dim,
const Standard_Real* V1,
const Standard_Real* V2)
{
@ -44,22 +45,22 @@ static Standard_Real EvalCurv(const Standard_Real dim,
// Curvature is curv = |V1^V2|/|V1|^3
// V1^V2 is outer product of two vectors:
// P(i,j) = V1(i)*V2(j) - V1(j)*V2(i);
Standard_Real mp = 0.;
Standard_Real mp = 0.;
Standard_Integer i, j;
Standard_Real p;
for(i = 1; i < dim; ++i)
Standard_Real p;
for (i = 1; i < dim; ++i)
{
for(j = 0; j < i; ++j)
for (j = 0; j < i; ++j)
{
p = V1[i]*V2[j] - V1[j]*V2[i];
mp += p*p;
p = V1[i] * V2[j] - V1[j] * V2[i];
mp += p * p;
}
}
//
Standard_Real q = 0.;
for(i = 0; i < dim; ++i)
for (i = 0; i < dim; ++i)
{
q += V1[i]*V1[i];
q += V1[i] * V1[i];
}
if (q < 1 / Precision::Infinite())
@ -78,7 +79,7 @@ static Standard_Real EvalCurv(const Standard_Real dim,
}
q = Min(q, Precision::Infinite());
q *= q*q;
q *= q * q;
//
Standard_Real curv = Sqrt(mp / q);
@ -86,20 +87,16 @@ static Standard_Real EvalCurv(const Standard_Real dim,
return curv;
}
//=======================================================================
//function : BuildCurvature
//purpose :
//=======================================================================
//=================================================================================================
void ApproxInt_KnotTools::BuildCurvature(
const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
const math_Vector& thePars,
TColStd_Array1OfReal& theCurv,
Standard_Real& theMaxCurv)
void ApproxInt_KnotTools::BuildCurvature(const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
const math_Vector& thePars,
TColStd_Array1OfReal& theCurv,
Standard_Real& theMaxCurv)
{
// Arrays are allocated for max theDim = 7: 1 3d curve + 2 2d curves.
Standard_Real Val[21], Par[3], Res[21];
Standard_Real Val[21], Par[3], Res[21];
Standard_Integer i, j, m, ic;
Standard_Integer dim = theDim;
//
@ -113,8 +110,8 @@ void ApproxInt_KnotTools::BuildCurvature(
for (j = 0; j < 3; ++j)
{
Standard_Integer k = i + j;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim*j;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim * j;
for (m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
@ -135,8 +132,8 @@ void ApproxInt_KnotTools::BuildCurvature(
for (j = 0; j < 3; ++j)
{
Standard_Integer k = i + j - 1;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim*j;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim * j;
for (m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
@ -156,8 +153,8 @@ void ApproxInt_KnotTools::BuildCurvature(
for (j = 0; j < 3; ++j)
{
Standard_Integer k = i + j - 2;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim*j;
ic = (k - theCurv.Lower()) * dim;
Standard_Integer l = dim * j;
for (m = 0; m < dim; ++m)
{
Val[l + m] = theCoords[ic + m];
@ -171,35 +168,32 @@ void ApproxInt_KnotTools::BuildCurvature(
{
theMaxCurv = theCurv(i);
}
}
//=======================================================================
//function : ComputeKnotInds
//purpose :
//=======================================================================
//=================================================================================================
void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
const math_Vector& thePars,
NCollection_Sequence<Standard_Integer>& theInds)
const Standard_Integer theDim,
const math_Vector& thePars,
NCollection_Sequence<Standard_Integer>& theInds)
{
//I: Create discrete curvature.
// I: Create discrete curvature.
NCollection_Sequence<Standard_Integer> aFeatureInds;
TColStd_Array1OfReal aCurv(thePars.Lower(), thePars.Upper());
Standard_Real aMaxCurv = 0.;
TColStd_Array1OfReal aCurv(thePars.Lower(), thePars.Upper());
Standard_Real aMaxCurv = 0.;
BuildCurvature(theCoords, theDim, thePars, aCurv, aMaxCurv);
//
//
Standard_Integer i, j, dim = theDim;
#ifdef APPROXINT_KNOTTOOLS_DEBUG
std::cout << "Discrete curvature array is" << std::endl;
for(i = aCurv.Lower(); i <= aCurv.Upper(); ++i)
for (i = aCurv.Lower(); i <= aCurv.Upper(); ++i)
{
std::cout << i << " " << aCurv(i) << std::endl;
}
#endif
theInds.Append(aCurv.Lower());
if(aMaxCurv <= Precision::Confusion())
if (aMaxCurv <= Precision::Confusion())
{
// Linear case.
theInds.Append(aCurv.Upper());
@ -208,32 +202,30 @@ void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_
// II: Find extremas of curvature.
// Not used Precision::PConfusion, by different from "param space" eps nature.
Standard_Real eps = 1.0e-9,
eps1 = 1.0e3 * eps;
for(i = aCurv.Lower() + 1; i < aCurv.Upper(); ++i)
Standard_Real eps = 1.0e-9, eps1 = 1.0e3 * eps;
for (i = aCurv.Lower() + 1; i < aCurv.Upper(); ++i)
{
Standard_Real d1 = aCurv(i) - aCurv(i - 1),
d2 = aCurv(i) - aCurv(i + 1),
ad1 = Abs(d1), ad2 = Abs(d2);
Standard_Real d1 = aCurv(i) - aCurv(i - 1), d2 = aCurv(i) - aCurv(i + 1), ad1 = Abs(d1),
ad2 = Abs(d2);
if(d1*d2 > 0. && ad1 > eps && ad2 > eps)
if (d1 * d2 > 0. && ad1 > eps && ad2 > eps)
{
if(i != theInds.Last())
if (i != theInds.Last())
{
theInds.Append(i);
aFeatureInds.Append(i);
}
}
else if((ad1 < eps && ad2 > eps1) || (ad1 > eps1 && ad2 < eps))
else if ((ad1 < eps && ad2 > eps1) || (ad1 > eps1 && ad2 < eps))
{
if(i != theInds.Last())
if (i != theInds.Last())
{
theInds.Append(i);
aFeatureInds.Append(i);
}
}
}
if(aCurv.Upper() != theInds.Last())
if (aCurv.Upper() != theInds.Last())
{
theInds.Append(aCurv.Upper());
}
@ -242,72 +234,71 @@ void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_
{
std::cout << "Feature indices new: " << std::endl;
i;
for(i = theInds.Lower(); i <= theInds.Upper(); ++i)
for (i = theInds.Lower(); i <= theInds.Upper(); ++i)
{
std::cout << i << " : " << theInds(i) << std::endl;
}
}
#endif
//III: Put knots in monotone intervals of curvature.
// III: Put knots in monotone intervals of curvature.
Standard_Boolean Ok;
i = 1;
do
{
i++;
//
Ok = InsKnotBefI(i, aCurv, theCoords, dim, theInds, Standard_True);
if(Ok)
Ok = InsKnotBefI(i, aCurv, theCoords, dim, theInds, Standard_True);
if (Ok)
{
i--;
}
}
while(i < theInds.Length());
} while (i < theInds.Length());
//IV: Checking feature points.
// IV: Checking feature points.
j = 2;
for(i = 1; i <= aFeatureInds.Length(); ++i)
for (i = 1; i <= aFeatureInds.Length(); ++i)
{
Standard_Integer anInd = aFeatureInds(i);
for(; j <= theInds.Length() - 1;)
for (; j <= theInds.Length() - 1;)
{
if(theInds(j) == anInd)
if (theInds(j) == anInd)
{
Standard_Integer anIndPrev = theInds(j-1);
Standard_Integer anIndNext = theInds(j+1);
Standard_Integer ici = (anIndPrev - aCurv.Lower()) * theDim,
ici1 = (anIndNext - aCurv.Lower()) * theDim,
icm = (anInd - aCurv.Lower()) * theDim;
Standard_Integer anIndPrev = theInds(j - 1);
Standard_Integer anIndNext = theInds(j + 1);
Standard_Integer ici = (anIndPrev - aCurv.Lower()) * theDim,
ici1 = (anIndNext - aCurv.Lower()) * theDim,
icm = (anInd - aCurv.Lower()) * theDim;
NCollection_LocalArray<Standard_Real> V1(theDim), V2(theDim);
Standard_Real mp = 0., m1 = 0., m2 = 0.;
Standard_Real p;
for(Standard_Integer k = 0; k < theDim; ++k)
Standard_Real mp = 0., m1 = 0., m2 = 0.;
Standard_Real p;
for (Standard_Integer k = 0; k < theDim; ++k)
{
V1[k] = theCoords[icm + k] - theCoords[ici + k];
m1 += V1[k]*V1[k];
m1 += V1[k] * V1[k];
V2[k] = theCoords[ici1 + k] - theCoords[icm + k];
m2 += V2[k]*V2[k];
m2 += V2[k] * V2[k];
}
for(Standard_Integer k = 1; k < theDim; ++k)
for (Standard_Integer k = 1; k < theDim; ++k)
{
for(Standard_Integer l = 0; l < k; ++l)
for (Standard_Integer l = 0; l < k; ++l)
{
p = V1[k]*V2[l] - V1[l]*V2[k];
mp += p*p;
p = V1[k] * V2[l] - V1[l] * V2[k];
mp += p * p;
}
}
//mp *= 2.; //P(j,i) = -P(i,j);
// mp *= 2.; //P(j,i) = -P(i,j);
//
if(mp > aSinCoeff2 * m1 * m2) // Sqrt (mp/(m1*m2)) > aSinCoeff
if (mp > aSinCoeff2 * m1 * m2) // Sqrt (mp/(m1*m2)) > aSinCoeff
{
//Insert new knots
// Insert new knots
Standard_Real d1 = Abs(aCurv(anInd) - aCurv(anIndPrev));
Standard_Real d2 = Abs(aCurv(anInd) - aCurv(anIndNext));
if(d1 > d2)
if (d1 > d2)
{
Ok = InsKnotBefI(j, aCurv, theCoords, dim, theInds, Standard_False);
if(Ok)
if (Ok)
{
j++;
}
@ -318,8 +309,8 @@ void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_
}
else
{
Ok = InsKnotBefI(j+1, aCurv, theCoords, dim, theInds, Standard_False);
if(!Ok)
Ok = InsKnotBefI(j + 1, aCurv, theCoords, dim, theInds, Standard_False);
if (!Ok)
{
break;
}
@ -340,25 +331,22 @@ void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_
//
}
//=================================================================================================
//=======================================================================
//function : FilterKnots
//purpose :
//=======================================================================
void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Integer theMinNbPnts,
NCollection_Vector<Standard_Integer>& theLKnots)
void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Integer theMinNbPnts,
NCollection_Vector<Standard_Integer>& theLKnots)
{
// Maximum number of points per knot interval.
Standard_Integer aMaxNbPnts = aMaxPntCoeff*theMinNbPnts;
Standard_Integer i = 1;
Standard_Integer aMaxNbPnts = aMaxPntCoeff * theMinNbPnts;
Standard_Integer i = 1;
Standard_Integer aMinNbStep = theMinNbPnts / 2;
// I: Filter too big number of points per knot interval.
while(i < theInds.Length())
while (i < theInds.Length())
{
Standard_Integer nbint = theInds(i + 1) - theInds(i) + 1;
if(nbint <= aMaxNbPnts)
if (nbint <= aMaxNbPnts)
{
++i;
continue;
@ -366,7 +354,7 @@ void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& th
else
{
Standard_Integer ind = theInds(i) + nbint / 2;
theInds.InsertAfter(i, ind);
theInds.InsertAfter(i, ind);
}
}
@ -374,14 +362,14 @@ void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& th
i = 1;
theLKnots.Append(theInds(i));
Standard_Integer anIndsPrev = theInds(i);
for(i = 2; i <= theInds.Length(); ++i)
for (i = 2; i <= theInds.Length(); ++i)
{
if(theInds(i) - anIndsPrev <= theMinNbPnts)
if (theInds(i) - anIndsPrev <= theMinNbPnts)
{
if (i != theInds.Length())
{
Standard_Integer anIdx = i + 1;
for( ; anIdx <= theInds.Length(); ++anIdx)
for (; anIdx <= theInds.Length(); ++anIdx)
{
if (theInds(anIdx) - anIndsPrev >= theMinNbPnts)
break;
@ -389,16 +377,15 @@ void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& th
anIdx--;
Standard_Integer aMidIdx = (theInds(anIdx) + anIndsPrev) / 2;
if (aMidIdx - anIndsPrev < theMinNbPnts &&
aMidIdx - theInds(anIdx) < theMinNbPnts &&
theInds(anIdx) - anIndsPrev >= aMinNbStep)
if (aMidIdx - anIndsPrev < theMinNbPnts && aMidIdx - theInds(anIdx) < theMinNbPnts
&& theInds(anIdx) - anIndsPrev >= aMinNbStep)
{
if (theInds(anIdx) - anIndsPrev > 2 * theMinNbPnts)
{
// Bad distribution points merge into one knot interval.
theLKnots.Append(anIndsPrev + theMinNbPnts);
anIndsPrev = anIndsPrev + theMinNbPnts;
i = anIdx - 1;
i = anIdx - 1;
}
else
{
@ -407,12 +394,12 @@ void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& th
// Bad distribution points merge into one knot interval.
theLKnots.Append(theInds(anIdx - 1));
anIndsPrev = theInds(anIdx - 1);
i = anIdx - 1;
i = anIdx - 1;
if (theInds(anIdx) - theInds(anIdx - 1) <= theMinNbPnts / 2)
{
theLKnots.SetValue(theLKnots.Upper(), theInds(anIdx));
anIndsPrev = theInds(anIdx );
i = anIdx;
anIndsPrev = theInds(anIdx);
i = anIdx;
}
}
else
@ -420,23 +407,23 @@ void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& th
// Bad distribution points merge into one knot interval.
theLKnots.Append(theInds(anIdx));
anIndsPrev = theInds(anIdx);
i = anIdx;
i = anIdx;
}
}
}
else if (anIdx == theInds.Upper() && // Last point obtained.
theLKnots.Length() >= 2) // It is possible to modify last item.
theLKnots.Length() >= 2) // It is possible to modify last item.
{
// Current bad interval from i to last.
// Trying to add knot to divide sequence on two parts:
// Last good index -> Last index - theMinNbPnts -> Last index
Standard_Integer aLastGoodIdx = theLKnots.Value(theLKnots.Upper() - 1);
if ( theInds.Last() - 2 * theMinNbPnts >= aLastGoodIdx)
if (theInds.Last() - 2 * theMinNbPnts >= aLastGoodIdx)
{
theLKnots(theLKnots.Upper()) = theInds.Last() - theMinNbPnts;
theLKnots.Append(theInds.Last());
anIndsPrev = theInds(anIdx);
i = anIdx;
i = anIdx;
}
}
} // if (i != theInds.Length())
@ -450,51 +437,50 @@ void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& th
}
// III: Fill Last Knot.
if(theLKnots.Length() < 2)
if (theLKnots.Length() < 2)
{
theLKnots.Append(theInds.Last());
}
else
{
if(theLKnots.Last() < theInds.Last())
if (theLKnots.Last() < theInds.Last())
{
theLKnots(theLKnots.Upper()) = theInds.Last();
}
}
}
//=======================================================================
//function : InsKnotBefI
//purpose :
//=======================================================================
Standard_Boolean ApproxInt_KnotTools::InsKnotBefI(const Standard_Integer theI,
const TColStd_Array1OfReal& theCurv,
const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Boolean ChkCurv)
//=================================================================================================
Standard_Boolean ApproxInt_KnotTools::InsKnotBefI(
const Standard_Integer theI,
const TColStd_Array1OfReal& theCurv,
const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Boolean ChkCurv)
{
Standard_Integer anInd1 = theInds(theI);
Standard_Integer anInd = theInds(theI - 1);
Standard_Integer anInd = theInds(theI - 1);
//
if((anInd1-anInd) == 1)
if ((anInd1 - anInd) == 1)
{
return Standard_False;
}
//
Standard_Real curv = 0.5*(theCurv(anInd) + theCurv(anInd1));
Standard_Integer mid = 0, j, jj;
Standard_Real curv = 0.5 * (theCurv(anInd) + theCurv(anInd1));
Standard_Integer mid = 0, j, jj;
const Standard_Real aLimitCurvatureChange = 3.0;
for(j = anInd+1; j < anInd1; ++j)
for (j = anInd + 1; j < anInd1; ++j)
{
mid = 0;
// I: Curvature change criteria:
// Non-null curvature.
if (theCurv(j) > Precision::Confusion() &&
theCurv(anInd) > Precision::Confusion() )
if (theCurv(j) > Precision::Confusion() && theCurv(anInd) > Precision::Confusion())
{
if (theCurv(j) / theCurv(anInd) > aLimitCurvatureChange ||
theCurv(j) / theCurv(anInd) < 1.0 / aLimitCurvatureChange)
if (theCurv(j) / theCurv(anInd) > aLimitCurvatureChange
|| theCurv(j) / theCurv(anInd) < 1.0 / aLimitCurvatureChange)
{
// Curvature on current interval changed more than 3 times.
mid = j;
@ -505,9 +491,9 @@ Standard_Boolean ApproxInt_KnotTools::InsKnotBefI(const Standard_Integer theI,
// II: Angular criteria:
Standard_Real ac = theCurv(j - 1), ac1 = theCurv(j);
if((curv >= ac && curv <= ac1) || (curv >= ac1 && curv <= ac))
if ((curv >= ac && curv <= ac1) || (curv >= ac1 && curv <= ac))
{
if(Abs(curv - ac) < Abs(curv - ac1))
if (Abs(curv - ac) < Abs(curv - ac1))
{
mid = j - 1;
}
@ -516,41 +502,41 @@ Standard_Boolean ApproxInt_KnotTools::InsKnotBefI(const Standard_Integer theI,
mid = j;
}
}
if(mid == anInd)
if (mid == anInd)
{
mid++;
}
if(mid == anInd1)
if (mid == anInd1)
{
mid--;
}
if(mid > 0)
if (mid > 0)
{
if(ChkCurv)
if (ChkCurv)
{
Standard_Integer ici = (anInd - theCurv.Lower()) * theDim,
ici1 = (anInd1 - theCurv.Lower()) * theDim,
icm = (mid - theCurv.Lower()) * theDim;
Standard_Integer ici = (anInd - theCurv.Lower()) * theDim,
ici1 = (anInd1 - theCurv.Lower()) * theDim,
icm = (mid - theCurv.Lower()) * theDim;
NCollection_LocalArray<Standard_Real> V1(theDim), V2(theDim);
Standard_Integer i;
Standard_Real mp = 0., m1 = 0., m2 = 0.;
Standard_Real p;
for(i = 0; i < theDim; ++i)
Standard_Integer i;
Standard_Real mp = 0., m1 = 0., m2 = 0.;
Standard_Real p;
for (i = 0; i < theDim; ++i)
{
V1[i] = theCoords[icm + i] - theCoords[ici + i];
m1 += V1[i]*V1[i];
m1 += V1[i] * V1[i];
V2[i] = theCoords[ici1 + i] - theCoords[icm + i];
m2 += V2[i]*V2[i];
m2 += V2[i] * V2[i];
}
for(i = 1; i < theDim; ++i)
for (i = 1; i < theDim; ++i)
{
for(jj = 0; jj < i; ++jj)
for (jj = 0; jj < i; ++jj)
{
p = V1[i]*V2[jj] - V1[jj]*V2[i];
mp += p*p;
p = V1[i] * V2[jj] - V1[jj] * V2[i];
mp += p * p;
}
}
//mp *= 2.; //P(j,i) = -P(i,j);
// mp *= 2.; //P(j,i) = -P(i,j);
//
if (mp > aSinCoeff2 * m1 * m2) // Sqrt (mp / m1m2) > aSinCoeff
@ -570,37 +556,35 @@ Standard_Boolean ApproxInt_KnotTools::InsKnotBefI(const Standard_Integer theI,
return Standard_False;
}
//=======================================================================
//function : BuildKnots
//purpose :
//=======================================================================
void ApproxInt_KnotTools::BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
const TColgp_Array1OfPnt2d& thePntsU1V1,
const TColgp_Array1OfPnt2d& thePntsU2V2,
const math_Vector& thePars,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2,
const Standard_Integer theMinNbPnts,
//=================================================================================================
void ApproxInt_KnotTools::BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
const TColgp_Array1OfPnt2d& thePntsU1V1,
const TColgp_Array1OfPnt2d& thePntsU2V2,
const math_Vector& thePars,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2,
const Standard_Integer theMinNbPnts,
NCollection_Vector<Standard_Integer>& theKnots)
{
NCollection_Sequence<Standard_Integer> aKnots;
Standard_Integer aDim = 0;
Standard_Integer aDim = 0;
// I: Convert input data to the corresponding format.
if(theApproxXYZ)
if (theApproxXYZ)
aDim += 3;
if(theApproxU1V1)
if (theApproxU1V1)
aDim += 2;
if(theApproxU2V2)
if (theApproxU2V2)
aDim += 2;
NCollection_LocalArray<Standard_Real> aCoords(thePars.Length()*aDim);
Standard_Integer i, j;
for(i = thePars.Lower(); i <= thePars.Upper(); ++i)
NCollection_LocalArray<Standard_Real> aCoords(thePars.Length() * aDim);
Standard_Integer i, j;
for (i = thePars.Lower(); i <= thePars.Upper(); ++i)
{
j = (i - thePars.Lower()) * aDim;
if(theApproxXYZ)
if (theApproxXYZ)
{
aCoords[j] = thePntsXYZ.Value(i).X();
++j;
@ -609,14 +593,14 @@ void ApproxInt_KnotTools::BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
aCoords[j] = thePntsXYZ.Value(i).Z();
++j;
}
if(theApproxU1V1)
if (theApproxU1V1)
{
aCoords[j] = thePntsU1V1.Value(i).X();
++j;
aCoords[j] = thePntsU1V1.Value(i).Y();
++j;
}
if(theApproxU2V2)
if (theApproxU2V2)
{
aCoords[j] = thePntsU2V2.Value(i).X();
++j;
@ -629,33 +613,31 @@ void ApproxInt_KnotTools::BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
ComputeKnotInds(aCoords, aDim, thePars, aKnots);
#if defined(APPROXINT_KNOTTOOLS_DEBUG)
std::cout << "Draft knot sequence: " << std::endl;
for(i = aKnots.Lower(); i <= aKnots.Upper(); ++i)
{
std::cout << i << " : " << aKnots(i) << std::endl;
}
std::cout << "Draft knot sequence: " << std::endl;
for (i = aKnots.Lower(); i <= aKnots.Upper(); ++i)
{
std::cout << i << " : " << aKnots(i) << std::endl;
}
#endif
// III: Build output knot sequence.
FilterKnots(aKnots, theMinNbPnts, theKnots);
#if defined(APPROXINT_KNOTTOOLS_DEBUG)
std::cout << "Result knot sequence: " << std::endl;
for(i = theKnots.Lower(); i <= theKnots.Upper(); ++i)
{
std::cout << i << " : " << theKnots(i) << std::endl;
}
std::cout << "Result knot sequence: " << std::endl;
for (i = theKnots.Lower(); i <= theKnots.Upper(); ++i)
{
std::cout << i << " : " << theKnots(i) << std::endl;
}
#endif
}
//=======================================================================
//function : MaxParamRatio
//purpose :
//=======================================================================
//=================================================================================================
static Standard_Real MaxParamRatio(const math_Vector& thePars)
{
Standard_Integer i;
Standard_Real aMaxRatio = 0.;
Standard_Real aMaxRatio = 0.;
//
for (i = thePars.Lower() + 1; i < thePars.Upper(); ++i)
{
@ -667,30 +649,41 @@ static Standard_Real MaxParamRatio(const math_Vector& thePars)
}
return aMaxRatio;
}
//=======================================================================
//function : DefineParType
//purpose :
//=======================================================================
Approx_ParametrizationType ApproxInt_KnotTools::DefineParType(
const Handle(IntPatch_WLine)& theWL,
const Standard_Integer theFpar, const Standard_Integer theLpar,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2
)
//=================================================================================================
Approx_ParametrizationType ApproxInt_KnotTools::DefineParType(const Handle(IntPatch_WLine)& theWL,
const Standard_Integer theFpar,
const Standard_Integer theLpar,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2)
{
if (theLpar - theFpar == 1)
return Approx_IsoParametric;
const Standard_Integer nbp3d = theApproxXYZ ? 1 : 0,
nbp2d = (theApproxU1V1 ? 1 : 0) + (theApproxU2V2 ? 1 : 0);
const Standard_Integer nbp3d = theApproxXYZ ? 1 : 0,
nbp2d = (theApproxU1V1 ? 1 : 0) + (theApproxU2V2 ? 1 : 0);
GeomInt_TheMultiLineOfWLApprox aTestLine(theWL, nbp3d, nbp2d, theApproxU1V1, theApproxU2V2,
0., 0., 0., 0., 0., 0., 0., theApproxU1V1, theFpar, theLpar);
GeomInt_TheMultiLineOfWLApprox aTestLine(theWL,
nbp3d,
nbp2d,
theApproxU1V1,
theApproxU2V2,
0.,
0.,
0.,
0.,
0.,
0.,
0.,
theApproxU1V1,
theFpar,
theLpar);
TColgp_Array1OfPnt aTabPnt3d(1, Max(1, nbp3d));
TColgp_Array1OfPnt aTabPnt3d(1, Max(1, nbp3d));
TColgp_Array1OfPnt2d aTabPnt2d(1, Max(1, nbp2d));
TColgp_Array1OfPnt aPntXYZ(theFpar, theLpar);
TColgp_Array1OfPnt aPntXYZ(theFpar, theLpar);
TColgp_Array1OfPnt2d aPntU1V1(theFpar, theLpar);
TColgp_Array1OfPnt2d aPntU2V2(theFpar, theLpar);
@ -698,9 +691,12 @@ Approx_ParametrizationType ApproxInt_KnotTools::DefineParType(
for (i = theFpar; i <= theLpar; ++i)
{
if (nbp3d != 0 && nbp2d != 0) aTestLine.Value(i, aTabPnt3d, aTabPnt2d);
else if (nbp2d != 0) aTestLine.Value(i, aTabPnt2d);
else if (nbp3d != 0) aTestLine.Value(i, aTabPnt3d);
if (nbp3d != 0 && nbp2d != 0)
aTestLine.Value(i, aTabPnt3d, aTabPnt2d);
else if (nbp2d != 0)
aTestLine.Value(i, aTabPnt2d);
else if (nbp3d != 0)
aTestLine.Value(i, aTabPnt3d);
//
if (nbp3d > 0)
{
@ -733,7 +729,7 @@ Approx_ParametrizationType ApproxInt_KnotTools::DefineParType(
if (theApproxU2V2)
aDim += 2;
Standard_Integer aLength = theLpar - theFpar + 1;
Standard_Integer aLength = theLpar - theFpar + 1;
NCollection_LocalArray<Standard_Real> aCoords(aLength * aDim);
for (i = theFpar; i <= theLpar; ++i)
{
@ -763,26 +759,25 @@ Approx_ParametrizationType ApproxInt_KnotTools::DefineParType(
}
}
//Analysis of curvature
const Standard_Real aCritRat = 500.;
const Standard_Real aCritParRat = 100.;
math_Vector aPars(theFpar, theLpar);
// Analysis of curvature
const Standard_Real aCritRat = 500.;
const Standard_Real aCritParRat = 100.;
math_Vector aPars(theFpar, theLpar);
Approx_ParametrizationType aParType = Approx_ChordLength;
GeomInt_WLApprox::Parameters(aTestLine, theFpar, theLpar, aParType, aPars);
TColStd_Array1OfReal aCurv(aPars.Lower(), aPars.Upper());
Standard_Real aMaxCurv = 0.;
Standard_Real aMaxCurv = 0.;
BuildCurvature(aCoords, aDim, aPars, aCurv, aMaxCurv);
if (aMaxCurv < Precision::PConfusion()
|| Precision::IsPositiveInfinite(aMaxCurv))
if (aMaxCurv < Precision::PConfusion() || Precision::IsPositiveInfinite(aMaxCurv))
{
//Linear case
// Linear case
return aParType;
}
Standard_Real aMidCurv = 0.;
Standard_Real eps = Epsilon(1.);
j = 0;
Standard_Real eps = Epsilon(1.);
j = 0;
for (i = aCurv.Lower(); i <= aCurv.Upper(); ++i)
{
if (aMaxCurv - aCurv(i) < eps)
@ -802,10 +797,10 @@ Approx_ParametrizationType ApproxInt_KnotTools::DefineParType(
return aParType;
Standard_Real aRat = aMaxCurv / aMidCurv;
if (aRat > aCritRat)
{
if(aRat > 5.*aCritRat)
if (aRat > 5. * aCritRat)
aParType = Approx_Centripetal;
else
{

99
src/ApproxInt/ApproxInt_KnotTools.hxx
View File

@ -14,28 +14,29 @@
#ifndef _ApproxInt_KnotTools_HeaderFile
#define _ApproxInt_KnotTools_HeaderFile
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <NCollection_Sequence.hxx>
#include <NCollection_List.hxx>
#include <math_Vector.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <NCollection_LocalArray.hxx>
#include <NCollection_Vector.hxx>
#include <Approx_ParametrizationType.hxx>
#include <NCollection_List.hxx>
#include <NCollection_LocalArray.hxx>
#include <NCollection_Sequence.hxx>
#include <NCollection_Vector.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Macro.hxx>
#include <Standard_Real.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <math_Vector.hxx>
class IntPatch_WLine;
// Corresponds for debug information output.
// Debug information is also printed when OCCT_DEBUG defined.
//#define APPROXINT_KNOTTOOLS_DEBUG
// #define APPROXINT_KNOTTOOLS_DEBUG
//! This class intended to build knots sequence on discrete set of points for further approximation into bspline curve.
//! This class intended to build knots sequence on discrete set of points for further approximation
//! into bspline curve.
//!
//! Short description of algorithm:
//! 1) Build discrete curvature on points set.
@ -47,7 +48,6 @@ class IntPatch_WLine;
class ApproxInt_KnotTools
{
public:
DEFINE_STANDARD_ALLOC
//! Main function to build optimal knot sequence.
@ -61,34 +61,33 @@ public:
//! @param theApproxU2V2 - Flag existence of second 2d set.
//! @param theMinNbPnts - Minimal number of points per knot interval.
//! @param theKnots - output knots sequence.
Standard_EXPORT static void BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
const TColgp_Array1OfPnt2d& thePntsU1V1,
const TColgp_Array1OfPnt2d& thePntsU2V2,
const math_Vector& thePars,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2,
const Standard_Integer theMinNbPnts,
Standard_EXPORT static void BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
const TColgp_Array1OfPnt2d& thePntsU1V1,
const TColgp_Array1OfPnt2d& thePntsU2V2,
const math_Vector& thePars,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2,
const Standard_Integer theMinNbPnts,
NCollection_Vector<Standard_Integer>& theKnots);
//! Builds discrete curvature
Standard_EXPORT static void BuildCurvature(
const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
const math_Vector& thePars,
TColStd_Array1OfReal& theCurv,
Standard_Real& theMaxCurv);
//! Defines preferable parametrization type for theWL
Standard_EXPORT static Approx_ParametrizationType DefineParType(const Handle(IntPatch_WLine)& theWL,
const Standard_Integer theFpar, const Standard_Integer theLpar,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2);
Standard_EXPORT static void BuildCurvature(const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
const math_Vector& thePars,
TColStd_Array1OfReal& theCurv,
Standard_Real& theMaxCurv);
//! Defines preferable parametrization type for theWL
Standard_EXPORT static Approx_ParametrizationType DefineParType(
const Handle(IntPatch_WLine)& theWL,
const Standard_Integer theFpar,
const Standard_Integer theLpar,
const Standard_Boolean theApproxXYZ,
const Standard_Boolean theApproxU1V1,
const Standard_Boolean theApproxU2V2);
private:
//! Compute indices of knots:
//!
//! I: Build discrete curvature in points set,
@ -100,25 +99,25 @@ private:
//!
//! IV: Put additional knots near extrema points.
static void ComputeKnotInds(const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
const math_Vector& thePars,
NCollection_Sequence<Standard_Integer>& theInds);
const Standard_Integer theDim,
const math_Vector& thePars,
NCollection_Sequence<Standard_Integer>& theInds);
//! Insert knots before index I.
//!
//! I: Check curvature change:
//! if ( maxCurvature / minCurvature ) of current interval greater than
//! if ( maxCurvature / minCurvature ) of current interval greater than
//! threshold value, then stop and use upper index as knot.
//!
//! II: Check midpoint criteria:
//! If exist point between two knot indices with angle greater than
//! threshold value, then stop and put this index as knot.
static Standard_Boolean InsKnotBefI(const Standard_Integer theI,
const TColStd_Array1OfReal& theCurv,
static Standard_Boolean InsKnotBefI(const Standard_Integer theI,
const TColStd_Array1OfReal& theCurv,
const NCollection_LocalArray<Standard_Real>& theCoords,
const Standard_Integer theDim,
NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Boolean ChkCurv);
const Standard_Integer theDim,
NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Boolean ChkCurv);
//! Perform knots filtration.
//!
@ -127,9 +126,9 @@ private:
//! II: Filter points with too small amount of points per knot interval.
//!
//! III: Fill Last Knot.
static void FilterKnots(NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Integer theMinNbPnts,
NCollection_Vector<Standard_Integer>& theLKnots);
static void FilterKnots(NCollection_Sequence<Standard_Integer>& theInds,
const Standard_Integer theMinNbPnts,
NCollection_Vector<Standard_Integer>& theLKnots);
};
#endif

221
src/ApproxInt/ApproxInt_MultiLineTool.lxx
View File

@ -23,110 +23,163 @@
#include <Approx_Status.hxx>
//================================================================================
inline Standard_Integer ApproxInt_MultiLineTool::NbP2d(const TheMultiLine& ML) {
return(ML.NbP2d());
}
//--------------------------------------------------------------------------------
inline Standard_Integer ApproxInt_MultiLineTool::NbP3d(const TheMultiLine& ML) {
return(ML.NbP3d());
}
//--------------------------------------------------------------------------------
inline Standard_Integer ApproxInt_MultiLineTool::FirstPoint(const TheMultiLine& ML) {
return(ML.FirstPoint());
}
//--------------------------------------------------------------------------------
inline Standard_Integer ApproxInt_MultiLineTool::LastPoint(const TheMultiLine& ML) {
return(ML.LastPoint());
}
//--------------------------------------------------------------------------------
inline void ApproxInt_MultiLineTool::Value( const TheMultiLine& ML
,const Standard_Integer Index
,TColgp_Array1OfPnt& TabPnt) {
ML.Value(Index,TabPnt);
}
//--------------------------------------------------------------------------------
inline void ApproxInt_MultiLineTool::Value( const TheMultiLine& ML
,const Standard_Integer Index
,TColgp_Array1OfPnt2d& TabPnt2d) {
ML.Value(Index,TabPnt2d);
}
//--------------------------------------------------------------------------------
inline void ApproxInt_MultiLineTool::Value( const TheMultiLine& ML
,const Standard_Integer Index
,TColgp_Array1OfPnt& TabPnt
,TColgp_Array1OfPnt2d& TabPnt2d) {
ML.Value(Index,TabPnt,TabPnt2d);
}
//--------------------------------------------------------------------------------
inline Standard_Boolean ApproxInt_MultiLineTool::Tangency( const TheMultiLine& ML
,const Standard_Integer Index
,TColgp_Array1OfVec& TabVec) {
return(ML.Tangency(Index,TabVec));
}
//--------------------------------------------------------------------------------
inline Standard_Boolean ApproxInt_MultiLineTool::Tangency( const TheMultiLine& ML
,const Standard_Integer Index
,TColgp_Array1OfVec2d& TabVec2d) {
return(ML.Tangency(Index,TabVec2d));
}
//--------------------------------------------------------------------------------
inline Standard_Boolean ApproxInt_MultiLineTool::Tangency( const TheMultiLine& ML
,const Standard_Integer Index
,TColgp_Array1OfVec& TabVec
,TColgp_Array1OfVec2d& TabVec2d) {
return(ML.Tangency(Index,TabVec,TabVec2d));
//=================================================================================================
inline Standard_Integer ApproxInt_MultiLineTool::NbP2d(const TheMultiLine& ML)
{
return (ML.NbP2d());
}
//--------------------------------------------------------------------------------
inline Standard_Boolean ApproxInt_MultiLineTool::Curvature( const TheMultiLine& //ML
,const Standard_Integer //Index
,TColgp_Array1OfVec& ) { //TabVec
//=================================================================================================
inline Standard_Integer ApproxInt_MultiLineTool::NbP3d(const TheMultiLine& ML)
{
return (ML.NbP3d());
}
//=================================================================================================
inline Standard_Integer ApproxInt_MultiLineTool::FirstPoint(const TheMultiLine& ML)
{
return (ML.FirstPoint());
}
//=================================================================================================
inline Standard_Integer ApproxInt_MultiLineTool::LastPoint(const TheMultiLine& ML)
{
return (ML.LastPoint());
}
//=================================================================================================
inline void ApproxInt_MultiLineTool::Value(const TheMultiLine& ML,
const Standard_Integer Index,
TColgp_Array1OfPnt& TabPnt)
{
ML.Value(Index, TabPnt);
}
//=================================================================================================
inline void ApproxInt_MultiLineTool::Value(const TheMultiLine& ML,
const Standard_Integer Index,
TColgp_Array1OfPnt2d& TabPnt2d)
{
ML.Value(Index, TabPnt2d);
}
//=================================================================================================
inline void ApproxInt_MultiLineTool::Value(const TheMultiLine& ML,
const Standard_Integer Index,
TColgp_Array1OfPnt& TabPnt,
TColgp_Array1OfPnt2d& TabPnt2d)
{
ML.Value(Index, TabPnt, TabPnt2d);
}
//=================================================================================================
inline Standard_Boolean ApproxInt_MultiLineTool::Tangency(const TheMultiLine& ML,
const Standard_Integer Index,
TColgp_Array1OfVec& TabVec)
{
return (ML.Tangency(Index, TabVec));
}
//=================================================================================================
inline Standard_Boolean ApproxInt_MultiLineTool::Tangency(const TheMultiLine& ML,
const Standard_Integer Index,
TColgp_Array1OfVec2d& TabVec2d)
{
return (ML.Tangency(Index, TabVec2d));
}
//=================================================================================================
inline Standard_Boolean ApproxInt_MultiLineTool::Tangency(const TheMultiLine& ML,
const Standard_Integer Index,
TColgp_Array1OfVec& TabVec,
TColgp_Array1OfVec2d& TabVec2d)
{
return (ML.Tangency(Index, TabVec, TabVec2d));
}
//=================================================================================================
inline Standard_Boolean ApproxInt_MultiLineTool::Curvature(const TheMultiLine& // ML
,
const Standard_Integer // Index
,
TColgp_Array1OfVec&)
{ // TabVec
return Standard_False;
}
//--------------------------------------------------------------------------------
inline Standard_Boolean ApproxInt_MultiLineTool::Curvature( const TheMultiLine& //ML
,const Standard_Integer //Index
,TColgp_Array1OfVec2d& ) { //TabVec2d
//=================================================================================================
inline Standard_Boolean ApproxInt_MultiLineTool::Curvature(const TheMultiLine& // ML
,
const Standard_Integer // Index
,
TColgp_Array1OfVec2d&)
{ // TabVec2d
return Standard_False;
}
//--------------------------------------------------------------------------------
inline Standard_Boolean ApproxInt_MultiLineTool::Curvature( const TheMultiLine& //ML
,const Standard_Integer //Index
,TColgp_Array1OfVec& //TabVec
,TColgp_Array1OfVec2d& ) { //TabVec2d
//=================================================================================================
inline Standard_Boolean ApproxInt_MultiLineTool::Curvature(const TheMultiLine& // ML
,
const Standard_Integer // Index
,
TColgp_Array1OfVec& // TabVec
,
TColgp_Array1OfVec2d&)
{ // TabVec2d
return Standard_False;
}
//--------------------------------------------------------------------------------
inline Approx_Status ApproxInt_MultiLineTool::WhatStatus(const TheMultiLine& ML
,const Standard_Integer
,const Standard_Integer) {
//=================================================================================================
inline Approx_Status ApproxInt_MultiLineTool::WhatStatus(const TheMultiLine& ML,
const Standard_Integer,
const Standard_Integer)
{
//-- PointsAdded,
//-- NoPointsAdded,
//-- NoApproximation
//-- Approx_PointsAdded
return(ML.WhatStatus());
return (ML.WhatStatus());
}
//--------------------------------------------------------------------------------
inline TheMultiLine ApproxInt_MultiLineTool::MakeMLBetween(const TheMultiLine& ML,
const Standard_Integer I1,
const Standard_Integer I2,
const Standard_Integer NbPMin) {
return(ML.MakeMLBetween(I1,I2,NbPMin));
//=================================================================================================
inline TheMultiLine ApproxInt_MultiLineTool::MakeMLBetween(const TheMultiLine& ML,
const Standard_Integer I1,
const Standard_Integer I2,
const Standard_Integer NbPMin)
{
return (ML.MakeMLBetween(I1, I2, NbPMin));
}
//--------------------------------------------------------------------------------
inline Standard_Boolean ApproxInt_MultiLineTool::MakeMLOneMorePoint(const TheMultiLine& ML,
//=================================================================================================
inline Standard_Boolean ApproxInt_MultiLineTool::MakeMLOneMorePoint(const TheMultiLine& ML,
const Standard_Integer I1,
const Standard_Integer I2,
const Standard_Integer indbad,
TheMultiLine& OtherLine)
{
return (ML.MakeMLOneMorePoint(I1,I2,indbad,OtherLine));
{
return (ML.MakeMLOneMorePoint(I1, I2, indbad, OtherLine));
}
inline void ApproxInt_MultiLineTool::Dump(const TheMultiLine& ML)
{
{
ML.Dump();
}
//================================================================================
//=================================================================================================

14
src/ApproxInt/ApproxInt_SvSurfaces.cxx
View File

@ -12,13 +12,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <ApproxInt_SvSurfaces.hxx>
//=======================================================================
//function : ~ApproxInt_SvSurfaces
//purpose : Destructor
//=======================================================================
ApproxInt_SvSurfaces::~ApproxInt_SvSurfaces()
{
}
//=================================================================================================
// function : ~ApproxInt_SvSurfaces
// purpose : Destructor
//=================================================================================================
ApproxInt_SvSurfaces::~ApproxInt_SvSurfaces() {}

96
src/ApproxInt/ApproxInt_SvSurfaces.hxx
View File

@ -28,72 +28,74 @@ class gp_Vec;
class gp_Vec2d;
class IntSurf_PntOn2S;
//! This class is root class for classes dedicated to calculate
//! This class is root class for classes dedicated to calculate
//! 2d and 3d points and tangents of intersection lines of two surfaces of different types
//! for given u, v parameters of intersection point on two surfaces.
//!
//!
//! The field myUseSolver is used to manage type of calculation:
//! if myUseSolver = true, input parameters u1, v1, u2, v2 are considered as first approximation of
//! exact intersection point, then coordinates u1, v1, u2, v2 are refined with help of
//! if myUseSolver = true, input parameters u1, v1, u2, v2 are considered as first approximation of
//! exact intersection point, then coordinates u1, v1, u2, v2 are refined with help of
//! the solver used in intersection algorithm and required values are calculated.
//! if myUseSolver = false, u1, v1, u2, v2 are considered as "exact" intersection points on two surfaces
//! and required values are calculated directly using u1, v1, u2, v2
//! if myUseSolver = false, u1, v1, u2, v2 are considered as "exact" intersection points on two
//! surfaces and required values are calculated directly using u1, v1, u2, v2
class ApproxInt_SvSurfaces
{
public:
DEFINE_STANDARD_ALLOC
ApproxInt_SvSurfaces() : myUseSolver (false) {}
ApproxInt_SvSurfaces()
: myUseSolver(false)
{
}
//! returns True if Tg,Tguv1 Tguv2 can be computed.
Standard_EXPORT virtual Standard_Boolean Compute (Standard_Real& u1, Standard_Real& v1,
Standard_Real& u2, Standard_Real& v2,
gp_Pnt& Pt,
gp_Vec& Tg,
gp_Vec2d& Tguv1,
gp_Vec2d& Tguv2) = 0;
Standard_EXPORT virtual void Pnt (const Standard_Real u1, const Standard_Real v1,
const Standard_Real u2, const Standard_Real v2,
gp_Pnt& P) = 0;
Standard_EXPORT virtual Standard_Boolean Compute(Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
Standard_Real& v2,
gp_Pnt& Pt,
gp_Vec& Tg,
gp_Vec2d& Tguv1,
gp_Vec2d& Tguv2) = 0;
Standard_EXPORT virtual void Pnt(const Standard_Real u1,
const Standard_Real v1,
const Standard_Real u2,
const Standard_Real v2,
gp_Pnt& P) = 0;
//! computes point on curve and parameters on the surfaces
Standard_EXPORT virtual Standard_Boolean SeekPoint(const Standard_Real u1, const Standard_Real v1,
const Standard_Real u2, const Standard_Real v2,
IntSurf_PntOn2S& Point) = 0;
Standard_EXPORT virtual Standard_Boolean Tangency (const Standard_Real u1, const Standard_Real v1,
const Standard_Real u2, const Standard_Real v2,
gp_Vec& Tg) = 0;
Standard_EXPORT virtual Standard_Boolean TangencyOnSurf1 (const Standard_Real u1,
const Standard_Real v1,
const Standard_Real u2,
const Standard_Real v2,
gp_Vec2d& Tg) = 0;
Standard_EXPORT virtual Standard_Boolean TangencyOnSurf2 (const Standard_Real u1,
const Standard_Real v1,
const Standard_Real u2,
const Standard_Real v2,
gp_Vec2d& Tg) = 0;
Standard_EXPORT virtual Standard_Boolean SeekPoint(const Standard_Real u1,
const Standard_Real v1,
const Standard_Real u2,
const Standard_Real v2,
IntSurf_PntOn2S& Point) = 0;
Standard_EXPORT virtual Standard_Boolean Tangency(const Standard_Real u1,
const Standard_Real v1,
const Standard_Real u2,
const Standard_Real v2,
gp_Vec& Tg) = 0;
Standard_EXPORT virtual Standard_Boolean TangencyOnSurf1(const Standard_Real u1,
const Standard_Real v1,
const Standard_Real u2,
const Standard_Real v2,
gp_Vec2d& Tg) = 0;
Standard_EXPORT virtual Standard_Boolean TangencyOnSurf2(const Standard_Real u1,
const Standard_Real v1,
const Standard_Real u2,
const Standard_Real v2,
gp_Vec2d& Tg) = 0;
Standard_EXPORT virtual ~ApproxInt_SvSurfaces();
void SetUseSolver (const Standard_Boolean theUseSol)
{
myUseSolver = theUseSol;
}
void SetUseSolver(const Standard_Boolean theUseSol) { myUseSolver = theUseSol; }
virtual Standard_Boolean GetUseSolver() const
{
return myUseSolver;
}
virtual Standard_Boolean GetUseSolver() const { return myUseSolver; }
private:
Standard_Boolean myUseSolver;
};
#endif // _ApproxInt_SvSurfaces_HeaderFile

345
src/DE/DE_ConfigurationContext.cxx
View File

@ -15,9 +15,9 @@
#include <Message.hxx>
#include <OSD_File.hxx>
#include <OSD_StreamBuffer.hxx>
#include <OSD_Path.hxx>
#include <OSD_Protection.hxx>
#include <OSD_StreamBuffer.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_HAsciiString.hxx>
@ -34,132 +34,123 @@ enum DE_ConfigurationContext_KindOfLine
namespace
{
//=======================================================================
//function : GetLine
//purpose :
//=======================================================================
static Standard_Boolean GetLine(OSD_File& theFile, TCollection_AsciiString& theLine)
//=================================================================================================
static Standard_Boolean GetLine(OSD_File& theFile, TCollection_AsciiString& theLine)
{
TCollection_AsciiString aBuffer;
Standard_Integer aBufSize = 10;
Standard_Integer aLen;
theLine.Clear();
do
{
TCollection_AsciiString aBuffer;
Standard_Integer aBufSize = 10;
Standard_Integer aLen;
theLine.Clear();
do
theFile.ReadLine(aBuffer, aBufSize, aLen);
theLine += aBuffer;
if (theFile.IsAtEnd())
{
theFile.ReadLine(aBuffer, aBufSize, aLen);
theLine += aBuffer;
if (theFile.IsAtEnd())
if (!theLine.Length())
{
if (!theLine.Length())
{
return Standard_False;
}
else
{
theLine += "\n";
}
return Standard_False;
}
} while (theLine.Value(theLine.Length()) != '\n');
return Standard_True;
}
//=======================================================================
//function : WhatKindOfLine
//purpose :
//=======================================================================
static DE_ConfigurationContext_KindOfLine WhatKindOfLine(const TCollection_AsciiString& theLine,
TCollection_AsciiString& theToken1,
TCollection_AsciiString& theToken2)
{
static const TCollection_AsciiString aWhiteSpace = " \t\r\n";
Standard_Integer aPos1 = 0, aPos2 = 0, aPos = 0;
TCollection_AsciiString aLine(theLine);
aLine.LeftAdjust();
aLine.RightAdjust();
if (!aLine.EndsWith(':') && (!aLine.EndsWith(' ') || !aLine.EndsWith('\t') || !aLine.EndsWith('\n')))
{
aLine.InsertAfter(aLine.Length(), " ");
}
if (aLine.Value(1) == '!')
{
return DE_ConfigurationContext_KindOfLine_Comment;
}
aPos1 = aLine.FirstLocationNotInSet(aWhiteSpace, 1, aLine.Length());
if (aLine.Value(aPos1) == '\n')
{
return DE_ConfigurationContext_KindOfLine_Empty;
}
aPos2 = aLine.Location(1, ':', aPos1, aLine.Length());
if (aPos2 == 0 || aPos1 == aPos2)
{
return DE_ConfigurationContext_KindOfLine_Error;
}
for (aPos = aPos2 - 1; aLine.Value(aPos) == '\t' || aLine.Value(aPos) == ' '; aPos--);
theToken1 = aLine.SubString(aPos1, aPos);
if(aPos2 != aLine.Length())
{
aPos2++;
}
aPos = aLine.FirstLocationNotInSet(aWhiteSpace, aPos2, aLine.Length());
if (aPos != 0)
{
if (aLine.Value(aPos) == '\\')
else
{
switch (aLine.Value(aPos + 1))
{
case '\\':
case ' ':
case '\t':
aPos++;
break;
}
theLine += "\n";
}
}
if (aPos == aLine.Length() || aPos == 0)
{
theToken2.Clear();
}
else
{
aLine.Remove(1, aPos - 1);
aLine.Remove(aLine.Length());
theToken2 = aLine;
}
return DE_ConfigurationContext_KindOfLine_Resource;
}
//=======================================================================
//function : MakeName
//purpose :
//=======================================================================
static TCollection_AsciiString MakeName(const TCollection_AsciiString& theScope,
const TCollection_AsciiString& theParam)
{
TCollection_AsciiString aStr(theScope);
if (!aStr.IsEmpty())
{
aStr += '.';
}
aStr += theParam;
return aStr;
}
} while (theLine.Value(theLine.Length()) != '\n');
return Standard_True;
}
//=======================================================================
//function : DE_ConfigurationContext
//purpose :
//=======================================================================
DE_ConfigurationContext::DE_ConfigurationContext()
{}
//=================================================================================================
static DE_ConfigurationContext_KindOfLine WhatKindOfLine(const TCollection_AsciiString& theLine,
TCollection_AsciiString& theToken1,
TCollection_AsciiString& theToken2)
{
static const TCollection_AsciiString aWhiteSpace = " \t\r\n";
Standard_Integer aPos1 = 0, aPos2 = 0, aPos = 0;
TCollection_AsciiString aLine(theLine);
aLine.LeftAdjust();
aLine.RightAdjust();
if (!aLine.EndsWith(':')
&& (!aLine.EndsWith(' ') || !aLine.EndsWith('\t') || !aLine.EndsWith('\n')))
{
aLine.InsertAfter(aLine.Length(), " ");
}
if (aLine.Value(1) == '!')
{
return DE_ConfigurationContext_KindOfLine_Comment;
}
aPos1 = aLine.FirstLocationNotInSet(aWhiteSpace, 1, aLine.Length());
if (aLine.Value(aPos1) == '\n')
{
return DE_ConfigurationContext_KindOfLine_Empty;
}
aPos2 = aLine.Location(1, ':', aPos1, aLine.Length());
if (aPos2 == 0 || aPos1 == aPos2)
{
return DE_ConfigurationContext_KindOfLine_Error;
}
for (aPos = aPos2 - 1; aLine.Value(aPos) == '\t' || aLine.Value(aPos) == ' '; aPos--)
;
theToken1 = aLine.SubString(aPos1, aPos);
if (aPos2 != aLine.Length())
{
aPos2++;
}
aPos = aLine.FirstLocationNotInSet(aWhiteSpace, aPos2, aLine.Length());
if (aPos != 0)
{
if (aLine.Value(aPos) == '\\')
{
switch (aLine.Value(aPos + 1))
{
case '\\':
case ' ':
case '\t':
aPos++;
break;
}
}
}
if (aPos == aLine.Length() || aPos == 0)
{
theToken2.Clear();
}
else
{
aLine.Remove(1, aPos - 1);
aLine.Remove(aLine.Length());
theToken2 = aLine;
}
return DE_ConfigurationContext_KindOfLine_Resource;
}
//=================================================================================================
static TCollection_AsciiString MakeName(const TCollection_AsciiString& theScope,
const TCollection_AsciiString& theParam)
{
TCollection_AsciiString aStr(theScope);
if (!aStr.IsEmpty())
{
aStr += '.';
}
aStr += theParam;
return aStr;
}
} // namespace
//=================================================================================================
DE_ConfigurationContext::DE_ConfigurationContext() {}
//=================================================================================================
//=======================================================================
//function : Load
//purpose :
//=======================================================================
Standard_Boolean DE_ConfigurationContext::Load(const TCollection_AsciiString& theConfiguration)
{
OSD_Path aPath = theConfiguration;
@ -181,15 +172,13 @@ Standard_Boolean DE_ConfigurationContext::Load(const TCollection_AsciiString& th
return true;
}
//=======================================================================
//function : LoadFile
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::LoadFile(const TCollection_AsciiString& theFile)
{
myResource.Clear();
OSD_Path aPath(theFile);
OSD_File aFile = aPath;
OSD_Path aPath(theFile);
OSD_File aFile = aPath;
TCollection_AsciiString FileName = aPath.Name();
aFile.Open(OSD_ReadOnly, OSD_Protection());
if (aFile.Failed())
@ -209,15 +198,13 @@ Standard_Boolean DE_ConfigurationContext::LoadFile(const TCollection_AsciiString
return Standard_True;
}
//=======================================================================
//function : LoadStr
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::LoadStr(const TCollection_AsciiString& theResource)
{
myResource.Clear();
TCollection_AsciiString aLine = "";
const Standard_Integer aLength = theResource.Length();
TCollection_AsciiString aLine = "";
const Standard_Integer aLength = theResource.Length();
for (Standard_Integer anInd = 1; anInd <= aLength; anInd++)
{
const Standard_Character aChar = theResource.Value(anInd);
@ -236,71 +223,60 @@ Standard_Boolean DE_ConfigurationContext::LoadStr(const TCollection_AsciiString&
return Standard_True;
}
//=======================================================================
//function : IsParamSet
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::IsParamSet(const TCollection_AsciiString& theParam,
const TCollection_AsciiString& theScope) const
{
TCollection_AsciiString aResource(MakeName(theScope, theParam));
TCollection_AsciiString aResource(MakeName(theScope, theParam));
return myResource.IsBound(aResource);
}
//=======================================================================
//function : RealVal
//purpose :
//=======================================================================
//=================================================================================================
Standard_Real DE_ConfigurationContext::RealVal(const TCollection_AsciiString& theParam,
const Standard_Real theDefValue,
const Standard_Real theDefValue,
const TCollection_AsciiString& theScope) const
{
Standard_Real aVal = 0.;
return GetReal(theParam, aVal, theScope) ? aVal : theDefValue;
}
//=======================================================================
//function : IntegerVal
//purpose :
//=======================================================================
//=================================================================================================
Standard_Integer DE_ConfigurationContext::IntegerVal(const TCollection_AsciiString& theParam,
const Standard_Integer theDefValue,
const Standard_Integer theDefValue,
const TCollection_AsciiString& theScope) const
{
Standard_Integer aVal = 0;
return GetInteger(theParam, aVal, theScope) ? aVal : theDefValue;
}
//=======================================================================
//function : BooleanVal
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::BooleanVal(const TCollection_AsciiString& theParam,
const Standard_Boolean theDefValue,
const Standard_Boolean theDefValue,
const TCollection_AsciiString& theScope) const
{
Standard_Boolean aVal = Standard_False;
return GetBoolean(theParam, aVal, theScope) ? aVal : theDefValue;
}
//=======================================================================
//function : StringVal
//purpose :
//=======================================================================
TCollection_AsciiString DE_ConfigurationContext::StringVal(const TCollection_AsciiString& theParam,
const TCollection_AsciiString& theDefValue,
const TCollection_AsciiString& theScope) const
//=================================================================================================
TCollection_AsciiString DE_ConfigurationContext::StringVal(
const TCollection_AsciiString& theParam,
const TCollection_AsciiString& theDefValue,
const TCollection_AsciiString& theScope) const
{
TCollection_AsciiString aVal = "";
return GetString(theParam, aVal, theScope) ? aVal : theDefValue;
}
//=======================================================================
//function : GetReal
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::GetReal(const TCollection_AsciiString& theParam,
Standard_Real& theValue,
Standard_Real& theValue,
const TCollection_AsciiString& theScope) const
{
TCollection_AsciiString aStr;
@ -316,12 +292,10 @@ Standard_Boolean DE_ConfigurationContext::GetReal(const TCollection_AsciiString&
return Standard_False;
}
//=======================================================================
//function : GetInteger
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::GetInteger(const TCollection_AsciiString& theParam,
Standard_Integer& theValue,
Standard_Integer& theValue,
const TCollection_AsciiString& theScope) const
{
TCollection_AsciiString aStr;
@ -337,12 +311,10 @@ Standard_Boolean DE_ConfigurationContext::GetInteger(const TCollection_AsciiStri
return Standard_False;
}
//=======================================================================
//function : GetBoolean
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::GetBoolean(const TCollection_AsciiString& theParam,
Standard_Boolean& theValue,
Standard_Boolean& theValue,
const TCollection_AsciiString& theScope) const
{
TCollection_AsciiString aStr;
@ -358,25 +330,22 @@ Standard_Boolean DE_ConfigurationContext::GetBoolean(const TCollection_AsciiStri
return Standard_False;
}
//=======================================================================
//function : GetString
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::GetString(const TCollection_AsciiString& theParam,
TCollection_AsciiString& theStr,
TCollection_AsciiString& theStr,
const TCollection_AsciiString& theScope) const
{
TCollection_AsciiString aResource = MakeName(theScope, theParam);
return myResource.Find(aResource, theStr);
}
//=======================================================================
//function : GetStringSeq
//purpose :
//=======================================================================
Standard_Boolean DE_ConfigurationContext::GetStringSeq(const TCollection_AsciiString& theParam,
TColStd_ListOfAsciiString& theValue,
const TCollection_AsciiString& theScope) const
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::GetStringSeq(
const TCollection_AsciiString& theParam,
TColStd_ListOfAsciiString& theValue,
const TCollection_AsciiString& theScope) const
{
TCollection_AsciiString aStr;
if (!GetString(theParam, aStr, theScope))
@ -385,7 +354,7 @@ Standard_Boolean DE_ConfigurationContext::GetStringSeq(const TCollection_AsciiSt
}
theValue.Clear();
TCollection_AsciiString anElem;
const Standard_Integer aLength = aStr.Length();
const Standard_Integer aLength = aStr.Length();
for (Standard_Integer anInd = 1; anInd <= aLength; anInd++)
{
const Standard_Character aChar = aStr.Value(anInd);
@ -401,17 +370,15 @@ Standard_Boolean DE_ConfigurationContext::GetStringSeq(const TCollection_AsciiSt
return Standard_True;
}
//=======================================================================
//function : load
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_ConfigurationContext::load(const TCollection_AsciiString& theResourceLine)
{
if (theResourceLine.IsEmpty())
{
return Standard_False;
}
TCollection_AsciiString aToken1, aToken2;
TCollection_AsciiString aToken1, aToken2;
DE_ConfigurationContext_KindOfLine aKind = WhatKindOfLine(theResourceLine, aToken1, aToken2);
switch (aKind)
{

28
src/DE/DE_ConfigurationContext.hxx
View File

@ -20,7 +20,7 @@
typedef NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString> DE_ResourceMap;
//! Provides convenient interface to resource file
//! Allows loading of the resource file and getting attributes'
//! Allows loading of the resource file and getting attributes'
//! values starting from some scope, for example
//! if scope is defined as "ToV4" and requested parameter
//! is "exec.op", value of "ToV4.exec.op" parameter from
@ -64,7 +64,7 @@ public:
//! @param[in] theScope base parameter name
//! @return Standard_False if parameter is not defined or has a wrong type
Standard_EXPORT Standard_Boolean GetReal(const TCollection_AsciiString& theParam,
Standard_Real& theValue,
Standard_Real& theValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets value of parameter as being of specific type
@ -73,7 +73,7 @@ public:
//! @param[in] theScope base parameter name
//! @return Standard_False if parameter is not defined or has a wrong type
Standard_EXPORT Standard_Boolean GetInteger(const TCollection_AsciiString& theParam,
Standard_Integer& theValue,
Standard_Integer& theValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets value of parameter as being of specific type
@ -82,7 +82,7 @@ public:
//! @param[in] theScope base parameter name
//! @return Standard_False if parameter is not defined or has a wrong type
Standard_EXPORT Standard_Boolean GetBoolean(const TCollection_AsciiString& theParam,
Standard_Boolean& theValue,
Standard_Boolean& theValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets value of parameter as being of specific type
@ -91,7 +91,7 @@ public:
//! @param[in] theScope base parameter name
//! @return Standard_False if parameter is not defined or has a wrong type
Standard_EXPORT Standard_Boolean GetString(const TCollection_AsciiString& theParam,
TCollection_AsciiString& theValue,
TCollection_AsciiString& theValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets value of parameter as being of specific type
@ -100,7 +100,7 @@ public:
//! @param[in] theScope base parameter name
//! @return Standard_False if parameter is not defined or has a wrong type
Standard_EXPORT Standard_Boolean GetStringSeq(const TCollection_AsciiString& theParam,
TColStd_ListOfAsciiString& theValue,
TColStd_ListOfAsciiString& theValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets value of parameter as being of specific type
@ -109,7 +109,7 @@ public:
//! @param[in] theScope base parameter name
//! @return specific type value
Standard_EXPORT Standard_Real RealVal(const TCollection_AsciiString& theParam,
const Standard_Real theDefValue,
const Standard_Real theDefValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets value of parameter as being of specific type
@ -118,7 +118,7 @@ public:
//! @param[in] theScope base parameter name
//! @return specific type value
Standard_EXPORT Standard_Integer IntegerVal(const TCollection_AsciiString& theParam,
const Standard_Integer theDefValue,
const Standard_Integer theDefValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets value of parameter as being of specific type
@ -127,7 +127,7 @@ public:
//! @param[in] theScope base parameter name
//! @return specific type value
Standard_EXPORT Standard_Boolean BooleanVal(const TCollection_AsciiString& theParam,
const Standard_Boolean theDefValue,
const Standard_Boolean theDefValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets value of parameter as being of specific type
@ -135,25 +135,23 @@ public:
//! @param[in] theDefValue value by default if param is not found or has wrong type
//! @param[in] theScope base parameter name
//! @return specific type value
Standard_EXPORT TCollection_AsciiString StringVal(const TCollection_AsciiString& theParam,
const TCollection_AsciiString& theDefValue,
const TCollection_AsciiString& theScope = "") const;
Standard_EXPORT TCollection_AsciiString
StringVal(const TCollection_AsciiString& theParam,
const TCollection_AsciiString& theDefValue,
const TCollection_AsciiString& theScope = "") const;
//! Gets internal resource map
//! @return map with resource value
Standard_EXPORT const DE_ResourceMap& GetInternalMap() const { return myResource; }
protected:
//! Update the resource with param value from the line
//! @paramp[in] theResourceLine line contains the parameter
//! @return true if theResourceLine has loaded correctly
Standard_Boolean load(const TCollection_AsciiString& theResourceLine);
private:
DE_ResourceMap myResource; //!< Internal parameters map
};
#endif // _DE_ConfigurationContext_HeaderFile

74
src/DE/DE_ConfigurationNode.cxx
View File

@ -13,9 +13,9 @@
#include <DE_ConfigurationNode.hxx>
#include <DE_ConfigurationContext.hxx>
#include <DE_Provider.hxx>
#include <DE_Wrapper.hxx>
#include <DE_ConfigurationContext.hxx>
#include <Message.hxx>
#include <OSD_File.hxx>
#include <OSD_Path.hxx>
@ -23,28 +23,23 @@
IMPLEMENT_STANDARD_RTTIEXT(DE_ConfigurationNode, Standard_Transient)
//=======================================================================
// function : DE_ConfigurationNode
// purpose :
//=======================================================================
DE_ConfigurationNode::DE_ConfigurationNode() :
myIsEnabled(Standard_True)
{}
//=================================================================================================
DE_ConfigurationNode::DE_ConfigurationNode()
: myIsEnabled(Standard_True)
{
}
//=================================================================================================
//=======================================================================
// function : DE_ConfigurationNode
// purpose :
//=======================================================================
DE_ConfigurationNode::DE_ConfigurationNode(const Handle(DE_ConfigurationNode)& theConfigurationNode)
{
GlobalParameters = theConfigurationNode->GlobalParameters;
myIsEnabled = theConfigurationNode->IsEnabled();
myIsEnabled = theConfigurationNode->IsEnabled();
}
//=======================================================================
// function : Load
// purpose :
//=======================================================================
//=================================================================================================
bool DE_ConfigurationNode::Load(const TCollection_AsciiString& theResourcePath)
{
Handle(DE_ConfigurationContext) aResource = new DE_ConfigurationContext();
@ -52,20 +47,18 @@ bool DE_ConfigurationNode::Load(const TCollection_AsciiString& theResourcePath)
return Load(aResource);
}
//=======================================================================
// function : Save
// purpose :
//=======================================================================
//=================================================================================================
bool DE_ConfigurationNode::Save(const TCollection_AsciiString& theResourcePath) const
{
OSD_Path aPath = theResourcePath;
OSD_File aFile(aPath);
OSD_Path aPath = theResourcePath;
OSD_File aFile(aPath);
OSD_Protection aProt;
{
try
{
OCC_CATCH_SIGNALS
aFile.Build(OSD_ReadWrite, aProt);
aFile.Build(OSD_ReadWrite, aProt);
}
catch (Standard_Failure const&)
{
@ -84,10 +77,8 @@ bool DE_ConfigurationNode::Save(const TCollection_AsciiString& theResourcePath)
return true;
}
//=======================================================================
// function : UpdateLoad
// purpose :
//=======================================================================
//=================================================================================================
bool DE_ConfigurationNode::UpdateLoad(const Standard_Boolean theToImport,
const Standard_Boolean theToKeep)
{
@ -96,28 +87,22 @@ bool DE_ConfigurationNode::UpdateLoad(const Standard_Boolean theToImport,
return true;
}
//=======================================================================
// function : IsImportSupported
// purpose :
//=======================================================================
//=================================================================================================
bool DE_ConfigurationNode::IsImportSupported() const
{
return false;
}
//=======================================================================
// function : IsExportSupported
// purpose :
//=======================================================================
//=================================================================================================
bool DE_ConfigurationNode::IsExportSupported() const
{
return false;
}
//=======================================================================
// function : CheckForSupport
// purpose :
//=======================================================================
//=================================================================================================
bool DE_ConfigurationNode::CheckExtension(const TCollection_AsciiString& theExtension) const
{
TCollection_AsciiString anExtension(theExtension);
@ -130,8 +115,7 @@ bool DE_ConfigurationNode::CheckExtension(const TCollection_AsciiString& theExte
anExtension.Remove(1);
}
const TColStd_ListOfAsciiString& anExtensions = GetExtensions();
for (TColStd_ListOfAsciiString::Iterator anIter(anExtensions);
anIter.More(); anIter.Next())
for (TColStd_ListOfAsciiString::Iterator anIter(anExtensions); anIter.More(); anIter.Next())
{
if (TCollection_AsciiString::IsSameString(anIter.Value(), anExtension, Standard_False))
{
@ -141,10 +125,8 @@ bool DE_ConfigurationNode::CheckExtension(const TCollection_AsciiString& theExte
return false;
}
//=======================================================================
// function : CheckForSupport
// purpose :
//=======================================================================
//=================================================================================================
bool DE_ConfigurationNode::CheckContent(const Handle(NCollection_Buffer)& theBuffer) const
{
(void)theBuffer;

25
src/DE/DE_ConfigurationNode.hxx
View File

@ -50,7 +50,6 @@ class DE_ConfigurationNode : public Standard_Transient
{
DEFINE_STANDARD_RTTIEXT(DE_ConfigurationNode, Standard_Transient)
public:
//! Initializes all field by default
Standard_EXPORT DE_ConfigurationNode();
@ -93,7 +92,6 @@ public:
const Standard_Boolean theToKeep);
public:
//! Checks the import supporting
//! @return Standard_True if import is support
Standard_EXPORT virtual bool IsImportSupported() const;
@ -125,20 +123,13 @@ public:
Standard_EXPORT virtual bool CheckContent(const Handle(NCollection_Buffer)& theBuffer) const;
public:
//! Gets the provider loading status
//! @return Standard_True if the load is correct
Standard_Boolean IsEnabled() const
{
return myIsEnabled;
}
Standard_Boolean IsEnabled() const { return myIsEnabled; }
//! Sets the provider loading status
//! @param[in] theIsLoaded input load status
void SetEnabled(const Standard_Boolean theIsLoaded)
{
myIsEnabled = theIsLoaded;
}
void SetEnabled(const Standard_Boolean theIsLoaded) { myIsEnabled = theIsLoaded; }
//! Custom function to activate commercial DE component.
//! The input is special sequence of values that described in
@ -150,18 +141,18 @@ public:
Standard_EXPORT virtual void CustomActivation(const TColStd_ListOfAsciiString&) {};
public:
//!< Internal parameters for transfer process
struct DE_SectionGlobal
{
Standard_Real LengthUnit = 1.0; //!< Target Unit (scaling based on MM) for the transfer process, default 1.0 (MM)
Standard_Real SystemUnit = 1.0; //!< System Unit (scaling based on MM) to be used when initial unit is unknown, default 1.0 (MM)
Standard_Real LengthUnit =
1.0; //!< Target Unit (scaling based on MM) for the transfer process, default 1.0 (MM)
Standard_Real SystemUnit = 1.0; //!< System Unit (scaling based on MM) to be used when initial
//!< unit is unknown, default 1.0 (MM)
} GlobalParameters;
private:
Standard_Boolean myIsEnabled; //!< Flag to use a current provider for Read or Write process via DE_Wrapper
Standard_Boolean
myIsEnabled; //!< Flag to use a current provider for Read or Write process via DE_Wrapper
};
#endif // _DE_ConfigurationNode_HeaderFile

136
src/DE/DE_Provider.cxx
View File

@ -18,153 +18,133 @@
IMPLEMENT_STANDARD_RTTIEXT(DE_Provider, Standard_Transient)
//=======================================================================
// function : DE_Provider
// purpose :
//=======================================================================
DE_Provider::DE_Provider()
{}
//=================================================================================================
DE_Provider::DE_Provider() {}
//=================================================================================================
//=======================================================================
// function : DE_Provider
// purpose :
//=======================================================================
DE_Provider::DE_Provider(const Handle(DE_ConfigurationNode)& theNode)
:myNode(theNode)
{}
: myNode(theNode)
{
}
//=======================================================================
// function : Read
// purpose :
//=======================================================================
Standard_Boolean DE_Provider::Read(const TCollection_AsciiString& thePath,
//=================================================================================================
Standard_Boolean DE_Provider::Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
{
(void)thePath;
(void)theDocument;
(void)theWS;
(void)theProgress;
Message::SendFail() << "Error: provider " << GetFormat() <<
" " << GetVendor() <<" doesn't support read operation";
Message::SendFail() << "Error: provider " << GetFormat() << " " << GetVendor()
<< " doesn't support read operation";
return Standard_False;
}
//=======================================================================
// function : Write
// purpose :
//=======================================================================
Standard_Boolean DE_Provider::Write(const TCollection_AsciiString& thePath,
//=================================================================================================
Standard_Boolean DE_Provider::Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
{
(void)thePath;
(void)theDocument;
(void)theWS;
(void)theProgress;
Message::SendFail() << "Error: provider " << GetFormat() <<
" " << GetVendor() << " doesn't support write operation";
Message::SendFail() << "Error: provider " << GetFormat() << " " << GetVendor()
<< " doesn't support write operation";
return Standard_False;
}
//=======================================================================
// function : Read
// purpose :
//=======================================================================
Standard_Boolean DE_Provider::Read(const TCollection_AsciiString& thePath,
//=================================================================================================
Standard_Boolean DE_Provider::Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress)
const Message_ProgressRange& theProgress)
{
(void)thePath;
(void)theDocument;
(void)theProgress;
Message::SendFail() << "Error: provider " << GetFormat() <<
" " << GetVendor() << " doesn't support read operation";
Message::SendFail() << "Error: provider " << GetFormat() << " " << GetVendor()
<< " doesn't support read operation";
return Standard_False;
}
//=======================================================================
// function : Write
// purpose :
//=======================================================================
Standard_Boolean DE_Provider::Write(const TCollection_AsciiString& thePath,
//=================================================================================================
Standard_Boolean DE_Provider::Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress)
const Message_ProgressRange& theProgress)
{
(void)thePath;
(void)theDocument;
(void)theProgress;
Message::SendFail() << "Error: provider " << GetFormat() <<
" " << GetVendor() << " doesn't support write operation";
Message::SendFail() << "Error: provider " << GetFormat() << " " << GetVendor()
<< " doesn't support write operation";
return Standard_False;
}
//=======================================================================
// function : Read
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Provider::Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
const Message_ProgressRange& theProgress)
{
(void)thePath;
(void)theShape;
(void)theWS;
(void)theProgress;
Message::SendFail() << "Error: provider " << GetFormat() <<
" " << GetVendor() << " doesn't support read operation";
Message::SendFail() << "Error: provider " << GetFormat() << " " << GetVendor()
<< " doesn't support read operation";
return Standard_False;
}
//=======================================================================
// function : Write
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Provider::Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
const TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
const Message_ProgressRange& theProgress)
{
(void)thePath;
(void)theShape;
(void)theWS;
(void)theProgress;
Message::SendFail() << "Error: provider " << GetFormat() <<
" " << GetVendor() << " doesn't support write operation";
Message::SendFail() << "Error: provider " << GetFormat() << " " << GetVendor()
<< " doesn't support write operation";
return Standard_False;
}
//=======================================================================
// function : Read
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Provider::Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
{
(void)thePath;
(void)theShape;
(void)theProgress;
Message::SendFail() << "Error: provider " << GetFormat() <<
" " << GetVendor() << " doesn't support read operation";
Message::SendFail() << "Error: provider " << GetFormat() << " " << GetVendor()
<< " doesn't support read operation";
return Standard_False;
}
//=======================================================================
// function : Write
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Provider::Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
{
(void)thePath;
(void)theShape;
(void)theProgress;
Message::SendFail() << "Error: provider " << GetFormat() <<
" " << GetVendor() << " doesn't support write operation";
Message::SendFail() << "Error: provider " << GetFormat() << " " << GetVendor()
<< " doesn't support write operation";
return Standard_False;
}

78
src/DE/DE_Provider.hxx
View File

@ -44,7 +44,6 @@ public:
DEFINE_STANDARD_RTTIEXT(DE_Provider, Standard_Transient)
public:
//! Default constructor
//! Configure translation process with global configuration
Standard_EXPORT DE_Provider();
@ -54,17 +53,17 @@ public:
Standard_EXPORT DE_Provider(const Handle(DE_ConfigurationNode)& theNode);
public:
//! Reads a CAD file, according internal configuration
//! @param[in] thePath path to the import CAD file
//! @param[out] theDocument document to save result
//! @param[in] theWS current work session
//! @param[in] theProgress progress indicator
//! @return True if Read was successful
Standard_EXPORT virtual Standard_Boolean Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean Read(
const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a CAD file, according internal configuration
//! @param[in] thePath path to the export CAD file
@ -72,28 +71,31 @@ public:
//! @param[in] theWS current work session
//! @param[in] theProgress progress indicator
//! @return True if Write was successful
Standard_EXPORT virtual Standard_Boolean Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean Write(
const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads a CAD file, according internal configuration
//! @param[in] thePath path to the import CAD file
//! @param[out] theDocument document to save result
//! @param[in] theProgress progress indicator
//! @return True if Read was successful
Standard_EXPORT virtual Standard_Boolean Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean Read(
const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a CAD file, according internal configuration
//! @param[in] thePath path to the export CAD file
//! @param[out] theDocument document to export
//! @param[in] theProgress progress indicator
//! @return True if Write was successful
Standard_EXPORT virtual Standard_Boolean Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean Write(
const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads a CAD file, according internal configuration
//! @param[in] thePath path to the import CAD file
@ -101,10 +103,11 @@ public:
//! @param[in] theWS current work session
//! @param[in] theProgress progress indicator
//! @return True if Read was successful
Standard_EXPORT virtual Standard_Boolean Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean Read(
const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a CAD file, according internal configuration
//! @param[in] thePath path to the export CAD file
@ -112,31 +115,33 @@ public:
//! @param[in] theWS current work session
//! @param[in] theProgress progress indicator
//! @return True if Write was successful
Standard_EXPORT virtual Standard_Boolean Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean Write(
const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads a CAD file, according internal configuration
//! @param[in] thePath path to the import CAD file
//! @param[out] theShape shape to save result
//! @param[in] theProgress progress indicator
//! @return True if Read was successful
Standard_EXPORT virtual Standard_Boolean Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean Read(
const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a CAD file, according internal configuration
//! @param[in] thePath path to the export CAD file
//! @param[out] theShape shape to export
//! @param[in] theProgress progress indicator
//! @return True if Write was successful
Standard_EXPORT virtual Standard_Boolean Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean Write(
const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress = Message_ProgressRange());
public:
//! Gets CAD format name of associated provider
//! @return provider CAD format
Standard_EXPORT virtual TCollection_AsciiString GetFormat() const = 0;
@ -147,20 +152,13 @@ public:
//! Gets internal configuration node
//! @return configuration node object
Handle(DE_ConfigurationNode) GetNode() const
{
return myNode;
}
Handle(DE_ConfigurationNode) GetNode() const { return myNode; }
//! Sets internal configuration node
//! @param[in] theNode configuration node to set
void SetNode(const Handle(DE_ConfigurationNode)& theNode)
{
myNode = theNode;
}
void SetNode(const Handle(DE_ConfigurationNode)& theNode) { myNode = theNode; }
private:
Handle(DE_ConfigurationNode) myNode; //!< Internal configuration for the own format
};

592
src/DE/DE_ShapeFixConfigurationNode.cxx
View File

@ -21,151 +21,260 @@ IMPLEMENT_STANDARD_RTTIEXT(DE_ShapeFixConfigurationNode, DE_ConfigurationNode)
namespace
{
static const TCollection_AsciiString& THE_CONFIGURATION_SCOPE()
{
static const TCollection_AsciiString aScope = "provider";
return aScope;
}
static const TCollection_AsciiString& THE_CONFIGURATION_SCOPE()
{
static const TCollection_AsciiString aScope = "provider";
return aScope;
}
} // namespace
//=================================================================================================
//=======================================================================
// function : DE_ShapeFixConfigurationNode
// purpose :
//=======================================================================
DE_ShapeFixConfigurationNode::DE_ShapeFixConfigurationNode()
: DE_ConfigurationNode()
{}
//=======================================================================
// function : DE_ShapeFixConfigurationNode
// purpose :
//=======================================================================
DE_ShapeFixConfigurationNode::DE_ShapeFixConfigurationNode(const Handle(DE_ShapeFixConfigurationNode)& theNode)
: DE_ConfigurationNode(theNode)
: DE_ConfigurationNode()
{
}
//=======================================================================
// function : Load
// purpose :
//=======================================================================
//=================================================================================================
DE_ShapeFixConfigurationNode::DE_ShapeFixConfigurationNode(
const Handle(DE_ShapeFixConfigurationNode)& theNode)
: DE_ConfigurationNode(theNode)
{
}
//=================================================================================================
bool DE_ShapeFixConfigurationNode::Load(const Handle(DE_ConfigurationContext)& theResource)
{
TCollection_AsciiString aScope = THE_CONFIGURATION_SCOPE() + "." + GetFormat() + "." + GetVendor() + ".healing";
TCollection_AsciiString aScope =
THE_CONFIGURATION_SCOPE() + "." + GetFormat() + "." + GetVendor() + ".healing";
HealingParameters.Tolerance3d = theResource->RealVal("tolerance3d", HealingParameters.Tolerance3d, aScope);
HealingParameters.MaxTolerance3d = theResource->RealVal("max.tolerance3d", HealingParameters.MaxTolerance3d, aScope);
HealingParameters.MinTolerance3d = theResource->RealVal("min.tolerance3d", HealingParameters.MinTolerance3d, aScope);
HealingParameters.FixFreeShellMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("free.shell", (int)HealingParameters.FixFreeShellMode, aScope);
HealingParameters.FixFreeFaceMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("free.face", (int)HealingParameters.FixFreeFaceMode, aScope);
HealingParameters.FixFreeWireMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("free.wire", (int)HealingParameters.FixFreeWireMode, aScope);
HealingParameters.FixSameParameterMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("same.parameter", (int)HealingParameters.FixSameParameterMode, aScope);
HealingParameters.FixSolidMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("solid", (int)HealingParameters.FixSolidMode, aScope);
HealingParameters.FixShellOrientationMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("shell.orientation", (int)HealingParameters.FixShellOrientationMode, aScope);
HealingParameters.CreateOpenSolidMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("create.open.solid", (int)HealingParameters.CreateOpenSolidMode, aScope);
HealingParameters.FixShellMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("shell", (int)HealingParameters.FixShellMode, aScope);
HealingParameters.FixFaceOrientationMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("face.orientation", (int)HealingParameters.FixFaceOrientationMode, aScope);
HealingParameters.FixFaceMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("face", (int)HealingParameters.FixFaceMode, aScope);
HealingParameters.FixWireMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("wire", (int)HealingParameters.FixWireMode, aScope);
HealingParameters.FixOrientationMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("orientation", (int)HealingParameters.FixOrientationMode, aScope);
HealingParameters.FixAddNaturalBoundMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("add.natural.bound", (int)HealingParameters.FixAddNaturalBoundMode, aScope);
HealingParameters.FixMissingSeamMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("missing.seam", (int)HealingParameters.FixMissingSeamMode, aScope);
HealingParameters.FixSmallAreaWireMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("small.area.wire", (int)HealingParameters.FixSmallAreaWireMode, aScope);
HealingParameters.RemoveSmallAreaFaceMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("remove.small.area.face", (int)HealingParameters.RemoveSmallAreaFaceMode, aScope);
HealingParameters.FixIntersectingWiresMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("intersecting.wires", (int)HealingParameters.FixIntersectingWiresMode, aScope);
HealingParameters.FixLoopWiresMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("loop.wires", (int)HealingParameters.FixLoopWiresMode, aScope);
HealingParameters.FixSplitFaceMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("split.face", (int)HealingParameters.FixSplitFaceMode, aScope);
HealingParameters.AutoCorrectPrecisionMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("auto.correct.precision", (int)HealingParameters.AutoCorrectPrecisionMode, aScope);
HealingParameters.ModifyTopologyMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("modify.topology", (int)HealingParameters.ModifyTopologyMode, aScope);
HealingParameters.ModifyGeometryMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("modify.geometry", (int)HealingParameters.ModifyGeometryMode, aScope);
HealingParameters.ClosedWireMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("closed.wire", (int)HealingParameters.ClosedWireMode, aScope);
HealingParameters.PreferencePCurveMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("preference.pcurve", (int)HealingParameters.PreferencePCurveMode, aScope);
HealingParameters.FixReorderMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("reorder.edges", (int)HealingParameters.FixReorderMode, aScope);
HealingParameters.FixSmallMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("remove.small.edges", (int)HealingParameters.FixSmallMode, aScope);
HealingParameters.FixConnectedMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("connected.edges", (int)HealingParameters.FixConnectedMode, aScope);
HealingParameters.FixEdgeCurvesMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("edge.curves", (int)HealingParameters.FixEdgeCurvesMode, aScope);
HealingParameters.FixDegeneratedMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("add.degenerated.edges", (int)HealingParameters.FixDegeneratedMode, aScope);
HealingParameters.FixLackingMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("add.lacking.edges", (int)HealingParameters.FixLackingMode, aScope);
HealingParameters.FixSelfIntersectionMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("selfintersection", (int)HealingParameters.FixSelfIntersectionMode, aScope);
HealingParameters.RemoveLoopMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("remove.loop", (int)HealingParameters.RemoveLoopMode, aScope);
HealingParameters.FixReversed2dMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("reversed2d", (int)HealingParameters.FixReversed2dMode, aScope);
HealingParameters.FixRemovePCurveMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("remove.pcurve", (int)HealingParameters.FixRemovePCurveMode, aScope);
HealingParameters.FixRemoveCurve3dMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("remove.curve3d", (int)HealingParameters.FixRemoveCurve3dMode, aScope);
HealingParameters.FixAddPCurveMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("add.pcurve", (int)HealingParameters.FixAddPCurveMode, aScope);
HealingParameters.FixAddCurve3dMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("add.curve3d", (int)HealingParameters.FixAddCurve3dMode, aScope);
HealingParameters.FixSeamMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("correct.order.in.seam", (int)HealingParameters.FixSeamMode, aScope);
HealingParameters.FixShiftedMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("shifted", (int)HealingParameters.FixShiftedMode, aScope);
HealingParameters.FixEdgeSameParameterMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("edge.same.parameter", (int)HealingParameters.FixEdgeSameParameterMode, aScope);
HealingParameters.FixNotchedEdgesMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("notched.edges", (int)HealingParameters.FixNotchedEdgesMode, aScope);
HealingParameters.FixTailMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("tail", (int)HealingParameters.FixTailMode, aScope);
HealingParameters.MaxTailAngle = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("max.tail.angle", (int)HealingParameters.MaxTailAngle, aScope);
HealingParameters.MaxTailWidth = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("max.tail.width", (int)HealingParameters.MaxTailWidth, aScope);
HealingParameters.FixSelfIntersectingEdgeMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("selfintersecting.edge", (int)HealingParameters.FixSelfIntersectingEdgeMode, aScope);
HealingParameters.FixIntersectingEdgesMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("intersecting.edges", (int)HealingParameters.FixIntersectingEdgesMode, aScope);
HealingParameters.FixNonAdjacentIntersectingEdgesMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("nonadjacent.intersecting.edges", (int)HealingParameters.FixNonAdjacentIntersectingEdgesMode, aScope);
HealingParameters.FixVertexPositionMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("vertex.position", (int)HealingParameters.FixVertexPositionMode, aScope);
HealingParameters.FixVertexToleranceMode = (DE_ShapeFixParameters::FixMode)
theResource->IntegerVal("vertex.tolerance", (int)HealingParameters.FixVertexToleranceMode, aScope);
HealingParameters.Tolerance3d =
theResource->RealVal("tolerance3d", HealingParameters.Tolerance3d, aScope);
HealingParameters.MaxTolerance3d =
theResource->RealVal("max.tolerance3d", HealingParameters.MaxTolerance3d, aScope);
HealingParameters.MinTolerance3d =
theResource->RealVal("min.tolerance3d", HealingParameters.MinTolerance3d, aScope);
HealingParameters.FixFreeShellMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("free.shell",
(int)HealingParameters.FixFreeShellMode,
aScope);
HealingParameters.FixFreeFaceMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("free.face",
(int)HealingParameters.FixFreeFaceMode,
aScope);
HealingParameters.FixFreeWireMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("free.wire",
(int)HealingParameters.FixFreeWireMode,
aScope);
HealingParameters.FixSameParameterMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"same.parameter",
(int)HealingParameters.FixSameParameterMode,
aScope);
HealingParameters.FixSolidMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("solid",
(int)HealingParameters.FixSolidMode,
aScope);
HealingParameters.FixShellOrientationMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"shell.orientation",
(int)HealingParameters.FixShellOrientationMode,
aScope);
HealingParameters.CreateOpenSolidMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"create.open.solid",
(int)HealingParameters.CreateOpenSolidMode,
aScope);
HealingParameters.FixShellMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("shell",
(int)HealingParameters.FixShellMode,
aScope);
HealingParameters.FixFaceOrientationMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"face.orientation",
(int)HealingParameters.FixFaceOrientationMode,
aScope);
HealingParameters.FixFaceMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("face",
(int)HealingParameters.FixFaceMode,
aScope);
HealingParameters.FixWireMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("wire",
(int)HealingParameters.FixWireMode,
aScope);
HealingParameters.FixOrientationMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"orientation",
(int)HealingParameters.FixOrientationMode,
aScope);
HealingParameters.FixAddNaturalBoundMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"add.natural.bound",
(int)HealingParameters.FixAddNaturalBoundMode,
aScope);
HealingParameters.FixMissingSeamMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"missing.seam",
(int)HealingParameters.FixMissingSeamMode,
aScope);
HealingParameters.FixSmallAreaWireMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"small.area.wire",
(int)HealingParameters.FixSmallAreaWireMode,
aScope);
HealingParameters.RemoveSmallAreaFaceMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"remove.small.area.face",
(int)HealingParameters.RemoveSmallAreaFaceMode,
aScope);
HealingParameters.FixIntersectingWiresMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"intersecting.wires",
(int)HealingParameters.FixIntersectingWiresMode,
aScope);
HealingParameters.FixLoopWiresMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("loop.wires",
(int)HealingParameters.FixLoopWiresMode,
aScope);
HealingParameters.FixSplitFaceMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("split.face",
(int)HealingParameters.FixSplitFaceMode,
aScope);
HealingParameters.AutoCorrectPrecisionMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"auto.correct.precision",
(int)HealingParameters.AutoCorrectPrecisionMode,
aScope);
HealingParameters.ModifyTopologyMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"modify.topology",
(int)HealingParameters.ModifyTopologyMode,
aScope);
HealingParameters.ModifyGeometryMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"modify.geometry",
(int)HealingParameters.ModifyGeometryMode,
aScope);
HealingParameters.ClosedWireMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("closed.wire",
(int)HealingParameters.ClosedWireMode,
aScope);
HealingParameters.PreferencePCurveMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"preference.pcurve",
(int)HealingParameters.PreferencePCurveMode,
aScope);
HealingParameters.FixReorderMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("reorder.edges",
(int)HealingParameters.FixReorderMode,
aScope);
HealingParameters.FixSmallMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("remove.small.edges",
(int)HealingParameters.FixSmallMode,
aScope);
HealingParameters.FixConnectedMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("connected.edges",
(int)HealingParameters.FixConnectedMode,
aScope);
HealingParameters.FixEdgeCurvesMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"edge.curves",
(int)HealingParameters.FixEdgeCurvesMode,
aScope);
HealingParameters.FixDegeneratedMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"add.degenerated.edges",
(int)HealingParameters.FixDegeneratedMode,
aScope);
HealingParameters.FixLackingMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("add.lacking.edges",
(int)HealingParameters.FixLackingMode,
aScope);
HealingParameters.FixSelfIntersectionMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"selfintersection",
(int)HealingParameters.FixSelfIntersectionMode,
aScope);
HealingParameters.RemoveLoopMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("remove.loop",
(int)HealingParameters.RemoveLoopMode,
aScope);
HealingParameters.FixReversed2dMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"reversed2d",
(int)HealingParameters.FixReversed2dMode,
aScope);
HealingParameters.FixRemovePCurveMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"remove.pcurve",
(int)HealingParameters.FixRemovePCurveMode,
aScope);
HealingParameters.FixRemoveCurve3dMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"remove.curve3d",
(int)HealingParameters.FixRemoveCurve3dMode,
aScope);
HealingParameters.FixAddPCurveMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("add.pcurve",
(int)HealingParameters.FixAddPCurveMode,
aScope);
HealingParameters.FixAddCurve3dMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"add.curve3d",
(int)HealingParameters.FixAddCurve3dMode,
aScope);
HealingParameters.FixSeamMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("correct.order.in.seam",
(int)HealingParameters.FixSeamMode,
aScope);
HealingParameters.FixShiftedMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("shifted",
(int)HealingParameters.FixShiftedMode,
aScope);
HealingParameters.FixEdgeSameParameterMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"edge.same.parameter",
(int)HealingParameters.FixEdgeSameParameterMode,
aScope);
HealingParameters.FixNotchedEdgesMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"notched.edges",
(int)HealingParameters.FixNotchedEdgesMode,
aScope);
HealingParameters.FixTailMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("tail",
(int)HealingParameters.FixTailMode,
aScope);
HealingParameters.MaxTailAngle =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("max.tail.angle",
(int)HealingParameters.MaxTailAngle,
aScope);
HealingParameters.MaxTailWidth =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal("max.tail.width",
(int)HealingParameters.MaxTailWidth,
aScope);
HealingParameters.FixSelfIntersectingEdgeMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"selfintersecting.edge",
(int)HealingParameters.FixSelfIntersectingEdgeMode,
aScope);
HealingParameters.FixIntersectingEdgesMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"intersecting.edges",
(int)HealingParameters.FixIntersectingEdgesMode,
aScope);
HealingParameters.FixNonAdjacentIntersectingEdgesMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"nonadjacent.intersecting.edges",
(int)HealingParameters.FixNonAdjacentIntersectingEdgesMode,
aScope);
HealingParameters.FixVertexPositionMode = (DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"vertex.position",
(int)HealingParameters.FixVertexPositionMode,
aScope);
HealingParameters.FixVertexToleranceMode =
(DE_ShapeFixParameters::FixMode)theResource->IntegerVal(
"vertex.tolerance",
(int)HealingParameters.FixVertexToleranceMode,
aScope);
return true;
}
//=======================================================================
// function : Save
// purpose :
//=======================================================================
//=================================================================================================
TCollection_AsciiString DE_ShapeFixConfigurationNode::Save() const
{
TCollection_AsciiString aResult;
TCollection_AsciiString aScope = THE_CONFIGURATION_SCOPE() + "." + GetFormat() + "." + GetVendor() + ".healing";
TCollection_AsciiString aScope =
THE_CONFIGURATION_SCOPE() + "." + GetFormat() + "." + GetVendor() + ".healing";
aResult += "!\n";
aResult += "!Shape healing parameters:\n";
@ -191,301 +300,376 @@ TCollection_AsciiString DE_ShapeFixConfigurationNode::Save() const
aResult += "!\n";
aResult += "!Defines the mode for applying fixes of ShapeFix_Shell for ShapeFix_Shape\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "free.shell :\t " + (int)HealingParameters.FixFreeShellMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying fixes of ShapeFix_Face for ShapeFix_Shape\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "free.face :\t " + (int)HealingParameters.FixFreeFaceMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying fixes of ShapeFix_Wire for ShapeFix_Shape\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "free.wire :\t " + (int)HealingParameters.FixFreeWireMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying ShapeFix::SameParameter after all fixes\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "same.parameter :\t " + (int)HealingParameters.FixSameParameterMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying fixes of ShapeFix_Solid\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "solid :\t " + (int)HealingParameters.FixSolidMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying analysis and fixes of orientation of shells in the solid\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "shell.orientation :\t " + (int)HealingParameters.FixShellOrientationMode + "\n";
aResult +=
"!Defines the mode for applying analysis and fixes of orientation of shells in the solid\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "shell.orientation :\t " + (int)HealingParameters.FixShellOrientationMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for creation of solids. If operation is executed then solids are created from open shells ";
aResult += "!Defines the mode for creation of solids. If operation is executed then solids are "
"created from open shells ";
aResult += "else solids are created from closed shells only\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "create.open.solid :\t " + (int)HealingParameters.CreateOpenSolidMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying fixes of ShapeFix_Shell for ShapeFix_Solid\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "shell :\t " + (int)HealingParameters.FixShellMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying analysis and fixes of orientation of faces in the shell\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "face.orientation :\t " + (int)HealingParameters.FixFaceOrientationMode + "\n";
aResult +=
"!Defines the mode for applying analysis and fixes of orientation of faces in the shell\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "face.orientation :\t " + (int)HealingParameters.FixFaceOrientationMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying fixes of ShapeFix_Face\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "face :\t " + (int)HealingParameters.FixFaceMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying fixes of ShapeFix_Wire\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "wire :\t " + (int)HealingParameters.FixWireMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying a fix for the orientation of faces in the shell\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "orientation :\t " + (int)HealingParameters.FixOrientationMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the add natural bound mode. If operation is executed then natural boundary is added on faces that miss them\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "add.natural.bound :\t " + (int)HealingParameters.FixAddNaturalBoundMode + "\n";
aResult += "!Defines the add natural bound mode. If operation is executed then natural boundary "
"is added on faces that miss them\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "add.natural.bound :\t " + (int)HealingParameters.FixAddNaturalBoundMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the fix missing seam mode (tries to insert seam is missed)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "missing.seam :\t " + (int)HealingParameters.FixMissingSeamMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the fix small area wire mode (drops small wires)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "small.area.wire :\t " + (int)HealingParameters.FixSmallAreaWireMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the remove face with small area (drops faces with small outer wires)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "remove.small.area.face :\t " + (int)HealingParameters.RemoveSmallAreaFaceMode + "\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "remove.small.area.face :\t " + (int)HealingParameters.RemoveSmallAreaFaceMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the fix intersecting wires mode in ShapeFix_Face\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "intersecting.wires :\t " + (int)HealingParameters.FixIntersectingWiresMode + "\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "intersecting.wires :\t " + (int)HealingParameters.FixIntersectingWiresMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the fix loop wires mode in ShapeFix_Face\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "loop.wires :\t " + (int)HealingParameters.FixLoopWiresMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the fix split face mode in ShapeFix_Face\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "split.face :\t " + (int)HealingParameters.FixSplitFaceMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the auto-correct precision mode in ShapeFix_Face\n";
aResult += "!Default value: \"Fix\"(1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "auto.correct.precision :\t " + (int)HealingParameters.AutoCorrectPrecisionMode + "\n";
aResult +=
"!Default value: \"Fix\"(1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult +=
aScope + "auto.correct.precision :\t " + (int)HealingParameters.AutoCorrectPrecisionMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to modify topology of the wire during fixing (adding/removing edges etc.)\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Defines the mode allowed to modify topology of the wire during fixing "
"(adding/removing edges etc.)\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "modify.topology :\t " + (int)HealingParameters.ModifyTopologyMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to modify geometry of the edges and vertices\n";
aResult += "!Default value: \"Fix\"(1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult +=
"!Default value: \"Fix\"(1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "modify.geometry :\t " + (int)HealingParameters.ModifyGeometryMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to defines whether the wire is to be closed (by calling methods like FixDegenerated() ";
aResult += "!Defines the mode allowed to defines whether the wire is to be closed (by calling "
"methods like FixDegenerated() ";
aResult += "!and FixConnected() for lastand first edges\n";
aResult += "!Default value: \"Fix\"(1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult +=
"!Default value: \"Fix\"(1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "closed.wire :\t " + (int)HealingParameters.ClosedWireMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to defines the 2d representation of the wire is preferable over 3d one ";
aResult += "!Defines the mode allowed to defines the 2d representation of the wire is preferable "
"over 3d one ";
aResult += "(in the case of ambiguity in FixEdgeCurves)\n";
aResult += "!and FixConnected() for lastand first edges\n";
aResult += "!Default value: \"Fix\"(1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult +=
"!Default value: \"Fix\"(1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "preference.pcurve :\t " + (int)HealingParameters.PreferencePCurveMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to reorder edges in the wire\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "reorder.edges :\t " + (int)HealingParameters.FixReorderMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to remove small edges\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "remove.small.edges :\t " + (int)HealingParameters.FixSmallMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for fix connecting edges in the wire\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "connected.edges :\t " + (int)HealingParameters.FixConnectedMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for fix edges (3Dcurves and 2D curves)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "edge.curves :\t " + (int)HealingParameters.FixEdgeCurvesMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for add degenerated edges\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "add.degenerated.edges :\t " + (int)HealingParameters.FixDegeneratedMode + "\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "add.degenerated.edges :\t " + (int)HealingParameters.FixDegeneratedMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for add lacking edges\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "add.lacking.edges :\t " + (int)HealingParameters.FixLackingMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for fix selfintersection edges\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "selfintersection :\t " + (int)HealingParameters.FixSelfIntersectionMode + "\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "selfintersection :\t " + (int)HealingParameters.FixSelfIntersectionMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to remove loop\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "remove.loop :\t " + (int)HealingParameters.RemoveLoopMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to fix edge if pcurve is directed opposite to 3d curve\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "reversed2d :\t " + (int)HealingParameters.FixReversed2dMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to remove the pcurve(s) of the edge if it does not match the vertices\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Defines the mode allowed to remove the pcurve(s) of the edge if it does not match "
"the vertices\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "remove.pcurve :\t " + (int)HealingParameters.FixRemovePCurveMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to remove 3d curve of the edge if it does not match the vertices\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult +=
"!Defines the mode allowed to remove 3d curve of the edge if it does not match the vertices\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "remove.curve3d :\t " + (int)HealingParameters.FixRemoveCurve3dMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to add pcurve(s) of the edge if missing (by projecting 3d curve)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult +=
"!Defines the mode allowed to add pcurve(s) of the edge if missing (by projecting 3d curve)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "add.pcurve :\t " + (int)HealingParameters.FixAddPCurveMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to build 3d curve of the edge if missing\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "add.curve3d :\t " + (int)HealingParameters.FixAddCurve3dMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to correct order of pcurves in the seam edge depends on its orientation\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Defines the mode allowed to correct order of pcurves in the seam edge depends on "
"its orientation\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "correct.order.in.seam :\t " + (int)HealingParameters.FixSeamMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode allowed to shifts wrong 2D curves back, ensuring that the 2D curves of the edges in the wire are connected\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Defines the mode allowed to shifts wrong 2D curves back, ensuring that the 2D "
"curves of the edges in the wire are connected\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "shifted :\t " + (int)HealingParameters.FixShiftedMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying EdgeSameParameter\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "edge.same.parameter :\t " + (int)HealingParameters.FixEdgeSameParameterMode + "\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "edge.same.parameter :\t " + (int)HealingParameters.FixEdgeSameParameterMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for fix notched edges\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "notched.edges :\t " + (int)HealingParameters.FixNotchedEdgesMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for fix tail in wire\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "tail :\t " + (int)HealingParameters.FixTailMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for max angle of the tails\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "max.tail.angle :\t " + (int)HealingParameters.MaxTailAngle + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for max tail width\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "max.tail.width :\t " + (int)HealingParameters.MaxTailWidth + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for fix selfintersecting of edge\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "selfintersecting.edge :\t " + (int)HealingParameters.FixSelfIntersectingEdgeMode + "\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "selfintersecting.edge :\t "
+ (int)HealingParameters.FixSelfIntersectingEdgeMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for fix intersecting edges\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "intersecting.edges :\t " + (int)HealingParameters.FixIntersectingEdgesMode + "\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "intersecting.edges :\t " + (int)HealingParameters.FixIntersectingEdgesMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for fix non adjacent intersecting edges\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "nonadjacent.intersecting.edges :\t " + (int)HealingParameters.FixNonAdjacentIntersectingEdgesMode + "\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "nonadjacent.intersecting.edges :\t "
+ (int)HealingParameters.FixNonAdjacentIntersectingEdgesMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for applying ShapeFix::FixVertexPosition before all fixes\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += "!Default value: \"NotFix\"(0). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult += aScope + "vertex.position :\t " + (int)HealingParameters.FixVertexPositionMode + "\n";
aResult += "!\n";
aResult += "!\n";
aResult += "!Defines the mode for increases the tolerances of the edge vertices to comprise ";
aResult += "!the ends of 3d curve and pcurve on the given face (first method) or all pcurves stored in an edge (second one)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), \"Fix\"(1)\n";
aResult += aScope + "vertex.tolerance :\t " + (int)HealingParameters.FixVertexToleranceMode + "\n";
aResult += "!the ends of 3d curve and pcurve on the given face (first method) or all pcurves "
"stored in an edge (second one)\n";
aResult += "!Default value: \"FixOrNot\"(-1). Available values: \"FixOrNot\"(-1), \"NotFix\"(0), "
"\"Fix\"(1)\n";
aResult +=
aScope + "vertex.tolerance :\t " + (int)HealingParameters.FixVertexToleranceMode + "\n";
aResult += "!\n";
return aResult;

9
src/DE/DE_ShapeFixConfigurationNode.hxx
View File

@ -25,27 +25,26 @@ class DE_ShapeFixConfigurationNode : public DE_ConfigurationNode
{
DEFINE_STANDARD_RTTIEXT(DE_ShapeFixConfigurationNode, DE_ConfigurationNode)
public:
//! Initializes all field by default
Standard_EXPORT DE_ShapeFixConfigurationNode();
//! Copies values of all fields
//! @param[in] theConfigurationNode object to copy
Standard_EXPORT DE_ShapeFixConfigurationNode(const Handle(DE_ShapeFixConfigurationNode)& theConfigurationNode);
Standard_EXPORT DE_ShapeFixConfigurationNode(
const Handle(DE_ShapeFixConfigurationNode)& theConfigurationNode);
//! Updates values according the resource
//! @param[in] theResource input resource to use
//! @return True if Load was successful
Standard_EXPORT virtual bool Load(const Handle(DE_ConfigurationContext)& theResource) Standard_OVERRIDE;
Standard_EXPORT virtual bool Load(const Handle(DE_ConfigurationContext)& theResource)
Standard_OVERRIDE;
//! Writes configuration to the string
//! @return result resource string
Standard_EXPORT virtual TCollection_AsciiString Save() const Standard_OVERRIDE;
public:
DE_ShapeFixParameters HealingParameters; //!< Shape healing parameters
};
#endif // _DE_ShapeFixConfigurationNode_HeaderFile

361
src/DE/DE_Wrapper.cxx
View File

@ -19,8 +19,8 @@
#include <Message_ProgressRange.hxx>
#include <NCollection_Buffer.hxx>
#include <OSD_File.hxx>
#include <OSD_Path.hxx>
#include <OSD_FileSystem.hxx>
#include <OSD_Path.hxx>
#include <OSD_Protection.hxx>
#include <Standard_ErrorHandler.hxx>
#include <TopoDS_Shape.hxx>
@ -29,44 +29,41 @@ IMPLEMENT_STANDARD_RTTIEXT(DE_Wrapper, Standard_Transient)
namespace
{
static const TCollection_AsciiString& THE_CONFIGURATION_SCOPE()
{
static const TCollection_AsciiString aScope ("global");
return aScope;
}
static Handle(DE_Wrapper)& THE_GLOBAL_CONFIGURATION()
{
static Handle(DE_Wrapper) aConf = new DE_Wrapper();
return aConf;
}
static const TCollection_AsciiString& THE_CONFIGURATION_SCOPE()
{
static const TCollection_AsciiString aScope("global");
return aScope;
}
//=======================================================================
// function : DE_Wrapper
// purpose :
//=======================================================================
DE_Wrapper::DE_Wrapper()
:myKeepUpdates(Standard_False)
{}
static Handle(DE_Wrapper)& THE_GLOBAL_CONFIGURATION()
{
static Handle(DE_Wrapper) aConf = new DE_Wrapper();
return aConf;
}
} // namespace
//=================================================================================================
DE_Wrapper::DE_Wrapper()
: myKeepUpdates(Standard_False)
{
}
//=================================================================================================
//=======================================================================
// function : DE_Wrapper
// purpose :
//=======================================================================
DE_Wrapper::DE_Wrapper(const Handle(DE_Wrapper)& theWrapper)
: DE_Wrapper()
: DE_Wrapper()
{
if (theWrapper.IsNull())
{
return;
}
GlobalParameters = theWrapper->GlobalParameters;
for (DE_ConfigurationFormatMap::Iterator aFormatIter(theWrapper->Nodes());
aFormatIter.More(); aFormatIter.Next())
for (DE_ConfigurationFormatMap::Iterator aFormatIter(theWrapper->Nodes()); aFormatIter.More();
aFormatIter.Next())
{
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value());
aVendorIter.More(); aVendorIter.Next())
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value()); aVendorIter.More();
aVendorIter.Next())
{
Bind(aVendorIter.Value());
}
@ -74,19 +71,15 @@ DE_Wrapper::DE_Wrapper(const Handle(DE_Wrapper)& theWrapper)
theWrapper->myKeepUpdates = myKeepUpdates;
}
//=======================================================================
// function : GlobalWrapper
// purpose :
//=======================================================================
//=================================================================================================
const Handle(DE_Wrapper)& DE_Wrapper::GlobalWrapper()
{
return THE_GLOBAL_CONFIGURATION();
}
//=======================================================================
// function : SetGlobalWrapper
// purpose :
//=======================================================================
//=================================================================================================
void DE_Wrapper::SetGlobalWrapper(const Handle(DE_Wrapper)& theWrapper)
{
if (!theWrapper.IsNull())
@ -95,24 +88,20 @@ void DE_Wrapper::SetGlobalWrapper(const Handle(DE_Wrapper)& theWrapper)
}
}
//=======================================================================
// function : GlobalLoadMutex
// purpose :
//=======================================================================
//=================================================================================================
Standard_Mutex& DE_Wrapper::GlobalLoadMutex()
{
static Standard_Mutex THE_GLOBAL_LOAD_MUTEX;
return THE_GLOBAL_LOAD_MUTEX;
}
//=======================================================================
// function : Read
// purpose :
//=======================================================================
Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
//=================================================================================================
Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
{
if (theDocument.IsNull())
{
@ -130,14 +119,12 @@ Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
return aProvider->Read(thePath, theDocument, theWS, theProgress);
}
//=======================================================================
// function : Write
// purpose :
//=======================================================================
Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
//=================================================================================================
Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
{
if (theDocument.IsNull())
{
@ -155,13 +142,11 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
return aProvider->Write(thePath, theDocument, theWS, theProgress);
}
//=======================================================================
// function : Read
// purpose :
//=======================================================================
Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
//=================================================================================================
Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress)
const Message_ProgressRange& theProgress)
{
if (theDocument.IsNull())
{
@ -175,13 +160,11 @@ Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
return aProvider->Read(thePath, theDocument, theProgress);
}
//=======================================================================
// function : Write
// purpose :
//=======================================================================
Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
//=================================================================================================
Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress)
const Message_ProgressRange& theProgress)
{
if (theDocument.IsNull())
{
@ -195,14 +178,12 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
return aProvider->Write(thePath, theDocument, theProgress);
}
//=======================================================================
// function : Read
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
const Message_ProgressRange& theProgress)
{
if (theWS.IsNull())
{
@ -216,14 +197,12 @@ Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
return aProvider->Read(thePath, theShape, theWS, theProgress);
}
//=======================================================================
// function : Write
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
const TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress)
const Message_ProgressRange& theProgress)
{
if (theWS.IsNull())
{
@ -237,13 +216,11 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
return aProvider->Write(thePath, theShape, theWS, theProgress);
}
//=======================================================================
// function : Read
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
{
Handle(DE_Provider) aProvider;
@ -254,13 +231,11 @@ Standard_Boolean DE_Wrapper::Read(const TCollection_AsciiString& thePath,
return aProvider->Read(thePath, theShape, theProgress);
}
//=======================================================================
// function : Write
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress)
{
Handle(DE_Provider) aProvider;
if (!FindProvider(thePath, Standard_False, aProvider))
@ -270,34 +245,34 @@ Standard_Boolean DE_Wrapper::Write(const TCollection_AsciiString& thePath,
return aProvider->Write(thePath, theShape, theProgress);
}
//=======================================================================
// function : Load
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::Load(const TCollection_AsciiString& theResource,
const Standard_Boolean theIsRecursive)
const Standard_Boolean theIsRecursive)
{
Handle(DE_ConfigurationContext) aResource = new DE_ConfigurationContext();
aResource->Load(theResource);
return Load(aResource, theIsRecursive);
}
//=======================================================================
// function : Load
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::Load(const Handle(DE_ConfigurationContext)& theResource,
const Standard_Boolean theIsRecursive)
const Standard_Boolean theIsRecursive)
{
GlobalParameters.LengthUnit = theResource->RealVal("general.length.unit", GlobalParameters.LengthUnit, THE_CONFIGURATION_SCOPE());
GlobalParameters.SystemUnit = theResource->RealVal("general.system.unit", GlobalParameters.SystemUnit, THE_CONFIGURATION_SCOPE());
GlobalParameters.LengthUnit = theResource->RealVal("general.length.unit",
GlobalParameters.LengthUnit,
THE_CONFIGURATION_SCOPE());
GlobalParameters.SystemUnit = theResource->RealVal("general.system.unit",
GlobalParameters.SystemUnit,
THE_CONFIGURATION_SCOPE());
if (theIsRecursive)
{
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration);
aFormatIter.More(); aFormatIter.Next())
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration); aFormatIter.More();
aFormatIter.Next())
{
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value());
aVendorIter.More(); aVendorIter.Next())
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value()); aVendorIter.More();
aVendorIter.Next())
{
aVendorIter.Value()->Load(theResource);
}
@ -307,23 +282,21 @@ Standard_Boolean DE_Wrapper::Load(const Handle(DE_ConfigurationContext)& theReso
return Standard_True;
}
//=======================================================================
// function : Save
// purpose :
//=======================================================================
Standard_Boolean DE_Wrapper::Save(const TCollection_AsciiString& theResourcePath,
const Standard_Boolean theIsRecursive,
//=================================================================================================
Standard_Boolean DE_Wrapper::Save(const TCollection_AsciiString& theResourcePath,
const Standard_Boolean theIsRecursive,
const TColStd_ListOfAsciiString& theFormats,
const TColStd_ListOfAsciiString& theVendors)
{
OSD_Path aPath = theResourcePath;
OSD_File aFile(aPath);
OSD_Path aPath = theResourcePath;
OSD_File aFile(aPath);
OSD_Protection aProt;
{
try
{
OCC_CATCH_SIGNALS
aFile.Build(OSD_ReadWrite, aProt);
aFile.Build(OSD_ReadWrite, aProt);
}
catch (Standard_Failure const&)
{
@ -340,11 +313,9 @@ Standard_Boolean DE_Wrapper::Save(const TCollection_AsciiString& theResourcePath
return Standard_True;
}
//=======================================================================
// function : Save
// purpose :
//=======================================================================
TCollection_AsciiString DE_Wrapper::Save(const Standard_Boolean theIsRecursive,
//=================================================================================================
TCollection_AsciiString DE_Wrapper::Save(const Standard_Boolean theIsRecursive,
const TColStd_ListOfAsciiString& theFormats,
const TColStd_ListOfAsciiString& theVendors)
{
@ -359,13 +330,13 @@ TCollection_AsciiString DE_Wrapper::Save(const Standard_Boolean theIsRecursive,
aResult += "!*****************************************************************************\n";
aResult += "!DE_Wrapper\n";
aResult += "!Priority vendor list. For every CAD format set indexed list of vendors\n";
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration);
aFormatIter.More(); aFormatIter.Next())
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration); aFormatIter.More();
aFormatIter.Next())
{
const TCollection_AsciiString& aFormat = aFormatIter.Key();
aResult += THE_CONFIGURATION_SCOPE() + '.' + "priority" + '.' + aFormat + " :\t ";
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value());
aVendorIter.More(); aVendorIter.Next())
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value()); aVendorIter.More();
aVendorIter.Next())
{
const TCollection_AsciiString& aVendorName = aVendorIter.Value()->GetVendor();
aResult += aVendorName + " ";
@ -374,20 +345,22 @@ TCollection_AsciiString DE_Wrapper::Save(const Standard_Boolean theIsRecursive,
}
aResult += "!Global parameters. Used for all providers\n";
aResult += "!Length scale unit value. Should be more than 0. Default value: 1.0(MM)\n";
aResult += THE_CONFIGURATION_SCOPE() + ".general.length.unit :\t " + GlobalParameters.LengthUnit + "\n";
aResult +=
THE_CONFIGURATION_SCOPE() + ".general.length.unit :\t " + GlobalParameters.LengthUnit + "\n";
aResult += "!System unit value. Should be more than 0. Default value: 1.0(MM)\n";
aResult += THE_CONFIGURATION_SCOPE() + ".general.system.unit :\t " + GlobalParameters.SystemUnit + "\n";
aResult +=
THE_CONFIGURATION_SCOPE() + ".general.system.unit :\t " + GlobalParameters.SystemUnit + "\n";
if (theIsRecursive)
{
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration);
aFormatIter.More(); aFormatIter.Next())
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration); aFormatIter.More();
aFormatIter.Next())
{
if (!theFormats.IsEmpty() && !theFormats.Contains(aFormatIter.Key()))
{
continue;
}
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value());
aVendorIter.More(); aVendorIter.Next())
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value()); aVendorIter.More();
aVendorIter.Next())
{
if (!theVendors.IsEmpty() && !theVendors.Contains(aVendorIter.Key()))
{
@ -403,10 +376,8 @@ TCollection_AsciiString DE_Wrapper::Save(const Standard_Boolean theIsRecursive,
return aResult;
}
//=======================================================================
// function : Bind
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::Bind(const Handle(DE_ConfigurationNode)& theNode)
{
if (theNode.IsNull())
@ -415,7 +386,7 @@ Standard_Boolean DE_Wrapper::Bind(const Handle(DE_ConfigurationNode)& theNode)
}
const TCollection_AsciiString aFileFormat = theNode->GetFormat();
const TCollection_AsciiString aVendorName = theNode->GetVendor();
DE_ConfigurationVendorMap* aVendorMap = myConfiguration.ChangeSeek(aFileFormat);
DE_ConfigurationVendorMap* aVendorMap = myConfiguration.ChangeSeek(aFileFormat);
if (aVendorMap == NULL)
{
DE_ConfigurationVendorMap aTmpVendorMap;
@ -424,10 +395,8 @@ Standard_Boolean DE_Wrapper::Bind(const Handle(DE_ConfigurationNode)& theNode)
return aVendorMap->Add(aVendorName, theNode) > 0;
}
//=======================================================================
// function : UnBind
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::UnBind(const Handle(DE_ConfigurationNode)& theNode)
{
if (theNode.IsNull())
@ -436,7 +405,7 @@ Standard_Boolean DE_Wrapper::UnBind(const Handle(DE_ConfigurationNode)& theNode)
}
const TCollection_AsciiString aFileFormat = theNode->GetFormat();
const TCollection_AsciiString aVendorName = theNode->GetVendor();
DE_ConfigurationVendorMap* aVendorMap = myConfiguration.ChangeSeek(aFileFormat);
DE_ConfigurationVendorMap* aVendorMap = myConfiguration.ChangeSeek(aFileFormat);
if (aVendorMap == NULL)
{
return false;
@ -446,25 +415,21 @@ Standard_Boolean DE_Wrapper::UnBind(const Handle(DE_ConfigurationNode)& theNode)
return aVendorMap->Size() != aPrevSize;
}
//=======================================================================
// function : Find
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::Find(const TCollection_AsciiString& theFormat,
const TCollection_AsciiString& theVendor,
Handle(DE_ConfigurationNode)& theNode) const
Handle(DE_ConfigurationNode)& theNode) const
{
const DE_ConfigurationVendorMap* aVendorMap = myConfiguration.Seek(theFormat);
return aVendorMap != nullptr && aVendorMap->FindFromKey(theVendor, theNode);
}
//=======================================================================
// function : ChangePriority
// purpose :
//=======================================================================
void DE_Wrapper::ChangePriority(const TCollection_AsciiString& theFormat,
//=================================================================================================
void DE_Wrapper::ChangePriority(const TCollection_AsciiString& theFormat,
const TColStd_ListOfAsciiString& theVendorPriority,
const Standard_Boolean theToDisable)
const Standard_Boolean theToDisable)
{
DE_ConfigurationVendorMap aVendorMap;
if (!myConfiguration.Find(theFormat, aVendorMap))
@ -473,11 +438,11 @@ void DE_Wrapper::ChangePriority(const TCollection_AsciiString& theFormat,
}
DE_ConfigurationVendorMap aNewVendorMap;
// Sets according to the input priority
for (TColStd_ListOfAsciiString::Iterator aPriorIter(theVendorPriority);
aPriorIter.More(); aPriorIter.Next())
for (TColStd_ListOfAsciiString::Iterator aPriorIter(theVendorPriority); aPriorIter.More();
aPriorIter.Next())
{
const TCollection_AsciiString& aVendorName = aPriorIter.Value();
Handle(DE_ConfigurationNode) aNode;
Handle(DE_ConfigurationNode) aNode;
if (aVendorMap.FindFromKey(aVendorName, aNode))
{
aNode->SetEnabled(Standard_True);
@ -485,8 +450,8 @@ void DE_Wrapper::ChangePriority(const TCollection_AsciiString& theFormat,
}
}
// Sets not used elements
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aVendorMap);
aVendorIter.More(); aVendorIter.Next())
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aVendorMap); aVendorIter.More();
aVendorIter.Next())
{
const TCollection_AsciiString& aVendorName = aVendorIter.Key();
if (!theVendorPriority.Contains(aVendorName))
@ -502,51 +467,44 @@ void DE_Wrapper::ChangePriority(const TCollection_AsciiString& theFormat,
myConfiguration.Bind(theFormat, aNewVendorMap);
}
//=======================================================================
// function : ChangePriority
// purpose :
//=======================================================================
//=================================================================================================
void DE_Wrapper::ChangePriority(const TColStd_ListOfAsciiString& theVendorPriority,
const Standard_Boolean theToDisable)
const Standard_Boolean theToDisable)
{
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration);
aFormatIter.More(); aFormatIter.Next())
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration); aFormatIter.More();
aFormatIter.Next())
{
ChangePriority(aFormatIter.Key(), theVendorPriority, theToDisable);
}
}
//=======================================================================
// function : Nodes
// purpose :
//=======================================================================
//=================================================================================================
const DE_ConfigurationFormatMap& DE_Wrapper::Nodes() const
{
return myConfiguration;
}
//=======================================================================
// function : Copy
// purpose :
//=======================================================================
//=================================================================================================
Handle(DE_Wrapper) DE_Wrapper::Copy() const
{
return new DE_Wrapper(*this);
}
//=======================================================================
// function : FindProvider
// purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean DE_Wrapper::FindProvider(const TCollection_AsciiString& thePath,
const Standard_Boolean theToImport,
Handle(DE_Provider)& theProvider) const
const Standard_Boolean theToImport,
Handle(DE_Provider)& theProvider) const
{
Handle(NCollection_Buffer) aBuffer;
if (theToImport)
{
const Handle(OSD_FileSystem)& aFileSystem = OSD_FileSystem::DefaultFileSystem();
std::shared_ptr<std::istream> aStream = aFileSystem->OpenIStream(thePath, std::ios::in | std::ios::binary);
std::shared_ptr<std::istream> aStream =
aFileSystem->OpenIStream(thePath, std::ios::in | std::ios::binary);
if (aStream.get() != nullptr)
{
aBuffer = new NCollection_Buffer(NCollection_BaseAllocator::CommonBaseAllocator(), 2048);
@ -554,23 +512,22 @@ Standard_Boolean DE_Wrapper::FindProvider(const TCollection_AsciiString& thePath
aBuffer->ChangeData()[2047] = '\0';
}
}
OSD_Path aPath(thePath);
OSD_Path aPath(thePath);
const TCollection_AsciiString anExtr = aPath.Extension();
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration);
aFormatIter.More(); aFormatIter.Next())
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration); aFormatIter.More();
aFormatIter.Next())
{
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value());
aVendorIter.More(); aVendorIter.Next())
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value()); aVendorIter.More();
aVendorIter.Next())
{
const Handle(DE_ConfigurationNode)& aNode = aVendorIter.Value();
if (aNode->IsEnabled() &&
((theToImport && aNode->IsImportSupported()) ||
(!theToImport && aNode->IsExportSupported())) &&
(aNode->CheckExtension(anExtr) ||
(theToImport && aNode->CheckContent(aBuffer))) &&
aNode->UpdateLoad(theToImport, myKeepUpdates))
if (aNode->IsEnabled()
&& ((theToImport && aNode->IsImportSupported())
|| (!theToImport && aNode->IsExportSupported()))
&& (aNode->CheckExtension(anExtr) || (theToImport && aNode->CheckContent(aBuffer)))
&& aNode->UpdateLoad(theToImport, myKeepUpdates))
{
theProvider = aNode->BuildProvider();
theProvider = aNode->BuildProvider();
aNode->GlobalParameters = GlobalParameters;
return Standard_True;
}
@ -579,17 +536,15 @@ Standard_Boolean DE_Wrapper::FindProvider(const TCollection_AsciiString& thePath
return Standard_False;
}
//=======================================================================
// function : UpdateLoad
// purpose :
//=======================================================================
//=================================================================================================
Standard_EXPORT void DE_Wrapper::UpdateLoad(const Standard_Boolean theToForceUpdate) const
{
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration);
aFormatIter.More(); aFormatIter.Next())
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration); aFormatIter.More();
aFormatIter.Next())
{
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value());
aVendorIter.More(); aVendorIter.Next())
for (DE_ConfigurationVendorMap::Iterator aVendorIter(aFormatIter.Value()); aVendorIter.More();
aVendorIter.Next())
{
const Handle(DE_ConfigurationNode)& aNode = aVendorIter.Value();
aNode->UpdateLoad(Standard_True, Standard_True);
@ -601,15 +556,13 @@ Standard_EXPORT void DE_Wrapper::UpdateLoad(const Standard_Boolean theToForceUpd
}
}
//=======================================================================
// function : sort
// purpose :
//=======================================================================
//=================================================================================================
void DE_Wrapper::sort(const Handle(DE_ConfigurationContext)& theResource)
{
const TCollection_AsciiString aScope(THE_CONFIGURATION_SCOPE() + '.' + "priority");
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration);
aFormatIter.More(); aFormatIter.Next())
for (DE_ConfigurationFormatMap::Iterator aFormatIter(myConfiguration); aFormatIter.More();
aFormatIter.Next())
{
TColStd_ListOfAsciiString aVendorPriority;
if (!theResource->GetStringSeq(aFormatIter.Key(), aVendorPriority, aScope))

109
src/DE/DE_Wrapper.hxx
View File

@ -25,8 +25,10 @@ class TopoDS_Shape;
class XSControl_WorkSession;
class TDocStd_Document;
typedef NCollection_IndexedDataMap<TCollection_AsciiString, Handle(DE_ConfigurationNode)> DE_ConfigurationVendorMap;
typedef NCollection_DataMap<TCollection_AsciiString, DE_ConfigurationVendorMap> DE_ConfigurationFormatMap;
typedef NCollection_IndexedDataMap<TCollection_AsciiString, Handle(DE_ConfigurationNode)>
DE_ConfigurationVendorMap;
typedef NCollection_DataMap<TCollection_AsciiString, DE_ConfigurationVendorMap>
DE_ConfigurationFormatMap;
//! The main class for working with CAD file exchange.
//! Loads and Saves special CAD transfer property.
@ -54,7 +56,6 @@ class DE_Wrapper : public Standard_Transient
DEFINE_STANDARD_RTTIEXT(DE_Wrapper, Standard_Transient)
public:
//! Initializes all field by default
Standard_EXPORT DE_Wrapper();
@ -74,17 +75,17 @@ public:
Standard_EXPORT static Standard_Mutex& GlobalLoadMutex();
public:
//! Reads a CAD file, according internal configuration
//! @param[in] thePath path to the import CAD file
//! @param[out] theDocument document to save result
//! @param[in] theWS current work session
//! @param[in] theProgress progress indicator
//! @return true if Read operation has ended correctly
Standard_EXPORT Standard_Boolean Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean
Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a CAD file, according internal configuration
//! @param[in] thePath path to the export CAD file
@ -92,28 +93,31 @@ public:
//! @param[in] theWS current work session
//! @param[in] theProgress progress indicator
//! @return true if Write operation has ended correctly
Standard_EXPORT Standard_Boolean Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean
Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads a CAD file, according internal configuration
//! @param[in] thePath path to the import CAD file
//! @param[out] theDocument document to save result
//! @param[in] theProgress progress indicator
//! @return true if Read operation has ended correctly
Standard_EXPORT Standard_Boolean Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean
Read(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a CAD file, according internal configuration
//! @param[in] thePath path to the export CAD file
//! @param[out] theDocument document to export
//! @param[in] theProgress progress indicator
//! @return true if Write operation has ended correctly
Standard_EXPORT Standard_Boolean Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean
Write(const TCollection_AsciiString& thePath,
const Handle(TDocStd_Document)& theDocument,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads a CAD file, according internal configuration
//! @param[in] thePath path to the import CAD file
@ -121,10 +125,11 @@ public:
//! @param[in] theWS current work session
//! @param[in] theProgress progress indicator
//! @return true if Read operation has ended correctly
Standard_EXPORT Standard_Boolean Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean
Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a CAD file, according internal configuration
//! @param[in] thePath path to the export CAD file
@ -132,37 +137,39 @@ public:
//! @param[in] theWS current work session
//! @param[in] theProgress progress indicator
//! @return true if Write operation has ended correctly
Standard_EXPORT Standard_Boolean Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean
Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
Handle(XSControl_WorkSession)& theWS,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads a CAD file, according internal configuration
//! @param[in] thePath path to the import CAD file
//! @param[out] theShape shape to save result
//! @param[in] theProgress progress indicator
//! @return true if Read operation has ended correctly
Standard_EXPORT Standard_Boolean Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean
Read(const TCollection_AsciiString& thePath,
TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a CAD file, according internal configuration
//! @param[in] thePath path to the export CAD file
//! @param[out] theShape shape to export
//! @param[in] theProgress progress indicator
//! @return true if Write operation has ended correctly
Standard_EXPORT Standard_Boolean Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean
Write(const TCollection_AsciiString& thePath,
const TopoDS_Shape& theShape,
const Message_ProgressRange& theProgress = Message_ProgressRange());
public:
//! Updates values according the resource file
//! @param[in] theResource file path to resource or resource value
//! @param[in] theIsRecursive flag to update all nodes
//! @return true if theResource has loaded correctly
Standard_EXPORT Standard_Boolean Load(const TCollection_AsciiString& theResource = "",
const Standard_Boolean theIsRecursive = Standard_True);
const Standard_Boolean theIsRecursive = Standard_True);
//! Updates values according the resource
//! @param[in] theResource input resource to use
@ -177,19 +184,21 @@ public:
//! @param[in] theFormats list of formats to save. If empty, saves all available
//! @param[in] theVendors list of providers to save. If empty, saves all available
//! @return true if the Configuration has saved correctly
Standard_EXPORT Standard_Boolean Save(const TCollection_AsciiString& theResourcePath,
const Standard_Boolean theIsRecursive = Standard_True,
const TColStd_ListOfAsciiString& theFormats = TColStd_ListOfAsciiString(),
const TColStd_ListOfAsciiString& theVendors = TColStd_ListOfAsciiString());
Standard_EXPORT Standard_Boolean
Save(const TCollection_AsciiString& theResourcePath,
const Standard_Boolean theIsRecursive = Standard_True,
const TColStd_ListOfAsciiString& theFormats = TColStd_ListOfAsciiString(),
const TColStd_ListOfAsciiString& theVendors = TColStd_ListOfAsciiString());
//! Writes configuration to the string
//! @param[in] theIsRecursive flag to write values of all nodes
//! @param[in] theFormats list of formats to save. If empty, saves all available
//! @param[in] theVendors list of providers to save. If empty, saves all available
//! @return result resource string
Standard_EXPORT TCollection_AsciiString Save(const Standard_Boolean theIsRecursive = Standard_True,
const TColStd_ListOfAsciiString& theFormats = TColStd_ListOfAsciiString(),
const TColStd_ListOfAsciiString& theVendors = TColStd_ListOfAsciiString());
Standard_EXPORT TCollection_AsciiString
Save(const Standard_Boolean theIsRecursive = Standard_True,
const TColStd_ListOfAsciiString& theFormats = TColStd_ListOfAsciiString(),
const TColStd_ListOfAsciiString& theVendors = TColStd_ListOfAsciiString());
//! Creates new node copy and adds to the map
//! @param[in] theNode input node to copy
@ -208,13 +217,13 @@ public:
//! @return Standard_True if the node is found
Standard_EXPORT Standard_Boolean Find(const TCollection_AsciiString& theFormat,
const TCollection_AsciiString& theVendor,
Handle(DE_ConfigurationNode)& theNode) const;
Handle(DE_ConfigurationNode)& theNode) const;
//! Changes provider priority to one format if it exists
//! @param[in] theFormat input node CAD format
//! @param[in] theVendorPriority priority of work with vendors
//! @param[in] theToDisable flag for disabling nodes that are not included in the priority
Standard_EXPORT void ChangePriority(const TCollection_AsciiString& theFormat,
Standard_EXPORT void ChangePriority(const TCollection_AsciiString& theFormat,
const TColStd_ListOfAsciiString& theVendorPriority,
const Standard_Boolean theToDisable = Standard_False);
@ -231,11 +240,12 @@ public:
//! @param[out] theProvider created new provider
//! @return Standard_True if provider found and created
Standard_EXPORT virtual Standard_Boolean FindProvider(const TCollection_AsciiString& thePath,
const Standard_Boolean theToImport,
const Standard_Boolean theToImport,
Handle(DE_Provider)& theProvider) const;
//! Updates all registered nodes, all changes will be saved in nodes
//! @param[in] theToForceUpdate flag that turns on/of nodes, according to updated ability to import/export
//! @param[in] theToForceUpdate flag that turns on/of nodes, according to updated ability to
//! import/export
Standard_EXPORT void UpdateLoad(const Standard_Boolean theToForceUpdate = Standard_False) const;
//! Gets flag that keeps changes on configuration nodes which are being updated, false by default
@ -253,7 +263,6 @@ public:
Standard_EXPORT virtual Handle(DE_Wrapper) Copy() const;
protected:
//! Sorts the vendors according to the priority to work
//! Formats omitted from the resource are not modified
//! Vendors omitted from the format scope are disabled
@ -261,12 +270,12 @@ protected:
void sort(const Handle(DE_ConfigurationContext)& theResource);
public:
DE_ConfigurationNode::DE_SectionGlobal GlobalParameters; //!< Internal parameters for the all translators
DE_ConfigurationNode::DE_SectionGlobal
GlobalParameters; //!< Internal parameters for the all translators
private:
Standard_Boolean myKeepUpdates; //!< Flag that keeps changes on configuration nodes which are being updated
Standard_Boolean
myKeepUpdates; //!< Flag that keeps changes on configuration nodes which are being updated
DE_ConfigurationFormatMap myConfiguration; //!< Internal map of formats
};