Welcome to Open CASCADE Technology (OCCT), a software development platform
providing services for 3D surface and solid modeling, CAD data exchange, and
@@ -13,12 +8,11 @@ visualization. Most of OCCT functionality is available in the form of C++
libraries. OCCT can be best applied in development of software dealing with 3D
modeling (CAD), manufacturing / measuring (CAM) or numerical simulation (CAE).
-@htmlonly
+
+
-* @ref intro_overview_fclasses "Foundation Classes" module underlies all other OCCT classes;
-* @ref intro_overview_moddata "Modeling Data" module supplies data structures to represent 2D and 3D geometric primitives and their compositions into CAD models;
-* @ref intro_overview_modalgo "Modeling Algorithms" module contains a vast range of geometrical and topological algorithms;
- * @ref intro_overview_mesh "Mesh" toolkit from "Modeling Algorithms" module implements tessellated representations of objects;
-* @ref intro_overview_visu "Visualization" module provides complex mechanisms for graphical data representation;
-* @ref intro_overview_de "Data Exchange" module inter-operates with popular data formats and relies on @ref intro_overview_heal "Shape Healing" to improve compatibility between CAD software of different vendors;
-* @ref intro_overview_ocaf "Application Framework" module offers ready-to-use solutions for handling application-specific data (user attributes) and commonly used functionality (save/restore, undo/redo, copy/paste, tracking CAD modifications, etc).
+* [Foundation Classes](#intro_overview_fclasses) module underlies all other OCCT classes;
+* [Modeling Data](#intro_overview_moddata) module supplies data structures to represent 2D and 3D geometric primitives and their compositions into CAD models;
+* [Modeling Algorithms](#intro_overview_modalgo) module contains a vast range of geometrical and topological algorithms;
+ * [Mesh](#intro_overview_mesh) toolkit from "Modeling Algorithms" module implements tessellated representations of objects;
+* [Visualization](#intro_overview_visu) module provides complex mechanisms for graphical data representation;
+* [Data Exchange](#intro_overview_de) module inter-operates with popular data formats and relies on [Shape Healing](#intro_overview_heal) to improve compatibility between CAD software of different vendors;
+* [Application Framework](#intro_overview_ocaf) module offers ready-to-use solutions for handling application-specific data (user attributes) and commonly used functionality (save/restore, undo/redo, copy/paste, tracking CAD modifications, etc).
-In addition, @ref intro_overview_draw "Open CASCADE Test Harness", also called Draw, provides an entry point to the library and can be used as a testing tool for its modules.
+In addition, [Open CASCADE Test Harness](#intro_overview_draw), also called Draw, provides an entry point to the library and can be used as a testing tool for its modules.
-@subsection intro_overview_fclasses Foundation Classes
+
* Boolean Operations, which allow creating new shapes from the combinations of source shapes. For two shapes *S1* and *S2*:
* *Common* contains all points that are in *S1* and *S2*;
* *Fuse* contains all points that are in *S1* or *S2*;
* *Cut* contains all points in that are in *S1* and not in *S2*.
-See @ref specification__boolean_operations "Boolean Operations" User's Guide for detailed documentation.
+See [Boolean Operations](boolean_operations#specification__boolean_operations) User's Guide for detailed documentation.
* Algorithms for local modifications such as:
* Hollowing;
@@ -160,11 +154,11 @@ See @ref specification__boolean_operations "Boolean Operations" User's Guide for
* Algorithms for creation of mechanical features, i.e. depressions, protrusions, ribs and grooves or slots along planar or revolution surfaces.
-@figure{/introduction/images/0004.png}
+
-See the details in @ref occt_user_guides__modeling_algos "Modeling Algorithms User's Guide".
+See the details in [Modeling Algorithms User's Guide](modeling_algos#occt_user_guides__modeling_algos).
-@subsection intro_overview_mesh Mesh
+
-@subsection intro_overview_visu Visualization
+
* Support of built-in and application-specific GLSL shaders.
-@figure{/introduction/images/0013.png, "Fragment shader implementing custom clipping surface"}
+
+ 
* Optimization of rendering performance through the algorithms of:
* View frustum culling, which skips the presentation outside camera at the rendering stage;
* Back face culling, which reduces the rendered number of triangles and eliminates artifacts at shape boundaries.
* Real-time ray tracing technique using recursive Whitted's algorithm and Bounded Volume Hierarchy effective optimization structure.
-@figure{introduction/images/0002.png, "Real time visualization by ray tracing method"}
-@figure{introduction/images/0012.png, "Simulation of a glass cover"}
-For more details, see @ref occt_user_guides__visualization "Visualization User's Guide".
+ 
+
+ 
+
+For more details, see [Visualization User's Guide](visualization#occt_user_guides__visualization).
-The visualization of OCCT topological shapes by means of VTK library provided by VIS component is described in a separate @ref occt_user_guides__vis "VTK Integration Services" User's Guide.
+The visualization of OCCT topological shapes by means of VTK library provided by VIS component is described in a separate [VTK Integration Services](vis#occt_user_guides__vis) User's Guide.
-@subsection intro_overview_de Data Exchange
+
**Data Exchange** is organized in a modular way as a set of interfaces that comply with various CAD formats: IGES, STEP, STL, VRML, etc.
The interfaces allow software based on OCCT to exchange data with various CAD/PDM software packages, maintaining a good level of interoperability.
@@ -231,16 +229,16 @@ This module handles various problems of interoperability between CAD systems, ca
* **Standardized Data Exchange** interfaces allow querying and examining the input file, converting its contents to a CAD model and running validity checks on a fully translated shape.
The following formats are currently supported:
- * @ref occt_user_guides__step "STEP" (AP203: Mechanical Design, this covers General 3D CAD; AP214: Automotive Design; AP242).
- * @ref occt_iges_1 "IGES" (up to 5.3).
+ * [STEP](step#occt_user_guides__step) (AP203: Mechanical Design, this covers General 3D CAD; AP214: Automotive Design; AP242).
+ * [IGES](iges#occt_iges_1) (up to 5.3).
* **glTF** 2.0 reader and writer.
* **OBJ** mesh file reader and writer.
* **VRML** converter translates Open CASCADE shapes to VRML 1.0 files (Virtual Reality Modeling Language).
* **STL** converter translates Open CASCADE shapes to STL files.
STL (STtereoLithography) format is widely used for rapid prototyping (3D printing).
-* @ref occt_user_guides__xde "Extended data exchange" (XDE) allows translating additional attributes attached to geometric data (colors, layers, names, materials etc).
+* [Extended data exchange](xde#occt_user_guides__xde) (XDE) allows translating additional attributes attached to geometric data (colors, layers, names, materials etc).
* Advanced Data Exchange Components
- are available in addition to standard Data Exchange interfaces to support interoperability and data adaptation (also using @ref intro_overview_heal "Shape Healing") with CAD software using the following proprietary formats:
+ are available in addition to standard Data Exchange interfaces to support interoperability and data adaptation (also using [Shape Healing](#intro_overview_heal)) with CAD software using the following proprietary formats:
* ACIS SAT
* Parasolid
* DXF
@@ -249,7 +247,7 @@ This module handles various problems of interoperability between CAD systems, ca
These components are based on the same architecture as interfaces with STEP and IGES.
-@subsection intro_overview_heal Shape Healing
+
The contents of the OCCT-7.4.0 directory (called further "OCCT root", or $CASROOT) are as follows:
-@figure{/introduction/images/overview_installation.png, "The directory tree"}
+
* **adm** This folder contains administration files, which allow rebuilding OCCT;
* **adm/cmake** This folder contains files of CMake building procedure;
@@ -443,18 +441,18 @@ The contents of the OCCT-7.4.0 directory (called further "OCCT root", or $CASROO
* **tools** This folder contains sources of Inspector tool.
* **win64/vc14** This folder contains executable and library files built in optimize mode for Windows platform by Visual C++ 2015;
-@subsection intro_install_linux Linux
+
-@c PrsMgr_PresentableObject::Compute() method takes three arguments:
-- **Presentation Manager** (@c PrsMgr_PresentationManager).
+`PrsMgr_PresentableObject::Compute()` method takes three arguments:
+- **Presentation Manager** (`PrsMgr_PresentationManager)`.
Rarely used parameter, but might be necessary for some advanced use cases.
-- **Presentation** (@c Prs3d_Presentation or @c Graphic3d_Structure).
+- **Presentation** (`Prs3d_Presentation` or `Graphic3d_Structure)`.
Defines the structure to fill in with presentation elements.
- **Display Mode** (integer number).
Specifies the display mode to compute.
- **0** is a default display mode, if not overridden by @c AIS_InteractiveObject::SetDisplayMode() or by @c AIS_InteractiveContext::Display().
+ **0** is a default display mode, if not overridden by `AIS_InteractiveObject::SetDisplayMode()` or by `AIS_InteractiveContext::Display()`.
-For each supported display mode, the **Presentation Manager** creates a dedicated @c Prs3d_Presentation and stores it within the object itself as a list of presentations @c PrsMgr_PresentableObject::Presentations().
-It is a good practice to reject unsupported display modes within @c @::Compute() method:
+For each supported display mode, the **Presentation Manager** creates a dedicated `Prs3d_Presentation` and stores it within the object itself as a list of presentations `PrsMgr_PresentableObject::Presentations()`.
+It is a good practice to reject unsupported display modes within `::Compute()` method:
~~~~{.cpp}
void MyAisObject::Compute (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
@@ -103,8 +100,8 @@ Handle(MyAisObject) aPrs = new MyAisObject();
theCtx->Display (aPrs, 100, -1, true);
~~~~
-The code above will display @c MyAisObject with display mode equal to 100, and after @c @::Compute() modifications nothing will be displayed on the screen.
-@c AIS will still create a presentation with specified display mode, but it will be empty - method @c @::AcceptDisplayMode() could be overridden to disallow even creation of an empty presentation:
+The code above will display `MyAisObject` with display mode equal to 100, and after `::Compute()` modifications nothing will be displayed on the screen.
+`AIS` will still create a presentation with specified display mode, but it will be empty - method `::AcceptDisplayMode()` could be overridden to disallow even creation of an empty presentation:
~~~~{.cpp}
bool MyAisObject::AcceptDisplayMode (const Standard_Integer theMode) const
@@ -113,8 +110,8 @@ bool MyAisObject::AcceptDisplayMode (const Standard_Integer theMode) const
}
~~~~
-@c AIS_InteractiveContext::Display() checks if requested display mode is actually supported by the object, and uses default display mode (_**0**_) if it is not.
-@c StdPrs_ShadedShape prepares a shaded (triangulated) presentation of a shape, while @c StdPrs_WFShape creates a wireframe presentation with B-Rep wire boundaries:
+`AIS_InteractiveContext::Display()` checks if requested display mode is actually supported by the object, and uses default display mode (_**0**_) if it is not.
+`StdPrs_ShadedShape` prepares a shaded (triangulated) presentation of a shape, while `StdPrs_WFShape` creates a wireframe presentation with B-Rep wire boundaries:
~~~~{.cpp}
void MyAisObject::Compute (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
@@ -129,13 +126,13 @@ void MyAisObject::Compute (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
}
~~~~
-@figure{ais_object_step1_shaded_wf.png,"Result of @c StdPrs_ShadedShape + @c StdPrs_WFShape presentation builders.",409} height=409px
+
-Presentation builders take the @c Prs3d_Drawer object defining various attributes - material of shaded shape, number of isolines in wireframe mode, tessellation quality, line colors and many others.
-@c PrsMgr_PresentableObject defines @c myDrawer property with default attributes.
-@c StdPrs makes it easy to display topological shapes.
-With the help of @c Prs3d tools we may display elements like arrows, boxes or text labels.
-Let's extend our presentation with a second **display mode 1** showing a bounding box using @c Prs3d_BndBox builder:
+Presentation builders take the `Prs3d_Drawer` object defining various attributes - material of shaded shape, number of isolines in wireframe mode, tessellation quality, line colors and many others.
+`PrsMgr_PresentableObject` defines `myDrawer` property with default attributes.
+`StdPrs` makes it easy to display topological shapes.
+With the help of `Prs3d` tools we may display elements like arrows, boxes or text labels.
+Let's extend our presentation with a second **display mode 1** showing a bounding box using `Prs3d_BndBox` builder:
~~~~{.cpp}
bool MyAisObject::AcceptDisplayMode (const Standard_Integer theMode) const
@@ -169,12 +166,12 @@ Handle(MyAisObject) aPrs = new MyAisObject();
theCtx->Display (aPrs, 1, 0, true);
~~~~
-@figure{ais_object_step1_bndbox.png,"@c Prs3d_BndBox presentation builder.",409} height=409px
+
-@c AIS disallows activating multiple display modes at the same time, so that these presentation modes should be alternatives to each other.
-But @c AIS may use non-active display mode for highlighting purposes - like wireframe (@c AIS_Wireframe) presentation displayed on top of shaded (@c AIS_Shaded) presentation for selected @c AIS_Shape objects.
+`AIS` disallows activating multiple display modes at the same time, so that these presentation modes should be alternatives to each other.
+But `AIS` may use non-active display mode for highlighting purposes - like wireframe (`AIS_Wireframe)` presentation displayed on top of shaded (`AIS_Shaded)` presentation for selected `AIS_Shape` objects.
-Let's define a dedicated enumeration for display modes supported by our interactive object and setup the 1st (@c MyDispMode_Highlight) display mode for highlighting with help of @c PrsMgr_PresentableObject::SetHilightMode():
+Let's define a dedicated enumeration for display modes supported by our interactive object and setup the 1st (`MyDispMode_Highlight)` display mode for highlighting with help of `PrsMgr_PresentableObject::SetHilightMode():`
~~~~{.cpp}
class MyAisObject : public AIS_InteractiveObject
@@ -199,33 +196,33 @@ theCtx->HilightWithColor (aPrs, aPrs->HilightAttributes(), false);
theCtx->CurrentViewer()->Redraw();
~~~~
-@figure{ais_object_step1_highlight.png,"Highlighting by color (left) and highlighting by another display mode (right).",818} height=409px
+
-In this particular use case we've used the method @c AIS_InteractiveContext::HilightWithColor() instead of @c @::SetSelected() - just because our object is not selectable yet and @c @::SetSelected() wouldn't work.
+In this particular use case we've used the method `AIS_InteractiveContext::HilightWithColor()` instead of `::SetSelected()` - just because our object is not selectable yet and `::SetSelected()` wouldn't work.
Highlighted presentation appears on the screen with modulated color (see left screenshot above).
Using a dedicated display mode for highlighting (right screenshot above) allows customizing presentation in selected / highlighted states.
-@section prim_arrays Primitive arrays
+
The process is quite straightforward:
-- Create a new @c Graphic3d_Group using @c Prs3d_Presentation::NewGroup();
-- Specify presentation aspects using @c Graphic3d_Group::SetGroupPrimitivesAspect();
-- Create and add an array of primitives using @c Graphic3d_Group::AddPrimitiveArray().
+- Create a new `Graphic3d_Group` using `Prs3d_Presentation::NewGroup();`
+- Specify presentation aspects using `Graphic3d_Group::SetGroupPrimitivesAspect();`
+- Create and add an array of primitives using `Graphic3d_Group::AddPrimitiveArray()`.
-Standard presentation builders like @c StdPrs_ShadedShape / @c StdPrs_WFShape internally do exactly the same thing - a tessellated representation of a shape is added to presentation in form of triangles (shaded),
+Standard presentation builders like `StdPrs_ShadedShape` / `StdPrs_WFShape` internally do exactly the same thing - a tessellated representation of a shape is added to presentation in form of triangles (shaded),
line segments (wireframe and free edges) and markers (free shape vertices).
-A single @c Graphic3d_Group normally defines just a single primitive array, but it is technically possible adding more arrays to the same group @c Graphic3d_Group::AddPrimitiveArray()
-and with different aspects @c Graphic3d_Group::SetPrimitivesAspect(), which might be considered in advanced scenarios.
+A single `Graphic3d_Group` normally defines just a single primitive array, but it is technically possible adding more arrays to the same group `Graphic3d_Group::AddPrimitiveArray()`
+and with different aspects `Graphic3d_Group::SetPrimitivesAspect()`, which might be considered in advanced scenarios.
-Method @c Graphic3d_Group::AddText() allows adding text labels to a presentation.
+Method `Graphic3d_Group::AddText()` allows adding text labels to a presentation.
Internally, text labels are rendered as an array of textured triangles using texture atlas created from a font, but this complex logic is hidden from the user.
-@section prim_aspects Primitive aspects
+
Well... that looks a little bit edgy.
Quadric builder creates a triangulation taking the following parameters:
@@ -362,21 +359,22 @@ Quadric builder creates a triangulation taking the following parameters:
(in case of a cylinder - base radius, top radius and height).
- Number of subdivisions along U (slices) and V (stacks) parameters.
In some cases only one parametric scope matters.
-- Transformation @c gp_Trsf to apply
+- Transformation `gp_Trsf` to apply
(original geometry is defined within some reference coordinate system).
Let's increase number of subdivisions from _10_ to _25_:
+
~~~~{.cpp}
Handle(Graphic3d_ArrayOfTriangles) aTris =
Prs3d_ToolCylinder::Create (aRadius, aRadius, aHeight, 25, 25, gp_Trsf());
~~~~
-@figure{ais_object_step3_quadrics_25.png,"@c Prs3d_ToolCylinder (25 slices).",409} height=409px
+
-It looks much better now! Note that @c Prs3d_ToolCylinder could be used for building both cones and cylinders depending on top/bottom radius definition.
+It looks much better now! Note that `Prs3d_ToolCylinder` could be used for building both cones and cylinders depending on top/bottom radius definition.
There is one issue though - our cylinder doesn't have top and bottom anymore!
-To fix this problem we will use one more quadric builder @c Prs3d_ToolDisk:
+To fix this problem we will use one more quadric builder `Prs3d_ToolDisk:`
~~~~{.cpp}
void MyAisObject::Compute (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
@@ -414,9 +412,9 @@ Now our cylinder looks solid! The sample above merges two triangulations into a
This looks like a minor difference, but it might have a _dramatic impact on performance_ in case of a large scene,
as each `Graphic3d_ArrayOfPrimitives` is mapped into a dedicated draw call at graphic driver (OpenGL) level.
-@figure{ais_object_step3_quadrics_fin.png,"@c Prs3d_ToolCylinder + @c Prs3d_ToolDisk.",409} height=409px
+
-As an exercise, let's try computing a triangulation for cylinder disk without help of @c Prs3d_ToolDisk builder:
+As an exercise, let's try computing a triangulation for cylinder disk without help of `Prs3d_ToolDisk` builder:
~~~~{.cpp}
void MyAisObject::Compute (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
@@ -456,24 +454,25 @@ void MyAisObject::Compute (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
}
~~~~
-@figure{ais_object_step3_quadrics_disk.png,"Manually triangulated disk.",409} height=409px
+
The disk is here, but it has a strange color - like it is not affected by lighting.
This happens when vertex normals are defined incorrectly.
-In our case we defined disk normal as @c -DZ (see the second argument of @c Graphic3d_ArrayOfTriangles::AddVertex()),
+In our case we defined disk normal as `-DZ` (see the second argument of `Graphic3d_ArrayOfTriangles::AddVertex())`,
but normal direction should be also aligned to triangulation winding rule.
-Graphic driver defines the front side of triangle using clockwise order of triangle nodes, and normal should be defined for a front side of triangle - e.g. it should be @c gp::DZ() in our case.
-After reversing vertex normal direction, cylinder looks exactly like when @c Prs3d_ToolDisk was used.
+Graphic driver defines the front side of triangle using clockwise order of triangle nodes, and normal should be defined for a front side of triangle - e.g. it should be `gp::DZ()` in our case.
+After reversing vertex normal direction, cylinder looks exactly like when `Prs3d_ToolDisk` was used.
+
+Front / back face orientation might be displayed using different material based on `Graphic3d_Aspects::SetDistinguish()` flag and `::FrontMaterial()` / `::BackMaterial()` setup.
-Front / back face orientation might be displayed using different material based on @c Graphic3d_Aspects::SetDistinguish() flag and @c @::FrontMaterial() / @c @::BackMaterial() setup.
+
-Now, let's override the @c SelectMgr_EntityOwner::HilightWithColor() method and display a bounding box presentation:
+Now, let's override the `SelectMgr_EntityOwner::HilightWithColor()` method and display a bounding box presentation:
~~~~{.cpp}
void MyAisOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
@@ -655,14 +654,14 @@ void MyAisOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager)& the
}
~~~~
-@c SelectMgr_EntityOwner::HilightWithColor() doesn't receive a presentation to fill in as an argument; highlight presentation should be manually created and even explicitly displayed on the screen.
-To avoid code duplication, the code above reuses @c MyAisObject::Compute() already implementing computation of highlight presentation.
+`SelectMgr_EntityOwner::HilightWithColor()` doesn't receive a presentation to fill in as an argument; highlight presentation should be manually created and even explicitly displayed on the screen.
+To avoid code duplication, the code above reuses `MyAisObject::Compute()` already implementing computation of highlight presentation.
-@figure{ais_object_step4_highlight2.png,"Result of custom implementation @c MyAisOwner::HilightWithColor().",409} height=409px
+
The visual result of the selected object looks exactly the same as when we've used a dedicated highlight mode.
One thing became broken, though - highlighting remains displayed even after clearing selection.
-To fix this issue, we need implementing @c SelectMgr_EntityOwner::Unhilight() and hide our custom presentation explicitly:
+To fix this issue, we need implementing `SelectMgr_EntityOwner::Unhilight()` and hide our custom presentation explicitly:
~~~~{.cpp}
void MyAisOwner::Unhilight (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
@@ -673,8 +672,8 @@ void MyAisOwner::Unhilight (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
~~~~
Another problem is that the object is no longer dynamically highlighted.
-To fix that we need to handle @c PrsMgr_PresentationManager::IsImmediateModeOn() specifically.
-Within this mode turned ON, presentation should be displayed on the screen with help of @c PrsMgr_PresentationManager::AddToImmediateList() method
+To fix that we need to handle `PrsMgr_PresentationManager::IsImmediateModeOn()` specifically.
+Within this mode turned ON, presentation should be displayed on the screen with help of `PrsMgr_PresentationManager::AddToImmediateList()` method
(it will be cleared from the screen automatically on the next mouse movement):
~~~~{.cpp}
@@ -703,7 +702,7 @@ void MyAisOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager)& the
}
~~~~
-We may create two dedicated presentations for dynamic highlighting or reuse existing one for both cases with help of a transient object @c Prs3d_PresentationShadow.
+We may create two dedicated presentations for dynamic highlighting or reuse existing one for both cases with help of a transient object `Prs3d_PresentationShadow`.
Let's go further and make dynamic highlighting a little bit more interesting - by drawing a surface normal at the point where mouse picked the object:
@@ -744,22 +743,22 @@ void MyAisOwner::HilightWithColor (const Handle(PrsMgr_PresentationManager)& the
}
~~~~
-Code above does not store our new highlight presentation as a property of @c MyAisOwner, and instead uses @c SelectMgr_SelectableObject::GetHilightPresentation() method
+Code above does not store our new highlight presentation as a property of `MyAisOwner`, and instead uses `SelectMgr_SelectableObject::GetHilightPresentation()` method
to create a presentation stored directly inside of our interactive object.
-Next trick is passing through the last picking results in @c StdSelect_ViewerSelector.
+Next trick is passing through the last picking results in `StdSelect_ViewerSelector`.
Dynamic highlighting is expected to be called right after picking, so that highlighted Owner should be always found in picking results.
-@c StdSelect_ViewerSelector::Picked() returns entities in the descending order of their distance from picking ray origin (mouse cursor);
-normally our Owner should be the very first one in this list when no selection filters are assigned to @c AIS_InteractiveContext.
+`StdSelect_ViewerSelector::Picked()` returns entities in the descending order of their distance from picking ray origin (mouse cursor);
+normally our Owner should be the very first one in this list when no selection filters are assigned to `AIS_InteractiveContext`.
-@c SelectMgr_SortCriterion provides us useful information like 3D point on detected object lying on the picking ray, and surface normal direction at this point (actually, it would be a normal to a picked triangle),
-which we display as an arrow with help of @c Prs3d_Arrow presentation builder.
+`SelectMgr_SortCriterion` provides us useful information like 3D point on detected object lying on the picking ray, and surface normal direction at this point (actually, it would be a normal to a picked triangle),
+which we display as an arrow with help of `Prs3d_Arrow` presentation builder.
-@figure{ais_object_step4_highlight3.png,"Surface normal on mouse over.",409} height=409px
+
Result looks pretty nice on the screenshot, but has interaction problems - once displayed, an arrow is no longer updated with further mouse movements.
-But this behavior is not a bug - @c AIS calls @c MyAisOwner::HilightWithColor() only when picking Owner changes to avoid unnecessary Viewer updates.
-To override this behavior, we may override @c SelectMgr_EntityOwner::IsForcedHilight() option:
+But this behavior is not a bug - `AIS` calls `MyAisOwner::HilightWithColor()` only when picking Owner changes to avoid unnecessary Viewer updates.
+To override this behavior, we may override `SelectMgr_EntityOwner::IsForcedHilight()` option:
~~~~{.cpp}
class MyAisOwner : public SelectMgr_EntityOwner
@@ -773,52 +772,52 @@ This solves the problem within our specific use case.
Keep in mind that most objects don't need updating highlight presentation on every mouse move;
overriding this flag everywhere would be a waste of resources and may cause performance issues - use it sparingly.
-@section highlight_apporaches Highlighting approaches
+
This Figure shows that
* Bcommon (S1, S2) = Sp12;
@@ -79,9 +76,9 @@ This Figure shows that
The fact that *RGF* contains the components of *RB* allows considering GFA as the general case of BOA. So it is possible to implement BOA as a subclass of GFA.
-For more details see @ref specification__boolean_7 "General Fuse Algorithm" section.
+For more details see [General Fuse Algorithm](#specification__boolean_7) section.
-@subsubsection specification__boolean_2_1_3 Splitter operator
+
The result is a new vertex *Vn* with 3D point *Pn* and tolerance value Tol(Vn).
The coordinates of *Pn* and the value Tol(Vn) are computed as the center and the radius of the sphere enclosing the tolerance spheres of the source vertices (V1, V2).
-@subsubsection specification__boolean_3_1_2 Vertex/Edge interference
+
The result is vertex *Vi* with the corresponding tolerance value Tol(Vi)=Max(Tol(Vi), D+Tol(Ej)), where D = distance (Pi, PPi);
and parameter *ti* of the projected point *PPi* on 3D curve *Cj* of edge *Ej*.
-@subsubsection specification__boolean_3_1_3 Vertex/Face interference
+
The result is vertex *Vi* with the corresponding tolerance value Tol(Vi)=Max(Tol(Vi), D+Tol(Fj)), where D = distance (Pi, PPi)
and parameters ui, vi of the projected point *PPi* on surface *Sj* of face *Fj*.
-@subsubsection specification__boolean_3_1_4 Edge/Edge interference
+
The results are:
* Parametric range [ti1, ti2 ] for 3D curve *Ci* of edge *Ei*.
@@ -200,7 +197,7 @@ The results are:
In the second case two edges have one or several common points in terms of tolerance.
-@figure{/specification/boolean_operations/images/operations_image006.svg,"Edge/edge interference: common points",420}
+
The result is a new vertex *Vn* with 3D point *Pn* and tolerance value *Tol(Vn)*.
@@ -209,7 +206,7 @@ The coordinates of *Pn* and the value *Tol(Vn)* are computed as the center and t
* Parameter *ti* of *Pi* for the 3D curve *Ci*.
* Parameter *tj* of *Pj* for the 3D curve *Cj*.
-@subsubsection specification__boolean_3_1_5 Edge/Face interference
+
The result is a parametric range [ti1, ti2] for the 3D curve *Ci* of the edge *Ei*.
In the second case Edge *Ei* and Face *Fj* have one or several common points in terms of tolerance.
-@figure{/specification/boolean_operations/images/operations_image008.svg,"Edge/face interference: common points",420}
+
The result is a new vertex *Vn* with 3D point *Pn* and tolerance value *Tol(Vn)*.
@@ -232,15 +229,15 @@ The coordinates of *Pn* and the value *Tol(Vn)* are computed as the center and t
* Parameter *ti* of *Pi* for the 3D curve *Ci*.
* Parameters *ui* and *vi* of the projected point *PPi* on the surface *Sj* of the face *Fj*.
-@subsubsection specification__boolean_3_1_6 Face/Face Interference
+
In the first case the result contains intersection curves *Cijk (k = 0, 1, 2…kN,* where *kN* is the number of intersection curves with corresponding values of tolerances *Tol(Cijk)*.
-@figure{/specification/boolean_operations/images/operations_image010.svg,"Face/face interference: common points",305}
+
In the second case Face *Fi* and face *Fj* have one or several new vertices *Vijm*, where m=0,1,2, ... mN, mN is the number of intersection points.
@@ -249,32 +246,32 @@ The coordinates of a 3D point *Pijm* and the value *Tol(Vijmj*, *vj* belong to point *PPj* projected on surface *Sj* of face *Fj*.
* Parameters *ui* and *vi* belong to point *PPi* projected on surface *Si* of face *Fi*.
-@subsubsection specification__boolean_3_1_7 Vertex/Solid Interference
+
-@subsubsection specification__boolean_3_1_8 Edge/Soild Interference
+
-@subsubsection specification__boolean_3_1_9 Face/Soild Interference
+
-@subsubsection specification__boolean_3_1_10 Solid/Soild Interference
+
-@subsubsection specification__boolean_3_1_11 Computation Order
+
-Two paves *PV1* and *PV2* on the same curve *C* can be compared using the parameter value @code PV1 > PV2 if t1 > t2 @endcode
+Two paves *PV1* and *PV2* on the same curve *C* can be compared using the parameter value ``` PV1 > PV2 if t1 > t2 ```
The usage of paves allows binding of the vertex to the curve (or any structure that contains a curve: edge, intersection curve).
-@subsection specification__boolean_3_3 Pave Blocks
+
Any finite source edge *E* has at least one pave block that contains two paves *PVb* and *PVe*:
* Pave *PVb* corresponds to the vertex *Vb* with minimal parameter tb on the curve of the edge.
* Pave *PVe* corresponds to the vertex *Ve* with maximal parameter te on the curve of the edge.
-@subsection specification__boolean_3_4 Shrunk Range
+
The theoretical parametric range of the pave block is [t1C, t2C].
@@ -343,20 +340,20 @@ The Figure shows that each tolerance sphere of a vertex can reduce the parametri
The shrunk range of the pave block is the part of 3D curve that can interfere with other shapes.
-@subsection specification__boolean_3_5 Common Blocks
+
If the pave blocks PB1, PB2…PBNbPB , where *NbPB* is the number of pave blocks have the same bounding vertices and geometrically coincide, the pave blocks form common block *CB*.
In case of Edge/Face interference the common parts are pave blocks lying on a face(s).
-@figure{/specification/boolean_operations/images/operations_image015.svg,"Common Blocks: Edge/Face interference",265}
+
If the pave blocks *PBi* geometrically coincide with a face *Fj*, the pave blocks form common block *CB*.
@@ -365,7 +362,7 @@ In general case a common block *CB* contains:
* A set of faces *Fj (j=0,1... NbF), NbF* -- number of faces.
-@subsection specification__boolean_3_6 FaceInfo
+
In the figure, for face *F1*:
* Pave blocks that have state **In** for the face: *PBin1*.
@@ -386,7 +383,7 @@ In the figure, for face *F1*:
* Vertices built up from intersection points for the face: none
-@section specification__boolean_4 Data Structure
+
-@subsection specification__boolean_4_4 Pave, PaveBlock and CommonBlock
+
The description provided in the next paragraphs is coherent with the implementation of the method *BOPAlgo_PaveFiller::Perform()*.
-@subsection specification__boolean_5_1 Initialization
+
-@subsection specification__boolean_5_3 Compute Vertex/Edge Interferences
+
* The pairs of coincided pave blocks are: (PB11, PB12), (PB11, PB13), (PB12, PB13), (PB21, PB22), (PB21, PB23), (PB22, PB23).
* The pairs produce two chains: (PB11, PB12, PB13) and (PB21, PB22, PB23).
-@subsection specification__boolean_5_6 Compute Vertex/Face Interferences
+
The class *BOPAlgo_BuilderShape* provides the interface for algorithms that have:
* A Shape as the result;
* History information (in terms of \::Generated(), \::Modified() and \::IsDeleted()).
-@section specification__boolean_7 General Fuse Algorithm
-@subsection specification__boolean_7_1 Arguments
-The arguments of the algorithm are shapes (in terms of *TopoDS_Shape*). The main requirements for the arguments are described in @ref specification__boolean_4 "Data Structure" chapter.
+
The result of the GFA operation is a compound containing 6 new edges: *E11, E12, E21, E22, E31*, and *E32*. These edges have one shared vertex *Vn1*.
@@ -921,11 +928,11 @@ In this case:
* The argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
* The argument edge *E3* has resulting split edges *E31* and *E32* (image of *E3*).
-@subsubsection specification__boolean_7_3_2 Case 2: Two wires and an edge
+
The result of the GF operation is a compound consisting of 2 wires: *Wn1 (Ew11, En1, En2, En3, Ew13)* and *Wn2 (Ew21, En2, En3, En4, Ew23)* and two edges: *E11* and *E12*.
@@ -935,88 +942,88 @@ In this case :
* The argument edge *E1* has split edges *E11* and *E12*. (image of *E1*).
The edges *En1, En2, En3, En4* and vertex *Vn1* are new shapes created during the operation. Edge *Ew12* has split edges *En1, En2* and *En3* and edge *Ew22* has split edges *En2, En3* and *En4*.
-@subsubsection specification__boolean_7_3_3 Case 3: An edge intersecting with a face
+
The result of the GF operation is a compound consisting of 3 shapes:
* Split edge parts *E11* and *E12* (image of *E1*).
* New face *F21* with internal edge *E12* (image of *F2*).
-@subsubsection specification__boolean_7_3_4 Case 4: An edge lying on a face
+
The result of the GF operation is a compound consisting of 5 shapes:
* Split edge parts *E11, E12* and *E13* (image of *E1*).
* Split face parts *F21* and *F22* (image of *F2*).
-@subsubsection specification__boolean_7_3_5 Case 5: An edge and a shell
+
The result of the GF operation is a compound consisting of 5 shapes:
* Split edge parts *E11, E12 , E13* and *E14* (image of *E1*).
* Image shell *Sh21* (that contains split face parts *F211, F212, F221* and *F222*).
-@subsubsection specification__boolean_7_3_6 Case 6: A wire and a shell
+
The result of the GF operation is a compound consisting of 2 shapes:
* Image wire *W11* that consists of split edge parts from wire *W1: E11, E12, E13* and *E14*.
* Image shell *Sh21* that contains split face parts: *F211, F212, F213, F221, F222* and *F223*.
-@subsubsection specification__boolean_7_3_7 Case 7: Three faces
+
The result of the GF operation is a compound consisting of 7 shapes:
* Split face parts: *Fn1, Fn2, Fn3, Fn4, Fn5, Fn6* and *Fn7*.
-@subsubsection specification__boolean_7_3_8 Case 8: A face and a shell
+
The result of the GF operation is a compound consisting of 4 shapes:
* Image shell *Sh11* that consists of split face parts from shell *Sh1: Fn1, Fn2, Fn3, Fn4, Fn5* and *Fn6*.
* Split parts of face *F2: Fn3, Fn6* and *Fn7*.
-@subsubsection specification__boolean_7_3_9 Case 9: A shell and a solid
+
The result of the GF operation is a compound consisting of 2 shapes:
* Image shell *Sh11* consisting of split face parts of *Sh1: Fn1, Fn2 ... Fn8.*
* Solid *So21* with internal shell. (image of *So2*).
-@figure{/specification/boolean_operations/images/operations_image030.png,"A shell and a solid: results",420}
+
-@subsubsection specification__boolean_7_3_10 Case 10: A compound and a solid
+
The result of the GF operation is a compound consisting of 4 shapes:
* Image compound *Cm11* consisting of split solid parts from *So11* and *So12 (Sn1, Sn2, Sn3, Sn4)*.
* Split parts of solid *So2 (Sn2, Sn3, Sn5)*.
-@figure{/specification/boolean_operations/images/operations_image032.png,"A compound and a solid: results",420}
+
-@subsection specification__boolean_7_4 Class BOPAlgo_Builder
+
* The pairs of same domain faces are: (F11, F21), (F22, F31), (F41, F51) , (F41, F6) and (F51, F6).
* The pairs produce the three chains: (F11, F21), (F22, F31) and (F41, F51, F6).
-@subsubsection specification__boolean_7_4_10 Build Result of Type Face
-This step is the same as @ref specification__boolean_7_4_4 "Building Result of Type Vertex" but for the type *Face*.
+| @figure{/specification/boolean_operations/images/bsplit_image001.png,"Arguments",160} | -@figure{/specification/boolean_operations/images/bsplit_image002.png,"Result",160} | + |
+ |
| @figure{/specification/boolean_operations/images/bsplit_image003.png,"Arguments",160} | -@figure{/specification/boolean_operations/images/bsplit_image004.png,"Result",160} | + |
+  |
| @figure{/specification/boolean_operations/images/bsplit_image005.png,"Arguments",160} | -@figure{/specification/boolean_operations/images/bsplit_image006.png,"Results",160} | + |
+  |
* The result of *Fuse* operation is the compound that contains new vertex *V*.
-@figure{/specification/boolean_operations/images/boolean_image002.svg,"",160}
+
* The result of *Common* operation is a compound containing new vertex *V*.
* The result of *Cut12* operation is an empty compound.
* The result of *Cut21* operation is an empty compound.
-@subsubsection specification__boolean_9_4_2 Case 2: A Vertex and an Edge
+
* The result of *Fuse* operation is result is not defined because the dimension of the vertex (0) is not equal to the dimension of the edge (1).
* The result of *Common* operation is a compound containing vertex *V1* as the argument *V1* has a common part with edge *E2*.
-@figure{/specification/boolean_operations/images/boolean_image005.png,"",230}
+
* The result of *Cut12* operation is an empty compound.
* The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the edge (1).
-@subsubsection specification__boolean_9_4_3 Case 3: A Vertex and a Face
+
* The result of *Fuse* operation is not defined because the dimension of the vertex (0) is not equal to the dimension of the face (2).
* The result of *Common* operation is a compound containing vertex *V1* as the argument *V1* has a common part with face *F2*.
-@figure{/specification/boolean_operations/images/boolean_image007.png,"",230}
+
* The result of *Cut12* operation is an empty compound.
* The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the face (2).
-@subsubsection specification__boolean_9_4_4 Case 4: A Vertex and a Solid
+
* The result of *Fuse* operation is not defined because the dimension of the vertex (0) is not equal to the dimension of the solid (3).
* The result of *Common* operation is a compound containing vertex *V1* as the argument *V1* has a common part with solid *S2*.
-@figure{/specification/boolean_operations/images/boolean_image009.png,"",230}
+
* The result of *Cut12* operation is an empty compound.
* The result of *Cut21* operation is not defined because the dimension of the vertex (0) is less than the dimension of the solid (3).
-@subsubsection specification__boolean_9_4_5 Case 5: Two edges intersecting at one point
+
* The result of *Fuse* operation is a compound containing split parts of arguments i.e. 4 new edges *E11, E12, E21*, and *E22*. These edges have one shared vertex *Vn1*.
In this case:
* argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*);
* argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
-@figure{/specification/boolean_operations/images/boolean_image011.svg,"",230}
+
* The result of *Common* operation is an empty compound because the dimension (0) of the common part between the edges (vertex) is less than the dimension of the arguments (1).
@@ -1451,19 +1467,19 @@ In this case:
In this case the argument edge *E1* has resulting split edges *E11* and *E12* (image of *E1*).
-@figure{/specification/boolean_operations/images/boolean_image012.svg,"",230}
+
* The result of *Cut21* operation is a compound containing split parts of the argument *E2*, i.e. 2 new edges *E21* and *E12*. These edges have one shared vertex *Vn1*.
In this case the argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*).
-@figure{/specification/boolean_operations/images/boolean_image013.svg,"",70}
+
-@subsubsection specification__boolean_9_4_6 Case 6: Two edges having a common block
+
* The result of *Fuse* operation is a compound containing split parts of arguments i.e. 3 new edges *E11*, *E12* and *E22*. These edges have two shared vertices.
In this case:
@@ -1471,27 +1487,27 @@ In this case:
* argument edge *E2* has resulting split edges *E21* and *E22* (image of *E2*);
* edge *E12* is common for the images of *E1* and *E2*.
-@figure{/specification/boolean_operations/images/boolean_image015.svg,"",230}
+
* The result of *Common* operation is a compound containing split parts of arguments i.e. 1 new edge *E12*. In this case edge *E12* is common for the images of *E1* and *E2*.
The common part between the edges (edge) has the same dimension (1) as the dimension of the arguments (1).
-@figure{/specification/boolean_operations/images/boolean_image016.svg,"",230}
+
* The result of *Cut12* operation is a compound containing a split part of argument *E1*, i.e. new edge *E11*.
-@figure{/specification/boolean_operations/images/boolean_image017.svg,"",230}
+
* The result of *Cut21* operation is a compound containing a split part of argument *E2*, i.e. new edge *E22*.
-@figure{/specification/boolean_operations/images/boolean_image018.svg,"",230}
+
-@subsubsection specification__boolean_9_4_7 Case 7: An Edge and a Face intersecting at a point
+
* The result of *Fuse* operation is not defined because the dimension of the edge (1) is not equal to the dimension of the face (2).
@@ -1501,15 +1517,15 @@ Let us consider edge *E1* and face *F2* that intersect at a 3D point:
In this case the argument edge *E1* has no common parts with the face *F2* so the whole image of *E1* is in the result.
-@figure{/specification/boolean_operations/images/boolean_image020.png,"",230}
+
* The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the face (2).
-@subsubsection specification__boolean_9_4_8 Case 8: A Face and an Edge that have a common block
+
* The result of *Fuse* operation is not defined because the dimension of the edge (1) is not equal to the dimension of the face (2).
@@ -1517,21 +1533,21 @@ Let us consider edge *E1* and face *F2* that have a common block:
In this case the argument edge *E1* has a common part with face *F2* so the corresponding part of the image of *E1* is in the result. The yellow square is not a part of the result. It only shows the place of *F2*.
-@figure{/specification/boolean_operations/images/boolean_image022.png,"",230}
+
* The result of *Cut12* operation is a compound containing split part of the argument *E1*, i.e. new edge *E11*.
In this case the argument edge *E1* has a common part with face *F2* so the corresponding part is not included into the result. The yellow square is not a part of the result. It only shows the place of F2.
-@figure{/specification/boolean_operations/images/boolean_image023.png,"",230}
+
* The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the face (2).
-@subsubsection specification__boolean_9_4_9 Case 9: An Edge and a Solid intersecting at a point
+
* The result of *Fuse* operation is not defined because the dimension of the edge (1) is not equal to the dimension of the solid (3).
@@ -1539,21 +1555,21 @@ Let us consider edge *E1* and solid *S2* that intersect at a point:
In this case the argument edge *E1* has a common part with solid *S2* so the corresponding part of the image of *E1* is in the result. The yellow square is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image025.png,"",230}
+
* The result of *Cut12* operation is a compound containing split part of the argument *E1*, i.e. new edge *E11*.
In this case the argument edge *E1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow square is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image071.png,"",230}
+
* The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the solid (3).
-@subsubsection specification__boolean_9_4_10 Case 10: An Edge and a Solid that have a common block
+
* The result of *Fuse* operation is not defined because the dimension of the edge (1) is not equal to the dimension of the solid (3).
@@ -1561,148 +1577,148 @@ Let us consider edge *E1* and solid *S2* that have a common block:
In this case the argument edge *E1* has a common part with solid *S2* so the corresponding part of the image of *E1* is in the result. The yellow square is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image073.png,"",230}
+
* The result of *Cut12* operation is a compound containing split part of the argument *E1*, i.e. new edge *E11*.
In this case the argument edge *E1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow square is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image026.png,"",230}
+
* The result of *Cut21* operation is not defined because the dimension of the edge (1) is less than the dimension of the solid (3).
-@subsubsection specification__boolean_9_4_11 Case 11: Two intersecting faces
+
* The result of *Fuse* operation is a compound containing split parts of arguments i.e. 2 new faces *F11* and *F21*. These faces have one shared edge *En1*.
-@figure{/specification/boolean_operations/images/boolean_image028.png,"",230}
+
* The result of *Common* operation is an empty compound because the dimension (1) of the common part between *F1* and *F2* (edge) is less than the dimension of arguments (2).
* The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.
-@figure{/specification/boolean_operations/images/boolean_image029.png,"",230}
+
* The result of *Cut21* operation is a compound containing split parts of the argument *F2*, i.e. 1 new face *F21*.
-@figure{/specification/boolean_operations/images/boolean_image030.png,"",127}
+
-@subsubsection specification__boolean_9_4_12 Case 12: Two faces that have a common part
+
* The result of *Fuse* operation is a compound containing split parts of arguments, i.e. 3 new faces: *F11*, *F12* and *F22*. These faces are shared through edges In this case:
* the argument edge *F1* has resulting split faces *F11* and *F12* (image of *F1*)
* the argument face *F2* has resulting split faces *F12* and *F22* (image of *F2*)
* the face *F12* is common for the images of *F1* and *F2*.
-@figure{/specification/boolean_operations/images/boolean_image032.png,"",230}
+
* The result of *Common* operation is a compound containing split parts of arguments i.e. 1 new face *F12*.
In this case: face *F12* is common for the images of *F1* and *F2*.
The common part between the faces (face) has the same dimension (2) as the dimension of the arguments (2).
-@figure{/specification/boolean_operations/images/boolean_image033.png,"",230}
+
* The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.
-@figure{/specification/boolean_operations/images/boolean_image034.png,"",230}
+
* The result of *Cut21* operation is a compound containing split parts of the argument *F2*, i.e. 1 new face *F21*.
-@figure{/specification/boolean_operations/images/boolean_image035.png,"",230}
+
-@subsubsection specification__boolean_9_4_13 Case 13: Two faces that have a common edge
+
* The result of *Fuse* operation is a compound containing split parts of arguments, i.e. 2 new faces: *F11* and *F21*. These faces have one shared edge *En1*.
-@figure{/specification/boolean_operations/images/boolean_image037.png,"",230}
+
* The result of *Common* operation is an empty compound because the dimension (1) of the common part between *F1* and *F2* (edge)is less than the dimension of the arguments (2)
* The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*. The vertices are shown just to clarify the fact that the edges are spitted.
-@figure{/specification/boolean_operations/images/boolean_image038.png,"",230}
+
* The result of *Cut21* operation is a compound containing split parts of the argument *F2*, i.e. 1 new face *F21*. The vertices are shown just to clarify the fact that the edges are spitted.
-@figure{/specification/boolean_operations/images/boolean_image039.png,"",230}
+
-@subsubsection specification__boolean_9_4_14 Case 14: Two faces that have a common vertex
+
* The result of *Fuse* operation is a compound containing split parts of arguments, i.e. 2 new faces: *F11* and *F21*. These faces have one shared vertex *Vn1*.
-@figure{/specification/boolean_operations/images/boolean_image041.png,"",230}
+
* The result of *Common* operation is an empty compound because the dimension (0) of the common part between *F1* and *F2* (vertex) is less than the dimension of the arguments (2)
* The result of *Cut12* operation is a compound containing split part of the argument *F1*, i.e. new face *F11*.
-@figure{/specification/boolean_operations/images/boolean_image042.png,"",230}
+
* The result of *Cut21* operation is a compound containing split parts of the argument *F2*, i.e. 1 new face *F21*.
-@figure{/specification/boolean_operations/images/boolean_image043.png,"",230}
+
-@subsubsection specification__boolean_9_4_15 Case 15: A Face and a Solid that have an intersection curve.
+
* The result of *Fuse* operation is not defined because the dimension of the face (2) is not equal to the dimension of the solid (3).
* The result of *Common* operation is a compound containing split part of the argument *F1*. In this case the argument face *F1* has a common part with solid *S2*, so the corresponding part of the image of *F1* is in the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image045.png,"",230}
+
* The result of *Cut12* operation is a compound containing split part of the argument *F1*. In this case argument face *F1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image046.png,"",230}
+
* The result of *Cut21* operation is not defined because the dimension of the face (2) is less than the dimension of the solid (3).
-@subsubsection specification__boolean_9_4_16 Case 16: A Face and a Solid that have overlapping faces.
+
* The result of *Fuse* operation is not defined because the dimension of the face (2) is not equal to the dimension of the solid (3).
* The result of *Common* operation is a compound containing split part of the argument *F1*. In this case the argument face *F1* has a common part with solid *S2*, so the corresponding part of the image of *F1* is included in the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image048.png,"",230}
+
* The result of *Cut12* operation is a compound containing split part of the argument *F1*. In this case argument face *F1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image049.png,"",230}
+
* The result of *Cut21* operation is not defined because the dimension of the face (2) is less than the dimension of the solid (3).
-@subsubsection specification__boolean_9_4_17 Case 17: A Face and a Solid that have overlapping edges.
+
* The result of *Fuse* operation is not defined because the dimension of the face (2) is not equal to the dimension of the solid (3).
@@ -1710,15 +1726,15 @@ Let us consider face *F1* and solid *S2* that have overlapping edges:
* The result of *Cut12* operation is a compound containing split part of the argument *F1*. In this case argument face *F1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image051.png,"",230}
+
* The result of *Cut21* operation is not defined because the dimension of the face (2) is less than the dimension of the solid (3).
-@subsubsection specification__boolean_9_4_18 Case 18: A Face and a Solid that have overlapping vertices.
+
* The result of *Fuse* operation is not defined because the dimension of the face (2) is not equal to the dimension of the solid (3).
@@ -1726,136 +1742,136 @@ Let us consider face *F1* and solid *S2* that have overlapping vertices:
* The result of *Cut12* operation is a compound containing split part of the argument *F1*. In this case argument face *F1* has a common part with solid *S2* so the corresponding part is not included into the result. The yellow contour is not a part of the result. It only shows the place of *S2*.
-@figure{/specification/boolean_operations/images/boolean_image053.png,"",230}
+
* The result of *Cut21* operation is not defined because the dimension of the face (2) is less than the dimension of the solid (3).
-@subsubsection specification__boolean_9_4_19 Case 19: Two intersecting Solids.
+
* The result of *Fuse* operation is a compound composed from the split parts of arguments *S11, S12* and *S22* (Cut12, Common, Cut21). All inner webs are removed, so the result is one new solid *R*.
-@figure{/specification/boolean_operations/images/boolean_image055.png,"",230}
+
* The result of *Common* operation is a compound containing split parts of arguments i.e. one new solid *S12*. In this case solid *S12* is common for the images of *S1* and *S2*. The common part between the solids (solid) has the same dimension (3) as the dimension of the arguments (3). The yellow contour is not a part of the result. It only shows the place of *S1*.
-@figure{/specification/boolean_operations/images/boolean_image056.png,"",176}
+
* The result of *Cut12* operation is a compound containing split part of the argument *S1*, i.e. 1 new solid *S11*.
-@figure{/specification/boolean_operations/images/boolean_image057.png,"",230}
+
* The result of *Cut21* operation is a compound containing split part of the argument *S2*, i.e. 1 new solid *S21*.
-@figure{/specification/boolean_operations/images/boolean_image058.png,"",230}
+
-@subsubsection specification__boolean_9_4_20 Case 20: Two Solids that have overlapping faces.
+
* The result of *Fuse* operation is a compound composed from the split parts of arguments *S11, S12* and *S22* (Cut12, Common, Cut21). All inner webs are removed, so the result is one new solid *R*.
-@figure{/specification/boolean_operations/images/boolean_image060.png,"",230}
+
* The result of *Common* operation is an empty compound because the dimension (2) of the common part between *S1* and *S2* (face) is less than the lower dimension of the arguments (3).
* The result of *Cut12* operation is a compound containing split part of the argument *S1*, i.e. 1 new solid *S11*.
-@figure{/specification/boolean_operations/images/boolean_image061.png,"",230}
+
* The result of *Cut21* operation is a compound containing split part of the argument *S2*, i.e. 1 new solid *S21*.
-@figure{/specification/boolean_operations/images/boolean_image062.png,"",230}
+
-@subsubsection specification__boolean_9_4_21 Case 21: Two Solids that have overlapping edges.
+
* The result of *Fuse* operation is a compound composed from the split parts of arguments i.e. 2 new solids *S11* and *S21*. These solids have one shared edge *En1*.
-@figure{/specification/boolean_operations/images/boolean_image064.png,"",230}
+
* The result of *Common* operation is an empty compound because the dimension (1) of the common part between *S1* and *S2* (edge) is less than the lower dimension of the arguments (3).
* The result of *Cut12* operation is a compound containing split part of the argument *S1*. In this case
argument *S1* has a common part with solid *S2* so the corresponding part is not included into the result.
-@figure{/specification/boolean_operations/images/boolean_image065.png,"",230}
+
* The result of *Cut21* operation is a compound containing split part of the argument *S2*. In this case
argument *S2* has a common part with solid *S1* so the corresponding part is not included into the result.
-@figure{/specification/boolean_operations/images/boolean_image066.png,"",230}
+
-@subsubsection specification__boolean_9_4_22 Case 22: Two Solids that have overlapping vertices.
+
* The result of *Fuse* operation is a compound composed from the split parts of arguments i.e. 2 new solids *S11* and *S21*. These solids share *Vn1*.
-@figure{/specification/boolean_operations/images/boolean_image068.png,"",230}
+
* The result of *Common* operation is an empty compound because the dimension (0) of the common part between *S1* and *S2* (vertex) is less than the lower dimension of the arguments (3).
* The result of *Cut12* operation is a compound containing split part of the argument *S1*.
-@figure{/specification/boolean_operations/images/boolean_image069.png,"",230}
+
* The result of *Cut21* operation is a compound containing split part of the argument *S2*.
-@figure{/specification/boolean_operations/images/boolean_image070.png,"",230}
+
-@subsubsection specification__boolean_9_4_23 Case 23: A Shell and a Wire cut by a Solid.
+
* The result of *Fuse* operation is not defined as the dimension of the arguments is not the same.
* The result of *Common* operation is a compound containing the parts of the initial Shell and Wire common for the Solid. The new Shell and Wire are created from the objects.
-@figure{/specification/boolean_operations/images/boolean_image137.png,"",230}
+
* The result of *Cut12* operation is a compound containing new Shell and Wire split from the arguments *Sh* and *W*. In this case they have a common part with solid *S* so the corresponding part is not included into the result.
-@figure{/specification/boolean_operations/images/boolean_image138.png,"",230}
+
* The result of *Cut21* operation is not defined as the objects have a lower dimension than the tool.
-@subsubsection specification__boolean_9_4_24 Case 24: Two Wires that have overlapping edges.
+
* The result of *Fuse* operation is a compound containing two Wires, which share an overlapping edge. The new Wires are created from the objects:
-@figure{/specification/boolean_operations/images/boolean_image140.png,"",230}
+
* The result of *Common* operation is a compound containing one Wire consisting of an overlapping edge. The new Wire is created from the objects:
-@figure{/specification/boolean_operations/images/boolean_image141.png,"",230}
+
* The result of *Cut12* operation is a compound containing a wire split from object *W1*. Its common part with *W2* is not included into the result.
-@figure{/specification/boolean_operations/images/boolean_image142.png,"",230}
+
* The result of *Cut21* operation is a compound containing a wire split from *W2*. Its common part with *W1* is not included into the result.
-@figure{/specification/boolean_operations/images/boolean_image143.png,"",230}
+
-@subsection specification__boolean_9_5 Class BOPAlgo_BOP
+
The result of *Section* operation is the compound that contains a new vertex *V*.
-@figure{/specification/boolean_operations/images/boolean_image081.png,"",128}
+
-@subsubsection specification__boolean_10a_3_2 Case 1: Case 2: A Vertex and an Edge
+
The result of *Section* operation is the compound that contains vertex *V1*.
-@figure{/specification/boolean_operations/images/boolean_image083.png,"",230}
+
+
+
The result of *Section* operation is the compound that contains vertex *V1*.
-@figure{/specification/boolean_operations/images/boolean_image085.png,"",230}
+
-@subsubsection specification__boolean_10a_3_4 Case 4: A Vertex and a Solid
+
The result of *Section* operation is an empty compound.
-@subsubsection specification__boolean_10a_3_5 Case 5: Two edges intersecting at one point
+
The result of *Section* operation is the compound that contains a new vertex *Vnew*.
-@figure{/specification/boolean_operations/images/boolean_image088.png,"",230}
+
-@subsubsection specification__boolean_10a_3_6 Case 6: Two edges having a common block
+
The result of *Section* operation is the compound that contains a new edge *Enew*.
-@figure{/specification/boolean_operations/images/boolean_image090.png,"",230}
+
-@subsubsection specification__boolean_10a_3_7 Case 7: An Edge and a Face intersecting at a point
+
The result of *Section* operation is the compound that contains a new vertex *Vnew*.
-@figure{/specification/boolean_operations/images/boolean_image092.png,"",230}
+
-@subsubsection specification__boolean_10a_3_8 Case 8: A Face and an Edge that have a common block
+
The result of *Section* operation is the compound that contains new edge *Enew*.
-@figure{/specification/boolean_operations/images/boolean_image094.png,"",230}
+
-@subsubsection specification__boolean_10a_3_9 Case 9: An Edge and a Solid intersecting at a point
+
The result of *Section* operation is the compound that contains a new vertex *Vnew*.
-@figure{/specification/boolean_operations/images/boolean_image096.png,"",230}
+
-@subsubsection specification__boolean_10a_3_10 Case 10: An Edge and a Solid that have a common block
+
The result of *Section* operation is the compound that contains a new edge *Enew*.
-@figure{/specification/boolean_operations/images/boolean_image098.png,"",230}
+
-@subsubsection specification__boolean_10a_3_11 Case 11: Two intersecting faces
+
The result of *Section* operation is the compound that contains a new edge *Enew*.
-@figure{/specification/boolean_operations/images/boolean_image100.png,"",230}
+
-@subsubsection specification__boolean_10a_3_12 Case 12: Two faces that have a common part
+
The result of *Section* operation is the compound that contains 4 new edges.
-@figure{/specification/boolean_operations/images/boolean_image134.png,"",230}
+
-@subsubsection specification__boolean_10a_3_13 Case 13: Two faces that have overlapping edges
+
The result of *Section* operation is the compound that contains a new edge *Enew*.
-@figure{/specification/boolean_operations/images/boolean_image102.png,"",230}
+
-@subsubsection specification__boolean_10a_3_14 Case 14: Two faces that have overlapping vertices
+
The result of *Section* operation is the compound that contains a new vertex *Vnew*.
-@figure{/specification/boolean_operations/images/boolean_image104.png,"",230}
+
-@subsubsection specification__boolean_10a_3_15 Case 15: A Face and a Solid that have an intersection curve
+
The result of *Section* operation is the compound that contains new edges.
-@figure{/specification/boolean_operations/images/boolean_image106.png,"",230}
+
-@subsubsection specification__boolean_10a_3_16 Case 16: A Face and a Solid that have overlapping faces.
+
The result of *Section* operation is the compound that contains new edges
-@figure{/specification/boolean_operations/images/boolean_image108.png,"",230}
+
-@subsubsection specification__boolean_10a_3_17 Case 17: A Face and a Solid that have overlapping edges.
+
The result of *Section* operation is the compound that contains a new edge *Enew*.
-@figure{/specification/boolean_operations/images/boolean_image110.png,"",230}
+
-@subsubsection specification__boolean_10a_3_18 Case 18: A Face and a Solid that have overlapping vertices.
+
The result of *Section* operation is the compound that contains a new vertex *Vnew*.
-@figure{/specification/boolean_operations/images/boolean_image112.png,"",230}
+
-@subsubsection specification__boolean_10a_3_19 Case 19: Two intersecting Solids
+
The result of *Section* operation is the compound that contains new edges.
-@figure{/specification/boolean_operations/images/boolean_image114.png,"",230}
-@subsubsection specification__boolean_10a_3_20 Case 20: Two Solids that have overlapping faces
+
+
+
The result of *Section* operation is the compound that contains new edges.
-@figure{/specification/boolean_operations/images/boolean_image116.png,"",230}
+
+
-@subsubsection specification__boolean_10a_3_21 Case 21: Two Solids that have overlapping edges
+
The result of *Section* operation is the compound that contains a new edge *Enew*.
-@figure{/specification/boolean_operations/images/boolean_image118.png,"",230}
-@subsubsection specification__boolean_10a_3_22 Case 22: Two Solids that have overlapping vertices
+
+
+
The result of *Section* operation is the compound that contains a new vertex *Vnew*.
-@figure{/specification/boolean_operations/images/boolean_image120.png,"",230}
-@subsection specification__boolean_10a_4 Class BOPAlgo_Section
+
+
+| @figure{/specification/boolean_operations/images/mkvolume_image001.png,"Arguments",200} | -@figure{/specification/boolean_operations/images/mkvolume_image002.png,"Results",200} | + |
+  |
| @figure{/specification/boolean_operations/images/mkvolume_image003.png,"Arguments",200} | -@figure{/specification/boolean_operations/images/mkvolume_image004.png,"Results",200} | + |
+  |
~~~~{.php}
bclearobjects
@@ -2368,7 +2399,7 @@ bcremoveall
bcadd res c 1 s 1 f 1
~~~~
-@figure{/specification/boolean_operations/images/cells_algorithm_002.png,"The result of COMMON operation",126}
+
#### 2. Common between cylinder and face
@@ -2377,7 +2408,7 @@ bcremoveall
bcadd res f 1 c 1
~~~~
-@figure{/specification/boolean_operations/images/cells_algorithm_003.png,"The result of COMMON operation between cylinder and face",90}
+
#### 3. Common between cylinder and sphere
@@ -2386,7 +2417,7 @@ bcremoveall
bcadd res c 1 s 1
~~~~
-@figure{/specification/boolean_operations/images/cells_algorithm_004.png,"The result of COMMON operation between cylinder and sphere",120}
+
#### 4. Fuse of cylinder and sphere
@@ -2397,7 +2428,7 @@ bcadd res s 1 -m 1
bcremoveint res
~~~~
-@figure{/specification/boolean_operations/images/cells_algorithm_005.png,"The result of FUSE operation between cylinder and sphere",160}
+
#### 5. Parts of the face inside solids - FUSE(COMMON(f, c), COMMON(f, s))
@@ -2407,13 +2438,13 @@ bcadd res f 1 s 1 -m 1
bcadd res f 1 c 1 -m 1
~~~~
-@figure{/specification/boolean_operations/images/cells_algorithm_006_1.png,"Parts of the face inside solids",160}
+
~~~~{.php}
bcremoveint res
~~~~
-@figure{/specification/boolean_operations/images/cells_algorithm_006_2.png,"Unified parts of the face inside solids",160}
+
#### 6. Part of the face outside solids
@@ -2422,7 +2453,7 @@ bcremoveall
bcadd res f 1 c 0 s 0
~~~~
-@figure{/specification/boolean_operations/images/cells_algorithm_007.png,"Part of the face outside solids",160}
+
#### 7. Fuse operation (impossible using standard Boolean Fuse operation)
@@ -2434,13 +2465,13 @@ bcadd res f 1 c 0 s 0
bcremoveint res
~~~~
-@figure{/specification/boolean_operations/images/cells_algorithm_008.png,"Fuse operation",160}
+
These examples may last forever. To define any new operation, it is just necessary to define, which Cells should be taken and which should be avoided.
-@section specification__boolean_10 Algorithm Limitations
+
#### Example 2: Self-interfered Edge
The edge *E* is a self-interfered shape and cannot be used as an argument of the Algorithms.
-@figure{/specification/boolean_operations/images/operations_image037.svg,"Self-interfered Edge",140}
+
#### Example 3: Self-interfered Face
The face *F* is a self-interfered shape and cannot be used as an argument of the Algorithms.
-@figure{/specification/boolean_operations/images/operations_image038.svg,"Self-interfered Face",230}
+
#### Example 4: Face of Revolution
The face *F* has been obtained by revolution of edge *E* around line *L*.
-@figure{/specification/boolean_operations/images/operations_image039a.png,"Face of Revolution: Arguments",230}
-@figure{/specification/boolean_operations/images/operations_image039b.png,"Face of Revolution: Result",230}
+
+
In spite of the fact that face *F* is valid (in terms of *BRepCheck_Analyzer*) it is a self-interfered shape and cannot be used as the argument of the Algorithms.
-@subsubsection specification__boolean_10_1_4 Self-interferences due to tolerances
+
The distance between the vertices of *E* is *D=0.69799*. The values of the tolerances *Tol(V1)=Tol(V2)=0.5*.
-@figure{/specification/boolean_operations/images/operations_image041.png,"Distance and Tolerances",230}
+
In spite of the fact that the edge *E* is valid in terms of *BRepCheck_Analyzer*, it is a self-interfered shape because its vertices are interfered. Thus, edge *E* cannot be used as an argument of the Algorithms.
#### Example 2: Solid containing an interfered vertex
-Let us consider solid *S* containing vertex V. @figure{/specification/boolean_operations/images/operations_image042.png,"Solid containing an interfered vertex",230}
+Let us consider solid *S* containing vertex V. 
The value of tolerance Tol(V)= 50.000075982061.
-@figure{/specification/boolean_operations/images/operations_image043.png,"Tolerance",230}
+
In spite of the fact that solid *S* is valid in terms of *BRepCheck_Analyzer* it is a self-interfered shape because vertex *V* is interfered with a lot of sub-shapes from *S* without any topological connection with them. Thus solid *S* cannot be used as an argument of the Algorithms.
-@subsubsection specification__boolean_10_1_5 Parametric representation
+
The range of *U* coordinate is always restricted while the range of *V* coordinate is non-restricted.
Let us consider a cylinder-based *Face 1* with radii *R=3* and *H=6*.
-@figure{/specification/boolean_operations/images/operations_image044.png,"Face 1",230}
+
-@figure{/specification/boolean_operations/images/operations_image045.png,"P-Curves for Face 1",230}
+
Let us also consider a cylinder-based *Face 2* with radii *R=3000* and *H=6000* (resulting from scaling Face 1 with scale factor *ScF=1000*).
-@figure{/specification/boolean_operations/images/operations_image046.png,"Face 2",230}
+
-@figure{/specification/boolean_operations/images/operations_image047.png,"P-Curves for Face 2",230}
+
Pay attention to the Zoom value of the Figures.
It is obvious that starting with some value of *ScF*, e.g. *ScF>1000000*, all sloped p-Curves on *Face 2* will be almost vertical. At least, there will be no difference between the values of angles computed by standard C Run-Time Library functions, such as *double acos(double x)*. The loss of accuracy in computation of angles can cause failure of some BP sub-algorithms, such as building faces from a set of edges or building solids from a set of faces.
-@subsubsection specification__boolean_10_1_6 Using tolerances of vertices to fix gaps
+
* Face *F* has two edges *E1* and *E2* and two vertices, the base plane is {0,0,0, 0,0,1};
* Edge *E1* is based on line {0,0,0, 1,0,0}, Tol(E1) = 1.e-7;
@@ -2568,8 +2601,9 @@ Let us consider the following example:
The values of tolerances *Tol(V1)* and *Tol(V2)* are big enough to fix the gaps between the ends of the edges, but the vertices *V1* and *V2* do not contain any information about the trajectories connecting the corresponding ends of the edges. Thus, the trajectories are undefined. This will cause failure of some sub-algorithms of BP. For example, the sub-algorithms for building faces from a set of edges use the information about all edges connected in a vertex. The situation when a vertex has several pairs of edges such as above will not be solved in a right way.
-@subsection specification__boolean_11_1 Intersection problems
-@subsubsection specification__boolean_11_1_1 Pure intersections and common zones
+
The result of pure intersection between *E1* and *E2* is vertex *Vx {0,-10,0}*.
@@ -2587,7 +2621,7 @@ The Intersection Part of Algorithms uses the result of pure intersection *Vx* in
* The Algorithms do not produce Common Blocks between edges based on underlying curves of explicitly different type (e.g. Line / Circle). If the curves have different types, the rule of thumb is that the produced result is of type **vertex**. This rule does not work for non-analytic curves (Bezier, B-Spline) and their combinations with analytic curves.
* The algorithm of intersection between two surfaces *IntPatch_Intersection* does not compute *CZ* of the intersection between curves and points. So even if *CZ* were computed by Edge/Edge intersection algorithm, its result could not be treated by Face/Face intersection algorithm.
-@subsubsection specification__boolean_11_2_2 Tolerances and inaccuracies
+
The problem cannot be solved in general, because the length of *E12* can be infinite and the values of *Tol(V1)* and *Tol(V2)* theoretically can be infinite too.
@@ -2614,11 +2648,11 @@ Let us consider two edges *E1* and *E2*, which have common vertices *V1* and *V2
*C1* practically coincides in 3D with *C2*. The value of deflection is *Dmax* (e.g. *Dmax=1.e-6*).
-@figure{/specification/boolean_operations/images/operations_image051.svg,"Intersecting Edges",420}
+
The evident and prospective result should be the Common Block between *E1* and *E2*. However, the result of intersection differs.
-@figure{/specification/boolean_operations/images/operations_image052.svg,"Result of Intersection",420}
+
The result contains three new vertices *Vx1, Vx2* and *Vx3*, 8 new edges (V1, Vx1, Vx2, Vx3, V2) and no Common Blocks. This is correct due to the source data: *Tol(E1)=1.e-7, Tol(E2)=1.e-7* and Dmax=1.e-6.
@@ -2628,17 +2662,18 @@ In this particular case the problem can be solved by several ways:
The example can be extended from 1D (edges) to 2D (faces).
-@figure{/specification/boolean_operations/images/operations_image053.svg,"Intersecting Faces",420}
+
The comments and recommendations are the same as for 1D case above.
-@subsubsection specification__boolean_11_2_3 Acquired Self-interferences
+
Vertex *V1* interferes with vertices *V12* and *V22*.
So vertex *V21* should interfere with vertex *V22*, which is impossible because vertices *V21* and *V22* are the vertices of edge *E2*, thus *V21* is not equal to *V22*.
@@ -2651,20 +2686,20 @@ In a particular case the problem can be solved by refinement of arguments, i.e.
Let us consider vertex *V2* and wire consisting of edges *E11* and *E12*.
-@figure{/specification/boolean_operations/images/operations_image055.svg,"Vertex and Wire",200}
+
The arguments themselves are not self-intersected.
Vertex *V2* interferes with edges *E11* and *E12*. Thus, edge *E11* should interfere with edge *E22*, but it is impossible because edges *E11* and *E12* cannot interfere by the condition.
The cases when a non-self-interfered argument (or its sub-shapes) become interfered due to the intersections with other arguments (or their sub-shapes) are considered as limitations for the Algorithms.
-@section specification__boolean_11a Advanced Options
+
The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 5e-5:
-@figure{/specification/boolean_operations/images/boolean_image122.png,"Result of CUT operation obtained with Basic Operations",240}
+
-@figure{/specification/boolean_operations/images/boolean_image123.png,"Result of CUT operation obtained with Fuzzy Option",240}
+
In this example Fuzzy option allows eliminating a very thin part of the result shape produced by Basic algorithm due to misalignment of rear faces of the box and the cylinder.
@@ -2697,13 +2733,13 @@ In this example Fuzzy option allows eliminating a very thin part of the result s
In this example two boxes are fused. One of them has dimensions 10*10*10, and the other is 10*10.000001*10.000001 and adjacent to the first one. There is no gap in this case as the surfaces of the neighboring faces coincide, but one box is slightly greater than the other.
-@figure{/specification/boolean_operations/images/boolean_image124.png,"",240}
+
The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 1e-6:
-@figure{/specification/boolean_operations/images/boolean_image125.png,"Result of CUT operation obtained with Basic Operations",240}
+
-@figure{/specification/boolean_operations/images/boolean_image126.png,"Result of CUT operation obtained with Fuzzy Option",240}
+
In this example Fuzzy option allows eliminating an extremely narrow face in the result produced by Basic operation.
@@ -2711,13 +2747,13 @@ In this example Fuzzy option allows eliminating an extremely narrow face in the
In this example the small planar face (shown in orange) is subtracted from the big one (shown in yellow). There is a gap 1e-5 between the edges of these faces.
-@figure{/specification/boolean_operations/images/boolean_image127.png,"",240}
+
The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 1e-5:
-@figure{/specification/boolean_operations/images/boolean_image128.png,"Result of CUT operation obtained with Basic Operations",240}
+
-@figure{/specification/boolean_operations/images/boolean_image129.png,"Result of CUT operation obtained with Fuzzy Option",240}
+
In this example Fuzzy options eliminated a pin-like protrusion resulting from the gap between edges of the argument faces.
@@ -2725,33 +2761,33 @@ In this example Fuzzy options eliminated a pin-like protrusion resulting from th
In this example the small edge is subtracted from the big one. The edges are overlapping not precisely, with max deviation between them equal to 5.28004e-5. We will use 6e-5 value for Fuzzy option.
-@figure{/specification/boolean_operations/images/boolean_image130.png,"",240}
+
The following results are obtained using Basic Operations and the Fuzzy ones with the fuzzy value 6e-5:
-@figure{/specification/boolean_operations/images/boolean_image131.png,"Result of CUT operation obtained with Basic Operations",240}
+
-@figure{/specification/boolean_operations/images/boolean_image132.png,"Result of CUT operation obtained with Fuzzy Option",240}
+
This example stresses not only the validity, but also the performance issue. The usage of Fuzzy option with the appropriate value allows processing the case much faster than with the pure Basic operation. The performance gain for the case is 45 (Processor: Intel(R) Core(TM) i5-3450 CPU @ 3.10 GHz).
-@subsection specification__boolean_11a_2 Gluing Operation
+
There are two possibilities of overlapping shapes:
* The shapes can be partially coinciding - the faces do not have intersection curves, but overlapping. The faces of such arguments will be split during the operation. The following picture illustrates such shapes:
-@figure{/specification/boolean_operations/images/glue_options_image001.png,"Partially coinciding faces",240}
+
* The shapes can be fully coinciding - there should be no partial overlapping of the faces, thus no intersection of type EDGE/FACE at all. In such cases the faces will not be split during the operation.
-@figure{/specification/boolean_operations/images/glue_options_image003.png,"Full coinciding faces of the boxes",240}
+
Thus, there are two possible options - for full and partial coincidence of the shapes.
@@ -2763,7 +2799,7 @@ The performance improvement in gluing mode is achieved by excluding the most tim
By setting the Gluing option for the operation user should guarantee that the arguments are really coinciding. The algorithm does not check this itself. Setting inappropriate option for the operation is likely to lead to incorrect result.
-@subsubsection specification__boolean_11a_2_1 Usage
+
Performance improvement from using the GlueShift option in this case is about 70 percent.
#### Case2 - Sewing faces of the shape after reading from IGES
-@figure{/specification/boolean_operations/images/glue_options_image005.png,"Faces with coinciding but not shared edges",240}
+
Performance improvement in this case is also about 70 percent.
-@subsection specification__boolean_11a_3 Safe processing mode
+| @figure{/specification/boolean_operations/images/bop_simple_001.png, "Not simplified result", 420} | -@figure{/specification/boolean_operations/images/bop_simple_002.png, "Simplified result", 420} | + |
+  |
The detailed description of the classes can be found in the corresponding .hxx files. The examples are below in this chapter.
-@subsection specification__boolean_11b_2 Package BOPTest
+
Update the value of the Output File for `x64` configuration:
- @figure{/build/build_3rdparty/images/3rdparty_image003.png}
+ 
Build the `freetype` project.
If the GUI tool is used, run this tool without additional arguments and after that specify the source directory by clicking **Browse Source** and the build (binary) one by clicking **Browse Build**:
-@figure{/build/build_occt/images/cmake_image001.png}
+
-@note Each configuration of the project should be built in its own directory.
-When building multiple configurations it is suggested to indicate in the name of build directories the system, bitness and compiler (e.g., d:/occt/build/win32-vc10).
+> **Note:** Each configuration of the project should be built in its own directory. When building multiple configurations it is suggested to indicate in the name of build directories the system, bitness and compiler (e.g., d:/occt/build/win32-vc10).
Once the source and build directories are selected, "Configure" button should be pressed in order to start manual configuration process.
It begins with selection of a target configurator. It is "Visual Studio 10 2010 Win64" in our example.
-@figure{/build/build_occt/images/cmake_image002.png}
+
-@note To build OCCT for **Universal Windows Platform (UWP)** specify the path to toolchain file for cross-compiling d:/occt/adm/templates/uwp.toolchain.config.cmake.
+> **Note:** To build OCCT for **Universal Windows Platform (UWP)** specify the path to toolchain file for cross-compiling d:/occt/adm/templates/uwp.toolchain.config.cmake.
Alternatively, if you are using CMake from the command line add options `-DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0`.
Universal Windows Platform (UWP) is supported only on "Visual Studio 14 2015".
File `CASROOT/samples/xaml/ReadMe.md` describes the building procedure of XAML (UWP) sample.
@@ -71,7 +67,7 @@ File `CASROOT/samples/xaml/ReadMe.md` describes the building procedure of XAML (
Once "Finish" button is pressed, the first pass of the configuration process is executed.
At the end of the process, CMake outputs the list of environment variables, which have to be properly specified for successful configuration.
-@figure{/build/build_occt/images/cmake_image003.png}
+
The error message provides some information about these variables.
This message will appear after each pass of the process until all required variables are specified correctly.
@@ -79,7 +75,7 @@ This message will appear after each pass of the process until all required varia
The change of the state of some variables can lead to the appearance of new variables.
The new variables appeared after the pass of the configuration process are highlighted with red color by CMake GUI tool.
-@note There is "grouped" option, which groups variables with a common prefix.
+> **Note:** There is "grouped" option, which groups variables with a common prefix.
The following table gives the full list of environment variables used at the configuration stage:
@@ -95,14 +91,14 @@ The following table gives the full list of environment variables used at the con
| USE_DRACO | Boolean | Indicates whether Draco product should be used in OCCT Data Exchange module for support of Draco compression in glTF mesh file format |
| USE_TK | Boolean | Indicates whether Tcl/Tk product should be used in OCCT Draw Harness module for user interface (in addition to Tcl, which is mandatory for Draw Harness) |
| USE_TBB | Boolean | Indicates whether TBB (Threading Building Blocks) 3rd party is used or not. Note that OCCT remains parallel even without TBB product |
-| USE_VTK | Boolean | Indicates whether VTK 3rd party is used or not. OCCT comes with a bridge between CAD data representation and VTK by means of its dedicated VIS component (VTK Integration Services). You may skip this 3rd party unless you are planning to use VTK visualization for OCCT geometry. See the official documentation @ref occt_user_guides__vis for the details on VIS |
+| USE_VTK | Boolean | Indicates whether VTK 3rd party is used or not. OCCT comes with a bridge between CAD data representation and VTK by means of its dedicated VIS component (VTK Integration Services). You may skip this 3rd party unless you are planning to use VTK visualization for OCCT geometry. See the official documentation [Link](#occt_user_guides__vis) for the details on VIS |
| 3RDPARTY_DIR | Path | Defines the root directory where all required 3rd party products will be searched. Once you define this path it is very convenient to click "Configure" button in order to let CMake automatically detect all necessary products|
| 3RDPARTY_FREETYPE_* | Path | Path to FreeType binaries |
| 3RDPARTY_TCL_* 3RDPARTY_TK_* | Path | Path to Tcl/Tk binaries |
| 3RDPARTY_FREEIMAGE* | Path | Path to FreeImage binaries |
| 3RDPARTY_TBB* | Path | Path to TBB binaries |
| 3RDPARTY_VTK_* | Path | Path to VTK binaries |
-| BUILD_MODULE_
By default, the build solution process skips the building of the INSTALL and Overview projects.
When the building process is finished build:
@@ -197,7 +193,7 @@ When the building process is finished build:
For this, right-click on the *Overview/INSTALL* project and select **Project Only -> Build Only** -> *Overview/INSTALL* in the solution explorer.
-@subsection build_cmake_install Installation
+
Click **Configure** button. It opens the window with a drop-down list of generators supported by CMake project.
Select "MinGW MakeFiles" item from the list
- Choose "Specify toolchain file for cross-compiling", and click "Next".
-@figure{/build/build_occt/images/android_image002.png}
+
- Specify a toolchain file at the next dialog to `android.toolchain.cmake`, and click "Finish".
-@figure{/build/build_occt/images/android_image003.png}
+
If `ANDROID_NDK` environment variable is not defined in current OS, add cache entry `ANDROID_NDK` (entry type is `PATH`) -- path to the NDK folder ("Add Entry" button):
-@figure{/build/build_occt/images/android_image004.png}
+
If on Windows the message is appeared:
"CMake Error: CMake was unable to find a build program corresponding to "MinGW Makefiles" CMAKE_MAKE_PROGRAM is not set. You probably need to select a different build tool.",
specify `CMAKE_MAKE_PROGRAM` to mingw32-make executable.
-@figure{/build/build_occt/images/android_image005.png}
+
-How to configure OCCT, see @ref build_cmake_conf "Configure" section taking into account the specific configuration variables for Android:
+How to configure OCCT, see [Configure](#build_cmake_conf) section taking into account the specific configuration variables for Android:
- `ANDROID_ABI` = `armeabi-v7a`
- `ANDROID_NATIVE_API_LEVEL` = `15`
- `ANDROID_NDK_LAYOUT` is equal to `CMAKE_BUILD_TYPE` variable
- `BUILD_MODULE_Draw` = `OFF`
-@figure{/build/build_occt/images/android_image006.png}
+
Click **Generate** button and wait until the generation process is finished.
Then makefiles will appear in the build folder (e.g. D:/tmp/occt-android ).
diff --git a/dox/contribution/coding_rules.md b/dox/coding_rules.md
similarity index 97%
rename from dox/contribution/coding_rules.md
rename to dox/coding_rules.md
index 70e151f020..86eefbd161 100644
--- a/dox/contribution/coding_rules.md
+++ b/dox/coding_rules.md
@@ -1,9 +1,6 @@
-Coding Rules {#occt_contribution__coding_rules}
-======================================
+# Coding Rules
-@tableofcontents
-
-@section occt_coding_rules_1 Introduction
+
The new integration branch is tested against possible regressions that might appear due to interference between separate changes.
When the tests are OK, the integration branch is pushed as the new master to the official repository.
@@ -289,12 +289,12 @@ The issue status is set then to **VERIFIED** and is assigned to the **Reporter**
The branches corresponding to the integrated fixes are removed from the repository by the **Bugmaster**.
-@subsection occt_contribution_workflow_close Closing an issue
+
Each document has its own folder if there are any images used in it. These images are stored in *images* subfolder.
@@ -127,16 +124,16 @@ If you want to use the same image for several documents, you can place it in *do
**Note**: To avoid incorrect image display, use a relative path to the image (starting from *dox* folder). For instance:
-@verbatim
-@figure{/contribution/documentation/images/documentation_test_image.svg,"",420}
-@endverbatim
+```
+
+```
The documentation is generated in subfolder *doc* :
* *html* -- a directory for generated HTML pages;
* *pdf* -- a directory for generated PDF files.
-@section OCCT_DM_SECTION_4 Adding a New Document
+
+```
The first argument is a path to the image file, relative to the *dox* folder.
The supported formats for images are PNG, JPG, and SVG.
@@ -414,13 +413,13 @@ Captions are included below the image; in PDF output the images with caption are
Example:
-@verbatim
- @figure{/contribution/documentation/images/documentation_test_image.svg,"Test SVG image"}
-@endverbatim
+```
+
+```
is rendered as:
-@figure{/contribution/documentation/images/documentation_test_image.svg,"Test SVG image",320}
+
We recommend using **Inkscape** for creation and edition of vector graphics.
The graphics created in MS Word Draw and some other vector editors can be copy-pasted to Inkscape and saved as SVG images.
@@ -429,19 +428,19 @@ Note that the image that will be included in documentation is the whole page of
Note that the *figure* command is an alias to the standard Doxygen command *image* repeated twice: once for HTML and then for Latex output (used for PDF generation). Thus if HTML and PDF outputs should include different images or captions, command "image" can be used:
-@verbatim
+```
@image html /relative/path/to/image/occ_logo_for_html.png
@image latex /relative/path/to/image/occ_logo_for_pdf.png
-@endverbatim
+```
-@subsection OCCT_DM_SECTION_A_8 Table Of Contents
+
Scripts can be written to customize Draw and perform tests.
New types of objects and new commands can be added using C++ programming language.
@@ -55,10 +54,10 @@ Declaration of available plug-ins is done through special resource file(s).
The *pload* command loads the plug-in in accordance with
the specified resource file and activates the commands implemented in the plug-in.
-The whole process of using the plug-in mechanism as well as the instructions for extending Test Harness is described in the @ref occt_user_guides__test_harness.
+The whole process of using the plug-in mechanism as well as the instructions for extending Test Harness is described in the [Link](draw_test_harness#occt_user_guides__test_harness).
Draw Test Harness provides an environment for OCCT automated testing system.
-Check its @ref occt_contribution__tests "Automated Testing System" for details.
+Check its [Automated Testing System](tests#occt_contribution__tests) for details.
Remarks:
@@ -68,8 +67,7 @@ Remarks:
Experimenting with Draw Test Harness
------------------------------------
- Running Draw
-------------
+ ### Running Draw
**On Linux:**
diff --git a/dox/user_guides/draw_test_harness/draw_test_harness.md b/dox/draw_test_harness.md
similarity index 87%
rename from dox/user_guides/draw_test_harness/draw_test_harness.md
rename to dox/draw_test_harness.md
index c1942e30cf..0eb2cee6ac 100644
--- a/dox/user_guides/draw_test_harness/draw_test_harness.md
+++ b/dox/draw_test_harness.md
@@ -1,14 +1,11 @@
-Draw Test Harness {#occt_user_guides__test_harness}
-===============================
-
-@tableofcontents
+# Draw Test Harness
-@section occt_draw_1 Introduction
+
-@subsubsection occt_draw_4_6_2 ivtkdisplay
+
-@subsubsection occt_draw_4_6_3 ivtkerase
+
-@subsubsection occt_draw_4_6_6 ivtksetselmode
+
-@subsubsection occt_draw_4_6_7 ivtkmoveto
+
~~~~{.php}
ivtkbgcolor 10 30 80 255 255 255
~~~~
-@figure{/user_guides/draw_test_harness/images/draw_image006.png,"",190}
+
-@section occt_draw_5 OCAF commands
+