src/ShapeAnalysis/ShapeAnalysis_Wire.cdl

   1 -- Created on: 1998-06-03
   2 -- Created by: data exchange team
   3 -- Copyright (c) 1998-1999 Matra Datavision
   4 -- Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 --
   6 -- This file is part of Open CASCADE Technology software library.
   7 --
   8 -- This library is free software; you can redistribute it and/or modify it under
   9 -- the terms of the GNU Lesser General Public License version 2.1 as published
  10 -- by the Free Software Foundation, with special exception defined in the file
  11 -- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 -- distribution for complete text of the license and disclaimer of any warranty.
  13 --
  14 -- Alternatively, this file may be used under the terms of Open CASCADE
  15 -- commercial license or contractual agreement.
  16
  17 class Wire from ShapeAnalysis inherits TShared from MMgt
  18
  19         ---Purpose: This class provides analysis of a wire to be compliant to
  20         --          CAS.CADE requirements.
  21         --
  22         --          The functionalities provided are the following:
  23         --           1. consistency of 2d and 3d edge curve senses
  24         --           2. connection of adjacent edges regarding to:
  25         --             a. their vertices
  26         --             b. their pcurves
  27         --             c. their 3d curves
  28         --           3. adjacency of the edge vertices to its pcurve and 3d curve
  29         --           4. if a wire is closed or not (considering its 3d and 2d
  30         --              contour)
  31         --           5. if a wire is outer on its face (considering pcurves)
  32         --
  33         --
  34         --          This class can be used in conjunction with class
  35         --          ShapeFix_Wire, which will fix the problems detected by this class.
  36         --
  37         --          The methods of the given class match to ones of the class
  38         --          ShapeFix_Wire, e.g., CheckSmall and FixSmall.
  39         --          This class also includes some auxilary methods
  40         --          (e.g., CheckOuterBound, etc.),
  41         --          which have no pair in ShapeFix_Wire.
  42         --
  43         --          Like methods of ShapeFix_Wire the ones of this class are
  44         --          grouped into two levels:
  45         --          - Public which are recommended for use (the most global
  46         --            method is Perform),
  47         --          - Advanced, for optional use only
  48         --
  49         --          For analyzing result of Public API checking methods use
  50         --          corresponding Status... method.
  51         --          The 'advanced' functions share the single status field which
  52         --          contains the result of the last performed 'advanced' method.
  53         --          It is quried by the method LastCheckStatus().
  54         --
  55         --          In order to prepare an analyzer, it is necessary to load a wire,
  56         --          set face and precision.
  57
  58 uses
  59
  60     Pnt2d     from gp,
  61     Curve     from Geom2d,
  62     Surface   from Geom,
  63     Location  from TopLoc,
  64     Shape     from TopoDS,
  65     Wire      from TopoDS,
  66     Face      from TopoDS,
  67     SequenceOfIntersectionPoint from IntRes2d,
  68     SequenceOfPnt               from TColgp,
  69     SequenceOfReal              from TColStd,
  70     Status    from ShapeExtend,
  71     WireData  from ShapeExtend,
  72     WireOrder from ShapeAnalysis,
  73     Surface   from ShapeAnalysis,
  74     IndexedMapOfShape from TopTools,
  75     DataMapOfShapeListOfShape from TopTools,
  76     MapOfShape from TopTools
  77 is
  78
  79     Create returns Wire from ShapeAnalysis;
  80         ---Purpose: Empty constructor
  81
  82     Create (wire     : Wire from TopoDS;
  83             face     : Face from TopoDS;
  84             precision: Real)
  85     returns Wire from ShapeAnalysis;
  86         ---Purpose: Creates object with standard TopoDS_Wire, face
  87         --          and precision
  88
  89     Create (sbwd     : WireData from ShapeExtend;
  90             face     : Face from TopoDS;
  91             precision: Real)
  92     returns Wire from ShapeAnalysis;
  93         ---Purpose: Creates the object with WireData object, face
  94         --          and precision
  95
  96     Init (me: mutable; wire     : Wire from TopoDS;
  97                       face     : Face from TopoDS;
  98                       precision: Real);
  99         ---Purpose: Initializes the object with standard TopoDS_Wire, face
 100         --          and precision
 101
 102     Init (me: mutable; sbwd     : WireData from ShapeExtend;
 103                       face     : Face from TopoDS;
 104                       precision: Real);
 105         ---Purpose: Initializes the object with WireData object, face
 106         --          and precision
 107
 108     Load (me: mutable; wire: Wire from TopoDS);
 109         ---Purpose: Loads the object with standard TopoDS_Wire
 110
 111     Load (me: mutable; sbwd: WireData from ShapeExtend);
 112         ---Purpose: Loads the object with WireData object
 113         ---Remark : Single WireData object will be shared
 114
 115     SetFace (me: mutable; face : Face from TopoDS);
 116         ---Purpose: Loads the face the wire lies on
 117
 118     SetSurface (me: mutable; surface : Surface from Geom);
 119         ---Purpose: Loads the surface the wire lies on
 120
 121     SetSurface (me: mutable; surface : Surface from Geom;
 122                             location: Location from TopLoc);
 123         ---Purpose: Loads the surface the wire lies on
 124
 125     SetPrecision (me: mutable; precision: Real);
 126         ---Precision: Set the precision value
 127
 128     ClearStatuses (me: mutable);
 129         ---Purpose: Unsets all the status and distance fields
 130         --          wire, face and precision are not cleared
 131
 132     IsLoaded (me) returns Boolean;
 133         ---C++: inline
 134         ---Purpose: Returns True if wire is loaded and has number of edges >0
 135
 136     IsReady (me) returns Boolean;
 137         ---C++: inline
 138         ---Purpose: Returns True if IsLoaded and underlying face is not null
 139
 140     Precision (me) returns Real;
 141         ---C++: inline
 142         ---Purpose: Returns the value of precision
 143
 144     WireData (me) returns WireData from ShapeExtend;
 145         ---C++: return const &
 146         ---C++: inline
 147         ---Purpose: Returns wire object being analyzed
 148
 149     NbEdges (me) returns Integer;
 150         ---C++: inline
 151         ---Purpose: Returns the number of edges in the wire, or 0 if it is not loaded
 152
 153     Face (me) returns Face from TopoDS;
 154         ---C++: return const &
 155         ---C++: inline
 156         ---Purpose: Returns the working face
 157
 158     Surface (me) returns Surface from ShapeAnalysis;
 159         ---C++: return const &
 160         ---C++: inline
 161         ---Purpose: Returns the working surface
 162
 163
 164     ---Checking methods:
 165
 166     ---Level: Public
 167
 168     ---Return: Check..() methods return True when and only when the situation was
 169     --         analyzed and the specific case detected.
 170     --         This corresponds to the flag DONE (or one of DONE#i) set in Status.
 171
 172     Perform (me : mutable) returns Boolean;
 173         ---Purpose: Performs all the checks in the following order :
 174         --          CheckOrder, CheckSmall, CheckConected, CheckEdgeCurves,
 175         --          CheckDegenerated, CheckSelfIntersection, CheckLacking,
 176         --          CheckClosed
 177         --  Returns: True if at least one method returned True;
 178         --          For deeper analysis use Status...(status) methods
 179
 180     CheckOrder (me: mutable; isClosed: Boolean = Standard_True;
 181                              mode3d: Boolean = Standard_True) returns Boolean;
 182         ---Purpose: Calls CheckOrder and returns False if wire is already
 183         --          ordered (tail-to-head), True otherwise
 184         --          Flag <isClosed> defines if the wire is closed or not
 185         --          Flag <mode3d> defines which mode is used (3d or 2d)
 186
 187     CheckConnected (me : mutable; prec : Real = 0.0) returns Boolean;
 188         ---Purpose: Calls to CheckConnected for each edge
 189         --  Returns: True if at least one pair of disconnected edges (not sharing the
 190         --          same vertex) was detected
 191
 192     CheckSmall (me : mutable; precsmall : Real = 0.0) returns Boolean;
 193         ---Purpose: Calls to CheckSmall for each edge
 194         --  Returns: True if at least one small edge was detected
 195
 196     CheckEdgeCurves (me : mutable) returns Boolean;
 197         ---Purpose: Checks edges geometry (consitency of 2d and 3d senses, adjasment
 198         --          of curves to the vertices, etc.).
 199         --          The order of the checks :
 200         --          Call ShapeAnalysis_Wire to check:
 201         --          ShapeAnalysis_Edge::CheckCurve3dWithPCurve  (1),
 202         --          ShapeAnalysis_Edge::CheckVertcesWithPCurve  (2),
 203         --          ShapeAnalysis_Edge::CheckVertcesWithCurve3d (3),
 204         --          CheckSeam                                   (4)
 205         --          Additional:
 206         --          CheckGap3d                                  (5),
 207         --          CheckGap2d                                  (6),
 208         --          ShapeAnalysis_Edge::CheckSameParameter      (7)
 209         -- Returns: True if at least one check returned True
 210         --  Remark:  The numbers in brackets show with what DONEi or FAILi
 211         --          the status can be queried
 212
 213     CheckDegenerated (me : mutable) returns Boolean;
 214         ---Purpose: Calls to CheckDegenerated for each edge
 215         --  Returns: True if at least one incorrect degenerated edge was detected
 216
 217     CheckClosed (me : mutable; prec : Real = 0.0) returns Boolean;
 218         ---Purpose: Checks if wire is closed, performs CheckConnected,
 219         --          CheckDegenerated and CheckLacking for the first and the last edges
 220         --  Returns: True if at least one check returned True
 221         --  Status:
 222         --          FAIL1 or DONE1: see CheckConnected
 223         --          FAIL2 or DONE2: see CheckDegenerated
 224
 225     CheckSelfIntersection (me : mutable) returns Boolean;
 226         ---Purpose: Checks self-intersection of the wire (considering pcurves)
 227         --          Looks for self-intersecting edges and each pair of intersecting
 228         --          edges.
 229         --  Warning: It does not check each edge with any other one (only each two
 230         --          adjacent edges)
 231         --          The order of the checks :
 232         --          CheckSelfIntersectingEdge, CheckIntersectingEdges
 233         --  Returns: True if at least one check returned True
 234         --  Status:  FAIL1 or DONE1 - see CheckSelfIntersectingEdge
 235         --          FAIL2 or DONE2 - see CheckIntersectingEdges
 236
 237     CheckLacking (me : mutable) returns Boolean;
 238         ---Purpose: Calls to CheckLacking for each edge
 239         --  Returns: True if at least one lacking edge was detected
 240
 241     CheckGaps3d (me : mutable) returns Boolean;
 242         ---Purpose:
 243         ---Returns:
 244
 245     CheckGaps2d (me : mutable) returns Boolean;
 246         ---Purpose:
 247         ---Returns:
 248
 249     CheckCurveGaps (me : mutable) returns Boolean;
 250         ---Purpose:
 251         ---Returns:
 252
 253
 254     ---Level: Advanced
 255
 256     ---Status: For analyzing the status of the last performed method use method
 257     --          Status(status)
 258     --
 259     --          All the Check...() methods below return False if the problem was
 260     --          not detected. If so, Status(ShapeExtend_OK) returns True.
 261
 262     CheckOrder (me: mutable; sawo: out WireOrder from ShapeAnalysis;
 263                              isClosed: Boolean = Standard_True;
 264                              mode3d: Boolean = Standard_True)
 265     returns Boolean;
 266         ---Purpose: Analyzes the order of the edges in the wire,
 267         --          uses class WireOrder for that purpose.
 268         --          Flag <isClosed> defines if the wire is closed or not
 269         --          Flag <mode3d> defines which mode is used (3d or 2d)
 270         --          Returns False if wire is already ordered (tail-to-head),
 271         --          True otherwise.
 272         --          Use returned WireOrder object for deeper analysis.
 273         --  Status:
 274         --          OK   : the same edges orientation, the same edges sequence
 275         --          DONE1: the same edges orientation, not the same edges sequence
 276         --          DONE2: as DONE1 and gaps more than myPrecision
 277         --          DONE3: not the same edges orientation (some need to be reversed)
 278         --          DONE4: as DONE3 and gaps more than myPrecision
 279         --          FAIL : algorithm failed (could not detect order)
 280
 281     CheckConnected (me : mutable; num: Integer; prec: Real = 0.0) returns Boolean;
 282         ---Purpose: Checks connected edges (num-th and preceeding).
 283         --           Tests with starting preci from <SBWD> or  with <prec> if
 284         --               it is greater.
 285         --           Considers Vertices.
 286         --  Returns: False if edges are connected by the common vertex, else True
 287         --  Status  :
 288         --           OK    : Vertices (end of num-1 th edge and start on num-th one)
 289         --                   are already the same
 290         --           DONE1 : Absolutely confused (gp::Resolution)
 291         --           DONE2 : Confused at starting <preci> from <SBWD>
 292         --           DONE3 : Confused at <prec> but not <preci>
 293         --           FAIL1 : Not confused
 294         --           FAIL2 : Not confused but confused with <preci> if reverse num-th edge
 295
 296     CheckSmall (me : mutable; num      : Integer;
 297                              precsmall: Real = 0.0)
 298     returns Boolean;
 299         ---Purpose: Checks if an edge has a length not greater than myPreci or
 300         --          precsmall (if it is smaller)
 301         --  Returns: False if its length is greater than precision
 302         --  Status:
 303         --          OK   : edge is not small or degenerated
 304         --          DONE1: edge is small, vertices are the same
 305         --          DONE2: edge is small, vertices are not the same
 306         --          FAIL : no 3d curve and pcurve
 307
 308     CheckSeam (me : mutable; num   : Integer;
 309                             C1, C2: out Curve from Geom2d;
 310                             cf, cl: out Real)
 311     returns Boolean;
 312         ---Purpose: Checks if a seam pcurves are correct oriented
 313         --  Returns: False (status OK) if given edge is not a seam or if it is OK
 314         --          C1 - current pcurve for FORWARD edge,
 315         --          C2 - current pcurve for REVERSED edge (if returns True they
 316         --          should be swapped for the seam),
 317         --          cf, cl - first and last parameters on curves
 318         --  Status:
 319         --          OK   : Pcurves are correct or edge is not seam
 320         --          DONE : Seam pcurves should be swapped
 321
 322     CheckSeam (me : mutable; num: Integer) returns Boolean;
 323         ---Purpose: Checks if a seam pcurves are correct oriented
 324         --          See previous functions for details
 325
 326     CheckDegenerated (me: mutable; num: Integer; dgnr1, dgnr2: out Pnt2d from gp)
 327     returns Boolean;
 328         ---Purpose: Checks for degenerated edge between two adjacent ones.
 329         --          Fills parameters dgnr1 and dgnr2 with points in paramterical
 330         --          space that correspond to the singularity (either gap that
 331         --          needs to be filled by degenerated edge or that already filled)
 332         --  Returns: False if no singularity or edge is already degenerated,
 333         --          otherwise True
 334         --  Status:
 335         --          OK   : No surface singularity, or edge is already degenerated
 336         --          DONE1: Degenerated edge should be inserted (gap in 2D)
 337         --          DONE2: Edge <num> should be made degenerated (recompute pcurve
 338         --                 and set the flag)
 339         --          FAIL1: One of edges neighbouring to degenerated one has
 340         --                 no pcurve
 341         --          FAIL2: Edge marked as degenerated and has no pcurve
 342         --                 but singularity is not detected
 343
 344     CheckDegenerated (me: mutable; num: Integer)
 345     returns Boolean;
 346         ---Purpose: Checks for degenerated edge between two adjacent ones.
 347         --  Remark : Calls previous function
 348         --  Status : See the function above for details
 349
 350     CheckGap3d (me : mutable; num : Integer = 0) returns Boolean;
 351         ---Purpose: Checks gap between edges in 3D (3d curves).
 352         --          Checks the distance between ends of 3d curves of the num-th
 353         --          and preceeding edge.
 354         --          The distance can be queried by MinDistance3d.
 355         --
 356         --  Returns: True if status is DONE
 357         --  Status:
 358         --          OK   : Gap is less than myPrecision
 359         --          DONE : Gap is greater than myPrecision
 360         --          FAIL : No 3d curve(s) on the edge(s)
 361
 362     CheckGap2d (me : mutable; num : Integer = 0) returns Boolean;
 363         ---Purpose: Checks gap between edges in 2D (pcurves).
 364         --          Checks the distance between ends of pcurves of the num-th
 365         --          and preceeding edge.
 366         --          The distance can be queried by MinDistance2d.
 367         --
 368         --  Returns: True if status is DONE
 369         --  Status:
 370         --          OK   : Gap is less than parametric precision out of myPrecision
 371         --          DONE : Gap is greater than parametric precision out of myPrecision
 372         --          FAIL : No pcurve(s) on the edge(s)
 373
 374     CheckCurveGap (me : mutable; num : Integer = 0) returns Boolean;
 375         ---Purpose: Checks gap between points on 3D curve and points on surface
 376         --          generated by pcurve of the num-th edge.
 377         --          The distance can be queried by MinDistance3d.
 378         --
 379         --  Returns: True if status is DONE
 380         --  Status:
 381         --          OK   : Gap is less than myPrecision
 382         --          DONE : Gap is greater than myPrecision
 383         --          FAIL : No 3d curve(s) on the edge(s)
 384
 385     CheckSelfIntersectingEdge (me: mutable; num: Integer;
 386                                points2d: out SequenceOfIntersectionPoint from IntRes2d;
 387                                points3d: out SequenceOfPnt from TColgp)
 388     returns Boolean;
 389         ---Purpose: Checks if num-th edge is self-intersecting.
 390         --          Self-intersection is reported only if intersection point lies outside
 391         --          of both end vertices of the edge.
 392         --  Returns: True if edge is self-intersecting.
 393         --          If returns True it also fills the sequences of intersection points
 394         --          and corresponding 3d points (only that are not enclosed by a vertices)
 395         --  Status:
 396         --          FAIL1 : No pcurve
 397         --          FAIL2 : No vertices
 398         --          DONE1 : Self-intersection found
 399
 400     CheckSelfIntersectingEdge (me: mutable; num: Integer)
 401     returns Boolean;
 402         --  Purpose: Checks num-th edge to be self-intersecting.
 403         --  Remark : Calls the previous method
 404         --  Status : See the function above for details
 405
 406     CheckIntersectingEdges (me : mutable; num: Integer;
 407                             points2d: out SequenceOfIntersectionPoint from IntRes2d;
 408                             points3d: out SequenceOfPnt from TColgp;
 409                             errors: out SequenceOfReal from TColStd)
 410     returns Boolean;
 411         ---Purpose: Checks two adjacent edges for intersecting.
 412         --          Intersection is reported only if intersection point is not enclosed
 413         --          by the common end vertex of the edges.
 414         --  Returns: True if intersection is found.
 415         --          If returns True it also fills the sequences of intersection points,
 416         --          corresponding 3d points, and errors for them (half-distances between
 417         --          intersection points in 3d calculated from one and from another edge)
 418         --  Status:
 419         --          FAIL1 : No pcurve
 420         --          FAIL2 : No vertices
 421         --          DONE1 : Self-intersection found
 422
 423     CheckIntersectingEdges (me: mutable; num: Integer)
 424     returns Boolean;
 425         ---Purpose: Checks two adjacent edges for intersecting.
 426         --  Remark : Calls the previous method
 427         --  Status : See the function above for details
 428
 429     CheckIntersectingEdges(me: mutable; num1: Integer; num2: Integer;
 430                            points2d: out SequenceOfIntersectionPoint from IntRes2d;
 431                            points3d: out SequenceOfPnt from TColgp;
 432                            errors: out SequenceOfReal from TColStd)
 433     returns Boolean;
 434         ---Purpose: Checks i-th and j-th edges for intersecting.
 435         --  Remark : See the previous method for details
 436
 437     CheckIntersectingEdges(me: mutable; num1: Integer; num2: Integer)
 438     returns Boolean;
 439         ---Purpose: Checks i-th and j-th edges for intersecting.
 440         --  Remark : Calls  previous method.
 441         --  Status : See the function above for details
 442
 443     CheckLacking (me: mutable; num: Integer; Tolerance: Real;
 444                               p2d1, p2d2: out Pnt2d from gp) returns Boolean;
 445         ---Purpose: Checks if there is a gap in 2d between edges, not comprised by
 446         --          the tolerance of their common vertex.
 447         --          If <Tolerance> is greater than 0. and less than tolerance of
 448         --          the vertex, then this value is used for check.
 449         --  Returns: True if not closed gap was detected
 450         --          p2d1 and p2d2 are the endpoint of <num-1>th edge and start of
 451         --          the <num>th edge in 2d.
 452         --  Status:
 453         --          OK: No edge is lacking (3d and 2d connection)
 454         --          FAIL1: edges have no vertices (at least one of them)
 455         --          FAIL2: edges are neither connected by common vertex, nor have
 456         --                 coincided vertices
 457         --          FAIL1: edges have no pcurves
 458         --          DONE1: the gap is detected which cannot be closed by the tolerance
 459         --                 of the common vertex (or with value of <Tolerance>)
 460         --          DONE2: is set (together with DONE1) if gap is detected and the
 461         --                 vector (p2d2 - p2d1) goes in direction opposite to the pcurves
 462         --                 of the edges (if angle is more than 0.9*PI).
 463
 464     CheckLacking (me : mutable; num: Integer; Tolerance: Real = 0.0) returns Boolean;
 465         ---Purpose: Checks if there is a gap in 2D between edges and not comprised by vertex tolerance
 466          --         The value of SBWD.thepreci is used.
 467         --  Returns: False if no edge should be inserted
 468         --  Status:
 469         --           OK    : No edge is lacking (3d and 2d connection)
 470         --          DONE1 : The vertex tolerance should be increased only (2d gap is
 471         --                  small)
 472         --          DONE2 : Edge can be inserted (3d and 2d gaps are large enough)
 473
 474     CheckOuterBound (me: mutable; APIMake: Boolean = Standard_True)
 475     returns Boolean;
 476         ---Purpose: Checks if wire defines an outer bound on the face
 477         --          Uses ShapeAnalysis::IsOuterBound for analysis
 478         --          If <APIMake> is True uses BRepAPI_MakeWire to build the
 479         --          wire, if False (to be used only when edges share common
 480         --          vertices) uses BRep_Builder to build the wire
 481         --
 482         ---Returns: False if wire is an outer bound, else returns True
 483         --  Status:
 484         --          OK   : If it is an outer wire
 485         --          DONE : If not
 486
 487     CheckNotchedEdges(me : mutable; num      : Integer;
 488                                     shortNum : out Integer;
 489                                     param    : out Real;
 490                                     Tolerance: Real = 0.0) returns Boolean;
 491         ---Purpose: Detects a notch
 492
 493     CheckSmallArea (me: mutable; theWire : Wire from TopoDS; theIsOuterWire : Boolean)
 494     returns Boolean;
 495         ---Purpose: Checks if wire has parametric area less than precision.
 496
 497     CheckShapeConnect (me : mutable; shape : Shape from TopoDS; prec: Real = 0.0)
 498     returns Boolean;
 499         ---Purpose: Checks with what orientation <shape> (wire or edge) can be
 500         --           connected to the wire.
 501         --           Tests distances with starting <preci> from <SBWD> (close confusion),
 502         --           but if given <prec> is greater, tests with <prec> (coarse confusion).
 503         --           The smallest found distance can be returned by MinDistance3d
 504         --
 505         --  Returns: False if status is FAIL (see below)
 506         --  Status:
 507         --           DONE1 : If <shape> follows <SBWD>, direct sense (normal)
 508         --           DONE2 : If <shape> follows <SBWD>, but if reversed
 509         --           DONE3 : If <shape> preceeds <SBWD>, direct sense
 510         --           DONE4 : If <shape> preceeds <SBWD>, but if reversed
 511         --           FAIL1 : If <shape> is neither an edge nor a wire
 512         --           FAIL2 : If <shape> cannot be connected to <SBWD>
 513         --
 514         --           DONE5 : To the tail of <SBWD> the <shape> is closer with
 515         --                   direct sense
 516         --           DONE6 : To the head of <SBWD> the <shape> is closer with
 517         --                   direct sense
 518         --
 519         --  Remark:   Statuses DONE1 - DONE4, FAIL1 - FAIL2 are basic and
 520         --           describe the nearest connection of the <shape> to <SBWD>.
 521         --           Statuses DONE5 and DONE6 are advanced and are to be used when
 522         --           analyzing with what sense (direct or reversed) the <shape>
 523         --           should be connected to <SBWD>:
 524         --           For tail of <SBWD> if DONE4 is True <shape> should be direct,
 525         --           otherwise reversed.
 526         --           For head of <SBWD> if DONE5 is True <shape> should be direct,
 527         --           otherwise reversed.
 528
 529     CheckShapeConnect (me : mutable; tailhead: out Real;
 530                                     tailtail: out Real;
 531                                     headtail: out Real;
 532                                     headhead: out Real;
 533                                     shape   : Shape from TopoDS;
 534                                     prec    : Real = 0.0)
 535     returns Boolean;
 536         ---Purpose: The same as previous CheckShapeConnect but is more advanced.
 537         --          It returns the distances between each end of <sbwd> and each
 538         --          end of <shape>. For example, <tailhead> stores distance
 539         --          between tail of <sbwd> and head of <shape>
 540         --  Remark:  First method CheckShapeConnect calls this one
 541
 542     CheckLoop (me : mutable; aMapLoopVertices : out IndexedMapOfShape from TopTools;
 543                              aMapVertexEdges :out DataMapOfShapeListOfShape from TopTools;
 544                              aMapSmallEdges : out MapOfShape from TopTools;
 545                              aMapSeemEdges : out MapOfShape from TopTools) returns Boolean;
 546         ---Purpose: Checks existance of loop on wire and return vertices wich are loop vertices
 547 -- (vertices belonging to a few pairs of edges)
 548
 549
 550         ---Status after checking :
 551
 552         ---Level  : Public
 553
 554         -- Querying the status of perfomed API checking procedures
 555     StatusOrder            (me; Status: Status from ShapeExtend) returns Boolean;
 556         ---C++: inline
 557     StatusConnected        (me; Status: Status from ShapeExtend) returns Boolean;
 558         ---C++: inline
 559     StatusEdgeCurves       (me; Status: Status from ShapeExtend) returns Boolean;
 560         ---C++: inline
 561     StatusDegenerated      (me; Status: Status from ShapeExtend) returns Boolean;
 562         ---C++: inline
 563     StatusClosed           (me; Status: Status from ShapeExtend) returns Boolean;
 564         ---C++: inline
 565     StatusSmall            (me; Status: Status from ShapeExtend) returns Boolean;
 566         ---C++: inline
 567     StatusSelfIntersection (me; Status: Status from ShapeExtend) returns Boolean;
 568         ---C++: inline
 569     StatusLacking          (me; Status: Status from ShapeExtend) returns Boolean;
 570         ---C++: inline
 571     StatusGaps3d           (me; Status: Status from ShapeExtend) returns Boolean;
 572         ---C++: inline
 573     StatusGaps2d           (me; Status: Status from ShapeExtend) returns Boolean;
 574         ---C++: inline
 575     StatusCurveGaps        (me; Status: Status from ShapeExtend) returns Boolean;
 576         ---C++: inline
 577
 578     StatusLoop             (me; Status: Status from ShapeExtend) returns Boolean;
 579         ---C++: inline
 580         ---Level  : Advanced
 581
 582     LastCheckStatus        (me; Status: Status from ShapeExtend) returns Boolean;
 583         ---C++: inline
 584         ---Purpose:  Querying the status of the LAST perfomed 'Advanced' checking procedure
 585
 586         ---Querying fields
 587
 588     MinDistance3d (me) returns Real;
 589         ---C++: inline
 590         ---Purpose: Returns the last lowest distance in 3D computed by
 591         --           CheckOrientation, CheckConnected, CheckContinuity3d,
 592         --               CheckVertex, CheckNewVertex
 593
 594     MinDistance2d (me) returns Real;
 595         ---C++: inline
 596         ---Purpose: Returns the last lowest distance in 2D-UV computed by
 597         --           CheckContinuity2d
 598
 599     MaxDistance3d (me) returns Real;
 600         ---C++: inline
 601         ---Purpose: Returns the last maximal distance in 3D computed by
 602         --           CheckOrientation, CheckConnected, CheckContinuity3d,
 603         --               CheckVertex, CheckNewVertex, CheckSameParameter
 604
 605     MaxDistance2d (me) returns Real;
 606         ---C++: inline
 607         ---Purpose: Returns the last maximal distance in 2D-UV computed by
 608         --           CheckContinuity2d
 609
 610 fields
 611
 612     myWire: WireData from ShapeExtend is protected;
 613     myFace: Face from TopoDS is protected;
 614     mySurf: Surface from ShapeAnalysis is protected;
 615     myPrecision : Real is protected;
 616
 617     myMin3d: Real is protected; -- lower computed distance 3d
 618     myMin2d: Real is protected; -- lower computed distance 2d
 619     myMax3d: Real is protected; -- upper computed distance 3d
 620     myMax2d: Real is protected; -- upper computed distance 2d
 621
 622         -- statuses corresponding to API methods, queried by Status..(status) methods
 623     myStatusOrder:            Integer is protected;
 624     myStatusConnected:        Integer is protected;
 625     myStatusEdgeCurves:       Integer is protected;
 626     myStatusDegenerated:      Integer is protected;
 627     myStatusClosed:           Integer is protected;
 628     myStatusSmall:            Integer is protected;
 629     myStatusSelfIntersection: Integer is protected;
 630     myStatusLacking:          Integer is protected;
 631     myStatusGaps3d:           Integer is protected; -- szvsh
 632     myStatusGaps2d:           Integer is protected; -- szvsh
 633     myStatusCurveGaps:        Integer is protected; -- szvsh
 634     myStatusLoop  :           Integer is protected;
 635
 636     myStatus: Integer is protected; -- for internal use, queried by LastCheckStatus(status) method
 637
 638 end Wire;