0026413: Visualization, SelectMgr_ViewerSelector - Pixel tolerance is overridden...
[occt.git] / src / SelectMgr / SelectMgr_ViewerSelector.hxx
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 // Modified by  ...
18 //              ROB JAN/07/98 : Improve Storage of detected entities
19 //              AGV OCT/23/03 : Optimize the method SortResult() (OCC4201)
20
21 #ifndef _SelectMgr_ViewerSelector_HeaderFile
22 #define _SelectMgr_ViewerSelector_HeaderFile
23
24 #include <MMgt_TShared.hxx>
25 #include <NCollection_Handle.hxx>
26 #include <NCollection_DataMap.hxx>
27 #include <OSD_Chronometer.hxx>
28 #include <TColStd_SequenceOfInteger.hxx>
29 #include <TColStd_HArray1OfInteger.hxx>
30
31 #include <Standard.hxx>
32 #include <Standard_Type.hxx>
33
34 #include <SelectMgr_IndexedDataMapOfOwnerCriterion.hxx>
35 #include <SelectMgr_SelectingVolumeManager.hxx>
36 #include <SelectMgr_Selection.hxx>
37 #include <SelectMgr_SelectableObject.hxx>
38 #include <SelectMgr_SelectableObjectSet.hxx>
39 #include <SelectMgr_StateOfSelection.hxx>
40 #include <Standard_OStream.hxx>
41
42 class SelectMgr_SelectionManager;
43 class SelectMgr_Selection;
44 class SelectMgr_SensitiveEntitySet;
45 class SelectMgr_EntityOwner;
46 class TCollection_AsciiString;
47 class SelectBasics_SensitiveEntity;
48 class SelectMgr_SelectableObjectSet;
49
50 typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), NCollection_Handle<SelectMgr_SensitiveEntitySet> > SelectMgr_MapOfObjectSensitives;
51 typedef NCollection_DataMap<Handle(SelectMgr_SelectableObject), NCollection_Handle<SelectMgr_SensitiveEntitySet> >::Iterator SelectMgr_MapOfObjectSensitivesIterator;
52
53 typedef NCollection_DataMap<Handle(SelectMgr_EntityOwner), Standard_Integer> SelectMgr_MapOfOwnerDetectedEntities;
54 typedef NCollection_DataMap<Handle(SelectMgr_EntityOwner), Standard_Integer>::Iterator SelectMgr_MapOfOwnerDetectedEntitiesIterator;
55
56 //! An internal class for calculation of current largest tolerance value which will be applied
57 //! for creation of selecting frustum by default. Each time the selection set is deactivated,
58 //! maximum tolerance value will be recalculated. If a user enables custom precision using
59 //! StdSelect_ViewerSelector3d::SetPixelTolerance, it will be applied to all sensitive entities
60 //! without any checks.
61 class SelectMgr_ToleranceMap
62 {
63 public:
64
65   //! Sets tolerance values to -1.0
66   SelectMgr_ToleranceMap();
67
68   Standard_EXPORT ~SelectMgr_ToleranceMap();
69
70   //! Adds the value given to map, checks if the current tolerance value
71   //! should be replaced by theTolerance
72   Standard_EXPORT void Add (const Standard_Real& theTolerance);
73
74   //! Decrements a counter of the tolerance given, checks if the current tolerance value
75   //! should be recalculated
76   Standard_EXPORT void Decrement (const Standard_Real& theTolerance);
77
78   //! Returns a current tolerance that must be applied
79   inline Standard_Real Tolerance() const;
80
81   //! Sets tolerance to the given one and disables adaptive checks
82   inline void SetCustomTolerance (const Standard_Real theTolerance);
83
84   //! Unsets a custom tolerance and enables adaptive checks
85   inline void ResetDefaults();
86
87   //! Returns the value of custom tolerance regardless of it validity
88   inline Standard_Real CustomTolerance() const;
89
90   //! Returns true if custom tolerance value is greater than zero
91   inline Standard_Boolean IsCustomTolSet() const;
92
93 private:
94   NCollection_DataMap<Standard_Real, Standard_Integer> myTolerances;
95   Standard_Real                                        myLargestKey;
96   Standard_Real                                        myCustomTolerance;
97 };
98
99 //! A framework to define finding, sorting the sensitive
100 //! primitives in a view. Services are also provided to
101 //! define the return of the owners of those primitives
102 //! selected. The primitives are sorted by criteria such
103 //! as priority of the primitive or its depth in the view
104 //! relative to that of other primitives.
105 //! Note that in 3D, the inheriting framework
106 //! StdSelect_ViewerSelector3d   is only to be used
107 //! if you do not want to use the services provided by
108 //! AIS.
109 //! Two tools are available to find and select objects
110 //! found at a given position in the view. If you want to
111 //! select the owners of all the objects detected at
112 //! point x,y,z you use the Init - More - Next - Picked
113 //! loop. If, on the other hand, you want to select only
114 //! one object detected at that point, you use the Init -
115 //! More - OnePicked loop. In this iteration, More is
116 //! used to see if an object was picked and
117 //! OnePicked, to get the object closest to the pick position.
118 //! Viewer selectors are driven by
119 //! SelectMgr_SelectionManager, and manipulate
120 //! the SelectMgr_Selection objects given to them by
121 //! the selection manager.
122 //!
123 //! Tolerances are applied to the entities in the following way:
124 //! 1. tolerance value stored in mytolerance will be used to calculate initial
125 //!    selecting frustum, which will be applied for intersection testing during
126 //!    BVH traverse;
127 //! 2. if tolerance of sensitive entity is less than mytolerance, the frustum for
128 //!    intersection detection will be resized according to its sensitivity.
129 class SelectMgr_ViewerSelector : public MMgt_TShared
130 {
131 public:
132
133   //! Empties all the tables, removes all selections...
134   Standard_EXPORT void Clear();
135
136   //! returns the Sensitivity of picking
137   Standard_Real Sensitivity() const;
138
139   //! Sorts the detected entites by priority and distance.
140   //!          to be redefined if other criterion are used...
141   Standard_EXPORT void SortResult();
142
143   //! Begins an iteration scanning for the owners detected at a position in the view.
144   void Init();
145
146   //!  Continues the interation scanning for the owners
147   //!   detected at a position in the view, or
148   //! -   continues the iteration scanning for the owner
149   //!   closest to the position in the view.
150   Standard_EXPORT Standard_Boolean More();
151
152   //! Returns the next owner found in the iteration. This is
153   //! a scan for the owners detected at a position in the view.
154   void Next();
155
156   //! Returns the current selected entity detected by the selector;
157   Standard_EXPORT Handle(SelectMgr_EntityOwner) Picked() const;
158
159   //! Returns the picked element with the highest priority,
160   //! and which is the closest to the last successful mouse position.
161   Standard_EXPORT Handle(SelectMgr_EntityOwner) OnePicked();
162
163   //! Set preference of selecting one object for OnePicked() method:
164   //! - If True, objects with less depth (distance fron the view plane) are
165   //!   preferred regardless of priority (priority is used then to choose among
166   //!   objects with similar depth),
167   //! - If False, objects with higher priority are preferred regardless of the
168   //!   depth which is used to choose among objects of the same priority.
169   void SetPickClosest (const Standard_Boolean preferClosest);
170
171   //! Returns the number of owners found at a position in
172   //! the view by the Init - More - Next - Picked iteration.
173   Standard_EXPORT Standard_Integer NbPicked() const;
174
175   //! Returns the  entity which is at rank <aRank>
176   //!          in the list of stored ones.
177   Standard_EXPORT Handle(SelectMgr_EntityOwner) Picked (const Standard_Integer aRank) const;
178
179   Standard_EXPORT Standard_Boolean Contains (const Handle(SelectMgr_SelectableObject)& theObject) const;
180
181   //! Returns the list of selection modes ModeList found in
182   //! this selector for the selectable object aSelectableObject.
183   //! Returns true if aSelectableObject is referenced inside
184   //! this selector; returns false if the object is not present
185   //! in this selector.
186   Standard_EXPORT Standard_Boolean Modes (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
187                                           TColStd_ListOfInteger& theModeList,
188                                           const SelectMgr_StateOfSelection theWantedState = SelectMgr_SOS_Any) const;
189
190   //! Returns true if the selectable object
191   //! aSelectableObject having the selection mode aMode
192   //! is active in this selector.
193   Standard_EXPORT Standard_Boolean IsActive (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
194                                              const Standard_Integer theMode) const;
195
196   //! Returns true if the selectable object
197   //! aSelectableObject having the selection mode aMode
198   //! is in this selector.
199   Standard_EXPORT Standard_Boolean IsInside (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
200                                              const Standard_Integer theMode) const;
201
202   //! Returns the selection status Status of the selection aSelection.
203   Standard_EXPORT SelectMgr_StateOfSelection Status (const Handle(SelectMgr_Selection)& theSelection) const;
204
205   Standard_EXPORT TCollection_AsciiString Status (const Handle(SelectMgr_SelectableObject)& theSelectableObject) const;
206
207   //! Returns the list of active entity owners
208   Standard_EXPORT void ActiveOwners (NCollection_List<Handle(SelectBasics_EntityOwner)>& theOwners) const;
209
210   //! Adds new object to the map of selectable objects
211   Standard_EXPORT void AddSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject);
212
213   //! Adds new selection to the object and builds its BVH tree
214   Standard_EXPORT void AddSelectionToObject (const Handle(SelectMgr_SelectableObject)& theObject,
215                                              const Handle(SelectMgr_Selection)& theSelection);
216
217   //! Removes selectable object from map of selectable ones
218   Standard_EXPORT void RemoveSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject);
219
220   //! Removes selection of the object and marks its BVH tree for rebuild
221   Standard_EXPORT void RemoveSelectionOfObject (const Handle(SelectMgr_SelectableObject)& theObject,
222                                                 const Handle(SelectMgr_Selection)& theSelection);
223
224   //! Marks BVH of selectable objects for rebuild. Parameter theIsForce set as true
225   //! guarantees that 1st level BVH for the viewer selector will be rebuilt during this call
226   Standard_EXPORT void RebuildObjectsTree (const Standard_Boolean theIsForce = Standard_False);
227
228   //! Marks BVH of sensitive entities of particular selectable object for rebuild. Parameter
229   //! theIsForce set as true guarantees that 2nd level BVH for the object given will be
230   //! rebuilt during this call
231   Standard_EXPORT void RebuildSensitivesTree (const Handle(SelectMgr_SelectableObject)& theObject,
232                                               const Standard_Boolean theIsForce = Standard_False);
233
234   //! Initializes internal iterator for stored detected sensitive entities
235   Standard_EXPORT void InitDetected();
236
237   //! Makes a step along the map of detected sensitive entities and their owners
238   Standard_EXPORT void NextDetected();
239
240   //! Returns true if iterator of map of detected sensitive entities has reached
241   //! its end
242   Standard_EXPORT Standard_Boolean MoreDetected();
243
244   //! Returns sensitive entity that was detected during the previous run of
245   //! selection algorithm
246   Standard_EXPORT const Handle(SelectBasics_SensitiveEntity)& DetectedEntity() const;
247
248   //! Returns instance of selecting volume manager of the viewer selector
249   Standard_EXPORT SelectMgr_SelectingVolumeManager& GetManager();
250
251   //! Marks all added sensitive entities of all objects as non-selectable
252   Standard_EXPORT void ResetSelectionActivationStatus();
253
254   //! Is used for rectangular selection only
255   //! If theIsToAllow is false, only fully included sensitives will be detected, otherwise the algorithm will
256   //! mark both included and overlapped entities as matched
257   Standard_EXPORT void AllowOverlapDetection (const Standard_Boolean theIsToAllow);
258
259   friend class SelectMgr_SelectionManager;
260
261   DEFINE_STANDARD_RTTI(SelectMgr_ViewerSelector, MMgt_TShared)
262
263 protected:
264
265   Standard_EXPORT SelectMgr_ViewerSelector();
266
267   //! Traverses BVH containing all added selectable objects and
268   //! finds candidates for further search of overlap
269   Standard_EXPORT void TraverseSensitives();
270
271   //! Returns True if the owner provides clipping by depth
272   //! for its sensitives. Override this method to tell the selector
273   //! to use the DepthClipping method for the owner.
274   //! Default implementation returns False for every owner.
275   //! @param theOwner [in] the onwer to check.
276   //! @return True if owner provides depth limits for sensitive clipping.
277   Standard_EXPORT virtual Standard_Boolean HasDepthClipping (const Handle(SelectMgr_EntityOwner)& theOwner) const;
278
279   //! Internal function that checks if there is possible overlap
280   //! between some entity of selectable object theObject and
281   //! current selecting volume
282   Standard_EXPORT void traverseObject (const Handle(SelectMgr_SelectableObject)& theObject);
283
284   //! Internal function that checks if a particular sensitive
285   //! entity theEntity overlaps current selecting volume precisely
286   Standard_EXPORT void checkOverlap (const Handle(SelectBasics_SensitiveEntity)& theEntity,
287                                      const Standard_Integer theEntityIdx,
288                                      SelectMgr_SelectingVolumeManager& theMgr);
289
290 private:
291
292   //! Checks if the entity given requires to scale current selecting frustum
293   Standard_Boolean isToScaleFrustum (const Handle(SelectBasics_SensitiveEntity)& theEntity);
294
295   //! In case if custom tolerance is set, this method will return sum of entity sensitivity and
296   //! custom tolerance. Otherwise, pure entity sensitivity factor will be returned.
297   Standard_Real sensitivity (const Handle(SelectBasics_SensitiveEntity)& theEntity) const;
298
299   //! Applies given scale and transformation matrices to the default selecting volume manager
300   SelectMgr_SelectingVolumeManager scaleAndTransform (const Standard_Real theScale,
301                                                       const gp_Trsf& theTrsf);
302
303   void Activate (const Handle(SelectMgr_Selection)& theSelection);
304
305   void Deactivate (const Handle(SelectMgr_Selection)& theSelection);
306
307   //! removes a Selection from the Selector
308   void Remove (const Handle(SelectMgr_Selection)& aSelection);
309
310 protected:
311
312   Standard_Boolean preferclosest;
313   Standard_Boolean myToUpdateTolerance;
314   SelectMgr_IndexedDataMapOfOwnerCriterion mystored;
315   SelectMgr_SelectingVolumeManager mySelectingVolumeMgr;
316   mutable NCollection_Handle<SelectMgr_SelectableObjectSet> mySelectableObjects;
317   SelectMgr_ToleranceMap myTolerances;
318
319 private:
320
321   Handle(TColStd_HArray1OfInteger)             myIndexes;
322   Standard_Integer                             myCurRank;
323   Standard_Boolean                             myIsLeftChildQueuedFirst;
324   Standard_Integer                             myEntityIdx;
325   SelectMgr_MapOfObjectSensitives              myMapOfObjectSensitives;
326   SelectMgr_MapOfOwnerDetectedEntities         myMapOfDetected;
327   SelectMgr_MapOfOwnerDetectedEntitiesIterator myDetectedIter;
328 };
329
330 DEFINE_STANDARD_HANDLE(SelectMgr_ViewerSelector, MMgt_TShared)
331
332 #include <SelectMgr_ViewerSelector.lxx>
333
334 #endif