0024530: TKMesh - remove unused package IntPoly
[occt.git] / src / NIS / NIS_Surface.hxx
1 // Created on: 2008-03-19
2 // Created by: Alexander GRIGORIEV
3 // Copyright (c) 2008-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_Surface_HeaderFile
17 #define NIS_Surface_HeaderFile
18
19 #include <NIS_InteractiveObject.hxx>
20 #include <NCollection_BaseAllocator.hxx>
21 #include <gp_XYZ.hxx>
22
23 class Quantity_Color;
24 class Handle_Poly_Triangulation;
25 class TopoDS_Shape;
26
27 /**
28  * Presentation of a meshed surface.
29  * Consists of 4 arrays: Nodes, Triangles, Normals and Edges. Normals are
30  * defined in nodes, so the number of stored normals is strictly the number of
31  * nodes. Edges is an array of pointers: each pointer starts an array of
32  * node indices that define a single edge (i.e., a polygon that can be closed or
33  * open, no matter). The first number in the edge is the number of nodes in it.
34  * <p>
35  * Instances of this class can be initialized either atomically (setting every
36  * node and triangle and edge) or from a TopoDS_Shape object. In side the
37  * TopoDS_Shape only triangulations in faces are used; edges are taken from
38  * PolygonOnTriangulation also belonging to faces.
39  * <p>
40  * This class is conceived as replacement of AIS_Shape; both wireframe and
41  * shading modes are available for dynamic switching.
42  */
43
44 class NIS_Surface : public NIS_InteractiveObject
45 {
46 public:
47   enum DisplayMode {
48     Shading,
49     Wireframe
50   };
51
52   /**
53    * Constructor
54    */
55   Standard_EXPORT NIS_Surface(const Handle_Poly_Triangulation& theTri,
56                               const Handle_NCollection_BaseAllocator&
57                                                                 theAlloc =0L);
58   /**
59    * Constructor. Creates the presentation of all faces in 'theShape' object.
60    * @param theShape
61    *   Source geometry. It should contain triangulations inside.
62    * @param theDeflection
63    *   Absolute deflection for meshing 'theShape' if such meshing is needed.
64    * @param theAl
65    *   Allocator used for nodes and triangles in this presentation.
66    */
67   Standard_EXPORT NIS_Surface(const TopoDS_Shape& theShape,
68                               const Standard_Real theDeflection,
69                               const Handle_NCollection_BaseAllocator& theAl=0L);
70
71   /**
72    * Destructor
73    */
74   Standard_EXPORT virtual ~NIS_Surface ();
75
76   /**
77    * Initialize the instance with a TopoDS_Shape. Used in constructor but can
78    * be called any time to redefine the geometry.
79    */
80   Standard_EXPORT void              Init        (const TopoDS_Shape& theShape,
81                                                  const Standard_Real theDefl);
82
83   /**
84    * Deallocate all internal data structures.
85    */
86   Standard_EXPORT void              Clear       ();
87
88   /**
89    * Query the number of nodes.
90    */
91   inline Standard_Integer           NNodes      () const { return myNNodes; }
92
93   /**
94    * Query the number of triangles.
95    */
96   inline Standard_Integer           NTriangles  () const { return myNTriangles;}
97
98   /**
99    * Query the number of edges for wireframe display.
100    */
101   inline Standard_Integer           NEdges      () const { return myNEdges; }
102
103   /**
104    * Query the node by its index.
105    * @return
106    *   pointer to array of 3 Standard_ShortReal values (X,Y,Z coordinates)
107    */
108   inline const Standard_ShortReal*
109                         Node            (const Standard_Integer theIndex) const
110   {
111     return &mypNodes[theIndex * 3];
112   }
113
114   /**
115    * Query the triangle by its index.
116    * @return
117    *   pointer to array of 3 Standard_Integer values (nodes 0, 1, 2)
118    */
119   inline const Standard_Integer*
120                         Triangle        (const Standard_Integer theIndex) const
121   {
122     return &mypTriangles[theIndex * 3];
123   }
124
125   /**
126    * Access to array of integers that represents an Edge.
127    * @return
128    *   Pointer to array where the 0th element is the number of nodes in the edge
129    *   and the elements starting from the 1st are node indices.
130    */
131   inline const Standard_Integer*
132                         Edge            (const Standard_Integer theIndex) const
133   {
134     return mypEdges[theIndex];
135   }
136
137   /**
138    * Query the normal vector at the given triangulation node (by index)
139    * @return
140    *   pointer to array of 3 Standard_ShortReal values (X,Y,Z coordinates)
141    */
142   inline const Standard_ShortReal*
143                         Normal          (const Standard_Integer theIndex) const
144   {
145     return &mypNormals[theIndex * 3];
146   }
147
148   /**
149    * Create a default drawer instance.
150    */
151   Standard_EXPORT virtual NIS_Drawer *
152                         DefaultDrawer   (NIS_Drawer *) const;
153
154   /**
155    * Set the normal color for presentation.
156    * @param theColor
157    *   New color to use for the presentation.
158    */
159   Standard_EXPORT void  SetColor        (const Quantity_Color& theColor);
160
161   /**
162    * Set the color for presentation of the back side of triangles.
163    * @param theColor
164    *   New color to use for the presentation.
165    */
166   Standard_EXPORT void  SetBackColor    (const Quantity_Color& theColor);
167
168   /**
169    * Set the offset for the presentation.
170    * @param theValue
171    *   New offset to use for the presentation.
172    */
173   Standard_EXPORT void  SetPolygonOffset (const Standard_Real theValue);
174
175   /**
176    * Set the display mode: Shading or Wireframe.
177    * The default mode is Shading.
178    */
179   Standard_EXPORT void  SetDisplayMode   (const DisplayMode theMode);
180
181   /**
182    * Query the current display mode: Shading or Wireframe.
183    */
184   Standard_EXPORT DisplayMode
185                         GetDisplayMode   () const;
186
187   /**
188    * Create a copy of theObject except its ID.
189    * @param theAll
190    *   Allocator where the Dest should store its private data.
191    * @param theDest
192    *   <tt>[in-out]</tt> The target object where the data are copied. If
193    *   passed NULL then the target should be created.
194    */
195   Standard_EXPORT virtual void
196                           Clone (const Handle_NCollection_BaseAllocator& theAll,
197                                  Handle_NIS_InteractiveObject& theDest) const;
198
199   /**
200    * Intersect the surface shading/wireframe geometry with a line/ray.
201    * @param theAxis
202    *   The line or ray in 3D space.
203    * @param theOver
204    *   Half-thickness of the selecting line - ignored.
205    * @return
206    *   If the return value is more than 0.1*RealLast() then no intersection is
207    *   detected. Otherwise returns the coordinate of the nearest intersection
208    *   on the ray. May be negative.
209    */
210   Standard_EXPORT virtual Standard_Real
211                           Intersect     (const gp_Ax1&       theAxis,
212                                          const Standard_Real theOver) const;
213
214   /**
215    * Intersect the surface shading/wireframe geometry with an oriented box.
216    * @param theBox
217    *   3D box of selection
218    * @param theTrf
219    *   Position/Orientation of the box.
220    * @param isFull
221    *   True if full inclusion is required, False - if partial.
222    * @return
223    *   True if the InteractiveObject geometry intersects the box or is inside it
224    */
225   Standard_EXPORT virtual Standard_Boolean
226                              Intersect     (const Bnd_B3f&         theBox,
227                                             const gp_Trsf&         theTrf,
228                                             const Standard_Boolean isFull)const;
229
230   /**
231    * Intersect the surface shading/wireframe geometry with a selection polygon.
232    * @param thePolygon
233    *   the list of vertices of a free-form closed polygon without
234    *   self-intersections. The last point should not coincide with the first
235    *   point of the list. Any two neighbor points should not be confused.
236    * @param theTrf
237    *   Position/Orientation of the polygon.
238    * @param isFullIn
239    *   True if full inclusion is required, False - if partial.
240    * @return
241    *   True if the InteractiveObject geometry intersects the polygon or is
242    *   inside it
243    */
244   Standard_EXPORT virtual Standard_Boolean Intersect
245                     (const NCollection_List<gp_XY> &thePolygon,
246                      const gp_Trsf                 &theTrf,
247                      const Standard_Boolean         isFullIn) const;
248
249 protected:
250
251   /**
252    * Allocator for method Clone().
253    */
254   Standard_EXPORT NIS_Surface (const Handle_NCollection_BaseAllocator& theAl); 
255
256   /**
257    * Create a 3D bounding box of the object.
258    */
259   Standard_EXPORT virtual void computeBox     ();
260
261   /**
262    * Compute normal to the surface at the node with the given index.
263    * Returns true if the vertex is artificial at this node.
264    */
265   Standard_Boolean computeNormal (Standard_Integer theIndex,
266                                   gp_XYZ& theNormal) const;
267
268 private:
269   Handle_NCollection_BaseAllocator myAlloc;
270   //! Array of nodes in triangles
271   Standard_ShortReal               * mypNodes;
272   //! Array of normals (TriNodes)
273   Standard_ShortReal               * mypNormals;
274   //! Array of triangles (node indices)
275   Standard_Integer                 * mypTriangles;
276   //! Array of edges, each edge is an array of indices prefixed by N nodes
277   Standard_Integer                 ** mypEdges;
278   //! Number of nodes in triangles
279   Standard_Integer                 myNNodes;
280   Standard_Integer                 myNTriangles;
281   Standard_Integer                 myNEdges;
282   Standard_Boolean                 myIsWireframe;
283
284 public:
285 // Declaration of CASCADE RTTI
286 DEFINE_STANDARD_RTTI (NIS_Surface)
287 };
288
289 // Definition of HANDLE object using Standard_DefineHandle.hxx
290 DEFINE_STANDARD_HANDLE (NIS_Surface, NIS_InteractiveObject)
291
292 #endif