0032337: Visualization - rename Overlaps() method in selection to more self-describab...
[occt.git] / src / SelectMgr / SelectMgr_SelectingVolumeManager.hxx
1 // Created on: 2014-05-22
2 // Created by: Varvara POSKONINA
3 // Copyright (c) 2005-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef _SelectMgr_SelectingVolumeManager_HeaderFile
17 #define _SelectMgr_SelectingVolumeManager_HeaderFile
18
19 #include <SelectBasics_SelectingVolumeManager.hxx>
20
21 #include <SelectMgr_BaseIntersector.hxx>
22 #include <SelectMgr_VectorTypes.hxx>
23 #include <SelectMgr_ViewClipRange.hxx>
24
25 //! This class is used to switch between active selecting volumes depending
26 //! on selection type chosen by the user.
27 //! The sample of correct selection volume initialization procedure:
28 //! @code
29 //!   aMgr.InitPointSelectingVolume (aMousePos);
30 //!   aMgr.SetPixelTolerance (aTolerance);
31 //!   aMgr.SetCamera (aCamera);
32 //!   aMgr.SetWindowSize (aWidth, aHeight);
33 //!   aMgr.BuildSelectingVolume();
34 //! @endcode
35 class SelectMgr_SelectingVolumeManager : public SelectBasics_SelectingVolumeManager
36 {
37 public:
38
39   //! Creates instances of all available selecting volume types
40   Standard_EXPORT SelectMgr_SelectingVolumeManager();
41
42   virtual ~SelectMgr_SelectingVolumeManager() {}
43
44   //! Creates, initializes and activates rectangular selecting frustum for point selection
45   Standard_EXPORT void InitPointSelectingVolume (const gp_Pnt2d& thePoint);
46
47   //! Creates, initializes and activates rectangular selecting frustum for box selection
48   Standard_EXPORT void InitBoxSelectingVolume (const gp_Pnt2d& theMinPt,
49                                                const gp_Pnt2d& theMaxPt);
50
51   //! Creates, initializes and activates set of triangular selecting frustums for polyline selection
52   Standard_EXPORT void InitPolylineSelectingVolume (const TColgp_Array1OfPnt2d& thePoints);
53
54   //! Creates and activates axis selector for point selection
55   Standard_EXPORT void InitAxisSelectingVolume (const gp_Ax1& theAxis);
56
57   //! Sets as active the custom selecting volume
58   Standard_EXPORT void InitSelectingVolume (const Handle(SelectMgr_BaseIntersector)& theVolume);
59
60   //! Builds previously initialized selecting volume.
61   Standard_EXPORT void BuildSelectingVolume();
62
63   //! Returns active selecting volume that was built during last
64   //! run of OCCT selection mechanism
65   const Handle(SelectMgr_BaseIntersector)& ActiveVolume() const { return myActiveSelectingVolume; }
66
67   // Returns active selection type (point, box, polyline)
68   Standard_EXPORT virtual Standard_Integer GetActiveSelectionType() const Standard_OVERRIDE;
69
70   //! IMPORTANT: Scaling makes sense only for frustum built on a single point!
71   //!            Note that this method does not perform any checks on type of the frustum.
72   //!
73   //! Returns a copy of the frustum resized according to the scale factor given
74   //! and transforms it using the matrix given.
75   //! There are no default parameters, but in case if:
76   //!    - transformation only is needed: @theScaleFactor must be initialized as any negative value;
77   //!    - scale only is needed: @theTrsf must be set to gp_Identity.
78   //! Builder is an optional argument that represents corresponding settings for re-constructing transformed
79   //! frustum from scratch. Can be null if reconstruction is not expected furthermore.
80   Standard_EXPORT virtual SelectMgr_SelectingVolumeManager ScaleAndTransform (const Standard_Integer theScaleFactor,
81                                                                               const gp_GTrsf& theTrsf,
82                                                                               const Handle(SelectMgr_FrustumBuilder)& theBuilder) const;
83
84 public:
85
86   //! Returns current camera definition.
87   Standard_EXPORT const Handle(Graphic3d_Camera)& Camera() const;
88
89   //! Updates camera projection and orientation matrices in all selecting volumes
90   //! Note: this method should be called after selection volume building
91   //! else exception will be thrown
92   Standard_EXPORT void SetCamera (const Handle(Graphic3d_Camera) theCamera);
93
94   //! Updates camera projection and orientation matrices in all selecting volumes
95   //! Note: this method should be called after selection volume building
96   //! else exception will be thrown
97   Standard_EXPORT void SetCamera (const Graphic3d_Mat4d& theProjection,
98                                   const Graphic3d_Mat4d& theWorldView,
99                                   const Standard_Boolean theIsOrthographic,
100                                   const Graphic3d_WorldViewProjState& theWVPState = Graphic3d_WorldViewProjState());
101
102   //! @return current projection transformation common for all selecting volumes
103   Standard_EXPORT const Graphic3d_Mat4d& ProjectionMatrix() const;
104
105   //! @return current world view transformation common for all selecting volumes
106   Standard_EXPORT const Graphic3d_Mat4d& WorldViewMatrix() const;
107
108   Standard_EXPORT void WindowSize (Standard_Integer& theWidth, Standard_Integer& theHeight) const;
109
110   //! @return current camera world view projection transformation state common for all selecting volumes
111   Standard_EXPORT const Graphic3d_WorldViewProjState& WorldViewProjState() const;
112
113   //! Updates viewport in all selecting volumes
114   //! Note: this method should be called after selection volume building
115   //! else exception will be thrown
116   Standard_EXPORT void SetViewport (const Standard_Real theX,
117                                     const Standard_Real theY,
118                                     const Standard_Real theWidth,
119                                     const Standard_Real theHeight);
120
121   //! Updates pixel tolerance in all selecting volumes
122   //! Note: this method should be called after selection volume building
123   //! else exception will be thrown
124   Standard_EXPORT void SetPixelTolerance (const Standard_Integer theTolerance);
125
126   //! Updates window size in all selecting volumes
127   //! Note: this method should be called after selection volume building
128   //! else exception will be thrown
129   Standard_EXPORT void SetWindowSize (const Standard_Integer theWidth, const Standard_Integer theHeight);
130
131
132   //! SAT intersection test between defined volume and given axis-aligned box
133   Standard_EXPORT virtual Standard_Boolean OverlapsBox (const SelectMgr_Vec3& theBoxMin,
134                                                         const SelectMgr_Vec3& theBoxMax,
135                                                         SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
136
137   //! Returns true if selecting volume is overlapped by axis-aligned bounding box
138   //! with minimum corner at point theMinPt and maximum at point theMaxPt
139   Standard_EXPORT  virtual Standard_Boolean OverlapsBox (const SelectMgr_Vec3& theBoxMin,
140                                                          const SelectMgr_Vec3& theBoxMax,
141                                                          Standard_Boolean*     theInside = NULL) const Standard_OVERRIDE;
142
143   //! Intersection test between defined volume and given point
144   Standard_EXPORT virtual Standard_Boolean OverlapsPoint (const gp_Pnt& thePnt,
145                                                           SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
146
147   //! Intersection test between defined volume and given point
148   Standard_EXPORT virtual Standard_Boolean OverlapsPoint (const gp_Pnt& thePnt) const Standard_OVERRIDE;
149
150   //! SAT intersection test between defined volume and given ordered set of points,
151   //! representing line segments. The test may be considered of interior part or
152   //! boundary line defined by segments depending on given sensitivity type
153   Standard_EXPORT virtual Standard_Boolean OverlapsPolygon (const Handle(TColgp_HArray1OfPnt)& theArrayOfPts,
154                                                             Standard_Integer theSensType,
155                                                             SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
156
157   //! SAT intersection test between defined volume and given ordered set of points,
158   //! representing line segments. The test may be considered of interior part or
159   //! boundary line defined by segments depending on given sensitivity type
160   Standard_EXPORT virtual Standard_Boolean OverlapsPolygon (const TColgp_Array1OfPnt& theArrayOfPts,
161                                                             Standard_Integer theSensType,
162                                                             SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
163
164   //! Checks if line segment overlaps selecting frustum
165   Standard_EXPORT virtual Standard_Boolean OverlapsSegment (const gp_Pnt& thePnt1,
166                                                             const gp_Pnt& thePnt2,
167                                                             SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
168
169   //! SAT intersection test between defined volume and given triangle. The test may
170   //! be considered of interior part or boundary line defined by triangle vertices
171   //! depending on given sensitivity type
172   Standard_EXPORT  virtual Standard_Boolean OverlapsTriangle (const gp_Pnt& thePnt1,
173                                                               const gp_Pnt& thePnt2,
174                                                               const gp_Pnt& thePnt3,
175                                                               Standard_Integer theSensType,
176                                                               SelectBasics_PickResult& thePickResult) const Standard_OVERRIDE;
177
178   //! Measures distance between 3d projection of user-picked
179   //! screen point and given point theCOG
180   Standard_EXPORT virtual Standard_Real DistToGeometryCenter (const gp_Pnt& theCOG) const Standard_OVERRIDE;
181
182   //! Calculates the point on a view ray that was detected during the run of selection algo by given depth.
183   //! Throws exception if active selection type is not Point.
184   Standard_EXPORT virtual gp_Pnt DetectedPoint (const Standard_Real theDepth) const Standard_OVERRIDE;
185
186   //! If theIsToAllow is false, only fully included sensitives will be detected, otherwise the algorithm will
187   //! mark both included and overlapped entities as matched
188   Standard_EXPORT virtual void AllowOverlapDetection (const Standard_Boolean theIsToAllow);
189
190   Standard_EXPORT virtual Standard_Boolean IsOverlapAllowed() const Standard_OVERRIDE;
191
192   //! Return view clipping planes.
193   const Handle(Graphic3d_SequenceOfHClipPlane)& ViewClipping() const { return myViewClipPlanes; }
194
195   //! Return object clipping planes.
196   const Handle(Graphic3d_SequenceOfHClipPlane)& ObjectClipping() const { return myObjectClipPlanes; }
197
198   //! Valid for point selection only!
199   //! Computes depth range for clipping planes.
200   //! @param theViewPlanes  [in] global view planes
201   //! @param theObjPlanes   [in] object planes
202   //! @param theWorldSelMgr [in] selection volume in world space for computing clipping plane ranges
203   Standard_EXPORT void SetViewClipping (const Handle(Graphic3d_SequenceOfHClipPlane)& theViewPlanes,
204                                         const Handle(Graphic3d_SequenceOfHClipPlane)& theObjPlanes,
205                                         const SelectMgr_SelectingVolumeManager* theWorldSelMgr);
206
207   //! Copy clipping planes from another volume manager.
208   Standard_EXPORT void SetViewClipping (const SelectMgr_SelectingVolumeManager& theOther);
209
210   //! Return clipping range.
211   const SelectMgr_ViewClipRange& ViewClipRanges() const { return myViewClipRange; }
212
213   //! Set clipping range.
214   void SetViewClipRanges (const SelectMgr_ViewClipRange& theRange) { myViewClipRange = theRange; }
215
216   //! A set of helper functions that return rectangular selecting frustum data
217   Standard_EXPORT const gp_Pnt* GetVertices() const;
218
219   //! Valid only for point and rectangular selection.
220   //! Returns projection of 2d mouse picked point or projection
221   //! of center of 2d rectangle (for point and rectangular selection
222   //! correspondingly) onto near view frustum plane
223   Standard_EXPORT virtual gp_Pnt GetNearPickedPnt() const Standard_OVERRIDE;
224
225   //! Valid only for point and rectangular selection.
226   //! Returns projection of 2d mouse picked point or projection
227   //! of center of 2d rectangle (for point and rectangular selection
228   //! correspondingly) onto far view frustum plane
229   Standard_EXPORT virtual gp_Pnt GetFarPickedPnt() const Standard_OVERRIDE;
230
231   //! Valid only for point and rectangular selection.
232   //! Returns view ray direction
233   Standard_EXPORT virtual gp_Dir GetViewRayDirection() const Standard_OVERRIDE;
234
235   //! Checks if it is possible to scale current active selecting volume
236   Standard_EXPORT virtual Standard_Boolean IsScalableActiveVolume() const Standard_OVERRIDE;
237
238   //! Returns mouse coordinates for Point selection mode.
239   //! @return infinite point in case of unsupport of mouse position for this active selection volume.
240   Standard_EXPORT virtual gp_Pnt2d GetMousePosition() const Standard_OVERRIDE;
241
242   //! Stores plane equation coefficients (in the following form:
243   //! Ax + By + Cz + D = 0) to the given vector
244   Standard_EXPORT virtual void GetPlanes (NCollection_Vector<SelectMgr_Vec4>& thePlaneEquations) const Standard_OVERRIDE;
245
246   //! Dumps the content of me into the stream
247   Standard_EXPORT virtual void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const Standard_OVERRIDE;
248
249 public:
250
251   Standard_DEPRECATED("Deprecated alias - SelectMgr_SelectionType should be used instead")
252   static const SelectMgr_SelectionType Point = SelectMgr_SelectionType_Point;
253
254   Standard_DEPRECATED("Deprecated alias - SelectMgr_SelectionType should be used instead")
255   static const SelectMgr_SelectionType Box = SelectMgr_SelectionType_Point;
256
257   Standard_DEPRECATED("Deprecated alias - SelectMgr_SelectionType should be used instead")
258   static const SelectMgr_SelectionType Polyline = SelectMgr_SelectionType_Point;
259
260   Standard_DEPRECATED("Deprecated alias - SelectMgr_SelectionType should be used instead")
261   static const SelectMgr_SelectionType Unknown = SelectMgr_SelectionType_Point;
262
263   Standard_DEPRECATED("Deprecated method - InitPointSelectingVolume() and Build() methods should be used instead")
264   Standard_EXPORT void BuildSelectingVolume (const gp_Pnt2d& thePoint);
265
266   Standard_DEPRECATED("Deprecated method - InitBoxSelectingVolume() and Build() should be used instead")
267   Standard_EXPORT void BuildSelectingVolume (const gp_Pnt2d& theMinPt,
268                                              const gp_Pnt2d& theMaxPt);
269
270   Standard_DEPRECATED("Deprecated method - InitPolylineSelectingVolume() and Build() should be used instead")
271   Standard_EXPORT void BuildSelectingVolume (const TColgp_Array1OfPnt2d& thePoints);
272
273   //! SAT intersection test between defined volume and given axis-aligned box
274   Standard_DEPRECATED ("Deprecated method - OverlapsBox() should be used instead")
275   Standard_Boolean Overlaps (const SelectMgr_Vec3& theBoxMin,
276                              const SelectMgr_Vec3& theBoxMax,
277                              SelectBasics_PickResult& thePickResult) const
278   {
279     return OverlapsBox (theBoxMin, theBoxMax, thePickResult);
280   }
281
282   //! Returns true if selecting volume is overlapped by axis-aligned bounding box
283   //! with minimum corner at point theMinPt and maximum at point theMaxPt
284   Standard_DEPRECATED ("Deprecated method - OverlapsBox() should be used instead")
285   Standard_Boolean Overlaps (const SelectMgr_Vec3& theBoxMin,
286                              const SelectMgr_Vec3& theBoxMax,
287                              Standard_Boolean*     theInside = NULL) const
288   {
289     return OverlapsBox (theBoxMin, theBoxMax, theInside);
290   }
291
292   //! Intersection test between defined volume and given point
293   Standard_DEPRECATED ("Deprecated method - OverlapsPoint() should be used instead")
294   Standard_Boolean Overlaps (const gp_Pnt& thePnt,
295                              SelectBasics_PickResult& thePickResult) const
296   {
297     return OverlapsPoint (thePnt, thePickResult);
298   }
299
300   //! Intersection test between defined volume and given point
301   Standard_DEPRECATED ("Deprecated method - OverlapsPoint() should be used instead")
302   Standard_Boolean Overlaps (const gp_Pnt& thePnt) const
303   {
304     return OverlapsPoint (thePnt);
305   }
306
307   //! SAT intersection test between defined volume and given ordered set of points,
308   //! representing line segments. The test may be considered of interior part or
309   //! boundary line defined by segments depending on given sensitivity type
310   Standard_DEPRECATED ("Deprecated method - OverlapsPolygon() should be used instead")
311   Standard_Boolean Overlaps (const Handle(TColgp_HArray1OfPnt)& theArrayOfPts,
312                              Standard_Integer theSensType,
313                              SelectBasics_PickResult& thePickResult) const
314   {
315     return OverlapsPolygon (theArrayOfPts, theSensType, thePickResult);
316   }
317
318   //! SAT intersection test between defined volume and given ordered set of points,
319   //! representing line segments. The test may be considered of interior part or
320   //! boundary line defined by segments depending on given sensitivity type
321   Standard_DEPRECATED ("Deprecated method - OverlapsPolygon() should be used instead")
322   Standard_Boolean Overlaps (const TColgp_Array1OfPnt& theArrayOfPts,
323                              Standard_Integer theSensType,
324                              SelectBasics_PickResult& thePickResult) const
325   {
326     return OverlapsPolygon (theArrayOfPts, theSensType, thePickResult);
327   }
328
329   //! Checks if line segment overlaps selecting frustum
330   Standard_DEPRECATED ("Deprecated method - OverlapsSegment() should be used instead")
331   Standard_Boolean Overlaps (const gp_Pnt& thePnt1,
332                              const gp_Pnt& thePnt2,
333                              SelectBasics_PickResult& thePickResult) const
334   {
335     return OverlapsSegment (thePnt1, thePnt2, thePickResult);
336   }
337
338   //! SAT intersection test between defined volume and given triangle. The test may
339   //! be considered of interior part or boundary line defined by triangle vertices
340   //! depending on given sensitivity type
341   Standard_DEPRECATED ("Deprecated method - OverlapsTriangle() should be used instead")
342   Standard_Boolean Overlaps (const gp_Pnt& thePnt1,
343                              const gp_Pnt& thePnt2,
344                              const gp_Pnt& thePnt3,
345                              Standard_Integer theSensType,
346                              SelectBasics_PickResult& thePickResult) const
347   {
348     return OverlapsTriangle (thePnt1, thePnt2, thePnt3, theSensType, thePickResult);
349   }
350
351 private:
352   Handle(SelectMgr_BaseIntersector)      myActiveSelectingVolume;
353   Handle(Graphic3d_SequenceOfHClipPlane) myViewClipPlanes;                  //!< view clipping planes
354   Handle(Graphic3d_SequenceOfHClipPlane) myObjectClipPlanes;                //!< object clipping planes
355   SelectMgr_ViewClipRange                myViewClipRange;
356   Standard_Boolean                       myToAllowOverlap;                  //!< Defines if partially overlapped entities will me detected or not
357 };
358
359 #endif