0031313: Foundation Classes - Dump improvement for classes
[occt.git] / src / Select3D / Select3D_SensitivePrimitiveArray.cxx
1 // Created on: 2016-02-20
2 // Created by: Kirill Gavrilov
3 // Copyright (c) 2016 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 <Select3D_SensitivePrimitiveArray.hxx>
17
18 #include <NCollection_AlignedAllocator.hxx>
19 #include <OSD_Parallel.hxx>
20 #include <Standard_Atomic.hxx>
21
22 IMPLEMENT_STANDARD_RTTIEXT(Select3D_SensitivePrimitiveArray, Select3D_SensitiveSet)
23
24 namespace
25 {
26
27   //! Auxiliary converter.
28   static inline gp_Pnt vecToPnt (const Graphic3d_Vec3& theVec)
29   {
30     return gp_Pnt (theVec.x(), theVec.y(), theVec.z());
31   }
32
33   //! Auxiliary converter.
34   static inline gp_Pnt vecToPnt (const Graphic3d_Vec2& theVec)
35   {
36     return gp_Pnt (theVec.x(), theVec.y(), 0.0);
37   }
38
39
40   //! Auxiliary function to find shared node between two triangles.
41   static inline bool hasSharedNode (const Standard_Integer* theTri1,
42                                     const Standard_Integer* theTri2)
43   {
44     return theTri1[0] == theTri2[0]
45         || theTri1[1] == theTri2[0]
46         || theTri1[2] == theTri2[0]
47         || theTri1[0] == theTri2[1]
48         || theTri1[1] == theTri2[1]
49         || theTri1[2] == theTri2[1]
50         || theTri1[0] == theTri2[2]
51         || theTri1[1] == theTri2[2]
52         || theTri1[2] == theTri2[2];
53   }
54
55   //! Fill in the triangle nodes indices.
56   static inline void getTriIndices (const Handle(Graphic3d_IndexBuffer)& theIndices,
57                                     const Standard_Integer theIndexOffset,
58                                     Standard_Integer* theNodes)
59   {
60     if (!theIndices.IsNull())
61     {
62       theNodes[0] = theIndices->Index (theIndexOffset + 0);
63       theNodes[1] = theIndices->Index (theIndexOffset + 1);
64       theNodes[2] = theIndices->Index (theIndexOffset + 2);
65     }
66     else
67     {
68       theNodes[0] = theIndexOffset + 0;
69       theNodes[1] = theIndexOffset + 1;
70       theNodes[2] = theIndexOffset + 2;
71     }
72   }
73
74 }
75
76 //! Functor for initializing groups in parallel threads.
77 struct Select3D_SensitivePrimitiveArray::Select3D_SensitivePrimitiveArray_InitFunctor
78 {
79   Select3D_SensitivePrimitiveArray_InitFunctor (Select3D_SensitivePrimitiveArray& thePrimArray,
80                                                 Standard_Integer theDivStep,
81                                                 Standard_Boolean theToEvalMinMax)
82   : myPrimArray (thePrimArray),
83     myDivStep (theDivStep),
84     myToEvalMinMax (theToEvalMinMax),
85     myToComputeBvh (Standard_True),
86     myNbFailures (0) {}
87   void operator()(const Standard_Integer& theIndex) const
88   {
89     Handle(Select3D_SensitivePrimitiveArray)& anEntity = myPrimArray.myGroups->ChangeValue (theIndex);
90     const Standard_Integer aLower  = myPrimArray.myIndexLower + theIndex * myDivStep;
91     const Standard_Integer anUpper = Min (aLower + myDivStep - 1, myPrimArray.myIndexUpper);
92     anEntity = new Select3D_SensitivePrimitiveArray (myPrimArray.myOwnerId);
93     anEntity->SetPatchSizeMax     (myPrimArray.myPatchSizeMax);
94     anEntity->SetPatchDistance    (myPrimArray.myPatchDistance);
95     anEntity->SetDetectElements   (myPrimArray.myToDetectElem);
96     anEntity->SetDetectElementMap (myPrimArray.ToDetectElementMap());
97     anEntity->SetDetectNodes      (myPrimArray.myToDetectNode);
98     anEntity->SetDetectNodeMap    (myPrimArray.ToDetectNodeMap());
99     anEntity->SetSensitivityFactor(myPrimArray.SensitivityFactor());
100     switch (myPrimArray.myPrimType)
101     {
102       case Graphic3d_TOPA_POINTS:
103       {
104         if (!anEntity->InitPoints (myPrimArray.myVerts, myPrimArray.myIndices, myPrimArray.myInitLocation, aLower, anUpper, myToEvalMinMax, 1))
105         {
106           Standard_Atomic_Increment (&myNbFailures);
107           return;
108         }
109         break;
110       }
111       case Graphic3d_TOPA_TRIANGLES:
112       {
113         if (!anEntity->InitTriangulation (myPrimArray.myVerts, myPrimArray.myIndices, myPrimArray.myInitLocation, aLower, anUpper, myToEvalMinMax, 1))
114         {
115           Standard_Atomic_Increment (&myNbFailures);
116           return;
117         }
118         break;
119       }
120       default:
121       {
122         Standard_Atomic_Increment (&myNbFailures);
123         return;
124       }
125     }
126
127     if (myToComputeBvh)
128     {
129       anEntity->BVH();
130     }
131   }
132   Standard_Boolean IsDone() const { return myNbFailures == 0; }
133 private:
134   Select3D_SensitivePrimitiveArray_InitFunctor operator= (Select3D_SensitivePrimitiveArray_InitFunctor& );
135 private:
136   Select3D_SensitivePrimitiveArray& myPrimArray;
137   Standard_Integer                  myDivStep;
138   Standard_Boolean                  myToEvalMinMax;
139   Standard_Boolean                  myToComputeBvh;
140   mutable volatile Standard_Integer myNbFailures;
141 };
142
143 //! Functor for computing BVH in parallel threads.
144 struct Select3D_SensitivePrimitiveArray::Select3D_SensitivePrimitiveArray_BVHFunctor
145 {
146   Select3D_SensitivePrimitiveArray_BVHFunctor (NCollection_Array1<Handle(Select3D_SensitivePrimitiveArray)>& theGroups) : myGroups (theGroups) {}
147   void operator()(const Standard_Integer& theIndex) const { myGroups.ChangeValue (theIndex)->BVH(); }
148 private:
149   Select3D_SensitivePrimitiveArray_BVHFunctor operator= (Select3D_SensitivePrimitiveArray_BVHFunctor& );
150 private:
151   NCollection_Array1<Handle(Select3D_SensitivePrimitiveArray)>& myGroups;
152 };
153
154 // =======================================================================
155 // function : Select3D_SensitivePrimitiveArray
156 // purpose  :
157 // =======================================================================
158 Select3D_SensitivePrimitiveArray::Select3D_SensitivePrimitiveArray (const Handle(SelectMgr_EntityOwner)& theOwnerId)
159 : Select3D_SensitiveSet (theOwnerId),
160   myPosData (NULL),
161   myPosStride (Standard_Size(-1)),
162   myPrimType (Graphic3d_TOPA_UNDEFINED),
163   myIndexLower (0),
164   myIndexUpper (0),
165   myPatchSizeMax (1),
166   myPatchDistance (ShortRealLast()),
167   myIs3d (false),
168   myBvhIndices (new NCollection_AlignedAllocator(16)),
169   myMinDepthElem (RealLast()),
170   myMinDepthNode (RealLast()),
171   myMinDepthEdge (RealLast()),
172   myDetectedElem (-1),
173   myDetectedNode (-1),
174   myDetectedEdgeNode1 (-1),
175   myDetectedEdgeNode2 (-1),
176   myToDetectElem (true),
177   myToDetectNode (false),
178   myToDetectEdge (false)
179 {
180   //
181 }
182
183 // =======================================================================
184 // function : SetDetectElementMap
185 // purpose  :
186 // =======================================================================
187 void Select3D_SensitivePrimitiveArray::SetDetectElementMap (bool theToDetect)
188 {
189   if (!theToDetect)
190   {
191     myDetectedElemMap.Nullify();
192     return;
193   }
194
195   if (myDetectedElemMap.IsNull())
196   {
197     myDetectedElemMap = new TColStd_HPackedMapOfInteger();
198   }
199   else
200   {
201     myDetectedElemMap->ChangeMap().Clear();
202   }
203 }
204
205 // =======================================================================
206 // function : SetDetectNodeMap
207 // purpose  :
208 // =======================================================================
209 void Select3D_SensitivePrimitiveArray::SetDetectNodeMap (bool theToDetect)
210 {
211   if (!theToDetect)
212   {
213     myDetectedNodeMap.Nullify();
214     return;
215   }
216
217   if (myDetectedNodeMap.IsNull())
218   {
219     myDetectedNodeMap = new TColStd_HPackedMapOfInteger();
220   }
221   else
222   {
223     myDetectedNodeMap->ChangeMap().Clear();
224   }
225 }
226
227 // =======================================================================
228 // function : InitTriangulation
229 // purpose  :
230 // =======================================================================
231 bool Select3D_SensitivePrimitiveArray::InitTriangulation (const Handle(Graphic3d_Buffer)&      theVerts,
232                                                           const Handle(Graphic3d_IndexBuffer)& theIndices,
233                                                           const TopLoc_Location&               theInitLoc,
234                                                           const Standard_Integer               theIndexLower,
235                                                           const Standard_Integer               theIndexUpper,
236                                                           const bool                           theToEvalMinMax,
237                                                           const Standard_Integer               theNbGroups)
238 {
239   MarkDirty();
240   myGroups.Nullify();
241   myPrimType = Graphic3d_TOPA_TRIANGLES;
242   myBndBox.Clear();
243   myVerts.Nullify();
244   myIndices.Nullify();
245   myIndexLower = 0;
246   myIndexUpper = 0;
247   myPosData = NULL;
248   myPosStride = Standard_Size(-1);
249   myBvhIndices.release();
250   myIs3d = false;
251   myInitLocation = theInitLoc;
252   myCDG3D.SetCoord (0.0, 0.0, 0.0);
253   if (theVerts.IsNull()
254    || theVerts->NbElements == 0)
255   {
256     return false;
257   }
258
259   Standard_Integer aPosAttribIndex = 0;
260   myPosData = theVerts->AttributeData (Graphic3d_TOA_POS, aPosAttribIndex, myPosStride);
261   if (myPosData == NULL)
262   {
263     return false;
264   }
265
266   const Graphic3d_Attribute& anAttrib = theVerts->Attribute (aPosAttribIndex);
267   myIs3d = anAttrib.DataType == Graphic3d_TOD_VEC3
268         || anAttrib.DataType == Graphic3d_TOD_VEC4;
269   if (!myIs3d && anAttrib.DataType != Graphic3d_TOD_VEC2)
270   {
271     myPosData = NULL;
272     return false;
273   }
274
275   if (!theIndices.IsNull())
276   {
277     if (theIndexLower < 0
278      || theIndexUpper >= theIndices->NbElements
279      || theIndices->NbElements == 0)
280     {
281       return false;
282     }
283   }
284   else
285   {
286     if (theIndexLower < 0
287      || theIndexUpper >= theVerts->NbElements)
288     {
289       return false;
290     }
291   }
292
293   Standard_Integer aTriFrom = theIndexLower / 3;
294   Standard_Integer aNbTris  = (theIndexUpper - theIndexLower + 1) / 3;
295   const bool hasGroups = (theNbGroups > 1) && (aNbTris / theNbGroups > 10);
296   if (aNbTris < 1)
297   {
298     return false;
299   }
300   if (!myBvhIndices.Init (hasGroups ? theNbGroups : aNbTris, !hasGroups && myPatchSizeMax > 1))
301   {
302     return false;
303   }
304
305   myVerts      = theVerts;
306   myIndices    = theIndices;
307   myIndexLower = theIndexLower;
308   myIndexUpper = theIndexUpper;
309   myInvInitLocation = myInitLocation.Transformation().Inverted();
310   if (hasGroups)
311   {
312     myGroups = new Select3D_PrimArraySubGroupArray (0, theNbGroups - 1);
313     const Standard_Integer aDivStep = (aNbTris / theNbGroups) * 3;
314     Select3D_SensitivePrimitiveArray_InitFunctor anInitFunctor (*this, aDivStep, theToEvalMinMax);
315     OSD_Parallel::For (myGroups->Lower(), myGroups->Upper() + 1, anInitFunctor);
316     if (!anInitFunctor.IsDone())
317     {
318       return false;
319     }
320     for (Standard_Integer aGroupIter = 0; aGroupIter < theNbGroups; ++aGroupIter)
321     {
322       Handle(Select3D_SensitivePrimitiveArray)& anEntity = myGroups->ChangeValue (aGroupIter);
323       myBndBox.Combine (anEntity->BoundingBox());
324       myBvhIndices.SetIndex (aGroupIter, aGroupIter);
325       myCDG3D.ChangeCoord() += anEntity->CenterOfGeometry().XYZ();
326     }
327     myCDG3D.ChangeCoord().Divide (static_cast<Standard_Real> (myGroups->Size()));
328     if (theToEvalMinMax)
329     {
330       computeBoundingBox();
331     }
332     return true;
333   }
334
335   Graphic3d_Vec3 aCenter (0.0f, 0.0f, 0.0f);
336   Standard_Integer  aTriNodes1[3] = { -1, -1, -1 };
337   Standard_Integer  aTriNodes2[3] = { -1, -1, -1 };
338   Standard_Integer* aTriNodesPrev = aTriNodes1;
339   Standard_Integer* aTriNodes     = aTriNodes2;
340   Standard_Integer  aPatchFrom    = 0;
341   Standard_Integer  aPatchSize    = 0;
342   if (myBvhIndices.HasPatches())
343   {
344     myBvhIndices.NbElements = 0;
345   }
346   for (Standard_Integer aTriIter = 0; aTriIter < aNbTris; ++aTriIter)
347   {
348     const Standard_Integer anIndexOffset = (aTriFrom + aTriIter) * 3;
349     getTriIndices (myIndices, anIndexOffset, aTriNodes);
350     if (myIs3d)
351     {
352       const Graphic3d_Vec3& aNode1 = getPosVec3 (aTriNodes[0]);
353       const Graphic3d_Vec3& aNode2 = getPosVec3 (aTriNodes[1]);
354       const Graphic3d_Vec3& aNode3 = getPosVec3 (aTriNodes[2]);
355       aCenter += (aNode1 + aNode2 + aNode3) / 3.0;
356     }
357     else
358     {
359       const Graphic3d_Vec2& aNode1 = getPosVec2 (aTriNodes[0]);
360       const Graphic3d_Vec2& aNode2 = getPosVec2 (aTriNodes[1]);
361       const Graphic3d_Vec2& aNode3 = getPosVec2 (aTriNodes[2]);
362       aCenter += Graphic3d_Vec3((aNode1 + aNode2 + aNode3) / 3.0);
363     }
364     if (myBvhIndices.HasPatches())
365     {
366       std::swap (aTriNodes, aTriNodesPrev);
367       if (aPatchSize < myPatchSizeMax
368        && hasSharedNode (aTriNodes, aTriNodesPrev))
369       {
370         ++aPatchSize;
371         continue;
372       }
373       else
374       {
375         myBvhIndices.SetIndex (myBvhIndices.NbElements++, aTriFrom + aPatchFrom, aPatchSize);
376         aPatchFrom = aTriIter;
377         aPatchSize = 0;
378       }
379     }
380     else
381     {
382       myBvhIndices.SetIndex (aTriIter, aTriFrom + aTriIter);
383     }
384   }
385   if (aPatchSize != 0)
386   {
387     myBvhIndices.SetIndex (myBvhIndices.NbElements++, aTriFrom + aPatchFrom, aPatchSize);
388   }
389   aCenter /= float(aNbTris);
390
391   myCDG3D = vecToPnt (aCenter);
392   if (theToEvalMinMax)
393   {
394     computeBoundingBox();
395   }
396   return true;
397 }
398
399 // =======================================================================
400 // function : InitPoints
401 // purpose  :
402 // =======================================================================
403 bool Select3D_SensitivePrimitiveArray::InitPoints (const Handle(Graphic3d_Buffer)&      theVerts,
404                                                    const Handle(Graphic3d_IndexBuffer)& theIndices,
405                                                    const TopLoc_Location&               theInitLoc,
406                                                    const Standard_Integer               theIndexLower,
407                                                    const Standard_Integer               theIndexUpper,
408                                                    const bool                           theToEvalMinMax,
409                                                    const Standard_Integer               theNbGroups)
410 {
411   MarkDirty();
412   myGroups.Nullify();
413   myPrimType = Graphic3d_TOPA_POINTS;
414   myBndBox.Clear();
415   myVerts.Nullify();
416   myIndices.Nullify();
417   myIndexLower = 0;
418   myIndexUpper = 0;
419   myPosData = NULL;
420   myPosStride = Standard_Size(-1);
421   myBvhIndices.release();
422   myIs3d = false;
423   myInitLocation = theInitLoc;
424   if (theVerts.IsNull()
425    || theVerts->NbElements == 0)
426   {
427     return false;
428   }
429
430   Standard_Integer aPosAttribIndex = 0;
431   myPosData = theVerts->AttributeData (Graphic3d_TOA_POS, aPosAttribIndex, myPosStride);
432   if (myPosData == NULL)
433   {
434     return false;
435   }
436
437   const Graphic3d_Attribute& anAttrib = theVerts->Attribute (aPosAttribIndex);
438   myIs3d = anAttrib.DataType == Graphic3d_TOD_VEC3
439         || anAttrib.DataType == Graphic3d_TOD_VEC4;
440   if (!myIs3d && anAttrib.DataType != Graphic3d_TOD_VEC2)
441   {
442     myPosData = NULL;
443     return false;
444   }
445
446   if (!theIndices.IsNull())
447   {
448     if (theIndexLower < 0
449      || theIndexUpper >= theIndices->NbElements
450      || theIndices->NbElements == 0)
451     {
452       return false;
453     }
454   }
455   else
456   {
457     if (theIndexLower < 0
458      || theIndexUpper >= theVerts->NbElements)
459     {
460       return false;
461     }
462   }
463
464   const Standard_Integer aNbPoints = theIndexUpper - theIndexLower + 1;
465   const bool hasGroups = (theNbGroups > 1) && (aNbPoints / theNbGroups > 10);
466   if (aNbPoints < 1)
467   {
468     return false;
469   }
470   if (!myBvhIndices.Init (hasGroups ? theNbGroups : aNbPoints, !hasGroups && myPatchSizeMax > 1))
471   {
472     return false;
473   }
474
475   myVerts      = theVerts;
476   myIndices    = theIndices;
477   myIndexLower = theIndexLower;
478   myIndexUpper = theIndexUpper;
479   myInvInitLocation = myInitLocation.Transformation().Inverted();
480   if (hasGroups)
481   {
482     myGroups = new Select3D_PrimArraySubGroupArray (0, theNbGroups - 1);
483     const Standard_Integer aDivStep = aNbPoints / theNbGroups;
484     Select3D_SensitivePrimitiveArray_InitFunctor anInitFunctor (*this, aDivStep, theToEvalMinMax);
485     OSD_Parallel::For (myGroups->Lower(), myGroups->Upper() + 1, anInitFunctor);
486     if (!anInitFunctor.IsDone())
487     {
488       return false;
489     }
490     for (Standard_Integer aGroupIter = 0; aGroupIter < theNbGroups; ++aGroupIter)
491     {
492       Handle(Select3D_SensitivePrimitiveArray)& anEntity = myGroups->ChangeValue (aGroupIter);
493       myBndBox.Combine (anEntity->BoundingBox());
494       myBvhIndices.SetIndex (aGroupIter, aGroupIter);
495       myCDG3D.ChangeCoord() += anEntity->CenterOfGeometry().XYZ();
496     }
497     myCDG3D.ChangeCoord().Divide (static_cast<Standard_Real> (myGroups->Size()));
498     if (theToEvalMinMax)
499     {
500       computeBoundingBox();
501     }
502     return true;
503   }
504
505   Graphic3d_Vec3 aCenter (0.0f, 0.0f, 0.0f);
506   Standard_Integer aPatchFrom = 0;
507   Standard_Integer aPatchSize = 0;
508   if (myBvhIndices.HasPatches())
509   {
510     myBvhIndices.NbElements = 0;
511   }
512   const float aPatchSize2 = myPatchDistance < ShortRealLast()
513                           ? myPatchDistance * myPatchDistance
514                           : myPatchDistance;
515   const Graphic3d_Vec3* aPnt3dPrev = NULL;
516   const Graphic3d_Vec3* aPnt3d     = NULL;
517   const Graphic3d_Vec2* aPnt2dPrev = NULL;
518   const Graphic3d_Vec2* aPnt2d     = NULL;
519   for (Standard_Integer aPointIter = 0; aPointIter < aNbPoints; ++aPointIter)
520   {
521     const Standard_Integer anIndexOffset = (theIndexLower + aPointIter);
522     const Standard_Integer aPointIndex   = !myIndices.IsNull()
523                                           ? myIndices->Index (anIndexOffset)
524                                           : anIndexOffset;
525     if (myIs3d)
526     {
527       aPnt3d = &getPosVec3 (aPointIndex);
528       aCenter += *aPnt3d;
529     }
530     else
531     {
532       aPnt2d = &getPosVec2 (aPointIndex);
533       aCenter += Graphic3d_Vec3(*aPnt2d);
534     }
535
536     if (myBvhIndices.HasPatches())
537     {
538       if (myIs3d)
539       {
540         std::swap (aPnt3d, aPnt3dPrev);
541         if (aPatchSize < myPatchSizeMax
542          && aPnt3d != NULL
543          && (*aPnt3dPrev - *aPnt3d).SquareModulus() < aPatchSize2)
544         {
545           ++aPatchSize;
546           continue;
547         }
548       }
549       else
550       {
551         std::swap (aPnt2d, aPnt2dPrev);
552         if (aPatchSize < myPatchSizeMax
553          && aPnt2d != NULL
554          && (*aPnt2dPrev - *aPnt2d).SquareModulus() < aPatchSize2)
555         {
556           ++aPatchSize;
557           continue;
558         }
559       }
560
561       myBvhIndices.SetIndex (myBvhIndices.NbElements++, theIndexLower + aPatchFrom,
562                               aPatchSize != 0 ? aPatchSize : 1);
563       aPatchFrom = aPointIter;
564       aPatchSize = 0;
565     }
566     else
567     {
568       myBvhIndices.SetIndex (aPointIter, theIndexLower + aPointIter);
569     }
570   }
571   if (aPatchSize != 0)
572   {
573     myBvhIndices.SetIndex (myBvhIndices.NbElements++, theIndexLower + aPatchFrom, aPatchSize);
574   }
575   aCenter /= float(aNbPoints);
576
577   myCDG3D = vecToPnt (aCenter);
578   if (theToEvalMinMax)
579   {
580     computeBoundingBox();
581   }
582   return true;
583 }
584
585 // =======================================================================
586 // function : GetConnected
587 // purpose  :
588 // =======================================================================
589 Handle(Select3D_SensitiveEntity) Select3D_SensitivePrimitiveArray::GetConnected()
590 {
591   Handle(Select3D_SensitivePrimitiveArray) aNewEntity = new Select3D_SensitivePrimitiveArray (myOwnerId);
592   switch (myPrimType)
593   {
594     case Graphic3d_TOPA_POINTS:
595     {
596       aNewEntity->InitPoints        (myVerts, myIndices, myInitLocation, myIndexLower, myIndexUpper, true, !myGroups.IsNull() ? myGroups->Size() : 1);
597       break;
598     }
599     case Graphic3d_TOPA_TRIANGLES:
600     {
601       aNewEntity->InitTriangulation (myVerts, myIndices, myInitLocation, myIndexLower, myIndexUpper, true, !myGroups.IsNull() ? myGroups->Size() : 1);
602       break;
603     }
604     default: break;
605   }
606   return aNewEntity;
607 }
608
609 //=======================================================================
610 //function : Set
611 //purpose  :
612 //=======================================================================
613 void Select3D_SensitivePrimitiveArray::Set (const Handle(SelectMgr_EntityOwner)& theOwnerId)
614 {
615   base_type::Set (theOwnerId);
616   if (!myGroups.IsNull())
617   {
618     for (Select3D_PrimArraySubGroupArray::Iterator aGroupIter (*myGroups); aGroupIter.More(); aGroupIter.Next())
619     {
620       aGroupIter.Value()->Set (theOwnerId);
621     }
622   }
623 }
624
625 // =======================================================================
626 // function : BVH
627 // purpose  :
628 // =======================================================================
629 void Select3D_SensitivePrimitiveArray::BVH()
630 {
631   if (!myContent.IsDirty())
632   {
633     return;
634   }
635
636   base_type::BVH();
637   if (myGroups.IsNull())
638   {
639     return;
640   }
641
642   Standard_Integer aNbToUpdate = 0;
643   for (Select3D_PrimArraySubGroupArray::Iterator aGroupIter (*myGroups); aGroupIter.More(); aGroupIter.Next())
644   {
645     if (aGroupIter.Value()->myContent.IsDirty())
646     {
647       ++aNbToUpdate;
648     }
649   }
650
651   if (aNbToUpdate > 0)
652   {
653     Select3D_SensitivePrimitiveArray_BVHFunctor aFunctor (*myGroups);
654     OSD_Parallel::For (myGroups->Lower(), myGroups->Upper() + 1, aFunctor, aNbToUpdate <= 1);
655   }
656 }
657
658 // =======================================================================
659 // function : Size
660 // purpose  :
661 // =======================================================================
662 Standard_Integer Select3D_SensitivePrimitiveArray::Size() const
663 {
664   return myBvhIndices.NbElements;
665 }
666
667 // =======================================================================
668 // function : Box
669 // purpose  :
670 // =======================================================================
671 Select3D_BndBox3d Select3D_SensitivePrimitiveArray::Box (const Standard_Integer theIdx) const
672 {
673   const Standard_Integer anElemIdx  = myBvhIndices.Index (theIdx);
674   const Standard_Integer aPatchSize = myBvhIndices.PatchSize (theIdx);
675   if (!myGroups.IsNull())
676   {
677     return myGroups->Value (anElemIdx)->BoundingBox();
678   }
679
680   Select3D_BndBox3d aBox;
681   switch (myPrimType)
682   {
683     case Graphic3d_TOPA_POINTS:
684     {
685       for (Standard_Integer anElemIter = 0; anElemIter < aPatchSize; ++anElemIter)
686       {
687         const Standard_Integer anIndexOffset = (anElemIdx + anElemIter);
688         const Standard_Integer aPointIndex   = !myIndices.IsNull()
689                                              ?  myIndices->Index (anIndexOffset)
690                                              :  anIndexOffset;
691         if (myIs3d)
692         {
693           const Graphic3d_Vec3& aPoint = getPosVec3 (aPointIndex);
694           aBox.Add (SelectMgr_Vec3 (aPoint.x(), aPoint.y(), aPoint.z()));
695         }
696         else
697         {
698           const Graphic3d_Vec2& aPoint = getPosVec2 (aPointIndex);
699           aBox.Add (SelectMgr_Vec3 (aPoint.x(), aPoint.y(), 0.0));
700         }
701       }
702       break;
703     }
704     case Graphic3d_TOPA_TRIANGLES:
705     {
706       Standard_Integer aTriNodes[3];
707       if (myIs3d)
708       {
709         for (Standard_Integer anElemIter = 0; anElemIter < aPatchSize; ++anElemIter)
710         {
711           const Standard_Integer anIndexOffset = (anElemIdx + anElemIter) * 3;
712           getTriIndices (myIndices, anIndexOffset, aTriNodes);
713           const Graphic3d_Vec3& aNode1 = getPosVec3 (aTriNodes[0]);
714           const Graphic3d_Vec3& aNode2 = getPosVec3 (aTriNodes[1]);
715           const Graphic3d_Vec3& aNode3 = getPosVec3 (aTriNodes[2]);
716           Graphic3d_Vec3 aMinPnt = (aNode1.cwiseMin (aNode2)).cwiseMin (aNode3);
717           Graphic3d_Vec3 aMaxPnt = (aNode1.cwiseMax (aNode2)).cwiseMax (aNode3);
718           aBox.Add (SelectMgr_Vec3 (aMinPnt.x(), aMinPnt.y(), aMinPnt.z()));
719           aBox.Add (SelectMgr_Vec3 (aMaxPnt.x(), aMaxPnt.y(), aMaxPnt.z()));
720         }
721       }
722       else
723       {
724         for (Standard_Integer anElemIter = 0; anElemIter < aPatchSize; ++anElemIter)
725         {
726           const Standard_Integer anIndexOffset = (anElemIdx + anElemIter) * 3;
727           getTriIndices (myIndices, anIndexOffset, aTriNodes);
728           const Graphic3d_Vec2& aNode1 = getPosVec2 (aTriNodes[0]);
729           const Graphic3d_Vec2& aNode2 = getPosVec2 (aTriNodes[1]);
730           const Graphic3d_Vec2& aNode3 = getPosVec2 (aTriNodes[2]);
731           Graphic3d_Vec2 aMinPnt = (aNode1.cwiseMin (aNode2)).cwiseMin (aNode3);
732           Graphic3d_Vec2 aMaxPnt = (aNode1.cwiseMax (aNode2)).cwiseMax (aNode3);
733           aBox.Add (SelectMgr_Vec3 (aMinPnt.x(), aMinPnt.y(), 0.0));
734           aBox.Add (SelectMgr_Vec3 (aMaxPnt.x(), aMaxPnt.y(), 0.0));
735         }
736       }
737       break;
738     }
739     default:
740     {
741       return aBox;
742     }
743   }
744   return aBox;
745 }
746
747 // =======================================================================
748 // function : Center
749 // purpose  :
750 // =======================================================================
751 Standard_Real Select3D_SensitivePrimitiveArray::Center (const Standard_Integer theIdx,
752                                                         const Standard_Integer theAxis) const
753 {
754   if (!myGroups.IsNull())
755   {
756     const Standard_Integer anElemIdx = myBvhIndices.Index (theIdx);
757     const gp_Pnt aCenter = myGroups->Value (anElemIdx)->CenterOfGeometry();
758     return theAxis == 0 ? aCenter.X() : (theAxis == 1 ? aCenter.Y() : aCenter.Z());
759   }
760
761   const Select3D_BndBox3d& aBox = Box (theIdx);
762   SelectMgr_Vec3 aCenter = (aBox.CornerMin() + aBox.CornerMax()) * 0.5;
763   return theAxis == 0 ? aCenter.x() : (theAxis == 1 ? aCenter.y() : aCenter.z());
764 }
765
766 // =======================================================================
767 // function : Swap
768 // purpose  :
769 // =======================================================================
770 void Select3D_SensitivePrimitiveArray::Swap (const Standard_Integer theIdx1,
771                                              const Standard_Integer theIdx2)
772 {
773   Standard_Integer anElemIdx1 = myBvhIndices.Index (theIdx1);
774   Standard_Integer anElemIdx2 = myBvhIndices.Index (theIdx2);
775   if (myBvhIndices.HasPatches())
776   {
777     Standard_Integer aPatchSize1 = myBvhIndices.PatchSize (theIdx1);
778     Standard_Integer aPatchSize2 = myBvhIndices.PatchSize (theIdx2);
779     myBvhIndices.SetIndex (theIdx1, anElemIdx2, aPatchSize2);
780     myBvhIndices.SetIndex (theIdx2, anElemIdx1, aPatchSize1);
781   }
782   else
783   {
784     myBvhIndices.SetIndex (theIdx1, anElemIdx2);
785     myBvhIndices.SetIndex (theIdx2, anElemIdx1);
786   }
787 }
788
789 // =======================================================================
790 // function : BoundingBox
791 // purpose  :
792 // =======================================================================
793 Select3D_BndBox3d Select3D_SensitivePrimitiveArray::BoundingBox()
794 {
795   if (!myBndBox.IsValid())
796   {
797     computeBoundingBox();
798   }
799   return applyTransformation();
800 }
801
802 // =======================================================================
803 // function : computeBoundingBox
804 // purpose  :
805 // =======================================================================
806 void Select3D_SensitivePrimitiveArray::computeBoundingBox()
807 {
808   myBndBox.Clear();
809   if (!myGroups.IsNull())
810   {
811     for (Select3D_PrimArraySubGroupArray::Iterator aGroupIter (*myGroups); aGroupIter.More(); aGroupIter.Next())
812     {
813       myBndBox.Combine (aGroupIter.Value()->BoundingBox());
814     }
815     return;
816   }
817
818   if (myVerts.IsNull())
819   {
820     return;
821   }
822
823   const Standard_Integer aNbVerts = myVerts->NbElements;
824   if (myIs3d)
825   {
826     for (Standard_Integer aVertIter = 0; aVertIter < aNbVerts; ++aVertIter)
827     {
828       const Graphic3d_Vec3& aVert = getPosVec3 (aVertIter);
829       myBndBox.Add (SelectMgr_Vec3 (aVert.x(), aVert.y(), aVert.z()));
830     }
831   }
832   else
833   {
834     for (Standard_Integer aVertIter = 0; aVertIter < aNbVerts; ++aVertIter)
835     {
836       const Graphic3d_Vec2& aVert = getPosVec2 (aVertIter);
837       myBndBox.Add (SelectMgr_Vec3 (aVert.x(), aVert.y(), 0.0));
838     }
839   }
840 }
841
842 // =======================================================================
843 // function : applyTransformation
844 // purpose  :
845 // =======================================================================
846 Select3D_BndBox3d Select3D_SensitivePrimitiveArray::applyTransformation()
847 {
848   if (!HasInitLocation())
849   {
850     return myBndBox;
851   }
852
853   Select3D_BndBox3d aBndBox;
854   for (Standard_Integer aX = 0; aX <=1; ++aX)
855   {
856     for (Standard_Integer aY = 0; aY <=1; ++aY)
857     {
858       for (Standard_Integer aZ = 0; aZ <= 1; ++aZ)
859       {
860         gp_Pnt aVertex = gp_Pnt (aX == 0 ? myBndBox.CornerMin().x() : myBndBox.CornerMax().x(),
861                                  aY == 0 ? myBndBox.CornerMin().y() : myBndBox.CornerMax().y(),
862                                  aZ == 0 ? myBndBox.CornerMin().z() : myBndBox.CornerMax().z());
863         aVertex.Transform (myInitLocation.Transformation());
864         aBndBox.Add (Select3D_Vec3 (aVertex.X(), aVertex.Y(), aVertex.Z()));
865       }
866     }
867   }
868   return aBndBox;
869 }
870
871 // =======================================================================
872 // function : Matches
873 // purpose  :
874 // =======================================================================
875 Standard_Boolean Select3D_SensitivePrimitiveArray::Matches (SelectBasics_SelectingVolumeManager& theMgr,
876                                                             SelectBasics_PickResult& thePickResult)
877 {
878   if (!myDetectedElemMap.IsNull())
879   {
880     myDetectedElemMap->ChangeMap().Clear();
881   }
882   if (!myDetectedNodeMap.IsNull())
883   {
884     myDetectedNodeMap->ChangeMap().Clear();
885   }
886   myMinDepthElem      = RealLast();
887   myMinDepthNode      = RealLast();
888   myMinDepthEdge      = RealLast();
889   myDetectedElem      = -1;
890   myDetectedNode      = -1;
891   myDetectedEdgeNode1 = -1;
892   myDetectedEdgeNode2 = -1;
893   const bool toDetectRange = !myDetectedElemMap.IsNull() || !myDetectedNodeMap.IsNull();
894   if (myGroups.IsNull()
895    || theMgr.GetActiveSelectionType() == SelectBasics_SelectingVolumeManager::Point
896    || !toDetectRange)
897   {
898     if (!matches (theMgr, thePickResult, toDetectRange))
899     {
900       return Standard_False;
901     }
902
903     if (!myGroups.IsNull() && myDetectedIdx != -1)
904     {
905       const Standard_Integer anIndex = myBvhIndices.Index (myDetectedIdx);
906       const Handle(Select3D_SensitivePrimitiveArray)& aLastGroup = myGroups->Value (anIndex);
907       myMinDepthElem      = aLastGroup->myMinDepthElem;
908       myMinDepthNode      = aLastGroup->myMinDepthNode;
909       myMinDepthEdge      = aLastGroup->myMinDepthEdge;
910       myDetectedElem      = aLastGroup->myDetectedElem;
911       myDetectedNode      = aLastGroup->myDetectedNode;
912       myDetectedEdgeNode1 = aLastGroup->myDetectedEdgeNode1;
913       myDetectedEdgeNode2 = aLastGroup->myDetectedEdgeNode2;
914     }
915     return Standard_True;
916   }
917
918   SelectBasics_PickResult aPickResult;
919   bool hasResults = false;
920   for (Standard_Integer aGroupIter = 0; aGroupIter < myBvhIndices.NbElements; ++aGroupIter)
921   {
922     const Standard_Integer anElemIdx = myBvhIndices.Index (aGroupIter);
923     Handle(Select3D_SensitivePrimitiveArray)& aChild = myGroups->ChangeValue (anElemIdx);
924     if (aChild->Matches (theMgr, aPickResult))
925     {
926       hasResults = true;
927       if (!myDetectedElemMap.IsNull())
928       {
929         myDetectedElemMap->ChangeMap().Unite (aChild->myDetectedElemMap->Map());
930       }
931       if (!myDetectedNodeMap.IsNull())
932       {
933         myDetectedNodeMap->ChangeMap().Unite (aChild->myDetectedNodeMap->Map());
934       }
935       if (thePickResult.Depth() > aPickResult.Depth())
936       {
937         myDetectedIdx = aGroupIter;
938         thePickResult = aPickResult;
939       }
940     }
941   }
942   if (!hasResults)
943   {
944     return Standard_False;
945   }
946   thePickResult.SetDistToGeomCenter(theMgr.DistToGeometryCenter(CenterOfGeometry()));
947   return Standard_True;
948 }
949
950 // =======================================================================
951 // function : overlapsElement
952 // purpose  :
953 // =======================================================================
954 Standard_Boolean Select3D_SensitivePrimitiveArray::overlapsElement (SelectBasics_PickResult& thePickResult,
955                                                                     SelectBasics_SelectingVolumeManager& theMgr,
956                                                                     Standard_Integer theElemIdx,
957                                                                     Standard_Boolean theIsFullInside)
958 {
959   const Standard_Integer anElemIdx = myBvhIndices.Index (theElemIdx);
960   if (!myGroups.IsNull())
961   {
962     return myGroups->Value (anElemIdx)->Matches (theMgr, thePickResult);
963   }
964
965   const Standard_Integer aPatchSize = myBvhIndices.PatchSize (theElemIdx);
966   Select3D_BndBox3d aBox;
967   Standard_Boolean aResult = Standard_False;
968   SelectBasics_PickResult aPickResult;
969   switch (myPrimType)
970   {
971     case Graphic3d_TOPA_POINTS:
972     {
973       for (Standard_Integer anElemIter = 0; anElemIter < aPatchSize; ++anElemIter)
974       {
975         const Standard_Integer anIndexOffset = (anElemIdx + anElemIter);
976         const Standard_Integer aPointIndex   = !myIndices.IsNull()
977                                              ?  myIndices->Index (anIndexOffset)
978                                              :  anIndexOffset;
979         gp_Pnt aPoint;
980         if (myIs3d)
981         {
982           aPoint = vecToPnt (getPosVec3 (aPointIndex));
983         }
984         else
985         {
986           aPoint = vecToPnt (getPosVec2 (aPointIndex));
987         }
988
989         if (myToDetectNode
990          || myToDetectElem)
991         {
992           if (theIsFullInside || theMgr.Overlaps (aPoint, aPickResult))
993           {
994             if (aPickResult.Depth() <= myMinDepthNode)
995             {
996               myDetectedElem = myDetectedNode = aPointIndex;
997               myMinDepthElem = myMinDepthNode = aPickResult.Depth();
998             }
999             if (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Point)
1000             {
1001               if (!myDetectedElemMap.IsNull())
1002               {
1003                 myDetectedElemMap->ChangeMap().Add (aPointIndex);
1004               }
1005               if (!myDetectedNodeMap.IsNull())
1006               {
1007                 myDetectedNodeMap->ChangeMap().Add (aPointIndex);
1008               }
1009             }
1010             aResult = Standard_True;
1011           }
1012         }
1013         thePickResult = SelectBasics_PickResult::Min (thePickResult, aPickResult);
1014       }
1015       break;
1016     }
1017     case Graphic3d_TOPA_TRIANGLES:
1018     {
1019       Graphic3d_Vec3i aTriNodes;
1020       for (Standard_Integer anElemIter = 0; anElemIter < aPatchSize; ++anElemIter)
1021       {
1022         const Standard_Integer aTriIndex     = anElemIdx + anElemIter;
1023         const Standard_Integer anIndexOffset = aTriIndex * 3;
1024         getTriIndices (myIndices, anIndexOffset, aTriNodes);
1025         gp_Pnt aPnts[3];
1026         if (myIs3d)
1027         {
1028           aPnts[0] = vecToPnt (getPosVec3 (aTriNodes[0]));
1029           aPnts[1] = vecToPnt (getPosVec3 (aTriNodes[1]));
1030           aPnts[2] = vecToPnt (getPosVec3 (aTriNodes[2]));
1031         }
1032         else
1033         {
1034           aPnts[0] = vecToPnt (getPosVec2 (aTriNodes[0]));
1035           aPnts[1] = vecToPnt (getPosVec2 (aTriNodes[1]));
1036           aPnts[2] = vecToPnt (getPosVec2 (aTriNodes[2]));
1037         }
1038
1039         if (myToDetectElem)
1040         {
1041           if (theIsFullInside || theMgr.Overlaps (aPnts[0], aPnts[1], aPnts[2], Select3D_TOS_INTERIOR, aPickResult))
1042           {
1043             if (aPickResult.Depth() <= myMinDepthElem)
1044             {
1045               myDetectedElem = aTriIndex;
1046               myMinDepthElem = aPickResult.Depth();
1047             }
1048             aResult = Standard_True;
1049             if (!myDetectedElemMap.IsNull()
1050               && theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Point)
1051             {
1052               myDetectedElemMap->ChangeMap().Add(aTriIndex);
1053             }
1054           }
1055         }
1056         if (myToDetectNode)
1057         {
1058           for (int aNodeIter = 0; aNodeIter < 3; ++aNodeIter)
1059           {
1060             if (theIsFullInside || theMgr.Overlaps (aPnts[aNodeIter], aPickResult))
1061             {
1062               if (aPickResult.Depth() <= myMinDepthNode)
1063               {
1064                 myDetectedNode = aTriNodes[aNodeIter];
1065                 myMinDepthNode = aPickResult.Depth();
1066               }
1067               if (!myDetectedNodeMap.IsNull()
1068                 && theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Point)
1069               {
1070                 myDetectedNodeMap->ChangeMap().Add (aTriNodes[aNodeIter]);
1071               }
1072               aResult = Standard_True;
1073             }
1074           }
1075         }
1076         if (myToDetectEdge)
1077         {
1078           for (int aNodeIter = 0; aNodeIter < 3; ++aNodeIter)
1079           {
1080             int aNode1 = aNodeIter == 0 ? 2 : (aNodeIter - 1);
1081             int aNode2 = aNodeIter;
1082             if (theIsFullInside || theMgr.Overlaps (aPnts[aNode1], aPnts[aNode2], aPickResult))
1083             {
1084               if (aPickResult.Depth() <= myMinDepthEdge)
1085               {
1086                 myDetectedEdgeNode1 = aTriNodes[aNode1];
1087                 myDetectedEdgeNode2 = aTriNodes[aNode2];
1088                 myMinDepthEdge = aPickResult.Depth();
1089               }
1090               aResult = Standard_True;
1091             }
1092           }
1093         }
1094         thePickResult = SelectBasics_PickResult::Min (thePickResult, aPickResult);
1095       }
1096       break;
1097     }
1098     default:
1099     {
1100       return Standard_False;
1101     }
1102   }
1103
1104   return aResult;
1105 }
1106
1107 // =======================================================================
1108 // function : distanceToCOG
1109 // purpose  :
1110 // =======================================================================
1111 Standard_Real Select3D_SensitivePrimitiveArray::distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr)
1112 {
1113   return theMgr.DistToGeometryCenter (myCDG3D);
1114 }
1115
1116 // =======================================================================
1117 // function : elementIsInside
1118 // purpose  :
1119 // =======================================================================
1120 Standard_Boolean Select3D_SensitivePrimitiveArray::elementIsInside (SelectBasics_SelectingVolumeManager& theMgr,
1121                                                                     Standard_Integer theElemIdx,
1122                                                                     Standard_Boolean theIsFullInside)
1123 {
1124   const Standard_Integer anElemIdx = myBvhIndices.Index (theElemIdx);
1125   if (!myGroups.IsNull())
1126   {
1127     SelectBasics_PickResult aDummy;
1128     return myGroups->Value (anElemIdx)->Matches (theMgr, aDummy);
1129   }
1130
1131   const Standard_Integer aPatchSize = myBvhIndices.PatchSize (theElemIdx);
1132   switch (myPrimType)
1133   {
1134     case Graphic3d_TOPA_POINTS:
1135     {
1136       for (Standard_Integer anElemIter = 0; anElemIter < aPatchSize; ++anElemIter)
1137       {
1138         const Standard_Integer anIndexOffset = (anElemIdx + anElemIter);
1139         const Standard_Integer aPointIndex   = !myIndices.IsNull()
1140                                              ?  myIndices->Index (anIndexOffset)
1141                                              :  anIndexOffset;
1142         gp_Pnt aPoint;
1143         if (myIs3d)
1144         {
1145           aPoint = vecToPnt (getPosVec3 (aPointIndex));
1146         }
1147         else
1148         {
1149           aPoint = vecToPnt (getPosVec2 (aPointIndex));
1150         }
1151         if (!theIsFullInside && !theMgr.Overlaps (aPoint))
1152         {
1153           return Standard_False;
1154         }
1155
1156         if (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Point)
1157         {
1158           if (!myDetectedElemMap.IsNull())
1159           {
1160             myDetectedElemMap->ChangeMap().Add (aPointIndex);
1161           }
1162           if (!myDetectedNodeMap.IsNull())
1163           {
1164             myDetectedNodeMap->ChangeMap().Add (aPointIndex);
1165           }
1166         }
1167       }
1168       return Standard_True;
1169     }
1170     case Graphic3d_TOPA_TRIANGLES:
1171     {
1172       Graphic3d_Vec3i aTriNodes;
1173       for (Standard_Integer anElemIter = 0; anElemIter < aPatchSize; ++anElemIter)
1174       {
1175         const Standard_Integer aTriIndex     = anElemIdx + anElemIter;
1176         const Standard_Integer anIndexOffset = aTriIndex * 3;
1177         getTriIndices (myIndices, anIndexOffset, aTriNodes);
1178         gp_Pnt aPnts[3];
1179         if (myIs3d)
1180         {
1181           aPnts[0] = vecToPnt (getPosVec3 (aTriNodes[0]));
1182           aPnts[1] = vecToPnt (getPosVec3 (aTriNodes[1]));
1183           aPnts[2] = vecToPnt (getPosVec3 (aTriNodes[2]));
1184         }
1185         else
1186         {
1187           aPnts[0] = vecToPnt (getPosVec2 (aTriNodes[0]));
1188           aPnts[1] = vecToPnt (getPosVec2 (aTriNodes[1]));
1189           aPnts[2] = vecToPnt (getPosVec2 (aTriNodes[2]));
1190         }
1191
1192         if (!theIsFullInside && (   !theMgr.Overlaps (aPnts[0])
1193                                  || !theMgr.Overlaps (aPnts[1])
1194                                  || !theMgr.Overlaps (aPnts[2])))
1195         {
1196           return Standard_False;
1197         }
1198
1199         if (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Point)
1200         {
1201           if (!myDetectedElemMap.IsNull())
1202           {
1203             myDetectedElemMap->ChangeMap().Add (aTriIndex);
1204           }
1205           if (!myDetectedNodeMap.IsNull())
1206           {
1207             myDetectedNodeMap->ChangeMap().Add (aTriNodes[0]);
1208             myDetectedNodeMap->ChangeMap().Add (aTriNodes[1]);
1209             myDetectedNodeMap->ChangeMap().Add (aTriNodes[2]);
1210           }
1211         }
1212       }
1213       return Standard_True;
1214     }
1215     default:
1216     {
1217       return Standard_False;
1218     }
1219   }
1220 }
1221
1222 // =======================================================================
1223 // function : DumpJson
1224 // purpose  :
1225 // =======================================================================
1226 void Select3D_SensitivePrimitiveArray::DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth) const
1227 {
1228   OCCT_DUMP_TRANSIENT_CLASS_BEGIN (theOStream)
1229   OCCT_DUMP_BASE_CLASS (theOStream, theDepth, Select3D_SensitiveSet)
1230
1231   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myPosStride)
1232   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myPrimType)
1233   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myIndexLower)
1234   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myIndexUpper)
1235   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myPatchSizeMax)
1236   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myPatchDistance)
1237   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myIs3d)
1238   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myInitLocation)
1239   OCCT_DUMP_FIELD_VALUES_DUMPED (theOStream, theDepth, &myBndBox)
1240
1241   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myMinDepthElem)
1242   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myMinDepthNode)
1243   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myMinDepthEdge)
1244
1245   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myDetectedElem)
1246   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myDetectedNode)
1247   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myDetectedEdgeNode1)
1248   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myDetectedEdgeNode2)
1249   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myToDetectElem)
1250   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myToDetectNode)
1251   OCCT_DUMP_FIELD_VALUE_NUMERICAL (theOStream, myToDetectEdge)
1252 }