0025695: Visualization, AIS_InteractiveContext - define default HilightMode
[occt.git] / src / StdSelect / StdSelect_BRepSelectionTool.cxx
CommitLineData
b311480e 1// Created on: 1995-03-14
2// Created by: Robert COUBLANC
3// Copyright (c) 1995-1999 Matra Datavision
973c2be1 4// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 5//
973c2be1 6// This file is part of Open CASCADE Technology software library.
b311480e 7//
d5f74e42 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
973c2be1 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.
b311480e 13//
973c2be1 14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
bbf32d01 16
f838dac4 17#include <StdSelect_BRepSelectionTool.hxx>
42cf5bc1 18
19#include <Bnd_Box.hxx>
20#include <BRep_Tool.hxx>
7fd59977 21#include <BRepAdaptor_Curve.hxx>
22#include <BRepAdaptor_Surface.hxx>
7fd59977 23#include <BRepBndLib.hxx>
42cf5bc1 24#include <BRepMesh_IncrementalMesh.hxx>
25#include <BRepTools.hxx>
26#include <BRepTools_WireExplorer.hxx>
27#include <GCPnts_TangentialDeflection.hxx>
7fd59977 28#include <Geom_Circle.hxx>
42cf5bc1 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>
7fd59977 38#include <Select3D_SensitiveCircle.hxx>
39#include <Select3D_SensitiveCurve.hxx>
42cf5bc1 40#include <Select3D_SensitiveEntity.hxx>
7fd59977 41#include <Select3D_SensitiveFace.hxx>
7fd59977 42#include <Select3D_SensitiveGroup.hxx>
42cf5bc1 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>
f751596e 51#include <SelectMgr_Selection.hxx>
42cf5bc1 52#include <Standard_ErrorHandler.hxx>
53#include <Standard_NullObject.hxx>
54#include <StdSelect_BRepOwner.hxx>
7fd59977 55#include <TColgp_HArray1OfPnt.hxx>
56#include <TColgp_SequenceOfPnt.hxx>
57#include <TColStd_Array1OfReal.hxx>
42cf5bc1 58#include <TopExp.hxx>
59#include <TopExp_Explorer.hxx>
60#include <TopoDS.hxx>
61#include <TopoDS_Face.hxx>
62#include <TopoDS_Shape.hxx>
bbf32d01 63#include <TopoDS_Wire.hxx>
42cf5bc1 64#include <TopTools_IndexedMapOfShape.hxx>
7fd59977 65
f751596e 66#define BVH_PRIMITIVE_LIMIT 800000
67
68//==================================================
114b7bf1 69// function: PreBuildBVH
f751596e 70// purpose : Pre-builds BVH tree for heavyweight
71// sensitive entities with sub-elements
72// amount more than BVH_PRIMITIVE_LIMIT
73//==================================================
114b7bf1 74void StdSelect_BRepSelectionTool::PreBuildBVH (const Handle(SelectMgr_Selection)& theSelection)
f751596e 75{
76 for (theSelection->Init(); theSelection->More(); theSelection->Next())
77 {
78 const Handle(SelectBasics_SensitiveEntity)& aSensitive = theSelection->Sensitive()->BaseSensitive();
79 if (aSensitive->NbSubElements() >= BVH_PRIMITIVE_LIMIT)
80 {
81 aSensitive->BVH();
82 }
83
84 if (aSensitive->IsInstance ("Select3D_SensitiveGroup"))
85 {
c5f3a425 86 Handle(Select3D_SensitiveGroup) aGroup (Handle(Select3D_SensitiveGroup)::DownCast (aSensitive));
f751596e 87 const Select3D_EntitySequence& aSubEntities = aGroup->GetEntities();
88 for (Select3D_EntitySequenceIter aSubEntitiesIter (aSubEntities); aSubEntitiesIter.More(); aSubEntitiesIter.Next())
89 {
90 const Handle(Select3D_SensitiveEntity)& aSubEntity = aSubEntitiesIter.Value();
91 if (aSubEntity->NbSubElements() >= BVH_PRIMITIVE_LIMIT)
92 {
93 aSubEntity->BVH();
94 }
95 }
96 }
97 }
98}
99
7fd59977 100//==================================================
bbf32d01
K
101// Function: Load
102// Purpose :
103//==================================================
f838dac4 104void StdSelect_BRepSelectionTool::Load (const Handle(SelectMgr_Selection)& theSelection,
105 const TopoDS_Shape& theShape,
106 const TopAbs_ShapeEnum theType,
107 const Standard_Real theDeflection,
108 const Standard_Real theDeviationAngle,
109 const Standard_Boolean isAutoTriangulation,
110 const Standard_Integer thePriority,
111 const Standard_Integer theNbPOnEdge,
112 const Standard_Real theMaxParam)
7fd59977 113{
bbf32d01 114 Standard_Integer aPriority = (thePriority == -1) ? GetStandardPriority (theShape, theType) : thePriority;
3c34883c
O
115
116 if( isAutoTriangulation && !BRepTools::Triangulation (theShape, Precision::Infinite()) )
117 {
14434f3e 118 BRepMesh_IncrementalMesh aMesher(theShape, theDeflection, Standard_False, theDeviationAngle);
3c34883c
O
119 }
120
bbf32d01
K
121 Handle(StdSelect_BRepOwner) aBrepOwner;
122 switch (theType)
123 {
124 case TopAbs_VERTEX:
125 case TopAbs_EDGE:
126 case TopAbs_WIRE:
127 case TopAbs_FACE:
128 case TopAbs_SHELL:
129 case TopAbs_SOLID:
130 case TopAbs_COMPSOLID:
7fd59977 131 {
bbf32d01
K
132 TopTools_IndexedMapOfShape aSubShapes;
133 TopExp::MapShapes (theShape, theType, aSubShapes);
134
135 Standard_Boolean isComesFromDecomposition = !((aSubShapes.Extent() == 1) && (theShape == aSubShapes (1)));
136 for (Standard_Integer aShIndex = 1; aShIndex <= aSubShapes.Extent(); ++aShIndex)
137 {
138 const TopoDS_Shape& aSubShape = aSubShapes (aShIndex);
139 aBrepOwner = new StdSelect_BRepOwner (aSubShape, aPriority, isComesFromDecomposition);
140 ComputeSensitive (aSubShape, aBrepOwner,
141 theSelection,
142 theDeflection,
143 theDeviationAngle,
144 theNbPOnEdge,
145 theMaxParam,
146 isAutoTriangulation);
7fd59977 147 }
148 break;
149 }
bbf32d01 150 default:
7fd59977 151 {
bbf32d01
K
152 aBrepOwner = new StdSelect_BRepOwner (theShape, aPriority);
153 ComputeSensitive (theShape, aBrepOwner,
154 theSelection,
155 theDeflection,
156 theDeviationAngle,
157 theNbPOnEdge,
158 theMaxParam,
159 isAutoTriangulation);
7fd59977 160 }
7fd59977 161 }
162}
163
bbf32d01
K
164//==================================================
165// Function: Load
166// Purpose :
167//==================================================
f838dac4 168void StdSelect_BRepSelectionTool::Load (const Handle(SelectMgr_Selection)& theSelection,
169 const Handle(SelectMgr_SelectableObject)& theSelectableObj,
170 const TopoDS_Shape& theShape,
171 const TopAbs_ShapeEnum theType,
172 const Standard_Real theDeflection,
173 const Standard_Real theDeviationAngle,
174 const Standard_Boolean isAutoTriangulation,
175 const Standard_Integer thePriority,
176 const Standard_Integer theNbPOnEdge,
177 const Standard_Real theMaxParam)
7fd59977 178{
bbf32d01
K
179 Load (theSelection,
180 theShape,
181 theType,
7fd59977 182 theDeflection,
183 theDeviationAngle,
bbf32d01
K
184 isAutoTriangulation,
185 thePriority,
186 theNbPOnEdge,
187 theMaxParam);
188
189 // loading of selectables...
190 for (theSelection->Init(); theSelection->More(); theSelection->Next())
191 {
192 Handle(SelectMgr_EntityOwner) anOwner
f751596e 193 = Handle(SelectMgr_EntityOwner)::DownCast (theSelection->Sensitive()->BaseSensitive()->OwnerId());
bbf32d01 194 anOwner->Set (theSelectableObj);
7fd59977 195 }
f751596e 196
114b7bf1 197 PreBuildBVH (theSelection);
7fd59977 198}
199
bbf32d01
K
200//==================================================
201// Function: ComputeSensitive
202// Purpose :
203//==================================================
f838dac4 204void 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)
7fd59977 212{
bbf32d01
K
213 switch (theShape.ShapeType())
214 {
215 case TopAbs_VERTEX:
216 {
217 theSelection->Add (new Select3D_SensitivePoint
218 (theOwner, BRep_Tool::Pnt (TopoDS::Vertex (theShape))));
7fd59977 219 break;
220 }
bbf32d01
K
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 }
7fd59977 231 break;
232 }
bbf32d01 233 case TopAbs_WIRE:
7fd59977 234 {
bbf32d01 235 BRepTools_WireExplorer aWireExp (TopoDS::Wire (theShape));
7fd59977 236 Handle (Select3D_SensitiveEntity) aSensitive;
bbf32d01
K
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();
7fd59977 249 }
250 break;
251 }
bbf32d01 252 case TopAbs_FACE:
7fd59977 253 {
bbf32d01 254 const TopoDS_Face& aFace = TopoDS::Face (theShape);
f751596e 255 Select3D_EntitySequence aSensitiveList;
bbf32d01
K
256 GetSensitiveForFace (aFace, theOwner,
257 aSensitiveList,
258 isAutoTriangulation, theNbPOnEdge, theMaxParam);
f751596e 259 for (Select3D_EntitySequenceIter aSensIter (aSensitiveList);
bbf32d01
K
260 aSensIter.More(); aSensIter.Next())
261 {
262 theSelection->Add (aSensIter.Value());
263 }
7fd59977 264 break;
265 }
bbf32d01 266 case TopAbs_SHELL:
bbf32d01
K
267 case TopAbs_SOLID:
268 case TopAbs_COMPSOLID:
7fd59977 269 {
bbf32d01
K
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 }
7fd59977 278 break;
279 }
bbf32d01
K
280 case TopAbs_COMPOUND:
281 default:
7fd59977 282 {
bbf32d01
K
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 }
7fd59977 305
bbf32d01
K
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 }
7fd59977 317}
318
bbf32d01
K
319//==================================================
320// Function: GetPointsFromPolygon
321// Purpose :
322//==================================================
36679076 323static Handle(TColgp_HArray1OfPnt) GetPointsFromPolygon (const TopoDS_Edge& theEdge)
7fd59977 324{
325 Handle(TColgp_HArray1OfPnt) aResultPoints;
326
7fd59977 327 TopLoc_Location aLocation;
328 Handle(Poly_Polygon3D) aPolygon = BRep_Tool::Polygon3D (theEdge, aLocation);
329 if (!aPolygon.IsNull())
330 {
36679076 331 const TColgp_Array1OfPnt& aNodes = aPolygon->Nodes();
332 aResultPoints = new TColgp_HArray1OfPnt (1, aNodes.Length());
333 if (aLocation.IsIdentity())
7fd59977 334 {
36679076 335 for (Standard_Integer aNodeId (aNodes.Lower()), aPntId (1); aNodeId <= aNodes.Upper(); ++aNodeId, ++aPntId)
7fd59977 336 {
36679076 337 aResultPoints->SetValue (aPntId, aNodes.Value (aNodeId));
7fd59977 338 }
36679076 339 }
340 else
341 {
342 for (Standard_Integer aNodeId (aNodes.Lower()), aPntId (1); aNodeId <= aNodes.Upper(); ++aNodeId, ++aPntId)
7fd59977 343 {
36679076 344 aResultPoints->SetValue (aPntId, aNodes.Value (aNodeId).Transformed (aLocation));
7fd59977 345 }
7fd59977 346 }
36679076 347 return aResultPoints;
7fd59977 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 {
36679076 355 const TColStd_Array1OfInteger& anIndices = anHIndices->Nodes();
356 const TColgp_Array1OfPnt& aNodes = aTriangulation->Nodes();
7fd59977 357
36679076 358 aResultPoints = new TColgp_HArray1OfPnt (1, anIndices.Length());
7fd59977 359
36679076 360 if (aLocation.IsIdentity())
361 {
362 for (Standard_Integer anIndex (anIndices.Lower()), aPntId (1); anIndex <= anIndices.Upper(); ++anIndex, ++aPntId)
7fd59977 363 {
36679076 364 aResultPoints->SetValue (aPntId, aNodes (anIndices (anIndex)));
7fd59977 365 }
36679076 366 }
367 else
368 {
369 for (Standard_Integer anIndex (anIndices.Lower()), aPntId (1); anIndex <= anIndices.Upper(); ++anIndex, ++aPntId)
7fd59977 370 {
36679076 371 aResultPoints->SetValue (aPntId, aNodes (anIndices (anIndex)).Transformed (aLocation));
7fd59977 372 }
7fd59977 373 }
36679076 374 return aResultPoints;
7fd59977 375 }
376 return aResultPoints;
377}
378
bbf32d01
K
379//==================================================
380// Function: FindLimits
381// Purpose :
382//==================================================
383static Standard_Boolean FindLimits (const Adaptor3d_Curve& theCurve,
384 const Standard_Real theLimit,
385 Standard_Real& theFirst,
386 Standard_Real& theLast)
7fd59977 387{
bbf32d01
K
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 {
7fd59977 399 do {
bbf32d01
K
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);
7fd59977 407 }
bbf32d01
K
408 else if (isFirstInf)
409 {
410 theCurve.D0 (theLast, aPnt2);
7fd59977 411 do {
bbf32d01
K
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);
7fd59977 417 }
bbf32d01
K
418 else if (isLastInf)
419 {
420 theCurve.D0 (theFirst, aPnt1);
7fd59977 421 do {
bbf32d01
K
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);
7fd59977 427 }
bbf32d01 428 }
7fd59977 429 return Standard_True;
430}
431
432//=====================================================
433// Function : GetEdgeSensitive
f838dac4 434// Purpose :
bbf32d01 435//=====================================================
f838dac4 436void 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)
7fd59977 444{
bbf32d01
K
445 const TopoDS_Edge& anEdge = TopoDS::Edge (theShape);
446 BRepAdaptor_Curve cu3d;
447 try {
448 OCC_CATCH_SIGNALS
449 cu3d.Initialize (anEdge);
450 } catch (Standard_NullObject) {
451 return;
452 }
7fd59977 453
454 // try to get points from existing polygons
36679076 455 Handle(TColgp_HArray1OfPnt) aPoints = GetPointsFromPolygon (anEdge);
7fd59977 456 if (!aPoints.IsNull() && aPoints->Length() > 0)
457 {
bbf32d01 458 theSensitive = new Select3D_SensitiveCurve (theOwner, aPoints);
7fd59977 459 return;
460 }
461
bbf32d01
K
462 Standard_Real aParamFirst = cu3d.FirstParameter();
463 Standard_Real aParamLast = cu3d.LastParameter();
464 switch (cu3d.GetType())
465 {
466 case GeomAbs_Line:
7fd59977 467 {
bbf32d01
K
468 BRep_Tool::Range (anEdge, aParamFirst, aParamLast);
469 theSensitive = new Select3D_SensitiveSegment (theOwner,
470 cu3d.Value (aParamFirst),
471 cu3d.Value (aParamLast));
7fd59977 472 break;
473 }
bbf32d01 474 case GeomAbs_Circle:
7fd59977 475 {
bbf32d01
K
476 Handle (Geom_Circle) aCircle = new Geom_Circle (cu3d.Circle());
477 if (aCircle->Radius() <= Precision::Confusion())
478 {
479 theSelection->Add (new Select3D_SensitivePoint (theOwner, aCircle->Location()));
480 }
7fd59977 481 else
bbf32d01
K
482 {
483 theSensitive = new Select3D_SensitiveCircle (theOwner, aCircle,
484 aParamFirst, aParamLast, Standard_False, 16);
485 }
7fd59977 486 break;
487 }
bbf32d01 488 default:
7fd59977 489 {
bbf32d01
K
490 // reproduce drawing behaviour
491 // TODO: remove copy-paste from StdPrs_Curve and some others...
492 if (FindLimits (cu3d, theMaxParam, aParamFirst, aParamLast))
7fd59977 493 {
494 Standard_Integer aNbIntervals = cu3d.NbIntervals (GeomAbs_C1);
495 TColStd_Array1OfReal anIntervals (1, aNbIntervals + 1);
496 cu3d.Intervals (anIntervals, GeomAbs_C1);
497 Standard_Real aV1, aV2;
498 Standard_Integer aNumberOfPoints;
499 TColgp_SequenceOfPnt aPointsSeq;
7fd59977 500 for (Standard_Integer anIntervalId = 1; anIntervalId <= aNbIntervals; ++anIntervalId)
501 {
bbf32d01
K
502 aV1 = anIntervals (anIntervalId);
503 aV2 = anIntervals (anIntervalId + 1);
504 if (aV2 > aParamFirst && aV1 < aParamLast)
7fd59977 505 {
bbf32d01
K
506 aV1 = Max (aV1, aParamFirst);
507 aV2 = Min (aV2, aParamLast);
7fd59977 508
509 GCPnts_TangentialDeflection anAlgo (cu3d, aV1, aV2, theDeviationAngle, theDeflection);
510 aNumberOfPoints = anAlgo.NbPoints();
511
bbf32d01 512 for (Standard_Integer aPntId = 1; aPntId < aNumberOfPoints; ++aPntId)
7fd59977 513 {
bbf32d01
K
514 aPointsSeq.Append (anAlgo.Value (aPntId));
515 }
516 if (aNumberOfPoints > 0 && anIntervalId == aNbIntervals)
517 {
518 aPointsSeq.Append (anAlgo.Value (aNumberOfPoints));
7fd59977 519 }
520 }
521 }
522
523 aPoints = new TColgp_HArray1OfPnt (1, aPointsSeq.Length());
524 for (Standard_Integer aPntId = 1; aPntId <= aPointsSeq.Length(); ++aPntId)
525 {
526 aPoints->SetValue (aPntId, aPointsSeq.Value (aPntId));
527 }
bbf32d01 528 theSensitive = new Select3D_SensitiveCurve (theOwner, aPoints);
7fd59977 529 break;
530 }
531
532 // simple subdivisions
533 Standard_Integer nbintervals = 1;
bbf32d01
K
534 if (cu3d.GetType() == GeomAbs_BSplineCurve)
535 {
536 nbintervals = cu3d.NbKnots() - 1;
537 nbintervals = Max (1, nbintervals / 3);
7fd59977 538 }
bbf32d01
K
539
540 Standard_Real aParam;
541 Standard_Integer aPntNb = Max (2, theNbPOnEdge * nbintervals);
542 Standard_Real aParamDelta = (aParamLast - aParamFirst) / (aPntNb - 1);
543 Handle(TColgp_HArray1OfPnt) aPointArray = new TColgp_HArray1OfPnt (1, aPntNb);
544 for (Standard_Integer aPntId = 1; aPntId <= aPntNb; ++aPntId)
545 {
546 aParam = aParamFirst + aParamDelta * (aPntId - 1);
547 aPointArray->SetValue (aPntId, cu3d.Value (aParam));
7fd59977 548 }
bbf32d01 549 theSensitive = new Select3D_SensitiveCurve (theOwner, aPointArray);
7fd59977 550 }
551 break;
552 }
553}
554
7fd59977 555//=======================================================================
556//function : GetSensitiveEntityForFace
bbf32d01 557//purpose :
7fd59977 558//=======================================================================
f838dac4 559Standard_Boolean StdSelect_BRepSelectionTool::GetSensitiveForFace (const TopoDS_Face& theFace,
560 const Handle(SelectMgr_EntityOwner)& theOwner,
561 Select3D_EntitySequence& theSensitiveList,
562 const Standard_Boolean /*theAutoTriangulation*/,
563 const Standard_Integer NbPOnEdge,
564 const Standard_Real theMaxParam,
565 const Standard_Boolean theInteriorFlag)
7fd59977 566{
81bba717 567 // check if there is triangulation of the face...
bbf32d01
K
568 TopLoc_Location aLoc;
569 Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation (theFace, aLoc);
3c34883c 570
bbf32d01
K
571 if (!aTriangulation.IsNull())
572 {
573 Handle(Select3D_SensitiveTriangulation) STG = new Select3D_SensitiveTriangulation (theOwner, aTriangulation, aLoc, theInteriorFlag);
574 theSensitiveList.Append (STG);
7fd59977 575 return Standard_True;
576 }
577
81bba717 578 // for faces with triangulation bugs or without autotriangulation ....
579 // very ugly and should not even exist ...
bbf32d01
K
580 BRepAdaptor_Surface BS;
581 BS.Initialize (theFace);
7fd59977 582
bbf32d01
K
583 Standard_Real FirstU = BS.FirstUParameter() <= -Precision::Infinite() ? -theMaxParam : BS.FirstUParameter();
584 Standard_Real LastU = BS.LastUParameter() >= Precision::Infinite() ? theMaxParam : BS.LastUParameter();
585 Standard_Real FirstV = BS.FirstVParameter() <= -Precision::Infinite() ? -theMaxParam : BS.FirstVParameter();
586 Standard_Real LastV = BS.LastVParameter() >= Precision::Infinite() ? theMaxParam : BS.LastVParameter();
7fd59977 587
bbf32d01
K
588 if (BS.GetType() == GeomAbs_Plane)
589 {
7fd59977 590 gp_Pnt pcur;
bbf32d01
K
591 Handle(TColgp_HArray1OfPnt) P = new TColgp_HArray1OfPnt (1, 5);
592 BS.D0 (FirstU, FirstV, pcur);
593 P->SetValue (1, pcur);
594 BS.D0 (LastU, FirstV, pcur);
595 P->SetValue (2, pcur);
596 BS.D0 (LastU, LastV, pcur);
597 P->SetValue (3, pcur);
598 BS.D0 (FirstU, LastV, pcur);
599 P->SetValue (4, pcur);
600 P->SetValue (5, P->Value (1));
81bba717 601 // if the plane is "infinite", it is sensitive only on the border limited by MaxParam
bbf32d01
K
602 if (FirstU == -theMaxParam && LastU == theMaxParam && FirstV == -theMaxParam && LastV == theMaxParam)
603 {
604 theSensitiveList.Append (new Select3D_SensitiveFace (theOwner, P, Select3D_TOS_BOUNDARY));
605 }
606 else
607 {
608 Select3D_TypeOfSensitivity TS = theInteriorFlag ? Select3D_TOS_INTERIOR : Select3D_TOS_BOUNDARY;
609 theSensitiveList.Append (new Select3D_SensitiveFace (theOwner, P, TS));
7fd59977 610 }
611 return Standard_True;
612 }
bbf32d01 613
81bba717 614 // This is construction of a sevsitive polygon from the exterior contour of the face...
615 // It is not good at all, but...
7fd59977 616 TopoDS_Wire aWire;
bbf32d01
K
617 TopExp_Explorer anExpWiresInFace (theFace, TopAbs_WIRE);
618 if (anExpWiresInFace.More())
619 {
620 // believing that this is the first... to be seen
621 aWire = TopoDS::Wire (anExpWiresInFace.Current());
622 }
623 if (aWire.IsNull())
624 {
625 return Standard_False;
626 }
7fd59977 627
7fd59977 628 TColgp_SequenceOfPnt WirePoints;
629 Standard_Boolean FirstExp = Standard_True;
bbf32d01
K
630 Standard_Real wf, wl;
631 BRepAdaptor_Curve cu3d;
632 for (BRepTools_WireExplorer aWireExplorer (aWire);
633 aWireExplorer.More(); aWireExplorer.Next())
634 {
635 cu3d.Initialize (aWireExplorer.Current());
636 BRep_Tool::Range (aWireExplorer.Current(), wf, wl);
637 if (Abs (wf - wl) <= Precision::Confusion())
638 {
0797d9d3 639 #ifdef OCCT_DEBUG
7fd59977 640 cout<<" StdSelect_BRepSelectionTool : Curve where ufirst = ulast ...."<<endl;
bbf32d01 641 #endif
7fd59977 642 }
bbf32d01
K
643 else
644 {
645 if (FirstExp)
646 {
647 if (aWireExplorer.Orientation() == TopAbs_FORWARD)
648 {
649 WirePoints.Append (cu3d.Value (wf));
650 }
651 else
652 {
653 WirePoints.Append (cu3d.Value (wl));
654 }
655 FirstExp = Standard_False;
7fd59977 656 }
bbf32d01
K
657
658 switch (cu3d.GetType())
659 {
660 case GeomAbs_Line:
661 {
662 WirePoints.Append (cu3d.Value ((aWireExplorer.Orientation() == TopAbs_FORWARD) ? wl : wf));
663 break;
664 }
665 case GeomAbs_Circle:
666 {
c6541a0c 667 if (2 * M_PI - Abs (wl - wf) <= Precision::Confusion())
bbf32d01
K
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 WirePoints.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 WirePoints.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 WirePoints.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 WirePoints.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 WirePoints.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 WirePoints.Append (cu3d.Value (wc));
740 }
741 }
742 }
7fd59977 743 }
744 }
745 }
746 Standard_Integer ArrayPosition = WirePoints.Length();
bbf32d01
K
747
748 Handle(TColgp_HArray1OfPnt) facepoints = new TColgp_HArray1OfPnt (1, ArrayPosition);
749 for (Standard_Integer I = 1; I <= ArrayPosition; ++I)
750 {
751 facepoints->SetValue (I, WirePoints.Value(I));
752 }
753
754 if ((facepoints->Array1()).Length() > 1)
755 { //1 if only one circular edge
756 Select3D_TypeOfSensitivity TS = theInteriorFlag ? Select3D_TOS_INTERIOR : Select3D_TOS_BOUNDARY;
757 theSensitiveList.Append (new Select3D_SensitiveFace (theOwner, facepoints, TS));
7fd59977 758 }
759 return Standard_True;
760}