If the line is in the circle-plane completely (or parallel to the circle-plane) then extremas and intersections in 2D-space are looked for. These case are pure analytical and solutions will be found precisely.
1. The methods PerformVZ, PerformEZ, PerformFZ and PerformZZ have been transferred from BOPAlgo_PaveFiller to BOPAlgo_CheckerSI class
to perform intersection of sub-shapes with solids only in self-intersection mode.
2. The checks for solids built from the same (shared) faces have been added into methods building the result of Boolean operations -
BOPAlgo_BOP::BuildRC() and BOPAlgo_BOP::BuildSolid().
3. Since the NonDestructive mode is now natively supported by the BOPAlgo_PaveFiller the methods providing the support of this mode by CheckerSI
(BOPAlgo_CheckerSI::PrepareCopy() and BOPAlgo_CheckerSI::PostTreatCopy()) are not needed and have been removed.
4. The pairs of sub-shapes with interfering bounding boxes are now sorted before real intersection to guarantee the constant order of
intersection of sub-shapes and produce more stable result. The class BOPDS_PassKey has been replaced with simpler class BOPDS_Pair.
5. The class BOPDS_SubIterator has been refactored.
6. Test cases for the issue.
7. Adjustment of the test case boolean volumemaker D2.
1. Earlier we could not put any IntPatch_Point to the intersection curve. The fix makes the algorithm of IntPatch_Points searching more precise. It is achieved by redetermination of earlier found vertices with help of minimization the distance between boundary of one intersection argument and another intersection argument (surface).
2. Additional check has been added, if IntPatch_Point adjusted to the domain boundary is true intersection point.
3. Method Contap_ArcFunction::Surface() has been added.
4. Method LastComputedPoint() has been added for IntPatch_ArcFunction and Contap_ArcFunction classes.
5. Correction in FindMaxDistance() method (see IntTools_FaceFace.cxx file) according to pure Golden-ratio minimization algorithm. Earlier this function worked wrong with small searching intervals.
6. Insignificant correction in math_BrentMinimum.cxx file (elimination of "defines").
Creation of test case for issues #27221 an #27252.
Adjusting some test cases according to their new behavior.
Correction according to the last remarks.
Small correction of shape names for issue CR27252
Test case for issue 28210
Small correction of test case for issue 28210
Method GetType() of class GeomAdaptor_SurfaceOfRevolution was modified to create plane instead Cone or SurfaceOfRevolution for "plane like" within Precision::Confusion() restricted object.
For infinite objects Cone with semiangle > PI/2 - eps is replaced by SurfaceOfRevolution for eps < Precision::Confusion()
Tests cases are added
Small correction of shape names for issue CR28261_28266
1. There has been implemented calculation of all possible types of continuity for shared edges:
* G1 is set if tangential planes are the same for connected faces in each control points through the edge;
* C1 is set in addition to G1 conditions if derivatives, orthogonal to the edge on each face, are equal vectors;
* G2 is set in addition to G1 if the centers of principal curvatures are the same for connected faces in each control points through the edge;
* C2 is set in addition to C1 and G2 if directions of principal curvatures are equal;
* CN continuity is set only if both connected faces are based on elementary surfaces (the conditions for this case are similar to C2 continuity).
2. ShapeFix::EncodeRegularity() is merged into BRepLib::EncodeRegularity().
3. Implemented several test cases to check correct handling of regularity.
4. Fix incorrect usage of BRepLib::EncodeRegularity() in BRepBuilderAPI_Sewing.
5. Implement a method for calculation of regularity on the given list of edges.
6. Documentation updates
1. The result of Boolean operation on the arguments of collection type, containers WIRE/SHELL/COMPSOLID, is also a collection.
The containers of type WIRE included into result should now also (as the SHELLs) have coherent orientation of its sub-shapes.
For that the new method has been implemented (BOPTools_AlgoTools::OrientEdgesOnWire(TopoDS_Shape&)) which reorients edges for correct ordering.
The duplicating containers, i.e. containers with the contents completely included in other containers, are now avoided in the result of BOP.
2. The result of Fuse operation on Compsolids is now also will be Compsolid.
3. Documentation has been updated.
4. New test cases for the issue.
5. Adjusting test cases to current behavior.
Correction of test case bugs/modalg_4/bug726_2 according to the new behavior
The method for building splits of the face BRepOffset_MakeOffset::BuildSplitsOfFace has been redesigned to use the BOPAlgo_BuilderFace algorithm directly.
The methods FindInvalidFaces and TrimNewIntersectionEdges have been corrected to avoid possible instabilities.
The filtering of invalid edges by existing bounding edges has been corrected to avoid removal of valid splits.
The method BRepOffset_Analyse::Correct2dPoint has been modified to avoid unnecessary initialization of BRepAdaptor_Surface.
Adjustment of the test cases.
Test case bugs modalg_6 bug26513 has been modified to unify faces of the input shape before operation.
BOPAlgo_CheckerSI crashed due to building of pcurve for an edge not lying on surface. The fix avoids building of pcurves in this algorithm.
The new flag has been added in BOPAlgo_PaveFiller class (method SetAvoidBuildPCurve). It tells whether to avoid building pcurves. It is worth to set if the result is not used to create splits of faces, as in example with BOPAlgo_CheckerSI.
The method BOPTools_AlgoTools2D::AttachExistingPCurve has been corrected so that
to call BRepLib::SameParameter not on the target edge with the whole set of pcurves,
but rather on a temporary edge with 3D curve and copied pcurve only.
After that the updated pcurve is transferred to the target edge.
Small correction of test case for issue CR28221
Several improvements have been made in BO code to fix the bug:
- Create empty edge-edge interference if intersection is close to an end vertex. This will help to avoid creation of unnecessary edge-face intersections.
- Improve PutPaveOnCurve() method to join nearly located vertices when they are put on the same section curve.
- Add processing of same-domain vertices for section edges in UpdatePaveBlocks() method.
- Improve the method CorrectWires() in order to not increase vertex tolerance if it will cover the major part of an edge.
- Replace vertices of section edges by same-domain equivalents.
- In the algorithm BOPAlgo_WireSplitter, correct angles computation and evaluation, taking into account periodicity.
- Modify PostTreatFF to properly take into account the orientations of coinciding section edges.
- In IntTools_Context::ComputePE, check distance from the point to vertices of the edge if the projection to the curve is failure.
Tests update:
- test offset\faces_type_i\C9 has been updated; now instead of returning bad shape it returns null result.
Notes for porting:
- Modify BopAlgo_PaveFiller so that on output each interference refers to the new vertex that will hit in the result (same-domain of the initial new vertex).
- Make the method BOPDS_DS::Index() returning valid index for new shapes.
// eliminate compile warning on VC14
Draw command 'proj' has been improved:
- Add possibility to pass the starting point. If it is passed than the algorithm Extrema_GenLocateExtPS is used instead of standard projection.
- Make the output of the command more clear.
Test case bugs/moddata_3/bug28196 has been added.
1. The possibility to prevent addition of internal parts has been added into the following algorithms:
- BOPAlgo_BuilderFace;
- BOPAlgo_BuilderSolid;
- BOPAlgo_MakerVolume.
Setting the option to avoid internal parts for MakerVolume algorithm guarantees that the result solids
will be manifold and not contain any internal parts. But it does not prevent from occurrence
of the internal edges or vertices in the faces.
2. The Set/Get methods of the BOPAlgo_BuilderArea class have been made inline.
3. Draw command mkvolume has been updated to take into account the new option.
4. BRepOffset_MakeOffset::BuildShellsCompleteInter() has been modified to use the new option of BOPAlgo_MakerVolume
to speed up the construction of the final result solid.
5. Documentation has been updated with new section dedicated to BOPAlgo_MakerVolume algorithm.
6. Test case for the issue.
1. Unification of the usage of the BRepAdaptor_Surface in Boolean Operations algorithm.
For each face when it is necessary the Adaptor is initialized only once and stored in Context.
For that purpose the new IntTools_Context::SurfaceAdaptor(const TopoDS_Face&) method has been implemented.
To provide possibility to take the Adaptor from the context, the context has been added as
a parameter in following methods:
BOPTools_AlgoTools::MakePCurve()
BOPTools_AlgoTools::Sence()
BOPTools_AlgoTools2D::BuildPCurveForEdgeOnFace()
BOPTools_AlgoTools2D::PointOnSurface
BOPTools_AlgoTools2D::CurveOnSurface
BOPTools_AlgoTools2D::AdjustPCurveOnFace
BOPTools_AlgoTools2D::Make2D
BOPTools_AlgoTools2D::MakePCurveOnFace
BOPTools_AlgoTools3D::GetNormalToFaceOnEdge
It is also possible now to pass the context into BOPAlgo_WireSplitter algorithm.
Also, the new IntTools_Context::UVBounds(const TopoDS_Face&) method
has been implemented to get the UV bounds of a face.
2. Additional improvement is a calculation of reduced intersection range only for the intersection
type VERTEX during computation of Edge/Face interference.
3. The methods IntTools_EdgeFace::Prepare() and IntTools_EdgeFace::FindProjectableRoot()
and the fields IntTools_EdgeFace::myProjectableRanges and IntTools_EdgeFace::myFClass2d
have been removed as obsolete.
4. Test cases for the issue.
The Gluing operation is an additional option for the algorithms in the Boolean Component
such as General Fuse, Boolean operations, Section operation, Maker Volume and Cells Builder algorithms.
The Gluing options have been designed to speed up the computation of the interference among arguments of the operations on special cases,
in which the arguments may be overlapping but do not have real intersections between their sub-shapes.
This option cannot be used on the shapes having real intersections, like intersection vertex between edges,
or intersection vertex between edge and a face or intersection line between faces.
The Gluing option is an enumeration implemented in BOPAlgo_GlueEnum.hxx. There are following items in the enum:
* BOPAlgo_GlueOff - default value for the algorithms, Gluing is switched off;
* BOPAlgo_GlueShift - Glue option for shapes with partial coincidence;
* BOPAlgo_GlueFull - Glue option for shapes with full coincidence.
For setting the Gluing options for the algorithm it is just necessary to call the SetGlue(BOPAlgo_GlueEnum) method with appropriate Glue value.
For using this option in DRAW the command bglue has been implemented:
* 0 - default value, Gluing is off;
* 1 - for partial coincidence;
* 2 - for full coincidence
Elimination of the warnings.
In the case of infinite point due to not enough machine precision the distance from the point to each edge of the face is computed the same, and the algorithm cannot correctly select the nearest edge. To solve this problem checking of point was added, if the point is located too far from the bounding box of the face, then it will be replaced with another point located on the line between the point and the center of the bounding box.
The new point has the same state as initial one but its state can be resolved without ambiguity.
Corrections in CheckPoint method
Small correction of test case for issue CR27434
The method BRepGProp_Face::LKnots has been corrected to make proper initialization of the output data for the case of a circle.
Added test case bugs/modalg_6/bug27033
The algorithm BRepExtrema_DistShapeShape has been protected against exceptions when non-geometric shape data is given on input, like a face containing triangulation only or an edge containing polygon only. Such faces/edges are ignored by the algorithm.
BRepGProps::VolumeProperties() now ignores faces without geometric surface to avoid access violation.
Check of the gap between ends of the p-curves having common vertex in the parametric space of face similar as in the class BRepCheck_Wire was added.
Check that face lies on the periodic surface was added.
Added check between ends of 2D curves in the 3D space and vertex the same which used in the BRepCheck_Wire::SelfIntersect
Test case for issue CR28094 has been created.
The whole piece of the walking line between two vertices is no more checked for having length greater than Precision::Confusion(). Instead, only full duplicate points (comparing with gp::Resolution()) are removed, allowing the resulting line have any non-null length.
The test bugs modalg_6 bug27720_5 has been reverted to its original state.
Problem of projection of line on the cone in the special case when starting point of the line coincides with the cone apex is fixed (by shifting this point along the source line).
Extension on the 3D Offset algorithm (Mode="Complete", Join Type = "Intersection")
for colliding cases to add support for new configurations of the shapes.
In the previous approach the result of the offset operation was build from
the offset faces using MakerVolume algorithm, without checking of the validity of these faces.
The new extension is based on this approach, but now the offset faces are being checked
on invalidity and rebuild in case of any. This allows (in case of successful rebuilding) to avoid creation
of the unforeseen parts such as dangling parts, spikes, inverted faces in the result of offset operation.
The main criteria for the validity of the faces is the coincidence of the normal
direction of the offset face with the normal direction of the original face.
Check for removal of invalid faces has been removed as obsolete.
BRepOffset_Inter2D: Avoid excess trimming of the edges due to coincidence with other edges.
BRepOffset_Inter3D: Careful treatment of the intersection of the faces connected only through vertices.
Eliminating the compiler warning.
Small corrections of test cases for issue CR26917
When fuzzy option is in force prevent increasing tolerance of input shapes. Instead pass increased by fuzzy value the tolerances of sub-shapes everywhere where it is needed by intersection algorithms.
The following changes in API have been made:
- The methods SetFuzzyValue and FuzzyValue have been moved from the classes BOPAlgo_ArgumentAnalyzer, BOPAlgo_Builder, and BOPAlgo_PaveFiller to the base class BOPAlgo_Algo.
- The public method BOPDS_DS::VerticesOnIn has been renamed to SubShapesOnIn, and the new output parameter theCommonPB has been added.
- In BOPTools_AlgoTools, a new argument "theFuzzyValue" has been added in the methods ComputeVV and AreFacesSameDomain.
- In IntTools_Context, a new argument "theFuzzyValue" has been added in the methods ComputeVE and ComputeVF.
- The methods SetFuzzyValue and FuzzyValue have been added in the classes IntTools_EdgeEdge, IntTools_FaceFace.
- In the class IntTools_EdgeFace, the methods SetTolE, SetTolF, TolE, TolF have been removed, and the methods SetFuzzyValue, FuzzyValue have been added.
- The new argument "theTol" has been added in the method IntTools_WLineTool::DecompositionOfWLine.
Some improvements in algorithms have been made during fighting with regressions:
- Correct initialization of pave blocks for degenerated edges.
- In BOPAlgo_PaveFiller::MakeBlocks(), filter out paves on intersection curve that were put on the curve accidentally due to wide range of E-F intersection vertex.
- In the method IntTools_Tools::ComputeTolerance the margin added to the computed tolerance has been increased up to 0.001%.
- The method BOPAlgo_PaveFiller::PutPaveOnCurve has been corrected in order to use the original vertex tolerance instead of the value increased during putting it on other curves.
- The new method BOPDS_PaveBlock::RemoveExtPave has been added.
- The vertex tolerance computation in BOPTools_AlgoTools::CorrectCurveOnSurface has been improved, taking into account intersection segments between p-curves (to avoid regression on "bugs modalg_6 bug22794").
- Improve IsExistingPaveBlock to make more stable catching of coincidence of common block with section curve (against regression "bugs modalg_4 bug697_2" on Linux).
Test case for the bug has been added.
The following test cases have been updated as improvements:
boolean gdml_private ZH2 ZI7 ZJ7
boolean volumemaker C4
The test case bugs/modalg_4/pro19653 has been corrected to make it stable. See comment inside the script for details.
The test case bugs/modalg_6/bug25880 has been corrected to suppress wrong bfuse commands.
The test bugs/modalg_6/bug26954_3 has been corrected to compare the result with more precise reference value.
The "faulty" TODO in boolean/volumemaker/A8 has been made actual for Linux as well.
//Eliminate compilation error on Linux.
The shape after scaling contains PCurves with incorrect parametrization, because of too large tolerance given.
1. Set Precision::PConfution() as a tolerance for GeomLib::SameRange.
2. Do not take into account tolerances of vertices while calculating tolerance of transformed PCurve for edge.
3. Test case bugs/modalg_6/bug28028
Checking of number of knots is added. If number of knots more then allowed value, algorithm does not search distance between curves for each knot interval, but uses predefined sample point distribution.
This change was born in the scope of work on the issue 26329, but does not have direct connection to it. Therefore it has been postponed to be integrated later in its own context.
Test case for issue #28030
Purger has been disabled (in IntPatch_PrmPrmIntersection algorithm) if some points have been added in the Walking line (it is stupidly, first, to insert some points in the line and, after that, to delete points from this line).
Some improvements in IntWalk_PWalking::SeekPointOnBoundary(...) method have been made (see comments in the code for detail information).
Some test cases have been adjusted according to their new behavior.
The method BRepOffsetAPI_MakePipeShell::Generated now returns generated shapes for sub-edges and sub-vertices of sections.
The method BRepFill_PipeShell::BuildHistory is redesigned: now it builds generated shapes for sub-edges and sub-vertices of sections.
New Draw command "gensweep" is added to sweep commands for testing of history building.
Check for null shape has been added in the command addsweep implementation.
// eliminate warning
Test case for issue CR24932
Test case has been corrected.
The algorithm in WorkWithBoundaries::BoundaryEstimation(...) did not take into account opposite directions of cylindrical axes (when the angle between them is obtuse). After the fix it does it.
Small correction of test cases for issue CR28009
The root of the problem is incorrect processing of cases when intersection line goes through the apex(es) of sphere. The fix improves this situation. The algorithm is taken from DecomposeResult(...) function (see IntPatch_ImpPrmIntersection.cxx file). Before the fix, faltering steps were done to solve this problem. As result, it worked in some particular cases. Now, its possibilities have been extended significantly.
Following changes have been made in the fix:
1. Class IntPatch_ALineToWLine has been rewritten cardinally. It touches as interfaces of existing methods as adding/removing some methods/fields. Correction touches both cases: going through seam of Cone/Sphere and through pole(s) of sphere. Old interface did not allow making some actions with analytical line (ALine), e.g. splitting it on several Walking-lines (WLine).
2. Restriction-line support has been removed from Implicit-Implicit intersection result (see IntPatch_Intersection::GeomGeomPerfom(...) method). It connects with the fact that the intersection algorithm itself returns precise intersection line in analytical cases (in compare with parametric intersector). Therefore, we do not need in additional (restriction) line.
3. New class IntPatch_SpecialPoints has been added. This class contains methods to add some special points (such as apex of cone, pole of sphere, point on surface boundary etc.) in intersection line (IntPatch_PointLine). It is based on the static functions, which already exist in IntPatch_ImpPrmIntersection.cxx file (these functions have been moved to the new class).
4. Method IntPatch_WLineTool::ExtendTwoWlinesToEachOther(...) has been renamed to IntPatch_WLineTool::ExtendTwoWLines(...). It is connected with changing main idea of the method. Now it allows extending WLine to the surface boundary or to the singular point (if it is possible): cone apex, sphere pole etc. Interface of this method has been corrected, too. At that, old functionality (extending to each other) has been kept. For implementation of this algorithm, new enumeration "IntPatchWT_WLsConnectionType" has been created.
5. Method IntPatch_PointLine::CurvatureRadiusOfIntersLine(...) has been added. See IntPatch_PointLine.hxx for detail information. It allows correct step computing depended on the local curvature of the intersection line. This method uses geometrical properties of intersected surfaces to compute local curvature. Therefore, it can be applied in wide range of cases even if the intersection curve is not represented in explicit form (e.g. in case of param-param-intersection).
6. Method IntSurf::SetPeriod(...) has been created.
7. Additional check has been added in Draft_Modification::Perform() method for better choice of correct fragment of intersection line for processing DRAFT operation.
8. New overload method IntPatch_Point::SetValue() has been added.
9. Some refactoring of the code has been made.
Creation of test case for issue #27431.
---------------------------------------------------------------------------------------------
Some test cases have been adjusted according to their new behavior.
tests\bugs\modalg_4\bug62
It is really IMPROVEMENT (but fortuitous).
tests\bugs\modalg_5\bug25838
The behavior of this test has been reverted to the state before fixing the issue #27341. Main problem has not been fixed in #27341. It was fortuitous improvement.
tests\bugs\moddata_2\bug565
Quality of intersection curve was not checked. And the curve is bad on both MASTER and FIX. Input data are really wrong: plane-like-cone. However, on the MASTER, four intersection curves (the quality is insignificant) are expected. On the fix, not empty intersection result is expected simply.
tests\boolean\volumemaker\A8
Differences in images and CPU is expected. Difference in images is expected to be fixed in the issue #26020. Now, we should apply this behavior.
Much CPU time is spent by IntTools_FaceFace::ComputeTolReached3d(...) and GeomInt_IntSS::BuildPCurves(...) methods calling. These methods are not touched by the algorithm. It is the result of change of intersection curve(s) form. However, the new Curve(s) seems to be valid and can be applied. As result, new behavior can be applied, too.
tests\boolean\volumemaker\F8
tests\boolean\volumemaker\F9
tests\boolean\volumemaker\G5
tests\boolean\volumemaker\G6
CPU difference is expected. Much CPU time is spent by IntPatch_PointLine::CurvatureRadiusOfIntersLine(...) method calling. This method is really new (it does not exist on the MASTER) and is really useful. Therefore, we should apply new behavior.
tests\boolean\volumemaker\G1
CPU difference is expected. Much CPU time is spent by IntTools_WLineTool::DecompositionOfWLine(...) and IntTools_FaceFace::ComputeTolReached3d(...) methods calling. These methods are not touched by the algorithm. It is the result of change of intersection curve(s) form. However, the new Curve(s) seems to be valid and can be applied. As result, new behavior can be applied, too.
tests\bugs\modalg_6\bug26619
Differences in images is expected. The test keeps its BAD status on the FIX. But the result on the fix is nearer to expected than on the MASTER. Issue #27014 is still actual. As before, it is not clear, why the number of entities is different. The number of section curves has not been changed. Interfered entities are the same as on the MASTER.
tests\bugs\modalg_5\bug25319_1(2)
The reason is described in the issue #27896.
Small correction in the test case
The SolidClassifier algorithm does not take into account the internal parts of the solid and its faces.
But in some cases the parts which are internal on some shapes can be included in other shapes of
the same solid with FORWARD/REVERSED orientation and therefore should be counted as well.
The fix changes the procedure of the initialization of the tree of bounding boxes of the edges and
vertices of the solid in SolidExplorer algorithm to treat the internal/external parts of the solid correctly.
Avoid getting non-existing array items. Use reference to array items instead of pointers where it is possible.
Create test case. Before the fix this test raised exception in debug mode.
Method WorkWithBoundaries::BoundaryEstimation(...) has been brought in balance with IsParallel(...) method, which checks if cylinder axes are parallel.
