Integration of OCCT 6.5.0 from SVN

src/Primitives/Primitives.cdl

@@ -0,0 +1,45 @@
+-- File:	Primitives.cdl
+-- Created:	Tue Jul 23 11:36:48 1991
+-- Author:	Christophe MARION
+--		<cma@sdsun1>
+---Copyright:	 Matra Datavision 1991
+
+
+
+package Primitives 
+
+	---Purpose: This  package   describes   algorithms  to   build
+	--          topological primitives.
+	--          
+	--          The algorithms  in  this package  are  generic. It
+	--          contains :
+	--          
+	--           *   The Builder  signature   class. Describes the
+	--           services    required  from    the  Topology  Data
+	--           Structure to build the following primitives.
+	--          
+	--           * The  OneAxis generic class.  Algorithm  used to
+	--           build rotational primitives.
+	--               
+	--           *  The  Wedge  generic  class. Algorithm to build
+	--           boxes and wedges.
+
+uses
+    gp        -- gp provides all geometrical information
+
+is
+
+
+    enumeration Direction is 
+	---Purpose: 
+    	XMin, XMax, YMin, YMax, ZMin, ZMax
+    end Direction;
+
+
+    deferred generic class Builder;
+    
+    deferred generic class OneAxis;
+    	
+    generic class Wedge; 
+    
+end Primitives;

src/Primitives/Primitives_Builder.cdl

@@ -0,0 +1,152 @@
+-- File:	Builder.cdl
+-- Created:	Thu Mar 12 11:04:50 1992
+-- Author:	Philippe DAUTRY
+--		<fid@sdsun1>
+---Copyright:	 Matra Datavision 1992
+
+
+
+deferred generic class Builder from Primitives(
+    TheShell  as any;
+    TheFace   as any;
+    TheWire   as any;
+    TheEdge   as any;
+    TheVertex as any)
+
+	---Purpose: This is a signature class describing services from
+	--          the  Topology Data   Structure   required  by  the
+	--          Primitives algorithms.
+
+uses
+    Pnt      from gp,
+    Lin      from gp,
+    Circ     from gp,
+    Pln      from gp,
+    
+    Lin2d    from gp,
+    Circ2d   from gp
+
+is
+    MakeShell (me; S : out TheShell)
+	---Purpose: Make a empty Shell.
+    is deferred;
+    
+    MakeFace (me; F : out TheFace; P : Pln from gp)
+	---Purpose: Returns in   <F> a  Face  built  with   the  plane
+	--          equation <P>.
+    is deferred;
+    
+    MakeWire(me; W : out TheWire)
+	---Purpose: Returns in <W> an empty Wire.
+    is deferred;
+    
+    MakeDegeneratedEdge (me; E : out TheEdge)
+	---Purpose: Returns in <E> a degenerated edge.
+    is deferred;
+
+    MakeEdge (me; E : out TheEdge; L : Lin from gp)
+	---Purpose: Returns   in <E>  an  Edge  built  with  the  line
+	--          equation  <L>.
+    is deferred;
+
+    MakeEdge (me; E : out TheEdge; C : Circ from gp)
+	---Purpose: Returns  in <E>   an  Edge  built  with the circle
+	--          equation  <C>.
+    is deferred;
+    
+    SetPCurve(me; E : in out TheEdge; F : in TheFace; L : Lin2d from gp)
+	---Purpose: Sets the line <L> to be the curve representing the
+	--          edge <E> in the parametric space of the surface of
+	--          <F>.
+    is deferred;
+    
+    SetPCurve(me; E : in out TheEdge; F : in TheFace; L1,L2 : Lin2d from gp)
+	---Purpose: Sets the    lines  <L1,L2>  to   be     the curves
+	--          representing the edge <E>  in the parametric space
+	--          of the surface of <F>. The surface is closed.
+    is deferred;
+    
+    SetPCurve(me; E : in out TheEdge; F : in TheFace; C : Circ2d from gp)
+	---Purpose: Sets the  circle <C> to  be the curve representing
+	--          the  edge <E>  in   the  parametric  space of  the
+	--          surface of <F>.
+    is deferred;
+    
+    MakeVertex (me; V : out TheVertex; P : Pnt from gp)
+	---Purpose: Returns in <V> a Vertex built with the point <P>.
+    is deferred;
+    
+    ReverseFace(me; F : in out TheFace)
+	---Purpose: Change the orientation of the face.
+    is deferred;
+    
+    AddEdgeVertex(me;
+    	    	    E      : in out TheEdge; 
+    	    	    V      : in     TheVertex;
+		    P      : in     Real;
+    	    	    direct : Boolean)
+	  ---Purpose: Adds the Vertex <V> in the Edge <E>. <P> is the
+	  --          parameter of the vertex on the edge. If <direct>
+	  --          is False the Vertex is reversed.
+    is deferred;
+
+    AddEdgeVertex(me;
+    	    	    E      : in out TheEdge; 
+    	    	    V      : in     TheVertex;
+		    P1,P2  : in     Real)
+	  ---Purpose: Adds the Vertex <V> in the Edge <E>. <P1,P2> are
+	  --          the parameters of  the vertex on the  edge.  The
+	  --          edge is a closed curve.
+    is deferred;
+
+    SetParameters(me;
+    	    	    E      : in out TheEdge; 
+    	    	    V      : in     TheVertex;
+		    P1,P2  : in     Real)
+	  ---Purpose: <P1,P2> are the parameters of the  vertex on the
+	  --          edge.  The edge is a closed curve.
+    is deferred;
+
+    AddWireEdge(me;
+    	    	    W      : in out TheWire; 
+                    E      : in     TheEdge;
+    	    	    direct : Boolean)
+	  ---Purpose: Adds the Edge <E> in the  Wire <W>, if direct is
+	  --          False the Edge is reversed.
+    is deferred;
+
+    AddFaceWire(me;
+    	    	    F      : in out TheFace; 
+                    W      : in     TheWire)
+	  ---Purpose: Adds the Wire <W> in  the Face <F>.
+    is deferred;
+
+    AddShellFace(me;
+    	    	    Sh     : in out TheShell; 
+                    F      : in     TheFace)
+	  ---Purpose: Adds the Face <F>  in the Shell <Sh>.
+    is deferred;
+
+    CompleteEdge(me; E : in out TheEdge)
+	---Purpose: This is called once an edge is completed. It gives
+	--          the opportunity to perform any post treatment.
+    is deferred;
+    
+    CompleteWire(me; W : in out TheWire)
+	---Purpose: This is called once a wire is  completed. It gives
+	--          the opportunity to perform any post treatment.
+    is deferred;
+    
+    CompleteFace(me; F : in out TheFace)
+	---Purpose: This is called once a face is  completed. It gives
+	--          the opportunity to perform any post treatment.
+    is deferred;
+    
+    CompleteShell(me; S : in out TheShell)
+	---Purpose: This is called once a shell is  completed. It gives
+	--          the opportunity to perform any post treatment.
+    is deferred;
+    
+end Builder from Primitives;
+
+

src/Primitives/Primitives_Builder.gxx

@@ -0,0 +1,4 @@
+// File:	Primitives_Builder.gxx
+// Created:	Thu Jul 15 16:02:09 1993
+// Author:	Remi LEQUETTE
+//		<rle@nonox>

src/Primitives/Primitives_OneAxis.cdl

@@ -0,0 +1,485 @@
+-- File:	OneAxis.cdl
+-- Created:	Tue Jul 23 14:01:59 1991
+-- Author:	Christophe MARION
+--		<cma@sdsun1>
+---Copyright:	 Matra Datavision 1991, 1992
+
+
+
+
+deferred generic class OneAxis from Primitives(
+    TheShell           as any;
+    TheFace            as any;
+    TheWire            as any;
+    TheEdge            as any;
+    TheVertex          as any;
+    TheBuilder         as any)  -- as Builder          from Primitives;
+    
+	---Purpose: 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.
+	--         
+
+
+
+uses
+    Ax2   from gp,
+    Pnt2d from gp
+    
+raises
+    DomainError,
+    OutOfRange
+
+is
+    Delete(me:out) is virtual ;
+    ---C++: alias ~
+    
+    Initialize(B : TheBuilder; 
+    	       A : Ax2 from gp; 
+    	       VMin, VMax : Real from  Standard);
+	---Purpose: Creates a OneAxis algorithm.  <B> is used to build
+	--          the Topology. The angle defaults to 2*PI.
+
+
+    SetMeridianOffset(me: in out;MeridianOffset : Real from Standard = 0)
+	---Purpose: 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.
+    is static;
+
+    Axes(me) returns Ax2 from gp
+	---Purpose: Returns the Ax2 from <me>.
+	---C++: return const &
+    is static;
+
+    Axes(me : in out; A : Ax2 from gp)
+    raises DomainError -- when some topology has been built or A > 2*PI
+    is static;
+
+    Angle(me) returns Real
+    is static;
+    
+    Angle(me : in out; A : Real)
+    raises DomainError -- when some topology has been built or A > 2*PI
+    is static;
+    
+    VMin(me) returns Real
+    is static;
+    
+    VMin(me : in out; V : Real)
+    raises DomainError -- when some topology has been built
+    is static;
+    
+    VMax(me) returns Real
+    is static;
+    
+    VMax(me : in out; V : Real)
+    raises DomainError -- when some topology has been built
+    is static;
+    
+    --
+    --     Methods to describe the meridian
+    --     They should be redefined in inherited classes
+    --     
+    
+    MakeEmptyLateralFace(me) returns TheFace
+	---Purpose: 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.
+    is deferred;
+    
+    MakeEmptyMeridianEdge(me; Ang : Real) returns TheEdge
+	---Purpose: 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.
+    is deferred;
+    
+    SetMeridianPCurve(me; E : in out TheEdge; F : TheFace)
+	---Purpose: Sets the  parametric curve of the  edge <E> in the
+	--          face  <F> to be  the   2d representation  of   the
+	--          meridian.
+    is deferred;
+    
+    MeridianValue(me; V : Real) returns Pnt2d from gp
+	---Purpose: Returns the meridian point at parameter <V> in the
+	--          plane XZ.
+    is deferred;
+    
+    MeridianOnAxis(me; V : Real) returns Boolean
+	---Purpose: Returns True if the point of  parameter <V> on the
+	--          meridian is on the Axis. Default implementation is
+	--          Abs(MeridianValue(V).X()) < Precision::Confusion()
+    is virtual;
+    
+    MeridianClosed(me) returns Boolean
+	---Purpose: Returns True  if the  meridian is  closed. Default
+	--          implementation                                  is
+	--          MeridianValue(VMin).IsEqual(MeridianValue(VMax),
+	--                                      Precision::Confusion()) 
+    is virtual;
+    
+    VMaxInfinite(me) returns Boolean
+	---Purpose: Returns  True   if  VMax    is  infinite.  Default
+	--          Precision::IsPositiveInfinite(VMax);
+    is virtual;
+	
+    VMinInfinite(me) returns Boolean
+	---Purpose: Returns  True   if  VMin    is  infinite.  Default
+	--          Precision::IsNegativeInfinite(VMax);
+    is virtual;
+	
+    
+    -- Usefull booleans
+    
+    HasTop(me) returns Boolean
+	---Purpose: Returns True if  there is  a top  face.
+	--          
+	--          That is neither : VMaxInfinite()   
+	--                            MeridianClosed()
+	--                            MeridianOnAxis(VMax)
+    is virtual;
+     
+    HasBottom(me) returns Boolean
+	---Purpose: Returns   True if there is   a bottom  face.
+	--          
+	--          That is neither : VMinInfinite()   
+	--                            MeridianClosed()
+	--                            MeridianOnAxis(VMin)
+    is virtual;
+     
+    HasSides(me) returns Boolean
+	---Purpose: Returns True if  there are Start   and  End faces.
+	--          
+	--          That is : 2*PI  - Angle > Precision::Angular()
+    is virtual;
+
+
+    --
+    -- Methods to get the Topology of:
+    -- 
+
+    -- the shell
+    Shell(me : in out) returns TheShell
+	---Purpose: Returns the Shell containing all the  Faces of the
+	--          primitive.
+	--          
+	---C++: return const &
+    is static;
+
+    -- the Faces
+
+    LateralFace(me : in out) returns TheFace
+	---Purpose: Returns  the lateral Face.   It is oriented toward
+	--          the outside of the primitive.
+	--          
+	---C++: return const &
+    is static;
+
+    TopFace(me : in out) returns TheFace
+	---Purpose: Returns the   top planar  Face.    It  is Oriented
+	--          toward the +Z axis (outside).
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasTop()
+    is static;
+    
+    BottomFace(me : in out) returns TheFace
+	---Purpose: Returns  the Bottom planar Face.   It is  Oriented
+	--          toward the -Z axis (outside).
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasBottom()
+    is static;
+    
+    StartFace(me : in out) returns TheFace
+	---Purpose: Returns  the  Face   starting   the slice, it   is
+	--          oriented toward the exterior of the primitive.
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasSides()
+    is static;
+
+    EndFace(me : in out) returns TheFace
+	---Purpose: Returns the Face ending the slice, it  is oriented
+	--          toward the exterior of the primitive.
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasSides()
+    is static;
+    
+    -- Wires
+
+    LateralWire(me : in out) returns TheWire
+	---Purpose: Returns  the wire in the lateral face.
+	--          
+	---C++: return const &
+    raises DomainError -- if VMinInfinite() && VMaxInfinite()
+    is static;
+    
+    LateralStartWire(me : in out) returns TheWire
+	---Purpose: Returns the   wire in the   lateral  face with the
+	--          start edge.
+	--          
+	---C++: return const &
+    raises DomainError -- if ! (VMinInfinite() && VMaxInfinite())
+    is static;
+    
+    LateralEndWire(me : in out) returns TheWire
+	---Purpose: Returns the wire with in lateral face with the end
+	--          edge.
+	--          
+	---C++: return const &
+    raises DomainError -- if ! (VMinInfinite() && VMaxInfinite())
+    is static;
+    
+    TopWire(me : in out) returns TheWire
+	---Purpose: Returns the wire in the top face.
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasTop()
+    is static;
+     
+    BottomWire(me : in out) returns TheWire
+	---Purpose: Returns the wire in the bottom face.
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasBottom()
+    is static;
+    
+    StartWire(me : in out) returns TheWire
+	---Purpose: Returns the wire  in the  start face.
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasSides()
+    is static;
+
+    AxisStartWire(me : in out) returns TheWire
+	---Purpose: Returns  the wire   in the  start   face  with the
+	--          AxisEdge.
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasSides() ! (VMinInfinite() && VMaxInfinite())
+    is static;
+
+    EndWire(me : in out) returns TheWire
+	---Purpose: Returns the Wire in   the end face.
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasSides()
+    is static;
+
+    AxisEndWire(me : in out) returns TheWire
+	---Purpose: Returns  the Wire  in  the   end   face  with  the
+	--          AxisEdge. 
+	--          
+	---C++: return const &
+    raises DomainError -- if !HasSides() ! (VMinInfinite() && VMaxInfinite())
+    is static;
+
+
+    -- Edges
+
+    AxisEdge(me : in out) returns TheEdge
+	---Purpose: Returns the Edge built along the Axis and oriented
+	--          on +Z of the Axis.
+	--          
+	---C++: return const &
+    raises DomainError -- if ! (MeridianOnAxis(VMin) || MeridianOnAxis(VMax))
+    is static;
+    
+    StartEdge(me : in out) returns TheEdge
+	---Purpose: Returns the   Edge at angle 0.
+	--          
+	---C++: return const &
+    is static;
+
+    EndEdge(me : in out) returns TheEdge
+	---Purpose: Returns the  Edge at  angle Angle.  If !HasSides()
+	--          the StartEdge and the EndEdge are the same edge.
+	--          
+	---C++: return const &
+    is static;
+
+    StartTopEdge(me : in out) returns TheEdge
+	---Purpose: Returns the linear Edge between start Face and top
+	--          Face.
+	--          
+	---C++: return const &
+    raises DomainError -- if ! (HasTop() && HasSides())
+    is static;
+
+    StartBottomEdge(me : in out) returns TheEdge
+	---Purpose: Returns the linear  Edge between  start  Face  and
+	--          bottom Face.
+	--          
+	---C++: return const &
+     raises DomainError -- if ! (HasBottom() && HasSides())
+    is static;
+
+    EndTopEdge(me : in out) returns TheEdge
+	---Purpose: Returns the linear Edge  between end Face and  top
+	--          Face.
+	--          
+	---C++: return const &
+    raises DomainError -- if ! (HasTop() && HasSides())
+    is static;
+
+    EndBottomEdge(me : in out) returns TheEdge
+	---Purpose: Returns  the  linear  Edge  between end  Face  and
+	--          bottom Face.
+	--          
+	---C++: return const &
+     raises DomainError -- if ! (HasBottom() && HasSides())
+    is static;
+
+    TopEdge(me : in out) returns TheEdge
+	---Purpose: Returns the edge at VMax. If  MeridianClosed() the
+	--          TopEdge and the BottomEdge are the same edge.
+	--          
+	---C++: return const &
+    raises DomainError -- if VMaxInfinite()
+    is static;
+
+    BottomEdge(me : in out) returns TheEdge
+	---Purpose: Returns the edge  at VMin. If MeridianClosed() the
+	--          TopEdge and the BottomEdge are the same edge.
+	--          
+	---C++: return const &
+    raises DomainError -- if VMinInfinite()
+    is static;
+
+    -- Vertices
+
+    AxisTopVertex(me : in out) returns TheVertex
+	---Purpose: Returns the Vertex at the Top altitude on the axis.
+	--          
+	---C++: return const &
+    raises DomainError -- if !MeridianOnAxis(VMax)
+    is static;
+
+    AxisBottomVertex(me : in out) returns TheVertex
+	---Purpose: Returns the Vertex  at the Bottom  altitude on the
+	--          axis.
+	--          
+	---C++: return const &
+    raises DomainError -- if !MeridianOnAxis(VMin)
+    is static;
+
+    TopStartVertex(me : in out) returns TheVertex
+	---Purpose: Returns the vertex (0,VMax)
+	--          
+	---C++: return const &
+    raises DomainError -- if VMaxInfinite()
+    is static;
+
+    TopEndVertex(me : in out) returns TheVertex
+	---Purpose: Returns the vertex (angle,VMax)
+	--          
+	---C++: return const &
+    raises DomainError -- if VMaxInfinite()
+    is static;
+
+    BottomStartVertex(me : in out) returns TheVertex
+	---Purpose: Returns the vertex (0,VMin)
+	--          
+	---C++: return const &
+    raises DomainError -- if VMinInfinite()
+    is static;
+
+    BottomEndVertex(me : in out) returns TheVertex
+	---Purpose: Returns the vertex (angle,VMax)
+	--          
+	---C++: return const &
+    raises DomainError -- if VMinInfinite()
+    is static;
+
+fields
+    myBuilder  : TheBuilder   is protected;  
+    myAxes     : Ax2 from gp;
+
+    myAngle    : Real from Standard;
+    myVMin     : Real from Standard;
+    myVMax     : Real from Standard;
+    myMeridianOffset : Real from Standard;
+
+    -- the Topology
+
+    myShell    : TheShell;
+    ShellBuilt : Boolean;
+
+    myVertices : TheVertex [6];
+    -- 0 : Vertex on top    of the axis
+    -- 1 :        on bottom of the axis
+    -- 2 :        top, start
+    -- 3 :        top, end
+    -- 4 :        bottom, start
+    -- 5 :        bottom, end
+    VerticesBuilt : Boolean [6];
+    
+    myEdges : TheEdge [9];
+    -- 0 : Edge on the Axis
+    -- 1 :        Start Edge
+    -- 2 :        End Edge
+    -- 3 :        Start Top
+    -- 4 :        Start Bottom
+    -- 5 :        End Top
+    -- 6 :        End Bottom
+    -- 7 :        Top
+    -- 8 :        Bottom
+    EdgesBuilt : Boolean [9];
+    
+    myWires : TheWire [9];
+    -- 0 : wire     Lateral
+    -- 1 :          Lateral Start
+    -- 2 :          Lateral End
+    -- 3 :          Top
+    -- 4 :          Bottom
+    -- 5 :          Start
+    -- 6 :          Axis Start
+    -- 7 :          End
+    -- 8 :          Axis End
+    WiresBuilt : Boolean [9];
+    
+    myFaces : TheFace [5];
+    -- 0 : Lateral Face
+    -- 1 : Top
+    -- 2 : Bottom
+    -- 3 : Start
+    -- 4 : End
+    FacesBuilt : Boolean [5];
+    
+
+end OneAxis;

src/Primitives/Primitives_Wedge.cdl

@@ -0,0 +1,299 @@
+-- File:	Wedge.cdl
+-- Created:	Wed Sep 18 17:42:49 1991
+-- Author:	Christophe MARION
+--		<cma@sdsun1>
+---Copyright:	 Matra Datavision 1991, 1992
+
+
+
+
+generic class Wedge from Primitives(
+    TheShell           as any;
+    TheFace            as any;
+    TheWire            as any;
+    TheEdge            as any;
+    TheVertex          as any;
+    TheBuilder         as any)
+
+	---Purpose: A wedge is defined by  :
+	--          
+	--          Axes : an Axis2 (coordinate system)
+	--          
+	--          YMin, YMax the  coordinates of the  ymin and ymax
+	--          rectangular faces parallel to the ZX plane (of the
+	--          coordinate systems)
+	--          
+	--          ZMin,ZMax,XMin,XMax the rectangular
+	--          left (YMin) face parallel to the Z and X axes.
+	--          
+	--          Z2Min,Z2Max,X2Min,X2Max the rectangular
+	--          right (YMax) face parallel to the Z and X axes.
+	--          
+	--          For a box Z2Min = ZMin, Z2Max = ZMax,
+	--                    X2Min = XMin, X2Max = XMax
+	--          
+	--          The wedge can be open in the corresponding direction
+	--          of its Boolean myInfinite
+
+
+uses
+    
+    Direction from Primitives,
+    
+    Ax2 from gp,
+    Pln from gp,
+    Lin from gp,
+    Pnt from gp
+
+raises
+    DomainError,
+    OutOfRange
+
+is
+    Create(B : TheBuilder; Axes : Ax2 from gp; dx, dy, dz : Real)
+    returns Wedge from Primitives
+	---Purpose: Creates a  Wedge  algorithm.   <Axes> is  the axis
+	--          system for the primitive.
+	--          
+	--          XMin, YMin, ZMin are set to 0
+	--          XMax, YMax, ZMax are set to dx, dy, dz
+	--          Z2Min = ZMin
+	--          Z2Max = ZMax
+	--          X2Min = XMin
+	--          X2Max = XMax
+	--          The result is a box
+	--          dx,dy,dz should be positive
+	raises DomainError;
+
+    Create(B : TheBuilder; Axes : Ax2 from gp; dx, dy, dz, ltx : Real)
+    returns Wedge from Primitives
+	---Purpose: Creates  a Wedge  primitive. <Axes> is   the  axis
+	--          system for the primitive.
+	--          
+	--          XMin, YMin, ZMin are set to 0
+	--          XMax, YMax, ZMax are set to dx, dy, dz
+	--          Z2Min = ZMin
+	--          Z2Max = ZMax
+	--          X2Min = ltx
+	--          X2Max = ltx
+	--          The result is a STEP right angular wedge
+	--          dx,dy,dz should be positive
+	--          ltx should not be negative
+	raises DomainError;
+
+    Create(B : TheBuilder; Axes : Ax2 from gp; xmin, ymin, zmin, z2min, x2min,
+                                   xmax, ymax, zmax, z2max, x2max : Real)
+    returns Wedge from Primitives
+	---Purpose: Create  a Wedge primitive.   <Axes>  is  the  axis
+	--          system for the primitive.
+	--          
+	--          all the fields are set to the corresponding value
+	--          XYZMax - XYZMin should be positive
+	--          ZX2Max - ZX2Min should not be negative 
+	raises DomainError;
+
+    Axes(me) returns Ax2 from gp
+	---Purpose: Returns the coordinates system from <me>.
+    is static;
+
+    GetXMin(me) returns Real
+	---Purpose: Returns Xmin value from <me>.
+    is static;
+
+    GetYMin(me) returns Real
+	---Purpose: Returns YMin value from <me>.
+    is static;
+
+    GetZMin(me) returns Real
+	---Purpose: Returns ZMin value from <me>.
+    is static;
+
+    GetZ2Min(me) returns Real 
+	---Purpose: Returns Z2Min value from <me>.
+    is static;
+
+    GetX2Min(me) returns Real 
+	---Purpose: Returns X2Min value from <me>.
+    is static;
+
+    GetXMax(me) returns Real
+	---Purpose: Returns XMax value from <me>.
+    is static;
+
+    GetYMax(me) returns Real
+	---Purpose: Returns YMax value from <me>.
+    is static;
+
+    GetZMax(me) returns Real
+	---Purpose: Returns ZMax value from <me>.
+    is static;
+
+    GetZ2Max(me) returns Real 
+	---Purpose: Returns Z2Max value from <me>.
+    is static;
+
+    GetX2Max(me) returns Real 
+	---Purpose: Returns X2Max value from <me>.
+    is static;
+
+    Open(me : in out; d1 : Direction from Primitives)
+	---Purpose: Opens <me> in <d1> direction. A face and its edges
+	--          or vertices are said nonexistant.
+    raises DomainError
+    is static;
+
+    Close(me : in out; d1 : Direction from Primitives)
+	---Purpose: Closes   <me>  in <d1>  direction.  A face and its
+	--          edges or vertices are said existant.
+    raises DomainError
+    is static;
+
+    IsInfinite(me; d1 : Direction from Primitives)
+	---Purpose: Returns True if <me> is open in <d1> direction.
+    returns Boolean;
+    
+    Shell(me : in out) returns TheShell
+	---Purpose: Returns the Shell containing the Faces of <me>.
+	--          
+	---C++: return const &
+    is static;
+
+    HasFace(me; d1 : Direction from Primitives)
+	---Purpose: Returns True if <me> has a Face in <d1> direction.
+    returns Boolean;
+
+    Face(me : in out; d1 : Direction from Primitives) returns TheFace
+	---Purpose: Returns the Face of <me> located in <d1> direction.
+	--          
+	---C++: return const &
+    raises DomainError
+    is static;
+    
+    Plane(me : in out; d1 : Direction from Primitives) returns Pln from  gp
+	---Purpose: Returns the plane  of the Face  of <me> located in
+	--          <d1> direction.
+    raises DomainError
+    is static;
+    
+    HasWire(me; d1 : Direction from Primitives)
+	---Purpose: Returns True if <me> has a Wire in <d1> direction.
+    returns Boolean;
+
+    Wire(me : in out; d1 : Direction from Primitives) returns TheWire
+	---Purpose: Returns the Wire of <me> located in <d1> direction.
+	--          
+	---C++: return const &
+    raises DomainError
+    is static;
+
+    HasEdge(me; d1, d2 : Direction from Primitives)
+	---Purpose: Returns True if <me> has an Edge in <d1><d2> direction.
+    returns Boolean;
+
+    Edge(me : in out; d1, d2 : Direction from Primitives) returns TheEdge
+	---Purpose: Returns the Edge of <me> located in <d1><d2> direction.
+	--          
+	---C++: return const &
+    raises DomainError
+    is static;
+
+    Line(me : in out; d1, d2 : Direction from Primitives) returns Lin from gp
+	---Purpose: Returns the line of  the Edge of <me>  located  in
+	--          <d1><d2> direction.
+    raises DomainError
+    is static;
+
+    HasVertex(me; d1, d2, d3 : Direction from Primitives)
+	---Purpose: Returns True if <me> has a  Vertex in <d1><d2><d3>
+	--          direction.
+    returns Boolean;
+
+    Vertex(me : in out; d1, d2, d3 : Direction from Primitives)
+    returns TheVertex
+	---Purpose: Returns the Vertex of <me> located in <d1><d2><d3>
+	--          direction.
+	--          
+	---C++: return const &
+    raises DomainError
+    is static;
+    
+    Point(me : in out; d1, d2, d3 : Direction from Primitives)
+    returns Pnt from gp
+	---Purpose: Returns the point of the Vertex of <me> located in
+	--          <d1><d2><d3> direction.
+    raises DomainError
+    is static;
+    
+fields
+    myBuilder : TheBuilder;
+
+    myAxes : Ax2 from gp;
+    XMin : Real;
+    XMax : Real;
+    YMin : Real;
+    YMax : Real;
+    ZMin : Real;
+    ZMax : Real;
+    Z2Min : Real;
+    Z2Max : Real;
+    X2Min : Real;
+    X2Max : Real;
+    
+    -- the Topology
+
+    myShell : TheShell;
+    ShellBuilt : Boolean;
+    
+    myVertices : TheVertex [8];
+    -- 0 : xmin ymin zmin
+    -- 1 : xmax ymin zmin
+    -- 2 : xmin ymax zmin
+    -- 3 : xmax ymax zmin
+    -- 4 : xmin ymin zmax
+    -- 5 : xmax ymin zmax
+    -- 6 : xmin ymax zmax
+    -- 7 : xmax ymax zmax
+    VerticesBuilt : Boolean [8];
+    
+    myEdges : TheEdge [12];
+    -- 0  : xmin ymin
+    -- 1  : xmax ymin
+    -- 2  : xmin ymax
+    -- 3  : xmax ymax
+    -- 4  : ymin zmin
+    -- 5  : ymax zmin
+    -- 6  : ymin zmax
+    -- 7  : ymax zmax
+    -- 8  : zmin xmin
+    -- 9  : zmax xmin
+    -- 10 : zmin xmax
+    -- 11 : zmax xmax
+    EdgesBuilt : Boolean [12];
+    
+    myWires : TheWire [6];
+    -- 0 : xmin
+    -- 1 : xmax
+    -- 2 : ymin
+    -- 3 : ymax
+    -- 4 : zmin
+    -- 5 : zmax
+    WiresBuilt : Boolean [6];
+    
+    myFaces : TheFace [6];
+    -- 0 : xmin
+    -- 1 : xmax
+    -- 2 : ymin
+    -- 3 : ymax
+    -- 4 : zmin
+    -- 5 : zmax
+    FacesBuilt : Boolean [6];
+
+    myInfinite : Boolean[6];
+    -- 0 : xmin
+    -- 1 : xmax
+    -- 2 : ymin
+    -- 3 : ymax
+    -- 4 : zmin
+    -- 5 : zmax
+
+end Wedge;