Refactored Standard_ErrorHandler to use thread_local storage for the error handler stack
instead of a global list protected by mutex. This eliminates locking overhead entirely
since each thread only accesses its own error handlers.
Changes:
- Replaced global mutex-protected stack with thread_local Top pointer
- Simplified FindHandler() to directly return the thread-local Top
- Removed Catches() and LastCaughtError() methods (no longer needed)
- Added Raise() method for re-throwing caught exceptions
- Removed obsolete member variables: myStatus, myThread
- Deleted unused headers: Standard_HandlerStatus.hxx, Standard_JmpBuf.hxx, Standard_PErrorHandler.hxx
- Updated OCC_CATCH_SIGNALS macro to use new Raise() method
- Removed non-functional pcurve handling code that was never properly executed
- Simplified the function to focus solely on 3D curve concatenation
- Improved code readability with better variable naming and modern C++ practices
- Eliminates redundant `Extrema_ExtPS` object creation by initializing once and performing multiple projections
- Removes unused `#include <Extrema_ExtPS.hxx>` directives from files that no longer directly instantiate the class
- Improves performance by avoiding repeated surface initialization overhead
- Removed unnecessary reference qualifiers (`&`) from `gp_Dir` variable declarations in geometric evaluation classes
- Initialized previously uninitialized variables (`DuvBuf`, `anFDOpenMode`) to prevent undefined behavior
- Removed redundant `Standard_EXPORT` from deleted copy constructors
- Added explicit base class initialization in `EnumeratedThread` copy constructor
- Replaced C-style cast with `reinterpret_cast` in `Quantity_ColorRGBA` for type safety
- Introduced a new `PreparedParams` struct to encapsulate both parameter and span data in `GeomGridEval_BSplineCurve`.
- Updated `prepareParams` function to return `PreparedParams` instead of using output parameters for span data.
- Simplified the parameter preparation process in `GeomGridEval_BSplineSurface` by creating dedicated functions `prepareGridPoints` and `preparePairPoints` that return sorted UV points with span information.
- Removed redundant `locateSpan` and `computeSpansAndSort` methods from the public interface of `GeomGridEval_BSplineSurface`.
- Enhanced code readability and maintainability by reducing the number of parameters passed to functions and encapsulating related data.
- Deleted TopoDS_ListOfShape.hxx and removed its references in various files.
- Replaced instances of TopoDS_ListOfShape with NCollection_List in TopoDS_Builder, TopoDS_Iterator, and TopoDS_TShape.
- Updated CMake files to exclude TopoDS_ListOfShape from the build.
- Removed Geom2dConvert_SequenceOfPPoint and its usages, replacing them with NCollection_Sequence.
- Cleaned up Select3D and SelectMgr modules by removing Select3D_EntitySequence, Select3D_IndexedMapOfEntity, and SelectMgr_IndexedMapOfOwner.
- Adjusted includes in various files to use NCollection types instead of removed classes.
- Overall, this commit streamlines the codebase by eliminating unused types and reducing dependencies.
- Added automated migration scripts for handle syntax, standard types, and macros
- Deprecated legacy `Standard_*` types and macros in favor of native C++ equivalents
- Introduced modern `occ` namespace with template-based type checking helpers
- Enhanced NCollection macros to support variadic arguments for complex template types- Added automated migration scripts for handle syntax, standard types, and macros
- Deprecated legacy `Standard_*` types and macros in favor of native C++ equivalents
- Introduced modern `occ` namespace with template-based type checking helpers
- Enhanced NCollection macros to support variadic arguments for complex template types
- Replaced custom DEFINE_HARRAY1 and DEFINE_HSEQUENCE macros with typedefs to NCollection_HArray1 and NCollection_HSequence for various data types across multiple files.
- Updated header files in the following modules:
- HLRAlgo
- TKShHealing
- TKBRep
- TKG2d
- TKG3d
- TKGeomBase
- TKMeshVS
- TKV3d
- This change improves consistency and reduces the complexity of the codebase by utilizing the standard NCollection templates.
- Updated multiple files in the HLRBRep module to replace occurrences of Standard_Address with new type aliases HLRBRep_CurvePtr and HLRBRep_SurfacePtr.
- Introduced HLRBRep_TypeDef.hxx to define these type aliases for better clarity and maintainability.
- Adjusted constructors, method signatures, and internal variable types to use the new pointer types.
- Ensured compatibility with existing functionality while enhancing type safety and readability.
- Moved tcl samples to resource folder.
- Clean up cmake from samples related settings.
- Removed CSharp samples from the repository.
- Removed MFC samples from the repository.
- Removed Qt samples from the repository.
- Removed Inspector samples from the repository.
- Removed glwin samples from the repository.
- Removed webgl samples from the repository.
- Removed xaml samples from the repository.
- Removed Java samples from the repository.
- Adds a new `PlaneProjector` struct that caches plane origin and direction components
- Replaces two instances of `ElSLib::Parameters` calls with the optimized projector for batch pole projection
Replaced std::vector with NCollection_Vector and std::unordered_map with NCollection_Array1 to use OCCT's native collection classes.
Avoid hashing to use array of elements with index directly.
Remove bit maps for storing the filling status and use the direct checking for emptiness.
Optimise allocations by using IncAllocator for all NCollection_Vector objects.
math_VectorBase can be used with both stack and heap storage and resized when needed.
This is not often required, but when it is, the Resize method allows to do it efficiently,
preserving existing data and optimizing memory usage.
- Replaced `memcpy`/`memset` calls with direct initialization loops to enable register allocation for small dimensions (1-15)
- Introduced local stack arrays that reduce memory round-trips by writing to output only at the end of computation
- Fused derivative and value update loops to minimize redundant memory reads
- Removed SetUVParams/SetParams methods from all GeomGridEval classes
- Updated all evaluation methods to accept parameters directly as arguments
- Added new EvaluatePoints methods for arbitrary UV pair evaluation
- Updated all callers to use the new direct evaluation pattern
- Refactored polyhedron initialization to use `GeomGridEval_Surface` for grid-based evaluation
- Implemented isoline optimization in surface evaluators (1D curve extraction for 1×N/N×1 grids)
- Reorganized tests: moved BSpline surface tests to dedicated file and added comprehensive isoline validation tests
- Added height-ordering detection methods (`IsHeightInverted()`, `AreHeightsEqual()`) to `BRepPrim_OneAxis`
- Fixed edge vertex ordering and wire direction flags to handle inverted heights
- Replaced preprocessor macros with modern C++ enums in anonymous namespace
- Added comprehensive GTest suite for `BRepPrimAPI_MakeTorus`
- Refactored template-based code generation to explicit implementations across multiple packages
Fixed incorrect loop index initialization in GlueEdgesWithPCurves function.
The loop for iterating PCurves started from index 0, but BRep_Tool::CurveOnSurface
requires 1-based indexing (returns immediately when Index < 1).
This bug caused the first PCurve to be skipped, potentially leading to
incorrect edge gluing results in ShapeUpgrade_UnifySameDomain.
Changed: for (int aCurveIndex = 0;; ...) -> for (int aCurveIndex = 1;; ...)
Refactored Geom_ExtrusionUtils.pxx and Geom_RevolutionUtils.pxx to provide
Calculate* functions that accept pre-computed curve values (point, D1, D2, D3).
This follows the pattern established in Geom_OffsetSurfaceUtils.pxx.
Changes:
- Added CalculateD0/D1/D2/D3/DN functions to both Utils files that work with
pre-computed curve data instead of requiring curve objects with methods
- Updated template functions D0/D1/D2/D3/DN to call the Calculate functions,
eliminating code duplication within the Utils files
- Updated GeomGridEval_SurfaceOfExtrusion to use Geom_ExtrusionUtils::Calculate*
- Updated GeomGridEval_SurfaceOfRevolution to use Geom_RevolutionUtils::Calculate*
- Fixed bug in GeomGridEval_BSplineSurface::prepare() where out-of-bounds
parameters were not properly stored after clamping by BSplCLib::LocateParameter()
This refactoring ensures a single source of truth for surface evaluation formulas,
fixing potential regression from commit 5870232236 where duplicated formulas in
GeomGridEval implementations could diverge from the canonical Utils implementations.
Refactor TKHLR module to eliminate usage of Standard_Address (void*)
for surface parameters, replacing them with type-safe HLRBRep_Surface*
pointers. This improves code readability, type safety, and enables
better compiler diagnostics.
Key changes:
- HLRBRep_Data: Change iFaceGeom member from Standard_Address to
HLRBRep_Surface*, removing all associated casts
- HLRBRep_SurfaceTool: Update all methods to take const HLRBRep_Surface*
- HLRBRep_Surface: Make NbUIntervals/NbVIntervals const-qualified
- HLRBRep_InterCSurf: Use typed pointer via type alias
- HLRBRep_Intersector: Remove Standard_Address from public interface
- HLRBRep_ThePolyhedronOfInterCSurf: Use HLRBRep_Surface* directly
- HLRBRep_TheCSFunctionOfInterCSurf: Use typed pointer member
- HLRBRep_TheQuadCurvExactInterCSurf: Use HLRBRep_Surface* parameter
- Template instantiation files (_0.cxx): Change #define to typedef
for ThePSurface to ensure correct const semantics with templates
- Introduced `GeomGridEval` package with specialized evaluators for analytical surfaces (plane, cylinder, sphere, cone, torus) and parametric surfaces (Bezier, BSpline, offset)
- Refactored extrema computation in `Extrema_GenExtSS`, `Extrema_GenExtPS`, and `Extrema_GenExtCS` to use batch grid evaluation
- Added comprehensive derivative computation support (D0-D3, DN) for all surface types
- Added six new packages: MathUtils, MathPoly, MathLin, MathOpt, MathRoot, MathSys, and MathInteg
- Implemented modern template-based algorithms with consistent result structures and error handling
- Added comprehensive test files for all new packages
- Refactored Add method in BVH_Box to utilize in-place component-wise operations, reducing temporary vector creation.
- Introduced precomputed reciprocal direction in BVH_Ray for faster ray-box intersection tests.
- Updated RayBoxIntersection methods to leverage the new reciprocal direction for optimal performance.
- Enhanced documentation for clarity on new functionalities and optimizations.
This commit completes the refactoring of geometry evaluator classes, replacing polymorphic Handle-based evaluators with inline template utilities and std::variant-based data storage in adaptor classes.
Key changes:
1. Removed GeomEvaluator and Geom2dEvaluator packages:
- Deleted GeomEvaluator_Curve, GeomEvaluator_Surface base classes
- Deleted GeomEvaluator_OffsetCurve, GeomEvaluator_OffsetSurface
- Deleted GeomEvaluator_SurfaceOfExtrusion, GeomEvaluator_SurfaceOfRevolution
- Deleted Geom2dEvaluator_Curve, Geom2dEvaluator_OffsetCurve
2. Added private utility headers (.pxx files) with inline template functions:
- Geom_OffsetCurveUtils.pxx - offset curve evaluation
- Geom_OffsetSurfaceUtils.pxx - offset surface evaluation
- Geom_ExtrusionUtils.pxx - surface of extrusion evaluation
- Geom_RevolutionUtils.pxx - surface of revolution evaluation
- Geom2d_OffsetCurveUtils.pxx - 2D offset curve evaluation
3. Refactored GeomAdaptor_Curve:
- Moved BezierData and BSplineData structs inside the class
- Added std::variant<monostate, OffsetData, BezierData, BSplineData> for type-specific evaluation data
- Removed separate myBSplineCurve and myCurveCache members
- Updated all evaluation methods to use variant-based access
4. Refactored GeomAdaptor_Surface:
- Changed ExtrusionData and RevolutionData to use Handle(Adaptor3d_Curve) instead of Handle(GeomAdaptor_Curve) for flexibility
- Changed RevolutionData to store gp_Ax1 instead of separate AxisLoc/AxisDir
- Updated OffsetData to store Handle(Geom_OffsetSurface) for osculating surface queries instead of creating new Geom_OsculatingSurface
5. Updated Geom_OsculatingSurface:
- Renamed UOscSurf/VOscSurf methods to UOsculatingSurface/VOsculatingSurface for consistency with Geom_OffsetSurface public API
6. Fixed specialized adaptor classes:
- GeomAdaptor_SurfaceOfLinearExtrusion - removed evaluator, uses variant
- GeomAdaptor_SurfaceOfRevolution - removed evaluator, uses variant
- Geom2dAdaptor_Curve - updated to use variant-based data
- Adaptor2d_OffsetCurve - updated to use Geom2d_OffsetCurveUtils
7. Fixed Geom_SurfaceOfRevolution:
- Updated utility calls to use gp_Ax1 parameter instead of separate XYZ
8. Added missing includes in dependent files:
- Adaptor3d_HSurfaceTool.cxx - added GeomAdaptor_Curve.hxx
- GeomAdaptor.cxx - added Adaptor3d_Surface.hxx, GeomAbs_SurfaceType.hxx
- Extrema_GenExtPS.cxx - added Adaptor3d_Curve/Surface.hxx, GeomAbs_IsoType.hxx
- TopOpeBRepTool_GEOMETRY.cxx - added Geom2dAdaptor_Curve.hxx
- BRepAdaptor_Curve2d.cxx - updated ShallowCopy for variant
Benefits:
- Reduced virtual function call overhead in hot evaluation paths
- Better code locality with inline template functions
- Simplified class hierarchy without abstract evaluator base classes
- More efficient memory layout with variant instead of polymorphic handles
- Consistent method naming across related classes
GeomConvert_CompCurveToBSplineCurve::Add() was incorrectly using
first/last poles for G0 continuity checks instead of actual curve
endpoints. For non-clamped or periodic B-splines, poles may not
coincide with curve start/end points, causing concatenation to fail
or produce incorrect results.
Changed to use StartPoint()/EndPoint() methods which properly
evaluate the curve at its parameter bounds.
- Added constexpr to constructors and methods in both classes, with special handling for already-normalized inputs
- Refactored coordinate access methods to avoid pointer arithmetic (incompatible with constexpr)
- Implemented a dual-path approach: fast path for normalized inputs (constexpr-compatible) and slow path for runtime normalization
Modernized and refactored the polynomial root-finding implementation
with improved numerical stability and modern C++ practices.
Key changes:
1. Implementation refactoring (math_DirectPolynomialRoots.cxx):
- Extracted helper functions into anonymous namespace for better encapsulation
- Introduced ScaledCoefficients struct for coefficient scaling operations
- Added separate functions for cubic root cases (three real, one real, multiple)
- Replaced deprecated OCCT math functions with std:: equivalents
(std::abs, std::sqrt, std::pow, std::log, std::cos, std::sin, std::atan, std::max)
- Improved code documentation with algorithm references
2. Header modernization (math_DirectPolynomialRoots.hxx):
- Added comprehensive Doxygen documentation for all public methods
- Renamed private members to follow OCCT conventions (myDone, myRoots, etc.)
- Moved inline implementations from .lxx file directly into header
- Removed math_DirectPolynomialRoots.lxx file (merged into .hxx)
3. Test improvements:
- Added test fixture class for math_DirectPolynomialRoots with helper methods
- Extended test coverage with numerical stability tests
- Added regression tests for problematic quartic cases
- Added Geom2dGcc_Circ2d3Tan tests for BUC60622 regression case
4. Minor fixes:
- Removed unused #include <iostream> from test file
- Updated FILES.cmake to remove deleted .lxx file
- Fixed test case expected values in bug28626_2
Completed the migration of IntCurveSurface_ThePolyhedronOfHInter and
HLRBRep_ThePolyhedronOfInterCSurf to fully utilize shared template
functions in IntCurveSurface_PolyhedronUtils.pxx.
The original commit fff55ee5fc introduced the .pxx template pattern but
only migrated 4 functions, leaving significant code duplication between
the two polyhedron implementations
Changes:
- Extended IntCurveSurface_PolyhedronUtils.pxx with 15 additional
template functions: AllocateArrays, Destroy, NbTriangles, NbPoints,
Triangle, TriConnex, PlaneEquation, Contain, FillBounding, IsOnBound,
ComputeMaxDeflection, ComputeMaxBorderDeflection,
SetDeflectionOverEstimation, Parameters, Point (3 overloads)
- Refactored both .cxx files to delegate all logic to PolyUtils namespace
This aligns the Polyhedron classes with other properly migrated classes
(Polygon, Inter, QuadricCurveExactInter) where the Utils.pxx contains
all shared logic and .cxx files are minimal wrappers.
Extract derivative calculation logic from GeomEvaluator and
Geom2dEvaluator classes into dedicated utility headers:
- Geom_OffsetSurfaceUtils.pxx for 3D offset surface derivatives
- Geom_OffsetCurveUtils.pxx for 3D offset curve derivatives
- Geom2d_OffsetCurveUtils.pxx for 2D offset curve derivatives
- Geom_ExtrusionUtils.pxx for extrusion surface calculations
- Geom_RevolutionUtils.pxx for revolution surface calculations
Utility functions provide unified handling of singular and non-singular
cases with osculating surface support for higher-order derivatives.
Buffer management uses NCollection_LocalArray for stack-safe allocation
with heap fallback when sizes exceed expected limits.
Test case expectations updated to reflect improved calculation accuracy.
Cleans up the BRepClass3d_SolidExplorer class by removing the
unused Bnd_Box member and associated code,
including preprocessor directives and function definitions.
The isVertexInsidePolygon method uses the winding number algorithm,
which computes cumulative angles from the test point to polygon vertices.
For a point inside a polygon, this sum should be ±2π.
The gp_Vec2d::Angle method uses an inverted sign convention where
CCW rotation gives negative angles. For CCW polygons, the total angle
is -2π, but the original check only accepted +2π.
Changed the condition from:
std::abs(Angle2PI - aTotalAng) > Precision::Angular()
to:
std::abs(std::abs(aTotalAng) - Angle2PI) > Precision::Angular()
This correctly handles both CCW (-2π) and CW (+2π) polygon orientations.
Replace custom HLRAlgo_PolyData::Box struct with standard Bnd_Box class
to leverage its built-in update functionality and reduce code duplication.
Changes:
- Remove HLRAlgo_PolyData::Box struct definition
- Update UpdateGlobalMinMax methods to use Bnd_Box::Update()
- Simplify bounding box computation logic using Bnd_Box methods
- Use C++17 structured bindings with Bnd_Box::Get()
- Added a default constructor to CSLib_Class2d for creating empty classifiers.
- Implemented move constructor and move assignment operator to optimize resource management.
- Updated IntTools_FClass2d and BRepTopAdaptor_FClass2d to utilize the new move semantics, eliminating unnecessary dynamic memory allocations.
- Replaced deprecated pointer-based storage with NCollection_Sequence for better memory management.
- Removed the obsolete BRepTopAdaptor_SeqOfPtr class to streamline the codebase.
BRep_Tool::CurveOnSurface expects Index >= 1, but the loop started
from ii = 0, resulting in a wasted iteration that always returned
a null pointer.
Fixes#0032371
Modernized curve/surface intersection algorithms by replacing preprocessor-based
generic programming (.gxx macros) with C++ templates (.pxx headers):
IntCurveSurface package (TKGeomAlgo):
- Introduced IntCurveSurface_Inter.pxx with callback-based template functions
for intersection algorithms, replacing IntCurveSurface_Inter.gxx
- Created IntCurveSurface_InterUtils.pxx with utility template functions for
surface decomposition, UV clamping, and quadric intersection handling
- Added IntCurveSurface_PolygonUtils.pxx for polygon construction utilities
- Added IntCurveSurface_PolyhedronUtils.pxx for polyhedron construction utilities
- Added IntCurveSurface_QuadricCurveExactInterUtils.pxx for exact quadric
intersection computations
- Converted standalone implementation files from macro instantiation (_0.cxx)
to direct template usage (.cxx)
- Removed obsolete .gxx and .lxx files
HLRBRep package (TKHLR):
- Updated HLRBRep_InterCSurf to use new IntCurveSurface template utilities
- Converted HLRBRep polygon, polyhedron, and intersection classes to use
modern template instantiation pattern
- Removed legacy macro-based instantiation files (_0.cxx)
This refactoring improves code maintainability, enables better IDE support
and debugging, and aligns with modern C++ practices while preserving
the existing API and functionality.
- Moved temporary allocator reset to the end of the iteration in BOPAlgo_PaveFiller to prevent memory accumulation.
- Introduced a separate temporary allocator for per-iteration data in BOPAlgo_FillIn3DParts, enhancing memory reclamation during processing.
- Cleared face map before resetting the allocator in BOPAlgo_Tools to ensure efficient memory usage.
- Deleted copy and move constructors and assignment operators in BRepAlgoAPI_BuilderAlgo to ensure non-copyability and non-movability, preventing potential double-free issues.
- Added comprehensive unit tests to verify the non-copyable and non-movable nature of BRepAlgoAPI_BuilderAlgo and its derived classes.
- Updated CMake files to include the new test source file for build integration.
- Added `D0Local`, `D1Local`, `D2Local`, `D3Local` methods to `BSplCLib_Cache` and `BSplSLib_Cache` classes
- Added accessor methods to `Geom_BSplineCurve` and `Geom_BSplineSurface` for direct handle access to internal arrays
- Comprehensive test coverage for both curve and surface cache implementations
Refactored BSplSLib_DataContainer and BSplCLib_DataContainer_T structs:
- Use compile-time constexpr THE_MAX_DEGREE for array sizes
- Remove constructors with runtime initialization overhead
- Add standalone validateBSplineDegree() functions for degree checks
- Eliminate unnecessary zero-initialization of stack buffers
- Replace Standard_Real/Standard_Integer with native double/int types
This improves performance by avoiding runtime memset of large arrays
(~2800 doubles for surfaces, ~200 for curves) on every B-spline evaluation.
