0030805: Visualization, StdSelect_BRepSelectionTool - empty sensitivity from polygon...
[occt.git] / src / StdSelect / StdSelect_BRepSelectionTool.cxx
1 // Created on: 1995-03-14
2 // Created by: Robert COUBLANC
3 // Copyright (c) 1995-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 <StdSelect_BRepSelectionTool.hxx>
18
19 #include <Bnd_Box.hxx>
20 #include <BRep_Tool.hxx>
21 #include <BRepAdaptor_Curve.hxx>
22 #include <BRepAdaptor_Surface.hxx>
23 #include <BRepBndLib.hxx>
24 #include <BRepMesh_IncrementalMesh.hxx>
25 #include <BRepTools.hxx>
26 #include <BRepTools_WireExplorer.hxx>
27 #include <GCPnts_TangentialDeflection.hxx>
28 #include <Geom_Circle.hxx>
29 #include <GeomAbs_SurfaceType.hxx>
30 #include <GeomAdaptor_Curve.hxx>
31 #include <gp_Circ.hxx>
32 #include <Poly_Array1OfTriangle.hxx>
33 #include <Poly_Polygon3D.hxx>
34 #include <Poly_PolygonOnTriangulation.hxx>
35 #include <Poly_Triangulation.hxx>
36 #include <Precision.hxx>
37 #include <Select3D_SensitiveBox.hxx>
38 #include <Select3D_SensitiveCircle.hxx>
39 #include <Select3D_SensitiveCurve.hxx>
40 #include <Select3D_SensitiveEntity.hxx>
41 #include <Select3D_SensitiveFace.hxx>
42 #include <Select3D_SensitiveGroup.hxx>
43 #include <Select3D_SensitivePoint.hxx>
44 #include <Select3D_SensitiveSegment.hxx>
45 #include <Select3D_SensitiveTriangle.hxx>
46 #include <Select3D_SensitiveTriangulation.hxx>
47 #include <Select3D_SensitiveWire.hxx>
48 #include <Select3D_TypeOfSensitivity.hxx>
49 #include <SelectMgr_EntityOwner.hxx>
50 #include <SelectMgr_SelectableObject.hxx>
51 #include <SelectMgr_Selection.hxx>
52 #include <Standard_ErrorHandler.hxx>
53 #include <Standard_NullObject.hxx>
54 #include <StdSelect_BRepOwner.hxx>
55 #include <TColgp_HArray1OfPnt.hxx>
56 #include <TColgp_SequenceOfPnt.hxx>
57 #include <TColStd_Array1OfReal.hxx>
58 #include <TopExp.hxx>
59 #include <TopExp_Explorer.hxx>
60 #include <TopoDS.hxx>
61 #include <TopoDS_Face.hxx>
62 #include <TopoDS_Shape.hxx>
63 #include <TopoDS_Wire.hxx>
64 #include <TopTools_IndexedMapOfShape.hxx>
65
66 #define BVH_PRIMITIVE_LIMIT 800000
67
68 //==================================================
69 // function: PreBuildBVH
70 // purpose : Pre-builds BVH tree for heavyweight
71 //           sensitive entities with sub-elements
72 //           amount more than BVH_PRIMITIVE_LIMIT
73 //==================================================
74 void StdSelect_BRepSelectionTool::PreBuildBVH (const Handle(SelectMgr_Selection)& theSelection)
75 {
76   for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator aSelEntIter (theSelection->Entities()); aSelEntIter.More(); aSelEntIter.Next())
77   {
78     const Handle(Select3D_SensitiveEntity)& aSensitive = aSelEntIter.Value()->BaseSensitive();
79     if (aSensitive->NbSubElements() >= BVH_PRIMITIVE_LIMIT)
80     {
81       aSensitive->BVH();
82     }
83
84     if (!aSensitive->IsInstance (STANDARD_TYPE(Select3D_SensitiveGroup)))
85     {
86       continue;
87     }
88
89     Handle(Select3D_SensitiveGroup) aGroup = Handle(Select3D_SensitiveGroup)::DownCast (aSensitive);
90     for (Select3D_IndexedMapOfEntity::Iterator aSubEntitiesIter (aGroup->Entities()); aSubEntitiesIter.More(); aSubEntitiesIter.Next())
91     {
92       const Handle(Select3D_SensitiveEntity)& aSubEntity = aSubEntitiesIter.Value();
93       if (aSubEntity->NbSubElements() >= BVH_PRIMITIVE_LIMIT)
94       {
95         aSubEntity->BVH();
96       }
97     }
98   }
99 }
100
101 //==================================================
102 // Function: Load
103 // Purpose :
104 //==================================================
105 void StdSelect_BRepSelectionTool::Load (const Handle(SelectMgr_Selection)& theSelection,
106                                         const TopoDS_Shape& theShape,
107                                         const TopAbs_ShapeEnum theType,
108                                         const Standard_Real theDeflection,
109                                         const Standard_Real theDeviationAngle,
110                                         const Standard_Boolean isAutoTriangulation,
111                                         const Standard_Integer thePriority,
112                                         const Standard_Integer theNbPOnEdge,
113                                         const Standard_Real theMaxParam)
114 {
115   Standard_Integer aPriority = (thePriority == -1) ? GetStandardPriority (theShape, theType) : thePriority;
116
117   if( isAutoTriangulation && !BRepTools::Triangulation (theShape, Precision::Infinite()) )
118   {
119     BRepMesh_IncrementalMesh aMesher(theShape, theDeflection, Standard_False, theDeviationAngle);
120   }
121
122   Handle(StdSelect_BRepOwner) aBrepOwner;
123   switch (theType)
124   {
125     case TopAbs_VERTEX:
126     case TopAbs_EDGE:
127     case TopAbs_WIRE:
128     case TopAbs_FACE:
129     case TopAbs_SHELL:
130     case TopAbs_SOLID:
131     case TopAbs_COMPSOLID:
132     {
133       TopTools_IndexedMapOfShape aSubShapes;
134       TopExp::MapShapes (theShape, theType, aSubShapes);
135
136       Standard_Boolean isComesFromDecomposition = !((aSubShapes.Extent() == 1) && (theShape == aSubShapes (1)));
137       for (Standard_Integer aShIndex = 1; aShIndex <= aSubShapes.Extent(); ++aShIndex)
138       {
139         const TopoDS_Shape& aSubShape = aSubShapes (aShIndex);
140         aBrepOwner = new StdSelect_BRepOwner (aSubShape, aPriority, isComesFromDecomposition);
141         ComputeSensitive (aSubShape, aBrepOwner,
142                           theSelection,
143                           theDeflection,
144                           theDeviationAngle,
145                           theNbPOnEdge,
146                           theMaxParam,
147                           isAutoTriangulation);
148       }
149       break;
150     }
151     default:
152     {
153       aBrepOwner = new StdSelect_BRepOwner (theShape, aPriority);
154       ComputeSensitive (theShape, aBrepOwner,
155                         theSelection,
156                         theDeflection,
157                         theDeviationAngle,
158                         theNbPOnEdge,
159                         theMaxParam,
160                         isAutoTriangulation);
161     }
162   }
163 }
164
165 //==================================================
166 // Function: Load
167 // Purpose :
168 //==================================================
169 void StdSelect_BRepSelectionTool::Load (const Handle(SelectMgr_Selection)& theSelection,
170                                         const Handle(SelectMgr_SelectableObject)& theSelectableObj,
171                                         const TopoDS_Shape& theShape,
172                                         const TopAbs_ShapeEnum theType,
173                                         const Standard_Real theDeflection,
174                                         const Standard_Real theDeviationAngle,
175                                         const Standard_Boolean isAutoTriangulation,
176                                         const Standard_Integer thePriority,
177                                         const Standard_Integer theNbPOnEdge,
178                                         const Standard_Real theMaxParam)
179 {
180   Load (theSelection,
181         theShape,
182         theType,
183         theDeflection,
184         theDeviationAngle,
185         isAutoTriangulation,
186         thePriority,
187         theNbPOnEdge,
188         theMaxParam);
189
190   // loading of selectables...
191   for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator aSelEntIter (theSelection->Entities()); aSelEntIter.More(); aSelEntIter.Next())
192   {
193     const Handle(SelectMgr_EntityOwner)& anOwner = aSelEntIter.Value()->BaseSensitive()->OwnerId();
194     anOwner->SetSelectable (theSelectableObj);
195   }
196
197   PreBuildBVH (theSelection);
198 }
199
200 //==================================================
201 // Function: ComputeSensitive
202 // Purpose :
203 //==================================================
204 void StdSelect_BRepSelectionTool::ComputeSensitive (const TopoDS_Shape& theShape,
205                                                     const Handle(SelectMgr_EntityOwner)& theOwner,
206                                                     const Handle(SelectMgr_Selection)& theSelection,
207                                                     const Standard_Real theDeflection,
208                                                     const Standard_Real theDeviationAngle,
209                                                     const Standard_Integer theNbPOnEdge,
210                                                     const Standard_Real theMaxParam,
211                                                     const Standard_Boolean isAutoTriangulation)
212 {
213   switch (theShape.ShapeType())
214   {
215     case TopAbs_VERTEX:
216     {
217       theSelection->Add (new Select3D_SensitivePoint
218                          (theOwner, BRep_Tool::Pnt (TopoDS::Vertex (theShape))));
219       break;
220     }
221     case TopAbs_EDGE:
222     {
223       Handle(Select3D_SensitiveEntity) aSensitive;
224       GetEdgeSensitive (theShape, theOwner, theSelection,
225                         theDeflection, theDeviationAngle, theNbPOnEdge, theMaxParam,
226                         aSensitive);
227       if (!aSensitive.IsNull())
228       {
229         theSelection->Add (aSensitive);
230       }
231       break;
232     }
233     case TopAbs_WIRE:
234     {
235       BRepTools_WireExplorer aWireExp (TopoDS::Wire (theShape));
236       Handle (Select3D_SensitiveEntity) aSensitive;
237       Handle (Select3D_SensitiveWire) aWireSensitive = new Select3D_SensitiveWire (theOwner);
238       theSelection->Add (aWireSensitive);
239       while (aWireExp.More())
240       {
241         GetEdgeSensitive (aWireExp.Current(), theOwner, theSelection,
242                           theDeflection, theDeviationAngle, theNbPOnEdge, theMaxParam,
243                           aSensitive);
244         if (!aSensitive.IsNull())
245         {
246           aWireSensitive->Add (aSensitive);
247         }
248         aWireExp.Next();
249       }
250       break;
251     }
252     case TopAbs_FACE:
253     {
254       const TopoDS_Face& aFace = TopoDS::Face (theShape);
255       Select3D_EntitySequence aSensitiveList;
256       GetSensitiveForFace (aFace, theOwner,
257                            aSensitiveList,
258                            isAutoTriangulation, theNbPOnEdge, theMaxParam);
259       for (Select3D_EntitySequenceIter aSensIter (aSensitiveList);
260            aSensIter.More(); aSensIter.Next())
261       {
262         theSelection->Add (aSensIter.Value());
263       }
264       break;
265     }
266     case TopAbs_SHELL:
267     case TopAbs_SOLID:
268     case TopAbs_COMPSOLID:
269     {
270       TopTools_IndexedMapOfShape aSubfacesMap;
271       TopExp::MapShapes (theShape, TopAbs_FACE, aSubfacesMap);
272       for (Standard_Integer aShIndex = 1; aShIndex <= aSubfacesMap.Extent(); ++aShIndex)
273       {
274         ComputeSensitive (aSubfacesMap (aShIndex), theOwner,
275                           theSelection,
276                           theDeflection, theDeviationAngle, theNbPOnEdge, theMaxParam, isAutoTriangulation);
277       }
278       break;
279     }
280     case TopAbs_COMPOUND:
281     default:
282     {
283       TopExp_Explorer anExp;
284       // sub-vertices
285       for (anExp.Init (theShape, TopAbs_VERTEX, TopAbs_EDGE); anExp.More(); anExp.Next())
286       {
287         ComputeSensitive (anExp.Current(), theOwner,
288                           theSelection,
289                           theDeflection, theDeviationAngle, theNbPOnEdge, theMaxParam, isAutoTriangulation);
290       }
291       // sub-edges
292       for (anExp.Init (theShape, TopAbs_EDGE, TopAbs_FACE); anExp.More(); anExp.Next())
293       {
294         ComputeSensitive (anExp.Current(), theOwner,
295                           theSelection,
296                           theDeflection, theDeviationAngle, theNbPOnEdge, theMaxParam, isAutoTriangulation);
297       }
298       // sub-wires
299       for (anExp.Init (theShape, TopAbs_WIRE, TopAbs_FACE); anExp.More(); anExp.Next())
300       {
301         ComputeSensitive (anExp.Current(), theOwner,
302                           theSelection,
303                           theDeflection, theDeviationAngle, theNbPOnEdge, theMaxParam, isAutoTriangulation);
304       }
305
306       // sub-faces
307       TopTools_IndexedMapOfShape aSubfacesMap;
308       TopExp::MapShapes (theShape, TopAbs_FACE, aSubfacesMap);
309       for (Standard_Integer aShIndex = 1; aShIndex <= aSubfacesMap.Extent(); ++aShIndex)
310       {
311         ComputeSensitive (aSubfacesMap (aShIndex), theOwner,
312                           theSelection,
313                           theDeflection, theDeviationAngle, theNbPOnEdge, theMaxParam, isAutoTriangulation);
314       }
315     }
316   }
317 }
318
319 //==================================================
320 // Function: GetPointsFromPolygon
321 // Purpose :
322 //==================================================
323 static Handle(TColgp_HArray1OfPnt) GetPointsFromPolygon (const TopoDS_Edge& theEdge)
324 {
325   Handle(TColgp_HArray1OfPnt) aResultPoints;
326
327   TopLoc_Location aLocation;
328   Handle(Poly_Polygon3D) aPolygon = BRep_Tool::Polygon3D (theEdge, aLocation);
329   if (!aPolygon.IsNull())
330   {
331     const TColgp_Array1OfPnt& aNodes = aPolygon->Nodes();
332     aResultPoints = new TColgp_HArray1OfPnt (1, aNodes.Length());
333     if (aLocation.IsIdentity())
334     {
335       for (Standard_Integer aNodeId (aNodes.Lower()), aPntId (1); aNodeId <= aNodes.Upper(); ++aNodeId, ++aPntId)
336       {
337         aResultPoints->SetValue (aPntId, aNodes.Value (aNodeId));
338       }
339     }
340     else
341     {
342       for (Standard_Integer aNodeId (aNodes.Lower()), aPntId (1); aNodeId <= aNodes.Upper(); ++aNodeId, ++aPntId)
343       {
344         aResultPoints->SetValue (aPntId, aNodes.Value (aNodeId).Transformed (aLocation));
345       }
346     }
347     return aResultPoints;
348   }
349
350   Handle(Poly_Triangulation) aTriangulation;
351   Handle(Poly_PolygonOnTriangulation) anHIndices;
352   BRep_Tool::PolygonOnTriangulation (theEdge, anHIndices, aTriangulation, aLocation);
353   if (!anHIndices.IsNull())
354   {
355     const TColStd_Array1OfInteger& anIndices = anHIndices->Nodes();
356     const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
357
358     aResultPoints = new TColgp_HArray1OfPnt (1, anIndices.Length());
359
360     if (aLocation.IsIdentity())
361     {
362       for (Standard_Integer anIndex (anIndices.Lower()), aPntId (1); anIndex <= anIndices.Upper(); ++anIndex, ++aPntId)
363       {
364         aResultPoints->SetValue (aPntId, aNodes (anIndices (anIndex)));
365       }
366     }
367     else
368     {
369       for (Standard_Integer anIndex (anIndices.Lower()), aPntId (1); anIndex <= anIndices.Upper(); ++anIndex, ++aPntId)
370       {
371         aResultPoints->SetValue (aPntId, aNodes (anIndices (anIndex)).Transformed (aLocation));
372       }
373     }
374     return aResultPoints;
375   }
376   return aResultPoints;
377 }
378
379 //==================================================
380 // Function: FindLimits
381 // Purpose :
382 //==================================================
383 static Standard_Boolean FindLimits (const Adaptor3d_Curve& theCurve,
384                                     const Standard_Real    theLimit,
385                                           Standard_Real&   theFirst,
386                                           Standard_Real&   theLast)
387 {
388   theFirst = theCurve.FirstParameter();
389   theLast  = theCurve.LastParameter();
390   Standard_Boolean isFirstInf = Precision::IsNegativeInfinite (theFirst);
391   Standard_Boolean isLastInf  = Precision::IsPositiveInfinite (theLast);
392   if (isFirstInf || isLastInf)
393   {
394     gp_Pnt aPnt1, aPnt2;
395     Standard_Real aDelta = 1.0;
396     Standard_Integer anIterCount = 0;
397     if (isFirstInf && isLastInf)
398     {
399       do {
400         if (anIterCount++ >= 100000) return Standard_False;
401         aDelta *= 2.0;
402         theFirst = - aDelta;
403         theLast  =   aDelta;
404         theCurve.D0 (theFirst, aPnt1);
405         theCurve.D0 (theLast,  aPnt2);
406       } while (aPnt1.Distance (aPnt2) < theLimit);
407     }
408     else if (isFirstInf)
409     {
410       theCurve.D0 (theLast, aPnt2);
411       do {
412         if (anIterCount++ >= 100000) return Standard_False;
413         aDelta *= 2.0;
414         theFirst = theLast - aDelta;
415         theCurve.D0 (theFirst, aPnt1);
416       } while (aPnt1.Distance (aPnt2) < theLimit);
417     }
418     else if (isLastInf)
419     {
420       theCurve.D0 (theFirst, aPnt1);
421       do {
422         if (anIterCount++ >= 100000) return Standard_False;
423         aDelta *= 2.0;
424         theLast = theFirst + aDelta;
425         theCurve.D0 (theLast, aPnt2);
426       } while (aPnt1.Distance (aPnt2) < theLimit);
427     }
428   }
429   return Standard_True;
430 }
431
432 //=====================================================
433 // Function : GetEdgeSensitive
434 // Purpose  :
435 //=====================================================
436 void StdSelect_BRepSelectionTool::GetEdgeSensitive (const TopoDS_Shape& theShape,
437                                                     const Handle(SelectMgr_EntityOwner)& theOwner,
438                                                     const Handle(SelectMgr_Selection)& theSelection,
439                                                     const Standard_Real theDeflection,
440                                                     const Standard_Real theDeviationAngle,
441                                                     const Standard_Integer theNbPOnEdge,
442                                                     const Standard_Real theMaxParam,
443                                                     Handle(Select3D_SensitiveEntity)& theSensitive)
444 {
445   const TopoDS_Edge& anEdge = TopoDS::Edge (theShape);
446   // try to get points from existing polygons
447   Handle(TColgp_HArray1OfPnt) aPoints = GetPointsFromPolygon (anEdge);
448   if (!aPoints.IsNull()
449    && !aPoints->IsEmpty())
450   {
451     theSensitive = new Select3D_SensitiveCurve (theOwner, aPoints);
452     return;
453   }
454
455   BRepAdaptor_Curve cu3d;
456   try {
457     OCC_CATCH_SIGNALS
458     cu3d.Initialize (anEdge);
459   } catch (Standard_NullObject const&) {
460     return;
461   }
462
463   Standard_Real aParamFirst = cu3d.FirstParameter();
464   Standard_Real aParamLast  = cu3d.LastParameter();
465   switch (cu3d.GetType())
466   {
467     case GeomAbs_Line:
468     {
469       BRep_Tool::Range (anEdge, aParamFirst, aParamLast);
470       theSensitive = new Select3D_SensitiveSegment (theOwner,
471                                                     cu3d.Value (aParamFirst),
472                                                     cu3d.Value (aParamLast));
473       break;
474     }
475     case GeomAbs_Circle:
476     {
477       Handle (Geom_Circle) aCircle = new Geom_Circle (cu3d.Circle());
478       if (aCircle->Radius() <= Precision::Confusion())
479       {
480         theSelection->Add (new Select3D_SensitivePoint (theOwner, aCircle->Location()));
481       }
482       else
483       {
484         theSensitive = new Select3D_SensitiveCircle (theOwner, aCircle,
485                                                      aParamFirst, aParamLast, Standard_False, 16);
486       }
487       break;
488     }
489     default:
490     {
491       // reproduce drawing behaviour
492       // TODO: remove copy-paste from StdPrs_Curve and some others...
493       if (FindLimits (cu3d, theMaxParam, aParamFirst, aParamLast))
494       {
495         Standard_Integer aNbIntervals = cu3d.NbIntervals (GeomAbs_C1);
496         TColStd_Array1OfReal anIntervals (1, aNbIntervals + 1);
497         cu3d.Intervals (anIntervals, GeomAbs_C1);
498         Standard_Real aV1, aV2;
499         Standard_Integer aNumberOfPoints;
500         TColgp_SequenceOfPnt aPointsSeq;
501         for (Standard_Integer anIntervalId = 1; anIntervalId <= aNbIntervals; ++anIntervalId)
502         {
503           aV1 = anIntervals (anIntervalId);
504           aV2 = anIntervals (anIntervalId + 1);
505           if (aV2 > aParamFirst && aV1 < aParamLast)
506           {
507             aV1 = Max (aV1, aParamFirst);
508             aV2 = Min (aV2, aParamLast);
509
510             GCPnts_TangentialDeflection anAlgo (cu3d, aV1, aV2, theDeviationAngle, theDeflection);
511             aNumberOfPoints = anAlgo.NbPoints();
512
513             for (Standard_Integer aPntId = 1; aPntId < aNumberOfPoints; ++aPntId)
514             {
515               aPointsSeq.Append (anAlgo.Value (aPntId));
516             }
517             if (aNumberOfPoints > 0 && anIntervalId == aNbIntervals)
518             {
519               aPointsSeq.Append (anAlgo.Value (aNumberOfPoints));
520             }
521           }
522         }
523
524         aPoints = new TColgp_HArray1OfPnt (1, aPointsSeq.Length());
525         for (Standard_Integer aPntId = 1; aPntId <= aPointsSeq.Length(); ++aPntId)
526         {
527           aPoints->SetValue (aPntId, aPointsSeq.Value (aPntId));
528         }
529         theSensitive = new Select3D_SensitiveCurve (theOwner, aPoints);
530         break;
531       }
532
533       // simple subdivisions
534       Standard_Integer nbintervals = 1;
535       if (cu3d.GetType() == GeomAbs_BSplineCurve)
536       {
537         nbintervals = cu3d.NbKnots() - 1;
538         nbintervals = Max (1, nbintervals / 3);
539       }
540
541       Standard_Real aParam;
542       Standard_Integer aPntNb = Max (2, theNbPOnEdge * nbintervals);
543       Standard_Real aParamDelta = (aParamLast - aParamFirst) / (aPntNb - 1);
544       Handle(TColgp_HArray1OfPnt) aPointArray = new TColgp_HArray1OfPnt (1, aPntNb);
545       for (Standard_Integer aPntId = 1; aPntId <= aPntNb; ++aPntId)
546       {
547         aParam = aParamFirst + aParamDelta * (aPntId - 1);
548         aPointArray->SetValue (aPntId, cu3d.Value (aParam));
549       }
550       theSensitive = new Select3D_SensitiveCurve (theOwner, aPointArray);
551     }
552     break;
553   }
554 }
555
556 //=======================================================================
557 //function : GetSensitiveEntityForFace
558 //purpose  :
559 //=======================================================================
560 Standard_Boolean StdSelect_BRepSelectionTool::GetSensitiveForFace (const TopoDS_Face& theFace,
561                                                                    const Handle(SelectMgr_EntityOwner)& theOwner,
562                                                                    Select3D_EntitySequence& theSensitiveList,
563                                                                    const Standard_Boolean /*theAutoTriangulation*/,
564                                                                    const Standard_Integer NbPOnEdge,
565                                                                    const Standard_Real    theMaxParam,
566                                                                    const Standard_Boolean theInteriorFlag)
567 {
568   TopLoc_Location aLoc;
569   if (Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (theFace, aLoc))
570   {
571     Handle(Select3D_SensitiveTriangulation) STG = new Select3D_SensitiveTriangulation (theOwner, aTriangulation, aLoc, theInteriorFlag);
572     theSensitiveList.Append (STG);
573     return Standard_True;
574   }
575
576   // for faces with triangulation bugs or without autotriangulation ....
577   // very ugly and should not even exist ...
578   BRepAdaptor_Surface BS (theFace);
579   if (BS.GetType() == GeomAbs_Plane)
580   {
581     const Standard_Real aFirstU = BS.FirstUParameter() <= -Precision::Infinite() ? -theMaxParam : BS.FirstUParameter();
582     const Standard_Real aLastU  = BS.LastUParameter()  >=  Precision::Infinite() ?  theMaxParam : BS.LastUParameter();
583     const Standard_Real aFirstV = BS.FirstVParameter() <= -Precision::Infinite() ? -theMaxParam : BS.FirstVParameter();
584     const Standard_Real aLastV  = BS.LastVParameter()  >=  Precision::Infinite() ?  theMaxParam : BS.LastVParameter();
585     Handle(TColgp_HArray1OfPnt) aPlanePnts = new TColgp_HArray1OfPnt (1, 5);
586     BS.D0 (aFirstU, aFirstV, aPlanePnts->ChangeValue (1));
587     BS.D0 (aLastU,  aFirstV, aPlanePnts->ChangeValue (2));
588     BS.D0 (aLastU,  aLastV,  aPlanePnts->ChangeValue (3));
589     BS.D0 (aFirstU, aLastV,  aPlanePnts->ChangeValue (4));
590     aPlanePnts->SetValue (5, aPlanePnts->Value (1));
591
592     // if the plane is "infinite", it is sensitive only on the border limited by MaxParam
593     const bool isInfinite = aFirstU == -theMaxParam
594                          && aLastU  ==  theMaxParam
595                          && aFirstV == -theMaxParam
596                          && aLastV  ==  theMaxParam;
597     theSensitiveList.Append (new Select3D_SensitiveFace (theOwner, aPlanePnts,
598                                                          theInteriorFlag && !isInfinite
599                                                        ? Select3D_TOS_INTERIOR
600                                                        : Select3D_TOS_BOUNDARY));
601     return Standard_True;
602   }
603
604   // This is construction of a sensitive polygon from the exterior contour of the face...
605   // It is not good at all, but...
606   TopoDS_Wire aWire;
607   {
608     TopExp_Explorer anExpWiresInFace (theFace, TopAbs_WIRE);
609     if (anExpWiresInFace.More())
610     {
611       // believing that this is the first... to be seen
612       aWire = TopoDS::Wire (anExpWiresInFace.Current());
613     }
614   }
615   if (aWire.IsNull())
616   {
617     return Standard_False;
618   }
619
620   TColgp_SequenceOfPnt aWirePoints;
621   Standard_Boolean isFirstExp = Standard_True;
622   BRepAdaptor_Curve cu3d;
623   for (BRepTools_WireExplorer aWireExplorer (aWire); aWireExplorer.More(); aWireExplorer.Next())
624   {
625     try
626     {
627       OCC_CATCH_SIGNALS
628       cu3d.Initialize (aWireExplorer.Current());
629     }
630     catch (Standard_NullObject const&)
631     {
632       continue;
633     }
634
635     Standard_Real wf = 0.0, wl = 0.0;
636     BRep_Tool::Range (aWireExplorer.Current(), wf, wl);
637     if (Abs (wf - wl) <= Precision::Confusion())
638     {
639     #ifdef OCCT_DEBUG
640       cout<<" StdSelect_BRepSelectionTool : Curve where ufirst = ulast ...."<<endl;
641     #endif
642       continue;
643     }
644
645     if (isFirstExp)
646     {
647       isFirstExp = Standard_False;
648       if (aWireExplorer.Orientation() == TopAbs_FORWARD)
649       {
650         aWirePoints.Append (cu3d.Value (wf));
651       }
652       else
653       {
654         aWirePoints.Append (cu3d.Value (wl));
655       }
656     }
657
658     switch (cu3d.GetType())
659     {
660       case GeomAbs_Line:
661       {
662         aWirePoints.Append (cu3d.Value ((aWireExplorer.Orientation() == TopAbs_FORWARD) ? wl : wf));
663         break;
664       }
665       case GeomAbs_Circle:
666       {
667         if (2.0 * M_PI - Abs (wl - wf) <= Precision::Confusion())
668         {
669           if (BS.GetType() == GeomAbs_Cylinder ||
670               BS.GetType() == GeomAbs_Torus ||
671               BS.GetType() == GeomAbs_Cone  ||
672               BS.GetType() == GeomAbs_BSplineSurface) // beuurkk pour l'instant...
673           {
674             Standard_Real ff = wf ,ll = wl;
675             Standard_Real dw =(Max (wf, wl) - Min (wf, wl)) / (Standard_Real )Max (2, NbPOnEdge - 1);
676             if (aWireExplorer.Orientation() == TopAbs_FORWARD)
677             {
678               for (Standard_Real wc = wf + dw; wc <= wl; wc += dw)
679               {
680                 aWirePoints.Append (cu3d.Value (wc));
681               }
682             }
683             else if (aWireExplorer.Orientation() == TopAbs_REVERSED)
684             {
685               for (Standard_Real wc = ll - dw; wc >= ff; wc -= dw)
686               {
687                 aWirePoints.Append (cu3d.Value (wc));
688               }
689             }
690           }
691           else
692           {
693             if (cu3d.Circle().Radius() <= Precision::Confusion())
694             {
695               theSensitiveList.Append (new Select3D_SensitivePoint (theOwner, cu3d.Circle().Location()));
696             }
697             else
698             {
699               theSensitiveList.Append (new Select3D_SensitiveCircle (theOwner, new Geom_Circle (cu3d.Circle()), theInteriorFlag, 16));
700             }
701           }
702         }
703         else
704         {
705           Standard_Real ff = wf, ll = wl;
706           Standard_Real dw = (Max (wf, wl) - Min (wf, wl)) / (Standard_Real )Max (2, NbPOnEdge - 1);
707           if (aWireExplorer.Orientation() == TopAbs_FORWARD)
708           {
709             for (Standard_Real wc = wf + dw; wc <= wl; wc += dw)
710             {
711               aWirePoints.Append (cu3d.Value (wc));
712             }
713           }
714           else if (aWireExplorer.Orientation() == TopAbs_REVERSED)
715           {
716             for (Standard_Real wc = ll - dw; wc >= ff; wc -= dw)
717             {
718               aWirePoints.Append (cu3d.Value (wc));
719             }
720           }
721         }
722         break;
723       }
724       default:
725       {
726         Standard_Real ff = wf, ll = wl;
727         Standard_Real dw = (Max (wf, wl) - Min (wf, wl)) / (Standard_Real )Max (2, NbPOnEdge - 1);
728         if (aWireExplorer.Orientation()==TopAbs_FORWARD)
729         {
730           for (Standard_Real wc = wf + dw; wc <= wl; wc += dw)
731           {
732             aWirePoints.Append (cu3d.Value (wc));
733           }
734         }
735         else if (aWireExplorer.Orientation() == TopAbs_REVERSED)
736         {
737           for (Standard_Real wc = ll - dw; wc >= ff; wc -= dw)
738           {
739             aWirePoints.Append (cu3d.Value (wc));
740           }
741         }
742       }
743     }
744   }
745
746   Handle(TColgp_HArray1OfPnt) aFacePoints = new TColgp_HArray1OfPnt (1, aWirePoints.Length());
747   {
748     Standard_Integer aPntIndex = 1;
749     for (TColgp_SequenceOfPnt::Iterator aPntIter (aWirePoints); aPntIter.More(); aPntIter.Next())
750     {
751       aFacePoints->SetValue (aPntIndex++, aPntIter.Value());
752     }
753   }
754
755   // 1 if only one circular edge
756   if (aFacePoints->Array1().Length() == 2)
757   {
758     theSensitiveList.Append (new Select3D_SensitiveCurve (theOwner, aFacePoints));
759   }
760   else if (aFacePoints->Array1().Length() > 2)
761   {
762     theSensitiveList.Append (new Select3D_SensitiveFace (theOwner, aFacePoints,
763                                                          theInteriorFlag
764                                                        ? Select3D_TOS_INTERIOR
765                                                        : Select3D_TOS_BOUNDARY));
766   }
767   return Standard_True;
768 }