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

File indexing completed on 2026-09-20 09:16:59

 // Created on: 1993-07-12
 // Created by: Remi LEQUETTE
 // Copyright (c) 1993-1999 Matra Datavision
 // Copyright (c) 1999-2014 OPEN CASCADE SAS
 //
 // 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 _BRepBuilderAPI_MakeFace_HeaderFile
 #define _BRepBuilderAPI_MakeFace_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 
 #include <BRepLib_MakeFace.hxx>
 #include <BRepBuilderAPI_MakeShape.hxx>
 #include <Standard_Real.hxx>
 #include <BRepBuilderAPI_FaceError.hxx>
 class TopoDS_Face;
 class gp_Pln;
 class gp_Cylinder;
 class gp_Cone;
 class gp_Sphere;
 class gp_Torus;
 class Geom_Surface;
 class TopoDS_Wire;
 
 //! Provides methods to build faces.
 //!
 //! A face may be built:
 //!
 //! * From a surface.
 //!
 //! - Elementary surface from gp.
 //!
 //! - Surface from Geom.
 //!
 //! * From a surface and U,V values.
 //!
 //! * From a wire.
 //!
 //! - Find the surface automatically if possible.
 //!
 //! * From a surface and a wire.
 //!
 //! - A flag Inside is given, when this flag is True
 //! the wire is oriented to bound a finite area on
 //! the surface.
 //!
 //! * From a face and a wire.
 //!
 //! - The new wire is a perforation.
 class BRepBuilderAPI_MakeFace : public BRepBuilderAPI_MakeShape
 {
 public:
   DEFINE_STANDARD_ALLOC
 
   //! Not done.
   Standard_EXPORT BRepBuilderAPI_MakeFace();
 
   //! Load a face. useful to add wires.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const TopoDS_Face& F);
 
   //! Make a face from a plane.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Pln& P);
 
   //! Make a face from a cylinder.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Cylinder& C);
 
   //! Make a face from a cone.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Cone& C);
 
   //! Make a face from a sphere.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Sphere& S);
 
   //! Make a face from a torus.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Torus& C);
 
   //! Make a face from a Surface. Accepts tolerance value (TolDegen)
   //! for resolution of degenerated edges.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const occ::handle<Geom_Surface>& S,
                                           const double                     TolDegen);
 
   //! Make a face from a plane.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Pln& P,
                                           const double  UMin,
                                           const double  UMax,
                                           const double  VMin,
                                           const double  VMax);
 
   //! Make a face from a cylinder.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Cylinder& C,
                                           const double       UMin,
                                           const double       UMax,
                                           const double       VMin,
                                           const double       VMax);
 
   //! Make a face from a cone.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Cone& C,
                                           const double   UMin,
                                           const double   UMax,
                                           const double   VMin,
                                           const double   VMax);
 
   //! Make a face from a sphere.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Sphere& S,
                                           const double     UMin,
                                           const double     UMax,
                                           const double     VMin,
                                           const double     VMax);
 
   //! Make a face from a torus.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Torus& C,
                                           const double    UMin,
                                           const double    UMax,
                                           const double    VMin,
                                           const double    VMax);
 
   //! Make a face from a Surface. Accepts tolerance value (TolDegen)
   //! for resolution of degenerated edges.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const occ::handle<Geom_Surface>& S,
                                           const double                     UMin,
                                           const double                     UMax,
                                           const double                     VMin,
                                           const double                     VMax,
                                           const double                     TolDegen);
 
   //! Find a surface from the wire and make a face.
   //! if <OnlyPlane> is true, the computed surface will be
   //! a plane. If it is not possible to find a plane, the
   //! flag NotDone will be set.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const TopoDS_Wire& W, const bool OnlyPlane = false);
 
   //! Make a face from a plane and a wire.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Pln&      P,
                                           const TopoDS_Wire& W,
                                           const bool         Inside = true);
 
   //! Make a face from a cylinder and a wire.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Cylinder& C,
                                           const TopoDS_Wire& W,
                                           const bool         Inside = true);
 
   //! Make a face from a cone and a wire.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Cone&     C,
                                           const TopoDS_Wire& W,
                                           const bool         Inside = true);
 
   //! Make a face from a sphere and a wire.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Sphere&   S,
                                           const TopoDS_Wire& W,
                                           const bool         Inside = true);
 
   //! Make a face from a torus and a wire.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const gp_Torus&    C,
                                           const TopoDS_Wire& W,
                                           const bool         Inside = true);
 
   //! Make a face from a Surface and a wire.
   //! If the surface S is not plane,
   //! it must contain pcurves for all edges in W,
   //! otherwise the wrong shape will be created.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const occ::handle<Geom_Surface>& S,
                                           const TopoDS_Wire&               W,
                                           const bool                       Inside = true);
 
   //! Adds the wire <W> in the face <F>
   //! A general method to create a face is to give
   //! -      a surface S as the support (the geometric domain) of the face,
   //! -      and a wire W to bound it.
   //! The bounds of the face can also be defined by four parameter values
   //! umin, umax, vmin, vmax which determine isoparametric limitations on
   //! the parametric space of the surface. In this way, a patch is
   //! defined. The parameter values are optional. If they are omitted, the
   //! natural bounds of the surface are used. A wire is automatically
   //! built using the defined bounds. Up to four edges and four vertices
   //! are created with this wire (no edge is created when the
   //! corresponding parameter value is infinite).
   //! Wires can then be added using the function Add to define other
   //! restrictions on the face. These restrictions represent holes. More
   //! than one wire may be added by this way, provided that the wires do
   //! not cross each other and that they define only one area on the
   //! surface. (Be careful, however, as this is not checked).
   //! Forbidden addition of wires
   //! Note that in this schema, the third case is valid if edges of the
   //! wire W are declared internal to the face. As a result, these edges
   //! are no longer bounds of the face.
   //! A default tolerance (Precision::Confusion()) is given to the face,
   //! this tolerance may be increased during construction of the face
   //! using various algorithms.
   //! Rules applied to the arguments
   //! For the surface:
   //! -      The surface must not be a 'null handle'.
   //! -      If the surface is a trimmed surface, the basis surface is used.
   //! -      For the wire: the wire is composed of connected edges, each
   //! edge having a parametric curve description in the parametric
   //! domain of the surface; in other words, as a pcurve.
   //! For the parameters:
   //! -      The parameter values must be in the parametric range of the
   //! surface (or the basis surface, if the surface is trimmed). If this
   //! condition is not satisfied, the face is not built, and the Error
   //! function will return BRepBuilderAPI_ParametersOutOfRange.
   //! -      The bounding parameters p1 and p2 are adjusted on a periodic
   //! surface in a given parametric direction by adding or subtracting
   //! the period to obtain p1 in the parametric range of the surface and
   //! such p2, that p2 - p1 <= Period, where Period is the period of the
   //! surface in this parametric direction.
   //! -      A parameter value may be infinite. There will be no edge and
   //! no vertex in the corresponding direction.
   Standard_EXPORT BRepBuilderAPI_MakeFace(const TopoDS_Face& F, const TopoDS_Wire& W);
 
   //! Initializes (or reinitializes) the
   //! construction of a face by creating a new object which is a copy of
   //! the face F, in order to add wires to it, using the function Add.
   //! Note: this complete copy of the geometry is only required if you
   //! want to work on the geometries of the two faces independently.
   Standard_EXPORT void Init(const TopoDS_Face& F);
 
   //! Initializes (or reinitializes) the construction of a face on
   //! the surface S. If Bound is true, a wire is
   //! automatically created from the natural bounds of the
   //! surface S and added to the face in order to bound it. If
   //! Bound is false, no wire is added. This option is used
   //! when real bounds are known. These will be added to
   //! the face after this initialization, using the function Add.
   //! TolDegen parameter is used for resolution of degenerated edges
   //! if calculation of natural bounds is turned on.
   Standard_EXPORT void Init(const occ::handle<Geom_Surface>& S,
                             const bool                       Bound,
                             const double                     TolDegen);
 
   //! Initializes (or reinitializes) the construction of a face on
   //! the surface S, limited in the u parametric direction by
   //! the two parameter values UMin and UMax and in the
   //! v parametric direction by the two parameter values VMin and VMax.
   //! Warning
   //! Error returns:
   //! -      BRepBuilderAPI_ParametersOutOfRange
   //! when the parameters given are outside the bounds of the
   //! surface or the basis surface of a trimmed surface.
   //! TolDegen parameter is used for resolution of degenerated edges.
   Standard_EXPORT void Init(const occ::handle<Geom_Surface>& S,
                             const double                     UMin,
                             const double                     UMax,
                             const double                     VMin,
                             const double                     VMax,
                             const double                     TolDegen);
 
   //! Adds the wire W to the constructed face as a hole.
   //! Warning
   //! W must not cross the other bounds of the face, and all
   //! the bounds must define only one area on the surface.
   //! (Be careful, however, as this is not checked.)
   //! Example
   //! // a cylinder
   //! gp_Cylinder C = ..;
   //! // a wire
   //! TopoDS_Wire W = ...;
   //! BRepBuilderAPI_MakeFace MF(C);
   //! MF.Add(W);
   //! TopoDS_Face F = MF;
   Standard_EXPORT void Add(const TopoDS_Wire& W);
 
   //! Returns true if this algorithm has a valid face.
   Standard_EXPORT bool IsDone() const override;
 
   //! Returns the construction status
   //! BRepBuilderAPI_FaceDone if the face is built, or
   //! -   another value of the BRepBuilderAPI_FaceError
   //! enumeration indicating why the construction failed, in
   //! particular when the given parameters are outside the
   //! bounds of the surface.
   Standard_EXPORT BRepBuilderAPI_FaceError Error() const;
 
   //! Returns the constructed face.
   //! Exceptions
   //! StdFail_NotDone if no face is built.
   Standard_EXPORT const TopoDS_Face& Face() const;
   Standard_EXPORT                    operator TopoDS_Face() const;
 
 private:
   BRepLib_MakeFace myMakeFace;
 };
 
 #endif // _BRepBuilderAPI_MakeFace_HeaderFile

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