0027670: Visualization - avoid duplication of structures defining primitive array...
[occt.git] / src / MeshVS / MeshVS_NodalColorPrsBuilder.cxx
1 // Created on: 2003-11-12
2 // Created by: Alexander SOLOVYOV
3 // Copyright (c) 2003-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 under
8 // the terms of the GNU Lesser General Public License 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 #define _POLYGONES_
17
18 // if define _POLYGONES_ ColorPrsBuilder use ArrayOfPolygons for drawing faces
19
20 #include <Aspect_SequenceOfColor.hxx>
21 #include <gp_Pnt.hxx>
22 #include <Graphic3d_ArrayOfPolygons.hxx>
23 #include <Graphic3d_ArrayOfPolylines.hxx>
24 #include <Graphic3d_ArrayOfPrimitives.hxx>
25 #include <Graphic3d_ArrayOfSegments.hxx>
26 #include <Graphic3d_ArrayOfTriangles.hxx>
27 #include <Graphic3d_AspectFillArea3d.hxx>
28 #include <Graphic3d_AspectLine3d.hxx>
29 #include <Graphic3d_Group.hxx>
30 #include <Graphic3d_Texture2D.hxx>
31 #include <Graphic3d_TextureParams.hxx>
32 #include <Graphic3d_TypeOfTextureMode.hxx>
33 #include <Image_PixMap.hxx>
34 #include <MeshVS_Buffer.hxx>
35 #include <MeshVS_DataSource.hxx>
36 #include <MeshVS_DisplayModeFlags.hxx>
37 #include <MeshVS_Drawer.hxx>
38 #include <MeshVS_DrawerAttribute.hxx>
39 #include <MeshVS_HArray1OfSequenceOfInteger.hxx>
40 #include <MeshVS_Mesh.hxx>
41 #include <MeshVS_MeshPrsBuilder.hxx>
42 #include <MeshVS_NodalColorPrsBuilder.hxx>
43 #include <MeshVS_SymmetricPairHasher.hxx>
44 #include <MeshVS_Tool.hxx>
45 #include <NCollection_Map.hxx>
46 #include <NCollection_Vector.hxx>
47 #include <Prs3d_Drawer.hxx>
48 #include <Prs3d_LineAspect.hxx>
49 #include <Prs3d_Presentation.hxx>
50 #include <Prs3d_Root.hxx>
51 #include <Prs3d_ShadingAspect.hxx>
52 #include <PrsMgr_PresentationManager3d.hxx>
53 #include <Quantity_Array1OfColor.hxx>
54 #include <Quantity_Color.hxx>
55 #include <Standard_Type.hxx>
56 #include <TColStd_Array1OfInteger.hxx>
57 #include <TColStd_Array1OfReal.hxx>
58 #include <TColStd_HArray1OfReal.hxx>
59 #include <TColStd_HPackedMapOfInteger.hxx>
60 #include <TColStd_ListIteratorOfListOfInteger.hxx>
61 #include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
62 #include <TColStd_SequenceOfInteger.hxx>
63
64 IMPLEMENT_STANDARD_RTTIEXT(MeshVS_NodalColorPrsBuilder,MeshVS_PrsBuilder)
65
66 /*
67   Class       : MeshVS_ImageTexture2D
68   Description : Texture for nodal presentation
69 */
70 class MeshVS_ImageTexture2D : public Graphic3d_Texture2D
71 {
72 public:
73
74   MeshVS_ImageTexture2D (const Handle(Image_PixMap)& theImg) : Graphic3d_Texture2D (theImg, Graphic3d_TOT_2D)
75   {
76     myParams->SetModulate (Standard_True);
77     myParams->SetFilter   (Graphic3d_TOTF_BILINEAR);
78   }
79
80 public:
81
82   DEFINE_STANDARD_RTTI_INLINE(MeshVS_ImageTexture2D,Graphic3d_Texture2D)
83 };
84
85 DEFINE_STANDARD_HANDLE    (MeshVS_ImageTexture2D, Graphic3d_Texture2D)
86
87
88 //================================================================
89 // Function : getNearestPow2
90 // Purpose  : Returns the nearest power of two greater than the
91 //            argument value
92 //================================================================
93 static inline Standard_Integer getNearestPow2( Standard_Integer theValue )
94 {
95   // Precaution against overflow
96   Standard_Integer aHalfMax = IntegerLast() >> 1, aRes = 1;
97   if ( theValue > aHalfMax ) theValue = aHalfMax;
98   while ( aRes < theValue ) aRes <<= 1;
99   return aRes;
100 }
101
102 /*
103   Class       : MeshVS_NodalColorPrsBuilder
104   Description : This class provides methods to create presentation of
105                 nodes with assigned color (See hxx for more description )
106 */
107
108 //================================================================
109 // Function : Constructor MeshVS_NodalColorPrsBuilder
110 // Purpose  :
111 //================================================================
112 MeshVS_NodalColorPrsBuilder::MeshVS_NodalColorPrsBuilder ( const Handle(MeshVS_Mesh)& Parent,
113                                                            const MeshVS_DisplayModeFlags& Flags,
114                                                            const Handle (MeshVS_DataSource)& DS,
115                                                            const Standard_Integer Id,
116                                                            const MeshVS_BuilderPriority& Priority )
117 : MeshVS_PrsBuilder ( Parent, Flags, DS, Id, Priority ),
118   myUseTexture( Standard_False ),
119   myInvalidColor( Quantity_NOC_GRAY )
120 {
121   SetExcluding ( Standard_True );
122 }
123
124 //================================================================
125 // Function : Build
126 // Purpose  :
127 //================================================================
128 void MeshVS_NodalColorPrsBuilder::Build ( const Handle(Prs3d_Presentation)& Prs,
129                                           const TColStd_PackedMapOfInteger& IDs,
130                                           TColStd_PackedMapOfInteger& IDsToExclude,
131                                           const Standard_Boolean IsElement,
132                                           const Standard_Integer DisplayMode) const
133 {
134   Handle (MeshVS_DataSource) aSource = GetDataSource();
135   Handle (MeshVS_Drawer)     aDrawer = GetDrawer();
136   if ( aSource.IsNull() || aDrawer.IsNull() )
137     return;
138
139   Standard_Integer aMaxFaceNodes;
140   if ( !aDrawer->GetInteger ( MeshVS_DA_MaxFaceNodes, aMaxFaceNodes ) || aMaxFaceNodes <= 0 )
141     return;
142
143   MeshVS_Buffer aCoordsBuf (3*aMaxFaceNodes*sizeof(Standard_Real));
144   TColStd_Array1OfReal aCoords ( aCoordsBuf, 1, 3 * aMaxFaceNodes );
145   Standard_Integer NbNodes;
146   MeshVS_EntityType aType;
147
148   if ( !( DisplayMode & GetFlags() ) || !IsElement )
149     return;
150
151   if ( (myUseTexture && ( !myTextureCoords.Extent() || !myTextureColorMap.Length() )) ||
152        (!myUseTexture && !myNodeColorMap.Extent()) )
153     return;
154
155   // subtract the hidden elements and ids to exclude (to minimize allocated memory)
156   TColStd_PackedMapOfInteger anIDs;
157   anIDs.Assign( IDs );
158   Handle(TColStd_HPackedMapOfInteger) aHiddenElems = myParentMesh->GetHiddenElems();
159   if ( !aHiddenElems.IsNull() )
160     anIDs.Subtract( aHiddenElems->Map() );
161   anIDs.Subtract( IDsToExclude );
162
163   Standard_Boolean IsReflect = Standard_False, IsMeshSmoothShading = Standard_False;
164   aDrawer->GetBoolean( MeshVS_DA_ColorReflection, IsReflect );
165   aDrawer->GetBoolean( MeshVS_DA_SmoothShading,   IsMeshSmoothShading );
166
167   // Following parameter are used for texture presentation only
168   int nbColors = 0; // Number of colors from color map
169   int nbTextureColors = 0; // Number of colors in texture (it will be pow of 2)
170   if ( myUseTexture )
171   {
172     nbColors = myTextureColorMap.Length();
173     nbTextureColors = getNearestPow2( nbColors );
174   }
175
176   Standard_Integer aSize = anIDs.Extent();
177
178   // Calculate maximum possible number of vertices and bounds
179   Handle( MeshVS_HArray1OfSequenceOfInteger ) aTopo;
180   Standard_Integer PolygonVerticesFor3D = 0, PolygonBoundsFor3D = 0;
181   TColStd_MapIteratorOfPackedMapOfInteger it (anIDs);
182   for( ; it.More(); it.Next() )
183   {
184     Standard_Integer aKey = it.Key();
185     if ( aSource->Get3DGeom( aKey, NbNodes, aTopo ) )
186       MeshVS_MeshPrsBuilder::HowManyPrimitives
187       ( aTopo, Standard_True, Standard_False, NbNodes,
188       PolygonVerticesFor3D, PolygonBoundsFor3D );
189   }
190
191   // Draw faces with nodal color
192   // OCC20644 Use "plastic" material as it is "non-physic" and so it is easier
193   // to get the required colors (see TelUpdateMaterial() function in OpenGl_attri.c)
194   Graphic3d_MaterialAspect aMaterial[ 2 ];
195   aMaterial[ 0 ] = Graphic3d_MaterialAspect( Graphic3d_NOM_PLASTIC );
196   aMaterial[ 1 ] = Graphic3d_MaterialAspect( Graphic3d_NOM_PLASTIC );
197   Standard_Integer i;
198   for ( i = 0; i < 2; i++ )
199   {
200     if ( !IsReflect )
201     {
202       aMaterial[ i ].SetReflectionModeOff( Graphic3d_TOR_SPECULAR );
203       aMaterial[ i ].SetReflectionModeOff( Graphic3d_TOR_AMBIENT );
204       aMaterial[ i ].SetReflectionModeOff( Graphic3d_TOR_DIFFUSE );
205       aMaterial[ i ].SetReflectionModeOff( Graphic3d_TOR_EMISSION );
206     }
207     else{
208       // OCC20644 Using the material with reflection properties same as in
209       // ElementalColorPrsBuilder, to get the same colors.
210       // Additionally, ambient and diffuse coefficients are used below to scale incoming colors,
211       // to simulate TelUpdateMaterial() function from OpenGl_attri.c.
212       // This is mandatory, as these "scaled" colors are then passed directly to OpenGL
213       // as ambient and diffuse colors of the current material using glColorMaterial().
214       // In ElementalColorPrsBuilder we do not need to do scale the colors, as this
215       // is done by TelUpdateMaterial().
216       // 0.5 is used to have the colors in 3D maximally similar to those in the color scale.
217       // This is possible when the sum of all coefficient is equal to 1.
218       aMaterial[i].SetAmbient( .5 );
219       aMaterial[i].SetDiffuse( .5 );
220       aMaterial[i].SetSpecular( 0. );
221       aMaterial[i].SetEmissive( 0. );
222     }
223
224  }
225
226
227   // Create array of polygons for interior presentation of faces and volumes
228   Handle(Graphic3d_ArrayOfPolygons) aCPolyArr = new Graphic3d_ArrayOfPolygons
229     ( aMaxFaceNodes * aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D,
230     0, myUseTexture || IsReflect, !myUseTexture, Standard_False, myUseTexture );
231
232     Standard_Integer aNbFacePrimitives = 0;
233     Standard_Integer aNbVolmPrimitives = 0;
234     Standard_Integer aNbEdgePrimitives = 0;
235     Standard_Integer aNbLinkPrimitives = 0;
236
237     for (it.Reset(); it.More(); it.Next())
238     {
239       Standard_Integer aNbNodes = 0;
240
241       if (!aSource->GetGeom (it.Key(), Standard_True, aCoords, aNbNodes, aType))
242         continue;
243
244       if (aType == MeshVS_ET_Volume)
245       {
246         if (aSource->Get3DGeom (it.Key(), aNbNodes, aTopo))
247         {
248           for (Standard_Integer aFaceIdx = aTopo->Lower(); aFaceIdx <= aTopo->Upper(); ++aFaceIdx)
249           {
250             const TColStd_SequenceOfInteger& aFaceNodes = aTopo->Value (aFaceIdx);
251
252             aNbEdgePrimitives += aFaceNodes.Length();     // add edge segments
253             aNbVolmPrimitives += aFaceNodes.Length() - 2; // add volumetric cell triangles
254           }
255         }
256       }
257       else if (aType == MeshVS_ET_Link)
258       {
259         aNbLinkPrimitives += aNbNodes - 1; // add link segments
260       }
261       else if (aType == MeshVS_ET_Face)
262       {
263         aNbEdgePrimitives += aNbNodes;     // add edge segments
264         aNbFacePrimitives += aNbNodes - 2; // add face triangles
265       }
266     }
267
268   // Here we do not use indices arrays because they are not effective for some mesh
269   // drawing modes: shrinking mode (displaces the vertices inside the polygon), 3D
270   // cell rendering (normal interpolation is not always applicable - flat shading),
271   // elemental coloring (color interpolation is impossible)
272
273   // Create array of polygons for interior presentation of faces and volumes
274   Handle(Graphic3d_ArrayOfTriangles) aFaceTriangles = new Graphic3d_ArrayOfTriangles
275     ( (aNbFacePrimitives + aNbVolmPrimitives) * 3, 0, myUseTexture || IsReflect, !myUseTexture, myUseTexture );
276
277   // Create array of polylines for presentation of edges
278   Handle(Graphic3d_ArrayOfSegments) anEdgeSegments = new Graphic3d_ArrayOfSegments
279     (aNbEdgePrimitives * 2);
280
281   gp_Pnt P, Start;
282   Standard_Real aMin = gp::Resolution() * gp::Resolution();
283   gp_Dir aDefNorm( 0., 0., 1. );
284
285   // Prepare for scaling the incoming colors
286   Standard_Real anColorRatio = aMaterial[0].Ambient();
287
288   for (it.Reset(); it.More(); it.Next())
289   {
290     Standard_Integer aKey = it.Key();
291
292     if (aSource->GetGeom (aKey, Standard_True, aCoords, NbNodes, aType))
293     {
294       TColStd_Array1OfInteger aNodes (1, NbNodes);
295       
296       if (!aSource->GetNodesByElement (aKey, aNodes, NbNodes))
297         continue;
298
299       Quantity_Color aNColor;
300
301       Standard_Boolean isValid = Standard_True;
302       
303       if (myUseTexture)
304       {
305         for (Standard_Integer k = 1; k <= NbNodes && isValid; ++k)
306           isValid = myTextureCoords.IsBound (aNodes (k));
307       }
308       else
309       {
310         for (Standard_Integer k = 1; k <= NbNodes && isValid; ++k)
311           isValid = GetColor (aNodes (k), aNColor);
312       }
313
314       if (!isValid)
315         continue;
316
317       // Preparing normal(s) to show reflections if requested
318       Handle(TColStd_HArray1OfReal) aNormals;
319
320       Standard_Boolean hasNormals =
321         (IsReflect && aSource->GetNormalsByElement (aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals));
322
323       if (aType == MeshVS_ET_Face)
324       {
325         for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes - 2; ++aNodeIdx) // triangulate polygon
326         {
327           for (Standard_Integer aSubIdx = 0; aSubIdx < 3; ++aSubIdx) // generate sub-triangle
328           {
329             gp_XYZ aPnt (aCoords (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
330                          aCoords (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
331                          aCoords (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3));
332
333             gp_Vec aNorm = aDefNorm;
334
335             if (hasNormals)
336             {
337               gp_Vec aTestNorm (aNormals->Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
338                                 aNormals->Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
339                                 aNormals->Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3));
340
341               if (aTestNorm.SquareMagnitude() > aMin)
342               {
343                 aNorm = gp_Dir (aTestNorm);
344               }
345             }
346
347             if (myUseTexture)
348             {
349               const Standard_Real aTexCoord = myTextureCoords (aNodes (aSubIdx == 0 ? 1 : (aNodeIdx + aSubIdx + 1)));
350
351               // Transform texture coordinate in accordance with number of colors specified
352               // by upper level and real size of OpenGL texture. The OpenGL texture has border
353               // colors interpolated with the colors from the color map, thats why we need to
354               // shrink texture coordinates around the middle point to exclude areas where the
355               // map colors are interpolated with the borders color
356               aFaceTriangles->AddVertex (aPnt, aNorm, gp_Pnt2d (
357                 (aTexCoord * (nbColors - 1.0) + 0.5) / nbTextureColors, aTexCoord < 0 || aTexCoord > 1 ? 0.25 : 0.75));
358             }
359             else
360             {
361               GetColor (aNodes (aSubIdx == 0 ? 1 : (aNodeIdx + aSubIdx + 1)), aNColor);
362               
363               if (IsReflect)
364               {
365                 aNColor.SetValues (anColorRatio * aNColor.Red(),
366                                    anColorRatio * aNColor.Green(),
367                                    anColorRatio * aNColor.Blue(),
368                                    Quantity_TOC_RGB);
369
370                 aFaceTriangles->AddVertex (aPnt, aNorm, aNColor);
371               }
372               else
373               {
374                 aFaceTriangles->AddVertex (aPnt, aNColor);
375               }
376             }
377           }
378         }
379
380         for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes; ++aNodeIdx) // border segmentation
381         {
382           const Standard_Integer aNextIdx = (aNodeIdx + 1) % NbNodes;
383
384           anEdgeSegments->AddVertex (aCoords (3 * aNodeIdx + 1),
385                                      aCoords (3 * aNodeIdx + 2),
386                                      aCoords (3 * aNodeIdx + 3));
387
388           anEdgeSegments->AddVertex (aCoords (3 * aNextIdx + 1),
389                                      aCoords (3 * aNextIdx + 2),
390                                      aCoords (3 * aNextIdx + 3));
391         }
392
393         // if IsExcludingOn then presentation must not be built by other builders
394         if (IsExcludingOn())
395         {
396           IDsToExclude.Add (aKey);
397         }
398       }
399       else if (aType == MeshVS_ET_Volume)
400       {
401         if (!aSource->Get3DGeom (aKey, NbNodes, aTopo))
402           continue;
403
404         AddVolumePrs (aTopo, aNodes, aCoords, aFaceTriangles,
405           IsReflect, nbColors, nbTextureColors, anColorRatio);
406         
407         AddVolumePrs (aTopo, aNodes, aCoords, anEdgeSegments,
408           IsReflect, nbColors, nbTextureColors, anColorRatio);
409
410         // if IsExcludingOn then presentation must not be built by other builders
411         if (IsExcludingOn())
412           IDsToExclude.Add (aKey);
413       }
414     }
415   } // for ( ...
416
417   Handle(Graphic3d_AspectFillArea3d) anAsp;
418
419 //  Aspect_InteriorStyle  aStyle;
420 //  Standard_Integer      aStyleInt;
421   Aspect_TypeOfLine     anEdgeType = Aspect_TOL_SOLID;
422   Standard_Integer      anEdgeInt;
423   Standard_Real         anEdgeWidth;
424   Quantity_Color        anInteriorColor;
425   Quantity_Color        anEdgeColor, aLineColor;
426   Standard_Boolean      aShowEdges = Standard_True;
427
428   aDrawer->GetColor  ( MeshVS_DA_InteriorColor, anInteriorColor );
429   aDrawer->GetColor  ( MeshVS_DA_EdgeColor, anEdgeColor );
430   aDrawer->GetColor  ( MeshVS_DA_BeamColor, aLineColor );
431   aDrawer->GetDouble ( MeshVS_DA_EdgeWidth, anEdgeWidth );
432   aDrawer->GetBoolean( MeshVS_DA_ShowEdges, aShowEdges );
433
434   if ( aDrawer->GetInteger ( MeshVS_DA_EdgeType, anEdgeInt ) )
435     anEdgeType = (Aspect_TypeOfLine) anEdgeInt;
436
437   if ( myUseTexture )
438   {
439     Handle(Prs3d_Drawer) aPrsDrawer =  myParentMesh->Attributes();
440     if ( aPrsDrawer.IsNull() )
441       return;
442
443     aPrsDrawer->SetShadingAspect( new Prs3d_ShadingAspect() );
444     anAsp = aPrsDrawer->ShadingAspect()->Aspect();
445     if ( anAsp.IsNull() )
446       return;
447
448     anAsp->SetFrontMaterial( aMaterial[ 0 ] );
449     anAsp->SetBackMaterial( aMaterial[ 1 ] );
450
451
452     Handle(Graphic3d_Texture2D) aTexture = CreateTexture();
453     if ( aTexture.IsNull() )
454       return;
455
456     anAsp->SetTextureMapOn();
457     anAsp->SetTextureMap( aTexture );
458     anAsp->SetInteriorColor( Quantity_NOC_WHITE );
459   }
460   else
461   {
462 //    if ( aDrawer->GetInteger ( MeshVS_DA_InteriorStyle, aStyleInt ) )
463 //      aStyle = (Aspect_InteriorStyle)aStyleInt;
464
465     anAsp = new Graphic3d_AspectFillArea3d (
466       Aspect_IS_SOLID, Quantity_NOC_GRAY, anEdgeColor,
467       anEdgeType, anEdgeWidth, aMaterial[ 0 ], aMaterial[ 1 ] );
468   }
469
470   anAsp->SetDistinguishOff();
471   anAsp->SetEdgeOff();
472
473   Handle(Graphic3d_AspectLine3d) anLAsp =
474     new Graphic3d_AspectLine3d( anEdgeColor, anEdgeType, anEdgeWidth );
475
476   Prs3d_Root::NewGroup ( Prs );
477   Handle(Graphic3d_Group) aGroup1 = Prs3d_Root::CurrentGroup ( Prs );
478
479   aGroup1->SetPrimitivesAspect( anAsp );
480   aGroup1->AddPrimitiveArray( aFaceTriangles /*aCPolyArr*/ );
481   //aGroup1->AddPrimitiveArray( aCPolyArr );
482
483   if (aShowEdges)
484   {
485     Prs3d_Root::NewGroup ( Prs );
486     Handle(Graphic3d_Group) aGroup2 = Prs3d_Root::CurrentGroup ( Prs );
487
488     Handle(Graphic3d_AspectFillArea3d) anAspCopy = new Graphic3d_AspectFillArea3d (*anAsp);
489     anAspCopy->SetTextureMapOff();
490     aGroup2->SetPrimitivesAspect( anAspCopy );
491     aGroup2->SetPrimitivesAspect( anLAsp );
492     aGroup2->AddPrimitiveArray( anEdgeSegments );
493   }
494 }
495
496 //================================================================
497 // Function : AddVolumePrs
498 // Purpose  :
499 //================================================================
500 void MeshVS_NodalColorPrsBuilder::AddVolumePrs (const Handle(MeshVS_HArray1OfSequenceOfInteger)& theTopo,
501                                                 const TColStd_Array1OfInteger&                   theNodes,
502                                                 const TColStd_Array1OfReal&                      theCoords,
503                                                 const Handle(Graphic3d_ArrayOfPrimitives)&       theArray,
504                                                 const Standard_Boolean                           theIsShaded,
505                                                 const Standard_Integer                           theNbColors,
506                                                 const Standard_Integer                           theNbTexColors,
507                                                 const Standard_Real                              theColorRatio) const
508 {
509   Standard_Integer aLow = theCoords.Lower();
510
511   if (theTopo.IsNull() || theArray.IsNull())
512     return;
513
514   Standard_Boolean aIsPolygons = theArray->IsKind (STANDARD_TYPE (Graphic3d_ArrayOfTriangles));
515
516   if (aIsPolygons)
517   {    
518     for (Standard_Integer aFaceIdx = theTopo->Lower(), topoup = theTopo->Upper(); aFaceIdx <= topoup; ++aFaceIdx)
519     {
520       const TColStd_SequenceOfInteger& aFaceNodes = theTopo->Value (aFaceIdx);
521       
522       TColStd_Array1OfReal aPolyNodes (0, 3 * aFaceNodes.Length());
523
524       for (Standard_Integer aNodeIdx = 0; aNodeIdx < aFaceNodes.Length(); ++aNodeIdx)
525       {
526         Standard_Integer anIdx = aFaceNodes.Value (aNodeIdx + 1);
527
528         Standard_Real aX = theCoords.Value (aLow + 3 * anIdx + 0);
529         Standard_Real aY = theCoords.Value (aLow + 3 * anIdx + 1);
530         Standard_Real aZ = theCoords.Value (aLow + 3 * anIdx + 2);
531
532         aPolyNodes.SetValue (3 * aNodeIdx + 1, aX);
533         aPolyNodes.SetValue (3 * aNodeIdx + 2, aY);
534         aPolyNodes.SetValue (3 * aNodeIdx + 3, aZ);
535       }
536       
537       gp_Vec aNorm (0.0, 0.0, 1.0);
538
539       if (theIsShaded)
540       {
541         aPolyNodes.SetValue (0, aFaceNodes.Length());
542         
543         if (!MeshVS_Tool::GetAverageNormal (aPolyNodes, aNorm))
544         {
545           aNorm.SetCoord (0.0, 0.0, 1.0);
546         }
547       }
548
549       for (Standard_Integer aNodeIdx = 0; aNodeIdx < aFaceNodes.Length() - 2; ++aNodeIdx) // triangulate polygon
550       {
551         for (Standard_Integer aSubIdx = 0; aSubIdx < 3; ++aSubIdx) // generate sub-triangle
552         {
553           gp_Pnt aPnt (aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
554                        aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
555                        aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3));
556
557           if (myUseTexture)
558           {
559             const Standard_Real aTexCoord = myTextureCoords (theNodes (aFaceNodes (aSubIdx == 0 ? 1 : (aNodeIdx + aSubIdx + 1)) + 1));
560
561             theArray->AddVertex (aPnt, aNorm, gp_Pnt2d (
562               (aTexCoord * (theNbColors - 1.0) + 0.5) / theNbTexColors, aTexCoord < 0 || aTexCoord > 1 ? 0.25 : 0.75));
563           }
564           else
565           {
566             Quantity_Color aNColor;
567             GetColor (theNodes ((aFaceNodes (aSubIdx == 0 ? 1 : (aNodeIdx + aSubIdx + 1)) + 1)), aNColor);
568
569             if (theIsShaded)
570             {
571               aNColor.SetValues (theColorRatio * aNColor.Red(),
572                                  theColorRatio * aNColor.Green(),
573                                  theColorRatio * aNColor.Blue(),
574                                  Quantity_TOC_RGB);
575
576               theArray->AddVertex (aPnt, aNorm, aNColor);
577             }
578             else
579             {
580               theArray->AddVertex (aPnt, aNColor);
581             }
582           }
583         }
584       }
585     }
586   }
587   else
588   {
589     // Find all pairs of nodes (edges) to draw (will be drawn only once)
590     NCollection_Map<MeshVS_NodePair, MeshVS_SymmetricPairHasher> aEdgeMap;
591
592     for (Standard_Integer aFaceIdx = theTopo->Lower(), topoup = theTopo->Upper(); aFaceIdx <= topoup; ++aFaceIdx)
593     {
594       const TColStd_SequenceOfInteger& aFaceNodes = theTopo->Value (aFaceIdx);
595       
596       for (Standard_Integer aNodeIdx = 0, aNbNodes = aFaceNodes.Length(); aNodeIdx < aNbNodes; ++aNodeIdx)
597       {
598         const Standard_Integer aNextIdx = (aNodeIdx + 1) % aNbNodes;
599
600         aEdgeMap.Add (MeshVS_NodePair (aFaceNodes.Value (aNodeIdx + 1),
601                                        aFaceNodes.Value (aNextIdx + 1)));
602       }
603     }
604
605     // Draw edges
606     for(NCollection_Map<MeshVS_NodePair, MeshVS_SymmetricPairHasher>::Iterator anIt (aEdgeMap); anIt.More(); anIt.Next())
607     {      
608       const Standard_Integer anIdx1 = aLow + 3 * anIt.Key().first;
609       const Standard_Integer anIdx2 = aLow + 3 * anIt.Key().second;
610
611       Standard_Real aX[] = { theCoords.Value (anIdx1 + 0), theCoords.Value (anIdx2 + 0) };
612       Standard_Real aY[] = { theCoords.Value (anIdx1 + 1), theCoords.Value (anIdx2 + 1) };
613       Standard_Real aZ[] = { theCoords.Value (anIdx1 + 2), theCoords.Value (anIdx2 + 2) };
614
615       theArray->AddVertex (aX[0], aY[0], aZ[0]);
616       theArray->AddVertex (aX[1], aY[1], aZ[1]);
617     }
618   }
619 }
620
621 //================================================================
622 // Function : SetColors
623 // Purpose  :
624 //================================================================
625 void MeshVS_NodalColorPrsBuilder::SetColors (
626   const MeshVS_DataMapOfIntegerColor& theColorMap )
627 {
628   myNodeColorMap = theColorMap;
629 }
630
631 //================================================================
632 // Function : GetColors
633 // Purpose  :
634 //================================================================
635 const MeshVS_DataMapOfIntegerColor& MeshVS_NodalColorPrsBuilder::GetColors() const
636 {
637   return myNodeColorMap;
638 }
639
640 //================================================================
641 // Function : HasColors
642 // Purpose  :
643 //================================================================
644 Standard_Boolean MeshVS_NodalColorPrsBuilder::HasColors () const
645 {
646   return ( myNodeColorMap.Extent() >0 );
647 }
648
649 //================================================================
650 // Function : GetColor
651 // Purpose  :
652 //================================================================
653 Standard_Boolean MeshVS_NodalColorPrsBuilder::GetColor ( const Standard_Integer ID,
654                                                          Quantity_Color& theColor ) const
655 {
656   Standard_Boolean aRes = myNodeColorMap.IsBound ( ID );
657   if ( aRes )
658     theColor = myNodeColorMap.Find ( ID );
659   return aRes;
660 }
661
662 //================================================================
663 // Function : SetColor
664 // Purpose  :
665 //================================================================
666 void MeshVS_NodalColorPrsBuilder::SetColor ( const Standard_Integer theID,
667                                              const Quantity_Color& theCol )
668 {
669   Standard_Boolean aRes = myNodeColorMap.IsBound ( theID );
670   if ( aRes )
671     myNodeColorMap.ChangeFind ( theID ) = theCol;
672   else
673     myNodeColorMap.Bind ( theID, theCol );
674 }
675
676 //================================================================
677 // Function : UseTexture
678 // Purpose  : Specify whether texture must be used to build presentation
679 //================================================================
680 void MeshVS_NodalColorPrsBuilder::UseTexture( const Standard_Boolean theToUse )
681 {
682   myUseTexture = theToUse;
683   if ( myUseTexture )
684     myNodeColorMap.Clear();
685   else
686     myTextureColorMap.Clear();
687 }
688
689 //================================================================
690 // Function : IsUseTexture
691 // Purpose  : Verify whether texture is used to build presentation
692 //================================================================
693 Standard_Boolean MeshVS_NodalColorPrsBuilder::IsUseTexture() const
694 {
695   return myUseTexture;
696 }
697
698 //================================================================
699 // Function : SetColorMap
700 // Purpose  : Set colors to be used for texrture presentation.
701 //            Generate texture in accordance with given parameters
702 //================================================================
703 void MeshVS_NodalColorPrsBuilder::SetColorMap( const Aspect_SequenceOfColor& theColors )
704 {
705   myTextureColorMap = theColors;
706 }
707
708 //================================================================
709 // Function : GetColorMap
710 // Purpose  : Return colors used for texrture presentation
711 //================================================================
712 const Aspect_SequenceOfColor& MeshVS_NodalColorPrsBuilder::GetColorMap() const
713 {
714   return myTextureColorMap;
715 }
716
717 //================================================================
718 // Function : SetInvalidColor
719 // Purpose  : Set color representing invalid texture coordinate
720 //            (laying outside range [0, 1])
721 //================================================================
722 void MeshVS_NodalColorPrsBuilder::SetInvalidColor(
723   const Quantity_Color& theInvalidColor )
724 {
725   myInvalidColor = theInvalidColor;
726 }
727
728 //================================================================
729 // Function : GetInvalidColor
730 // Purpose  : Return color representing invalid texture coordinate
731 //            (laying outside range [0, 1])
732 //================================================================
733 Quantity_Color MeshVS_NodalColorPrsBuilder::GetInvalidColor() const
734 {
735   return myInvalidColor;
736 }
737
738 //================================================================
739 // Function : SetTextureCoords
740 // Purpose  : Specify correspondence between node IDs and texture
741 //            coordinates (range [0, 1])
742 //================================================================
743 void MeshVS_NodalColorPrsBuilder::SetTextureCoords (
744   const TColStd_DataMapOfIntegerReal& theMap )
745 {
746   myTextureCoords = theMap;
747 }
748
749 //================================================================
750 // Function : GetTextureCoords
751 // Purpose  : Get correspondence between node IDs and texture
752 //            coordinates (range [0, 1])
753 //================================================================
754 const TColStd_DataMapOfIntegerReal& MeshVS_NodalColorPrsBuilder::GetTextureCoords() const
755 {
756   return myTextureCoords;
757 }
758
759 //================================================================
760 // Function : SetTextureCoord
761 // Purpose  : Specify correspondence between node ID and texture
762 //            coordinate (range [0, 1])
763 //================================================================
764 void MeshVS_NodalColorPrsBuilder::SetTextureCoord( const Standard_Integer theID,
765                                                    const Standard_Real theCoord )
766 {
767   myTextureCoords.Bind( theID, theCoord );
768 }
769
770 //================================================================
771 // Function : GetTextureCoord
772 // Purpose  : Return correspondence between node IDs and texture
773 //            coordinate (range [0, 1])
774 //================================================================
775 Standard_Real MeshVS_NodalColorPrsBuilder::GetTextureCoord( const Standard_Integer theID )
776 {
777   return myTextureCoords.IsBound( theID ) ? myTextureCoords( theID ) : -1;
778 }
779
780 //================================================================
781 // Function : CreateTexture
782 // Purpose  : Create texture in accordance with myTextureColorMap
783 //================================================================
784 Handle(Graphic3d_Texture2D) MeshVS_NodalColorPrsBuilder::CreateTexture() const
785 {
786   const Standard_Integer aColorsNb = myTextureColorMap.Length();
787   if (aColorsNb == 0)
788   {
789     return NULL;
790   }
791
792   // create and fill image with colors
793   Handle(Image_PixMap) anImage = new Image_PixMap();
794   if (!anImage->InitTrash (Image_PixMap::ImgRGBA, Standard_Size(getNearestPow2 (aColorsNb)), 2))
795   {
796     return NULL;
797   }
798
799   anImage->SetTopDown (false);
800   for (Standard_Size aCol = 0; aCol < Standard_Size(aColorsNb); ++aCol)
801   {
802     const Quantity_Color& aSrcColor = myTextureColorMap.Value (Standard_Integer(aCol) + 1);
803     Image_ColorRGBA& aColor = anImage->ChangeValue<Image_ColorRGBA> (0, aCol);
804     aColor.r() = Standard_Byte(255.0 * aSrcColor.Red());
805     aColor.g() = Standard_Byte(255.0 * aSrcColor.Green());
806     aColor.b() = Standard_Byte(255.0 * aSrcColor.Blue());
807     aColor.a() = 0xFF;
808   }
809
810   // fill padding bytes
811   const Quantity_Color& aLastColorSrc = myTextureColorMap.Last();
812   const Image_ColorRGBA aLastColor =
813   {{
814     Standard_Byte(255.0 * aLastColorSrc.Red()),
815     Standard_Byte(255.0 * aLastColorSrc.Green()),
816     Standard_Byte(255.0 * aLastColorSrc.Blue()),
817     0xFF
818   }};
819
820   // fill second row
821   for (Standard_Size aCol = (Standard_Size )aColorsNb; aCol < anImage->SizeX(); ++aCol)
822   {
823     anImage->ChangeValue<Image_ColorRGBA> (0, aCol) = aLastColor;
824   }
825
826   const Image_ColorRGBA anInvalidColor =
827   {{
828     Standard_Byte(255.0 * myInvalidColor.Red()),
829     Standard_Byte(255.0 * myInvalidColor.Green()),
830     Standard_Byte(255.0 * myInvalidColor.Blue()),
831     0xFF
832   }};
833   for (Standard_Size aCol = 0; aCol < anImage->SizeX(); ++aCol)
834   {
835     anImage->ChangeValue<Image_ColorRGBA> (1, aCol) = anInvalidColor;
836   }
837
838   // create texture
839   return new MeshVS_ImageTexture2D (anImage);
840 }