lili/OCCT
1
0
Fork 0
mirror of https://github.com/Open-Cascade-SAS/OCCT.git synced 2026-07-13 23:27:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

Coding - Refactor switch-case statements and improve memory management #569

Browse Source 
- Added missing break statements in switch-case blocks in LDOMBasicString, LDOM_BasicElement, PCDM_ReadWriter, and IntCurve_IntConicConic_1 to prevent fall-through behavior.
- Enhanced Standard_Macro.hxx to support fallthrough attributes across different compilers.
- Corrected the use of std::forward in Standard_MemoryUtils.hxx for better type deduction.
- Replaced raw arrays with NCollection_Array1 in AdvApp2Var_SysBase for improved memory safety.
- Updated Extrema_ExtCC2d to utilize smart pointers for better memory management and avoid potential leaks.
- Refactored Units_UnitsDictionary to use NCollection_Array2 for matrix representation, improving readability and maintainability.
- Initialized TranFirst and TranLast in TopTrans_CurveTransition constructor for better default state management.
- Set myStatus in ShapeConstruct_ProjectCurveOnSurface constructor to ensure proper initialization.
- Changed matrix access in Units_UnitsDictionary to use NCollection_Array2 syntax for consistency.
This commit is contained in:
Pasukhin Dmitry
2025-05-30 14:31:26 +01:00
committed by GitHub
parent 3b62a5eb29
commit 4629ee0ca3
13 changed files with 177 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/ModelingData/TKG2d/Geom2dLProp/Geom2dLProp_NumericCurInf2d.cxx
View File

@@ -51,8 +51,8 @@ void Geom2dLProp_NumericCurInf2d::PerformCurExt(const Handle(Geom2d_Curve)& C,
{
isDone = Standard_True;
Standard_Real EpsH = 1.e-4 * (UMax - UMin);
Standard_Real Tol = Precision::PConfusion();
Standard_Real EpsH = 1.e-4 * (UMax - UMin);
constexpr Standard_Real Tol = Precision::PConfusion();
// la premiere recherce se fait avec une tolerance assez grande
// car la derivee de la fonction est estimee assez grossierement.

13
src/ModelingData/TKGeomBase/AdvApp2Var/AdvApp2Var_SysBase.cxx
View File

@@ -14,6 +14,7 @@
// AdvApp2Var_SysBase.cxx
#include <assert.h>
#include <cmath>
#include <NCollection_Array1.hxx>
#include <string.h>
#include <AdvApp2Var_SysBase.hxx>
#include <AdvApp2Var_Data.hxx>
@@ -1850,11 +1851,11 @@ int mcrcomm_(integer* kop, integer* noct, intptr_t* iadr, integer* ier)
integer i__1, i__2;
/* Local variables */
intptr_t ideb;
doublereal dtab[32000];
intptr_t itab[160] /* was [4][40] */;
intptr_t ipre;
integer i__, j, k;
intptr_t ideb;
NCollection_Array1<doublereal> dtab(0, 32000 - 1);
NCollection_Array1<intptr_t> itab(0, 160 - 1); // was [4][40] but now flattened to a single array
intptr_t ipre;
integer i__, j, k;
/************************************************************************
*******/
@@ -1973,7 +1974,7 @@ int mcrcomm_(integer* kop, integer* noct, intptr_t* iadr, integer* ier)
itab[(i__ << 2) - 4] = *noct / 8 + 1;
itab[(i__ << 2) - 3] = ipre;
itab[(i__ << 2) - 2] = *noct;
*iadr = reinterpret_cast<intptr_t>(&dtab[ipre - 1]);
*iadr = reinterpret_cast<intptr_t>(&dtab[static_cast<Standard_Integer>(ipre) - 1]);
itab[(i__ << 2) - 1] = *iadr;
goto L9900;
}

227
src/ModelingData/TKGeomBase/Extrema/Extrema_ExtCC2d.cxx
View File

@@ -25,6 +25,7 @@
#include <GeomAbs_CurveType.hxx>
#include <gp_Pnt2d.hxx>
#include <Precision.hxx>
#include <Standard_MemoryUtils.hxx>
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>
@@ -34,6 +35,7 @@ Extrema_ExtCC2d::Extrema_ExtCC2d()
myIsPar(Standard_False),
mynbext(0),
inverse(Standard_False),
myC(nullptr),
myv1(0.0),
myv2(0.0),
mytolc1(0.0),
@@ -109,6 +111,9 @@ void Extrema_ExtCC2d::Perform(const Adaptor2d_Curve2d& C1,
P2f = Extrema_Curve2dTool::Value(*myC, U21);
P2l = Extrema_Curve2dTool::Value(*myC, U22);
std::shared_ptr<Extrema_ExtElC2d> aXtream;
std::shared_ptr<Extrema_ECC2d> aParamSolver;
switch (type1)
{
//
@@ -120,44 +125,45 @@ void Extrema_ExtCC2d::Perform(const Adaptor2d_Curve2d& C1,
{
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC),
Extrema_Curve2dTool::Circle(C1),
Tol);
Results(Xtrem, U11, U12, U21, U22, 2 * M_PI, 0.);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(*myC),
Extrema_Curve2dTool::Circle(C1),
Tol);
Results(*aXtream, U11, U12, U21, U22, 2 * M_PI, 0.);
}
break;
case GeomAbs_Circle: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1),
Extrema_Curve2dTool::Circle(*myC));
Results(Xtrem, U11, U12, U21, U22, 2 * M_PI, 2 * M_PI);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Circle(C1),
Extrema_Curve2dTool::Circle(*myC));
Results(*aXtream, U11, U12, U21, U22, 2 * M_PI, 2 * M_PI);
}
break;
case GeomAbs_Ellipse: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1),
Extrema_Curve2dTool::Ellipse(*myC));
Results(Xtrem, U11, U12, U21, U22, 2 * M_PI, 2 * M_PI);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Circle(C1),
Extrema_Curve2dTool::Ellipse(*myC));
Results(*aXtream, U11, U12, U21, U22, 2 * M_PI, 2 * M_PI);
}
break;
case GeomAbs_Parabola: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1),
Extrema_Curve2dTool::Parabola(*myC));
Results(Xtrem, U11, U12, U21, U22, 2 * M_PI, 0.);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Circle(C1),
Extrema_Curve2dTool::Parabola(*myC));
Results(*aXtream, U11, U12, U21, U22, 2 * M_PI, 0.);
}
break;
case GeomAbs_Hyperbola: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(C1),
Extrema_Curve2dTool::Hyperbola(*myC));
Results(Xtrem, U11, U12, U21, U22, 2 * M_PI, 0.);
aXtream =
opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Circle(C1),
Extrema_Curve2dTool::Hyperbola(*myC));
Results(*aXtream, U11, U12, U21, U22, 2 * M_PI, 0.);
}
break;
default: {
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Standard_Real Period2 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(*myC))
Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 2 * M_PI, Period2);
Results(*aParamSolver, U11, U12, U21, U22, 2 * M_PI, Period2);
}
break;
}; // switch(type2)
@@ -173,50 +179,51 @@ void Extrema_ExtCC2d::Perform(const Adaptor2d_Curve2d& C1,
{
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC), Extrema_Curve2dTool::Ellipse(C1));
Results(Xtrem, U11, U12, U21, U22, 2 * M_PI, 0.);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(*myC),
Extrema_Curve2dTool::Ellipse(C1));
Results(*aXtream, U11, U12, U21, U22, 2 * M_PI, 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC),
Extrema_Curve2dTool::Ellipse(C1));
Results(Xtrem, U11, U12, U21, U22, 2 * M_PI, 2 * M_PI);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Circle(*myC),
Extrema_Curve2dTool::Ellipse(C1));
Results(*aXtream, U11, U12, U21, U22, 2 * M_PI, 2 * M_PI);
}
break;
case GeomAbs_Ellipse: {
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 2 * M_PI, 2 * M_PI);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 2 * M_PI, 2 * M_PI);
}
break;
case GeomAbs_Parabola: {
// Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1),
// Extrema_Curve2dTool::Parabola(*myC));
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 2 * M_PI, 0.);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 2 * M_PI, 0.);
}
break;
case GeomAbs_Hyperbola: {
// Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(C1),
// Extrema_Curve2dTool::Hyperbola(*myC));
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 2 * M_PI, 0.);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 2 * M_PI, 0.);
}
break;
default: {
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Standard_Real Period2 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(*myC))
Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 2 * M_PI, Period2);
Results(*aParamSolver, U11, U12, U21, U22, 2 * M_PI, Period2);
}
break;
}; // switch(type2)
@@ -232,55 +239,55 @@ void Extrema_ExtCC2d::Perform(const Adaptor2d_Curve2d& C1,
{
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC),
Extrema_Curve2dTool::Parabola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(*myC),
Extrema_Curve2dTool::Parabola(C1));
Results(*aXtream, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC),
Extrema_Curve2dTool::Parabola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 2 * M_PI);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Circle(*myC),
Extrema_Curve2dTool::Parabola(C1));
Results(*aXtream, U11, U12, U21, U22, 0., 2 * M_PI);
}
break;
case GeomAbs_Ellipse: {
// inverse = Standard_True;
// Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*myC),
// Extrema_Curve2dTool::Parabola(C1));
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 2 * M_PI);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 0., 2 * M_PI);
}
break;
case GeomAbs_Parabola: {
// Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Parabola(C1),
// Extrema_Curve2dTool::Parabola(*myC));
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Hyperbola: {
// inverse = Standard_True;
// Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(*myC),
// Extrema_Curve2dTool::Parabola(C1));
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Standard_Real Period2 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(*myC))
Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
Results(*aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
}; // switch(type2)
@@ -296,54 +303,54 @@ void Extrema_ExtCC2d::Perform(const Adaptor2d_Curve2d& C1,
{
case GeomAbs_Line: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(*myC),
Extrema_Curve2dTool::Hyperbola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(*myC),
Extrema_Curve2dTool::Hyperbola(C1));
Results(*aXtream, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
inverse = Standard_True;
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Circle(*myC),
Extrema_Curve2dTool::Hyperbola(C1));
Results(Xtrem, U11, U12, U21, U22, 0., 2 * M_PI);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Circle(*myC),
Extrema_Curve2dTool::Hyperbola(C1));
Results(*aXtream, U11, U12, U21, U22, 0., 2 * M_PI);
}
break;
case GeomAbs_Ellipse: {
// inverse = Standard_True;
// Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Ellipse(*myC),
// Extrema_Curve2dTool::Hyperbola(C1));
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 2 * M_PI);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 0., 2 * M_PI);
}
break;
case GeomAbs_Parabola: {
// Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1),
// Extrema_Curve2dTool::Parabola(*myC));
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Hyperbola: {
// Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Hyperbola(C1),
// Extrema_Curve2dTool::Hyperbola(*myC));
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
Results(aParamSolver, U11, U12, U21, U22, 0., 0.);
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Results(*aParamSolver, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Standard_Real Period2 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(*myC))
Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
Results(*aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
}; // switch(type2)
@@ -358,44 +365,46 @@ void Extrema_ExtCC2d::Perform(const Adaptor2d_Curve2d& C1,
switch (type2)
{
case GeomAbs_Line: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Line(*myC),
Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Line(*myC),
Tol);
Results(*aXtream, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Circle: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Circle(*myC),
Tol);
Results(Xtrem, U11, U12, U21, U22, 0., 2 * M_PI);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Circle(*myC),
Tol);
Results(*aXtream, U11, U12, U21, U22, 0., 2 * M_PI);
}
break;
case GeomAbs_Ellipse: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1), Extrema_Curve2dTool::Ellipse(*myC));
Results(Xtrem, U11, U12, U21, U22, 0., 2 * M_PI);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Ellipse(*myC));
Results(*aXtream, U11, U12, U21, U22, 0., 2 * M_PI);
}
break;
case GeomAbs_Parabola: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Parabola(*myC));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
aXtream = opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Parabola(*myC));
Results(*aXtream, U11, U12, U21, U22, 0., 0.);
}
break;
case GeomAbs_Hyperbola: {
Extrema_ExtElC2d Xtrem(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Hyperbola(*myC));
Results(Xtrem, U11, U12, U21, U22, 0., 0.);
aXtream =
opencascade::make_shared<Extrema_ExtElC2d>(Extrema_Curve2dTool::Line(C1),
Extrema_Curve2dTool::Hyperbola(*myC));
Results(*aXtream, U11, U12, U21, U22, 0., 0.);
}
break;
default: {
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Standard_Real Period2 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(*myC))
Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, 0., Period2);
Results(*aParamSolver, U11, U12, U21, U22, 0., Period2);
}
break;
}; // switch(type2)
@@ -406,16 +415,16 @@ void Extrema_ExtCC2d::Perform(const Adaptor2d_Curve2d& C1,
// La premiere courbe est une BezierCurve ou une BSplineCurve:
//
default: {
Extrema_ECC2d aParamSolver(C1, *myC);
aParamSolver.SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver.Perform();
aParamSolver = opencascade::make_shared<Extrema_ECC2d>(C1, *myC);
aParamSolver->SetSingleSolutionFlag(GetSingleSolutionFlag());
aParamSolver->Perform();
Standard_Real Period1 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(C1))
Period1 = Extrema_Curve2dTool::Period(C1);
Standard_Real Period2 = 0.;
if (Extrema_Curve2dTool::IsPeriodic(*myC))
Period2 = Extrema_Curve2dTool::Period(*myC);
Results(aParamSolver, U11, U12, U21, U22, Period1, Period2);
Results(*aParamSolver, U11, U12, U21, U22, Period1, Period2);
}
break;
};