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

Warning, file /include/opencascade/ShapeFix_ComposeShell.hxx was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 // 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

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