[occt.git] / src / HLRBRep / HLRBRep_Data.cdl

-- Created on: 1993-01-11
-- Created by: Christophe MARION
-- Copyright (c) 1993-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.

class Data from HLRBRep inherits TShared from MMgt

uses
    Address           from Standard,
    Integer           from Standard,
    Boolean           from Standard,
    ShortReal         from Standard,
    Real              from Standard,
    Array1OfInteger   from TColStd,
    Pnt               from gp,
    Pnt2d             from gp,
    Dir2d             from gp,
    CurveType         from GeomAbs,
    SurfaceType       from GeomAbs,
    State             from TopAbs,
    Orientation       from TopAbs,
    IndexedMapOfShape from TopTools,
    IntersectionPoint from IntRes2d,
    Interference      from HLRAlgo,
    InterferenceList  from HLRAlgo,
    Projector         from HLRAlgo,
    EdgeData          from HLRBRep,
    FaceData          from HLRBRep,
    Array1OfEData     from HLRBRep,
    Array1OfFData     from HLRBRep,
    FaceIterator      from HLRBRep,
    EdgeFaceTool      from HLRBRep,
    Intersector       from HLRBRep,
    Curve             from HLRBRep,
    CLProps           from HLRBRep,
    Surface           from HLRBRep,
    SLProps           from HLRBRep,
    TopolTool         from BRepTopAdaptor,
    MapOfShapeTool    from BRepTopAdaptor
    
    
raises
    UndefinedDerivative from StdFail

is
    --
    --       Method to load or edit the Data Structure
    --       

    Create(NV, NE, NF : Integer from Standard)
	---Purpose: Create an  empty data structure  of <NV> vertices,
	--          <NE> edges and <NF> faces.
    returns Data from HLRBRep;
    
    Write(me : mutable; DS       : Data    from HLRBRep;
                        dv,de,df : Integer from Standard)
	---Purpose: Write <DS>    in   me  with   a     translation of
	--          <dv>,<de>,<df>.
    is static;
    
    EDataArray(me : mutable) returns Array1OfEData from HLRBRep
    	---C++: inline
    	---C++: return &
    is static;

    FDataArray(me : mutable) returns Array1OfFData from HLRBRep
    	---C++: inline
    	---C++: return &
    is static;

    Tolerance(me : mutable; tol : ShortReal from Standard)
    	---C++: inline
    	---Purpose: Set the  tolerance for the  rejections  during the
    	--          exploration
    is static;
    
    Tolerance(me) returns ShortReal from Standard
    	---C++: inline
    	---Purpose: returns  the tolerance for the  rejections  during
    	--          the exploration
    is static;
    
    Update(me : mutable; P : Projector from HLRAlgo)
    	---Purpose: end of building  of the Data and updating
    	--          all the informations linked to the projection.
    is static;
    
    Projector(me : mutable) returns Projector from HLRAlgo
    	---C++: inline
	---C++: return &
    is static;

    --
    --      Methods to query the Data
    --      
    
    NbVertices(me) returns Integer from Standard
    	---C++: inline
    is static;

    NbEdges(me) returns Integer from Standard
    	---C++: inline
    is static;

    NbFaces(me) returns Integer from Standard
    	---C++: inline
    is static;

    EdgeMap(me : mutable) returns IndexedMapOfShape from TopTools
    	---C++: inline
    	---C++: return &
    is static;

    FaceMap(me : mutable) returns IndexedMapOfShape from TopTools
    	---C++: inline
    	---C++: return &
    is static;

    --
    --      Exploration of non rejected visible edges
    --      

    InitBoundSort(me        : mutable;
                  MinMaxTot : Address from Standard;
                  e1,e2     : Integer from Standard)
	---Purpose: to compare with only non rejected edges.
    is static;
    
    InitEdge(me : mutable; FI :        Integer        from Standard;
                           MST: in out MapOfShapeTool from BRepTopAdaptor)
	---Purpose: Begin an iteration only  on visible Edges
	--          crossing the face number <FI>.
    is static;
    
    MoreEdge(me : mutable) returns Boolean from Standard
    is static;
    
    NextEdge(me : mutable; skip : Boolean from Standard = Standard_True)
    is static;
    
    Edge(me) returns Integer from Standard
	---Purpose: Returns the  current Edge
    is static;

    HidingTheFace(me) returns Boolean from Standard
    	---C++: inline
        ---Purpose: Returns true if   the  current edge to   be hidden
        --          belongs to the hiding face.
    is static;
    
    SimpleHidingFace(me) returns Boolean from Standard
    	---C++: inline
    	---Purpose: Returns true if the current hiding face is not  an
    	--          auto-intersected one.
    is static;
    
    --
    --     Intersection of current edge with face
    --     
    
    InitInterference(me : mutable)
	---Purpose: Intersect  the current  Edge  with the boundary of
	--          the hiding  face.   The interferences are given by
	--          the More, Next, and Value methods.
    is static;
    
    MoreInterference(me) returns Boolean from Standard
    	---C++: inline
    is static;
    
    NextInterference(me : mutable)
    is static;

    RejectedInterference(me : mutable) returns Boolean from Standard
    	---Purpose: Returns  True if the  interference is rejected.
    is static;
    
    AboveInterference(me : mutable) returns Boolean from Standard
    	---Purpose: Returns True if the rejected interference is above
    	--          the face.
    is static;
    
    Interference(me : mutable) returns Interference from HLRAlgo
    	---C++: inline
    	---C++: return &
    is static;
    
    LocalLEGeometry2D(me : mutable; Param :     Real    from Standard;
    	                            Tg    : out Dir2d   from gp;
    	                            Nm    : out Dir2d   from gp;
                                    Cu    : out Real    from Standard)
	---Purpose: Returns the local description of the projection of
	--          the current LEdge  at parameter  <Param>.
    raises
    	UndefinedDerivative from StdFail
    is static;

    LocalFEGeometry2D(me : mutable; FE    :     Integer from Standard;
                                    Param :     Real    from Standard;
    	                            Tg    : out Dir2d   from gp;
    	                            Nm    : out Dir2d   from gp;
                                    Cu    : out Real    from Standard)
	---Purpose: Returns the local description of the projection of
	--          the current FEdge  at parameter  <Param>.
    raises
    	UndefinedDerivative from StdFail
    is static;

    EdgeState(me : mutable; p1,p2       :     Real  from Standard;
                            stbef, staf : out State from TopAbs)
	---Purpose: Returns the local  3D   state of the  intersection
	--          between the current edge and the current face at the
	--          <p1> and <p2> parameters.
    is static;
    
    EdgeOfTheHidingFace(me; E  : Integer  from Standard;
                            ED : EdgeData from HLRBRep)
    returns Boolean from Standard
	---Purpose: Returns the  true if the  Edge <ED> belongs to the
	--          Hiding Face.
 	---C++: inline
   is static;

    HidingStartLevel(me : mutable; E  : Integer          from Standard;
                                   ED : EdgeData         from HLRBRep;
                                   IL : InterferenceList from HLRAlgo)
    returns Integer from Standard
	---Purpose: Returns the number of  levels of hiding face above
	--          the   first  point  of   the    edge <ED>.     The
	--          InterferenceList is  given to  compute far away of
	--          the Interferences and then come back.
    is static;

    Compare(me : mutable; E  : Integer  from Standard;
                          ED : EdgeData from HLRBRep)
    returns State from TopAbs
	---Purpose: Returns   the  state   of  the   Edge  <ED>  after
	--          classification.
    is static;

    SimplClassify(me : mutable; E         :     Integer  from Standard;
                            	ED        :     EdgeData from HLRBRep;
                            	Nbp       :     Integer  from Standard;
                            	p1,  p2   :     Real     from Standard)
    returns State from TopAbs; 
	---Purpose: Simple classification of part of edge  [p1,  p2] 
	--  returns  OUT  if  at  least  1 of  Nbp  points  of  edge  is  out 
	--  othewise  returns  IN 
	--  It  is  used  to  check  "suspision"  hided  part  of  edge.
    
    -- The following methods are private

    OrientOutLine(me : mutable; I  :     Integer  from Standard;
                                FD : out FaceData from HLRBRep)
    returns Boolean from Standard
	---Purpose: Orient the   OutLines  ( left  must  be  inside in
	--          projection ). Returns True if the face of a closed
	--          shell has been inverted;
    is static private;

    OrientOthEdge(me : mutable; I  :     Integer  from Standard;
                                FD : out FaceData from HLRBRep)
	---Purpose: Orient the Edges which  are not  Internal OutLine,
	--          not Double and not IsoLine.
    is static private;

    Classify(me : mutable; E         :     Integer  from Standard;
                           ED        :     EdgeData from HLRBRep;
                           LevelFlag :     Boolean  from Standard;
                           Level     : out Integer  from Standard;
                           param     :     Real     from Standard)
    returns State from TopAbs;
	---Purpose: Classification of an edge.

    RejectedPoint(me : mutable; PInter      : IntersectionPoint from IntRes2d;
    	    	                BoundOri    : Orientation       from TopAbs;
                                NumSeg      : Integer           from Standard) --- -1 if Point else NumSegment 
    returns Boolean from Standard
    	---Purpose: Returns  True  if the  intersection is  rejected.
    is static private;

    SameVertex(me : mutable; head1,head2 : Boolean from Standard)
    returns Boolean from Standard
	---Purpose: returns True  if there is a common  vertex between
	--          myLE and myFE  dependig  on  <head1> and  <head2>.
    is static private;
    
    Destroy(me: mutable);
    	---C++: alias ~
    
    
fields

    -- basic data : Vertices, Edges, Faces
    myNbVertices  : Integer           from Standard;
    myNbEdges     : Integer           from Standard;
    myNbFaces     : Integer           from Standard;
    myEMap        : IndexedMapOfShape from TopTools;
    myFMap        : IndexedMapOfShape from TopTools;
    myEData       : Array1OfEData     from HLRBRep;
    myFData       : Array1OfFData     from HLRBRep;
    myEdgeIndices : Array1OfInteger   from TColStd;
    myToler       : ShortReal         from Standard;
    myProj        : Projector         from HLRAlgo;
    myLLProps     : CLProps           from HLRBRep;
    myFLProps     : CLProps           from HLRBRep;
    mySLProps     : SLProps           from HLRBRep;
    myBigSize     : Real              from Standard;

    -- Face exploration
    myFaceItr1    : FaceIterator      from HLRBRep;
    myFaceItr2    : FaceIterator      from HLRBRep;
    
    -- Current hiding face
    iFace         : Integer           from Standard;
    iFaceData     : Address           from Standard;
    iFaceGeom     : Address           from Standard;
    iFaceMinMax   : Address           from Standard;
    iFaceType     : SurfaceType       from GeomAbs;
    iFaceBack     : Boolean           from Standard;
    iFaceSimp     : Boolean           from Standard;
    iFaceSmpl     : Boolean           from Standard;
    iFaceTest     : Boolean           from Standard;
    
    -- Exploration of edges to be hidden
    myHideCount   : Integer           from Standard;
    myDeca        : Real              from Standard[16];
    mySurD        : Real              from Standard[16];
    myCurSortEd   : Integer           from Standard;
    myNbrSortEd   : Integer           from Standard;
     
    -- Current hidden edge, to be intersected
    myLE          : Integer           from Standard;
    myLEOutLine   : Boolean           from Standard;
    myLEInternal  : Boolean           from Standard;
    myLEDouble    : Boolean           from Standard;
    myLEIsoLine   : Boolean           from Standard;
    myLEData      : Address           from Standard;
    myLEGeom      : Address           from Standard;
    myLEMinMax    : Address           from Standard;
    myLEType      : CurveType         from GeomAbs;
    myLETol       : ShortReal         from Standard;

    -- Exploration of hiding face for intersection
    myFE          : Integer           from Standard;
    myFEOri       : Orientation       from TopAbs;
    myFEOutLine   : Boolean           from Standard;
    myFEInternal  : Boolean           from Standard;
    myFEDouble    : Boolean           from Standard;
    myFEData      : Address           from Standard;
    myFEGeom      : Address           from Standard;
    myFEType      : CurveType         from GeomAbs;
    myFETol       : ShortReal         from Standard;
    
    -- Intersections
    myIntersector : Intersector       from HLRBRep;
    myClassifier  : TopolTool         from BRepTopAdaptor;
    mySameVertex  : Boolean           from Standard;
    myIntersected : Boolean           from Standard;
    myNbPoints    : Integer           from Standard;
    myNbSegments  : Integer           from Standard;
    iInterf       : Integer           from Standard;
    myIntf        : Interference      from HLRAlgo;
    myAboveIntf   : Boolean           from Standard;

    myReject      : Address           from Standard; 
     
    
end Data;
Commit	Line	Data
b311480e	1	-- Created on: 1993-01-11
	2	-- Created by: Christophe MARION
	3	-- Copyright (c) 1993-1999 Matra Datavision
973c2be1	4	-- Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	--
973c2be1	6	-- This file is part of Open CASCADE Technology software library.
b311480e	7	--
d5f74e42	8	-- This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	-- the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	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.
b311480e	13	--
973c2be1	14	-- Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	-- commercial license or contractual agreement.
7fd59977	16
	17	class Data from HLRBRep inherits TShared from MMgt
	18
	19	uses
	20	Address from Standard,
	21	Integer from Standard,
	22	Boolean from Standard,
	23	ShortReal from Standard,
	24	Real from Standard,
	25	Array1OfInteger from TColStd,
	26	Pnt from gp,
	27	Pnt2d from gp,
	28	Dir2d from gp,
	29	CurveType from GeomAbs,
	30	SurfaceType from GeomAbs,
	31	State from TopAbs,
	32	Orientation from TopAbs,
	33	IndexedMapOfShape from TopTools,
	34	IntersectionPoint from IntRes2d,
	35	Interference from HLRAlgo,
	36	InterferenceList from HLRAlgo,
	37	Projector from HLRAlgo,
	38	EdgeData from HLRBRep,
	39	FaceData from HLRBRep,
	40	Array1OfEData from HLRBRep,
	41	Array1OfFData from HLRBRep,
	42	FaceIterator from HLRBRep,
	43	EdgeFaceTool from HLRBRep,
	44	Intersector from HLRBRep,
	45	Curve from HLRBRep,
	46	CLProps from HLRBRep,
	47	Surface from HLRBRep,
	48	SLProps from HLRBRep,
	49	TopolTool from BRepTopAdaptor,
	50	MapOfShapeTool from BRepTopAdaptor
	51
	52
	53	raises
	54	UndefinedDerivative from StdFail
	55
	56	is
	57	--
	58	-- Method to load or edit the Data Structure
	59	--
	60
	61	Create(NV, NE, NF : Integer from Standard)
	62	---Purpose: Create an empty data structure of <NV> vertices,
	63	-- <NE> edges and <NF> faces.
6e33d3ce	64	returns Data from HLRBRep;
7fd59977	65
	66	Write(me : mutable; DS : Data from HLRBRep;
	67	dv,de,df : Integer from Standard)
	68	---Purpose: Write <DS> in me with a translation of
	69	-- <dv>,<de>,<df>.
	70	is static;
	71
	72	EDataArray(me : mutable) returns Array1OfEData from HLRBRep
	73	---C++: inline
	74	---C++: return &
	75	is static;
	76
	77	FDataArray(me : mutable) returns Array1OfFData from HLRBRep
	78	---C++: inline
	79	---C++: return &
	80	is static;
	81
	82	Tolerance(me : mutable; tol : ShortReal from Standard)
	83	---C++: inline
	84	---Purpose: Set the tolerance for the rejections during the
	85	-- exploration
	86	is static;
	87
	88	Tolerance(me) returns ShortReal from Standard
	89	---C++: inline
	90	---Purpose: returns the tolerance for the rejections during
	91	-- the exploration
	92	is static;
	93
	94	Update(me : mutable; P : Projector from HLRAlgo)
	95	---Purpose: end of building of the Data and updating
	96	-- all the informations linked to the projection.
	97	is static;
	98
	99	Projector(me : mutable) returns Projector from HLRAlgo
	100	---C++: inline
	101	---C++: return &
	102	is static;
	103
	104	--
	105	-- Methods to query the Data
	106	--
	107
	108	NbVertices(me) returns Integer from Standard
	109	---C++: inline
	110	is static;
	111
	112	NbEdges(me) returns Integer from Standard
	113	---C++: inline
	114	is static;
	115
	116	NbFaces(me) returns Integer from Standard
	117	---C++: inline
	118	is static;
	119
	120	EdgeMap(me : mutable) returns IndexedMapOfShape from TopTools
	121	---C++: inline
	122	---C++: return &
	123	is static;
	124
	125	FaceMap(me : mutable) returns IndexedMapOfShape from TopTools
	126	---C++: inline
	127	---C++: return &
	128	is static;
129
130	--
131	-- Exploration of non rejected visible edges
132	--
133
134	InitBoundSort(me : mutable;
135	MinMaxTot : Address from Standard;
136	e1,e2 : Integer from Standard)
137	---Purpose: to compare with only non rejected edges.
138	is static;
139
140	InitEdge(me : mutable; FI : Integer from Standard;
141	MST: in out MapOfShapeTool from BRepTopAdaptor)
142	---Purpose: Begin an iteration only on visible Edges
143	-- crossing the face number <FI>.
144	is static;
145
146	MoreEdge(me : mutable) returns Boolean from Standard
147	is static;
148
149	NextEdge(me : mutable; skip : Boolean from Standard = Standard_True)
150	is static;
151
152	Edge(me) returns Integer from Standard
153	---Purpose: Returns the current Edge
154	is static;
155
156	HidingTheFace(me) returns Boolean from Standard
157	---C++: inline
158	---Purpose: Returns true if the current edge to be hidden
159	-- belongs to the hiding face.
160	is static;
161
162	SimpleHidingFace(me) returns Boolean from Standard
163	---C++: inline
164	---Purpose: Returns true if the current hiding face is not an
165	-- auto-intersected one.
166	is static;
167
168	--
169	-- Intersection of current edge with face
170	--
171
172	InitInterference(me : mutable)
173	---Purpose: Intersect the current Edge with the boundary of
174	-- the hiding face. The interferences are given by
175	-- the More, Next, and Value methods.
176	is static;
177
178	MoreInterference(me) returns Boolean from Standard
179	---C++: inline
180	is static;
181
182	NextInterference(me : mutable)
183	is static;
184
185	RejectedInterference(me : mutable) returns Boolean from Standard
186	---Purpose: Returns True if the interference is rejected.
187	is static;
188
189	AboveInterference(me : mutable) returns Boolean from Standard
190	---Purpose: Returns True if the rejected interference is above
191	-- the face.
192	is static;
193
194	Interference(me : mutable) returns Interference from HLRAlgo
195	---C++: inline
196	---C++: return &
197	is static;
198
199	LocalLEGeometry2D(me : mutable; Param : Real from Standard;
200	Tg : out Dir2d from gp;
201	Nm : out Dir2d from gp;
202	Cu : out Real from Standard)
203	---Purpose: Returns the local description of the projection of
204	-- the current LEdge at parameter <Param>.
205	raises
206	UndefinedDerivative from StdFail
207	is static;
208
209	LocalFEGeometry2D(me : mutable; FE : Integer from Standard;
210	Param : Real from Standard;
211	Tg : out Dir2d from gp;
212	Nm : out Dir2d from gp;
213	Cu : out Real from Standard)
214	---Purpose: Returns the local description of the projection of
215	-- the current FEdge at parameter <Param>.
216	raises
217	UndefinedDerivative from StdFail
218	is static;
219
220	EdgeState(me : mutable; p1,p2 : Real from Standard;
221	stbef, staf : out State from TopAbs)
222	---Purpose: Returns the local 3D state of the intersection
223	-- between the current edge and the current face at the
224	-- <p1> and <p2> parameters.
225	is static;
226
227	EdgeOfTheHidingFace(me; E : Integer from Standard;
228	ED : EdgeData from HLRBRep)
229	returns Boolean from Standard
230	---Purpose: Returns the true if the Edge <ED> belongs to the
231	-- Hiding Face.
232	---C++: inline
233	is static;
234
235	HidingStartLevel(me : mutable; E : Integer from Standard;
236	ED : EdgeData from HLRBRep;
237	IL : InterferenceList from HLRAlgo)
238	returns Integer from Standard
239	---Purpose: Returns the number of levels of hiding face above
240	-- the first point of the edge <ED>. The
241	-- InterferenceList is given to compute far away of
242	-- the Interferences and then come back.
243	is static;
244
245	Compare(me : mutable; E : Integer from Standard;
246	ED : EdgeData from HLRBRep)
247	returns State from TopAbs
248	---Purpose: Returns the state of the Edge <ED> after
249	-- classification.
250	is static;
251
252	SimplClassify(me : mutable; E : Integer from Standard;
253	ED : EdgeData from HLRBRep;
254	Nbp : Integer from Standard;
255	p1, p2 : Real from Standard)
256	returns State from TopAbs;
257	---Purpose: Simple classification of part of edge [p1, p2]
258	-- returns OUT if at least 1 of Nbp points of edge is out
259	-- othewise returns IN
260	-- It is used to check "suspision" hided part of edge.
261
262	-- The following methods are private
263
264	OrientOutLine(me : mutable; I : Integer from Standard;
265	FD : out FaceData from HLRBRep)
266	returns Boolean from Standard
267	---Purpose: Orient the OutLines ( left must be inside in
268	-- projection ). Returns True if the face of a closed
269	-- shell has been inverted;
270	is static private;
271
272	OrientOthEdge(me : mutable; I : Integer from Standard;
273	FD : out FaceData from HLRBRep)
274	---Purpose: Orient the Edges which are not Internal OutLine,
275	-- not Double and not IsoLine.
276	is static private;
277
278	Classify(me : mutable; E : Integer from Standard;
279	ED : EdgeData from HLRBRep;
280	LevelFlag : Boolean from Standard;
281	Level : out Integer from Standard;
282	param : Real from Standard)
bda83605	283	returns State from TopAbs;
7fd59977	284	---Purpose: Classification of an edge.
7fd59977	285
	286	RejectedPoint(me : mutable; PInter : IntersectionPoint from IntRes2d;
	287	BoundOri : Orientation from TopAbs;
	288	NumSeg : Integer from Standard) --- -1 if Point else NumSegment
	289	returns Boolean from Standard
	290	---Purpose: Returns True if the intersection is rejected.
	291	is static private;
	292
	293	SameVertex(me : mutable; head1,head2 : Boolean from Standard)
	294	returns Boolean from Standard
	295	---Purpose: returns True if there is a common vertex between
	296	-- myLE and myFE dependig on <head1> and <head2>.
	297	is static private;
	298
	299	Destroy(me: mutable);
	300	---C++: alias ~
	301
	302
	303	fields
	304
	305	-- basic data : Vertices, Edges, Faces
	306	myNbVertices : Integer from Standard;
	307	myNbEdges : Integer from Standard;
	308	myNbFaces : Integer from Standard;
	309	myEMap : IndexedMapOfShape from TopTools;
	310	myFMap : IndexedMapOfShape from TopTools;
	311	myEData : Array1OfEData from HLRBRep;
	312	myFData : Array1OfFData from HLRBRep;
	313	myEdgeIndices : Array1OfInteger from TColStd;
	314	myToler : ShortReal from Standard;
	315	myProj : Projector from HLRAlgo;
	316	myLLProps : CLProps from HLRBRep;
	317	myFLProps : CLProps from HLRBRep;
	318	mySLProps : SLProps from HLRBRep;
	319	myBigSize : Real from Standard;
	320
	321	-- Face exploration
	322	myFaceItr1 : FaceIterator from HLRBRep;
	323	myFaceItr2 : FaceIterator from HLRBRep;
	324
	325	-- Current hiding face
	326	iFace : Integer from Standard;
	327	iFaceData : Address from Standard;
	328	iFaceGeom : Address from Standard;
	329	iFaceMinMax : Address from Standard;
	330	iFaceType : SurfaceType from GeomAbs;
	331	iFaceBack : Boolean from Standard;
	332	iFaceSimp : Boolean from Standard;
	333	iFaceSmpl : Boolean from Standard;
	334	iFaceTest : Boolean from Standard;
	335
	336	-- Exploration of edges to be hidden
	337	myHideCount : Integer from Standard;
	338	myDeca : Real from Standard[16];
	339	mySurD : Real from Standard[16];
	340	myCurSortEd : Integer from Standard;
	341	myNbrSortEd : Integer from Standard;
	342
	343	-- Current hidden edge, to be intersected
	344	myLE : Integer from Standard;
	345	myLEOutLine : Boolean from Standard;
	346	myLEInternal : Boolean from Standard;
	347	myLEDouble : Boolean from Standard;
	348	myLEIsoLine : Boolean from Standard;
349	myLEData : Address from Standard;
350	myLEGeom : Address from Standard;
351	myLEMinMax : Address from Standard;
352	myLEType : CurveType from GeomAbs;
353	myLETol : ShortReal from Standard;
354
355	-- Exploration of hiding face for intersection
356	myFE : Integer from Standard;
357	myFEOri : Orientation from TopAbs;
358	myFEOutLine : Boolean from Standard;
359	myFEInternal : Boolean from Standard;
360	myFEDouble : Boolean from Standard;
361	myFEData : Address from Standard;
362	myFEGeom : Address from Standard;
363	myFEType : CurveType from GeomAbs;
364	myFETol : ShortReal from Standard;
365
366	-- Intersections
367	myIntersector : Intersector from HLRBRep;
368	myClassifier : TopolTool from BRepTopAdaptor;
369	mySameVertex : Boolean from Standard;
370	myIntersected : Boolean from Standard;
371	myNbPoints : Integer from Standard;
372	myNbSegments : Integer from Standard;
373	iInterf : Integer from Standard;
374	myIntf : Interference from HLRAlgo;
375	myAboveIntf : Boolean from Standard;
376
377	myReject : Address from Standard;
378
379
380	end Data;