0024530: TKMesh - remove unused package IntPoly
[occt.git] / src / NIS / NIS_Triangulated.hxx
1 // Created on: 2007-07-17
2 // Created by: Alexander GRIGORIEV
3 // Copyright (c) 2007-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and / or modify it
8 // under the terms of the GNU Lesser General Public version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef NIS_Triangulated_HeaderFile
17 #define NIS_Triangulated_HeaderFile
18
19 #include <NIS_InteractiveObject.hxx>
20 #include <Quantity_Color.hxx>
21
22 class Handle_NIS_TriangulatedDrawer;
23 class NCollection_BaseAllocator;
24 class Handle_NCollection_BaseAllocator;
25 class NIS_TriangulatedDrawer;
26
27 /**
28  * Interactive object that consists of triangles, lines and polygons without
29  * normals. Particularly can be used to render planar 2D shapes.
30  *
31  * @par 2D and 3D model
32  * Vertices are stored in an array of float numbers, 2 or 3 numbers per vertex.
33  * The number of dimensions is defined in the constructor, see the parameter
34  * 'is2D'. When 2D is defined then for all vertices the Z coordinate is 0.
35  * To display planar objects in a plane different from XOY you should subclass
36  * this type together with the correponding Drawer and store the transformation
37  * parameters. In Drawer subclass either in method BeforeDraw() or in method
38  * Draw() you would call glTranslate() or glMultMatrix() so that all vertices
39  * should be located in their proper positions.
40  *
41  * @par Compressed storage
42  * For efficient memory utilization, indice (triangles, segments, polygons) are
43  * 8-bit, 16-bit or 32-bit numbers. The width of this numeric representation is
44  * chosen automatically when the total number of nodes is passed in the
45  * constructor or in any Set* method. For example, if this number of nodes is
46  * smaller than 256 then 8-bit representation is selected. The choice is stored
47  * in 'myIndexType' data member.
48  */
49
50 class NIS_Triangulated : public NIS_InteractiveObject
51 {
52  protected:
53   /**
54    * Constants defining the mode (type) of presentation. They allow mixed type,
55    * e.g., Triangulation+Line. Line and Segments are not mixable, their mix is
56    * treated as Line only.
57    */
58   enum {
59     Type_None          =  0,
60     Type_Loop          =  1,  //!< modifier to Line
61     Type_Line          =  2,
62     Type_Segments      =  4,
63     Type_Triangulation =  8,
64     Type_Polygons      = 16
65   };
66
67  public:
68   /**
69    * Enumerated type of polygon rendering.
70    */
71   enum PolygonType {
72     Polygon_Default  = 0,  //!< Polygon as LINE, Triangulation as FILL
73     Polygon_Line     = 1,  //!< Both Polygon and Triangulation as LINE
74     Polygon_Fill     = 2   //!< Both Polygon and Triangulation as FILL
75   };
76
77  public:
78   // ---------- PUBLIC METHODS ----------
79
80
81   /**
82    * Constructor. Optionally defines the number of nodes that will be allocated
83    * (this number may be defined later in methods Set*Prs) as well as the
84    * memory allocator where the nodes, lines and triangles will be stored by
85    * this instance.
86    * @param nNodes
87    *   Total number of nodes that will be initialized for this object
88    * @param is2D
89    *   If true then the nodes will be 2D in plane Z=0, otherwise normal 3D.
90    * @param theAlloc
91    *   Allocator for internal data
92    */
93   Standard_EXPORT NIS_Triangulated(const Standard_Integer nNodes = 0,
94                                    const Standard_Boolean is2D = Standard_False,
95                                    const Handle_NCollection_BaseAllocator&
96                                    theAlloc = 0L);
97
98   /**
99    * Define the polygonal presentration.
100    * @param nPolygons
101    *   Number of separate polygons. If set to 0, polygons are cancelled
102    * @param nNodes
103    *   Optional: Number of nodes to allocate. If left as 0, the previous nodes
104    *   allocation is used, otherwise a new allocation is created.
105    */ 
106   Standard_EXPORT void              SetPolygonsPrs
107                                         (const Standard_Integer nPolygons,
108                                          const Standard_Integer nNodes = 0);
109
110   /**
111    * Define the triangulated presentration.
112    * @param nTriangles
113    *   Number of triangles. If set to 0, triangulation is cancelled
114    * @param nNodes
115    *   Optional: Number of nodes to allocate. If left as 0, the previous nodes
116    *   allocation is used, otherwise a new allocation is created.
117    */ 
118   Standard_EXPORT void              SetTriangulationPrs
119                                         (const Standard_Integer nTriangles,
120                                          const Standard_Integer nNodes = 0);
121
122   /**
123    * Define the line presentration (polygon through points)
124    * @param nPoints
125    *   Number of nodes defining the line. If set to 0, line is cancelled
126    * @param isClosed
127    *   True if the polygon is closed, so the segment between the first and
128    *   the last points is created automatically.
129    * @param nNodes
130    *   Optional: Number of nodes to allocate. If left as 0, the previous nodes
131    *   allocation is used, otherwise a new allocation is created.
132    */ 
133   Standard_EXPORT void              SetLinePrs
134                                         (const Standard_Integer nPoints,
135                                          const Standard_Boolean isClosed,
136                                          const Standard_Integer nNodes = 0);
137
138   /**
139    * Define the segments presentration. Each segment is defined by 2 nodes
140    * @param nSegments
141    *   Number of segments. If set to 0, segments presentation is cancelled
142    * @param nNodes
143    *   Optional: Number of nodes to allocate. If left as 0, the previous nodes
144    *   allocation is used, otherwise a new allocation is created.
145    */ 
146   Standard_EXPORT void              SetSegmentPrs
147                                         (const Standard_Integer nSegments,
148                                          const Standard_Integer nNodes = 0);
149
150   /**
151    * Query if there is Triangulation component in the presentation.
152    */
153   inline Standard_Boolean           IsTriangulation () const
154   { return (myType & Type_Triangulation) != 0; }
155
156   /**
157    * Query if there is Polygons component in the presentation.
158    */
159   inline Standard_Boolean           IsPolygons  () const
160   { return (myType & Type_Polygons) != 0; }
161
162   /**
163    * Query if there is Line component in the presentation.
164    */
165   inline Standard_Boolean           IsLine      (Standard_Boolean& isLoop) const
166   { isLoop = (myType & Type_Loop) != 0; return (myType & Type_Line) != 0; }
167
168   /**
169    * Query if there is Segments component in the presentation.
170    */
171   inline Standard_Boolean           IsSegments  () const
172   { return (myType & Type_Segments) != 0; }
173
174   /**
175    * Reset all data memebers and free all allocated memory.
176    * Called from the destructor, also can be usedto re-initialize a given
177    * Interactive Objects. 
178    */
179   Standard_EXPORT void              Clear       ();
180
181   /**
182    * Destructor.
183    */
184   Standard_EXPORT virtual ~NIS_Triangulated     ();
185
186   /**
187    * Create a default drawer instance.
188    */
189   Standard_EXPORT virtual NIS_Drawer *
190                                     DefaultDrawer (NIS_Drawer *) const;
191
192   /**
193    * Define the coordinates of node [ind].
194    */
195   Standard_EXPORT void              SetNode   (const Standard_Integer  ind,
196                                                const gp_XYZ&           thePnt);
197
198   /**
199    * Define the coordinates of node [ind]. Z coordinate is assigned to 0.
200    */
201   Standard_EXPORT void              SetNode   (const Standard_Integer  ind,
202                                                const gp_XY&            thePnt);
203
204   /**
205    * Define the triangle [ind] by indices of its three nodes.
206    */
207   Standard_EXPORT void              SetTriangle(const Standard_Integer  ind,
208                                                 const Standard_Integer  iNode0,
209                                                 const Standard_Integer  iNode1,
210                                                 const Standard_Integer  iNode2);
211
212   /**
213    * Allocate a single polygon, should be called for each polygon following
214    * the call SetPolygonsPrs(). The polygon can be filled by node indices using
215    * the method SetPolygonNode().
216    * @param ind
217    *   Index of the polygon, should be [0..Npolygons-1]
218    * @param theSz
219    *   Number of points (segments) in the polygon.
220    */
221   Standard_EXPORT void              SetPolygon (const Standard_Integer  ind,
222                                                 const Standard_Integer  theSz);
223
224   /**
225    * Define the line node by index.
226    */
227   Standard_EXPORT void              SetLineNode(const Standard_Integer ind,
228                                                 const Standard_Integer iNode);
229
230   /**
231    * Query the number of nodes.
232    */
233   inline Standard_Integer           NNodes    () const
234   { return myNNodes; }
235
236   /**
237    * Query the number of triangles.
238    */
239   inline Standard_Integer           NTriangles() const
240   { return myNTriangles; }
241
242   /**
243    * Query the number of line points.
244    */
245   inline Standard_Integer           NLineNodes() const
246   { return myNLineNodes; }
247
248   /**
249    * Query the number of polygons.
250    */
251   inline Standard_Integer           NPolygons () const
252   { return static_cast<Standard_Integer>(myNPolygons); }
253
254   /**
255    * Query the node by its index.
256    * @return
257    *   pointer to array of 2 or 3 Standard_ShortReal values {X,Y(,Z) coord}
258    */
259   inline const Standard_ShortReal * Node      (const Standard_Integer ind) const
260   { return &mypNodes[ind * myNodeCoord]; }
261
262   /**
263    * Define the node of a polygon by index.
264    * @param indPoly
265    *   Index of the Polygon, should be less than the number of polygons that is
266    *   defined in SetPolygonsPrs() and can be returned by NPOlygons().
267    * @param ind
268    *   Index of the node in the Polygon. Should be less than the parameter theSz
269    *   in the corresponding previous SetPolygon() call.
270    * @param iNode
271    *   Index of the node in the given position of the Polygon. 
272    */
273   Standard_EXPORT void              SetPolygonNode
274                                               (const Standard_Integer indPoly,
275                                                const Standard_Integer ind,
276                                                const Standard_Integer iNode);
277
278   /**
279    * Get the node with index 'ind' from the polygon number 'indPoly'.
280    */
281   Standard_EXPORT Standard_Integer PolygonNode(const Standard_Integer indPoly,
282                                                const Standard_Integer ind)const;
283
284   /**
285    * Get the number of nodes for the polygon number 'indPoly'.
286    */
287   Standard_EXPORT Standard_Integer NPolygonNodes
288                                          (const Standard_Integer indPoly)const;
289
290   /**
291    * Set the boolean flag defining if the polygons or the triangulation
292    * should be drawn. This method does not affect the presentation of
293    * Line/Segments.
294    * @param isDrawPolygons
295    *   True defines that no triangulation is drawn, only polygons are. False
296    *   defines that only triangulation is drawn, no polygons.
297    */
298   Standard_EXPORT void              SetDrawPolygons
299                                         (const Standard_Boolean isDrawPolygons);
300   /**
301    * Set the type of polygon rendering.
302    */
303   Standard_EXPORT void              SetPolygonType
304                                         (const PolygonType      theType);
305
306   /**
307    * Set the normal color for presentation.
308    * @param theColor
309    *   New color to use for the presentation.
310    */
311   Standard_EXPORT void              SetColor  (const Quantity_Color&  theColor);
312
313   /**
314    * Get Normal, Transparent or Hilighted color of the presentation.
315    * @param theDrawType
316    *   The draw type, for which the color is retrieved.
317    */
318   Standard_EXPORT Quantity_Color GetColor  
319                           (const NIS_Drawer::DrawType theDrawType) const;
320
321   /**
322    * Set the color for hilighted presentation.
323    * @param theColor
324    *   New color to use for the presentation.
325    */
326   Standard_EXPORT void      SetHilightColor   (const Quantity_Color&  theColor);
327
328   /**
329    * Set the color for dynamic hilight presentation.
330    * @param theColor
331    *   New color to use for the presentation.
332    */
333   Standard_EXPORT void      SetDynHilightColor(const Quantity_Color&  theColor);
334
335   /**
336    * Set the width of line presentations in pixels.
337    * @param theWidth
338    *   New line width to use for the presentation.
339    */
340   Standard_EXPORT void      SetLineWidth      (const Standard_Real    theWidth);
341
342   /**
343    * Create a copy of theObject except its ID.
344    * @param theAll
345    *   Allocator where the Dest should store its private data.
346    * @param theDest
347    *   <tt>[in-out]</tt> The target object where the data are copied. If
348    *   passed NULL then the target should be created.
349    */
350   Standard_EXPORT virtual void
351                           Clone (const Handle_NCollection_BaseAllocator& theAll,
352                                  Handle_NIS_InteractiveObject& theDest) const;
353
354   /**
355    * Intersect the InteractiveObject geometry with a line/ray.
356    * @param theAxis
357    *   The line or ray in 3D space.
358    * @param theOver
359    *   Half-thickness of the selecting line.
360    * @return
361    *   If the return value is more than 0.1*RealLast() then no intersection is
362    *   detected. Otherwise returns the coordinate of thePnt on the ray. May be
363    *   negative.
364    */
365   Standard_EXPORT virtual Standard_Real
366                             Intersect       (const gp_Ax1&       theAxis,
367                                              const Standard_Real theOver) const;
368
369   /**
370    * Intersect the InteractiveObject geometry with an oriented box.
371    * @param theBox
372    *   3D box of selection
373    * @param theTrf
374    *   Position/Orientation of the box.
375    * @param isFull
376    *   True if full inclusion is required, False - if partial.
377    * @return
378    *   True if the InteractiveObject geometry intersects the box or is inside it
379    */
380   Standard_EXPORT virtual Standard_Boolean
381                              Intersect     (const Bnd_B3f&         theBox,
382                                             const gp_Trsf&         theTrf,
383                                             const Standard_Boolean isFull)const;
384
385   /**
386    * Intersect the InteractiveObject geometry with a selection polygon.
387    * @param thePolygon
388    *   the list of vertices of a free-form closed polygon without
389    *   self-intersections. The last point should not coincide with the first
390    *   point of the list. Any two neighbor points should not be confused.
391    * @param theTrf
392    *   Position/Orientation of the polygon.
393    * @param isFullIn
394    *   True if full inclusion is required, False - if partial.
395    * @return
396    *   True if the InteractiveObject geometry intersects the polygon or is
397    *   inside it
398    */
399   Standard_EXPORT virtual Standard_Boolean Intersect
400                     (const NCollection_List<gp_XY> &thePolygon,
401                      const gp_Trsf                 &theTrf,
402                      const Standard_Boolean         isFullIn) const;
403
404   Standard_EXPORT static int tri_line_intersect  (const double      start[3],
405                                                   const double      dir[3],
406                                                   const float       V0[3],
407                                                   const float       V1[3],
408                                                   const float       V2[3],
409                                                   double            * tInter);
410
411   Standard_EXPORT static int tri2d_line_intersect(const double      start[3],
412                                                   const double      dir[3],
413                                                   const float       V0[2],
414                                                   const float       V1[2],
415                                                   const float       V2[2],
416                                                   double            * tInter);
417
418   Standard_EXPORT static int seg_line_intersect  (const gp_XYZ&     aStart,
419                                                   const gp_XYZ&     aDir,
420                                                   const double      over2,
421                                                   const float       V0[3],
422                                                   const float       V1[3],
423                                                   double            * tInter);
424
425   Standard_EXPORT static int seg2d_line_intersect(const gp_XYZ&     aStart,
426                                                   const gp_XYZ&     aDir,
427                                                   const double      over2,
428                                                   const float       V0[2],
429                                                   const float       V1[2],
430                                                   double            * tInter);
431
432   Standard_EXPORT static int seg_box_intersect  (const Bnd_B3f&    theBox,
433                                                  const gp_Pnt      thePnt[2]);
434
435   Standard_EXPORT static int seg_box_included   (const Bnd_B3f&    theBox,
436                                                  const gp_Pnt      thePnt[2]);
437
438   Standard_EXPORT static int seg_polygon_intersect
439                               (const NCollection_List<gp_XY> &thePolygon,
440                                const gp_XY                    thePnt[2]);
441
442   Standard_EXPORT static int seg_polygon_included
443                               (const NCollection_List<gp_XY> &thePolygon,
444                                const gp_XY                    thePnt[2]);
445
446   Standard_EXPORT static void ComputeBox    (Bnd_B3f&                  theBox,
447                                              const Standard_Integer    nNodes,
448                                              const Standard_ShortReal* pNodes,
449                                              const Standard_Integer    nCoord);
450
451   /**
452    * Classification of thePoint with respect to thePolygon.
453    * @param thePolygon
454    *   the list of vertices of a free-form closed polygon without
455    *   self-intersections. The last point should not coincide with the first
456    *   point of the list. Any two neighbor points should not be confused.
457    * @param thePoint
458    *   the point to be classified.
459    * @return
460    *   Standard_True if thePoint in inside thePolygon or lies on its boundary.
461    */
462   Standard_EXPORT static Standard_Boolean
463                  IsIn (const NCollection_List<gp_XY> &thePolygon,
464                        const gp_XY                   &thePoint);
465
466   /**
467    * Implements deallocation of the object instance
468    */
469   Standard_EXPORT virtual void Delete () const; 
470
471  protected:
472
473   /**
474    * Allocator-based operator new for dynamic allocations in method Clone()
475    */
476   DEFINE_STANDARD_ALLOC
477   DEFINE_NCOLLECTION_ALLOC
478
479   /**
480    * Create a 3D bounding box of the object.
481    */
482   Standard_EXPORT virtual void computeBox     ();
483
484   /**
485    * Create the memory buffer for the declared number of nodes, old nodes
486    * are deallocated.
487    */
488   Standard_EXPORT void         allocateNodes  (const Standard_Integer nNodes);
489
490   /**
491    * Get the node pointed by the i-th index in the array.
492    */
493   Standard_EXPORT gp_Pnt       nodeAtInd      (const Standard_Integer * theArr,
494                                                const Standard_Integer i) const;
495
496   /**
497    * Get the node pointed by the i-th index in the array.
498    */
499   Standard_EXPORT float*       nodeArrAtInd   (const Standard_Integer * theArr,
500                                                const Standard_Integer i) const;
501
502  protected:
503   // ---------- PROTECTED FIELDS ----------
504
505   NCollection_BaseAllocator  * myAlloc; //!< Usually from InteractiveContext
506   Standard_Integer           myType;    //!< Combination of Type_* constants
507   Standard_ShortReal         *  mypNodes;
508   Standard_Integer           *  mypTriangles;
509   Standard_Integer           *  mypLines;
510   Standard_Integer           ** mypPolygons;
511   Standard_Integer           myNNodes;
512   Standard_Integer           myNTriangles;
513   Standard_Integer           myNLineNodes;
514   unsigned int               myNPolygons      : 24;
515   Standard_Boolean           myIsDrawPolygons : 1;
516   Standard_Boolean           myIsCloned       : 1; //!< How it is allocated
517   unsigned int               myIndexType      : 2; //!< 0:8bit, 1:16bit, 2:32bit
518   unsigned int               myNodeCoord      : 2; //!< 2 or 3 coordinates
519   unsigned int               myPolygonType    : 2;
520
521  public:
522 // Declaration of CASCADE RTTI
523 DEFINE_STANDARD_RTTI (NIS_Triangulated)
524
525   friend class NIS_TriangulatedDrawer;
526 };
527
528 // Definition of HANDLE object using Standard_DefineHandle.hxx
529 DEFINE_STANDARD_HANDLE (NIS_Triangulated, NIS_InteractiveObject)
530
531 #endif