0023021: MeshVS_DataSource::GetNormalsByElement returns Standard_False and gives...
[occt.git] / src / MeshVS / MeshVS_DataSource.cxx
1 // Created on: 2003-09-16
2 // Created by: Alexander SOLOVYOV
3 // Copyright (c) 2003-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20
21 #include <MeshVS_DataSource.ixx>
22 #include <MeshVS_Tool.hxx>
23 #include <MeshVS_Buffer.hxx>
24
25 #include <gp.hxx>
26 #include <gp_Vec.hxx>
27 #include <TColgp_Array1OfPnt.hxx>
28 #include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
29
30 //================================================================
31 // Function : Get3DGeom
32 // Purpose  :
33 //================================================================
34 Standard_Boolean MeshVS_DataSource::Get3DGeom( const Standard_Integer /*ID*/, 
35                                                Standard_Integer& /*NbNodes*/,
36                                                Handle( MeshVS_HArray1OfSequenceOfInteger )& /*Data*/ ) const
37 {
38   return Standard_False;
39 }
40
41 //================================================================
42 // Function : GetNormal
43 // Purpose  :
44 //================================================================
45 Standard_Boolean MeshVS_DataSource::GetNormal ( const Standard_Integer Id,
46                                                 const Standard_Integer Max,
47                                                 Standard_Real &nx,
48                                                 Standard_Real &ny,
49                                                 Standard_Real &nz ) const
50 {
51   if ( Max <= 0 )
52     return Standard_False;
53
54   MeshVS_Buffer aCoordsBuf (3*Max*sizeof(Standard_Real));
55   TColStd_Array1OfReal Coords ( aCoordsBuf, 1, 3*Max );
56   Standard_Integer nbNodes;
57   MeshVS_EntityType Type;
58
59   Standard_Boolean res = Standard_False;
60
61   if ( !GetGeom ( Id, Standard_True, Coords, nbNodes, Type ) )
62     return res;
63
64   if ( Type == MeshVS_ET_Face && nbNodes >= 3 )
65   {
66     Standard_Real x1 = Coords( 1 );
67     Standard_Real y1 = Coords( 2 );
68     Standard_Real z1 = Coords( 3 );
69     Standard_Real x2 = Coords( 4 );
70     Standard_Real y2 = Coords( 5 );
71     Standard_Real z2 = Coords( 6 );
72     Standard_Real x3 = Coords( ( nbNodes - 1 ) * 3 + 1 );
73     Standard_Real y3 = Coords( ( nbNodes - 1 ) * 3 + 2 );
74     Standard_Real z3 = Coords( ( nbNodes - 1 ) * 3 + 3 );
75     Standard_Real p1 = x2 - x1, p2 = y2 - y1, p3 = z2 - z1,
76                   q1 = x3 - x1, q2 = y3 - y1, q3 = z3 - z1;
77     nx = p2*q3 - p3*q2;
78     ny = p3*q1 - p1*q3;
79     nz = p1*q2 - p2*q1;
80     Standard_Real len = sqrt ( nx*nx + ny*ny + nz*nz );
81     if ( len <= gp::Resolution() )
82     {
83       nx = ny = nz = 0;
84       return res;
85     }
86     nx /= len; ny /= len; nz /= len;
87     res = Standard_True;
88   }
89   return res;
90 }
91
92 //================================================================
93 // Function : GetNodeNormal
94 // Purpose  :
95 //================================================================
96 Standard_Boolean MeshVS_DataSource::GetNodeNormal
97                                 ( const Standard_Integer /*ranknode*/,
98                                   const Standard_Integer /*Id*/,
99                                   Standard_Real &/*nx*/,
100                                   Standard_Real &/*ny*/,
101                                   Standard_Real &/*nz*/ ) const
102 {
103   return Standard_False;
104 }
105
106 //================================================================
107 // Function : GetNormalsByElement
108 // Purpose  :
109 //================================================================
110 Standard_Boolean MeshVS_DataSource::GetNormalsByElement(const Standard_Integer Id,
111                                                         const Standard_Boolean IsNodal,
112                                                         const Standard_Integer MaxNodes,
113                                                         Handle(TColStd_HArray1OfReal)& Normals) const
114 {
115   MeshVS_Buffer aCoordsBuf (3*MaxNodes*sizeof(Standard_Real));
116   TColStd_Array1OfReal Coords ( aCoordsBuf, 1, 3*MaxNodes );
117   Standard_Integer NbNodes;
118   MeshVS_EntityType Type;
119
120   Standard_Boolean res = Standard_False;
121   if ( MaxNodes <= 0 )
122     return res;
123
124   if ( !GetGeom ( Id, Standard_True, Coords, NbNodes, Type ) )
125     return res;
126
127   Standard_Integer aNbNormals = NbNodes;
128
129   Handle( MeshVS_HArray1OfSequenceOfInteger ) aTopo;
130   if ( Type == MeshVS_ET_Volume )
131   {
132     if( !Get3DGeom( Id, NbNodes, aTopo ) )
133           return res;
134     // calculate number of normals for faces of volume 
135     aNbNormals = aTopo->Upper() - aTopo->Lower() + 1;
136   }
137
138   Handle(TColStd_HArray1OfReal) aNormals = new TColStd_HArray1OfReal(1, 3 * aNbNormals );
139
140   Standard_Boolean allNormals = ( Type == MeshVS_ET_Face && IsNodal );
141   // Try returning nodal normals if possible
142   for( Standard_Integer k=1; k<=NbNodes && allNormals; k++ )
143     allNormals = GetNodeNormal( k, 
144                                 Id, 
145                                 aNormals->ChangeValue(3 * k - 2), 
146                                 aNormals->ChangeValue(3 * k - 1), 
147                                 aNormals->ChangeValue(3 * k    ) );
148
149   // Nodal normals not available or not needed
150   if ( !allNormals )
151   {
152     switch ( Type )
153     {
154     // Compute a face normal and duplicate it for all element`s nodes
155     case MeshVS_ET_Face:
156       res = GetNormal( Id, 
157                        MaxNodes, 
158                        aNormals->ChangeValue(1), 
159                        aNormals->ChangeValue(2), 
160                        aNormals->ChangeValue(3) );
161       if ( res )
162       {
163         for( Standard_Integer k=2; k<=NbNodes; k++ )
164         {
165           aNormals->ChangeValue(3 * k - 2) = aNormals->Value(1);
166           aNormals->ChangeValue(3 * k - 1) = aNormals->Value(2);
167           aNormals->ChangeValue(3 * k    ) = aNormals->Value(3);
168         }
169       }
170       break;
171
172     // Compute normals for each of volum`s faces - not for each node!
173     case MeshVS_ET_Volume:
174       {
175         gp_Vec norm;
176         Standard_Integer low = Coords.Lower();
177         for ( Standard_Integer k = aTopo->Lower(), last = aTopo->Upper(), i = 1; k <= last; k++, i++ )
178         {
179           const TColStd_SequenceOfInteger& aSeq = aTopo->Value( k );
180           Standard_Integer m = aSeq.Length(), ind;
181
182           norm.SetCoord( 0, 0, 0 );
183           MeshVS_Buffer PolyNodesBuf (3*m*sizeof(Standard_Real));
184           TColStd_Array1OfReal PolyNodes( PolyNodesBuf, 0, 3*m );
185           PolyNodes.SetValue( 0, m );
186           for( Standard_Integer j=1; j<=m; j++ )
187           {          
188             ind = aSeq.Value( j );
189             PolyNodes.SetValue( 3*j-2, Coords( low+3*ind   ) );
190             PolyNodes.SetValue( 3*j-1, Coords( low+3*ind+1 ) );
191             PolyNodes.SetValue( 3*j,   Coords( low+3*ind+2 ) );
192           }
193
194           MeshVS_Tool::GetAverageNormal( PolyNodes, norm );
195
196           aNormals->ChangeValue(i * 3 - 2) = norm.X();
197           aNormals->ChangeValue(i * 3 - 1) = norm.Y();
198           aNormals->ChangeValue(i * 3    ) = norm.Z();
199         }
200         res = Standard_True;
201       }
202       break;
203
204     default:
205       return res;
206     } // switch ( Type )
207   } // if ( !allNormals )
208
209   if ( res || allNormals )
210     Normals = aNormals;
211
212   return ( res || allNormals );
213 }
214
215 //================================================================
216 // Function : GetAllGroups
217 // Purpose  :
218 //================================================================
219 void MeshVS_DataSource::GetAllGroups( TColStd_PackedMapOfInteger& /*Ids*/ ) const
220 {
221 }
222
223 //================================================================
224 // Function : GetGroup
225 // Purpose  :
226 //================================================================
227 Standard_Boolean MeshVS_DataSource::GetGroup( const Standard_Integer /*Id*/,
228                                               MeshVS_EntityType& Type,
229                                               TColStd_PackedMapOfInteger& /*Ids*/ )  const
230 {
231   Type = MeshVS_ET_NONE;
232   return Standard_False;
233 }
234
235
236 //================================================================
237 // Function : GetGroupAddr
238 // Purpose  :
239 //================================================================
240 Standard_Address MeshVS_DataSource::GetGroupAddr(const Standard_Integer /*ID*/) const
241 {
242   return NULL;
243 }
244
245 //================================================================
246 // Function : IsAdvancedSelectionEnabled
247 // Purpose  :
248 //================================================================
249 Standard_Boolean MeshVS_DataSource::IsAdvancedSelectionEnabled() const
250 {
251   return Standard_False;
252 }
253
254 //================================================================
255 // Function : GetDetectedEntities
256 // Purpose  :
257 //================================================================
258 Standard_Boolean MeshVS_DataSource::GetDetectedEntities(const Handle(MeshVS_Mesh)& /*theMesh*/, 
259                                                         const Standard_Real     /*X*/,
260                                                         const Standard_Real     /*Y*/,
261                                                         const Standard_Real     /*aTol*/,
262                                                         Handle(TColStd_HPackedMapOfInteger)& /*Nodes*/,
263                                                         Handle(TColStd_HPackedMapOfInteger)& /*Elements*/,
264                                                         Standard_Real& /*DMin*/)
265 {
266   return Standard_False;
267 }
268
269 //================================================================
270 // Function : GetDetectedEntities
271 // Purpose  :
272 //================================================================
273 Standard_Boolean MeshVS_DataSource::GetDetectedEntities(const Handle(MeshVS_Mesh)& /*theMesh*/, 
274                                                         const Standard_Real     /*XMin*/,
275                                                         const Standard_Real     /*YMin*/,
276                                                         const Standard_Real     /*XMax*/,
277                                                         const Standard_Real     /*YMax*/,
278                                                         const Standard_Real     /*aTol*/,
279                                                         Handle(TColStd_HPackedMapOfInteger)& /*Nodes*/,
280                                                         Handle(TColStd_HPackedMapOfInteger)& /*Elements*/) 
281 {
282   return Standard_False;
283 }
284
285 //================================================================
286 // Function : GetDetectedEntities
287 // Purpose  :
288 //================================================================
289 Standard_Boolean MeshVS_DataSource::GetDetectedEntities(const Handle(MeshVS_Mesh)& /*theMesh*/, 
290                                                         const TColgp_Array1OfPnt2d& /*Polyline*/,
291                                                         const Bnd_Box2d&            /*aBox*/,
292                                                         const Standard_Real         /*aTol*/,
293                                                         Handle(TColStd_HPackedMapOfInteger)& /*Nodes*/,
294                                                         Handle(TColStd_HPackedMapOfInteger)& /*Elements*/)
295 {
296   return Standard_False;
297 }
298
299 //================================================================
300 // Function : GetDetectedEntities
301 // Purpose  :
302 //================================================================
303 Standard_Boolean MeshVS_DataSource::GetDetectedEntities(const Handle(MeshVS_Mesh)& /*theMesh*/,
304                                                         Handle(TColStd_HPackedMapOfInteger)& /*Nodes*/,
305                                                         Handle(TColStd_HPackedMapOfInteger)& /*Elements*/)
306 {
307   return Standard_False;
308 }
309
310 //================================================================
311 // Function : GetBoundingBox
312 // Purpose  :
313 //================================================================
314 Bnd_Box MeshVS_DataSource::GetBoundingBox() const
315 {
316   // Compute the 3D bounding box for mesh
317   Bnd_Box aBox;
318   const TColStd_PackedMapOfInteger& aNodes = GetAllNodes();
319   if( aNodes.Extent() )
320   {
321     Standard_Real aCoordsBuf[ 3 ];
322     TColStd_Array1OfReal aCoords (*aCoordsBuf, 1, 3);
323     Standard_Integer nbNodes;
324     MeshVS_EntityType aType;
325     TColStd_MapIteratorOfPackedMapOfInteger anIter (aNodes);
326     for ( ; anIter.More(); anIter.Next() )
327     {
328       Standard_Integer aKey = anIter.Key();
329       if ( !GetGeom ( aKey, Standard_False, aCoords, nbNodes, aType ) )
330         continue;
331       aBox.Add( gp_Pnt( aCoordsBuf[0], aCoordsBuf[1], aCoordsBuf[2] ) );
332     }
333   }
334   return aBox;
335 }