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 to get the required colors
 193   Graphic3d_MaterialAspect aMaterial[2] = { Graphic3d_NOM_PLASTIC, Graphic3d_NOM_PLASTIC };
 194   for (Standard_Integer i = 0; i < 2; ++i)
 195   {
 196     aMaterial[i].SetSpecularColor (Quantity_NOC_BLACK);
 197     aMaterial[i].SetEmissiveColor (Quantity_NOC_BLACK);
 198     if ( !IsReflect )
 199     {
 200       aMaterial[i].SetAmbientColor (Quantity_NOC_BLACK);
 201       aMaterial[i].SetDiffuseColor (Quantity_NOC_BLACK);
 202     }
 203     else{
 204       // OCC20644 Using the material with reflection properties same as in
 205       // ElementalColorPrsBuilder, to get the same colors.
 206       // Additionally, ambient and diffuse coefficients are used below to scale incoming colors,
 207       // to simulate TelUpdateMaterial() function from OpenGl_attri.c.
 208       // This is mandatory, as these "scaled" colors are then passed directly to OpenGL
 209       // as ambient and diffuse colors of the current material using glColorMaterial().
 210       // In ElementalColorPrsBuilder we do not need to do scale the colors, as this
 211       // is done by TelUpdateMaterial().
 212       // 0.5 is used to have the colors in 3D maximally similar to those in the color scale.
 213       // This is possible when the sum of all coefficient is equal to 1.
 214       aMaterial[i].SetAmbientColor (Quantity_Color (Graphic3d_Vec3 (0.5f)));
 215       aMaterial[i].SetDiffuseColor (Quantity_Color (Graphic3d_Vec3 (0.5f)));
 216     }
 217   }
 218
 219   // Create array of polygons for interior presentation of faces and volumes
 220   Handle(Graphic3d_ArrayOfPolygons) aCPolyArr = new Graphic3d_ArrayOfPolygons
 221     ( aMaxFaceNodes * aSize + PolygonVerticesFor3D, aSize + PolygonBoundsFor3D,
 222     0, myUseTexture || IsReflect, !myUseTexture, Standard_False, myUseTexture );
 223
 224     Standard_Integer aNbFacePrimitives = 0;
 225     Standard_Integer aNbVolmPrimitives = 0;
 226     Standard_Integer aNbEdgePrimitives = 0;
 227     Standard_Integer aNbLinkPrimitives = 0;
 228
 229     for (it.Reset(); it.More(); it.Next())
 230     {
 231       Standard_Integer aNbNodes = 0;
 232
 233       if (!aSource->GetGeom (it.Key(), Standard_True, aCoords, aNbNodes, aType))
 234         continue;
 235
 236       if (aType == MeshVS_ET_Volume)
 237       {
 238         if (aSource->Get3DGeom (it.Key(), aNbNodes, aTopo))
 239         {
 240           for (Standard_Integer aFaceIdx = aTopo->Lower(); aFaceIdx <= aTopo->Upper(); ++aFaceIdx)
 241           {
 242             const TColStd_SequenceOfInteger& aFaceNodes = aTopo->Value (aFaceIdx);
 243
 244             aNbEdgePrimitives += aFaceNodes.Length();     // add edge segments
 245             aNbVolmPrimitives += aFaceNodes.Length() - 2; // add volumetric cell triangles
 246           }
 247         }
 248       }
 249       else if (aType == MeshVS_ET_Link)
 250       {
 251         aNbLinkPrimitives += aNbNodes - 1; // add link segments
 252       }
 253       else if (aType == MeshVS_ET_Face)
 254       {
 255         aNbEdgePrimitives += aNbNodes;     // add edge segments
 256         aNbFacePrimitives += aNbNodes - 2; // add face triangles
 257       }
 258     }
 259
 260   // Here we do not use indices arrays because they are not effective for some mesh
 261   // drawing modes: shrinking mode (displaces the vertices inside the polygon), 3D
 262   // cell rendering (normal interpolation is not always applicable - flat shading),
 263   // elemental coloring (color interpolation is impossible)
 264
 265   // Create array of polygons for interior presentation of faces and volumes
 266   Handle(Graphic3d_ArrayOfTriangles) aFaceTriangles = new Graphic3d_ArrayOfTriangles
 267     ( (aNbFacePrimitives + aNbVolmPrimitives) * 3, 0, myUseTexture || IsReflect, !myUseTexture, myUseTexture );
 268
 269   // Create array of polylines for presentation of edges
 270   Handle(Graphic3d_ArrayOfSegments) anEdgeSegments = new Graphic3d_ArrayOfSegments
 271     (aNbEdgePrimitives * 2);
 272
 273   gp_Pnt P, Start;
 274   Standard_Real aMin = gp::Resolution() * gp::Resolution();
 275   gp_Dir aDefNorm( 0., 0., 1. );
 276
 277   // Prepare for scaling the incoming colors
 278   const Standard_Real anColorRatio = !IsReflect ? 0.44f : 0.5f;
 279
 280   for (it.Reset(); it.More(); it.Next())
 281   {
 282     Standard_Integer aKey = it.Key();
 283
 284     if (aSource->GetGeom (aKey, Standard_True, aCoords, NbNodes, aType))
 285     {
 286       TColStd_Array1OfInteger aNodes (1, NbNodes);
 287
 288       if (!aSource->GetNodesByElement (aKey, aNodes, NbNodes))
 289         continue;
 290
 291       Quantity_Color aNColor;
 292
 293       Standard_Boolean isValid = Standard_True;
 294
 295       if (myUseTexture)
 296       {
 297         for (Standard_Integer k = 1; k <= NbNodes && isValid; ++k)
 298           isValid = myTextureCoords.IsBound (aNodes (k));
 299       }
 300       else
 301       {
 302         for (Standard_Integer k = 1; k <= NbNodes && isValid; ++k)
 303           isValid = GetColor (aNodes (k), aNColor);
 304       }
 305
 306       if (!isValid)
 307         continue;
 308
 309       // Preparing normal(s) to show reflections if requested
 310       Handle(TColStd_HArray1OfReal) aNormals;
 311
 312       Standard_Boolean hasNormals =
 313         (IsReflect && aSource->GetNormalsByElement (aKey, IsMeshSmoothShading, aMaxFaceNodes, aNormals));
 314
 315       if (aType == MeshVS_ET_Face)
 316       {
 317         for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes - 2; ++aNodeIdx) // triangulate polygon
 318         {
 319           for (Standard_Integer aSubIdx = 0; aSubIdx < 3; ++aSubIdx) // generate sub-triangle
 320           {
 321             gp_XYZ aPnt (aCoords (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
 322                          aCoords (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
 323                          aCoords (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3));
 324
 325             gp_Vec aNorm = aDefNorm;
 326
 327             if (hasNormals)
 328             {
 329               gp_Vec aTestNorm (aNormals->Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
 330                                 aNormals->Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
 331                                 aNormals->Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3));
 332
 333               if (aTestNorm.SquareMagnitude() > aMin)
 334               {
 335                 aNorm = gp_Dir (aTestNorm);
 336               }
 337             }
 338
 339             if (myUseTexture)
 340             {
 341               const Standard_Real aTexCoord = myTextureCoords (aNodes (aSubIdx == 0 ? 1 : (aNodeIdx + aSubIdx + 1)));
 342
 343               // Transform texture coordinate in accordance with number of colors specified
 344               // by upper level and real size of OpenGL texture. The OpenGL texture has border
 345               // colors interpolated with the colors from the color map, thats why we need to
 346               // shrink texture coordinates around the middle point to exclude areas where the
 347               // map colors are interpolated with the borders color
 348               aFaceTriangles->AddVertex (aPnt, aNorm, gp_Pnt2d (
 349                 (aTexCoord * (nbColors - 1.0) + 0.5) / nbTextureColors, aTexCoord < 0 || aTexCoord > 1 ? 0.25 : 0.75));
 350             }
 351             else
 352             {
 353               GetColor (aNodes (aSubIdx == 0 ? 1 : (aNodeIdx + aSubIdx + 1)), aNColor);
 354
 355               if (IsReflect)
 356               {
 357                 aNColor.SetValues (anColorRatio * aNColor.Red(),
 358                                    anColorRatio * aNColor.Green(),
 359                                    anColorRatio * aNColor.Blue(),
 360                                    Quantity_TOC_RGB);
 361
 362                 aFaceTriangles->AddVertex (aPnt, aNorm, aNColor);
 363               }
 364               else
 365               {
 366                 aFaceTriangles->AddVertex (aPnt, aNColor);
 367               }
 368             }
 369           }
 370         }
 371
 372         for (Standard_Integer aNodeIdx = 0; aNodeIdx < NbNodes; ++aNodeIdx) // border segmentation
 373         {
 374           const Standard_Integer aNextIdx = (aNodeIdx + 1) % NbNodes;
 375
 376           anEdgeSegments->AddVertex (aCoords (3 * aNodeIdx + 1),
 377                                      aCoords (3 * aNodeIdx + 2),
 378                                      aCoords (3 * aNodeIdx + 3));
 379
 380           anEdgeSegments->AddVertex (aCoords (3 * aNextIdx + 1),
 381                                      aCoords (3 * aNextIdx + 2),
 382                                      aCoords (3 * aNextIdx + 3));
 383         }
 384
 385         // if IsExcludingOn then presentation must not be built by other builders
 386         if (IsExcludingOn())
 387         {
 388           IDsToExclude.Add (aKey);
 389         }
 390       }
 391       else if (aType == MeshVS_ET_Volume)
 392       {
 393         if (!aSource->Get3DGeom (aKey, NbNodes, aTopo))
 394           continue;
 395
 396         AddVolumePrs (aTopo, aNodes, aCoords, aFaceTriangles,
 397           IsReflect, nbColors, nbTextureColors, anColorRatio);
 398
 399         AddVolumePrs (aTopo, aNodes, aCoords, anEdgeSegments,
 400           IsReflect, nbColors, nbTextureColors, anColorRatio);
 401
 402         // if IsExcludingOn then presentation must not be built by other builders
 403         if (IsExcludingOn())
 404           IDsToExclude.Add (aKey);
 405       }
 406     }
 407   } // for ( ...
 408
 409   Handle(Graphic3d_AspectFillArea3d) anAsp;
 410
 411 //  Aspect_InteriorStyle  aStyle;
 412 //  Standard_Integer      aStyleInt;
 413   Aspect_TypeOfLine     anEdgeType = Aspect_TOL_SOLID;
 414   Standard_Real         anEdgeWidth = 1.0;
 415   Quantity_Color        anInteriorColor;
 416   Quantity_Color        anEdgeColor, aLineColor;
 417   Standard_Boolean      aShowEdges = Standard_True;
 418
 419   aDrawer->GetColor  ( MeshVS_DA_InteriorColor, anInteriorColor );
 420   aDrawer->GetColor  ( MeshVS_DA_EdgeColor, anEdgeColor );
 421   aDrawer->GetColor  ( MeshVS_DA_BeamColor, aLineColor );
 422   aDrawer->GetDouble ( MeshVS_DA_EdgeWidth, anEdgeWidth );
 423   aDrawer->GetBoolean( MeshVS_DA_ShowEdges, aShowEdges );
 424
 425   Standard_Integer anEdgeInt = Aspect_TOL_SOLID;
 426   if ( aDrawer->GetInteger ( MeshVS_DA_EdgeType, anEdgeInt ) )
 427     anEdgeType = (Aspect_TypeOfLine) anEdgeInt;
 428
 429   if ( myUseTexture )
 430   {
 431     Handle(Prs3d_Drawer) aPrsDrawer =  myParentMesh->Attributes();
 432     if ( aPrsDrawer.IsNull() )
 433       return;
 434
 435     aPrsDrawer->SetShadingAspect( new Prs3d_ShadingAspect() );
 436     anAsp = aPrsDrawer->ShadingAspect()->Aspect();
 437     if ( anAsp.IsNull() )
 438       return;
 439
 440     anAsp->SetFrontMaterial( aMaterial[ 0 ] );
 441     anAsp->SetBackMaterial( aMaterial[ 1 ] );
 442
 443
 444     Handle(Graphic3d_Texture2D) aTexture = CreateTexture();
 445     if ( aTexture.IsNull() )
 446       return;
 447
 448     anAsp->SetTextureMapOn();
 449     anAsp->SetTextureMap( aTexture );
 450     anAsp->SetInteriorColor( Quantity_NOC_WHITE );
 451   }
 452   else
 453   {
 454 //    if ( aDrawer->GetInteger ( MeshVS_DA_InteriorStyle, aStyleInt ) )
 455 //      aStyle = (Aspect_InteriorStyle)aStyleInt;
 456
 457     anAsp = new Graphic3d_AspectFillArea3d (
 458       Aspect_IS_SOLID, Quantity_NOC_GRAY, anEdgeColor,
 459       anEdgeType, anEdgeWidth, aMaterial[ 0 ], aMaterial[ 1 ] );
 460   }
 461
 462   anAsp->SetDistinguishOff();
 463   anAsp->SetEdgeOff();
 464
 465   Handle(Graphic3d_AspectLine3d) anLAsp =
 466     new Graphic3d_AspectLine3d( anEdgeColor, anEdgeType, anEdgeWidth );
 467
 468   Handle(Graphic3d_Group) aGroup1 = Prs3d_Root::NewGroup (Prs);
 469
 470   Standard_Boolean toSupressBackFaces = Standard_False;
 471   aDrawer->GetBoolean (MeshVS_DA_SupressBackFaces, toSupressBackFaces);
 472   aGroup1->SetClosed (toSupressBackFaces == Standard_True);
 473
 474   aGroup1->SetPrimitivesAspect( anAsp );
 475   aGroup1->AddPrimitiveArray( aFaceTriangles /*aCPolyArr*/ );
 476   //aGroup1->AddPrimitiveArray( aCPolyArr );
 477
 478   if (aShowEdges)
 479   {
 480     Prs3d_Root::NewGroup ( Prs );
 481     Handle(Graphic3d_Group) aGroup2 = Prs3d_Root::CurrentGroup ( Prs );
 482
 483     Handle(Graphic3d_AspectFillArea3d) anAspCopy = new Graphic3d_AspectFillArea3d (*anAsp);
 484     anAspCopy->SetTextureMapOff();
 485     aGroup2->SetPrimitivesAspect( anAspCopy );
 486     aGroup2->SetPrimitivesAspect( anLAsp );
 487     aGroup2->AddPrimitiveArray( anEdgeSegments );
 488   }
 489 }
 490
 491 //================================================================
 492 // Function : AddVolumePrs
 493 // Purpose  :
 494 //================================================================
 495 void MeshVS_NodalColorPrsBuilder::AddVolumePrs (const Handle(MeshVS_HArray1OfSequenceOfInteger)& theTopo,
 496                                                 const TColStd_Array1OfInteger&                   theNodes,
 497                                                 const TColStd_Array1OfReal&                      theCoords,
 498                                                 const Handle(Graphic3d_ArrayOfPrimitives)&       theArray,
 499                                                 const Standard_Boolean                           theIsShaded,
 500                                                 const Standard_Integer                           theNbColors,
 501                                                 const Standard_Integer                           theNbTexColors,
 502                                                 const Standard_Real                              theColorRatio) const
 503 {
 504   Standard_Integer aLow = theCoords.Lower();
 505
 506   if (theTopo.IsNull() || theArray.IsNull())
 507     return;
 508
 509   Standard_Boolean aIsPolygons = theArray->IsKind (STANDARD_TYPE (Graphic3d_ArrayOfTriangles));
 510
 511   if (aIsPolygons)
 512   {
 513     for (Standard_Integer aFaceIdx = theTopo->Lower(), topoup = theTopo->Upper(); aFaceIdx <= topoup; ++aFaceIdx)
 514     {
 515       const TColStd_SequenceOfInteger& aFaceNodes = theTopo->Value (aFaceIdx);
 516
 517       TColStd_Array1OfReal aPolyNodes (0, 3 * aFaceNodes.Length());
 518
 519       for (Standard_Integer aNodeIdx = 0; aNodeIdx < aFaceNodes.Length(); ++aNodeIdx)
 520       {
 521         Standard_Integer anIdx = aFaceNodes.Value (aNodeIdx + 1);
 522
 523         Standard_Real aX = theCoords.Value (aLow + 3 * anIdx + 0);
 524         Standard_Real aY = theCoords.Value (aLow + 3 * anIdx + 1);
 525         Standard_Real aZ = theCoords.Value (aLow + 3 * anIdx + 2);
 526
 527         aPolyNodes.SetValue (3 * aNodeIdx + 1, aX);
 528         aPolyNodes.SetValue (3 * aNodeIdx + 2, aY);
 529         aPolyNodes.SetValue (3 * aNodeIdx + 3, aZ);
 530       }
 531
 532       gp_Vec aNorm (0.0, 0.0, 1.0);
 533
 534       if (theIsShaded)
 535       {
 536         aPolyNodes.SetValue (0, aFaceNodes.Length());
 537
 538         if (!MeshVS_Tool::GetAverageNormal (aPolyNodes, aNorm))
 539         {
 540           aNorm.SetCoord (0.0, 0.0, 1.0);
 541         }
 542       }
 543
 544       for (Standard_Integer aNodeIdx = 0; aNodeIdx < aFaceNodes.Length() - 2; ++aNodeIdx) // triangulate polygon
 545       {
 546         for (Standard_Integer aSubIdx = 0; aSubIdx < 3; ++aSubIdx) // generate sub-triangle
 547         {
 548           gp_Pnt aPnt (aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 1),
 549                        aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 2),
 550                        aPolyNodes.Value (3 * (aSubIdx == 0 ? 0 : (aNodeIdx + aSubIdx)) + 3));
 551
 552           if (myUseTexture)
 553           {
 554             const Standard_Real aTexCoord = myTextureCoords (theNodes (aFaceNodes (aSubIdx == 0 ? 1 : (aNodeIdx + aSubIdx + 1)) + 1));
 555
 556             theArray->AddVertex (aPnt, aNorm, gp_Pnt2d (
 557               (aTexCoord * (theNbColors - 1.0) + 0.5) / theNbTexColors, aTexCoord < 0 || aTexCoord > 1 ? 0.25 : 0.75));
 558           }
 559           else
 560           {
 561             Quantity_Color aNColor;
 562             GetColor (theNodes ((aFaceNodes (aSubIdx == 0 ? 1 : (aNodeIdx + aSubIdx + 1)) + 1)), aNColor);
 563
 564             if (theIsShaded)
 565             {
 566               aNColor.SetValues (theColorRatio * aNColor.Red(),
 567                                  theColorRatio * aNColor.Green(),
 568                                  theColorRatio * aNColor.Blue(),
 569                                  Quantity_TOC_RGB);
 570
 571               theArray->AddVertex (aPnt, aNorm, aNColor);
 572             }
 573             else
 574             {
 575               theArray->AddVertex (aPnt, aNColor);
 576             }
 577           }
 578         }
 579       }
 580     }
 581   }
 582   else
 583   {
 584     // Find all pairs of nodes (edges) to draw (will be drawn only once)
 585     NCollection_Map<MeshVS_NodePair, MeshVS_SymmetricPairHasher> aEdgeMap;
 586
 587     for (Standard_Integer aFaceIdx = theTopo->Lower(), topoup = theTopo->Upper(); aFaceIdx <= topoup; ++aFaceIdx)
 588     {
 589       const TColStd_SequenceOfInteger& aFaceNodes = theTopo->Value (aFaceIdx);
 590
 591       for (Standard_Integer aNodeIdx = 0, aNbNodes = aFaceNodes.Length(); aNodeIdx < aNbNodes; ++aNodeIdx)
 592       {
 593         const Standard_Integer aNextIdx = (aNodeIdx + 1) % aNbNodes;
 594
 595         aEdgeMap.Add (MeshVS_NodePair (aFaceNodes.Value (aNodeIdx + 1),
 596                                        aFaceNodes.Value (aNextIdx + 1)));
 597       }
 598     }
 599
 600     // Draw edges
 601     for(NCollection_Map<MeshVS_NodePair, MeshVS_SymmetricPairHasher>::Iterator anIt (aEdgeMap); anIt.More(); anIt.Next())
 602     {
 603       const Standard_Integer anIdx1 = aLow + 3 * anIt.Key().first;
 604       const Standard_Integer anIdx2 = aLow + 3 * anIt.Key().second;
 605
 606       Standard_Real aX[] = { theCoords.Value (anIdx1 + 0), theCoords.Value (anIdx2 + 0) };
 607       Standard_Real aY[] = { theCoords.Value (anIdx1 + 1), theCoords.Value (anIdx2 + 1) };
 608       Standard_Real aZ[] = { theCoords.Value (anIdx1 + 2), theCoords.Value (anIdx2 + 2) };
 609
 610       theArray->AddVertex (aX[0], aY[0], aZ[0]);
 611       theArray->AddVertex (aX[1], aY[1], aZ[1]);
 612     }
 613   }
 614 }
 615
 616 //================================================================
 617 // Function : SetColors
 618 // Purpose  :
 619 //================================================================
 620 void MeshVS_NodalColorPrsBuilder::SetColors (
 621   const MeshVS_DataMapOfIntegerColor& theColorMap )
 622 {
 623   myNodeColorMap = theColorMap;
 624 }
 625
 626 //================================================================
 627 // Function : GetColors
 628 // Purpose  :
 629 //================================================================
 630 const MeshVS_DataMapOfIntegerColor& MeshVS_NodalColorPrsBuilder::GetColors() const
 631 {
 632   return myNodeColorMap;
 633 }
 634
 635 //================================================================
 636 // Function : HasColors
 637 // Purpose  :
 638 //================================================================
 639 Standard_Boolean MeshVS_NodalColorPrsBuilder::HasColors () const
 640 {
 641   return ( myNodeColorMap.Extent() >0 );
 642 }
 643
 644 //================================================================
 645 // Function : GetColor
 646 // Purpose  :
 647 //================================================================
 648 Standard_Boolean MeshVS_NodalColorPrsBuilder::GetColor ( const Standard_Integer ID,
 649                                                          Quantity_Color& theColor ) const
 650 {
 651   Standard_Boolean aRes = myNodeColorMap.IsBound ( ID );
 652   if ( aRes )
 653     theColor = myNodeColorMap.Find ( ID );
 654   return aRes;
 655 }
 656
 657 //================================================================
 658 // Function : SetColor
 659 // Purpose  :
 660 //================================================================
 661 void MeshVS_NodalColorPrsBuilder::SetColor ( const Standard_Integer theID,
 662                                              const Quantity_Color& theCol )
 663 {
 664   Standard_Boolean aRes = myNodeColorMap.IsBound ( theID );
 665   if ( aRes )
 666     myNodeColorMap.ChangeFind ( theID ) = theCol;
 667   else
 668     myNodeColorMap.Bind ( theID, theCol );
 669 }
 670
 671 //================================================================
 672 // Function : UseTexture
 673 // Purpose  : Specify whether texture must be used to build presentation
 674 //================================================================
 675 void MeshVS_NodalColorPrsBuilder::UseTexture( const Standard_Boolean theToUse )
 676 {
 677   myUseTexture = theToUse;
 678   if ( myUseTexture )
 679     myNodeColorMap.Clear();
 680   else
 681     myTextureColorMap.Clear();
 682 }
 683
 684 //================================================================
 685 // Function : IsUseTexture
 686 // Purpose  : Verify whether texture is used to build presentation
 687 //================================================================
 688 Standard_Boolean MeshVS_NodalColorPrsBuilder::IsUseTexture() const
 689 {
 690   return myUseTexture;
 691 }
 692
 693 //================================================================
 694 // Function : SetColorMap
 695 // Purpose  : Set colors to be used for texrture presentation.
 696 //            Generate texture in accordance with given parameters
 697 //================================================================
 698 void MeshVS_NodalColorPrsBuilder::SetColorMap( const Aspect_SequenceOfColor& theColors )
 699 {
 700   myTextureColorMap = theColors;
 701 }
 702
 703 //================================================================
 704 // Function : GetColorMap
 705 // Purpose  : Return colors used for texrture presentation
 706 //================================================================
 707 const Aspect_SequenceOfColor& MeshVS_NodalColorPrsBuilder::GetColorMap() const
 708 {
 709   return myTextureColorMap;
 710 }
 711
 712 //================================================================
 713 // Function : SetInvalidColor
 714 // Purpose  : Set color representing invalid texture coordinate
 715 //            (laying outside range [0, 1])
 716 //================================================================
 717 void MeshVS_NodalColorPrsBuilder::SetInvalidColor(
 718   const Quantity_Color& theInvalidColor )
 719 {
 720   myInvalidColor = theInvalidColor;
 721 }
 722
 723 //================================================================
 724 // Function : GetInvalidColor
 725 // Purpose  : Return color representing invalid texture coordinate
 726 //            (laying outside range [0, 1])
 727 //================================================================
 728 Quantity_Color MeshVS_NodalColorPrsBuilder::GetInvalidColor() const
 729 {
 730   return myInvalidColor;
 731 }
 732
 733 //================================================================
 734 // Function : SetTextureCoords
 735 // Purpose  : Specify correspondence between node IDs and texture
 736 //            coordinates (range [0, 1])
 737 //================================================================
 738 void MeshVS_NodalColorPrsBuilder::SetTextureCoords (
 739   const TColStd_DataMapOfIntegerReal& theMap )
 740 {
 741   myTextureCoords = theMap;
 742 }
 743
 744 //================================================================
 745 // Function : GetTextureCoords
 746 // Purpose  : Get correspondence between node IDs and texture
 747 //            coordinates (range [0, 1])
 748 //================================================================
 749 const TColStd_DataMapOfIntegerReal& MeshVS_NodalColorPrsBuilder::GetTextureCoords() const
 750 {
 751   return myTextureCoords;
 752 }
 753
 754 //================================================================
 755 // Function : SetTextureCoord
 756 // Purpose  : Specify correspondence between node ID and texture
 757 //            coordinate (range [0, 1])
 758 //================================================================
 759 void MeshVS_NodalColorPrsBuilder::SetTextureCoord( const Standard_Integer theID,
 760                                                    const Standard_Real theCoord )
 761 {
 762   myTextureCoords.Bind( theID, theCoord );
 763 }
 764
 765 //================================================================
 766 // Function : GetTextureCoord
 767 // Purpose  : Return correspondence between node IDs and texture
 768 //            coordinate (range [0, 1])
 769 //================================================================
 770 Standard_Real MeshVS_NodalColorPrsBuilder::GetTextureCoord( const Standard_Integer theID )
 771 {
 772   return myTextureCoords.IsBound( theID ) ? myTextureCoords( theID ) : -1;
 773 }
 774
 775 //================================================================
 776 // Function : CreateTexture
 777 // Purpose  : Create texture in accordance with myTextureColorMap
 778 //================================================================
 779 Handle(Graphic3d_Texture2D) MeshVS_NodalColorPrsBuilder::CreateTexture() const
 780 {
 781   const Standard_Integer aColorsNb = myTextureColorMap.Length();
 782   if (aColorsNb == 0)
 783   {
 784     return NULL;
 785   }
 786
 787   // create and fill image with colors
 788   Handle(Image_PixMap) anImage = new Image_PixMap();
 789   if (!anImage->InitTrash (Image_Format_RGBA, Standard_Size(getNearestPow2 (aColorsNb)), 2))
 790   {
 791     return NULL;
 792   }
 793
 794   anImage->SetTopDown (false);
 795   for (Standard_Size aCol = 0; aCol < Standard_Size(aColorsNb); ++aCol)
 796   {
 797     const Quantity_Color& aSrcColor = myTextureColorMap.Value (Standard_Integer(aCol) + 1);
 798     Image_ColorRGBA& aColor = anImage->ChangeValue<Image_ColorRGBA> (0, aCol);
 799     aColor.r() = Standard_Byte(255.0 * aSrcColor.Red());
 800     aColor.g() = Standard_Byte(255.0 * aSrcColor.Green());
 801     aColor.b() = Standard_Byte(255.0 * aSrcColor.Blue());
 802     aColor.a() = 0xFF;
 803   }
 804
 805   // fill padding bytes
 806   const Quantity_Color& aLastColorSrc = myTextureColorMap.Last();
 807   const Image_ColorRGBA aLastColor =
 808   {{
 809     Standard_Byte(255.0 * aLastColorSrc.Red()),
 810     Standard_Byte(255.0 * aLastColorSrc.Green()),
 811     Standard_Byte(255.0 * aLastColorSrc.Blue()),
 812     0xFF
 813   }};
 814
 815   // fill second row
 816   for (Standard_Size aCol = (Standard_Size )aColorsNb; aCol < anImage->SizeX(); ++aCol)
 817   {
 818     anImage->ChangeValue<Image_ColorRGBA> (0, aCol) = aLastColor;
 819   }
 820
 821   const Image_ColorRGBA anInvalidColor =
 822   {{
 823     Standard_Byte(255.0 * myInvalidColor.Red()),
 824     Standard_Byte(255.0 * myInvalidColor.Green()),
 825     Standard_Byte(255.0 * myInvalidColor.Blue()),
 826     0xFF
 827   }};
 828   for (Standard_Size aCol = 0; aCol < anImage->SizeX(); ++aCol)
 829   {
 830     anImage->ChangeValue<Image_ColorRGBA> (1, aCol) = anInvalidColor;
 831   }
 832
 833   // create texture
 834   return new MeshVS_ImageTexture2D (anImage);
 835 }