OCCT

// Created on: 1991-07-24
// 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.

#include <BRepPrim_Builder.hxx>
#include <BRepPrim_OneAxis.hxx>
#include <gp_Ax2.hxx>
#include <gp_Circ.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Pln.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec.hxx>
#include <Precision.hxx>
#include <Standard_DomainError.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Vertex.hxx>

#define NBVERTICES 6
#define VAXISTOP 0
#define VAXISBOT 1
#define VTOPSTART 2
#define VTOPEND 3
#define VBOTSTART 4
#define VBOTEND 5
#define NBEDGES 9
#define EAXIS 0
#define ESTART 1
#define EEND 2
#define ETOPSTART 3
#define ETOPEND 4
#define EBOTSTART 5
#define EBOTEND 6
#define ETOP 7
#define EBOTTOM 8
#define NBWIRES 9
#define WLATERAL 0
#define WLATERALSTART 0
#define WLATERALEND 1
#define WTOP 2
#define WBOTTOM 3
#define WSTART 5
#define WAXISSTART 6
#define WEND 7
#define WAXISEND 8
#define NBFACES 5
#define FLATERAL 0
#define FTOP 1
#define FBOTTOM 2
#define FSTART 3
#define FEND 4

//=======================================================================
// function : BRepPrim_OneAxis_Check
// purpose  : raise Standard_DomainError if something was built
//=======================================================================

static void BRepPrim_OneAxis_Check(const Standard_Boolean V[],
                                   const Standard_Boolean E[],
                                   const Standard_Boolean W[],
                                   const Standard_Boolean F[])
{
  Standard_Integer i;
  for (i = 0; i < NBVERTICES; i++)
    if (V[i])
      throw Standard_DomainError();
  for (i = 0; i < NBEDGES; i++)
    if (E[i])
      throw Standard_DomainError();
  for (i = 0; i < NBWIRES; i++)
    if (W[i])
      throw Standard_DomainError();
  for (i = 0; i < NBFACES; i++)
    if (F[i])
      throw Standard_DomainError();
}

//=================================================================================================

BRepPrim_OneAxis::BRepPrim_OneAxis(const BRepPrim_Builder& B,
                                   const gp_Ax2&           A,
                                   const Standard_Real     VMin,
                                   const Standard_Real     VMax)
    : myBuilder(B),
      myAxes(A),
      myAngle(2 * M_PI),
      myVMin(VMin),
      myVMax(VMax),
      myMeridianOffset(0)

{
  // init Built flags
  Standard_Integer i;
  ShellBuilt = Standard_False;
  for (i = 0; i < NBVERTICES; i++)
    VerticesBuilt[i] = Standard_False;
  for (i = 0; i < NBEDGES; i++)
    EdgesBuilt[i] = Standard_False;
  for (i = 0; i < NBWIRES; i++)
    WiresBuilt[i] = Standard_False;
  for (i = 0; i < NBFACES; i++)
    FacesBuilt[i] = Standard_False;
}

//=================================================================================================

BRepPrim_OneAxis::~BRepPrim_OneAxis() {}

//=================================================================================================

void BRepPrim_OneAxis::SetMeridianOffset(const Standard_Real O)
{
  myMeridianOffset = O;
}

//=======================================================================
// function : Axes, Angle, VMin, VMax
// purpose  :
//=======================================================================

const gp_Ax2& BRepPrim_OneAxis::Axes() const
{
  return myAxes;
}

void BRepPrim_OneAxis::Axes(const gp_Ax2& A)
{
  BRepPrim_OneAxis_Check(VerticesBuilt, EdgesBuilt, WiresBuilt, FacesBuilt);
  myAxes = A;
}

Standard_Real BRepPrim_OneAxis::Angle() const
{
  return myAngle;
}

void BRepPrim_OneAxis::Angle(const Standard_Real A)
{
  BRepPrim_OneAxis_Check(VerticesBuilt, EdgesBuilt, WiresBuilt, FacesBuilt);
  myAngle = A;
}

Standard_Real BRepPrim_OneAxis::VMin() const
{
  return myVMin;
}

void BRepPrim_OneAxis::VMin(const Standard_Real V)
{
  BRepPrim_OneAxis_Check(VerticesBuilt, EdgesBuilt, WiresBuilt, FacesBuilt);
  myVMin = V;
}

Standard_Real BRepPrim_OneAxis::VMax() const
{
  return myVMax;
}

void BRepPrim_OneAxis::VMax(const Standard_Real V)
{
  BRepPrim_OneAxis_Check(VerticesBuilt, EdgesBuilt, WiresBuilt, FacesBuilt);
  myVMax = V;
}

//=================================================================================================

Standard_Boolean BRepPrim_OneAxis::MeridianOnAxis(const Standard_Real V) const
{
  return Abs(MeridianValue(V).X()) < Precision::Confusion();
}

//=================================================================================================

Standard_Boolean BRepPrim_OneAxis::MeridianClosed() const
{
  if (VMaxInfinite())
    return Standard_False;
  if (VMinInfinite())
    return Standard_False;
  return MeridianValue(myVMin).IsEqual(MeridianValue(myVMax), Precision::Confusion());
}

//=================================================================================================

Standard_Boolean BRepPrim_OneAxis::VMaxInfinite() const
{
  return Precision::IsPositiveInfinite(myVMax);
}

//=================================================================================================

Standard_Boolean BRepPrim_OneAxis::VMinInfinite() const
{
  return Precision::IsNegativeInfinite(myVMin);
}

//=================================================================================================

Standard_Boolean BRepPrim_OneAxis::HasTop() const
{
  if (VMaxInfinite())
    return Standard_False;
  if (MeridianClosed())
    return Standard_False;
  if (MeridianOnAxis(myVMax))
    return Standard_False;
  return Standard_True;
}

//=================================================================================================

Standard_Boolean BRepPrim_OneAxis::HasBottom() const
{
  if (VMinInfinite())
    return Standard_False;
  if (MeridianClosed())
    return Standard_False;
  if (MeridianOnAxis(myVMin))
    return Standard_False;
  return Standard_True;
}

//=================================================================================================

Standard_Boolean BRepPrim_OneAxis::HasSides() const
{
  return 2 * M_PI - myAngle > Precision::Angular();
}

//=================================================================================================

const TopoDS_Shell& BRepPrim_OneAxis::Shell()
{
  if (!ShellBuilt)
  {
    myBuilder.MakeShell(myShell);

    myBuilder.AddShellFace(myShell, LateralFace());
    if (HasTop())
      myBuilder.AddShellFace(myShell, TopFace());
    if (HasBottom())
      myBuilder.AddShellFace(myShell, BottomFace());
    if (HasSides())
    {
      myBuilder.AddShellFace(myShell, StartFace());
      myBuilder.AddShellFace(myShell, EndFace());
    }

    myShell.Closed(BRep_Tool::IsClosed(myShell));
    myBuilder.CompleteShell(myShell);
    ShellBuilt = Standard_True;
  }
  return myShell;
}

//=======================================================================
// function : LateralFace
// purpose  : build the lateral face
//=======================================================================

const TopoDS_Face& BRepPrim_OneAxis::LateralFace()
{
  // do it if not done
  if (!FacesBuilt[FLATERAL])
  {

    // build an empty lateral face
    myFaces[FLATERAL] = MakeEmptyLateralFace();

    // add the wires
    if (VMaxInfinite() && VMinInfinite())
    {
      myBuilder.AddFaceWire(myFaces[FLATERAL], LateralStartWire());
      myBuilder.AddFaceWire(myFaces[FLATERAL], LateralEndWire());
    }
    else
      myBuilder.AddFaceWire(myFaces[FLATERAL], LateralWire());

    // put the parametric curves
    if (MeridianClosed())
    {
      // closed edge
      myBuilder.SetPCurve(myEdges[ETOP],
                          myFaces[FLATERAL],
                          gp_Lin2d(gp_Pnt2d(0, myVMin), gp_Dir2d(1, 0)),
                          gp_Lin2d(gp_Pnt2d(0, myVMax), gp_Dir2d(1, 0)));
    }
    else
    {
      if (!VMaxInfinite())
      {
        myBuilder.SetPCurve(myEdges[ETOP],
                            myFaces[FLATERAL],
                            gp_Lin2d(gp_Pnt2d(0, myVMax), gp_Dir2d(1, 0)));
        if (!HasSides() || MeridianOnAxis(myVMax))
        {
          // closed edge set parameters
          myBuilder.SetParameters(myEdges[ETOP], TopEndVertex(), 0., myAngle);
        }
      }
      if (!VMinInfinite())
      {
        myBuilder.SetPCurve(myEdges[EBOTTOM],
                            myFaces[FLATERAL],
                            gp_Lin2d(gp_Pnt2d(0, myVMin), gp_Dir2d(1, 0)));
        if (!HasSides() || MeridianOnAxis(myVMin))
        {
          // closed edge set parameters
          myBuilder.SetParameters(myEdges[EBOTTOM], BottomEndVertex(), 0., myAngle);
        }
      }
    }
    if (HasSides())
    {
      myBuilder.SetPCurve(myEdges[ESTART],
                          myFaces[FLATERAL],
                          gp_Lin2d(gp_Pnt2d(0, -myMeridianOffset), gp_Dir2d(0, 1)));

      myBuilder.SetPCurve(myEdges[EEND],
                          myFaces[FLATERAL],
                          gp_Lin2d(gp_Pnt2d(myAngle, -myMeridianOffset), gp_Dir2d(0, 1)));
    }
    else
    {
      // closed edge
      myBuilder.SetPCurve(myEdges[ESTART],
                          myFaces[FLATERAL],
                          gp_Lin2d(gp_Pnt2d(myAngle, -myMeridianOffset), gp_Dir2d(0, 1)),
                          gp_Lin2d(gp_Pnt2d(0, -myMeridianOffset), gp_Dir2d(0, 1)));
    }
    myBuilder.CompleteFace(myFaces[FLATERAL]);
    FacesBuilt[FLATERAL] = Standard_True;
  }
  return myFaces[FLATERAL];
}

//=======================================================================
// function : TopFace
// purpose  : build and return the TopFace
//=======================================================================

const TopoDS_Face& BRepPrim_OneAxis::TopFace()
{
  // do it if not done
  if (!FacesBuilt[FTOP])
  {

    Standard_DomainError_Raise_if(!HasTop(), "BRepPrim_OneAxis::TopFace:No top face");

    // make the empty face by translating the axes
    Standard_Real z = MeridianValue(myVMax).Y();
    gp_Vec        V = myAxes.Direction();
    V.Multiply(z);
    myBuilder.MakeFace(myFaces[FTOP], gp_Pln(myAxes.Translated(V)));

    myBuilder.AddFaceWire(myFaces[FTOP], TopWire());

    // put the parametric curves
    myBuilder.SetPCurve(
      myEdges[ETOP],
      myFaces[FTOP],
      gp_Circ2d(gp_Ax2d(gp_Pnt2d(0, 0), gp_Dir2d(1, 0)), MeridianValue(myVMax).X()));
    if (HasSides())
    {
      myBuilder.SetPCurve(myEdges[ETOPSTART],
                          myFaces[FTOP],
                          gp_Lin2d(gp_Pnt2d(0, 0), gp_Dir2d(1, 0)));
      myBuilder.SetPCurve(myEdges[ETOPEND],
                          myFaces[FTOP],
                          gp_Lin2d(gp_Pnt2d(0, 0), gp_Dir2d(Cos(myAngle), Sin(myAngle))));
    }

    myBuilder.CompleteFace(myFaces[FTOP]);
    FacesBuilt[FTOP] = Standard_True;
  }

  return myFaces[FTOP];
}

//=================================================================================================

const TopoDS_Face& BRepPrim_OneAxis::BottomFace()
{
  // do it if not done
  if (!FacesBuilt[FBOTTOM])
  {

    Standard_DomainError_Raise_if(!HasBottom(), "BRepPrim_OneAxis::BottomFace:No bottom face");

    // make the empty face by translating the axes
    Standard_Real z = MeridianValue(myVMin).Y();
    gp_Vec        V = myAxes.Direction();
    V.Multiply(z);
    gp_Ax2 axes = myAxes.Translated(V);
    myBuilder.MakeFace(myFaces[FBOTTOM], gp_Pln(axes));
    myBuilder.ReverseFace(myFaces[FBOTTOM]);
    myBuilder.AddFaceWire(myFaces[FBOTTOM], BottomWire());

    // put the parametric curves
    myBuilder.SetPCurve(
      myEdges[EBOTTOM],
      myFaces[FBOTTOM],
      gp_Circ2d(gp_Ax2d(gp_Pnt2d(0, 0), gp_Dir2d(1, 0)), MeridianValue(myVMin).X()));
    if (HasSides())
    {
      myBuilder.SetPCurve(myEdges[EBOTSTART],
                          myFaces[FBOTTOM],
                          gp_Lin2d(gp_Pnt2d(0, 0), gp_Dir2d(1, 0)));
      myBuilder.SetPCurve(myEdges[EBOTEND],
                          myFaces[FBOTTOM],
                          gp_Lin2d(gp_Pnt2d(0, 0), gp_Dir2d(Cos(myAngle), Sin(myAngle))));
    }

    myBuilder.CompleteFace(myFaces[FBOTTOM]);
    FacesBuilt[FBOTTOM] = Standard_True;
  }

  return myFaces[FBOTTOM];
}

//=================================================================================================

const TopoDS_Face& BRepPrim_OneAxis::StartFace()
{
  // do it if not done
  if (!FacesBuilt[FSTART])
  {

    Standard_DomainError_Raise_if(!HasSides(), "BRepPrim_OneAxes::StartFace:No side faces");

    // build the empty face, perpendicular to myTool.Axes()
    gp_Ax2 axes(myAxes.Location(), myAxes.YDirection().Reversed(), myAxes.XDirection());
    myBuilder.MakeFace(myFaces[FSTART], gp_Pln(axes));

    if (VMaxInfinite() && VMinInfinite())
      myBuilder.AddFaceWire(myFaces[FSTART], AxisStartWire());

    myBuilder.AddFaceWire(myFaces[FSTART], StartWire());

    // parametric curves
    SetMeridianPCurve(myEdges[ESTART], myFaces[FSTART]);
    if (EdgesBuilt[EAXIS])
      myBuilder.SetPCurve(myEdges[EAXIS],
                          myFaces[FSTART],
                          gp_Lin2d(gp_Pnt2d(0, 0), gp_Dir2d(0, 1)));
    if (EdgesBuilt[ETOPSTART])
      myBuilder.SetPCurve(myEdges[ETOPSTART],
                          myFaces[FSTART],
                          gp_Lin2d(gp_Pnt2d(0, MeridianValue(myVMax).Y()), gp_Dir2d(1, 0)));
    if (EdgesBuilt[EBOTSTART])
      myBuilder.SetPCurve(myEdges[EBOTSTART],
                          myFaces[FSTART],
                          gp_Lin2d(gp_Pnt2d(0, MeridianValue(myVMin).Y()), gp_Dir2d(1, 0)));

    myBuilder.CompleteFace(myFaces[FSTART]);
    FacesBuilt[FSTART] = Standard_True;
  }

  return myFaces[FSTART];
}

//=================================================================================================

const TopoDS_Face& BRepPrim_OneAxis::EndFace()
{
  // do it if not done
  if (!FacesBuilt[FEND])
  {

    Standard_DomainError_Raise_if(!HasSides(), "BRepPrim_OneAxes::EndFace:No side faces");

    // build the empty face, perpendicular to myTool.Axes()
    gp_Ax2 axes(myAxes.Location(), myAxes.YDirection().Reversed(), myAxes.XDirection());
    axes.Rotate(myAxes.Axis(), myAngle);
    myBuilder.MakeFace(myFaces[FEND], gp_Pln(axes));
    myBuilder.ReverseFace(myFaces[FEND]);

    if (VMaxInfinite() && VMinInfinite())
      myBuilder.AddFaceWire(myFaces[FEND], AxisEndWire());
    myBuilder.AddFaceWire(myFaces[FEND], EndWire());

    // parametric curves
    SetMeridianPCurve(myEdges[EEND], myFaces[FEND]);
    if (EdgesBuilt[EAXIS])
      myBuilder.SetPCurve(myEdges[EAXIS], myFaces[FEND], gp_Lin2d(gp_Pnt2d(0, 0), gp_Dir2d(0, 1)));
    if (EdgesBuilt[ETOPEND])
      myBuilder.SetPCurve(myEdges[ETOPEND],
                          myFaces[FEND],
                          gp_Lin2d(gp_Pnt2d(0, MeridianValue(myVMax).Y()), gp_Dir2d(1, 0)));
    if (EdgesBuilt[EBOTEND])
      myBuilder.SetPCurve(myEdges[EBOTEND],
                          myFaces[FEND],
                          gp_Lin2d(gp_Pnt2d(0, MeridianValue(myVMin).Y()), gp_Dir2d(1, 0)));

    myBuilder.CompleteFace(myFaces[FEND]);
    FacesBuilt[FEND] = Standard_True;
  }

  return myFaces[FEND];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::LateralWire()
{
  // do it if not done
  if (!WiresBuilt[WLATERAL])
  {

    myBuilder.MakeWire(myWires[WLATERAL]);

    if (!VMaxInfinite())
      myBuilder.AddWireEdge(myWires[WLATERAL], TopEdge(), Standard_False);
    myBuilder.AddWireEdge(myWires[WLATERAL], EndEdge(), Standard_True);
    if (!VMinInfinite())
      myBuilder.AddWireEdge(myWires[WLATERAL], BottomEdge(), Standard_True);
    myBuilder.AddWireEdge(myWires[WLATERAL], StartEdge(), Standard_False);

    myBuilder.CompleteWire(myWires[WLATERAL]);
    WiresBuilt[WLATERAL] = Standard_True;
  }

  return myWires[WLATERAL];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::LateralStartWire()
{
  // do it if not done
  if (!WiresBuilt[WLATERALSTART])
  {

    myBuilder.MakeWire(myWires[WLATERALSTART]);

    myBuilder.AddWireEdge(myWires[WLATERALSTART], StartEdge(), Standard_False);

    myBuilder.CompleteWire(myWires[WLATERALSTART]);
    WiresBuilt[WLATERALSTART] = Standard_True;
  }

  return myWires[WLATERALSTART];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::LateralEndWire()
{
  // do it if not done
  if (!WiresBuilt[WLATERALEND])
  {

    myBuilder.MakeWire(myWires[WLATERALEND]);

    myBuilder.AddWireEdge(myWires[WLATERALEND], EndEdge(), Standard_True);

    myBuilder.CompleteWire(myWires[WLATERALEND]);
    WiresBuilt[WLATERALEND] = Standard_True;
  }

  return myWires[WLATERALEND];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::TopWire()
{
  // do it if not done
  if (!WiresBuilt[WTOP])
  {

    Standard_DomainError_Raise_if(!HasTop(), "BRepPrim_OneAxis::TopWire: no top");

    myBuilder.MakeWire(myWires[WTOP]);

    myBuilder.AddWireEdge(myWires[WTOP], TopEdge(), Standard_True);
    if (HasSides())
    {
      myBuilder.AddWireEdge(myWires[WTOP], StartTopEdge(), Standard_True);
      myBuilder.AddWireEdge(myWires[WTOP], EndTopEdge(), Standard_False);
    }
    myBuilder.CompleteWire(myWires[WTOP]);
    WiresBuilt[WTOP] = Standard_True;
  }

  return myWires[WTOP];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::BottomWire()
{
  // do it if not done
  if (!WiresBuilt[WBOTTOM])
  {

    Standard_DomainError_Raise_if(!HasBottom(), "BRepPrim_OneAxis::BottomWire: no bottom");

    myBuilder.MakeWire(myWires[WBOTTOM]);

    myBuilder.AddWireEdge(myWires[WBOTTOM], BottomEdge(), Standard_False);
    if (HasSides())
    {
      myBuilder.AddWireEdge(myWires[WBOTTOM], EndBottomEdge(), Standard_True);
      myBuilder.AddWireEdge(myWires[WBOTTOM], StartBottomEdge(), Standard_False);
    }

    myBuilder.CompleteWire(myWires[WBOTTOM]);
    WiresBuilt[WBOTTOM] = Standard_True;
  }

  return myWires[WBOTTOM];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::StartWire()
{
  // do it if not done
  if (!WiresBuilt[WSTART])
  {

    Standard_DomainError_Raise_if(!HasSides(), "BRepPrim_OneAxes::StartWire:no sides");

    myBuilder.MakeWire(myWires[WSTART]);

    if (HasBottom())
      myBuilder.AddWireEdge(myWires[WSTART], StartBottomEdge(), Standard_True);

    if (!MeridianClosed())
    {
      if (!VMaxInfinite() || !VMinInfinite())
        myBuilder.AddWireEdge(myWires[WSTART], AxisEdge(), Standard_False);
    }

    if (HasTop())
      myBuilder.AddWireEdge(myWires[WSTART], StartTopEdge(), Standard_False);
    myBuilder.AddWireEdge(myWires[WSTART], StartEdge(), Standard_True);

    myBuilder.CompleteWire(myWires[WSTART]);
    WiresBuilt[WSTART] = Standard_True;
  }

  return myWires[WSTART];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::AxisStartWire()
{
  // do it if not done
  if (!WiresBuilt[WAXISSTART])
  {

    Standard_DomainError_Raise_if(!HasSides(), "BRepPrim_OneAxes::AxisStartWire:no sides");

    Standard_DomainError_Raise_if(!VMaxInfinite() || !VMinInfinite(),
                                  "BRepPrim_OneAxes::AxisStartWire:not infinite");

    Standard_DomainError_Raise_if(MeridianClosed(),
                                  "BRepPrim_OneAxes::AxisStartWire:meridian closed");

    myBuilder.MakeWire(myWires[WAXISSTART]);

    myBuilder.AddWireEdge(myWires[WAXISSTART], AxisEdge(), Standard_False);

    myBuilder.CompleteWire(myWires[WAXISSTART]);
    WiresBuilt[WAXISSTART] = Standard_True;
  }

  return myWires[WAXISSTART];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::EndWire()
{
  // do it if not done
  if (!WiresBuilt[WEND])
  {

    Standard_DomainError_Raise_if(!HasSides(), "BRepPrim_OneAxes::EndWire:no sides");

    myBuilder.MakeWire(myWires[WEND]);

    if (HasTop())
      myBuilder.AddWireEdge(myWires[WEND], EndTopEdge(), Standard_True);
    if (!MeridianClosed())
    {
      if (!VMaxInfinite() || !VMinInfinite())
      {
        myBuilder.AddWireEdge(myWires[WEND], AxisEdge(), Standard_True);
      }
    }
    if (HasBottom())
      myBuilder.AddWireEdge(myWires[WEND], EndBottomEdge(), Standard_False);
    myBuilder.AddWireEdge(myWires[WEND], EndEdge(), Standard_False);

    myBuilder.CompleteWire(myWires[WEND]);
    WiresBuilt[WEND] = Standard_True;
  }
  return myWires[WEND];
}

//=================================================================================================

const TopoDS_Wire& BRepPrim_OneAxis::AxisEndWire()
{
  // do it if not done
  if (!WiresBuilt[WAXISEND])
  {

    Standard_DomainError_Raise_if(!HasSides(), "BRepPrim_OneAxes::AxisEndWire:no sides");

    Standard_DomainError_Raise_if(!VMaxInfinite() || !VMinInfinite(),
                                  "BRepPrim_OneAxes::AxisEndWire:not infinite");

    Standard_DomainError_Raise_if(MeridianClosed(),
                                  "BRepPrim_OneAxes::AxisEndWire:meridian closed");

    myBuilder.MakeWire(myWires[WAXISEND]);

    myBuilder.AddWireEdge(myWires[WAXISEND], AxisEdge(), Standard_True);

    myBuilder.CompleteWire(myWires[WAXISEND]);
    WiresBuilt[WAXISEND] = Standard_True;
  }
  return myWires[WAXISEND];
}

//=======================================================================
// function : AxisEdge
// purpose  : make the edge on the axis, oriented +Z
//=======================================================================

const TopoDS_Edge& BRepPrim_OneAxis::AxisEdge()
{
  // do it if not done
  if (!EdgesBuilt[EAXIS])
  {

    Standard_DomainError_Raise_if(!HasSides(), "BRepPrim_OneAxis::AxisEdge:no sides");
    Standard_DomainError_Raise_if(MeridianClosed(), "BRepPrim_OneAxis::AxisEdge:closed");

    // build the empty edge.
    myBuilder.MakeEdge(myEdges[EAXIS], gp_Lin(myAxes.Axis()));

    if (!VMaxInfinite())
      myBuilder.AddEdgeVertex(myEdges[EAXIS],
                              AxisTopVertex(),
                              MeridianValue(myVMax).Y(),
                              Standard_False);
    if (!VMinInfinite())
      myBuilder.AddEdgeVertex(myEdges[EAXIS],
                              AxisBottomVertex(),
                              MeridianValue(myVMin).Y(),
                              Standard_True);

    myBuilder.CompleteEdge(myEdges[EAXIS]);
    EdgesBuilt[EAXIS] = Standard_True;
  }

  return myEdges[EAXIS];
}

//=================================================================================================

const TopoDS_Edge& BRepPrim_OneAxis::StartEdge()
{
  // do it if not done
  if (!EdgesBuilt[ESTART])
  {

    // is it shared with the EndEdge

    if (!HasSides() && EdgesBuilt[EEND])
      myEdges[ESTART] = myEdges[EEND];

    else
    {
      // build the empty Edge
      myEdges[ESTART] = MakeEmptyMeridianEdge(0.);

      if (MeridianClosed())
      {
        // Closed edge
        myBuilder.AddEdgeVertex(myEdges[ESTART],
                                TopStartVertex(),
                                myVMin + myMeridianOffset,
                                myVMax + myMeridianOffset);
      }
      else
      {
        if (!VMaxInfinite())
        {
          myBuilder.AddEdgeVertex(myEdges[ESTART],
                                  TopStartVertex(),
                                  myVMax + myMeridianOffset,
                                  Standard_False);
        }
        if (!VMinInfinite())
        {
          myBuilder.AddEdgeVertex(myEdges[ESTART],
                                  BottomStartVertex(),
                                  myVMin + myMeridianOffset,
                                  Standard_True);
        }
      }
    }

    myBuilder.CompleteEdge(myEdges[ESTART]);
    EdgesBuilt[ESTART] = Standard_True;
  }

  return myEdges[ESTART];
}

//=================================================================================================

const TopoDS_Edge& BRepPrim_OneAxis::EndEdge()
{
  // do it if not done
  if (!EdgesBuilt[EEND])
  {

    // is it shared with the start edge
    if (!HasSides() && EdgesBuilt[ESTART])
      myEdges[EEND] = myEdges[ESTART];

    else
    {
      // build the empty Edge
      myEdges[EEND] = MakeEmptyMeridianEdge(myAngle);

      if (MeridianClosed())
      {
        // Closed edge
        myBuilder.AddEdgeVertex(myEdges[EEND],
                                TopEndVertex(),
                                myVMin + myMeridianOffset,
                                myVMax + myMeridianOffset);
      }
      else
      {
        if (!VMaxInfinite())
        {
          myBuilder.AddEdgeVertex(myEdges[EEND],
                                  TopEndVertex(),
                                  myVMax + myMeridianOffset,
                                  Standard_False);
        }
        if (!VMinInfinite())
        {
          myBuilder.AddEdgeVertex(myEdges[EEND],
                                  BottomEndVertex(),
                                  myVMin + myMeridianOffset,
                                  Standard_True);
        }
      }
    }

    myBuilder.CompleteEdge(myEdges[EEND]);
    EdgesBuilt[EEND] = Standard_True;
  }

  return myEdges[EEND];
}

//=================================================================================================

const TopoDS_Edge& BRepPrim_OneAxis::StartTopEdge()
{
  // do it if not done
  if (!EdgesBuilt[ETOPSTART])
  {

    Standard_DomainError_Raise_if(!HasTop() || !HasSides(),
                                  "BRepPrim_OneAxis::StartTopEdge:no sides or no top");

    // build the empty Edge
    gp_Vec V = myAxes.Direction();
    V.Multiply(MeridianValue(myVMax).Y());
    gp_Pnt P = myAxes.Location().Translated(V);
    myBuilder.MakeEdge(myEdges[ETOPSTART], gp_Lin(P, myAxes.XDirection()));

    myBuilder.AddEdgeVertex(myEdges[ETOPSTART], AxisTopVertex(), 0., Standard_True);
    myBuilder.AddEdgeVertex(myEdges[ETOPSTART],
                            TopStartVertex(),
                            MeridianValue(myVMax).X(),
                            Standard_False);

    myBuilder.CompleteEdge(myEdges[ETOPSTART]);
    EdgesBuilt[ETOPSTART] = Standard_True;
  }

  return myEdges[ETOPSTART];
}

//=================================================================================================

const TopoDS_Edge& BRepPrim_OneAxis::StartBottomEdge()
{
  // do it if not done
  if (!EdgesBuilt[EBOTSTART])
  {

    Standard_DomainError_Raise_if(!HasBottom() || !HasSides(),
                                  "BRepPrim_OneAxis::StartBottomEdge:no sides or no top");

    // build the empty Edge
    gp_Vec V = myAxes.Direction();
    V.Multiply(MeridianValue(myVMin).Y());
    gp_Pnt P = myAxes.Location().Translated(V);
    myBuilder.MakeEdge(myEdges[EBOTSTART], gp_Lin(P, myAxes.XDirection()));

    myBuilder.AddEdgeVertex(myEdges[EBOTSTART],
                            BottomStartVertex(),
                            MeridianValue(myVMin).X(),
                            Standard_False);
    myBuilder.AddEdgeVertex(myEdges[EBOTSTART], AxisBottomVertex(), 0., Standard_True);

    myBuilder.CompleteEdge(myEdges[EBOTSTART]);
    EdgesBuilt[EBOTSTART] = Standard_True;
  }

  return myEdges[EBOTSTART];
}

//=================================================================================================

const TopoDS_Edge& BRepPrim_OneAxis::EndTopEdge()
{
  // do it if not done
  if (!EdgesBuilt[ETOPEND])
  {

    Standard_DomainError_Raise_if(!HasTop() || !HasSides(),
                                  "BRepPrim_OneAxis::EndTopEdge:no sides or no top");

    // build the empty Edge
    gp_Vec V = myAxes.Direction();
    V.Multiply(MeridianValue(myVMax).Y());
    gp_Pnt P = myAxes.Location().Translated(V);
    gp_Lin L(P, myAxes.XDirection());
    L.Rotate(myAxes.Axis(), myAngle);
    myBuilder.MakeEdge(myEdges[ETOPEND], L);

    myBuilder.AddEdgeVertex(myEdges[ETOPEND], AxisTopVertex(), 0., Standard_True);
    myBuilder.AddEdgeVertex(myEdges[ETOPEND],
                            TopEndVertex(),
                            MeridianValue(myVMax).X(),
                            Standard_False);

    myBuilder.CompleteEdge(myEdges[ETOPEND]);
    EdgesBuilt[ETOPEND] = Standard_True;
  }

  return myEdges[ETOPEND];
}

//=================================================================================================

const TopoDS_Edge& BRepPrim_OneAxis::EndBottomEdge()
{
  // do it if not done
  if (!EdgesBuilt[EBOTEND])
  {

    Standard_DomainError_Raise_if(!HasBottom() || !HasSides(),
                                  "BRepPrim_OneAxis::EndBottomEdge:no sides or no bottom");

    // build the empty Edge
    gp_Vec V = myAxes.Direction();
    V.Multiply(MeridianValue(myVMin).Y());
    gp_Pnt P = myAxes.Location().Translated(V);
    gp_Lin L(P, myAxes.XDirection());
    L.Rotate(myAxes.Axis(), myAngle);
    myBuilder.MakeEdge(myEdges[EBOTEND], L);

    myBuilder.AddEdgeVertex(myEdges[EBOTEND], AxisBottomVertex(), 0., Standard_True);
    myBuilder.AddEdgeVertex(myEdges[EBOTEND],
                            BottomEndVertex(),
                            MeridianValue(myVMin).X(),
                            Standard_False);

    myBuilder.CompleteEdge(myEdges[EBOTEND]);
    EdgesBuilt[EBOTEND] = Standard_True;
  }

  return myEdges[EBOTEND];
}

//=================================================================================================

const TopoDS_Edge& BRepPrim_OneAxis::TopEdge()
{
  // do it if not done
  if (!EdgesBuilt[ETOP])
  {

    // Test if shared with bottom edge
    if (MeridianClosed() && EdgesBuilt[EBOTTOM])
    {
      myEdges[ETOP] = myEdges[EBOTTOM];
    }

    else
    {

      // build the empty Edge
      if (!MeridianOnAxis(myVMax))
      {
        gp_Pnt2d mp = MeridianValue(myVMax);
        gp_Vec   V  = myAxes.Direction();
        V.Multiply(mp.Y());
        gp_Pnt  P = myAxes.Location().Translated(V);
        gp_Circ C(gp_Ax2(P, myAxes.Direction(), myAxes.XDirection()), mp.X());
        myBuilder.MakeEdge(myEdges[ETOP], C);
      }
      else
        myBuilder.MakeDegeneratedEdge(myEdges[ETOP]);

      if (!HasSides())
      {
        // closed edge
        myBuilder.AddEdgeVertex(myEdges[ETOP], TopEndVertex(), 0., myAngle);
      }
      else
      {
        myBuilder.AddEdgeVertex(myEdges[ETOP], TopEndVertex(), myAngle, Standard_False);
        myBuilder.AddEdgeVertex(myEdges[ETOP], TopStartVertex(), 0., Standard_True);
      }
    }

    myBuilder.CompleteEdge(myEdges[ETOP]);
    EdgesBuilt[ETOP] = Standard_True;
  }

  return myEdges[ETOP];
}

//=================================================================================================

const TopoDS_Edge& BRepPrim_OneAxis::BottomEdge()
{
  // do it if not done
  if (!EdgesBuilt[EBOTTOM])
  {

    // Test if shared with top edge
    if (MeridianClosed() && EdgesBuilt[ETOP])
    {
      myEdges[EBOTTOM] = myEdges[ETOP];
    }

    else
    {

      // build the empty Edge

      if (!MeridianOnAxis(myVMin))
      {
        gp_Pnt2d mp = MeridianValue(myVMin);
        gp_Vec   V  = myAxes.Direction();
        V.Multiply(mp.Y());
        gp_Pnt  P = myAxes.Location().Translated(V);
        gp_Circ C(gp_Ax2(P, myAxes.Direction(), myAxes.XDirection()), mp.X());
        myBuilder.MakeEdge(myEdges[EBOTTOM], C);
      }
      else
        myBuilder.MakeDegeneratedEdge(myEdges[EBOTTOM]);

      if (!HasSides())
      {
        // closed edge
        myBuilder.AddEdgeVertex(myEdges[EBOTTOM], BottomEndVertex(), 0., myAngle);
      }
      else
      {
        myBuilder.AddEdgeVertex(myEdges[EBOTTOM], BottomEndVertex(), myAngle, Standard_False);
        myBuilder.AddEdgeVertex(myEdges[EBOTTOM], BottomStartVertex(), 0., Standard_True);
      }
    }

    myBuilder.CompleteEdge(myEdges[EBOTTOM]);
    EdgesBuilt[EBOTTOM] = Standard_True;
  }

  return myEdges[EBOTTOM];
}

//=================================================================================================

const TopoDS_Vertex& BRepPrim_OneAxis::AxisTopVertex()
{
  // do it if not done
  if (!VerticesBuilt[VAXISTOP])
  {

    // deduct from others
    if (MeridianOnAxis(myVMax) && VerticesBuilt[VTOPSTART])
      myVertices[VAXISTOP] = myVertices[VTOPSTART];

    else if (MeridianOnAxis(myVMax) && VerticesBuilt[VTOPEND])
      myVertices[VAXISTOP] = myVertices[VTOPEND];

    else
    {
      Standard_DomainError_Raise_if(MeridianClosed(), "BRepPrim_OneAxis::AxisTopVertex");
      Standard_DomainError_Raise_if(VMaxInfinite(), "BRepPrim_OneAxis::AxisTopVertex");

      gp_Vec V = myAxes.Direction();
      V.Multiply(MeridianValue(myVMax).Y());
      gp_Pnt P = myAxes.Location().Translated(V);
      myBuilder.MakeVertex(myVertices[VAXISTOP], P);
    }

    VerticesBuilt[VAXISTOP] = Standard_True;
  }

  return myVertices[VAXISTOP];
}

//=================================================================================================

const TopoDS_Vertex& BRepPrim_OneAxis::AxisBottomVertex()
{
  // do it if not done
  if (!VerticesBuilt[VAXISBOT])
  {

    // deduct from others
    if (MeridianOnAxis(myVMin) && VerticesBuilt[VBOTSTART])
      myVertices[VAXISBOT] = myVertices[VBOTSTART];

    else if (MeridianOnAxis(myVMin) && VerticesBuilt[VBOTEND])
      myVertices[VAXISBOT] = myVertices[VBOTEND];

    else
    {
      Standard_DomainError_Raise_if(MeridianClosed(), "BRepPrim_OneAxis::AxisBottomVertex");
      Standard_DomainError_Raise_if(VMinInfinite(), "BRepPrim_OneAxis::AxisBottomVertex");

      gp_Vec V = myAxes.Direction();
      V.Multiply(MeridianValue(myVMin).Y());
      gp_Pnt P = myAxes.Location().Translated(V);
      myBuilder.MakeVertex(myVertices[VAXISBOT], P);
    }

    VerticesBuilt[VAXISBOT] = Standard_True;
  }

  return myVertices[VAXISBOT];
}

//=================================================================================================

const TopoDS_Vertex& BRepPrim_OneAxis::TopStartVertex()
{
  // do it if not done
  if (!VerticesBuilt[VTOPSTART])
  {

    // deduct from others
    if (MeridianOnAxis(myVMax) && VerticesBuilt[VAXISTOP])
      myVertices[VTOPSTART] = myVertices[VAXISTOP];
    else if ((MeridianOnAxis(myVMax) || !HasSides()) && VerticesBuilt[VTOPEND])
      myVertices[VTOPSTART] = myVertices[VTOPEND];
    else if (MeridianClosed() && VerticesBuilt[VBOTSTART])
      myVertices[VTOPSTART] = myVertices[VBOTSTART];
    else if ((MeridianClosed() && !HasSides()) && VerticesBuilt[VBOTEND])
      myVertices[VTOPSTART] = myVertices[VBOTEND];

    else
    {
      gp_Pnt2d mp = MeridianValue(myVMax);
      gp_Vec   V  = myAxes.Direction();
      V.Multiply(mp.Y());
      gp_Pnt P = myAxes.Location().Translated(V);
      V        = myAxes.XDirection();
      V.Multiply(mp.X());
      P.Translate(V);
      myBuilder.MakeVertex(myVertices[VTOPSTART], P);
    }

    VerticesBuilt[VTOPSTART] = Standard_True;
  }

  return myVertices[VTOPSTART];
}

//=================================================================================================

const TopoDS_Vertex& BRepPrim_OneAxis::TopEndVertex()
{
  // do it if not done
  if (!VerticesBuilt[VTOPEND])
  {

    // deduct from others
    if (MeridianOnAxis(myVMax) && VerticesBuilt[VAXISTOP])
      myVertices[VTOPEND] = myVertices[VAXISTOP];
    else if ((MeridianOnAxis(myVMax) || !HasSides()) && VerticesBuilt[VTOPSTART])
      myVertices[VTOPEND] = myVertices[VTOPSTART];
    else if (MeridianClosed() && VerticesBuilt[VBOTEND])
      myVertices[VTOPEND] = myVertices[VBOTEND];
    else if ((MeridianClosed() && !HasSides()) && VerticesBuilt[VBOTSTART])
      myVertices[VTOPEND] = myVertices[VBOTSTART];

    else
    {
      gp_Pnt2d mp = MeridianValue(myVMax);
      gp_Vec   V  = myAxes.Direction();
      V.Multiply(mp.Y());
      gp_Pnt P = myAxes.Location().Translated(V);
      V        = myAxes.XDirection();
      V.Multiply(mp.X());
      P.Translate(V);
      P.Rotate(myAxes.Axis(), myAngle);
      myBuilder.MakeVertex(myVertices[VTOPEND], P);
    }

    VerticesBuilt[VTOPEND] = Standard_True;
  }

  return myVertices[VTOPEND];
}

//=================================================================================================

const TopoDS_Vertex& BRepPrim_OneAxis::BottomStartVertex()
{
  // do it if not done
  if (!VerticesBuilt[VBOTSTART])
  {

    // deduct from others
    if (MeridianOnAxis(myVMin) && VerticesBuilt[VAXISBOT])
      myVertices[VBOTSTART] = myVertices[VAXISBOT];
    else if ((MeridianOnAxis(myVMin) || !HasSides()) && VerticesBuilt[VBOTEND])
      myVertices[VBOTSTART] = myVertices[VBOTEND];
    else if (MeridianClosed() && VerticesBuilt[VTOPSTART])
      myVertices[VBOTSTART] = myVertices[VTOPSTART];
    else if ((MeridianClosed() && !HasSides()) && VerticesBuilt[VTOPEND])
      myVertices[VBOTSTART] = myVertices[VTOPEND];

    else
    {
      gp_Pnt2d mp = MeridianValue(myVMin);
      gp_Vec   V  = myAxes.Direction();
      V.Multiply(mp.Y());
      gp_Pnt P = myAxes.Location().Translated(V);
      V        = myAxes.XDirection();
      V.Multiply(mp.X());
      P.Translate(V);
      myBuilder.MakeVertex(myVertices[VBOTSTART], P);
    }

    VerticesBuilt[VBOTSTART] = Standard_True;
  }

  return myVertices[VBOTSTART];
}

//=================================================================================================

const TopoDS_Vertex& BRepPrim_OneAxis::BottomEndVertex()
{
  // do it if not done
  if (!VerticesBuilt[VBOTEND])
  {

    // deduct from others
    if (MeridianOnAxis(myVMin) && VerticesBuilt[VAXISBOT])
      myVertices[VBOTEND] = myVertices[VAXISBOT];
    else if ((MeridianOnAxis(myVMin) || !HasSides()) && VerticesBuilt[VBOTSTART])
      myVertices[VBOTEND] = myVertices[VBOTSTART];
    else if (MeridianClosed() && VerticesBuilt[VTOPEND])
      myVertices[VBOTEND] = myVertices[VTOPEND];
    else if (MeridianClosed() && !HasSides() && VerticesBuilt[VTOPSTART])
      myVertices[VBOTEND] = myVertices[VTOPSTART];

    else
    {
      gp_Pnt2d mp = MeridianValue(myVMin);
      gp_Vec   V  = myAxes.Direction();
      V.Multiply(mp.Y());
      gp_Pnt P = myAxes.Location().Translated(V);
      V        = myAxes.XDirection();
      V.Multiply(mp.X());
      P.Translate(V);
      P.Rotate(myAxes.Axis(), myAngle);
      myBuilder.MakeVertex(myVertices[VBOTEND], P);
    }

    VerticesBuilt[VBOTEND] = Standard_True;
  }

  return myVertices[VBOTEND];
}