BOPAlgo

The class provides the root interface for the algorithms in Boolean Component.

check the validity of argument(s) for Boolean Operations

The class represents the Building part of the Boolean Operations algorithm. The arguments of the algorithms are divided in two groups - Objects and Tools. The algorithm builds the splits of the given arguments using the intersection results and combines the result of Boolean Operation of given type:

• FUSE - union of two groups of objects;
• COMMON - intersection of two groups of objects;
• CUT - subtraction of one group from the other.
  The rules for the arguments and type of the operation are the following:
• For Boolean operation FUSE all arguments should have equal dimensions;
• For Boolean operation CUT the minimal dimension of Tools should not be less than the maximal dimension of Objects;
• For Boolean operation COMMON the arguments can have any dimension.
  The class is a General Fuse based algorithm. Thus, all options of the General Fuse algorithm such as Fuzzy mode, safe processing mode, parallel processing mode, gluing mode and history support are also available in this algorithm.
  Additionally to the Warnings of the parent class the algorithm returns the following warnings:
• BOPAlgo_AlertEmptyShape - in case some of the input shapes are empty shapes.
  Additionally to Errors of the parent class the algorithm returns the following Error statuses:
• BOPAlgo_AlertBOPIsNotSet - in case the type of Boolean operation is not set;
• BOPAlgo_AlertBOPNotAllowed - in case the operation of given type is not allowed on given inputs;
• BOPAlgo_AlertSolidBuilderFailed - in case the BuilderSolid algorithm failed to produce the Fused solid.

The class is a General Fuse algorithm - base algorithm for the algorithms in the Boolean Component. Its main purpose is to build the split parts of the argument shapes from which the result of the operations is combined. The result of the General Fuse algorithm itself is a compound containing all split parts of the arguments.
Additionally to the options of the base classes, the algorithm has the following options:

• Safe processing mode - allows to avoid modification of the input shapes during the operation (by default it is off);
• Gluing options - allows to speed up the calculation of the intersections on the special cases, in which some sub-shapes are coinciding.
• Disabling the check for inverted solids - Disables/Enables the check of the input solids for inverted status (holes in the space). The default value is TRUE, i.e. the check is performed. Setting this flag to FALSE for inverted solids, most likely will lead to incorrect results.
  The algorithm returns the following warnings:
• BOPAlgo_AlertUnableToOrientTheShape - in case the check on the orientation of the split shape to match the orientation of the original shape has failed.
  The algorithm returns the following Error statuses:
• BOPAlgo_AlertTooFewArguments - in case there are no enough arguments to perform the operation;
• BOPAlgo_AlertNoFiller - in case the intersection tool has not been created;
• BOPAlgo_AlertIntersectionFailed - in case the intersection of the arguments has failed;
• BOPAlgo_AlertBuilderFailed - in case building splits of arguments has failed with some unexpected error.

The root class for algorithms to build faces/solids from set of edges/faces.

The algorithm to build new faces from the given faces and set of edges lying on this face.
The algorithm returns the following Error statuses:

• BOPAlgo_AlertNullInputShapes - in case the given face is a null shape.

Root class for algorithms that has shape as result.
The class provides the History mechanism, which allows tracking the modification of the input shapes during the operation. It uses the BRepTools_History tool as a storer for history objects.

Solid Builder is the algorithm for building solids from set of faces. The given faces should be non-intersecting, i.e. all coinciding parts of the faces should be shared among them.
The algorithm performs the following steps to build the solids:

1. Find:faces orientated INTERNAL;alone faces given twice with different orientation;
2. Build all possible closed shells from the rest of the faces (BOPAlgo_ShellSplitter is used for that);
3. Classify the obtained shells on the Holes and Growths;
4. Build solids from the Growth shells, put Hole shells into closest Growth solids;
5. Classify all unused faces relatively created solids and put them as internal shells into the closest solids;
6. Find all unclassified faces, i.e. faces outside of all created solids, make internal shells from them and put these shells into a warning.
   It is possible to avoid all internal shells in the resulting solids. For that it is necessary to use the method SetAvoidInternalShapes(true) of the base class. In this case the steps 5 and 6 will not be performed at all.
   The algorithm may return the following warnings:

• BOPAlgo_AlertShellSplitterFailed in case the ShellSplitter algorithm has failed;
• BOPAlgo_AlertSolidBuilderUnusedFaces in case there are some faces outside of created solids left.
  Example of usage of the algorithm:

constNCollection_List<TopoDS_Shape>&aFaces=...;//Facestobuildthesolids boolisAvoidInternals=...;//Flagwhichdefineswhethertocreatethe internalshellsornotBOPAlgo_BuilderSolidaBS;//SolidBuildertool aBS.SetShapes(aFaces);//Setthefaces aBS.SetAvoidInternalShapes(isAvoidInternals);//SettheAvoidInternalShapesFlag aBS.Perform();//Performtheoperation if(!aBS.IsDone())//Checkfortheerrors { //errortreatment Standard_SStreamaSStream; aBS.DumpErrors(aSStream); return; } if(aBS.HasWarnings())//Checkforthewarnings { //warningstreatment Standard_SStreamaSStream; aBS.DumpWarnings(aSStream); } constNCollection_List<TopoDS_Shape>&aSolids=aBS.Areas();//Obtainingtheresultsolids

The algorithm is based on the General Fuse algorithm (GFA). The result of GFA is all split parts of the Arguments.
The purpose of this algorithm is to provide the result with the content of:

1. Cells (parts) defined by the user;
2. Internal boundaries defined by the user.
   In other words the algorithm should provide the possibility for the user to add or remove any part to (from) result and remove any internal boundaries between parts.
   All the requirements of GFA for the DATA are inherited in this algorithm. The arguments could be of any type (dimension) and should be valid in terms of BRepCheck_Analyzer and BOPAlgo_ArgumentAnalyzer.
   Results:
   The result of the algorithm is compound containing selected parts of the basic types (VERTEX, EDGE, FACE or SOLID). The default result is empty compound. It is possible to add any split part to the result by using the methods AddToRessult() and AddAllToResult(). It is also possible to remove any part from the result by using methods RemoveFromResult() and RemoveAllFromResult(). The method RemoveAllFromResult() is also suitable for clearing the result.
   To remove Internal boundaries it is necessary to set the same material to the parts between which the boundaries should be removed and call the method RemoveInternalBoundaries(). The material should not be equal to 0, as this is default material value. The boundaries between parts with this value will not be removed. One part cannot be added with the different materials. It is also possible to remove the boundaries during combining the result. To do this it is necessary to set the material for parts (not equal to 0) and set the flag bUpdate to TRUE.
   For the arguments of the types FACE or EDGE it is recommended to remove the boundaries in the end when the result is completely built. It will help to avoid self-intersections in the result.
   Note, that if the result contains the parts with same material but of different dimension the boundaries between such parts will not be removed. Currently, the removal of the internal boundaries between multi-dimensional shapes is not supported.
   It is possible to create typed Containers from the parts added to result by using method MakeContainers().
   The type of the containers will depend on the type of the arguments: WIRES for EEDGE, SHELLS for FACES and COMPSOLIDS for SOLIDS. The result will be compound containing containers. Adding of the parts to such result will not update containers. The result compound will contain the containers and new added parts (of basic type). Removing of the parts from such result may affect some containers if the parts that should be removed is in container. In this case this container will be rebuilt without that part.
   History:
   The algorithm supports history information for basic types of the shapes - VERTEX, EDGE, FACE. This information available through the methods IsDeleted() and Modified().
   In DRAW Test Harness it is available through the same commands as for Boolean Operations (bmodified, bgenerated and bisdeleted).
   The algorithm can return the following Error Statuses:

• Error status acquired in the General Fuse algorithm. The Error status can be checked with HasErrors() method. If the Error status is not equal to zero, the result cannot be trustworthy.
  The algorithm can set the following Warning Statuses:
• Warning status acquired in the General Fuse algorithm;
• BOPAlgo_AlertRemovalOfIBForMDimShapes
• BOPAlgo_AlertRemovalOfIBForFacesFailed
• BOPAlgo_AlertRemovalOfIBForEdgesFailed
• BOPAlgo_AlertRemovalOfIBForSolidsFailed
  The Warning status can be checked with HasWarnings() method or printed with the DumpWarnings() method. If warnings are recorded, the result may be not as expected.
  Examples:

API BOPAlgo_CellsBuilderaCBuilder; NCollection_List<TopoDS_Shape>aLS=...;//arguments //parallelorsinglemode(thedefaultvalueisFALSE) booltoRunParallel=false; //fuzzyoption(defaultvalueis0) doubleaTol=0.0; // aCBuilder.SetArguments(aLS); aCBuilder.SetRunParallel(toRunParallel); aCBuilder.SetFuzzyValue(aTol); // aCBuilder.Perform(); if(aCBuilder.HasErrors())//checkerrorstatus { return; } //emptycompound,asnothinghasbeenaddedyet constTopoDS_Shape&aRes=aCBuilder.Shape(); //allsplitparts constTopoDS_Shape&aRes=aCBuilder.GetAllParts(); // NCollection_List<TopoDS_Shape>aLSToTake=...;//partsoftheseargumentswillbetakeninto resultNCollection_List<TopoDS_Shape>aLSToAvoid=...;//partsoftheseargumentswillnotbe takenintoresult // //definesthematerialcommonforthecells, //i.e.theboundariesbetweencellswiththesamematerialwillberemoved. //Bydefaultitissetto0. //Thus,toremovesomeboundarythevalueofthisvariableshouldnotbeequalto0. intiMaterial=...;
//defineswhethertoupdatetheresultrightnowornot booltoUpdate=...; //addingtoresult aCBuilder.AddToResult(aLSToTake,aLSToAvoid,iMaterial,toUpdate); aR=aCBuilder.Shape();//theresult //removingoftheboundaries(shouldbecalledonlyiftoUpdateisfalse) aCBuilder.RemoveInternalBoundaries(); // //removingfromresult aCBuilder.AddAllToResult(); aCBuilder.RemoveFromResult(aLSToTake,aLSToAvoid); aR=aCBuilder.Shape();//theresult
2. DRAW Test Harness pspheres115 pspheres215 pspheres315 ttranslates10010 ttranslates220010 ttranslates31000 #addingarguments bclearobjects;bcleartools baddobjectss1s2s3 #intersection bfillds #rxwillcontainallsplitparts bcbuildrx #addtoresultthepartthatiscommonforallthreespheres bcaddress11s21s31-m1 #addtoresultthepartthatiscommononlyforfirstandthirdspheres bcaddress11s20s31-m1 #removeinternalboundaries bcremoveintres

Checks the shape on self-interference.
The algorithm can set the following errors:

• BOPAlgo_AlertMultipleArguments - The number of the input arguments is not one;
• BOPALgo_ErrorIntersectionFailed - The check has been aborted during intersection of sub-shapes. In case the error has occurred during intersection of sub-shapes, i.e. in BOPAlgo_PaveFiller::PerformInternal() method, the errors from this method directly will be returned.

contains information about faulty shapes and faulty types can't be processed by Boolean Operations

BOPAlgo_MakeConnected is the algorithm for making the touching shapes connected or glued, i.e. for making the coinciding geometries be topologically shared among the shapes.
The input shapes should be of the same dimension, otherwise the gluing will not make any sense.
After the shapes are made connected, the border elements of input shapes are associated with the shapes to which they belong. At that, the orientation of the border element in the shape is taken into account. The associations are made for the following types:

• For input SOLIDS, the resulting FACES are associated with the input solids;
• For input FACES, the resulting EDGES are associated with the input faces;
• For input EDGES, the resulting VERTICES are associated with the input edges.
  In frames of this algorithm the input shapes are called materials, and the association process is called the material association. The material association allows finding the coinciding elements for the opposite input shapes. These elements will be associated to at least two materials.
  After making the shapes connected, it is possible to make the connected shape periodic using the BOPAlgo_MakePeriodic tool. After making the shape periodic, the material associations will be updated to correspond to the actual state of the result shape. Repetition of the periodic shape is also possible here. Material associations are not going to be lost.
  The algorithm supports history of shapes modification, thus it is possible to track the modification of the input shapes during the operations. Additionally to standard history methods, the algorithm provides the the method GetOrigins() which allows obtaining the input shapes from which the resulting shape has been created.
  The algorithm supports the parallel processing mode, which allows faster completion of the operations.
  The algorithm returns the following Error/Warning messages:
• BOPAlgo_AlertTooFewArguments - error alert is given on the attempt to run the algorithm without the arguments;
• BOPAlgo_AlertMultiDimensionalArguments - error alert is given on the attempt to run the algorithm on multi-dimensional arguments;
• BOPAlgo_AlertUnableToGlue - error alert is given if the gluer algorithm is unable to glue the given arguments;
• BOPAlgo_AlertUnableToMakePeriodic - warning alert is given if the periodicity maker is unable to make the connected shape periodic with given options;
• BOPAlgo_AlertShapeIsNotPeriodic - warning alert is given on the attempt to repeat the shape before making it periodic.
  Here is the example of usage of the algorithm:

NCollection_List<TopoDS_Shape>anArguments=...;//Shapestomakeconnected boolbRunParallel=...;//Parallelprocessingmode BOPAlgo_MakeConnectedaMC;//Toolformakingtheshapesconnected aMC.SetArguments(anArguments);//Settheshapes aMC.SetRunParallel(bRunParallel);//Setparallelprocessingmode aMC.Perform();//Performtheoperation if(aMC.HasErrors())//Checkfortheerrors { //errorstreatment Standard_SStreamaSStream; aMC.DumpErrors(aSStream); return; } if(aMC.HasWarnings())//Checkforthewarnings { //warningstreatment Standard_SStreamaSStream; aMC.DumpWarnings(aSStream); } constTopoDS_Shape&aGluedShape=aMC.Shape();//Connectedshape //Checkingmaterialassociations TopAbs_ShapeEnumanElemType=...;//Typeofborderelement TopExp_ExploreranExp(anArguments.First(),anElemType); for(;anExp.More();anExp.Next()) { constTopoDS_Shape&anElement=anExp.Current(); constNCollection_List<TopoDS_Shape>&aNegativeM=aMC.MaterialsOnNegativeSide(anElement);constNCollection_List<TopoDS_Shape>&aPositiveM=aMC.MaterialsOnPositiveSide(anElement); } //Makingtheconnectedshapeperiodic BOPAlgo_MakePeriodic::PeriodicityParamsaParams=...;//Optionsforperiodicityofthe connectedshapeaMC.MakePeriodic(aParams); //Shaperepetitionaftermakingitperiodic //Checkiftheshapehasbeenmadeperiodicsuccessfully if(aMC.PeriodicityTool().HasErrors()) { //Periodicitymakererrortreatment } //Shaperepetitioninperiodicdirections aMC.RepeatShape(0,2); constTopoDS_Shape&aShape=aMC.PeriodicShape();//Periodicandrepeatedshape

BOPAlgo_MakePeriodic is the tool for making an arbitrary shape periodic in 3D space in specified directions.
Periodicity of the shape means that the shape can be repeated in any periodic direction any number of times without creation of the new geometry or splits.
The idea is to make the shape look identical on the opposite sides of the periodic directions, so when translating the copy of a shape on the period there will be no coinciding parts of different dimensions.
If necessary the algorithm will trim the shape to fit it into the requested period by splitting it by the planes limiting the shape's requested period.
For making the shape periodic in certain direction the algorithm performs the following steps:

• Creates the copy of the shape and moves it on the period into negative side of the requested direction;
• Splits the negative side of the shape by the moved copy, ensuring copying of the geometry from positive side to negative;
• Creates the copy of the shape (with already split negative side) and moves it on the period into the positive side of the requested direction;
• Splits the positive side of the shape by the moved copy, ensuring copying of the geometry from negative side to positive.
  The algorithm also associates the identical (or twin) shapes located on the opposite sides of the result shape. Using the GetTwins() method it is possible to get the twin shapes from the opposite sides.
  Algorithm also provides the methods to repeat the periodic shape in periodic directions. The subsequent repetitions are performed on the repeated shape, thus repeating the shape two times in X direction will create result in three shapes (original plus two copies). Single subsequent repetition will result already in 6 shapes. The repetitions can be cleared and started over.
  The algorithm supports History of shapes modifications, thus it is possible to track how the shape has been changed to make it periodic and what new shapes have been created during repetitions.
  The algorithm supports the parallel processing mode, which allows faster completion of the operations.
  The algorithm supports the Error/Warning system and returns the following alerts:
• BOPAlgo_AlertNoPeriodicityRequired - Error alert is given if no periodicity has been requested in any direction;
• BOPAlgo_AlertUnableToTrim - Error alert is given if the trimming of the shape for fitting it into requested period has failed;
• BOPAlgo_AlertUnableToMakeIdentical - Error alert is given if splitting of the shape by its moved copies has failed;
• BOPAlgo_AlertUnableToRepeat - Warning alert is given if the gluing of the repeated shapes has failed.
  Example of usage of the algorithm:

TopoDS_ShapeaShape=...;//Theshapetomakeperiodic boolbMakeXPeriodic=...;//FlagformakingornottheshapeperiodicinX directiondoubleaXPeriod=...;//Xperiodfortheshapebool isXTrimmed=...;//Flagdefiningwhetheritisnecessarytotrimming //theshapetofittoXperiod doubleaXFirst=...;//StartoftheXperiod //(reallynecessaryonlyifthetrimmingis requested) boolbRunParallel=...;//Parallelprocessingmodeorsingle BOPAlgo_MakePeriodicaPeriodicityMaker;//Periodicitymaker aPeriodicityMaker.SetShape(aShape);//Settheshape aPeriodicityMaker.MakeXPeriodic(bMakePeriodic,aXPeriod);//MakingtheshapeperiodicinX directionaPeriodicityMaker.SetTrimmed(isXTrimmed,aXFirst);//TrimtheshapetofitX periodaPeriodicityMaker.SetRunParallel(bRunParallel);//Settheparallelprocessing modeaPeriodicityMaker.Perform();//Performingtheoperation if(aPeriodicityMaker.HasErrors())//Checkfortheerrors { //errorstreatment Standard_SStreamaSStream; aPeriodicityMaker.DumpErrors(aSStream); return; }if(aPeriodicityMaker.HasWarnings())//Checkforthewarnings { //warningstreatment Standard_SStreamaSStream; aPeriodicityMaker.DumpWarnings(aSStream); } constTopoDS_Shape&aPeriodicShape=aPeriodicityMaker.Shape();//Resultperiodicshape aPeriodicityMaker.XRepeat(2);//Makingrepetitions constTopoDS_Shape&aRepeat=aPeriodicityMaker.RepeatedShape();//Gettingtherepeatedshape aPeriodicityMaker.ClearRepetitions();//Clearingtherepetitions

The algorithm is to build solids from set of shapes. It uses the BOPAlgo_Builder algorithm to intersect the given shapes and build the images of faces (if needed) and BOPAlgo_BuilderSolid algorithm to build the solids.
Steps of the algorithm:

1. Collect all faces: intersect the shapes if necessary and collect the images of faces, otherwise just collect the faces to the <myFaces> list; All faces on this step added twice, with orientation FORWARD and REVERSED;
2. Create bounding box covering all the faces from <myFaces> and create solid box from corner points of that bounding box (myBBox, mySBox). Add faces from that box to <myFaces>;
3. Build solids from <myFaces> using BOPAlgo_BuilderSolid algorithm;
4. Treat the result: Eliminate solid containing faces from <mySBox>;
5. Fill internal shapes: add internal vertices and edges into created solids;
6. Prepare the history.
   Fields: <myIntersect> - boolean flag. It defines whether intersect shapes from <myArguments> (if set to TRUE) or not (FALSE). The default value is TRUE. By setting it to FALSE the user should guarantee that shapes in <myArguments> do not interfere with each other, otherwise the result is unpredictable.
   <myBBox> - bounding box, covering all faces from <myFaces>.
   <mySBox> - Solid box created from the corner points of <myBBox>.
   <myFaces> - the list is to keep the "final" faces, that will be given to the BOPAlgo_BuilderSolid algorithm. If the shapes have been interfered it should contain the images of the source shapes, otherwise its just the original faces. It also contains the faces from <mySBox>.
   Fields inherited from BOPAlgo_Builder:
   <myArguments> - list of the source shapes. The source shapes can have any type, but each shape must not be self-interfered.
   <myShape> - Result shape:

• empty compound - if no solids were created;
• solid - if created only one solid;
• compound of solids - if created more than one solid.
  Fields inherited from BOPAlgo_Algo:
  <myRunParallel> - Defines whether the parallel processing is switched on or not. <myReport> - Error status of the operation. Additionally to the errors of the parent algorithm it can have the following values:
• BOPAlgo_AlertSolidBuilderFailed - BOPAlgo_BuilderSolid algorithm has failed.
  Example:
  BOPAlgo_MakerVolume aMV; // aMV.SetArguments(aLS); //source shapes aMV.SetRunParallel(bRunParallel); //parallel or single mode aMV.SetIntersect(bIntersect); //intersect or not the shapes from <aLS> // aMV.Perform(); //perform the operation if (aMV.HasErrors()) { //check error status return; } // const TopoDS_Shape& aResult = aMV.Shape(); //result of the operation