0032337: Visualization - rename Overlaps() method in selection to more self-describab...
[occt.git] / src / SelectMgr / SelectMgr_SelectingVolumeManager.cxx
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 #include <SelectMgr_SelectingVolumeManager.hxx>
17
18 #include <Graphic3d_SequenceOfHClipPlane.hxx>
19 #include <SelectMgr_AxisIntersector.hxx>
20 #include <SelectMgr_RectangularFrustum.hxx>
21 #include <SelectMgr_TriangularFrustumSet.hxx>
22
23 #include <BVH_Tools.hxx>
24 #include <Standard_Dump.hxx>
25
26 //=======================================================================
27 // function : SelectMgr_SelectingVolumeManager
28 // purpose  : Creates instances of all available selecting volume types
29 //=======================================================================
30 SelectMgr_SelectingVolumeManager::SelectMgr_SelectingVolumeManager()
31 : myActiveSelectingVolume (NULL),
32   myToAllowOverlap (Standard_False)
33 {
34 }
35
36 //=======================================================================
37 // function : ScaleAndTransform
38 // purpose  : IMPORTANT: Scaling makes sense only for frustum built on a single point!
39 //            Note that this method does not perform any checks on type of the frustum.
40 //
41 //            Returns a copy of the frustum resized according to the scale factor given
42 //            and transforms it using the matrix given.
43 //            There are no default parameters, but in case if:
44 //                - transformation only is needed: @theScaleFactor must be initialized
45 //                  as any negative value;
46 //                - scale only is needed: @theTrsf must be set to gp_Identity.
47 //            Builder is an optional argument that represents corresponding settings for
48 //            re-constructing transformed frustum from scratch. Can be null if reconstruction
49 //            is not needed furthermore in the code.
50 //=======================================================================
51 SelectMgr_SelectingVolumeManager SelectMgr_SelectingVolumeManager::ScaleAndTransform (const Standard_Integer theScaleFactor,
52                                                                                       const gp_GTrsf& theTrsf,
53                                                                                       const Handle(SelectMgr_FrustumBuilder)& theBuilder) const
54 {
55   SelectMgr_SelectingVolumeManager aMgr;
56   if (myActiveSelectingVolume.IsNull())
57   {
58     return aMgr;
59   }
60
61   aMgr.myActiveSelectingVolume = myActiveSelectingVolume->ScaleAndTransform (theScaleFactor, theTrsf, theBuilder);
62   aMgr.myToAllowOverlap = myToAllowOverlap;
63   aMgr.myViewClipPlanes = myViewClipPlanes;
64   aMgr.myObjectClipPlanes = myObjectClipPlanes;
65   aMgr.myViewClipRange = myViewClipRange;
66
67   return aMgr;
68 }
69
70 //=======================================================================
71 // function : GetActiveSelectionType
72 // purpose  :
73 //=======================================================================
74 Standard_Integer SelectMgr_SelectingVolumeManager::GetActiveSelectionType() const
75 {
76   if (myActiveSelectingVolume.IsNull())
77   {
78     return SelectMgr_SelectionType_Unknown;
79   }
80   return myActiveSelectingVolume->GetSelectionType();
81 }
82
83 //=======================================================================
84 // function : Camera
85 // purpose  :
86 //=======================================================================
87 const Handle(Graphic3d_Camera)& SelectMgr_SelectingVolumeManager::Camera() const
88 {
89   if (myActiveSelectingVolume.IsNull())
90   {
91     static const Handle(Graphic3d_Camera) anEmptyCamera;
92     return anEmptyCamera;
93   }
94   return myActiveSelectingVolume->Camera();
95 }
96
97 //=======================================================================
98 // function : SetCamera
99 // purpose  :
100 //=======================================================================
101 void SelectMgr_SelectingVolumeManager::SetCamera (const Handle(Graphic3d_Camera) theCamera)
102 {
103   Standard_ASSERT_RAISE(!myActiveSelectingVolume.IsNull(),
104     "SelectMgr_SelectingVolumeManager::SetCamera() should be called after initialization of selection volume ");
105   myActiveSelectingVolume->SetCamera (theCamera);
106 }
107
108 //=======================================================================
109 // function : SetCamera
110 // purpose  : Updates camera projection and orientation matrices in all
111 //            selecting volumes
112 //=======================================================================
113 void SelectMgr_SelectingVolumeManager::SetCamera (const Graphic3d_Mat4d& theProjection,
114                                                   const Graphic3d_Mat4d& theWorldView,
115                                                   const Standard_Boolean theIsOrthographic,
116                                                   const Graphic3d_WorldViewProjState& theWVPState)
117 {
118   Standard_ASSERT_RAISE(!myActiveSelectingVolume.IsNull(),
119     "SelectMgr_SelectingVolumeManager::SetCamera() should be called after initialization of selection volume ");
120   myActiveSelectingVolume->SetCamera (theProjection, theWorldView, theIsOrthographic, theWVPState);
121 }
122
123 //=======================================================================
124 // function : ProjectionMatrix
125 // purpose  : Returns current projection transformation common for all
126 //            selecting volumes
127 //=======================================================================
128 const Graphic3d_Mat4d& SelectMgr_SelectingVolumeManager::ProjectionMatrix() const
129 {
130   if (myActiveSelectingVolume.IsNull())
131   {
132     static const Graphic3d_Mat4d anEmptyMatrix;
133     return anEmptyMatrix;
134   }
135   return myActiveSelectingVolume->ProjectionMatrix();
136 }
137
138 //=======================================================================
139 // function : WorldViewMatrix
140 // purpose  : Returns current world view transformation common for all
141 //            selecting volumes
142 //=======================================================================
143 const Graphic3d_Mat4d& SelectMgr_SelectingVolumeManager::WorldViewMatrix() const
144 {
145   if (myActiveSelectingVolume.IsNull())
146   {
147     static const Graphic3d_Mat4d anEmptyMatrix;
148     return anEmptyMatrix;
149   }
150   return myActiveSelectingVolume->WorldViewMatrix();
151 }
152
153 //=======================================================================
154 // function : WorldViewProjState
155 // purpose  : Returns current camera world view projection transformation
156 //            state common for all selecting volumes
157 //=======================================================================
158 const Graphic3d_WorldViewProjState& SelectMgr_SelectingVolumeManager::WorldViewProjState() const
159 {
160   if (myActiveSelectingVolume.IsNull())
161   {
162     static const Graphic3d_WorldViewProjState anEmptyState;
163     return anEmptyState;
164   }
165   return myActiveSelectingVolume->WorldViewProjState();
166 }
167
168 //=======================================================================
169 // function : WindowSize
170 // purpose  :
171 //=======================================================================
172 void SelectMgr_SelectingVolumeManager::WindowSize (Standard_Integer& theWidth, Standard_Integer& theHeight) const
173 {
174   if (myActiveSelectingVolume.IsNull())
175   {
176     return;
177   }
178   myActiveSelectingVolume->WindowSize (theWidth, theHeight);
179 }
180
181 //=======================================================================
182 // function : SetWindowSize
183 // purpose  : Updates window size in all selecting volumes
184 //=======================================================================
185 void SelectMgr_SelectingVolumeManager::SetWindowSize (const Standard_Integer theWidth,
186                                                       const Standard_Integer theHeight)
187 {
188   Standard_ASSERT_RAISE(!myActiveSelectingVolume.IsNull(),
189     "SelectMgr_SelectingVolumeManager::SetWindowSize() should be called after initialization of selection volume ");
190   myActiveSelectingVolume->SetWindowSize (theWidth, theHeight);
191 }
192
193 //=======================================================================
194 // function : SetCamera
195 // purpose  : Updates viewport in all selecting volumes
196 //=======================================================================
197 void SelectMgr_SelectingVolumeManager::SetViewport (const Standard_Real theX,
198                                                     const Standard_Real theY,
199                                                     const Standard_Real theWidth,
200                                                     const Standard_Real theHeight)
201 {
202   Standard_ASSERT_RAISE(!myActiveSelectingVolume.IsNull(),
203     "SelectMgr_SelectingVolumeManager::SetViewport() should be called after initialization of selection volume ");
204   myActiveSelectingVolume->SetViewport (theX, theY, theWidth, theHeight);
205 }
206
207 //=======================================================================
208 // function : SetPixelTolerance
209 // purpose  : Updates pixel tolerance in all selecting volumes
210 //=======================================================================
211 void SelectMgr_SelectingVolumeManager::SetPixelTolerance (const Standard_Integer theTolerance)
212 {
213   Standard_ASSERT_RAISE(!myActiveSelectingVolume.IsNull(),
214     "SelectMgr_SelectingVolumeManager::SetPixelTolerance() should be called after initialization of selection volume ");
215   myActiveSelectingVolume->SetPixelTolerance (theTolerance);
216 }
217
218 //=======================================================================
219 // function : InitPointSelectingVolume
220 // purpose  :
221 //=======================================================================
222 void SelectMgr_SelectingVolumeManager::InitPointSelectingVolume (const gp_Pnt2d& thePoint)
223 {
224   Handle(SelectMgr_RectangularFrustum) aPntVolume = Handle(SelectMgr_RectangularFrustum)::DownCast(myActiveSelectingVolume);
225   if (aPntVolume.IsNull())
226   {
227     aPntVolume = new SelectMgr_RectangularFrustum();
228   }
229   aPntVolume->Init (thePoint);
230   myActiveSelectingVolume = aPntVolume;
231 }
232
233 //=======================================================================
234 // function : InitBoxSelectingVolume
235 // purpose  :
236 //=======================================================================
237 void SelectMgr_SelectingVolumeManager::InitBoxSelectingVolume (const gp_Pnt2d& theMinPt,
238                                                                const gp_Pnt2d& theMaxPt)
239 {
240   Handle(SelectMgr_RectangularFrustum) aBoxVolume = Handle(SelectMgr_RectangularFrustum)::DownCast(myActiveSelectingVolume);
241   if (aBoxVolume.IsNull())
242   {
243     aBoxVolume = new SelectMgr_RectangularFrustum();
244   }
245   aBoxVolume->Init (theMinPt, theMaxPt);
246   myActiveSelectingVolume = aBoxVolume;
247 }
248
249 //=======================================================================
250 // function : InitPolylineSelectingVolume
251 // purpose  :
252 //=======================================================================
253 void SelectMgr_SelectingVolumeManager::InitPolylineSelectingVolume (const TColgp_Array1OfPnt2d& thePoints)
254 {
255   Handle(SelectMgr_TriangularFrustumSet) aPolylineVolume = Handle(SelectMgr_TriangularFrustumSet)::DownCast(myActiveSelectingVolume);
256   if (aPolylineVolume.IsNull())
257   {
258     aPolylineVolume = new SelectMgr_TriangularFrustumSet();
259   }
260   aPolylineVolume->Init (thePoints);
261   myActiveSelectingVolume = aPolylineVolume;
262   aPolylineVolume->SetAllowOverlapDetection (IsOverlapAllowed());
263 }
264
265 //=======================================================================
266 // function : InitAxisSelectingVolume
267 // purpose  :
268 //=======================================================================
269 void SelectMgr_SelectingVolumeManager::InitAxisSelectingVolume (const gp_Ax1& theAxis)
270 {
271   Handle(SelectMgr_AxisIntersector) anAxisVolume = Handle(SelectMgr_AxisIntersector)::DownCast(myActiveSelectingVolume);
272   if (anAxisVolume.IsNull())
273   {
274     anAxisVolume = new SelectMgr_AxisIntersector();
275   }
276   anAxisVolume->Init (theAxis);
277   myActiveSelectingVolume = anAxisVolume;
278 }
279
280 //=======================================================================
281 // function : InitSelectingVolume
282 // purpose  :
283 //=======================================================================
284 void SelectMgr_SelectingVolumeManager::InitSelectingVolume(const Handle(SelectMgr_BaseIntersector)& theVolume)
285 {
286   myActiveSelectingVolume = theVolume;
287 }
288
289 //=======================================================================
290 // function : BuildSelectingVolume
291 // purpose  :
292 //=======================================================================
293 void SelectMgr_SelectingVolumeManager::BuildSelectingVolume()
294 {
295   Standard_ASSERT_RAISE (!myActiveSelectingVolume.IsNull(),
296     "SelectMgr_SelectingVolumeManager::BuildSelectingVolume() should be called after initialization of active selection volume.");
297   myActiveSelectingVolume->Build();
298 }
299
300 //=======================================================================
301 // function : BuildSelectingVolume
302 // purpose  :
303 //=======================================================================
304 void SelectMgr_SelectingVolumeManager::BuildSelectingVolume (const gp_Pnt2d& thePoint)
305 {
306   InitPointSelectingVolume (thePoint);
307   myActiveSelectingVolume->Build();
308 }
309
310 //=======================================================================
311 // function : BuildSelectingVolume
312 // purpose  :
313 //=======================================================================
314 void SelectMgr_SelectingVolumeManager::BuildSelectingVolume (const gp_Pnt2d& theMinPt,
315                                                              const gp_Pnt2d& theMaxPt)
316 {
317   InitBoxSelectingVolume (theMinPt, theMaxPt);
318   myActiveSelectingVolume->Build();
319 }
320
321 //=======================================================================
322 // function : BuildSelectingVolume
323 // purpose  :
324 //=======================================================================
325 void SelectMgr_SelectingVolumeManager::BuildSelectingVolume (const TColgp_Array1OfPnt2d& thePoints)
326 {
327   InitPolylineSelectingVolume (thePoints);
328   myActiveSelectingVolume->Build();
329 }
330
331 //=======================================================================
332 // function : OverlapsBox
333 // purpose  : SAT intersection test between defined volume and
334 //            given axis-aligned box
335 //=======================================================================
336 Standard_Boolean SelectMgr_SelectingVolumeManager::OverlapsBox (const SelectMgr_Vec3& theBoxMin,
337                                                                 const SelectMgr_Vec3& theBoxMax,
338                                                                 SelectBasics_PickResult& thePickResult) const
339 {
340   if (myActiveSelectingVolume.IsNull())
341   {
342     return Standard_False;
343   }
344
345   return myActiveSelectingVolume->OverlapsBox (theBoxMin, theBoxMax, myViewClipRange, thePickResult);
346 }
347
348 //=======================================================================
349 // function : OverlapsBox
350 // purpose  : Intersection test between defined volume and given point
351 //=======================================================================
352 Standard_Boolean SelectMgr_SelectingVolumeManager::OverlapsBox (const SelectMgr_Vec3& theBoxMin,
353                                                                 const SelectMgr_Vec3& theBoxMax,
354                                                                 Standard_Boolean*     theInside) const
355 {
356   if (myActiveSelectingVolume.IsNull())
357   {
358     return Standard_False;
359   }
360
361   return myActiveSelectingVolume->OverlapsBox (theBoxMin, theBoxMax, theInside);
362 }
363
364 //=======================================================================
365 // function : OverlapsPoint
366 // purpose  : Intersection test between defined volume and given point
367 //=======================================================================
368 Standard_Boolean SelectMgr_SelectingVolumeManager::OverlapsPoint (const gp_Pnt& thePnt,
369                                                                   SelectBasics_PickResult& thePickResult) const
370 {
371   if (myActiveSelectingVolume.IsNull())
372   {
373     return Standard_False;
374   }
375
376   return myActiveSelectingVolume->OverlapsPoint (thePnt, myViewClipRange, thePickResult);
377 }
378
379 //=======================================================================
380 // function : OverlapsPoint
381 // purpose  : Intersection test between defined volume and given point
382 //=======================================================================
383 Standard_Boolean SelectMgr_SelectingVolumeManager::OverlapsPoint (const gp_Pnt& thePnt) const
384 {
385   if (myActiveSelectingVolume.IsNull())
386   {
387     return Standard_False;
388   }
389
390   return myActiveSelectingVolume->OverlapsPoint (thePnt);
391 }
392
393 //=======================================================================
394 // function : OverlapsPolygon
395 // purpose  : SAT intersection test between defined volume and given
396 //            ordered set of points, representing line segments. The test
397 //            may be considered of interior part or boundary line defined
398 //            by segments depending on given sensitivity type
399 //=======================================================================
400 Standard_Boolean SelectMgr_SelectingVolumeManager::OverlapsPolygon (const Handle(TColgp_HArray1OfPnt)& theArrayOfPnts,
401                                                                     Standard_Integer theSensType,
402                                                                     SelectBasics_PickResult& thePickResult) const
403 {
404   if (myActiveSelectingVolume.IsNull())
405   {
406     return Standard_False;
407   }
408
409   return myActiveSelectingVolume->OverlapsPolygon (theArrayOfPnts->Array1(), (Select3D_TypeOfSensitivity)theSensType,
410                                                    myViewClipRange, thePickResult);
411 }
412
413 //=======================================================================
414 // function : OverlapsPolygon
415 // purpose  : SAT intersection test between defined volume and given
416 //            ordered set of points, representing line segments. The test
417 //            may be considered of interior part or boundary line defined
418 //            by segments depending on given sensitivity type
419 //=======================================================================
420 Standard_Boolean SelectMgr_SelectingVolumeManager::OverlapsPolygon (const TColgp_Array1OfPnt& theArrayOfPnts,
421                                                                     Standard_Integer theSensType,
422                                                                     SelectBasics_PickResult& thePickResult) const
423 {
424   if (myActiveSelectingVolume.IsNull())
425   {
426     return Standard_False;
427   }
428
429   return myActiveSelectingVolume->OverlapsPolygon (theArrayOfPnts, (Select3D_TypeOfSensitivity)theSensType,
430                                                    myViewClipRange, thePickResult);
431 }
432
433 //=======================================================================
434 // function : OverlapsSegment
435 // purpose  : Checks if line segment overlaps selecting volume
436 //=======================================================================
437 Standard_Boolean SelectMgr_SelectingVolumeManager::OverlapsSegment (const gp_Pnt& thePt1,
438                                                                     const gp_Pnt& thePt2,
439                                                                     SelectBasics_PickResult& thePickResult) const
440 {
441   if (myActiveSelectingVolume.IsNull())
442   {
443     return Standard_False;
444   }
445
446   return myActiveSelectingVolume->OverlapsSegment (thePt1, thePt2, myViewClipRange, thePickResult);
447 }
448
449 //=======================================================================
450 // function : OverlapsTriangle
451 // purpose  : SAT intersection test between defined volume and given
452 //            triangle. The test may be considered of interior part or
453 //            boundary line defined by triangle vertices depending on
454 //            given sensitivity type
455 //=======================================================================
456 Standard_Boolean SelectMgr_SelectingVolumeManager::OverlapsTriangle (const gp_Pnt& thePt1,
457                                                                      const gp_Pnt& thePt2,
458                                                                      const gp_Pnt& thePt3,
459                                                                      Standard_Integer theSensType,
460                                                                      SelectBasics_PickResult& thePickResult) const
461 {
462   if (myActiveSelectingVolume.IsNull())
463   {
464     return Standard_False;
465   }
466
467   return myActiveSelectingVolume->OverlapsTriangle (thePt1, thePt2, thePt3, (Select3D_TypeOfSensitivity)theSensType,
468                                                     myViewClipRange, thePickResult);
469 }
470
471 //=======================================================================
472 // function : DistToGeometryCenter
473 // purpose  : Measures distance between 3d projection of user-picked
474 //            screen point and given point theCOG
475 //=======================================================================
476 Standard_Real SelectMgr_SelectingVolumeManager::DistToGeometryCenter (const gp_Pnt& theCOG) const
477 {
478   if (myActiveSelectingVolume.IsNull())
479   {
480     return RealLast();
481   }
482   return myActiveSelectingVolume->DistToGeometryCenter (theCOG);
483 }
484
485 // =======================================================================
486 // function : DetectedPoint
487 // purpose  : Calculates the point on a view ray that was detected during
488 //            the run of selection algo by given depth. Is valid for point
489 //            selection only
490 // =======================================================================
491 gp_Pnt SelectMgr_SelectingVolumeManager::DetectedPoint (const Standard_Real theDepth) const
492 {
493   Standard_ASSERT_RAISE(!myActiveSelectingVolume.IsNull(),
494     "SelectMgr_SelectingVolumeManager::DetectedPoint() should be called after initialization of selection volume");
495   return myActiveSelectingVolume->DetectedPoint (theDepth);
496 }
497
498 //=======================================================================
499 // function : AllowOverlapDetection
500 // purpose  : If theIsToAllow is false, only fully included sensitives will
501 //            be detected, otherwise the algorithm will mark both included
502 //            and overlapped entities as matched
503 //=======================================================================
504 void SelectMgr_SelectingVolumeManager::AllowOverlapDetection (const Standard_Boolean theIsToAllow)
505 {
506   myToAllowOverlap = theIsToAllow;
507 }
508
509 //=======================================================================
510 // function : IsOverlapAllowed
511 // purpose  :
512 //=======================================================================
513 Standard_Boolean SelectMgr_SelectingVolumeManager::IsOverlapAllowed() const
514 {
515   return myToAllowOverlap || GetActiveSelectionType() == SelectMgr_SelectionType_Point;
516 }
517
518 //=======================================================================
519 // function : GetVertices
520 // purpose  :
521 //=======================================================================
522 const gp_Pnt* SelectMgr_SelectingVolumeManager::GetVertices() const
523 {
524   if (myActiveSelectingVolume.IsNull())
525   {
526     return NULL;
527   }
528   const SelectMgr_RectangularFrustum* aRectFrustum =
529     static_cast<const SelectMgr_RectangularFrustum*> (myActiveSelectingVolume.get());
530   if (aRectFrustum == NULL)
531   {
532     return NULL;
533   }
534   return aRectFrustum->GetVertices();
535 }
536
537 //=======================================================================
538 // function : GetNearPickedPnt
539 // purpose  :
540 //=======================================================================
541 gp_Pnt SelectMgr_SelectingVolumeManager::GetNearPickedPnt() const
542 {
543   if (myActiveSelectingVolume.IsNull())
544   {
545     return gp_Pnt();
546   }
547   return myActiveSelectingVolume->GetNearPnt();
548 }
549
550 //=======================================================================
551 // function : GetFarPickedPnt
552 // purpose  :
553 //=======================================================================
554 gp_Pnt SelectMgr_SelectingVolumeManager::GetFarPickedPnt() const
555 {
556   if (myActiveSelectingVolume.IsNull())
557   {
558     return gp_Pnt(RealLast(), RealLast(), RealLast());
559   }
560   return myActiveSelectingVolume->GetFarPnt();
561 }
562
563 //=======================================================================
564 // function : GetViewRayDirection
565 // purpose  :
566 //=======================================================================
567 gp_Dir SelectMgr_SelectingVolumeManager::GetViewRayDirection() const
568 {
569   if (myActiveSelectingVolume.IsNull())
570   {
571     return gp_Dir();
572   }
573   return myActiveSelectingVolume->GetViewRayDirection();
574 }
575
576 //=======================================================================
577 // function : IsScalableActiveVolume
578 // purpose  :
579 //=======================================================================
580 Standard_Boolean SelectMgr_SelectingVolumeManager::IsScalableActiveVolume() const
581 {
582   if (myActiveSelectingVolume.IsNull())
583   {
584     return Standard_False;
585   }
586   return myActiveSelectingVolume->IsScalable();
587 }
588
589 //=======================================================================
590 // function : GetMousePosition
591 // purpose  :
592 //=======================================================================
593 gp_Pnt2d SelectMgr_SelectingVolumeManager::GetMousePosition() const
594 {
595   if (myActiveSelectingVolume.IsNull())
596   {
597     return gp_Pnt2d(RealLast(), RealLast());
598   }
599   return myActiveSelectingVolume->GetMousePosition();
600 }
601
602 //=======================================================================
603 // function : GetPlanes
604 // purpose  :
605 //=======================================================================
606 void SelectMgr_SelectingVolumeManager::GetPlanes (NCollection_Vector<SelectMgr_Vec4>& thePlaneEquations) const
607 {
608   if (myActiveSelectingVolume.IsNull())
609   {
610     thePlaneEquations.Clear();
611     return;
612   }
613   return myActiveSelectingVolume->GetPlanes (thePlaneEquations);
614 }
615
616 //=======================================================================
617 // function : SetViewClipping
618 // purpose  :
619 //=======================================================================
620 void SelectMgr_SelectingVolumeManager::SetViewClipping (const Handle(Graphic3d_SequenceOfHClipPlane)& theViewPlanes,
621                                                         const Handle(Graphic3d_SequenceOfHClipPlane)& theObjPlanes,
622                                                         const SelectMgr_SelectingVolumeManager* theWorldSelMgr)
623 {
624   myViewClipPlanes   = theViewPlanes;
625   myObjectClipPlanes = theObjPlanes;
626   if (GetActiveSelectionType() != SelectMgr_SelectionType_Point)
627   {
628     return;
629   }
630
631   const SelectMgr_SelectingVolumeManager* aWorldSelMgr = theWorldSelMgr != NULL ? theWorldSelMgr : this;
632   myViewClipRange.SetVoid();
633   if (!theViewPlanes.IsNull()
634    && !theViewPlanes->IsEmpty())
635   {
636     myViewClipRange.AddClippingPlanes (*theViewPlanes,
637       gp_Ax1(aWorldSelMgr->myActiveSelectingVolume->GetNearPnt(),
638              aWorldSelMgr->myActiveSelectingVolume->GetViewRayDirection()));
639   }
640   if (!theObjPlanes.IsNull()
641    && !theObjPlanes->IsEmpty())
642   {
643     myViewClipRange.AddClippingPlanes (*theObjPlanes,
644       gp_Ax1(aWorldSelMgr->myActiveSelectingVolume->GetNearPnt(),
645              aWorldSelMgr->myActiveSelectingVolume->GetViewRayDirection()));
646   }
647 }
648
649 //=======================================================================
650 // function : SetViewClipping
651 // purpose  :
652 //=======================================================================
653 void SelectMgr_SelectingVolumeManager::SetViewClipping (const SelectMgr_SelectingVolumeManager& theOther)
654 {
655   myViewClipPlanes   = theOther.myViewClipPlanes;
656   myObjectClipPlanes = theOther.myObjectClipPlanes;
657   myViewClipRange    = theOther.myViewClipRange;
658 }
659
660 //=======================================================================
661 //function : DumpJson
662 //purpose  : 
663 //=======================================================================
664 void SelectMgr_SelectingVolumeManager::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const 
665 {
666   OCCT_DUMP_CLASS_BEGIN (theOStream, SelectMgr_SelectingVolumeManager)
667
668   OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myActiveSelectingVolume.get())
669   OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myViewClipPlanes.get())
670   OCCT_DUMP_FIELD_VALUE_POINTER (theOStream, myObjectClipPlanes.get())
671
672   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myViewClipRange)
673   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myToAllowOverlap)
674 }