EIC code displayed by LXR master/​include/​opencascade/​BOPAlgo_BuilderSolid.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:03:03

 // Created by: Peter KURNEV
 // Copyright (c) 2010-2014 OPEN CASCADE SAS
 // Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
 // Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
 //                         EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _BOPAlgo_BuilderSolid_HeaderFile
 #define _BOPAlgo_BuilderSolid_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 
 #include <BOPAlgo_BuilderArea.hxx>
 #include <NCollection_BaseAllocator.hxx>
 #include <TopTools_DataMapOfShapeBox.hxx>
 
 
 //! 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:
 //! ~~~~
 //! const TopTools_ListOfShape& aFaces = ...;     // Faces to build the solids
 //! Standard_Boolean isAvoidInternals = ...;      // Flag which defines whether to create the internal shells or not
 //! BOPAlgo_BuilderSolid aBS;                     // Solid Builder tool
 //! aBS.SetShapes(aFaces);                        // Set the faces
 //! aBS.SetAvoidInternalShapes(isAvoidInternals); // Set the AvoidInternalShapesFlag
 //! aBS.Perform();                                // Perform the operation
 //! if (!aBS.IsDone())                            // Check for the errors
 //! {
 //!   // error treatment
 //!   Standard_SStream aSStream;
 //!   aBS.DumpErrors(aSStream);
 //!   return;
 //! }
 //! if (aBS.HasWarnings())                        // Check for the warnings
 //! {
 //!   // warnings treatment
 //!   Standard_SStream aSStream;
 //!   aBS.DumpWarnings(aSStream);
 //! }
 //!
 //! const TopTools_ListOfShape& aSolids = aBS.Areas(); // Obtaining the result solids
 //! ~~~~
 //!
 class BOPAlgo_BuilderSolid  : public BOPAlgo_BuilderArea
 {
 public:
 
   DEFINE_STANDARD_ALLOC
 
 public: //! @name Constructors
 
   //! Empty constructor
   Standard_EXPORT BOPAlgo_BuilderSolid();
   Standard_EXPORT virtual ~BOPAlgo_BuilderSolid();
 
   //! Constructor with allocator
   Standard_EXPORT BOPAlgo_BuilderSolid(const Handle(NCollection_BaseAllocator)& theAllocator);
 
 public: //! @name Performing the operation
 
   //! Performs the construction of the solids from the given faces
   Standard_EXPORT virtual void Perform(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
 
 public: //! @name Getting the bounding boxes of the created solids
 
   //! For classification purposes the algorithm builds the bounding boxes
   //! for all created solids. This method returns the data map of solid - box pairs.
   const TopTools_DataMapOfShapeBox& GetBoxesMap() const
   {
     return myBoxes;
   }
 
 protected: //! @name Protected methods performing the operation
 
   //! Collect the faces:
   //! - with INTERNAL orientation;
   //! - that are alone but given twice with different orientation.
   //! These faces will be put into the map *myShapesToAvoid* and will be
   //! avoided in shells construction, but will be classified later on.
   Standard_EXPORT virtual void PerformShapesToAvoid(const Message_ProgressRange& theRange) Standard_OVERRIDE;
 
   //! Build all possible closed shells from the given faces.
   //! The method fills the following maps:
   //! - myLoops - Created closed shells;
   //! - myLoopsInternal - The shells created from unused faces.
   Standard_EXPORT virtual void PerformLoops(const Message_ProgressRange& theRange) Standard_OVERRIDE;
 
   //! Classifies the created shells on the Holes and Growths.
   //! Creates the solids from the Growths shells.
   //! Puts the Hole shells into the closest Growths solids.
   Standard_EXPORT virtual void PerformAreas(const Message_ProgressRange& theRange) Standard_OVERRIDE;
 
   //! Classifies the unused faces relatively the created solids.
   //! Puts the classified faces into the closest solids as internal shells.
   //! Warns the user about unclassified faces if any.
   Standard_EXPORT virtual void PerformInternalShapes(const Message_ProgressRange& theRange) Standard_OVERRIDE;
 
 private:
 
   TopTools_DataMapOfShapeBox myBoxes; // Boxes of the produced solids
 
 };
 
 #endif // _BOPAlgo_BuilderSolid_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team