0025279: OCCT fails to read VRML file created by OCCT
[occt.git] / 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 <BRepMesh_IncrementalMesh.hxx>
24 #include <BRep_Builder.hxx>
25 #include <BRep_Tool.hxx>
26 #include <Geom_Surface.hxx>
27 #include <NCollection_DataMap.hxx>
28 #include <Poly_Triangulation.hxx>
29 #include <Poly_Connect.hxx>
30 #include <Poly_PolygonOnTriangulation.hxx>
31 #include <Poly_Polygon3D.hxx>
32 #include <Precision.hxx>
33 #include <TColgp_Array1OfPnt2d.hxx>
34 #include <TopExp_Explorer.hxx>
35 #include <TopoDS.hxx>
36 #include <TopoDS_Edge.hxx>
37 #include <TopoDS_Face.hxx>
38 #include <TopoDS_Shape.hxx>
39 #include <TopoDS_Wire.hxx>
40 #include <GCPnts_TangentialDeflection.hxx>
41 #include <BRepAdaptor_Curve.hxx>
42 #include <TColStd_Array1OfReal.hxx>
43 #include <TColStd_HArray1OfReal.hxx>
44 #include <TShort_Array1OfShortReal.hxx>
45 #include <GeomLib.hxx>
46 #include <TShort_HArray1OfShortReal.hxx>
47
48 //=======================================================================
49 //function : IsEqual
50 //purpose  : for NCollection_DataMap interface
51 //=======================================================================
52
53 inline Standard_Boolean IsEqual (const TopoDS_Shape& one,
54                                  const TopoDS_Shape& two) 
55 {
56   return one == two;
57 }
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 //function : Convert
102 //purpose  : 
103 //=======================================================================
104
105 void VrmlData_ShapeConvert::Convert (const Standard_Boolean theExtractFaces,
106                                      const Standard_Boolean theExtractEdges,
107                                      const Standard_Real    theDeflection,
108                                      const Standard_Real    theDeflAngle)
109 {
110   const Standard_Real aDeflection =
111     theDeflection < 0.0001 ? 0.0001 : theDeflection;
112
113   Standard_Boolean Extract[2] = {theExtractFaces, theExtractEdges};
114   TopAbs_ShapeEnum ShapeType[2] = {TopAbs_FACE, TopAbs_EDGE};
115   Standard_Integer i;
116
117   const Handle(NCollection_IncAllocator) anAlloc = new NCollection_IncAllocator;
118
119   // Relocation map for converted shapes. We should distinguish both TShape
120   // and Orientation in this map.
121   NCollection_DataMap <TopoDS_Shape,Handle(VrmlData_Geometry)>
122     aRelMap (100, anAlloc);
123
124
125   NCollection_List<ShapeData>::Iterator anIter (myShapes);
126   for (; anIter.More(); anIter.Next()) {
127
128     ShapeData& aData = anIter.ChangeValue();
129     Handle(VrmlData_Group) aGroup =
130       new VrmlData_Group (myScene, aData.Name.ToCString());
131     myScene.AddNode (aGroup);
132
133     for(i = 0; i < 2; ++i) {
134
135       if(!Extract[i]) continue;
136
137       TopExp_Explorer anExp (aData.Shape, ShapeType[i]);
138       for (; anExp.More(); anExp.Next()) {
139         const TopoDS_Shape& aShape = anExp.Current();
140         TopLoc_Location aLoc;
141         Handle(VrmlData_Geometry) aTShapeNode;
142         const Standard_Boolean isReverse=(aShape.Orientation()==TopAbs_REVERSED); 
143
144         TopoDS_Shape aTestedShape;
145         aTestedShape.TShape (aShape.TShape());
146         aTestedShape.Orientation (isReverse ? TopAbs_REVERSED : TopAbs_FORWARD);
147         switch (ShapeType[i]) {
148         case TopAbs_FACE:
149           {
150             const TopoDS_Face& aFace = TopoDS::Face (aShape);
151             if (aFace.IsNull() == Standard_False) {
152               Handle(Poly_Triangulation) aTri =
153                 BRep_Tool::Triangulation (aFace, aLoc);
154       
155               if (aRelMap.IsBound (aTestedShape)) {
156                 aTShapeNode = aRelMap(aTestedShape);
157                 break;
158               }
159
160               if (aTri.IsNull() == Standard_False) {
161                 TopoDS_Shape aTestedShapeRev = aTestedShape;
162                 aTestedShapeRev.Orientation (isReverse ?
163                                              TopAbs_FORWARD : TopAbs_REVERSED);
164                 Handle(VrmlData_IndexedFaceSet) aFaceSetToReuse;
165                 if (aRelMap.IsBound (aTestedShapeRev))
166                   aFaceSetToReuse = Handle(VrmlData_IndexedFaceSet)::DownCast
167                     (aRelMap(aTestedShapeRev));
168
169                 Handle(VrmlData_Coordinate) aCoordToReuse;
170                 if (aFaceSetToReuse.IsNull() == Standard_False)
171                   aCoordToReuse = aFaceSetToReuse->Coordinates();
172
173                 aTShapeNode = triToIndexedFaceSet (aTri, aFace, aCoordToReuse);
174                 myScene.AddNode (aTShapeNode, Standard_False);
175                 // Bind the converted face
176                 aRelMap.Bind (aTestedShape, aTShapeNode);
177               }
178             }
179           }
180           break;
181         case TopAbs_WIRE:
182           {
183             const TopoDS_Wire& aWire = TopoDS::Wire (aShape);
184             if (aWire.IsNull() == Standard_False) {
185             }
186           }
187           break;
188        case TopAbs_EDGE:
189          {
190            const TopoDS_Edge& aEdge = TopoDS::Edge (aShape);
191             if (aEdge.IsNull() == Standard_False) {
192               if (aRelMap.IsBound (aTestedShape)) {
193                 aTShapeNode = aRelMap(aTestedShape);
194                 break;
195               }
196               // Check the presence of reversly oriented Edge. It can also be used
197               // because we do not distinguish the orientation for edges.
198               aTestedShape.Orientation (isReverse ?
199                                         TopAbs_FORWARD : TopAbs_REVERSED);
200               if (aRelMap.IsBound (aTestedShape)) {
201                 aTShapeNode = aRelMap(aTestedShape);
202                 break;
203               }
204
205               //try to find PolygonOnTriangulation
206               Handle(Poly_PolygonOnTriangulation) aPT;
207               Handle(Poly_Triangulation) aT;
208               TopLoc_Location aL;
209               BRep_Tool::PolygonOnTriangulation(aEdge, aPT, aT, aL);
210
211               // If PolygonOnTriangulation was found -> get the Polygon3D
212               Handle(Poly_Polygon3D) aPol;
213               if(!aPT.IsNull() && !aT.IsNull() && aPT->HasParameters()) {
214                 BRepAdaptor_Curve aCurve(aEdge);
215                 Handle(TColStd_HArray1OfReal) aPrs = aPT->Parameters();
216                 Standard_Integer nbNodes = aPT->NbNodes();
217                 TColgp_Array1OfPnt arrNodes(1, nbNodes);
218                 TColStd_Array1OfReal arrUVNodes(1, nbNodes);
219
220                 for(Standard_Integer j = 1; j <= nbNodes; j++) {
221                   arrUVNodes(j) = aPrs->Value(aPrs->Lower() + j - 1);
222                   arrNodes(j) = aCurve.Value(arrUVNodes(j));
223                 }
224                 aPol = new Poly_Polygon3D(arrNodes, arrUVNodes);
225                 aPol->Deflection (aPT->Deflection());
226               }
227               else {
228                 aPol = BRep_Tool::Polygon3D(aEdge, aL);
229
230                 // If polygon was not found -> generate it
231                 if (aPol.IsNull()) {
232                   BRepAdaptor_Curve aCurve(aEdge);
233                   const Standard_Real aFirst = aCurve.FirstParameter();
234                   const Standard_Real aLast  = aCurve.LastParameter();
235                 
236                   GCPnts_TangentialDeflection TD (aCurve, aFirst, aLast,
237                                                   theDeflAngle, aDeflection, 2);
238                   const Standard_Integer nbNodes = TD.NbPoints();
239                 
240                   TColgp_Array1OfPnt arrNodes(1, nbNodes);
241                   TColStd_Array1OfReal arrUVNodes(1, nbNodes);
242                   for (Standard_Integer j = 1; j <= nbNodes; j++) {
243                     arrNodes(j) = TD.Value(j);
244                     arrUVNodes(j) = TD.Parameter(j);
245                   }
246                   aPol = new Poly_Polygon3D(arrNodes, arrUVNodes);
247                   aPol->Deflection (aDeflection);
248                 }
249               }
250
251               if (aPol.IsNull())
252                 continue;
253
254               aTShapeNode = polToIndexedLineSet (aPol);
255               myScene.AddNode (aTShapeNode, Standard_False);
256               // Bind the converted face
257               aRelMap.Bind (aTestedShape, aTShapeNode);
258             }
259           }
260           break;
261         default:
262           break;
263         }
264         
265         if (aTShapeNode.IsNull() == Standard_False) {
266           const Handle(VrmlData_ShapeNode) aShapeNode =
267             new VrmlData_ShapeNode (myScene, 0L);
268           aShapeNode->SetAppearance (ShapeType[i] == TopAbs_FACE ?
269                                      defaultMaterialFace():defaultMaterialEdge());
270           myScene.AddNode (aShapeNode, Standard_False);
271           aShapeNode->SetGeometry (aTShapeNode);
272           if (aLoc.IsIdentity())
273             // Store the shape node directly into the main Group.
274             aGroup->AddNode (aShapeNode);
275           else {
276             // Create a Transform grouping node
277             Handle(VrmlData_Group) aTrans = new VrmlData_Group (myScene, 0L,
278                                                                 Standard_True);
279             gp_Trsf aTrsf (aLoc);
280             if (fabs(myScale - 1.) > Precision::Confusion()) {
281               const gp_XYZ aTransl = aTrsf.TranslationPart() * myScale;
282               aTrsf.SetTranslationPart (aTransl);
283             }
284             aTrans->SetTransform (aTrsf);
285             myScene.AddNode (aTrans, Standard_False);
286             aGroup->AddNode (aTrans);
287             
288             // Store the shape node under the transform.
289             aTrans->AddNode (aShapeNode);
290           }
291         }
292       }
293     }
294   }
295   myShapes.Clear();
296 }
297
298 //=======================================================================
299 //function : triToIndexedFaceSet
300 //purpose  : 
301 //=======================================================================
302
303 Handle(VrmlData_Geometry) VrmlData_ShapeConvert::triToIndexedFaceSet
304                                   (const Handle(Poly_Triangulation)&  theTri,
305                                    const TopoDS_Face&                theFace,
306                                    const Handle(VrmlData_Coordinate)& theCoord)
307 {
308   Standard_Integer i;
309   const Standard_Integer nNodes         (theTri->NbNodes());
310   const Standard_Integer nTriangles     (theTri->NbTriangles());
311   const TColgp_Array1OfPnt&    arrPolyNodes = theTri->Nodes();
312   const Poly_Array1OfTriangle& arrTriangles = theTri->Triangles();
313
314   const Handle(VrmlData_IndexedFaceSet) aFaceSet =
315     new VrmlData_IndexedFaceSet (myScene,
316                                  0L,                    // no name
317                                  Standard_True,         // IsCCW
318                                  Standard_False,        // IsSolid
319                                  Standard_False);       // IsConvex
320   const Handle(NCollection_IncAllocator)& anAlloc = myScene.Allocator();
321   const Standard_Boolean isReverse = (theFace.Orientation() == TopAbs_REVERSED);
322
323   // Create the array of triangles
324   const Standard_Integer ** arrPolygons = static_cast<const Standard_Integer **>
325     (anAlloc->Allocate (nTriangles * sizeof(const Standard_Integer *)));
326   aFaceSet->SetPolygons (nTriangles, arrPolygons);
327
328   // Store the triangles
329   for (i = 0; i < nTriangles; i++) {
330     Standard_Integer * aPolygon = static_cast<Standard_Integer *>
331       (anAlloc->Allocate (4*sizeof(Standard_Integer)));
332     aPolygon[0] = 3;
333     arrTriangles(i+1).Get (aPolygon[1],aPolygon[2],aPolygon[3]);
334     aPolygon[1]--;
335     if (isReverse) {
336       const Standard_Integer aTmp = aPolygon[2]-1;
337       aPolygon[2] = aPolygon[3]-1;
338       aPolygon[3] = aTmp;
339     } else {
340       aPolygon[2]--;
341       aPolygon[3]--;
342     }
343     arrPolygons[i] = aPolygon;
344   }
345
346   // Create the Coordinates node
347   if (theCoord.IsNull() == Standard_False)
348     aFaceSet->SetCoordinates (theCoord);
349   else {
350     gp_XYZ * arrNodes = static_cast <gp_XYZ *>
351       (anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
352     for  (i = 0; i < nNodes; i++)
353       arrNodes[i] = arrPolyNodes(i+1).XYZ() * myScale;
354
355     const Handle(VrmlData_Coordinate) aCoordNode =
356       new VrmlData_Coordinate (myScene, 0L, nNodes, arrNodes);
357     myScene.AddNode (aCoordNode, Standard_False);
358     aFaceSet->SetCoordinates (aCoordNode);
359   }
360
361   // Create the Normals node if theTri has normals
362   if(theTri->HasNormals()) {
363     gp_XYZ * arrVec = static_cast <gp_XYZ *>
364       (anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
365     const TShort_Array1OfShortReal& Norm = theTri->Normals();
366     Standard_Integer j;
367     for  (i = 0, j = 1; i < nNodes; i++, j += 3) {
368       
369       gp_XYZ aNormal(Norm(j), Norm(j+1), Norm(j+2));
370       arrVec[i] = aNormal;
371
372     }
373     const Handle(VrmlData_Normal) aNormalNode =
374       new VrmlData_Normal (myScene, 0L, nNodes, arrVec);
375     myScene.AddNode (aNormalNode, Standard_False);
376     aFaceSet->SetNormals (aNormalNode);
377     return aFaceSet;
378   }
379
380   Poly_Connect PC(theTri);
381   // Create the Normals node (if UV- values are available)
382   TopLoc_Location aLoc;
383   const Standard_Real aConf2 = Precision::SquareConfusion();
384   const Handle(Geom_Surface) aSurface = BRep_Tool::Surface (theFace, aLoc);
385   if (theTri->HasUVNodes() && aSurface.IsNull() == Standard_False) {
386     if (aSurface->IsCNu(1) && aSurface->IsCNv(1))
387     {
388       Standard_Integer nbNormVal  = nNodes * 3; 
389       Handle(TShort_HArray1OfShortReal) Normals = 
390         new TShort_HArray1OfShortReal(1, nbNormVal);
391
392       const TColgp_Array1OfPnt2d& arrUV = theTri->UVNodes();
393       gp_XYZ * arrVec = static_cast <gp_XYZ *>
394         (anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
395
396       // Compute the normal vectors
397       Standard_Real Tol = Sqrt(aConf2);
398       for  (i = 0; i < nNodes; i++) {
399         const gp_Pnt2d& aUV = arrUV(i+1);
400         
401         gp_Dir aNormal;
402         
403         if (GeomLib::NormEstim(aSurface, aUV, Tol, aNormal) > 1) {
404           //Try to estimate as middle normal of adjacent triangles
405           Standard_Integer n[3];
406
407           gp_XYZ eqPlan(0., 0., 0.);
408           for (PC.Initialize(i+1);  PC.More(); PC.Next()) {
409             arrTriangles(PC.Value()).Get(n[0], n[1], n[2]);
410             gp_XYZ v1(arrPolyNodes(n[1]).Coord()-arrPolyNodes(n[0]).Coord());
411             gp_XYZ v2(arrPolyNodes(n[2]).Coord()-arrPolyNodes(n[1]).Coord());
412             gp_XYZ vv = v1^v2;
413
414             Standard_Real mod = vv.Modulus();
415             if (mod < Tol)
416               continue;
417
418             eqPlan += vv/mod;
419           }
420
421           if (eqPlan.SquareModulus() > gp::Resolution())
422             aNormal = gp_Dir(eqPlan);
423         }
424         if (isReverse)
425           aNormal.Reverse();
426
427         if (aNormal.X()*aNormal.X() < aConf2)
428           aNormal.SetX(0.);
429         if (aNormal.Y()*aNormal.Y() < aConf2)
430           aNormal.SetY(0.);
431         if (aNormal.Z()*aNormal.Z() < aConf2)
432           aNormal.SetZ(0.);
433         arrVec[i] = aNormal.XYZ();
434
435         Standard_Integer j = i * 3;
436         Normals->SetValue(j + 1, (Standard_ShortReal)aNormal.X());
437         Normals->SetValue(j + 2, (Standard_ShortReal)aNormal.Y());
438         Normals->SetValue(j + 3, (Standard_ShortReal)aNormal.Z());
439
440       }
441
442       theTri->SetNormals(Normals);  
443   
444       const Handle(VrmlData_Normal) aNormalNode =
445         new VrmlData_Normal (myScene, 0L, nNodes, arrVec);
446       myScene.AddNode (aNormalNode, Standard_False);
447       aFaceSet->SetNormals (aNormalNode);
448     }
449   }
450
451   return aFaceSet;
452 }
453
454 //=======================================================================
455 //function : polToIndexedLineSet
456 //purpose  : single polygon3D => IndexedLineSet
457 //=======================================================================
458
459 Handle(VrmlData_Geometry) VrmlData_ShapeConvert::polToIndexedLineSet
460                                         (const Handle(Poly_Polygon3D)& thePol)
461 {
462   Standard_Integer i;
463   const Standard_Integer    nNodes (thePol->NbNodes());
464   const TColgp_Array1OfPnt& arrPolyNodes = thePol->Nodes();
465   const Handle(NCollection_IncAllocator)& anAlloc = myScene.Allocator();
466
467   const Handle(VrmlData_IndexedLineSet) aLineSet =
468     new VrmlData_IndexedLineSet (myScene, 0L);
469
470   // Create the array of polygons (1 member)
471   const Standard_Integer ** arrPolygons = static_cast<const Standard_Integer **>
472     (anAlloc->Allocate (sizeof(const Standard_Integer *)));
473   aLineSet->SetPolygons (1, arrPolygons);
474
475   // Store the polygon
476   Standard_Integer * aPolygon = static_cast<Standard_Integer *>
477     (anAlloc->Allocate ((nNodes+1)*sizeof(Standard_Integer)));
478   aPolygon[0] = nNodes;
479   for (i = 1; i <= nNodes; i++)
480     aPolygon[i] = i-1;
481   arrPolygons[0] = aPolygon;
482
483   // Create the Coordinates node
484   gp_XYZ * arrNodes = static_cast <gp_XYZ *>
485     (anAlloc->Allocate (nNodes * sizeof(gp_XYZ)));
486   for  (i = 0; i < nNodes; i++)
487     arrNodes[i] = arrPolyNodes(i+1).XYZ() * myScale;
488
489   const Handle(VrmlData_Coordinate) aCoordNode =
490     new VrmlData_Coordinate (myScene, 0L, nNodes, arrNodes);
491   myScene.AddNode (aCoordNode, Standard_False);
492   aLineSet->SetCoordinates (aCoordNode);
493
494   return aLineSet;
495 }
496
497 //=======================================================================
498 //function : defaultMaterialFace
499 //purpose  : 
500 //=======================================================================
501
502 Handle(VrmlData_Appearance) VrmlData_ShapeConvert::defaultMaterialFace () const
503 {
504   static char aNodeName[] = "__defaultMaterialFace";
505   Handle(VrmlData_Appearance) anAppearance =
506     Handle(VrmlData_Appearance)::DownCast(myScene.FindNode(aNodeName));
507   if (anAppearance.IsNull()) {
508     const Handle(VrmlData_Material) aMaterial =
509       new VrmlData_Material (myScene, 0L, 1.0, 0.022, 0.);
510     aMaterial->SetDiffuseColor (Quantity_Color(0.780392, 0.568627, 0.113725,
511                                                Quantity_TOC_RGB));
512     aMaterial->SetEmissiveColor(Quantity_Color(0.329412, 0.223529, 0.027451,
513                                                Quantity_TOC_RGB));
514     aMaterial->SetSpecularColor(Quantity_Color(0.992157, 0.941176, 0.807843,
515                                                Quantity_TOC_RGB));
516     myScene.AddNode (aMaterial, Standard_False);
517     anAppearance = new VrmlData_Appearance (myScene, aNodeName);
518     anAppearance->SetMaterial (aMaterial);
519     myScene.AddNode (anAppearance, Standard_False);
520   }
521   return anAppearance;
522 }
523
524 //=======================================================================
525 //function : defaultMaterialEdge
526 //purpose  : 
527 //=======================================================================
528
529 Handle(VrmlData_Appearance) VrmlData_ShapeConvert::defaultMaterialEdge () const
530 {
531   static char aNodeName[] = "__defaultMaterialEdge";
532   Handle(VrmlData_Appearance) anAppearance =
533     Handle(VrmlData_Appearance)::DownCast(myScene.FindNode(aNodeName));
534   if (anAppearance.IsNull()) { 
535     const Handle(VrmlData_Material) aMaterial =
536       new VrmlData_Material (myScene, 0L, 0.2, 0.2, 0.2);
537     aMaterial->SetDiffuseColor (Quantity_Color(0.2, 0.7, 0.2,
538                                                Quantity_TOC_RGB));
539     aMaterial->SetEmissiveColor(Quantity_Color(0.2, 0.7, 0.2,
540                                                Quantity_TOC_RGB));
541     aMaterial->SetSpecularColor(Quantity_Color(0.2, 0.7, 0.2,
542                                                Quantity_TOC_RGB));
543     myScene.AddNode (aMaterial, Standard_False);
544     anAppearance = new VrmlData_Appearance (myScene, aNodeName);
545     anAppearance->SetMaterial (aMaterial);
546     myScene.AddNode (anAppearance, Standard_False);
547   }
548   return anAppearance;
549 }