0027105: Make code ISO-compliant [-Wpedantic fixes]
[occt.git] / src / StdPrs / StdPrs_ShadedShape.cxx
1 // Created on: 1993-09-23
2 // Created by: Jean-Louis FRENKEL
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <StdPrs_ShadedShape.hxx>
18
19 #include <Bnd_Box.hxx>
20 #include <BRepTools.hxx>
21 #include <BRepBndLib.hxx>
22 #include <BRep_Builder.hxx>
23 #include <BRep_Tool.hxx>
24 #include <Graphic3d_ArrayOfSegments.hxx>
25 #include <Graphic3d_ArrayOfTriangles.hxx>
26 #include <Graphic3d_AspectFillArea3d.hxx>
27 #include <Graphic3d_Group.hxx>
28 #include <gp_Dir.hxx>
29 #include <gp_Vec.hxx>
30 #include <gp_Pnt.hxx>
31 #include <NCollection_List.hxx>
32 #include <Precision.hxx>
33 #include <Prs3d_Drawer.hxx>
34 #include <Prs3d_IsoAspect.hxx>
35 #include <Prs3d_LineAspect.hxx>
36 #include <Prs3d_Presentation.hxx>
37 #include <Prs3d_ShadingAspect.hxx>
38 #include <Poly_Connect.hxx>
39 #include <Poly_PolygonOnTriangulation.hxx>
40 #include <Poly_Triangulation.hxx>
41 #include <StdPrs_ToolTriangulatedShape.hxx>
42 #include <StdPrs_WFShape.hxx>
43 #include <TopExp.hxx>
44 #include <TopExp_Explorer.hxx>
45 #include <TopoDS.hxx>
46 #include <TopoDS_Compound.hxx>
47 #include <TopoDS_Face.hxx>
48 #include <TopoDS_Shape.hxx>
49 #include <TColgp_Array1OfDir.hxx>
50 #include <TColgp_Array1OfPnt2d.hxx>
51 #include <TColgp_HArray1OfPnt.hxx>
52 #include <TopTools_ListOfShape.hxx>
53 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
54
55 namespace
56 {
57
58   //! Computes wireframe presentation for free wires and vertices
59   void wireframeFromShape (const Handle (Prs3d_Presentation)& thePrs,
60                            const TopoDS_Shape&                theShape,
61                            const Handle (Prs3d_Drawer)&       theDrawer)
62   {
63     Standard_Boolean aDrawAllVerticesFlag = (theDrawer->VertexDrawMode() == Prs3d_VDM_All);
64
65     if (!aDrawAllVerticesFlag && theShape.ShapeType() != TopAbs_COMPOUND)
66     {
67       return;
68     }
69
70     TopExp_Explorer aShapeIter (theShape, TopAbs_FACE);
71     if (!aShapeIter.More())
72     {
73       // compound contains no shaded elements at all
74       StdPrs_WFShape::Add (thePrs, theShape, theDrawer);
75       return;
76     }
77
78     // We have to create a compound and collect all subshapes not drawn by the shading algo.
79     // This includes:
80     // - isolated edges
81     // - isolated vertices, if aDrawAllVerticesFlag == Standard_False
82     // - all shape's vertices, if aDrawAllVerticesFlag == Standard_True
83     TopoDS_Compound aCompoundWF;
84     BRep_Builder aBuilder;
85     aBuilder.MakeCompound (aCompoundWF);
86     Standard_Boolean hasElement = Standard_False;
87
88     // isolated edges
89     for (aShapeIter.Init (theShape, TopAbs_EDGE, TopAbs_FACE); aShapeIter.More(); aShapeIter.Next())
90     {
91       hasElement = Standard_True;
92       aBuilder.Add (aCompoundWF, aShapeIter.Current());
93     }
94     // isolated or all vertices
95     aShapeIter.Init (theShape, TopAbs_VERTEX, aDrawAllVerticesFlag ? TopAbs_SHAPE : TopAbs_EDGE);
96     for (; aShapeIter.More(); aShapeIter.Next())
97     {
98       hasElement = Standard_True;
99       aBuilder.Add (aCompoundWF, aShapeIter.Current());
100     }
101     if (hasElement)
102     {
103       StdPrs_WFShape::Add (thePrs, aCompoundWF, theDrawer);
104     }
105   }
106
107   //! Computes special wireframe presentation for faces without triangulation.
108   void wireframeNoTriangFacesFromShape (const Handle(Prs3d_Presentation)& thePrs,
109                                         const TopoDS_Shape&               theShape,
110                                         const Handle(Prs3d_Drawer)&       theDrawer)
111   {
112     TopoDS_Compound aCompoundWF;
113     BRep_Builder aBuilder;
114     aBuilder.MakeCompound (aCompoundWF);
115     TopLoc_Location aLoc;
116     Standard_Boolean hasElement = Standard_False;
117
118     for (TopExp_Explorer aShapeIter(theShape, TopAbs_FACE); aShapeIter.More(); aShapeIter.Next())
119     {
120       const TopoDS_Face& aFace = TopoDS::Face (aShapeIter.Current());
121       const Handle(Poly_Triangulation) aTriang = BRep_Tool::Triangulation (aFace, aLoc);
122       if (aTriang.IsNull())
123       {
124         hasElement = Standard_True;
125         aBuilder.Add (aCompoundWF, aFace);
126       }
127     }
128
129     if (hasElement)
130     {
131       Standard_Integer aPrevUIsoNb = theDrawer->UIsoAspect()->Number();
132       Standard_Integer aPrevVIsoNb = theDrawer->VIsoAspect()->Number();
133       theDrawer->UIsoAspect()->SetNumber (5);
134       theDrawer->VIsoAspect()->SetNumber (5);
135
136       StdPrs_WFShape::Add (thePrs, aCompoundWF, theDrawer);
137
138       theDrawer->UIsoAspect()->SetNumber (aPrevUIsoNb);
139       theDrawer->VIsoAspect()->SetNumber (aPrevVIsoNb);
140     }
141   }
142
143   //! Gets triangulation of every face of shape and fills output array of triangles
144   static Handle(Graphic3d_ArrayOfTriangles) fillTriangles (const TopoDS_Shape&    theShape,
145                                                            const Standard_Boolean theHasTexels,
146                                                            const gp_Pnt2d&        theUVOrigin,
147                                                            const gp_Pnt2d&        theUVRepeat,
148                                                            const gp_Pnt2d&        theUVScale)
149   {
150     Handle(Poly_Triangulation) aT;
151     TopLoc_Location aLoc;
152     gp_Pnt aPoint;
153     Standard_Integer aNbTriangles = 0;
154     Standard_Integer aNbVertices  = 0;
155
156     // Precision for compare square distances
157     const Standard_Real aPreci = Precision::SquareConfusion();
158
159     TopExp_Explorer aFaceIt(theShape, TopAbs_FACE);
160     for (; aFaceIt.More(); aFaceIt.Next())
161     {
162       const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
163       aT = BRep_Tool::Triangulation (aFace, aLoc);
164       if (!aT.IsNull())
165       {
166         aNbTriangles += aT->NbTriangles();
167         aNbVertices  += aT->NbNodes();
168       }
169     }
170     if (aNbVertices  <  3 || aNbTriangles <= 0)
171     {
172       return Handle(Graphic3d_ArrayOfTriangles)();
173     }
174
175     Handle(Graphic3d_ArrayOfTriangles) anArray = new Graphic3d_ArrayOfTriangles (aNbVertices, 3 * aNbTriangles,
176                                                                                  Standard_True, Standard_False, theHasTexels);
177     Standard_Real aUmin (0.0), aUmax (0.0), aVmin (0.0), aVmax (0.0), dUmax (0.0), dVmax (0.0);
178     for (aFaceIt.Init (theShape, TopAbs_FACE); aFaceIt.More(); aFaceIt.Next())
179     {
180       const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
181       aT = BRep_Tool::Triangulation (aFace, aLoc);
182       if (aT.IsNull())
183       {
184         continue;
185       }
186       const gp_Trsf& aTrsf = aLoc.Transformation();
187
188       // Determinant of transform matrix less then 0 means that mirror transform applied.
189       Standard_Boolean isMirrored = aTrsf.VectorialPart().Determinant() < 0;
190
191       Poly_Connect aPolyConnect (aT);
192       // Extracts vertices & normals from nodes
193       const TColgp_Array1OfPnt&   aNodes   = aT->Nodes();
194       const TColgp_Array1OfPnt2d& aUVNodes = aT->UVNodes();
195       TColgp_Array1OfDir aNormals (aNodes.Lower(), aNodes.Upper());
196       StdPrs_ToolTriangulatedShape::Normal (aFace, aPolyConnect, aNormals);
197
198       if (theHasTexels)
199       {
200         BRepTools::UVBounds (aFace, aUmin, aUmax, aVmin, aVmax);
201         dUmax = (aUmax - aUmin);
202         dVmax = (aVmax - aVmin);
203       }
204
205       const Standard_Integer aDecal = anArray->VertexNumber();
206       for (Standard_Integer aNodeIter = aNodes.Lower(); aNodeIter <= aNodes.Upper(); ++aNodeIter)
207       {
208         aPoint = aNodes (aNodeIter);
209         if (!aLoc.IsIdentity())
210         {
211           aPoint.Transform (aTrsf);
212
213           aNormals (aNodeIter) = aNormals (aNodeIter).Transformed (aTrsf);
214         }
215
216         if (theHasTexels && aUVNodes.Upper() == aNodes.Upper())
217         {
218           const gp_Pnt2d aTexel = gp_Pnt2d ((-theUVOrigin.X() + (theUVRepeat.X() * (aUVNodes (aNodeIter).X() - aUmin)) / dUmax) / theUVScale.X(),
219                                             (-theUVOrigin.Y() + (theUVRepeat.Y() * (aUVNodes (aNodeIter).Y() - aVmin)) / dVmax) / theUVScale.Y());
220           anArray->AddVertex (aPoint, aNormals (aNodeIter), aTexel);
221         }
222         else
223         {
224           anArray->AddVertex (aPoint, aNormals (aNodeIter));
225         }
226       }
227
228       // Fill array with vertex and edge visibility info
229       const Poly_Array1OfTriangle& aTriangles = aT->Triangles();
230       Standard_Integer anIndex[3];
231       for (Standard_Integer aTriIter = 1; aTriIter <= aT->NbTriangles(); ++aTriIter)
232       {
233         if ((aFace.Orientation() == TopAbs_REVERSED) ^ isMirrored)
234         {
235           aTriangles (aTriIter).Get (anIndex[0], anIndex[2], anIndex[1]);
236         }
237         else
238         {
239           aTriangles (aTriIter).Get (anIndex[0], anIndex[1], anIndex[2]);
240         }
241
242         gp_Pnt aP1 = aNodes (anIndex[0]);
243         gp_Pnt aP2 = aNodes (anIndex[1]);
244         gp_Pnt aP3 = aNodes (anIndex[2]);
245
246         gp_Vec aV1 (aP1, aP2);
247         if (aV1.SquareMagnitude() <= aPreci)
248         {
249           continue;
250         }
251         gp_Vec aV2 (aP2, aP3);
252         if (aV2.SquareMagnitude() <= aPreci)
253         {
254           continue;
255         }
256         gp_Vec aV3 (aP3, aP1);
257         if (aV3.SquareMagnitude() <= aPreci)
258         {
259           continue;
260         }
261         aV1.Normalize();
262         aV2.Normalize();
263         aV1.Cross (aV2);
264         if (aV1.SquareMagnitude() > aPreci)
265         {
266           anArray->AddEdge (anIndex[0] + aDecal);
267           anArray->AddEdge (anIndex[1] + aDecal);
268           anArray->AddEdge (anIndex[2] + aDecal);
269         }
270       }
271     }
272     return anArray;
273   }
274
275   //! Prepare shaded presentation for specified shape
276   static Standard_Boolean shadeFromShape (const TopoDS_Shape&               theShape,
277                                           const Handle(Prs3d_Presentation)& thePrs,
278                                           const Handle(Prs3d_Drawer)&       theDrawer,
279                                           const Standard_Boolean            theHasTexels,
280                                           const gp_Pnt2d&                   theUVOrigin,
281                                           const gp_Pnt2d&                   theUVRepeat,
282                                           const gp_Pnt2d&                   theUVScale,
283                                           const Standard_Boolean            theIsClosed)
284   {
285     Handle(Graphic3d_ArrayOfTriangles) aPArray = fillTriangles (theShape, theHasTexels, theUVOrigin, theUVRepeat, theUVScale);
286     if (aPArray.IsNull())
287     {
288       return Standard_False;
289     }
290
291     Handle(Graphic3d_Group) aGroup = Prs3d_Root::NewGroup (thePrs);
292     aGroup->SetClosed (theIsClosed);
293     if (!theDrawer->ShadingAspectGlobal())
294     {
295       Handle(Graphic3d_AspectFillArea3d) anAsp = theDrawer->ShadingAspect()->Aspect();
296       theIsClosed ? anAsp->SuppressBackFace() : anAsp->AllowBackFace();
297       aGroup->SetGroupPrimitivesAspect (anAsp);
298     }
299     aGroup->AddPrimitiveArray (aPArray);
300     return Standard_True;
301   }
302
303   //! Compute boundary presentation for faces of the shape.
304   static void computeFaceBoundaries (const TopoDS_Shape&               theShape,
305                                      const Handle(Prs3d_Presentation)& thePrs,
306                                      const Handle(Prs3d_Drawer)&       theDrawer)
307   {
308     // collection of all triangulation nodes on edges
309     // for computing boundaries presentation
310     NCollection_List<Handle(TColgp_HArray1OfPnt)> aNodeCollection;
311     Standard_Integer aNodeNumber = 0;
312
313     TopLoc_Location aTrsf;
314
315     // explore all boundary edges
316     TopTools_IndexedDataMapOfShapeListOfShape anEdgesMap;
317     TopExp::MapShapesAndAncestors (
318       theShape, TopAbs_EDGE, TopAbs_FACE, anEdgesMap);
319
320     Standard_Integer anEdgeIdx = 1;
321     for ( ; anEdgeIdx <= anEdgesMap.Extent (); anEdgeIdx++)
322     {
323       // reject free edges
324       const TopTools_ListOfShape& aFaceList = anEdgesMap.FindFromIndex (anEdgeIdx);
325       if (aFaceList.Extent() == 0)
326         continue;
327
328       // take one of the shared edges and get edge triangulation
329       const TopoDS_Face& aFace  = TopoDS::Face (aFaceList.First ());
330       const TopoDS_Edge& anEdge = TopoDS::Edge (anEdgesMap.FindKey (anEdgeIdx));
331
332       Handle(Poly_Triangulation) aTriangulation =
333         BRep_Tool::Triangulation (aFace, aTrsf);
334
335       if (aTriangulation.IsNull ())
336         continue;
337
338       Handle(Poly_PolygonOnTriangulation) anEdgePoly =
339         BRep_Tool::PolygonOnTriangulation (anEdge, aTriangulation, aTrsf);
340
341       if (anEdgePoly.IsNull ())
342         continue;
343
344       // get edge nodes indexes from face triangulation
345       const TColgp_Array1OfPnt& aTriNodes = aTriangulation->Nodes ();
346       const TColStd_Array1OfInteger& anEdgeNodes = anEdgePoly->Nodes ();
347
348       if (anEdgeNodes.Length () < 2)
349         continue;
350
351       // collect the edge nodes
352       Handle(TColgp_HArray1OfPnt) aCollected =
353         new TColgp_HArray1OfPnt (anEdgeNodes.Lower (), anEdgeNodes.Upper ());
354
355       Standard_Integer aNodeIdx = anEdgeNodes.Lower ();
356       for ( ; aNodeIdx <= anEdgeNodes.Upper (); aNodeIdx++)
357       {
358         // node index in face triangulation
359         Standard_Integer aTriIndex = anEdgeNodes.Value (aNodeIdx);
360
361         // get node and apply location transformation to the node
362         gp_Pnt aTriNode = aTriNodes.Value (aTriIndex);
363         if (!aTrsf.IsIdentity ())
364           aTriNode.Transform (aTrsf);
365
366         // add node to the boundary array
367         aCollected->SetValue (aNodeIdx, aTriNode);
368       }
369
370       aNodeNumber += anEdgeNodes.Length ();
371       aNodeCollection.Append (aCollected);
372     }
373
374     // check if it possible to continue building the presentation
375     if (aNodeNumber == 0)
376       return;
377
378     // allocate polyline array for presentation
379     Standard_Integer aSegmentEdgeNb = 
380       (aNodeNumber - aNodeCollection.Extent()) * 2;
381
382     Handle(Graphic3d_ArrayOfSegments) aSegments = 
383       new Graphic3d_ArrayOfSegments (aNodeNumber, aSegmentEdgeNb);
384
385     // build presentation for edge bondaries
386     NCollection_List<Handle(TColgp_HArray1OfPnt)>::Iterator 
387       aCollIt (aNodeCollection);
388
389     // the edge index is increased in each iteration step to
390     // avoid contiguous segments between different face edges.
391     for ( ; aCollIt.More(); aCollIt.Next () )
392     {
393       const Handle(TColgp_HArray1OfPnt)& aNodeArray = aCollIt.Value ();
394
395       Standard_Integer aNodeIdx = aNodeArray->Lower ();
396
397       // add first node (this node is not shared with previous segment).
398       // for each face edge, indices for sharing nodes 
399       // between segments begin from the first added node.
400       Standard_Integer aSegmentEdge = 
401         aSegments->AddVertex (aNodeArray->Value (aNodeIdx));
402
403       // add subsequent nodes and provide edge indexes for sharing
404       // the nodes between the sequential segments.
405       for ( aNodeIdx++; aNodeIdx <= aNodeArray->Upper (); aNodeIdx++ )
406       {
407         aSegments->AddVertex (aNodeArray->Value (aNodeIdx));
408         aSegments->AddEdge (  aSegmentEdge);
409         aSegments->AddEdge (++aSegmentEdge);
410       }
411     }
412
413     // set up aspect and add polyline data
414     Handle(Graphic3d_AspectLine3d) aBoundaryAspect = 
415       theDrawer->FaceBoundaryAspect ()->Aspect ();
416
417     Handle(Graphic3d_Group) aPrsGrp = Prs3d_Root::CurrentGroup (thePrs);
418     aPrsGrp->SetGroupPrimitivesAspect (aBoundaryAspect);
419     aPrsGrp->AddPrimitiveArray (aSegments);
420   }
421 }
422
423 // =======================================================================
424 // function : ExploreSolids
425 // purpose  :
426 // =======================================================================
427 void StdPrs_ShadedShape::ExploreSolids (const TopoDS_Shape&    theShape,
428                                         const BRep_Builder&    theBuilder,
429                                         TopoDS_Compound&       theClosed,
430                                         TopoDS_Compound&       theOpened,
431                                         const Standard_Boolean theIgnore1DSubShape)
432 {
433   if (theShape.IsNull())
434   {
435     return;
436   }
437
438   switch (theShape.ShapeType())
439   {
440     case TopAbs_COMPOUND:
441     case TopAbs_COMPSOLID:
442     {
443       for (TopoDS_Iterator anIter (theShape); anIter.More(); anIter.Next())
444       {
445         ExploreSolids (anIter.Value(), theBuilder, theClosed, theOpened, theIgnore1DSubShape);
446       }
447       return;
448     }
449     case TopAbs_SOLID:
450     {
451       for (TopoDS_Iterator anIter (theShape); anIter.More(); anIter.Next())
452       {
453         const TopoDS_Shape& aSubShape   = anIter.Value();
454         const Standard_Boolean isClosed = aSubShape.ShapeType() == TopAbs_SHELL &&
455                                           BRep_Tool::IsClosed (aSubShape)       &&
456                                           StdPrs_ToolTriangulatedShape::IsTriangulated (aSubShape);
457         theBuilder.Add (isClosed ? theClosed : theOpened, aSubShape);
458       }
459       return;
460     }
461     case TopAbs_SHELL:
462     case TopAbs_FACE:
463     {
464       theBuilder.Add (theOpened, theShape);
465       return;
466     }
467     case TopAbs_WIRE:
468     case TopAbs_EDGE:
469     case TopAbs_VERTEX:
470     {
471       if (!theIgnore1DSubShape)
472       {
473         theBuilder.Add (theOpened, theShape);
474       }
475       return;
476     }
477     case TopAbs_SHAPE:
478     default:
479       return;
480   }
481 }
482
483 // =======================================================================
484 // function : Add
485 // purpose  :
486 // =======================================================================
487 void StdPrs_ShadedShape::Add (const Handle(Prs3d_Presentation)& thePrs,
488                               const TopoDS_Shape&               theShape,
489                               const Handle(Prs3d_Drawer)&       theDrawer,
490                               const StdPrs_Volume               theVolume)
491 {
492   gp_Pnt2d aDummy;
493   StdPrs_ShadedShape::Add (thePrs, theShape, theDrawer,
494                            Standard_False, aDummy, aDummy, aDummy, theVolume);
495 }
496
497 // =======================================================================
498 // function : Add
499 // purpose  :
500 // =======================================================================
501 void StdPrs_ShadedShape::Add (const Handle (Prs3d_Presentation)& thePrs,
502                               const TopoDS_Shape&                theShape,
503                               const Handle (Prs3d_Drawer)&       theDrawer,
504                               const Standard_Boolean             theHasTexels,
505                               const gp_Pnt2d&                    theUVOrigin,
506                               const gp_Pnt2d&                    theUVRepeat,
507                               const gp_Pnt2d&                    theUVScale,
508                               const StdPrs_Volume                theVolume)
509 {
510   if (theShape.IsNull())
511   {
512     return;
513   }
514
515   // add wireframe presentation for isolated edges and vertices
516   wireframeFromShape (thePrs, theShape, theDrawer);
517
518   // Use automatic re-triangulation with deflection-check logic only if this feature is enable
519   if (theDrawer->IsAutoTriangulation())
520   {
521     // Triangulation completeness is important for "open-closed" analysis - perform tessellation beforehand
522     StdPrs_ToolTriangulatedShape::Tessellate (theShape, theDrawer);
523   }
524
525   // add special wireframe presentation for faces without triangulation
526   wireframeNoTriangFacesFromShape (thePrs, theShape, theDrawer);
527
528   // The shape types listed below need advanced analysis as potentially containing
529   // both closed and open parts. Solids are also included, because they might
530   // contain non-manifold parts inside (internal open shells)
531   if ((theShape.ShapeType() == TopAbs_COMPOUND
532     || theShape.ShapeType() == TopAbs_COMPSOLID
533     || theShape.ShapeType() == TopAbs_SOLID)
534    &&  theVolume == StdPrs_Volume_Autodetection)
535   {
536     // collect two compounds: for opened and closed (solid) sub-shapes
537     TopoDS_Compound anOpened, aClosed;
538     BRep_Builder aBuilder;
539     aBuilder.MakeCompound (aClosed);
540     aBuilder.MakeCompound (anOpened);
541     ExploreSolids (theShape, aBuilder, aClosed, anOpened, Standard_True);
542
543     TopoDS_Iterator aShapeIter (aClosed);
544     if (aShapeIter.More())
545     {
546       shadeFromShape (aClosed, thePrs, theDrawer,
547                       theHasTexels, theUVOrigin, theUVRepeat, theUVScale, Standard_True);
548     }
549
550     aShapeIter.Initialize (anOpened);
551     if (aShapeIter.More())
552     {
553       shadeFromShape (anOpened, thePrs, theDrawer,
554                       theHasTexels, theUVOrigin, theUVRepeat, theUVScale, Standard_False);
555     }
556   }
557   else
558   {
559     // if the shape type is not compound, composolid or solid, use autodetection back-facing filled
560     shadeFromShape (theShape, thePrs, theDrawer,
561                     theHasTexels, theUVOrigin, theUVRepeat, theUVScale,
562                     (theVolume == StdPrs_Volume_Closed ? Standard_True : Standard_False));
563   }
564
565   if (theDrawer->FaceBoundaryDraw())
566   {
567     computeFaceBoundaries (theShape, thePrs, theDrawer);
568   }
569 }