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

File indexing completed on 2026-09-12 09:16:51

 // Created on: 1991-07-23
 // Created by: Christophe MARION
 // Copyright (c) 1991-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 _BRepPrim_OneAxis_HeaderFile
 #define _BRepPrim_OneAxis_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 
 #include <BRepPrim_Builder.hxx>
 #include <gp_Ax2.hxx>
 #include <TopoDS_Shell.hxx>
 #include <TopoDS_Vertex.hxx>
 #include <TopoDS_Edge.hxx>
 #include <TopoDS_Wire.hxx>
 #include <TopoDS_Face.hxx>
 class gp_Pnt2d;
 
 //! Algorithm to build primitives with one axis of
 //! revolution.
 //!
 //! The revolution body is described by:
 //!
 //! A coordinate system (Ax2 from gp). The Z axis is
 //! the rotational axis.
 //!
 //! An Angle around the Axis, When the Angle is 2*PI
 //! the primitive is not limited by planar faces. The
 //! U parameter range from 0 to Angle.
 //!
 //! A parameter range VMin, VMax on the meridian.
 //!
 //! A meridian: The meridian is a curve described by
 //! a set of deferred methods.
 //!
 //! The topology consists of A shell, Faces, Wires,
 //! Edges and Vertices. Methods are provided to build
 //! all the elements. Building an element implies the
 //! automatic building of all its sub-elements.
 //!
 //! So building the shell builds everything.
 //!
 //! There are at most 5 faces:
 //!
 //! - The LateralFace.
 //! - The TopFace and the BottomFace.
 //! - The StartFace and the EndFace.
 class BRepPrim_OneAxis
 {
 public:
   DEFINE_STANDARD_ALLOC
 
   //! The MeridianOffset is added to the parameters on
   //! the meridian curve and to the V values of the
   //! pcurves. This is used for the sphere for example,
   //! to give a range on the meridian edge which is not
   //! VMin, VMax.
   Standard_EXPORT void SetMeridianOffset(const double MeridianOffset = 0);
 
   //! Returns the Ax2 from <me>.
   Standard_EXPORT const gp_Ax2& Axes() const;
 
   Standard_EXPORT void Axes(const gp_Ax2& A);
 
   Standard_EXPORT double Angle() const;
 
   Standard_EXPORT void Angle(const double A);
 
   Standard_EXPORT double VMin() const;
 
   Standard_EXPORT void VMin(const double V);
 
   Standard_EXPORT double VMax() const;
 
   Standard_EXPORT void VMax(const double V);
 
   //! Returns a face with no edges. The surface is the
   //! lateral surface with normals pointing outward. The
   //! U parameter is the angle with the origin on the X
   //! axis. The V parameter is the parameter of the
   //! meridian.
   Standard_EXPORT virtual TopoDS_Face MakeEmptyLateralFace() const = 0;
 
   //! Returns an edge with a 3D curve made from the
   //! meridian in the XZ plane rotated by <Ang> around
   //! the Z-axis. Ang may be 0 or myAngle.
   Standard_EXPORT virtual TopoDS_Edge MakeEmptyMeridianEdge(const double Ang) const = 0;
 
   //! Sets the parametric curve of the edge <E> in the
   //! face <F> to be the 2d representation of the
   //! meridian.
   Standard_EXPORT virtual void SetMeridianPCurve(TopoDS_Edge& E, const TopoDS_Face& F) const = 0;
 
   //! Returns the meridian point at parameter <V> in the
   //! plane XZ.
   Standard_EXPORT virtual gp_Pnt2d MeridianValue(const double V) const = 0;
 
   //! Returns True if the point of parameter <V> on the
   //! meridian is on the Axis. Default implementation is
   //! std::abs(MeridianValue(V).X()) < Precision::Confusion()
   Standard_EXPORT virtual bool MeridianOnAxis(const double V) const;
 
   //! Returns True if the meridian is closed.
   //! Default implementation is:
   //! MeridianValue(VMin).IsEqual(MeridianValue(VMax),
   //! Precision::Confusion())
   Standard_EXPORT virtual bool MeridianClosed() const;
 
   //! Returns True if VMax is infinite.
   //! Default Precision::IsPositiveInfinite(VMax);
   Standard_EXPORT virtual bool VMaxInfinite() const;
 
   //! Returns True if VMin is infinite.
   //! Default Precision::IsNegativeInfinite(VMax);
   Standard_EXPORT virtual bool VMinInfinite() const;
 
   //! Returns True if there is a top face.
   //!
   //! That is neither: VMaxInfinite()
   //! MeridianClosed()
   //! MeridianOnAxis(VMax)
   Standard_EXPORT virtual bool HasTop() const;
 
   //! Returns True if there is a bottom face.
   //!
   //! That is neither: VMinInfinite()
   //! MeridianClosed()
   //! MeridianOnAxis(VMin)
   Standard_EXPORT virtual bool HasBottom() const;
 
   //! Returns True if there are Start and End faces.
   //!
   //! That is: 2*PI - Angle > Precision::Angular()
   Standard_EXPORT virtual bool HasSides() const;
 
   //! Returns the Shell containing all the Faces of the
   //! primitive.
   Standard_EXPORT const TopoDS_Shell& Shell();
 
   //! Returns the lateral Face. It is oriented toward
   //! the outside of the primitive.
   Standard_EXPORT const TopoDS_Face& LateralFace();
 
   //! Returns the top planar Face. It is Oriented
   //! toward the +Z axis (outside).
   Standard_EXPORT const TopoDS_Face& TopFace();
 
   //! Returns the Bottom planar Face. It is Oriented
   //! toward the -Z axis (outside).
   Standard_EXPORT const TopoDS_Face& BottomFace();
 
   //! Returns the Face starting the slice, it is
   //! oriented toward the exterior of the primitive.
   Standard_EXPORT const TopoDS_Face& StartFace();
 
   //! Returns the Face ending the slice, it is oriented
   //! toward the exterior of the primitive.
   Standard_EXPORT const TopoDS_Face& EndFace();
 
   //! Returns the wire in the lateral face.
   Standard_EXPORT const TopoDS_Wire& LateralWire();
 
   //! Returns the wire in the lateral face with the
   //! start edge.
   Standard_EXPORT const TopoDS_Wire& LateralStartWire();
 
   //! Returns the wire with in lateral face with the end
   //! edge.
   Standard_EXPORT const TopoDS_Wire& LateralEndWire();
 
   //! Returns the wire in the top face.
   Standard_EXPORT const TopoDS_Wire& TopWire();
 
   //! Returns the wire in the bottom face.
   Standard_EXPORT const TopoDS_Wire& BottomWire();
 
   //! Returns the wire in the start face.
   Standard_EXPORT const TopoDS_Wire& StartWire();
 
   //! Returns the wire in the start face with the
   //! AxisEdge.
   Standard_EXPORT const TopoDS_Wire& AxisStartWire();
 
   //! Returns the Wire in the end face.
   Standard_EXPORT const TopoDS_Wire& EndWire();
 
   //! Returns the Wire in the end face with the
   //! AxisEdge.
   Standard_EXPORT const TopoDS_Wire& AxisEndWire();
 
   //! Returns the Edge built along the Axis and oriented
   //! on +Z of the Axis.
   Standard_EXPORT const TopoDS_Edge& AxisEdge();
 
   //! Returns the Edge at angle 0.
   Standard_EXPORT const TopoDS_Edge& StartEdge();
 
   //! Returns the Edge at angle Angle. If !HasSides()
   //! the StartEdge and the EndEdge are the same edge.
   Standard_EXPORT const TopoDS_Edge& EndEdge();
 
   //! Returns the linear Edge between start Face and top
   //! Face.
   Standard_EXPORT const TopoDS_Edge& StartTopEdge();
 
   //! Returns the linear Edge between start Face and
   //! bottom Face.
   Standard_EXPORT const TopoDS_Edge& StartBottomEdge();
 
   //! Returns the linear Edge between end Face and top
   //! Face.
   Standard_EXPORT const TopoDS_Edge& EndTopEdge();
 
   //! Returns the linear Edge between end Face and
   //! bottom Face.
   Standard_EXPORT const TopoDS_Edge& EndBottomEdge();
 
   //! Returns the edge at VMax. If MeridianClosed() the
   //! TopEdge and the BottomEdge are the same edge.
   Standard_EXPORT const TopoDS_Edge& TopEdge();
 
   //! Returns the edge at VMin. If MeridianClosed() the
   //! TopEdge and the BottomEdge are the same edge.
   Standard_EXPORT const TopoDS_Edge& BottomEdge();
 
   //! Returns the Vertex at the Top altitude on the axis.
   Standard_EXPORT const TopoDS_Vertex& AxisTopVertex();
 
   //! Returns the Vertex at the Bottom altitude on the
   //! axis.
   Standard_EXPORT const TopoDS_Vertex& AxisBottomVertex();
 
   //! Returns the vertex (0,VMax)
   Standard_EXPORT const TopoDS_Vertex& TopStartVertex();
 
   //! Returns the vertex (angle,VMax)
   Standard_EXPORT const TopoDS_Vertex& TopEndVertex();
 
   //! Returns the vertex (0,VMin)
   Standard_EXPORT const TopoDS_Vertex& BottomStartVertex();
 
   //! Returns the vertex (angle,VMax)
   Standard_EXPORT const TopoDS_Vertex& BottomEndVertex();
   Standard_EXPORT virtual ~BRepPrim_OneAxis();
 
 protected:
   //! Creates a OneAxis algorithm. <B> is used to build
   //! the Topology. The angle defaults to 2*PI.
   Standard_EXPORT BRepPrim_OneAxis(const BRepPrim_Builder& B,
                                    const gp_Ax2&           A,
                                    const double            VMin,
                                    const double            VMax);
 
   BRepPrim_Builder myBuilder;
 
 private:
   //! Returns true if the geometric height ordering is inverted,
   //! i.e., MeridianValue(VMax).Y() < MeridianValue(VMin).Y().
   //! When true, VMin corresponds to geometric top and VMax to geometric bottom.
   //! This can occur with torus when V range like (90deg, 270deg) is used.
   bool isHeightInverted() const;
 
   //! Returns true if the heights at VMin and VMax are equal (within tolerance).
   //! This indicates the AxisEdge would be degenerate (zero length).
   bool areHeightsEqual() const;
 
   gp_Ax2        myAxes;
   double        myAngle;
   double        myVMin;
   double        myVMax;
   double        myMeridianOffset;
   TopoDS_Shell  myShell;
   bool          ShellBuilt;
   TopoDS_Vertex myVertices[6];
   bool          VerticesBuilt[6];
   TopoDS_Edge   myEdges[9];
   bool          EdgesBuilt[9];
   TopoDS_Wire   myWires[9];
   bool          WiresBuilt[9];
   TopoDS_Face   myFaces[5];
   bool          FacesBuilt[5];
 };
 
 #endif // _BRepPrim_OneAxis_HeaderFile

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