src/VrmlData/VrmlData_ShapeConvert.cxx

   1 // Created on: 2007-08-04
   2 // Created by: Alexander GRIGORIEV
   3 // Copyright (c) 2007-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it 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 #include <VrmlData_ShapeConvert.hxx>
  17 #include <VrmlData_Scene.hxx>
  18 #include <VrmlData_Group.hxx>
  19 #include <VrmlData_Coordinate.hxx>
  20 #include <VrmlData_IndexedFaceSet.hxx>
  21 #include <VrmlData_IndexedLineSet.hxx>
  22 #include <VrmlData_ShapeNode.hxx>
  23 #include <BRep_Builder.hxx>
  24 #include <BRep_Tool.hxx>
  25 #include <Geom_Surface.hxx>
  26 #include <NCollection_DataMap.hxx>
  27 #include <Poly_Triangulation.hxx>
  28 #include <Poly_Connect.hxx>
  29 #include <Poly_PolygonOnTriangulation.hxx>
  30 #include <Poly_Polygon3D.hxx>
  31 #include <Precision.hxx>
  32 #include <Quantity_ColorRGBA.hxx>
  33 #include <TColgp_Array1OfPnt2d.hxx>
  34 #include <TDataStd_Name.hxx>
  35 #include <TDF_Label.hxx>
  36 //#include <TDF_LabelSequence.hxx>
  37 #include <TDocStd_Document.hxx>
  38 #include <TopExp_Explorer.hxx>
  39 #include <TopoDS.hxx>
  40 #include <TopoDS_Edge.hxx>
  41 #include <TopoDS_Face.hxx>
  42 #include <TopoDS_Shape.hxx>
  43 #include <TopoDS_Wire.hxx>
  44 #include <GCPnts_TangentialDeflection.hxx>
  45 #include <BRepAdaptor_Curve.hxx>
  46 #include <TColStd_Array1OfReal.hxx>
  47 #include <TColStd_HArray1OfReal.hxx>
  48 #include <TShort_Array1OfShortReal.hxx>
  49 #include <GeomLib.hxx>
  50 #include <TShort_HArray1OfShortReal.hxx>
  51 #include <VrmlData_Appearance.hxx>
  52 #include <XCAFDoc_ColorTool.hxx>
  53 #include <XCAFDoc_DocumentTool.hxx>
  54 #include <XCAFDoc_ShapeTool.hxx>
  55 #include <XCAFPrs_Style.hxx>
  56 #include <XCAFDoc_VisMaterial.hxx>
  57 #include <XCAFDoc_VisMaterialTool.hxx>
  58
  59 //=======================================================================
  60 //function : AddShape
  61 //purpose  :
  62 //=======================================================================
  63
  64 void VrmlData_ShapeConvert::AddShape (const TopoDS_Shape& theShape,
  65                                       const char *        theName)
  66 {
  67   ShapeData aData;/* = { - compilation problem on SUN
  68     TCollection_AsciiString(),
  69     theShape,
  70     NULL
  71   };*/
  72   aData.Shape = theShape;
  73   aData.Node = NULL;
  74
  75   if (theName) {
  76     char buf[2048], * optr = &buf[0];
  77     char * eptr = &buf[sizeof(buf)-1];
  78     for (const char * ptr = theName;; ptr++) {
  79       char sym = *ptr;
  80       if (sym == '\0' || sym == '\n' || sym == '\r') {
  81         * optr = '\0';
  82         break;
  83       }
  84       if (sym == '\"' || sym == '\\')
  85         * optr = '/';
  86       else if (sym == '.')
  87         * optr = '_';
  88       else
  89         * optr = sym;
  90       if (++optr >= eptr) {
  91         *optr = '\0';
  92         break;
  93       }
  94     }
  95     aData.Name = buf;
  96   }
  97   myShapes.Append (aData);
  98 }
  99
 100
 101 //=======================================================================
 102 //function : makeTShapeNode
 103 //purpose  : auxilary
 104 //=======================================================================
 105 Handle(VrmlData_Geometry) VrmlData_ShapeConvert::makeTShapeNode(const TopoDS_Shape& theShape,
 106                                                                 const TopAbs_ShapeEnum theShapeType,
 107                                                                 TopLoc_Location& theLoc)
 108 {
 109   Handle(VrmlData_Geometry) aTShapeNode = 0L;
 110   const Standard_Boolean isReverse = (theShape.Orientation() == TopAbs_REVERSED);
 111
 112   TopoDS_Shape aTestedShape;
 113   aTestedShape.TShape(theShape.TShape());
 114   aTestedShape.Orientation(isReverse ? TopAbs_REVERSED : TopAbs_FORWARD);
 115   switch (theShapeType) {
 116   case TopAbs_FACE:
 117   {
 118     const TopoDS_Face& aFace = TopoDS::Face(theShape);
 119     if (aFace.IsNull() == Standard_False) {
 120       Handle(Poly_Triangulation) aTri =
 121         BRep_Tool::Triangulation(aFace, theLoc);
 122
 123       if (myRelMap.IsBound(aTestedShape)) {
 124         aTShapeNode = myRelMap(aTestedShape);
 125         break;
 126       }
 127
 128       if (aTri.IsNull() == Standard_False) {
 129         TopoDS_Shape aTestedShapeRev = aTestedShape;
 130         aTestedShapeRev.Orientation(isReverse ?
 131           TopAbs_FORWARD : TopAbs_REVERSED);
 132         Handle(VrmlData_IndexedFaceSet) aFaceSetToReuse;
 133         if (myRelMap.IsBound(aTestedShapeRev))
 134           aFaceSetToReuse = Handle(VrmlData_IndexedFaceSet)::DownCast
 135           (myRelMap(aTestedShapeRev));
 136
 137         Handle(VrmlData_Coordinate) aCoordToReuse;
 138         if (aFaceSetToReuse.IsNull() == Standard_False)
 139           aCoordToReuse = aFaceSetToReuse->Coordinates();
 140
 141         aTShapeNode = triToIndexedFaceSet(aTri, aFace, aCoordToReuse);
 142         myScene.AddNode(aTShapeNode, Standard_False);
 143         // Bind the converted face
 144         myRelMap.Bind(aTestedShape, aTShapeNode);
 145       }
 146     }
 147   }
 148   break;
 149   case TopAbs_WIRE:
 150   {
 151     const TopoDS_Wire& aWire = TopoDS::Wire(theShape);
 152     if (aWire.IsNull() == Standard_False) {
 153     }
 154   }
 155   break;
 156   case TopAbs_EDGE:
 157   {
 158     const TopoDS_Edge& aEdge = TopoDS::Edge(theShape);
 159     if (aEdge.IsNull() == Standard_False) {
 160       if (myRelMap.IsBound(aTestedShape)) {
 161         aTShapeNode = myRelMap(aTestedShape);
 162         break;
 163       }
 164       // Check the presence of reversly oriented Edge. It can also be used
 165       // because we do not distinguish the orientation for edges.
 166       aTestedShape.Orientation(isReverse ?
 167         TopAbs_FORWARD : TopAbs_REVERSED);
 168       if (myRelMap.IsBound(aTestedShape)) {
 169         aTShapeNode = myRelMap(aTestedShape);
 170         break;
 171       }
 172
 173       //try to find PolygonOnTriangulation
 174       Handle(Poly_PolygonOnTriangulation) aPT;
 175       Handle(Poly_Triangulation) aT;
 176       TopLoc_Location aL;
 177       BRep_Tool::PolygonOnTriangulation(aEdge, aPT, aT, aL);
 178
 179       // If PolygonOnTriangulation was found -> get the Polygon3D
 180       Handle(Poly_Polygon3D) aPol;
 181       if (!aPT.IsNull() && !aT.IsNull() && aPT->HasParameters()) {
 182         BRepAdaptor_Curve aCurve(aEdge);
 183         Handle(TColStd_HArray1OfReal) aPrs = aPT->Parameters();
 184         Standard_Integer nbNodes = aPT->NbNodes();
 185         TColgp_Array1OfPnt arrNodes(1, nbNodes);
 186         TColStd_Array1OfReal arrUVNodes(1, nbNodes);
 187
 188         for (Standard_Integer j = 1; j <= nbNodes; j++) {
 189           arrUVNodes(j) = aPrs->Value(aPrs->Lower() + j - 1);
 190           arrNodes(j) = aCurve.Value(arrUVNodes(j));
 191         }
 192         aPol = new Poly_Polygon3D(arrNodes, arrUVNodes);
 193         aPol->Deflection(aPT->Deflection());
 194       }
 195       else {
 196         aPol = BRep_Tool::Polygon3D(aEdge, aL);
 197
 198         // If polygon was not found -> generate it
 199         if (aPol.IsNull()) {
 200           BRepAdaptor_Curve aCurve(aEdge);
 201           const Standard_Real aFirst = aCurve.FirstParameter();
 202           const Standard_Real aLast = aCurve.LastParameter();
 203
 204           GCPnts_TangentialDeflection TD(aCurve, aFirst, aLast,
 205             myDeflAngle, myDeflection, 2);
 206           const Standard_Integer nbNodes = TD.NbPoints();
 207
 208           TColgp_Array1OfPnt arrNodes(1, nbNodes);
 209           TColStd_Array1OfReal arrUVNodes(1, nbNodes);
 210           for (Standard_Integer j = 1; j <= nbNodes; j++) {
 211             arrNodes(j) = TD.Value(j);
 212             arrUVNodes(j) = TD.Parameter(j);
 213           }
 214           aPol = new Poly_Polygon3D(arrNodes, arrUVNodes);
 215           aPol->Deflection(myDeflection);
 216         }
 217       }
 218
 219       if (!aPol.IsNull())
 220       {
 221         aTShapeNode = polToIndexedLineSet(aPol);
 222         myScene.AddNode(aTShapeNode, Standard_False);
 223         // Bind the converted face
 224         myRelMap.Bind(aTestedShape, aTShapeNode);
 225       }
 226     }
 227   }
 228   break;
 229   default:
 230     break;
 231   }
 232
 233   return aTShapeNode;
 234 }
 235
 236
 237 //=======================================================================
 238 //function : Convert
 239 //purpose  :
 240 //=======================================================================
 241
 242 void VrmlData_ShapeConvert::Convert (const Standard_Boolean theExtractFaces,
 243                                      const Standard_Boolean theExtractEdges,
 244                                      const Standard_Real    theDeflection,
 245                                      const Standard_Real    theDeflAngle)
 246 {
 247   //const Standard_Real aDeflection =
 248   //  theDeflection < 0.0001 ? 0.0001 : theDeflection;
 249
 250   myDeflection = theDeflection < 0.0001 ? 0.0001 : theDeflection;
 251   myDeflAngle = theDeflAngle;
 252
 253   Standard_Boolean Extract[2] = {theExtractFaces, theExtractEdges};
 254   TopAbs_ShapeEnum ShapeType[2] = {TopAbs_FACE, TopAbs_EDGE};
 255   Standard_Integer i;
 256
 257   const Handle(NCollection_IncAllocator) anAlloc = new NCollection_IncAllocator;
 258
 259   // Relocation map for converted shapes. We should distinguish both TShape
 260   // and Orientation in this map.
 261   //NCollection_DataMap <TopoDS_Shape,Handle(VrmlData_Geometry)>
 262   //  aRelMap (100, anAlloc);
 263   myRelMap = NCollection_DataMap <TopoDS_Shape, Handle(VrmlData_Geometry)>(100, anAlloc);
 264
 265   NCollection_List<ShapeData>::Iterator anIter (myShapes);
 266   for (; anIter.More(); anIter.Next())
 267   {
 268     ShapeData& aData = anIter.ChangeValue();
 269     TCollection_AsciiString aGrName = aData.Name;
 270     aGrName.ChangeAll(' ', '_');
 271     aGrName.ChangeAll('#', '_');
 272     Handle(VrmlData_Group) aGroup =
 273       new VrmlData_Group (myScene, aGrName.ToCString());
 274     myScene.AddNode (aGroup);
 275
 276     for(i = 0; i < 2; ++i) {
 277
 278       if(!Extract[i]) continue;
 279
 280       TopExp_Explorer anExp (aData.Shape, ShapeType[i]);
 281       for (; anExp.More(); anExp.Next()) {
 282         const TopoDS_Shape& aShape = anExp.Current();
 283         TopLoc_Location aLoc;
 284         Handle(VrmlData_Geometry) aTShapeNode =
 285           makeTShapeNode(aShape, ShapeType[i], aLoc);
 286         if (!aTShapeNode.IsNull()) {
 287           const Handle(VrmlData_ShapeNode) aShapeNode =
 288             new VrmlData_ShapeNode (myScene, 0L);
 289           aShapeNode->SetAppearance (ShapeType[i] == TopAbs_FACE ?
 290                                      defaultMaterialFace():defaultMaterialEdge());
 291           myScene.AddNode (aShapeNode, Standard_False);
 292           aShapeNode->SetGeometry (aTShapeNode);
 293           if (aLoc.IsIdentity())
 294             // Store the shape node directly into the main Group.
 295             aGroup->AddNode (aShapeNode);
 296           else {
 297             // Create a Transform grouping node
 298             Handle(VrmlData_Group) aTrans = new VrmlData_Group (myScene, 0L,
 299                                                                 Standard_True);
 300             gp_Trsf aTrsf (aLoc);
 301             if (fabs(myScale - 1.) > Precision::Confusion())
 302             {
 303               const gp_XYZ aTransl = aTrsf.TranslationPart() * myScale;
 304               aTrsf.SetTranslationPart (aTransl);
 305             }
 306             aTrans->SetTransform (aTrsf);
 307             myScene.AddNode (aTrans, Standard_False);
 308             aGroup->AddNode (aTrans);
 309
 310             // Store the shape node under the transform.
 311             aTrans->AddNode (aShapeNode);
 312           }
 313         }
 314       }
 315     }
 316   }
 317   myShapes.Clear();
 318 }
 319
 320 //=======================================================================
 321 //function : triToIndexedFaceSet
 322 //purpose  :
 323 //=======================================================================
 324
 325 Handle(VrmlData_Geometry) VrmlData_ShapeConvert::triToIndexedFaceSet
 326                                   (const Handle(Poly_Triangulation)&  theTri,
 327                                    const TopoDS_Face&                theFace,
 328                                    const Handle(VrmlData_Coordinate)& theCoord)
 329 {
 330   Standard_Integer i;
 331   const Standard_Integer nNodes         (theTri->NbNodes());
 332   const Standard_Integer nTriangles     (theTri->NbTriangles());
 333   const TColgp_Array1OfPnt&    arrPolyNodes = theTri->Nodes();
 334   const Poly_Array1OfTriangle& arrTriangles = theTri->Triangles();
 335
 336   // protection against creation degenerative triangles
 337   Standard_Integer nbTri = 0;
 338   Poly_Array1OfTriangle aTriangles(1, nTriangles);
 339   for (i = 0; i < nTriangles; i++) {
 340     Standard_Integer idx[3];
 341     arrTriangles(i + 1).Get(idx[0], idx[1], idx[2]);
 342     if (idx[0] == idx[1] || idx[0] == idx[2] || idx[1] == idx[2])
 343     {
 344       continue;
 345     }
 346     nbTri++;
 347     aTriangles.SetValue(nbTri, arrTriangles(i + 1));
 348   }
 349   aTriangles.Resize(1, nbTri, Standard_True);
 350
 351   const Handle(VrmlData_IndexedFaceSet) aFaceSet =
 352     new VrmlData_IndexedFaceSet (myScene,
 353                                  0L,                    // no name
 354                                  Standard_True,         // IsCCW
 355                                  Standard_False,        // IsSolid
 356                                  Standard_False);       // IsConvex
 357   const Handle(NCollection_IncAllocator)& anAlloc = myScene.Allocator();
 358   const Standard_Boolean isReverse = (theFace.Orientation() == TopAbs_REVERSED);
 359
 360   // Create the array of triangles
 361   const Standard_Integer ** arrPolygons = static_cast<const Standard_Integer **>
 362     (anAlloc->Allocate (nbTri * sizeof(const Standard_Integer *)));
 363   aFaceSet->SetPolygons (nbTri, arrPolygons);
 364
 365   // Store the triangles
 366   for (i = 0; i < nbTri; i++) {
 367     Standard_Integer * aPolygon = static_cast<Standard_Integer *>
 368       (anAlloc->Allocate (4*sizeof(Standard_Integer)));
 369     aPolygon[0] = 3;
 370     aTriangles(i + 1).Get(aPolygon[1], aPolygon[2], aPolygon[3]);
 371     aPolygon[1]--;
 372     if (isReverse) {
 373       const Standard_Integer aTmp = aPolygon[2]-1;
 374       aPolygon[2] = aPolygon[3]-1;
 375       aPolygon[3] = aTmp;
 376     } else {
 377       aPolygon[2]--;
 378       aPolygon[3]--;
 379     }
 380     arrPolygons[i] = aPolygon;
 381   }
 382
 383   // Create the Coordinates node
 384   if (theCoord.IsNull() == Standard_False)
 385     aFaceSet->SetCoordinates (theCoord);
 386   else {
 387     gp_XYZ * arrNodes = static_cast <gp_XYZ *>
 388       (anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
 389     for  (i = 0; i < nNodes; i++)
 390       arrNodes[i] = arrPolyNodes(i+1).XYZ() * myScale;
 391
 392     const Handle(VrmlData_Coordinate) aCoordNode =
 393       new VrmlData_Coordinate (myScene, 0L, nNodes, arrNodes);
 394     myScene.AddNode (aCoordNode, Standard_False);
 395     aFaceSet->SetCoordinates (aCoordNode);
 396   }
 397
 398   // Create the Normals node if theTri has normals
 399   if(theTri->HasNormals()) {
 400     gp_XYZ * arrVec = static_cast <gp_XYZ *>
 401       (anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
 402     const TShort_Array1OfShortReal& Norm = theTri->Normals();
 403     Standard_Integer j;
 404     for  (i = 0, j = 1; i < nNodes; i++, j += 3)
 405     {
 406       gp_XYZ aNormal(Norm(j), Norm(j+1), Norm(j+2));
 407       if (isReverse)
 408       {
 409         aNormal.Reverse();
 410       }
 411       arrVec[i] = aNormal;
 412     }
 413     const Handle(VrmlData_Normal) aNormalNode =
 414       new VrmlData_Normal (myScene, 0L, nNodes, arrVec);
 415     myScene.AddNode (aNormalNode, Standard_False);
 416     aFaceSet->SetNormals (aNormalNode);
 417     return Handle(VrmlData_Geometry) (aFaceSet);
 418   }
 419
 420   Poly_Connect PC(theTri);
 421   // Create the Normals node (if UV- values are available)
 422   TopLoc_Location aLoc;
 423   const Standard_Real aConf2 = Precision::SquareConfusion();
 424   const Handle(Geom_Surface) aSurface = BRep_Tool::Surface (theFace, aLoc);
 425   if (theTri->HasUVNodes() && aSurface.IsNull() == Standard_False) {
 426     if (aSurface->IsCNu(1) && aSurface->IsCNv(1))
 427     {
 428       Standard_Integer nbNormVal  = nNodes * 3;
 429       Handle(TShort_HArray1OfShortReal) Normals =
 430         new TShort_HArray1OfShortReal(1, nbNormVal);
 431
 432       const TColgp_Array1OfPnt2d& arrUV = theTri->UVNodes();
 433       gp_XYZ * arrVec = static_cast <gp_XYZ *>
 434         (anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
 435
 436       // Compute the normal vectors
 437       Standard_Real Tol = Sqrt(aConf2);
 438       for  (i = 0; i < nNodes; i++) {
 439         const gp_Pnt2d& aUV = arrUV(i+1);
 440
 441         gp_Dir aNormal;
 442
 443         if (GeomLib::NormEstim(aSurface, aUV, Tol, aNormal) > 1) {
 444           //Try to estimate as middle normal of adjacent triangles
 445           Standard_Integer n[3];
 446
 447           gp_XYZ eqPlan(0., 0., 0.);
 448           for (PC.Initialize(i+1);  PC.More(); PC.Next()) {
 449             aTriangles(PC.Value()).Get(n[0], n[1], n[2]);
 450             gp_XYZ v1(arrPolyNodes(n[1]).Coord()-arrPolyNodes(n[0]).Coord());
 451             gp_XYZ v2(arrPolyNodes(n[2]).Coord()-arrPolyNodes(n[1]).Coord());
 452             gp_XYZ vv = v1^v2;
 453
 454             Standard_Real mod = vv.Modulus();
 455             if (mod < Tol)
 456               continue;
 457
 458             eqPlan += vv/mod;
 459           }
 460
 461           if (eqPlan.SquareModulus() > gp::Resolution())
 462             aNormal = gp_Dir(eqPlan);
 463         }
 464         if (isReverse)
 465           aNormal.Reverse();
 466
 467         if (aNormal.X()*aNormal.X() < aConf2)
 468           aNormal.SetX(0.);
 469         if (aNormal.Y()*aNormal.Y() < aConf2)
 470           aNormal.SetY(0.);
 471         if (aNormal.Z()*aNormal.Z() < aConf2)
 472           aNormal.SetZ(0.);
 473         arrVec[i] = aNormal.XYZ();
 474
 475         Standard_Integer j = i * 3;
 476         Normals->SetValue(j + 1, (Standard_ShortReal)aNormal.X());
 477         Normals->SetValue(j + 2, (Standard_ShortReal)aNormal.Y());
 478         Normals->SetValue(j + 3, (Standard_ShortReal)aNormal.Z());
 479
 480       }
 481
 482       theTri->SetNormals(Normals);
 483
 484       const Handle(VrmlData_Normal) aNormalNode =
 485         new VrmlData_Normal (myScene, 0L, nNodes, arrVec);
 486       myScene.AddNode (aNormalNode, Standard_False);
 487       aFaceSet->SetNormals (aNormalNode);
 488     }
 489   }
 490
 491   return Handle(VrmlData_Geometry) (aFaceSet);
 492 }
 493
 494 //=======================================================================
 495 //function : polToIndexedLineSet
 496 //purpose  : single polygon3D => IndexedLineSet
 497 //=======================================================================
 498
 499 Handle(VrmlData_Geometry) VrmlData_ShapeConvert::polToIndexedLineSet
 500                                         (const Handle(Poly_Polygon3D)& thePol)
 501 {
 502   Standard_Integer i;
 503   const Standard_Integer    nNodes (thePol->NbNodes());
 504   const TColgp_Array1OfPnt& arrPolyNodes = thePol->Nodes();
 505   const Handle(NCollection_IncAllocator)& anAlloc = myScene.Allocator();
 506
 507   const Handle(VrmlData_IndexedLineSet) aLineSet =
 508     new VrmlData_IndexedLineSet (myScene, 0L);
 509
 510   // Create the array of polygons (1 member)
 511   const Standard_Integer ** arrPolygons = static_cast<const Standard_Integer **>
 512     (anAlloc->Allocate (sizeof(const Standard_Integer *)));
 513   aLineSet->SetPolygons (1, arrPolygons);
 514
 515   // Store the polygon
 516   Standard_Integer * aPolygon = static_cast<Standard_Integer *>
 517     (anAlloc->Allocate ((nNodes+1)*sizeof(Standard_Integer)));
 518   aPolygon[0] = nNodes;
 519   for (i = 1; i <= nNodes; i++)
 520     aPolygon[i] = i-1;
 521   arrPolygons[0] = aPolygon;
 522
 523   // Create the Coordinates node
 524   gp_XYZ * arrNodes = static_cast <gp_XYZ *>
 525     (anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
 526   for  (i = 0; i < nNodes; i++)
 527     arrNodes[i] = arrPolyNodes(i+1).XYZ() * myScale;
 528
 529   const Handle(VrmlData_Coordinate) aCoordNode =
 530     new VrmlData_Coordinate (myScene, 0L, nNodes, arrNodes);
 531   myScene.AddNode (aCoordNode, Standard_False);
 532   aLineSet->SetCoordinates (aCoordNode);
 533
 534   return Handle(VrmlData_Geometry) (aLineSet);
 535 }
 536
 537 //=======================================================================
 538 //function : defaultMaterialFace
 539 //purpose  :
 540 //=======================================================================
 541
 542 Handle(VrmlData_Appearance) VrmlData_ShapeConvert::defaultMaterialFace () const
 543 {
 544   static char aNodeName[] = "__defaultMaterialFace";
 545   Handle(VrmlData_Appearance) anAppearance =
 546     Handle(VrmlData_Appearance)::DownCast(myScene.FindNode(aNodeName));
 547   if (anAppearance.IsNull()) {
 548     const Handle(VrmlData_Material) aMaterial =
 549       new VrmlData_Material (myScene, 0L, 1.0, 0.022, 0.);
 550     aMaterial->SetDiffuseColor (Quantity_Color(0.780392, 0.568627, 0.113725,
 551                                                Quantity_TOC_sRGB));
 552     aMaterial->SetEmissiveColor(Quantity_Color(0.329412, 0.223529, 0.027451,
 553                                                Quantity_TOC_sRGB));
 554     aMaterial->SetSpecularColor(Quantity_Color(0.992157, 0.941176, 0.807843,
 555                                                Quantity_TOC_sRGB));
 556     myScene.AddNode (aMaterial, Standard_False);
 557     anAppearance = new VrmlData_Appearance (myScene, aNodeName);
 558     anAppearance->SetMaterial (aMaterial);
 559     myScene.AddNode (anAppearance, Standard_False);
 560   }
 561   return anAppearance;
 562 }
 563
 564 //=======================================================================
 565 //function : defaultMaterialEdge
 566 //purpose  :
 567 //=======================================================================
 568
 569 Handle(VrmlData_Appearance) VrmlData_ShapeConvert::defaultMaterialEdge () const
 570 {
 571   static char aNodeName[] = "__defaultMaterialEdge";
 572   Handle(VrmlData_Appearance) anAppearance =
 573     Handle(VrmlData_Appearance)::DownCast(myScene.FindNode(aNodeName));
 574   if (anAppearance.IsNull()) {
 575     const Handle(VrmlData_Material) aMaterial =
 576       new VrmlData_Material (myScene, 0L, 0.2, 0.2, 0.2);
 577     aMaterial->SetDiffuseColor (Quantity_Color(0.2, 0.7, 0.2,
 578                                                Quantity_TOC_RGB));
 579     aMaterial->SetEmissiveColor(Quantity_Color(0.2, 0.7, 0.2,
 580                                                Quantity_TOC_RGB));
 581     aMaterial->SetSpecularColor(Quantity_Color(0.2, 0.7, 0.2,
 582                                                Quantity_TOC_RGB));
 583     myScene.AddNode (aMaterial, Standard_False);
 584     anAppearance = new VrmlData_Appearance (myScene, aNodeName);
 585     anAppearance->SetMaterial (aMaterial);
 586     myScene.AddNode (anAppearance, Standard_False);
 587   }
 588   return anAppearance;
 589 }
 590
 591
 592 //=======================================================================
 593 //function : addShape
 594 //purpose  : Adds the shape from the document
 595 //=======================================================================
 596 void VrmlData_ShapeConvert::addShape (const Handle(VrmlData_Group)& theParent,
 597                                       const TDF_Label& theLabel,
 598                                       const Handle(TDocStd_Document)& theDoc)
 599 {
 600   Handle(XCAFDoc_ShapeTool) aShapeTool = XCAFDoc_DocumentTool::ShapeTool(theDoc->Main());
 601   Handle(XCAFDoc_ColorTool) aColorTool = XCAFDoc_DocumentTool::ColorTool(theDoc->Main());
 602   Handle(XCAFDoc_VisMaterialTool) aMatTool = XCAFDoc_DocumentTool::VisMaterialTool(theDoc->Main());
 603
 604   NCollection_DataMap<TopoDS_Shape, TDF_Label> aChildShapeToLabels;
 605   TDF_LabelSequence aChildLabels;
 606   aShapeTool->GetSubShapes(theLabel, aChildLabels);
 607   for (TDF_LabelSequence::Iterator aChildIter(aChildLabels); aChildIter.More(); aChildIter.Next())
 608   {
 609     const TDF_Label& aChildLabel = aChildIter.Value();
 610     TopoDS_Shape aChildShape;
 611     if (aShapeTool->GetShape(aChildLabel, aChildShape))
 612     {
 613       aChildShapeToLabels.Bind(aChildShape, aChildLabel);
 614     }
 615   }
 616
 617   const TopoDS_Shape aShape = aShapeTool->GetShape(theLabel);
 618   Handle(VrmlData_Group) aGroup = 0L;
 619   TopExp_Explorer anExp(aShape, TopAbs_FACE);
 620   Standard_Integer nbFaces = 0;
 621   for (; anExp.More(); anExp.Next()) {
 622     nbFaces++;
 623   }
 624   Handle(TDataStd_Name) aNameAttribute;
 625   theLabel.FindAttribute(TDataStd_Name::GetID(), aNameAttribute);
 626   if (nbFaces > 1)
 627   {
 628     if (!aNameAttribute.IsNull())
 629     {
 630       TCollection_AsciiString aName = aNameAttribute->Get();
 631       aName.ChangeAll(' ', '_');
 632       aName.ChangeAll('#', '_');
 633       aGroup = new VrmlData_Group(myScene, aName.ToCString());
 634     }
 635     else
 636     {
 637       aGroup = new VrmlData_Group(myScene, 0L);
 638     }
 639     myScene.AddNode(aGroup, theParent.IsNull());
 640     if (!theParent.IsNull())
 641     {
 642       theParent->AddNode(aGroup);
 643     }
 644   }
 645
 646   anExp.Init(aShape, TopAbs_FACE);
 647   for (; anExp.More(); anExp.Next()) {
 648     TopLoc_Location aLoc;
 649     Handle(VrmlData_Geometry) aTShapeNode =
 650       makeTShapeNode(anExp.Current(), TopAbs_FACE, aLoc);
 651     if (!aTShapeNode.IsNull())
 652     {
 653       Handle(VrmlData_ShapeNode) aShapeNode = 0L;
 654       if (aGroup.IsNull() && !aNameAttribute.IsNull())
 655       {
 656         TCollection_AsciiString aName = aNameAttribute->Get();
 657         aName.ChangeAll(' ', '_');
 658         aName.ChangeAll('#', '_');
 659         aShapeNode = new VrmlData_ShapeNode(myScene, aName.ToCString());
 660       }
 661       else
 662       {
 663         aShapeNode = new VrmlData_ShapeNode(myScene, 0L);
 664       }
 665
 666       // set color
 667       XCAFPrs_Style aStyle;
 668       Quantity_ColorRGBA aColor;
 669       TDF_Label aLabel, anAttribLab;
 670       if (aChildShapeToLabels.Find (anExp.Current(), aLabel))
 671       {
 672         Handle(XCAFDoc_VisMaterial) aVisMat = aMatTool->GetShapeMaterial (aLabel);
 673         if (!aVisMat.IsNull()
 674          && !aVisMat->IsEmpty())
 675         {
 676           anAttribLab = aVisMat->Label();
 677           aStyle.SetMaterial (aVisMat);
 678         }
 679         else if (aColorTool->GetColor (aLabel, XCAFDoc_ColorSurf, anAttribLab)
 680               || aColorTool->GetColor (aLabel, XCAFDoc_ColorGen,  anAttribLab))
 681         {
 682           aColorTool->GetColor (anAttribLab, aColor);
 683           aStyle.SetColorSurf (aColor);
 684         }
 685       }
 686       if (!aStyle.IsSetColorSurf()
 687         && aStyle.Material().IsNull())
 688       {
 689         Handle(XCAFDoc_VisMaterial) aVisMat = aMatTool->GetShapeMaterial (theLabel);
 690         if (!aVisMat.IsNull()
 691          && !aVisMat->IsEmpty())
 692         {
 693           anAttribLab = aVisMat->Label();
 694           aStyle.SetMaterial (aVisMat);
 695         }
 696         if (aColorTool->GetColor (theLabel, XCAFDoc_ColorSurf, anAttribLab)
 697          || aColorTool->GetColor (theLabel, XCAFDoc_ColorGen,  anAttribLab))
 698         {
 699           aColorTool->GetColor (anAttribLab, aColor);
 700           aStyle.SetColorSurf (aColor);
 701         }
 702       }
 703       if (!aStyle.IsSetColorSurf()
 704         && aStyle.Material().IsNull())
 705       {
 706         aShapeNode->SetAppearance(defaultMaterialFace());
 707       }
 708       else
 709       {
 710         aShapeNode->SetAppearance (makeMaterialFromStyle (aStyle, anAttribLab));
 711       }
 712
 713       myScene.AddNode(aShapeNode, theParent.IsNull() && aGroup.IsNull());
 714       aShapeNode->SetGeometry(aTShapeNode);
 715       if (aLoc.IsIdentity())
 716       {
 717         // Store the shape node directly into the main Group.
 718         if (!aGroup.IsNull())
 719         {
 720           aGroup->AddNode(aShapeNode);
 721         }
 722         else if (!theParent.IsNull())
 723         {
 724           theParent->AddNode(aShapeNode);
 725         }
 726       }
 727       else
 728       {
 729         // Create a Transform grouping node
 730         Handle(VrmlData_Group) aTrans = new VrmlData_Group(myScene, 0L,
 731           Standard_True);
 732         gp_Trsf aTrsf(aLoc);
 733         if (fabs(myScale - 1.) > Precision::Confusion())
 734         {
 735             const gp_XYZ aTransl = aTrsf.TranslationPart() * myScale;
 736             aTrsf.SetTranslationPart(aTransl);
 737         }
 738         aTrans->SetTransform(aTrsf);
 739         myScene.AddNode(aTrans, theParent.IsNull() && aGroup.IsNull());
 740         if (!aGroup.IsNull())
 741         {
 742           aGroup->AddNode(aTrans);
 743         }
 744         else if (!theParent.IsNull())
 745         {
 746           theParent->AddNode(aTrans);
 747         }
 748         // Store the shape node under the transform.
 749         aTrans->AddNode(aShapeNode);
 750       }
 751     }
 752   }
 753 }
 754
 755
 756 //=======================================================================
 757 //function : addInstance
 758 //purpose  : Adds the reference from the document
 759 //=======================================================================
 760 void VrmlData_ShapeConvert::addInstance (const Handle(VrmlData_Group)& theParent,
 761                                          const TDF_Label& theLabel,
 762                                          const Handle(TDocStd_Document)& theDoc)
 763 {
 764   Handle(XCAFDoc_ShapeTool) aShapeTool = XCAFDoc_DocumentTool::ShapeTool(theDoc->Main());
 765
 766   const TopLoc_Location aLoc = aShapeTool->GetLocation(theLabel);
 767   Handle(VrmlData_Group) aTrans = 0L;
 768   if (!aLoc.IsIdentity())
 769   {
 770     // Create a Transform grouping node
 771     aTrans = new VrmlData_Group(myScene, 0L, Standard_True);
 772     gp_Trsf aTrsf(aLoc);
 773     if (fabs(myScale - 1.) > Precision::Confusion())
 774     {
 775         const gp_XYZ aTransl = aTrsf.TranslationPart() * myScale;
 776         aTrsf.SetTranslationPart(aTransl);
 777     }
 778     aTrans->SetTransform(aTrsf);
 779     myScene.AddNode(aTrans, theParent.IsNull());
 780     if (!theParent.IsNull())
 781     {
 782       theParent->AddNode(aTrans);
 783     }
 784   }
 785
 786   Handle(TDataStd_Name) aNameAttribute;
 787   theLabel.FindAttribute(TDataStd_Name::GetID(), aNameAttribute);
 788
 789   TDF_Label aRefLabel;
 790   aShapeTool->GetReferredShape(theLabel, aRefLabel);
 791   Handle(TDataStd_Name) aRefNameAttribute;
 792   aRefLabel.FindAttribute(TDataStd_Name::GetID(), aRefNameAttribute);
 793
 794   if (aShapeTool->IsSimpleShape(aRefLabel))
 795   {
 796     addShape((aTrans.IsNull() ? theParent : aTrans), aRefLabel, theDoc);
 797   }
 798   else if (aShapeTool->IsAssembly(aRefLabel))
 799   {
 800     addAssembly((aTrans.IsNull() ? theParent : aTrans), aRefLabel, theDoc, aTrans.IsNull());
 801   }
 802 }
 803
 804
 805 //=======================================================================
 806 //function : addAssembly
 807 //purpose  : Adds the assembly from the document
 808 //=======================================================================
 809 void VrmlData_ShapeConvert::addAssembly (const Handle(VrmlData_Group)& theParent,
 810                                          const TDF_Label& theLabel,
 811                                          const Handle(TDocStd_Document)& theDoc,
 812                                          const Standard_Boolean theNeedCreateGroup)
 813 {
 814   Handle(XCAFDoc_ShapeTool) aShapeTool = XCAFDoc_DocumentTool::ShapeTool(theDoc->Main());
 815
 816   Handle(VrmlData_Group) anAssembly = 0L;
 817   if (theNeedCreateGroup)
 818   {
 819     Handle(TDataStd_Name) aNameAttribute;
 820     theLabel.FindAttribute(TDataStd_Name::GetID(), aNameAttribute);
 821     if (!aNameAttribute.IsNull())
 822     {
 823       TCollection_AsciiString aName = aNameAttribute->Get();
 824       aName.ChangeAll(' ', '_');
 825       aName.ChangeAll('#', '_');
 826       anAssembly = new VrmlData_Group(myScene, aName.ToCString());
 827     }
 828     else
 829     {
 830       anAssembly = new VrmlData_Group(myScene, 0L);
 831     }
 832     TopLoc_Location aLoc = aShapeTool->GetLocation(theLabel);
 833     if (!aLoc.IsIdentity())
 834     {
 835       gp_Trsf aTrsf(aLoc);
 836       if (fabs(myScale - 1.) > Precision::Confusion())
 837       {
 838         const gp_XYZ aTransl = aTrsf.TranslationPart() * myScale;
 839         aTrsf.SetTranslationPart(aTransl);
 840       }
 841       anAssembly->SetTransform(aTrsf);
 842     }
 843     myScene.AddNode(anAssembly, theParent.IsNull());
 844     if (!theParent.IsNull())
 845     {
 846       theParent->AddNode(anAssembly);
 847     }
 848   }
 849
 850   TDF_LabelSequence aChildLabels;
 851   aShapeTool->GetComponents(theLabel, aChildLabels);
 852   for (TDF_LabelSequence::Iterator aChildIter(aChildLabels); aChildIter.More(); aChildIter.Next())
 853   {
 854     const TDF_Label& aChildLabel = aChildIter.Value();
 855     if (aShapeTool->IsAssembly(aChildLabel))
 856     {
 857       addAssembly((anAssembly.IsNull() ? theParent : anAssembly), aChildLabel, theDoc, anAssembly.IsNull());
 858     }
 859     else if (aShapeTool->IsReference(aChildLabel))
 860     {
 861       addInstance((anAssembly.IsNull() ? theParent : anAssembly), aChildLabel, theDoc);
 862     }
 863     else if (aShapeTool->IsSimpleShape(aChildLabel))
 864     {
 865       addShape((anAssembly.IsNull() ? theParent : anAssembly), aChildLabel, theDoc);
 866     }
 867   }
 868 }
 869
 870
 871 //=======================================================================
 872 //function : ConvertDocument
 873 //purpose  :
 874 //=======================================================================
 875 void VrmlData_ShapeConvert::ConvertDocument(const Handle(TDocStd_Document) &theDoc)
 876 {
 877   Handle(XCAFDoc_ShapeTool) aShapeTool = XCAFDoc_DocumentTool::ShapeTool(theDoc->Main());
 878
 879   TDF_LabelSequence aFreeShapeLabels;
 880   aShapeTool->GetFreeShapes(aFreeShapeLabels);
 881
 882   Handle(VrmlData_Group) aGroup = 0L;
 883   if (aFreeShapeLabels.Size() > 1)
 884   {
 885     aGroup = new VrmlData_Group(myScene, 0L);
 886     myScene.AddNode(aGroup);
 887   }
 888
 889   for (TDF_LabelSequence::Iterator aRootIter(aFreeShapeLabels); aRootIter.More(); aRootIter.Next())
 890   {
 891     const TDF_Label& aFreeShapeLabel = aRootIter.Value();
 892     if (aShapeTool->IsAssembly (aFreeShapeLabel))
 893     {
 894       addAssembly (aGroup, aFreeShapeLabel, theDoc, Standard_True);
 895     }
 896     else if (aShapeTool->IsReference (aFreeShapeLabel))
 897     {
 898       addInstance (aGroup, aFreeShapeLabel, theDoc);
 899     }
 900     else if (aShapeTool->IsSimpleShape (aFreeShapeLabel))
 901     {
 902       addShape (aGroup, aFreeShapeLabel, theDoc);
 903     }
 904   }
 905 }
 906
 907 //=======================================================================
 908 //function : makeMaterialFromStyle
 909 //purpose  :
 910 //=======================================================================
 911 Handle(VrmlData_Appearance) VrmlData_ShapeConvert::makeMaterialFromStyle (const XCAFPrs_Style& theStyle,
 912                                                                           const TDF_Label& theAttribLab) const
 913 {
 914   const Quantity_ColorRGBA aColor = !theStyle.Material().IsNull()
 915                                    ? theStyle.Material()->BaseColor()
 916                                    : theStyle.GetColorSurfRGBA();
 917
 918   TCollection_AsciiString aNodeName = "_materialFace_";
 919   Handle(TDataStd_Name) aNameAttribute;
 920   if (theAttribLab.FindAttribute(TDataStd_Name::GetID(), aNameAttribute))
 921   {
 922     aNodeName.AssignCat(aNameAttribute->Get());
 923     Standard_Integer n = aNodeName.Search(" ");
 924     if (n > 0)
 925     {
 926       aNodeName = aNodeName.SubString(1, n - 1);
 927     }
 928   }
 929   else
 930   {
 931     NCollection_Vec3<Standard_Real> aColor_sRGB;
 932     aColor.GetRGB().Values (aColor_sRGB.r(), aColor_sRGB.g(), aColor_sRGB.b(), Quantity_TOC_sRGB);
 933     aNodeName.AssignCat(aColor_sRGB.r());
 934     aNodeName.AssignCat("_");
 935     aNodeName.AssignCat(aColor_sRGB.g());
 936     aNodeName.AssignCat("_");
 937     aNodeName.AssignCat(aColor_sRGB.b());
 938   }
 939
 940   Handle(VrmlData_Appearance) anAppearance = Handle(VrmlData_Appearance)::DownCast(myScene.FindNode(aNodeName.ToCString()));
 941   if (anAppearance.IsNull())
 942   {
 943     Handle(VrmlData_Material) aMaterial = new VrmlData_Material (myScene, 0L);
 944     aMaterial->SetDiffuseColor (aColor.GetRGB());
 945     myScene.AddNode (aMaterial, Standard_False);
 946     anAppearance = new VrmlData_Appearance (myScene, aNodeName.ToCString());
 947     anAppearance->SetMaterial (aMaterial);
 948     myScene.AddNode (anAppearance, Standard_False);
 949   }
 950
 951   return anAppearance;
 952 }