OCCT

// Created on: 1999-04-26
// Created by: Andrey BETENEV
// Copyright (c) 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 _ShapeFix_ComposeShell_HeaderFile
#define _ShapeFix_ComposeShell_HeaderFile

#include <Standard.hxx>
#include <Standard_Type.hxx>

#include <TopLoc_Location.hxx>
#include <TopoDS_Face.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopoDS_Shape.hxx>
#include <Standard_Integer.hxx>
#include <ShapeFix_Root.hxx>
#include <ShapeExtend_Status.hxx>
#include <ShapeFix_WireSegment.hxx>
#include <NCollection_Sequence.hxx>
class ShapeExtend_CompositeSurface;
class ShapeAnalysis_TransferParameters;
class ShapeExtend_WireData;
class gp_Lin2d;
class ShapeFix_WireSegment;
class Geom_Surface;

// resolve name collisions with X11 headers
#ifdef Status
  #undef Status
#endif

//! This class is intended to create a shell from the composite
//! surface (grid of surfaces) and set of wires.
//! It may be either division of the supporting surface of the
//! face, or creating a shape corresponding to face on composite
//! surface which is missing in CAS.CADE but exists in some other
//! systems.
//!
//! It splits (if necessary) original face to several ones by
//! splitting lines which are joint lines on a supplied grid of
//! surfaces (U- and V- isolines of the composite surface).
//! There are two modes of work, which differ in the way of
//! handling faces on periodic surfaces:
//!
//! - if ClosedMode is False (default), when splitting itself is
//! done as if surface were not periodic. The periodicity of the
//! underlying surface is taken into account by duplicating splitting
//! lines in the periodic direction, as necessary to split all
//! the wires (whole parametrical range of a face)
//! In this mode, some regularization procedures are performed
//! (indexation of split segments by patch numbers), and it is
//! expected to be more reliable and robust in case of bad shapes
//!
//! - if ClosedMode is True, when everything on a periodic surfaces
//! is considered as modulo period. This allows to deal with wires
//! which are closed in 3d but not in 2d, with wires which may be
//! shifted on several periods in 2d etc. However, this mode is
//! less reliable since some regularizations do not work for it.
//!
//! The work is made basing on pcurves of the edges. These pcurves
//! should already exist (for example, in the case of division of
//! existing face), then they are taken as is. The existing pcurves
//! should be assigned to one surface (face) for all edges,
//! this surface (face) will be used only for accessing pcurves,
//! and it may have any geometry.
//!
//! All the modifications are recorded in the context tool
//! (ShapeBuild_ReShape).
class ShapeFix_ComposeShell : public ShapeFix_Root
{

public:
  //! Creates empty tool.
  Standard_EXPORT ShapeFix_ComposeShell();

  //! Initializes with composite surface, face and precision.
  //! Here face defines both set of wires and way of getting
  //! pcurves. Precision is used (together with tolerance of edges)
  //! for handling subtle cases, such as tangential intersections.
  Standard_EXPORT void Init(const occ::handle<ShapeExtend_CompositeSurface>& Grid,
                            const TopLoc_Location&                           L,
                            const TopoDS_Face&                               Face,
                            const double                                     Prec);

  //! Returns (modifiable) flag for special 'closed'
  //! mode which forces ComposeShell to consider
  //! all pcurves on closed surface as modulo period.
  //! This can reduce reliability, but allows to deal
  //! with wires closed in 3d but open in 2d (missing seam)
  //! Default is False
  Standard_EXPORT bool& ClosedMode();

  //! Performs the work on already loaded data.
  Standard_EXPORT virtual bool Perform();

  //! Splits edges in the original shape by grid.
  //! This is a part of Perform() which does not produce any
  //! resulting shape; the only result is filled context
  //! where splittings are recorded.
  //!
  //! NOTE: If edge is split, it is replaced by wire, and
  //! order of edges in the wire corresponds to FORWARD orientation
  //! of the edge.
  Standard_EXPORT void SplitEdges();

  //! Returns resulting shell or face (or Null shape if not done)
  Standard_EXPORT const TopoDS_Shape& Result() const;

  //! Queries status of last call to Perform()
  //! OK   : nothing done (some kind of error)
  //! DONE1: splitting is done, at least one new face created
  //! DONE2: splitting is done, several new faces obtained
  //! FAIL1: misoriented wire encountered (handled)
  //! FAIL2: recoverable parity error
  //! FAIL3: edge with no pcurve on supporting face
  //! FAIL4: unrecoverable algorithm error (parity check)
  Standard_EXPORT bool Status(const ShapeExtend_Status status) const;

  //! Creates new faces from the set of (closed) wires. Each wire
  //! is put on corresponding patch in the composite surface,
  //! and all pcurves on the initial (pseudo)face are reassigned to
  //! that surface. If several wires are one inside another, single
  //! face is created.
  Standard_EXPORT void DispatchWires(NCollection_Sequence<TopoDS_Shape>&         faces,
                                     NCollection_Sequence<ShapeFix_WireSegment>& wires) const;

  //! Sets tool for transfer parameters from 3d to 2d and vice versa.
  Standard_EXPORT void SetTransferParamTool(
    const occ::handle<ShapeAnalysis_TransferParameters>& TransferParam);

  //! Gets tool for transfer parameters from 3d to 2d and vice versa.
  Standard_EXPORT occ::handle<ShapeAnalysis_TransferParameters> GetTransferParamTool() const;

  DEFINE_STANDARD_RTTIEXT(ShapeFix_ComposeShell, ShapeFix_Root)

protected:
  //! Fill sequence of wire segments by wires from myFace
  //! (pre-loaded). It performs reorder so that edges in segments
  //! are well-ordered. The context is applied to all wires
  //! before using them.
  Standard_EXPORT void LoadWires(NCollection_Sequence<ShapeFix_WireSegment>& seqw) const;

  //! Analyze tangencies and compute orientation code for wire segment
  //! between two intersections: tells if segment is on left or right side
  //! of cutting line, or tangent to it (by several points recomputed to 3d,
  //! distance is compared with tolerance of corresponding edge).
  Standard_EXPORT int ComputeCode(const occ::handle<ShapeExtend_WireData>& wire,
                                  const gp_Lin2d&                          line,
                                  const int                                begInd,
                                  const int                                endInd,
                                  const double                             begPar,
                                  const double                             endPar,
                                  const bool                               IsInternal = false);

  //! Splits edges in the wire by given indices of edges and
  //! parameters on them. Returns resulting wire and vertices
  //! corresponding to splitting parameters. If two consecutive
  //! splitting points are too near one to another (with tolerance
  //! of edge), edge is divided in single point. In the same way,
  //! splitting which is too near to end of edge, is not applied
  //! (end vertex is returned instead).
  //!
  //! NOTE: If edge is split, it is replaced by wire, and
  //! order of edges in the wire corresponds to FORWARD orientation
  //! of the edge.
  Standard_EXPORT ShapeFix_WireSegment SplitWire(ShapeFix_WireSegment&               wire,
                                                 NCollection_Sequence<int>&          indexes,
                                                 const NCollection_Sequence<double>& values,
                                                 NCollection_Sequence<TopoDS_Shape>& vertices,
                                                 const NCollection_Sequence<int>&    segcodes,
                                                 const bool                          cutbyu,
                                                 const int                           cutindex);

  //! Split edges in the wire by cutting line.
  //! Wires with FORWARD or REVERSED orientation are considered
  //! as closed.
  //!
  //! All modifications (splitting) are recorded in context,
  //! except splitting of wires marked as EXTERNAL
  //! (they are supposed to be former cutting lines).
  //!
  //! Method fills sequences of parameters of intersection points
  //! of cutting line with all edges, their types, and corresponding
  //! vertices (including ones created during splitting edges).
  Standard_EXPORT bool SplitByLine(ShapeFix_WireSegment&               wire,
                                   const gp_Lin2d&                     line,
                                   const bool                          cutbyu,
                                   const int                           cutindex,
                                   NCollection_Sequence<double>&       SplitLinePar,
                                   NCollection_Sequence<int>&          SplitLineCode,
                                   NCollection_Sequence<TopoDS_Shape>& SplitLineVertex);

  //! Split edges in the sequence of wires by cutting line.
  //! Wires with FORWARD or REVERSED orientation are considered
  //! as closed.
  //!
  //! Parts of cutting line which get inside the face (defined by
  //! parity check of intersections with all wires) are added
  //! into that sequence (with orientation EXTERNAL). Each part
  //! is represented by one-edge wire segment with no 3d curve.
  //! They share common vertices with all wires they intersect.
  //!
  //! All modifications (splitting) are recorded in context,
  //! except splitting of wires marked as EXTERNAL
  //! (they are supposed to be former cutting lines).
  Standard_EXPORT void SplitByLine(NCollection_Sequence<ShapeFix_WireSegment>& seqw,
                                   const gp_Lin2d&                             line,
                                   const bool                                  cutbyu,
                                   const int                                   cutindex);

  //! Split initial set of (closed) wires by grid of lines corresponding
  //! to joints between patches on the composite surface.
  //! Parts of joint lines which get inside the face are also added
  //! into the sequence as wires with orientation EXTERNAL.
  //! They share common vertices with all wires they intersect.
  //! All modifications (splitting) are recorded in context,
  //! except splitting of joint edge itself and wires marked as
  //! EXTERNAL (they supposed to be another joint edges).
  Standard_EXPORT void SplitByGrid(NCollection_Sequence<ShapeFix_WireSegment>& seqw);

  //! Break wires into open wire segments by common vertices
  //! (splitting points), so that each segment is either closed and
  //! not touching others, or touches others at ends (have common
  //! vertices).
  //! After that, each wire segment lies on its own patch of grid.
  Standard_EXPORT void BreakWires(NCollection_Sequence<ShapeFix_WireSegment>& seqw);

  //! Collect set of wire segments (already split) into closed
  //! wires. This is done by traversing all the segments in allowed
  //! directions, starting only from the REVERSED and FORWARD and
  //! taking EXTERNAL as necessary in fork points. Forks are detected
  //! by common vertices. In fork point, most left way is selected
  //! among all possible ways.
  Standard_EXPORT void CollectWires(NCollection_Sequence<ShapeFix_WireSegment>& wires,
                                    NCollection_Sequence<ShapeFix_WireSegment>& seqw);

  //! Creates new faces on one path of grid. It dispatches given loops
  //! (wires) into one or several faces depending on their mutual
  //! position.
  Standard_EXPORT void MakeFacesOnPatch(NCollection_Sequence<TopoDS_Shape>& faces,
                                        const occ::handle<Geom_Surface>&    surf,
                                        NCollection_Sequence<TopoDS_Shape>& loops) const;

  TopAbs_Orientation myOrient;
  TopoDS_Shape       myResult;
  int                myStatus;

private:
  occ::handle<ShapeExtend_CompositeSurface>     myGrid;
  TopLoc_Location                               myLoc;
  TopoDS_Face                                   myFace;
  double                                        myUResolution;
  double                                        myVResolution;
  occ::handle<ShapeAnalysis_TransferParameters> myTransferParamTool;
  bool                                          myInvertEdgeStatus;
  bool                                          myClosedMode;
  bool                                          myUClosed;
  bool                                          myVClosed;
  double                                        myUPeriod;
  double                                        myVPeriod;
};

#endif // _ShapeFix_ComposeShell_HeaderFile