OCCT

// Created on: 1995-01-04
// Created by: Bruno DUMORTIER
// Copyright (c) 1995-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 <BRep_Builder.hxx>
#include <BRepLib.hxx>
#include <BRepLib_MakeFace.hxx>
#include <BRepLib_MakeShell.hxx>
#include <Geom2d_Line.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Precision.hxx>
#include <StdFail_NotDone.hxx>
#include <TColGeom2d_Array1OfCurve.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
#include <TopTools_Array1OfShape.hxx>

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

BRepLib_MakeShell::BRepLib_MakeShell()
    : myError(BRepLib_EmptyShell)
{
}

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

BRepLib_MakeShell::BRepLib_MakeShell(const Handle(Geom_Surface)& S, const Standard_Boolean Segment)
{
  Standard_Real UMin, UMax, VMin, VMax;
  S->Bounds(UMin, UMax, VMin, VMax);
  Init(S, UMin, UMax, VMin, VMax, Segment);
}

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

BRepLib_MakeShell::BRepLib_MakeShell(const Handle(Geom_Surface)& S,
                                     const Standard_Real         UMin,
                                     const Standard_Real         UMax,
                                     const Standard_Real         VMin,
                                     const Standard_Real         VMax,
                                     const Standard_Boolean      Segment)
{
  Init(S, UMin, UMax, VMin, VMax, Segment);
}

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

void BRepLib_MakeShell::Init(const Handle(Geom_Surface)& S,
                             const Standard_Real         UMin,
                             const Standard_Real         UMax,
                             const Standard_Real         VMin,
                             const Standard_Real         VMax,
                             const Standard_Boolean      Segment)
{
  Handle(Geom_Surface) BS = S;
  if (S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
  {
    Handle(Geom_RectangularTrimmedSurface) RTS =
      Handle(Geom_RectangularTrimmedSurface)::DownCast(S);
    BS = RTS->BasisSurface();
  }
  myError                     = BRepLib_EmptyShell;
  constexpr Standard_Real tol = Precision::Confusion();

  // Make a shell from a surface
  GeomAdaptor_Surface GS(BS, UMin, UMax, VMin, VMax);

  Standard_Integer nu = GS.NbUIntervals(GeomAbs_C2);
  Standard_Integer nv = GS.NbVIntervals(GeomAbs_C2);

  Standard_Boolean uperiodic = GS.IsUPeriodic();
  Standard_Boolean vperiodic = GS.IsVPeriodic();

  if (nu == 0 || nv == 0)
    return;

  // arrays of parameters and pcurves
  TColStd_Array1OfReal     upars(1, nu + 1);
  TColStd_Array1OfReal     vpars(1, nv + 1);
  TColGeom2d_Array1OfCurve uisos(1, nu + 1);
  TColGeom2d_Array1OfCurve visos(1, nv + 1);

  Standard_Integer iu, iv;

  GS.UIntervals(upars, GeomAbs_C2);
  gp_Dir2d dv(0, 1);
  for (iu = 1; iu <= nu + 1; iu++)
  {
    Standard_Real u = upars(iu);
    if (!Precision::IsInfinite(u))
      uisos(iu) = new Geom2d_Line(gp_Pnt2d(u, 0.), dv);
  }

  GS.VIntervals(vpars, GeomAbs_C2);
  gp_Dir2d du(1, 0);
  for (iv = 1; iv <= nv + 1; iv++)
  {
    Standard_Real v = vpars(iv);
    if (!Precision::IsInfinite(v))
      visos(iv) = new Geom2d_Line(gp_Pnt2d(0., v), du);
  }

  // create row by row

  // create the shell
  BRep_Builder B;
  B.MakeShell(TopoDS::Shell(myShape));

  // arrays of edges and vertices for each row
  TopTools_Array1OfShape botedges(1, nu);
  TopTools_Array1OfShape botvertices(1, nu + 1);

  // copies of the first ones for periodic case
  TopTools_Array1OfShape fbotedges(1, nu);
  TopTools_Array1OfShape fbotvertices(1, nu + 1);

  TopoDS_Face   F;
  TopoDS_Wire   W;
  TopoDS_Edge   eleft, eright, etop, ebot, feleft;
  TopoDS_Vertex vlb, vlt, vrb, vrt, fvlt;

  // init the botedges and botvertices
  if (!Precision::IsInfinite(vpars(1)))
  {
    if (!Precision::IsInfinite(upars(1)))
      B.MakeVertex(vrt, S->Value(upars(1), vpars(1)), tol);
    fbotvertices(1) = botvertices(1) = vrt;

    for (iu = 1; iu <= nu; iu++)
    {
      vlt = vrt;

      if (uperiodic && iu == nu)
        vrt = TopoDS::Vertex(botvertices(1));
      else if (!Precision::IsInfinite(upars(iu + 1)))
        B.MakeVertex(vrt, S->Value(upars(iu + 1), vpars(1)), tol);

      fbotvertices(iu + 1) = botvertices(iu + 1) = vrt;
      B.MakeEdge(etop);
      if (!vlt.IsNull())
      {
        vlt.Orientation(TopAbs_FORWARD);
        B.Add(etop, vlt);
      }
      if (!vrt.IsNull())
      {
        vrt.Orientation(TopAbs_REVERSED);
        B.Add(etop, vrt);
      }
      fbotedges(iu) = botedges(iu) = etop;
    }
  }

  for (iv = 1; iv <= nv; iv++)
  {

    // compute the first edge and vertices of the line
    vrb = TopoDS::Vertex(botvertices(1));

    if (vperiodic && iv == nv)
    {
      vrt = TopoDS::Vertex(fbotvertices(1));
    }
    else
    {
      vrt.Nullify();
      if (!Precision::IsInfinite(vpars(iv + 1)))
      {
        if (!Precision::IsInfinite(upars(1)))
          B.MakeVertex(vrt, S->Value(upars(1), vpars(iv + 1)), tol);
      }
    }

    eright.Nullify();
    if (!Precision::IsInfinite(upars(1)))
    {
      B.MakeEdge(eright);
      if (!vrb.IsNull())
      {
        vrb.Orientation(TopAbs_FORWARD);
        B.Add(eright, vrb);
      }
      if (!vrt.IsNull())
      {
        vrt.Orientation(TopAbs_REVERSED);
        B.Add(eright, vrt);
      }
    }

    fvlt   = vrt;
    feleft = eright;

    // make the row of faces

    for (iu = 1; iu <= nu; iu++)
    {

      // create the face at iu, iv

      // the surface
      Handle(Geom_Surface) SS = Handle(Geom_Surface)::DownCast(BS->Copy());
      if (GS.GetType() == GeomAbs_BSplineSurface && Segment)
      {
        Handle(Geom_BSplineSurface)::DownCast(SS)->Segment(upars(iu),
                                                           upars(iu + 1),
                                                           vpars(iv),
                                                           vpars(iv + 1));
      }
      B.MakeFace(F, SS, tol);

      // the wire

      B.MakeWire(W);

      // the vertices

      vlb = vrb;
      vrb = TopoDS::Vertex(botvertices(iu + 1));
      vlt = vrt;

      if (uperiodic && iu == nu)
        vrt = fvlt;
      else
      {
        vrt.Nullify();
        if (!Precision::IsInfinite(vpars(iv + 1)))
        {
          if (!Precision::IsInfinite(upars(iu + 1)))
            B.MakeVertex(vrt, S->Value(upars(iu + 1), vpars(iv + 1)), tol);
        }
      }

      botvertices(iu)     = vlt;
      botvertices(iu + 1) = vrt;

      // the edges

      eleft = eright;

      if (uperiodic && iu == nu)
        eright = feleft;
      else
      {
        eright.Nullify();
        if (!Precision::IsInfinite(upars(iu + 1)))
        {
          B.MakeEdge(eright);
          if (!vrb.IsNull())
          {
            vrb.Orientation(TopAbs_FORWARD);
            B.Add(eright, vrb);
          }
          if (!vrt.IsNull())
          {
            vrt.Orientation(TopAbs_REVERSED);
            B.Add(eright, vrt);
          }
        }
      }

      if (uperiodic && nu == 1)
      {
        if (!eleft.IsNull() && !eright.IsNull())
        {
          B.UpdateEdge(eleft, uisos(2), uisos(1), F, tol);
          B.Range(eleft, F, vpars(iv), vpars(iv + 1));
        }
      }
      else
      {
        if (!eleft.IsNull())
        {
          B.UpdateEdge(eleft, uisos(iu), F, tol);
          B.Range(eleft, F, vpars(iv), vpars(iv + 1));
        }
        if (!eright.IsNull())
        {
          B.UpdateEdge(eright, uisos(iu + 1), F, tol);
          B.Range(eright, F, vpars(iv), vpars(iv + 1));
        }
      }

      ebot = TopoDS::Edge(botedges(iu));

      if (vperiodic && iv == nv)
        etop = TopoDS::Edge(fbotedges(iu));
      else
      {
        etop.Nullify();
        if (!Precision::IsInfinite(vpars(iv + 1)))
        {
          B.MakeEdge(etop);
          if (!vlt.IsNull())
          {
            vlt.Orientation(TopAbs_FORWARD);
            B.Add(etop, vlt);
          }
          if (!vrt.IsNull())
          {
            vrt.Orientation(TopAbs_REVERSED);
            B.Add(etop, vrt);
          }
        }
      }

      if (vperiodic && nv == 1)
      {
        if (!ebot.IsNull() && !etop.IsNull())
        {
          B.UpdateEdge(ebot, visos(1), visos(2), F, tol);
          B.Range(ebot, F, vpars(iv), vpars(iv + 1));
        }
      }
      else
      {
        if (!ebot.IsNull())
        {
          B.UpdateEdge(ebot, visos(iv), F, tol);
          B.Range(ebot, F, upars(iu), upars(iu + 1));
        }
        if (!etop.IsNull())
        {
          B.UpdateEdge(etop, visos(iv + 1), F, tol);
          B.Range(etop, F, upars(iu), upars(iu + 1));
        }
      }

      botedges(iu) = etop;

      if (!eleft.IsNull())
      {
        eleft.Orientation(TopAbs_REVERSED);
        B.Add(W, eleft);
      }
      if (!ebot.IsNull())
      {
        ebot.Orientation(TopAbs_FORWARD);
        B.Add(W, ebot);
      }
      if (!eright.IsNull())
      {
        eright.Orientation(TopAbs_FORWARD);
        B.Add(W, eright);
      }
      if (!etop.IsNull())
      {
        etop.Orientation(TopAbs_REVERSED);
        B.Add(W, etop);
      }

      B.Add(F, W);
      B.Add(myShape, F);
    }
  }

  // codage des courbes 3d et regularites.
  BRepLib::BuildCurves3d(myShape, tol);
  BRepLib::EncodeRegularity(myShape);
  myShape.Closed(BRep_Tool::IsClosed(myShape));

  // Additional checking for degenerated edges
  Standard_Boolean        isDegenerated;
  Standard_Real           aFirst, aLast;
  constexpr Standard_Real aTol = Precision::Confusion();
  Standard_Real           anActTol;
  TopExp_Explorer         anExp(myShape, TopAbs_EDGE);
  for (; anExp.More(); anExp.Next())
  {
    const TopoDS_Edge& anEdge = TopoDS::Edge(anExp.Current());
    Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, aFirst, aLast);
    isDegenerated             = BRepLib_MakeFace::IsDegenerated(aCurve, aTol, anActTol);
    B.Degenerated(anEdge, isDegenerated);
  }

  myError = BRepLib_ShellDone;
  Done();
}

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

BRepLib_ShellError BRepLib_MakeShell::Error() const
{
  return myError;
}

//=======================================================================
// function : TopoDS_Shell&
// purpose  :
//=======================================================================

const TopoDS_Shell& BRepLib_MakeShell::Shell() const
{
  return TopoDS::Shell(myShape);
}

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

BRepLib_MakeShell::operator TopoDS_Shell() const
{
  return Shell();
}