67e11c007415e671913f82c671a3d5b595da106b
[occt.git] / src / SelectMgr / SelectMgr_ViewerSelector.cxx
1 // Created on: 1995-02-15
2 // Created by: Roberc 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 <SelectMgr_ViewerSelector.hxx>
18
19 #include <BVH_Tree.hxx>
20 #include <gp_GTrsf.hxx>
21 #include <gp_Pnt.hxx>
22 #include <OSD_Environment.hxx>
23 #include <Precision.hxx>
24 #include <Select3D_SensitiveEntity.hxx>
25 #include <SelectBasics_PickResult.hxx>
26 #include <SelectMgr_EntityOwner.hxx>
27 #include <SelectMgr_SortCriterion.hxx>
28 #include <SelectMgr_SensitiveEntitySet.hxx>
29 #include <TColStd_Array1OfInteger.hxx>
30 #include <TCollection_AsciiString.hxx>
31 #include <TColStd_HArray1OfInteger.hxx>
32 #include <TColStd_ListOfInteger.hxx>
33
34 #include <algorithm>
35
36 IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_ViewerSelector, Standard_Transient)
37
38 namespace
39 {
40   //! Comparison operator for sorting selection results
41   class CompareResults
42   {
43   public:
44
45     CompareResults (const SelectMgr_IndexedDataMapOfOwnerCriterion& theMapOfCriterion)
46     : myMapOfCriterion (&theMapOfCriterion)
47     {
48     }
49
50     Standard_Boolean operator() (Standard_Integer theLeft, Standard_Integer theRight) const
51     {
52       return myMapOfCriterion->FindFromIndex (theLeft) > myMapOfCriterion->FindFromIndex (theRight);
53     }
54
55   private:
56     const SelectMgr_IndexedDataMapOfOwnerCriterion* myMapOfCriterion;
57   };
58
59   static const Graphic3d_Mat4d SelectMgr_ViewerSelector_THE_IDENTITY_MAT;
60 }
61
62 //=======================================================================
63 // function : updatePoint3d
64 // purpose  :
65 //=======================================================================
66 void SelectMgr_ViewerSelector::updatePoint3d (SelectMgr_SortCriterion& theCriterion,
67                                               const SelectBasics_PickResult& thePickResult,
68                                               const Handle(Select3D_SensitiveEntity)& theEntity,
69                                               const gp_GTrsf& theInversedTrsf,
70                                               const SelectMgr_SelectingVolumeManager& theMgr) const
71 {
72   if (theMgr.GetActiveSelectionType() != SelectMgr_SelectingVolumeManager::Point)
73   {
74     return;
75   }
76
77   bool hasNormal = false;
78   if (thePickResult.HasPickedPoint())
79   {
80     theCriterion.Point  = thePickResult.PickedPoint();
81     theCriterion.Normal = thePickResult.SurfaceNormal();
82     const float aNormLen2 = theCriterion.Normal.SquareModulus();
83     if (aNormLen2 > ShortRealEpsilon())
84     {
85       hasNormal = true;
86       theCriterion.Normal *= 1.0f / sqrtf (aNormLen2);
87     }
88   }
89   else if (!thePickResult.IsValid())
90   {
91     theCriterion.Point = thePickResult.PickedPoint();
92     return;
93   }
94   else
95   {
96     theCriterion.Point = theMgr.DetectedPoint (theCriterion.Depth);
97   }
98
99   gp_GTrsf anInvTrsf = theInversedTrsf;
100   if (theCriterion.Entity->HasInitLocation())
101   {
102     anInvTrsf = theCriterion.Entity->InvInitLocation() * anInvTrsf;
103   }
104   if (anInvTrsf.Form() != gp_Identity)
105   {
106     const gp_GTrsf anInvInvTrsd = anInvTrsf.Inverted();
107     anInvInvTrsd.Transforms (theCriterion.Point.ChangeCoord());
108     if (hasNormal)
109     {
110       Graphic3d_Mat4d aMat4;
111       anInvInvTrsd.GetMat4 (aMat4);
112       const Graphic3d_Vec4d aNormRes = aMat4 * Graphic3d_Vec4d (Graphic3d_Vec3d (theCriterion.Normal), 0.0);
113       theCriterion.Normal = Graphic3d_Vec3 (aNormRes.xyz());
114     }
115   }
116
117   if (mySelectingVolumeMgr.Camera().IsNull())
118   {
119     theCriterion.Tolerance = theEntity->SensitivityFactor() / 33.0;
120   }
121   else if (mySelectingVolumeMgr.Camera()->IsOrthographic())
122   {
123     theCriterion.Tolerance = myCameraScale * theEntity->SensitivityFactor();
124   }
125   else
126   {
127     const Standard_Real aDistFromEye = Abs ((theCriterion.Point.XYZ() - myCameraEye.XYZ()).Dot (myCameraDir.XYZ()));
128     theCriterion.Tolerance = aDistFromEye * myCameraScale * theEntity->SensitivityFactor();
129   }
130 }
131
132 //==================================================
133 // Function: Initialize
134 // Purpose :
135 //==================================================
136 SelectMgr_ViewerSelector::SelectMgr_ViewerSelector():
137 preferclosest(Standard_True),
138 myToUpdateTolerance (Standard_True),
139 myCameraScale (1.0),
140 myCurRank (0),
141 myIsLeftChildQueuedFirst (Standard_False),
142 myEntityIdx (0)
143 {
144   myEntitySetBuilder = new BVH_BinnedBuilder<Standard_Real, 3, 4> (BVH_Constants_LeafNodeSizeSingle, BVH_Constants_MaxTreeDepth, Standard_True);
145 }
146
147 //=======================================================================
148 // Function: SetPixelTolerance
149 // Purpose :
150 //=======================================================================
151 void SelectMgr_ViewerSelector::SetPixelTolerance (const Standard_Integer theTolerance)
152 {
153   if (myTolerances.Tolerance() == theTolerance)
154   {
155     return;
156   }
157
158   myToUpdateTolerance = Standard_True;
159   if (theTolerance < 0)
160   {
161     myTolerances.ResetDefaults();
162   }
163   else
164   {
165     myTolerances.SetCustomTolerance (theTolerance);
166   }
167 }
168
169 //==================================================
170 // Function: Activate
171 // Purpose :
172 //==================================================
173 void SelectMgr_ViewerSelector::Activate (const Handle(SelectMgr_Selection)& theSelection)
174 {
175   for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator aSelEntIter (theSelection->Entities()); aSelEntIter.More(); aSelEntIter.Next())
176   {
177     aSelEntIter.Value()->SetActiveForSelection();
178   }
179
180   if (theSelection->GetSelectionState() != SelectMgr_SOS_Activated)
181   {
182     theSelection->SetSelectionState (SelectMgr_SOS_Activated);
183
184     myTolerances.Add (theSelection->Sensitivity());
185     myToUpdateTolerance = Standard_True;
186   }
187 }
188
189 //==================================================
190 // Function: Deactivate
191 // Purpose :
192 //==================================================
193 void SelectMgr_ViewerSelector::Deactivate (const Handle(SelectMgr_Selection)& theSelection)
194 {
195   for (NCollection_Vector<Handle(SelectMgr_SensitiveEntity)>::Iterator aSelEntIter (theSelection->Entities()); aSelEntIter.More(); aSelEntIter.Next())
196   {
197     aSelEntIter.Value()->ResetSelectionActiveStatus();
198   }
199
200   if (theSelection->GetSelectionState() == SelectMgr_SOS_Activated)
201   {
202     theSelection->SetSelectionState (SelectMgr_SOS_Deactivated);
203
204     myTolerances.Decrement (theSelection->Sensitivity());
205     myToUpdateTolerance = Standard_True;
206   }
207 }
208
209 //==================================================
210 // Function: Clear
211 // Purpose :
212 //==================================================
213 void SelectMgr_ViewerSelector::Clear()
214 {
215   mystored.Clear();
216 }
217
218 //=======================================================================
219 // function: isToScaleFrustum
220 // purpose : Checks if the entity given requires to scale current selecting frustum
221 //=======================================================================
222 Standard_Boolean SelectMgr_ViewerSelector::isToScaleFrustum (const Handle(Select3D_SensitiveEntity)& theEntity)
223 {
224   return mySelectingVolumeMgr.GetActiveSelectionType() == SelectMgr_SelectingVolumeManager::Point
225     && sensitivity (theEntity) < myTolerances.Tolerance();
226 }
227
228 //=======================================================================
229 // function: sensitivity
230 // purpose : In case if custom tolerance is set, this method will return sum of entity
231 //           sensitivity and custom tolerance.
232 //=======================================================================
233 Standard_Integer SelectMgr_ViewerSelector::sensitivity (const Handle(Select3D_SensitiveEntity)& theEntity) const
234 {
235   return myTolerances.IsCustomTolSet() ?
236     theEntity->SensitivityFactor() + myTolerances.CustomTolerance() : theEntity->SensitivityFactor();
237 }
238
239 //=======================================================================
240 // function: checkOverlap
241 // purpose : Internal function that checks if a particular sensitive
242 //           entity theEntity overlaps current selecting volume precisely
243 //=======================================================================
244 void SelectMgr_ViewerSelector::checkOverlap (const Handle(Select3D_SensitiveEntity)& theEntity,
245                                              const gp_GTrsf& theInversedTrsf,
246                                              SelectMgr_SelectingVolumeManager& theMgr)
247 {
248   const Handle(SelectMgr_EntityOwner)& anOwner = theEntity->OwnerId();
249   Handle(SelectMgr_SelectableObject) aSelectable = !anOwner.IsNull() ? anOwner->Selectable() : Handle(SelectMgr_SelectableObject)();
250   SelectBasics_PickResult aPickResult;
251   const Standard_Boolean isMatched = theEntity->Matches(theMgr, aPickResult);
252   if (!isMatched
253     || anOwner.IsNull())
254   {
255     return;
256   }
257
258   SelectMgr_SortCriterion aCriterion;
259   myZLayerOrderMap.Find (!aSelectable.IsNull() ? aSelectable->ZLayer() : Graphic3d_ZLayerId_Default, aCriterion.ZLayerPosition);
260   aCriterion.Entity    = theEntity;
261   aCriterion.Priority  = anOwner->Priority();
262   aCriterion.Depth     = aPickResult.Depth();
263   aCriterion.MinDist   = aPickResult.DistToGeomCenter();
264   aCriterion.ToPreferClosest = preferclosest;
265
266   if (SelectMgr_SortCriterion* aPrevCriterion = mystored.ChangeSeek (anOwner))
267   {
268     ++aPrevCriterion->NbOwnerMatches;
269     aCriterion.NbOwnerMatches = aPrevCriterion->NbOwnerMatches;
270     if (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Box)
271     {
272       if (aCriterion > *aPrevCriterion)
273       {
274         updatePoint3d (aCriterion, aPickResult, theEntity, theInversedTrsf, theMgr);
275         *aPrevCriterion = aCriterion;
276       }
277     }
278   }
279   else
280   {
281     aCriterion.NbOwnerMatches = 1;
282     updatePoint3d (aCriterion, aPickResult, theEntity, theInversedTrsf, theMgr);
283     mystored.Add (anOwner, aCriterion);
284   }
285 }
286
287 //=======================================================================
288 // function: computeFrustum
289 // purpose :
290 //=======================================================================
291 void SelectMgr_ViewerSelector::computeFrustum (const Handle(Select3D_SensitiveEntity)& theEnt,
292                                                const SelectMgr_SelectingVolumeManager& theMgrGlobal,
293                                                const SelectMgr_SelectingVolumeManager& theMgrObject,
294                                                const gp_GTrsf& theInvTrsf,
295                                                SelectMgr_FrustumCache& theCachedMgrs,
296                                                SelectMgr_SelectingVolumeManager& theResMgr)
297 {
298   Standard_Integer aScale = isToScaleFrustum (theEnt) ? sensitivity (theEnt) : 1;
299   const gp_GTrsf aTrsfMtr = theEnt->HasInitLocation() ? theEnt->InvInitLocation() * theInvTrsf : theInvTrsf;
300   const Standard_Boolean toScale = aScale != 1;
301   const Standard_Boolean toTransform = aTrsfMtr.Form() != gp_Identity;
302   if (toScale && toTransform)
303   {
304     theResMgr = theMgrGlobal.ScaleAndTransform (aScale, aTrsfMtr, NULL);
305     theResMgr.SetViewClipping (theMgrObject);
306   }
307   else if (toScale)
308   {
309     if (!theCachedMgrs.Find (aScale, theResMgr))
310     {
311       theResMgr = theMgrGlobal.ScaleAndTransform (aScale, gp_Trsf(), NULL);
312       theCachedMgrs.Bind (aScale, theResMgr);
313     }
314     theResMgr.SetViewClipping (theMgrObject);
315   }
316   else if (toTransform)
317   {
318     theResMgr = theMgrGlobal.ScaleAndTransform (1, aTrsfMtr, NULL);
319     theResMgr.SetViewClipping (theMgrObject);
320   }
321   else
322   {
323     theResMgr = theMgrObject;
324   }
325 }
326
327 //=======================================================================
328 // function: traverseObject
329 // purpose : Internal function that checks if there is possible overlap
330 //           between some entity of selectable object theObject and
331 //           current selecting volume
332 //=======================================================================
333 void SelectMgr_ViewerSelector::traverseObject (const Handle(SelectMgr_SelectableObject)& theObject,
334                                                const SelectMgr_SelectingVolumeManager& theMgr,
335                                                const Handle(Graphic3d_Camera)& theCamera,
336                                                const Graphic3d_Mat4d& theProjectionMat,
337                                                const Graphic3d_Mat4d& theWorldViewMat,
338                                                const Standard_Integer theViewportWidth,
339                                                const Standard_Integer theViewportHeight)
340 {
341   Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = myMapOfObjectSensitives.ChangeFind (theObject);
342   if (anEntitySet->Size() == 0)
343   {
344     return;
345   }
346
347   const opencascade::handle<BVH_Tree<Standard_Real, 3> >& aSensitivesTree = anEntitySet->BVH();
348   gp_GTrsf aInversedTrsf;
349   if (theObject->HasTransformation() || !theObject->TransformPersistence().IsNull())
350   {
351     if (theObject->TransformPersistence().IsNull())
352     {
353       aInversedTrsf = theObject->InversedTransformation();
354     }
355     else
356     {
357       gp_GTrsf aTPers;
358       Graphic3d_Mat4d aMat = theObject->TransformPersistence()->Compute (theCamera, theProjectionMat, theWorldViewMat, theViewportWidth, theViewportHeight);
359
360       aTPers.SetValue (1, 1, aMat.GetValue (0, 0));
361       aTPers.SetValue (1, 2, aMat.GetValue (0, 1));
362       aTPers.SetValue (1, 3, aMat.GetValue (0, 2));
363       aTPers.SetValue (2, 1, aMat.GetValue (1, 0));
364       aTPers.SetValue (2, 2, aMat.GetValue (1, 1));
365       aTPers.SetValue (2, 3, aMat.GetValue (1, 2));
366       aTPers.SetValue (3, 1, aMat.GetValue (2, 0));
367       aTPers.SetValue (3, 2, aMat.GetValue (2, 1));
368       aTPers.SetValue (3, 3, aMat.GetValue (2, 2));
369       aTPers.SetTranslationPart (gp_XYZ (aMat.GetValue (0, 3), aMat.GetValue (1, 3), aMat.GetValue (2, 3)));
370
371       aInversedTrsf = (aTPers * gp_GTrsf (theObject->Transformation())).Inverted();
372     }
373   }
374
375   SelectMgr_SelectingVolumeManager aMgr = aInversedTrsf.Form() != gp_Identity
376                                         ? theMgr.ScaleAndTransform (1, aInversedTrsf, NULL)
377                                         : theMgr;
378   if (!aMgr.Overlaps (aSensitivesTree->MinPoint (0),
379                       aSensitivesTree->MaxPoint (0)))
380   {
381     return;
382   }
383
384   if (!theObject->ClipPlanes().IsNull()
385     && theObject->ClipPlanes()->ToOverrideGlobal())
386   {
387     aMgr.SetViewClipping (Handle(Graphic3d_SequenceOfHClipPlane)(), theObject->ClipPlanes(), &theMgr);
388   }
389   else if (!theObject->TransformPersistence().IsNull())
390   {
391     if (theObject->TransformPersistence()->IsZoomOrRotate()
392     && !theMgr.ViewClipping().IsNull())
393     {
394       // Zoom/rotate persistence object lives in two worlds at the same time.
395       // Global clipping planes can not be trivially applied without being converted
396       // into local space of transformation persistence object.
397       // As more simple alternative - just clip entire object by its anchor point defined in the world space.
398       const gp_Pnt anAnchor = theObject->TransformPersistence()->AnchorPoint();
399       for (Graphic3d_SequenceOfHClipPlane::Iterator aPlaneIt (*theMgr.ViewClipping()); aPlaneIt.More(); aPlaneIt.Next())
400       {
401         const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIt.Value();
402         if (!aPlane->IsOn())
403         {
404           continue;
405         }
406
407         const Graphic3d_Vec4d aCheckPnt (anAnchor.X(), anAnchor.Y(), anAnchor.Z(), 1.0);
408         if (aPlane->ProbePoint (aCheckPnt) == Graphic3d_ClipState_Out)
409         {
410           return;
411         }
412       }
413     }
414
415     aMgr.SetViewClipping (Handle(Graphic3d_SequenceOfHClipPlane)(), theObject->ClipPlanes(), &theMgr);
416   }
417   else if (!theObject->ClipPlanes().IsNull()
418         && !theObject->ClipPlanes()->IsEmpty())
419   {
420     aMgr.SetViewClipping (theMgr.ViewClipping(), theObject->ClipPlanes(), &theMgr);
421   }
422
423   if (!theMgr.ViewClipping().IsNull() &&
424       theMgr.GetActiveSelectionType() == SelectBasics_SelectingVolumeManager::Box)
425   {
426     Graphic3d_BndBox3d aBBox (aSensitivesTree->MinPoint (0), aSensitivesTree->MaxPoint (0));
427     // If box selection is active, and the whole sensitive tree is out of the clip planes
428     // selection is empty for this object
429     const Handle(Graphic3d_SequenceOfHClipPlane)& aViewPlanes = theMgr.ViewClipping();
430
431     for (Graphic3d_SequenceOfHClipPlane::Iterator aPlaneIt (*aViewPlanes); aPlaneIt.More(); aPlaneIt.Next())
432     {
433       const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIt.Value();
434       if (!aPlane->IsOn())
435       {
436         continue;
437       }
438
439       Graphic3d_ClipState aState = aPlane->ProbeBox (aBBox);
440       if (aState == Graphic3d_ClipState_Out) // do not process only whole trees, next check on the tree node
441       {
442         return;
443       }
444     }
445   }
446
447   const Standard_Integer aFirstStored = mystored.Extent() + 1;
448
449   Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
450   Standard_Integer aHead = -1;
451   Standard_Integer aNode = 0; // a root node
452   SelectMgr_FrustumCache aScaledTrnsfFrustums;
453   SelectMgr_SelectingVolumeManager aTmpMgr (false);
454   for (;;)
455   {
456     if (!aSensitivesTree->IsOuter (aNode))
457     {
458       const Standard_Integer aLeftChildIdx  = aSensitivesTree->Child<0> (aNode);
459       const Standard_Integer aRightChildIdx = aSensitivesTree->Child<1> (aNode);
460       const Standard_Boolean isLeftChildIn  =  aMgr.Overlaps (aSensitivesTree->MinPoint (aLeftChildIdx),
461                                                               aSensitivesTree->MaxPoint (aLeftChildIdx));
462       const Standard_Boolean isRightChildIn = aMgr.Overlaps (aSensitivesTree->MinPoint (aRightChildIdx),
463                                                              aSensitivesTree->MaxPoint (aRightChildIdx));
464       if (isLeftChildIn
465           && isRightChildIn)
466       {
467         aNode = aLeftChildIdx;
468         ++aHead;
469         aStack[aHead] = aRightChildIdx;
470       }
471       else if (isLeftChildIn
472         || isRightChildIn)
473       {
474         aNode = isLeftChildIn ? aLeftChildIdx : aRightChildIdx;
475       }
476       else
477       {
478         if (aHead < 0)
479         {
480           break;
481         }
482
483         aNode = aStack[aHead];
484         --aHead;
485       }
486     }
487     else
488     {
489       bool aClipped = false;
490       if (!theMgr.ViewClipping().IsNull() &&
491           theMgr.GetActiveSelectionType() == SelectBasics_SelectingVolumeManager::Box)
492       {
493         Graphic3d_BndBox3d aBBox (aSensitivesTree->MinPoint (aNode), aSensitivesTree->MaxPoint (aNode));
494         // If box selection is active, and the whole sensitive tree is out of the clip planes
495         // selection is empty for this object
496         const Handle(Graphic3d_SequenceOfHClipPlane)& aViewPlanes = theMgr.ViewClipping();
497
498         for (Graphic3d_SequenceOfHClipPlane::Iterator aPlaneIt (*aViewPlanes); aPlaneIt.More(); aPlaneIt.Next())
499         {
500           const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIt.Value();
501           if (!aPlane->IsOn())
502           {
503             continue;
504           }
505           Graphic3d_ClipState aState = aPlane->ProbeBox (aBBox);
506           if (aState == Graphic3d_ClipState_Out)
507           {
508             aClipped = true;
509             break;
510           }
511           if (aState == Graphic3d_ClipState_On && !mySelectingVolumeMgr.IsOverlapAllowed()) // partially clipped
512           {
513             if (aPlane->ProbeBoxTouch (aBBox))
514               continue;
515             aClipped = true;
516             break;
517           }
518         }
519       }
520       if (!aClipped)
521       {
522         Standard_Integer aStartIdx = aSensitivesTree->BegPrimitive (aNode);
523         Standard_Integer anEndIdx = aSensitivesTree->EndPrimitive (aNode);
524         for (Standard_Integer anIdx = aStartIdx; anIdx <= anEndIdx; ++anIdx)
525         {
526           const Handle(SelectMgr_SensitiveEntity)& aSensitive = anEntitySet->GetSensitiveById (anIdx);
527           if (aSensitive->IsActiveForSelection())
528           {
529             const Handle(Select3D_SensitiveEntity)& anEnt = aSensitive->BaseSensitive();
530             computeFrustum (anEnt, theMgr, aMgr, aInversedTrsf, aScaledTrnsfFrustums, aTmpMgr);
531             checkOverlap (anEnt, aInversedTrsf, aTmpMgr);
532           }
533         }
534       }
535       if (aHead < 0)
536       {
537         break;
538       }
539
540       aNode = aStack[aHead];
541       --aHead;
542     }
543   }
544
545   // in case of Box/Polyline selection - keep only Owners having all Entities detected
546   if (mySelectingVolumeMgr.IsOverlapAllowed()
547   || (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Box
548    && theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Polyline))
549   {
550     return;
551   }
552
553   for (Standard_Integer aStoredIter = mystored.Extent(); aStoredIter >= aFirstStored; --aStoredIter)
554   {
555     const SelectMgr_SortCriterion& aCriterion = mystored.FindFromIndex (aStoredIter);
556     const Handle(SelectMgr_EntityOwner)& anOwner = aCriterion.Entity->OwnerId();
557     Standard_Integer aNbOwnerEntities = 0;
558     for (SelectMgr_IndexedMapOfHSensitive::Iterator aSensIter (anEntitySet->Sensitives()); aSensIter.More(); aSensIter.Next())
559     {
560       if (aSensIter.Value()->BaseSensitive()->OwnerId() == anOwner)
561       {
562         if (++aNbOwnerEntities > aCriterion.NbOwnerMatches)
563         {
564           // Remove from index map.
565           // Considering NCollection_IndexedDataMap implementation, the values for lower indexes will not be modified.
566           // Hence, just keep iterating in backward direction.
567           mystored.RemoveFromIndex (aStoredIter);
568           break;
569         }
570       }
571     }
572   }
573 }
574
575 //=======================================================================
576 // function: TraverseSensitives
577 // purpose : Traverses BVH containing all added selectable objects and
578 //           finds candidates for further search of overlap
579 //=======================================================================
580 void SelectMgr_ViewerSelector::TraverseSensitives()
581 {
582   mystored.Clear();
583
584   Standard_Integer aWidth;
585   Standard_Integer aHeight;
586   mySelectingVolumeMgr.WindowSize (aWidth, aHeight);
587   mySelectableObjects.UpdateBVH (mySelectingVolumeMgr.Camera(),
588                                  mySelectingVolumeMgr.ProjectionMatrix(),
589                                  mySelectingVolumeMgr.WorldViewMatrix(),
590                                  mySelectingVolumeMgr.WorldViewProjState(),
591                                  aWidth, aHeight);
592   const Handle(Graphic3d_Camera)& aCamera = mySelectingVolumeMgr.Camera();
593   if (!aCamera.IsNull())
594   {
595     myCameraEye = aCamera->Eye().XYZ();
596     myCameraDir = aCamera->Direction().XYZ();
597     myCameraScale = aCamera->IsOrthographic()
598                   ? aCamera->Scale()
599                   : 2.0 * Tan (aCamera->FOVy() * M_PI / 360.0);
600     const double aPixelSize = Max (1.0 / aWidth, 1.0 / aHeight);
601     myCameraScale *= aPixelSize;
602   }
603
604   for (Standard_Integer aBVHSetIt = 0; aBVHSetIt < SelectMgr_SelectableObjectSet::BVHSubsetNb; ++aBVHSetIt)
605   {
606     SelectMgr_SelectableObjectSet::BVHSubset aBVHSubset =
607       static_cast<SelectMgr_SelectableObjectSet::BVHSubset> (aBVHSetIt);
608
609     if (mySelectableObjects.IsEmpty (aBVHSubset))
610     {
611       continue;
612     }
613
614     gp_GTrsf aTFrustum;
615
616     SelectMgr_SelectingVolumeManager aMgr (Standard_False);
617
618     // for 2D space selection transform selecting volumes to perform overap testing
619     // directly in camera's eye space omitting the camera position, which is not
620     // needed there at all
621     if (aBVHSubset == SelectMgr_SelectableObjectSet::BVHSubset_2dPersistent)
622     {
623       const Graphic3d_Mat4d& aMat = mySelectingVolumeMgr.WorldViewMatrix();
624       aTFrustum.SetValue (1, 1, aMat.GetValue (0, 0));
625       aTFrustum.SetValue (1, 2, aMat.GetValue (0, 1));
626       aTFrustum.SetValue (1, 3, aMat.GetValue (0, 2));
627       aTFrustum.SetValue (2, 1, aMat.GetValue (1, 0));
628       aTFrustum.SetValue (2, 2, aMat.GetValue (1, 1));
629       aTFrustum.SetValue (2, 3, aMat.GetValue (1, 2));
630       aTFrustum.SetValue (3, 1, aMat.GetValue (2, 0));
631       aTFrustum.SetValue (3, 2, aMat.GetValue (2, 1));
632       aTFrustum.SetValue (3, 3, aMat.GetValue (2, 2));
633       aTFrustum.SetTranslationPart (gp_XYZ (aMat.GetValue (0, 3), aMat.GetValue (1, 3), aMat.GetValue (2, 3)));
634
635       // define corresponding frustum builder parameters
636       Handle(SelectMgr_FrustumBuilder) aBuilder = new SelectMgr_FrustumBuilder();
637       aBuilder->SetProjectionMatrix (mySelectingVolumeMgr.ProjectionMatrix());
638       aBuilder->SetWorldViewMatrix (SelectMgr_ViewerSelector_THE_IDENTITY_MAT);
639       aBuilder->SetWindowSize (aWidth, aHeight);
640       aMgr = mySelectingVolumeMgr.ScaleAndTransform (1, aTFrustum, aBuilder);
641     }
642     else
643     {
644       aMgr = mySelectingVolumeMgr;
645     }
646
647     const Graphic3d_Mat4d& aProjectionMat   = mySelectingVolumeMgr.ProjectionMatrix();
648     const Graphic3d_Mat4d& aWorldViewMat    = aBVHSubset != SelectMgr_SelectableObjectSet::BVHSubset_2dPersistent
649                                             ? mySelectingVolumeMgr.WorldViewMatrix()
650                                             : SelectMgr_ViewerSelector_THE_IDENTITY_MAT;
651
652     const opencascade::handle<BVH_Tree<Standard_Real, 3> >& aBVHTree = mySelectableObjects.BVH (aBVHSubset);
653
654     Standard_Integer aNode = 0;
655     if (!aMgr.Overlaps (aBVHTree->MinPoint (0), aBVHTree->MaxPoint (0)))
656     {
657       continue;
658     }
659
660     Standard_Integer aStack[BVH_Constants_MaxTreeDepth];
661     Standard_Integer aHead = -1;
662     for (;;)
663     {
664       if (!aBVHTree->IsOuter (aNode))
665       {
666         const Standard_Integer aLeftChildIdx  = aBVHTree->Child<0> (aNode);
667         const Standard_Integer aRightChildIdx = aBVHTree->Child<1> (aNode);
668         const Standard_Boolean isLeftChildIn  =
669           aMgr.Overlaps (aBVHTree->MinPoint (aLeftChildIdx), aBVHTree->MaxPoint (aLeftChildIdx));
670         const Standard_Boolean isRightChildIn =
671           aMgr.Overlaps (aBVHTree->MinPoint (aRightChildIdx), aBVHTree->MaxPoint (aRightChildIdx));
672         if (isLeftChildIn
673           && isRightChildIn)
674         {
675           aNode = aLeftChildIdx;
676           ++aHead;
677           aStack[aHead] = aRightChildIdx;
678         }
679         else if (isLeftChildIn
680           || isRightChildIn)
681         {
682           aNode = isLeftChildIn ? aLeftChildIdx : aRightChildIdx;
683         }
684         else
685         {
686           if (aHead < 0)
687           {
688             break;
689           }
690
691           aNode = aStack[aHead];
692           --aHead;
693         }
694       }
695       else
696       {
697         Standard_Integer aStartIdx = aBVHTree->BegPrimitive (aNode);
698         Standard_Integer anEndIdx  = aBVHTree->EndPrimitive (aNode);
699         for (Standard_Integer anIdx = aStartIdx; anIdx <= anEndIdx; ++anIdx)
700         {
701           const Handle(SelectMgr_SelectableObject)& aSelectableObject =
702             mySelectableObjects.GetObjectById (aBVHSubset, anIdx);
703
704           traverseObject (aSelectableObject, aMgr, aCamera, aProjectionMat, aWorldViewMat, aWidth, aHeight);
705         }
706         if (aHead < 0)
707         {
708           break;
709         }
710
711         aNode = aStack[aHead];
712         --aHead;
713       }
714     }
715   }
716
717   SortResult();
718 }
719
720 //==================================================
721 // Function: ClearPicked
722 // Purpose :
723 //==================================================
724 void SelectMgr_ViewerSelector::ClearPicked()
725 {
726   mystored.Clear();
727 }
728
729 //==================================================
730 // Function: Picked
731 // Purpose :
732 //==================================================
733 Handle(SelectMgr_EntityOwner) SelectMgr_ViewerSelector::Picked() const
734 {
735   const Standard_Integer aRankInMap = myIndexes->Value (myCurRank);
736   const Handle(SelectMgr_EntityOwner)& anOwner = mystored.FindKey (aRankInMap);
737   return anOwner;
738 }
739
740 //=======================================================================
741 //function : Picked
742 //purpose  :
743 //=======================================================================
744 Handle(SelectMgr_EntityOwner) SelectMgr_ViewerSelector::Picked (const Standard_Integer theRank) const
745 {
746   if (theRank < 1 || theRank > NbPicked())
747   {
748     return Handle(SelectMgr_EntityOwner)();
749   }
750
751   const Standard_Integer anOwnerIdx = myIndexes->Value (theRank);
752   const Handle(SelectMgr_EntityOwner)& aStoredOwner = mystored.FindKey (anOwnerIdx);
753   return aStoredOwner;
754 }
755
756 //=======================================================================
757 //function : PickedData
758 //purpose  :
759 //=======================================================================
760 const SelectMgr_SortCriterion& SelectMgr_ViewerSelector::PickedData(const Standard_Integer theRank) const
761 {
762   Standard_OutOfRange_Raise_if (theRank < 1 || theRank > NbPicked(), "SelectMgr_ViewerSelector::PickedData() out of range index");
763   const Standard_Integer anOwnerIdx = myIndexes->Value (theRank);
764   return mystored.FindFromIndex (anOwnerIdx);
765 }
766
767 //===================================================
768 //
769 //       INTERNAL METHODS ....
770 //
771 //==================================================
772
773 //==================================================
774 // Function: SetEntitySetBuilder
775 // Purpose :
776 //==================================================
777 void SelectMgr_ViewerSelector::SetEntitySetBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder)
778 {
779   myEntitySetBuilder = theBuilder;
780   for (SelectMgr_MapOfObjectSensitives::Iterator aSetIter (myMapOfObjectSensitives); aSetIter.More(); aSetIter.Next())
781   {
782     aSetIter.ChangeValue()->SetBuilder (myEntitySetBuilder);
783   }
784 }
785
786 //==================================================
787 // Function: Contains
788 // Purpose :
789 //==================================================
790 Standard_Boolean SelectMgr_ViewerSelector::Contains (const Handle(SelectMgr_SelectableObject)& theObject) const
791 {
792   return mySelectableObjects.Contains (theObject);
793 }
794
795 //==================================================
796 // Function: ActiveModes
797 // Purpose : return all the  modes with a given state for an object
798 //==================================================
799 Standard_Boolean SelectMgr_ViewerSelector::Modes (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
800                                                   TColStd_ListOfInteger& theModeList,
801                                                   const SelectMgr_StateOfSelection theWantedState) const
802 {
803   Standard_Boolean hasActivatedStates = Contains (theSelectableObject);
804   for (SelectMgr_SequenceOfSelection::Iterator aSelIter (theSelectableObject->Selections()); aSelIter.More(); aSelIter.Next())
805   {
806     if (theWantedState == SelectMgr_SOS_Any)
807     {
808       theModeList.Append (aSelIter.Value()->Mode());
809     }
810     else if (theWantedState == aSelIter.Value()->GetSelectionState())
811     {
812       theModeList.Append (aSelIter.Value()->Mode());
813     }
814   }
815
816   return hasActivatedStates;
817 }
818
819 //==================================================
820 // Function: IsActive
821 // Purpose :
822 //==================================================
823 Standard_Boolean SelectMgr_ViewerSelector::IsActive (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
824                                                      const Standard_Integer theMode) const
825 {
826   if (!Contains (theSelectableObject))
827     return Standard_False;
828
829   const Handle(SelectMgr_Selection)& aSel = theSelectableObject->Selection (theMode);
830   return !aSel.IsNull()
831        && aSel->GetSelectionState() == SelectMgr_SOS_Activated;
832 }
833
834 //==================================================
835 // Function: IsInside
836 // Purpose :
837 //==================================================
838 Standard_Boolean SelectMgr_ViewerSelector::IsInside (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
839                                                      const Standard_Integer theMode) const
840 {
841   if (!Contains (theSelectableObject))
842     return Standard_False;
843
844   const Handle(SelectMgr_Selection)& aSel = theSelectableObject->Selection (theMode);
845   return !aSel.IsNull()
846        && aSel->GetSelectionState() != SelectMgr_SOS_Unknown;
847 }
848
849
850 //=======================================================================
851 //function : Status
852 //purpose  :
853 //=======================================================================
854
855 SelectMgr_StateOfSelection SelectMgr_ViewerSelector::Status (const Handle(SelectMgr_Selection)& theSelection) const
856 {
857   return theSelection->GetSelectionState();
858 }
859
860 //==================================================
861 // Function: Status
862 // Purpose : gives Information about selectors
863 //==================================================
864
865 TCollection_AsciiString SelectMgr_ViewerSelector::Status (const Handle(SelectMgr_SelectableObject)& theSelectableObject) const
866 {
867   TCollection_AsciiString aStatus ("Status Object :\n\t");
868   for (SelectMgr_SequenceOfSelection::Iterator aSelIter (theSelectableObject->Selections()); aSelIter.More(); aSelIter.Next())
869   {
870     if (aSelIter.Value()->GetSelectionState() != SelectMgr_SOS_Unknown)
871     {
872       aStatus = aStatus + "Mode " + TCollection_AsciiString (aSelIter.Value()->Mode()) + " present - "
873               + (aSelIter.Value()->GetSelectionState() == SelectMgr_SOS_Activated ? " Active \n\t" : " Inactive \n\t");
874     }
875   }
876
877   if (!Contains (theSelectableObject))
878   {
879     aStatus = aStatus + "Not Present in the selector\n\n";
880   }
881
882   return aStatus;
883 }
884
885 //=======================================================================
886 //function : SortResult
887 //purpose  :  there is a certain number of entities ranged by criteria
888 //            (depth, size, priority, mouse distance from borders or
889 //            CDG of the detected primitive. Parsing :
890 //             maximum priorities .
891 //             then a reasonable compromise between depth and distance...
892 // finally the ranges are stored in myindexes depending on the parsing.
893 // so, it is possible to only read
894 //=======================================================================
895 void SelectMgr_ViewerSelector::SortResult()
896 {
897   if(mystored.IsEmpty()) return;
898
899   const Standard_Integer anExtent = mystored.Extent();
900   if(myIndexes.IsNull() || anExtent != myIndexes->Length())
901     myIndexes = new TColStd_HArray1OfInteger (1, anExtent);
902
903   TColStd_Array1OfInteger& anIndexArray = myIndexes->ChangeArray1();
904   for (Standard_Integer anIndexIter = 1; anIndexIter <= anExtent; ++anIndexIter)
905   {
906     anIndexArray.SetValue (anIndexIter, anIndexIter);
907   }
908   std::sort (anIndexArray.begin(), anIndexArray.end(), CompareResults (mystored));
909 }
910
911 //=======================================================================
912 // function : AddSelectableObject
913 // purpose  : Adds new object to the map of selectable objects
914 //=======================================================================
915 void SelectMgr_ViewerSelector::AddSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
916 {
917   if (!myMapOfObjectSensitives.IsBound (theObject))
918   {
919     mySelectableObjects.Append (theObject);
920     Handle(SelectMgr_SensitiveEntitySet) anEntitySet = new SelectMgr_SensitiveEntitySet (myEntitySetBuilder);
921     myMapOfObjectSensitives.Bind (theObject, anEntitySet);
922   }
923 }
924
925 //=======================================================================
926 // function : AddSelectionToObject
927 // purpose  : Adds new selection to the object and builds its BVH tree
928 //=======================================================================
929 void SelectMgr_ViewerSelector::AddSelectionToObject (const Handle(SelectMgr_SelectableObject)& theObject,
930                                                      const Handle(SelectMgr_Selection)& theSelection)
931 {
932   if (Handle(SelectMgr_SensitiveEntitySet)* anEntitySet = myMapOfObjectSensitives.ChangeSeek (theObject))
933   {
934     (*anEntitySet)->Append (theSelection);
935     (*anEntitySet)->BVH();
936   }
937   else
938   {
939     AddSelectableObject (theObject);
940     AddSelectionToObject (theObject, theSelection);
941   }
942 }
943
944 //=======================================================================
945 // function : MoveSelectableObject
946 // purpose  :
947 //=======================================================================
948 void SelectMgr_ViewerSelector::MoveSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
949 {
950   mySelectableObjects.ChangeSubset (theObject);
951 }
952
953 //=======================================================================
954 // function : RemoveSelectableObject
955 // purpose  : Removes selectable object from map of selectable ones
956 //=======================================================================
957 void SelectMgr_ViewerSelector::RemoveSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
958 {
959   Handle(SelectMgr_SelectableObject) anObj = theObject;
960   if (myMapOfObjectSensitives.UnBind (theObject))
961   {
962     mySelectableObjects.Remove (theObject);
963   }
964 }
965
966 //=======================================================================
967 // function : RemoveSelectionOfObject
968 // purpose  : Removes selection of the object and marks its BVH tree
969 //            for rebuild
970 //=======================================================================
971 void SelectMgr_ViewerSelector::RemoveSelectionOfObject (const Handle(SelectMgr_SelectableObject)& theObject,
972                                                         const Handle(SelectMgr_Selection)& theSelection)
973 {
974   if (Handle(SelectMgr_SensitiveEntitySet)* anEntitySet = myMapOfObjectSensitives.ChangeSeek (theObject))
975   {
976     (*anEntitySet)->Remove (theSelection);
977   }
978 }
979
980 //=======================================================================
981 // function : RebuildObjectsTree
982 // purpose  : Marks BVH of selectable objects for rebuild
983 //=======================================================================
984 void SelectMgr_ViewerSelector::RebuildObjectsTree (const Standard_Boolean theIsForce)
985 {
986   mySelectableObjects.MarkDirty();
987
988   if (theIsForce)
989   {
990     Standard_Integer aViewportWidth, aViewportHeight;
991     mySelectingVolumeMgr.WindowSize (aViewportWidth, aViewportHeight);
992
993     Standard_Integer aWidth;
994     Standard_Integer aHeight;
995     mySelectingVolumeMgr.WindowSize (aWidth, aHeight);
996     mySelectableObjects.UpdateBVH (mySelectingVolumeMgr.Camera(),
997                                    mySelectingVolumeMgr.ProjectionMatrix(),
998                                    mySelectingVolumeMgr.WorldViewMatrix(),
999                                    mySelectingVolumeMgr.WorldViewProjState(),
1000                                    aWidth, aHeight);
1001   }
1002 }
1003
1004 //=======================================================================
1005 // function : RebuildSensitivesTree
1006 // purpose  : Marks BVH of sensitive entities of particular selectable
1007 //            object for rebuild
1008 //=======================================================================
1009 void SelectMgr_ViewerSelector::RebuildSensitivesTree (const Handle(SelectMgr_SelectableObject)& theObject,
1010                                                       const Standard_Boolean theIsForce)
1011 {
1012   if (!Contains (theObject))
1013     return;
1014
1015   Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = myMapOfObjectSensitives.ChangeFind (theObject);
1016   anEntitySet->MarkDirty();
1017
1018   if (theIsForce)
1019   {
1020     anEntitySet->BVH();
1021   }
1022 }
1023
1024 //=======================================================================
1025 // function : resetSelectionActivationStatus
1026 // purpose  : Marks all added sensitive entities of all objects as
1027 //            non-selectable
1028 //=======================================================================
1029 void SelectMgr_ViewerSelector::ResetSelectionActivationStatus()
1030 {
1031   for (SelectMgr_MapOfObjectSensitivesIterator aSensitivesIter (myMapOfObjectSensitives); aSensitivesIter.More(); aSensitivesIter.Next())
1032   {
1033     Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = aSensitivesIter.ChangeValue();
1034     const Standard_Integer anEntitiesNb = anEntitySet->Size();
1035     for (Standard_Integer anIdx = 0; anIdx < anEntitiesNb; ++anIdx)
1036     {
1037       anEntitySet->GetSensitiveById (anIdx)->ResetSelectionActiveStatus();
1038     }
1039   }
1040 }
1041
1042 //=======================================================================
1043 // function : DetectedEntity
1044 // purpose  : Returns sensitive entity that was detected during the
1045 //            previous run of selection algorithm
1046 //=======================================================================
1047 const Handle(Select3D_SensitiveEntity)& SelectMgr_ViewerSelector::DetectedEntity() const
1048 {
1049   const Standard_Integer aRankInMap = myIndexes->Value(myCurRank);
1050   return mystored.FindFromIndex (aRankInMap).Entity;
1051 }
1052
1053 //=======================================================================
1054 // function : ActiveOwners
1055 // purpose  : Returns the list of active entity owners
1056 //=======================================================================
1057 void SelectMgr_ViewerSelector::ActiveOwners (NCollection_List<Handle(SelectMgr_EntityOwner)>& theOwners) const
1058 {
1059   for (SelectMgr_MapOfObjectSensitivesIterator anIter (myMapOfObjectSensitives); anIter.More(); anIter.Next())
1060   {
1061     const Handle(SelectMgr_SensitiveEntitySet)& anEntitySet = anIter.Value();
1062     const Standard_Integer anEntitiesNb = anEntitySet->Size();
1063     for (Standard_Integer anIdx = 0; anIdx < anEntitiesNb; ++anIdx)
1064     {
1065       const Handle(SelectMgr_SensitiveEntity)& aSensitive = anEntitySet->GetSensitiveById (anIdx);
1066       if (aSensitive->IsActiveForSelection())
1067       {
1068         theOwners.Append (aSensitive->BaseSensitive()->OwnerId());
1069       }
1070     }
1071   }
1072 }
1073
1074 //=======================================================================
1075 //function : AllowOverlapDetection
1076 //purpose  : Sets the detection type: if theIsToAllow is false,
1077 //           only fully included sensitives will be detected, otherwise
1078 //           the algorithm will mark both included and overlapped entities
1079 //           as matched
1080 //=======================================================================
1081 void SelectMgr_ViewerSelector::AllowOverlapDetection (const Standard_Boolean theIsToAllow)
1082 {
1083   mySelectingVolumeMgr.AllowOverlapDetection (theIsToAllow);
1084 }
1085
1086 //=======================================================================
1087 //function : DumpJson
1088 //purpose  : 
1089 //=======================================================================
1090 void SelectMgr_ViewerSelector::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const 
1091 {
1092   OCCT_DUMP_TRANSIENT_CLASS_BEGIN (theOStream)
1093
1094   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, preferclosest)
1095   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myToUpdateTolerance)
1096   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, mystored.Extent())
1097
1098   OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, &mySelectingVolumeMgr)
1099   OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, &mySelectableObjects)
1100
1101   Standard_Integer aNbOfSelectableObjects = 0;
1102   for (SelectMgr_SelectableObjectSet::Iterator aSelectableIt (mySelectableObjects); aSelectableIt.More(); aSelectableIt.Next())
1103   {
1104     aNbOfSelectableObjects++;
1105   }
1106   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, aNbOfSelectableObjects)
1107
1108   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myTolerances.Tolerance())
1109   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myTolerances.CustomTolerance())
1110   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myZLayerOrderMap.Extent())
1111
1112   OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myEntitySetBuilder.get())
1113   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myCameraEye)
1114   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myCameraDir)
1115   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myCameraScale)
1116
1117   if (!myIndexes.IsNull())
1118     OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myIndexes->Size())
1119
1120   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myCurRank)
1121   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myIsLeftChildQueuedFirst)
1122   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myEntityIdx)
1123   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myMapOfObjectSensitives.Extent())
1124 }