src/SelectMgr/SelectMgr_ViewerSelector.cxx

   1 // Created on: 1995-02-15
   2 // Created by: Roberc Coublanc
   3 // Copyright (c) 1995-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 #include <SelectMgr_ViewerSelector.hxx>
  18
  19 #include <BVH_Tree.hxx>
  20 #include <gp_GTrsf.hxx>
  21 #include <gp_Pnt.hxx>
  22 #include <OSD_Environment.hxx>
  23 #include <Precision.hxx>
  24 #include <SelectBasics_EntityOwner.hxx>
  25 #include <SelectBasics_SensitiveEntity.hxx>
  26 #include <SelectBasics_PickResult.hxx>
  27 #include <SelectMgr_EntityOwner.hxx>
  28 #include <SelectMgr_SortCriterion.hxx>
  29 #include <SelectMgr_SensitiveEntitySet.hxx>
  30 #include <TColStd_Array1OfInteger.hxx>
  31 #include <TCollection_AsciiString.hxx>
  32 #include <TColStd_HArray1OfInteger.hxx>
  33 #include <TColStd_ListOfInteger.hxx>
  34
  35 #include <algorithm>
  36
  37 IMPLEMENT_STANDARD_RTTIEXT(SelectMgr_ViewerSelector,MMgt_TShared)
  38
  39 namespace {
  40   // Comparison operator for sorting selection results
  41   class CompareResults
  42   {
  43   public:
  44
  45     CompareResults (const SelectMgr_IndexedDataMapOfOwnerCriterion& aMapOfCriterion)
  46       : myMapOfCriterion (aMapOfCriterion)
  47     {
  48     }
  49
  50     Standard_Boolean operator() (Standard_Integer theLeft, Standard_Integer theRight) const
  51     {
  52       return myMapOfCriterion.FindFromIndex(theLeft) > myMapOfCriterion.FindFromIndex(theRight);
  53     }
  54
  55   private:
  56     void operator = (const CompareResults&);
  57
  58   private:
  59     const SelectMgr_IndexedDataMapOfOwnerCriterion&  myMapOfCriterion;
  60   };
  61
  62   //! Compute 3d position for detected entity.
  63   inline void updatePoint3d (SelectMgr_SortCriterion& theCriterion,
  64                              const gp_GTrsf& theInversedTrsf,
  65                              SelectMgr_SelectingVolumeManager& theMgr)
  66   {
  67     theCriterion.Point = theMgr.DetectedPoint (theCriterion.Depth);
  68     gp_GTrsf anInvTrsf = theInversedTrsf;
  69     if (theCriterion.Entity->HasInitLocation())
  70     {
  71       anInvTrsf = theCriterion.Entity->InvInitLocation() * anInvTrsf;
  72     }
  73     if (anInvTrsf.Form() != gp_Identity)
  74     {
  75       anInvTrsf.Inverted().Transforms (theCriterion.Point.ChangeCoord());
  76     }
  77   }
  78
  79   static const Graphic3d_Mat4d THE_IDENTITY_MAT;
  80 }
  81
  82 //==================================================
  83 // Function: Initialize
  84 // Purpose :
  85 //==================================================
  86 SelectMgr_ViewerSelector::SelectMgr_ViewerSelector():
  87 preferclosest(Standard_True),
  88 myToUpdateTolerance (Standard_True),
  89 myCurRank (0),
  90 myIsLeftChildQueuedFirst (Standard_False),
  91 myEntityIdx (0)
  92 {
  93 }
  94
  95 //==================================================
  96 // Function: Activate
  97 // Purpose :
  98 //==================================================
  99 void SelectMgr_ViewerSelector::Activate (const Handle(SelectMgr_Selection)& theSelection)
 100 {
 101   for (theSelection->Init(); theSelection->More(); theSelection->Next())
 102   {
 103     theSelection->Sensitive()->SetActiveForSelection();
 104   }
 105
 106   theSelection->SetSelectionState (SelectMgr_SOS_Activated);
 107
 108   myTolerances.Add (theSelection->Sensitivity());
 109   myToUpdateTolerance = Standard_True;
 110 }
 111
 112 //==================================================
 113 // Function: Deactivate
 114 // Purpose :
 115 //==================================================
 116 void SelectMgr_ViewerSelector::Deactivate (const Handle(SelectMgr_Selection)& theSelection)
 117 {
 118   for (theSelection->Init(); theSelection->More(); theSelection->Next())
 119   {
 120     theSelection->Sensitive()->ResetSelectionActiveStatus();
 121   }
 122
 123   theSelection->SetSelectionState (SelectMgr_SOS_Deactivated);
 124
 125   myTolerances.Decrement (theSelection->Sensitivity());
 126   myToUpdateTolerance = Standard_True;
 127 }
 128
 129 //==================================================
 130 // Function: Clear
 131 // Purpose :
 132 //==================================================
 133 void SelectMgr_ViewerSelector::Clear()
 134 {
 135   mystored.Clear();
 136 }
 137
 138 //=======================================================================
 139 // function: isToScaleFrustum
 140 // purpose : Checks if the entity given requires to scale current selecting frustum
 141 //=======================================================================
 142 Standard_Boolean SelectMgr_ViewerSelector::isToScaleFrustum (const Handle(SelectBasics_SensitiveEntity)& theEntity)
 143 {
 144   return mySelectingVolumeMgr.GetActiveSelectionType() == SelectMgr_SelectingVolumeManager::Point
 145     && sensitivity (theEntity) < myTolerances.Tolerance();
 146 }
 147
 148 //=======================================================================
 149 // function: sensitivity
 150 // purpose : In case if custom tolerance is set, this method will return sum of entity
 151 //           sensitivity and custom tolerance.
 152 //=======================================================================
 153 Standard_Integer SelectMgr_ViewerSelector::sensitivity (const Handle(SelectBasics_SensitiveEntity)& theEntity) const
 154 {
 155   return myTolerances.IsCustomTolSet() ?
 156     theEntity->SensitivityFactor() + myTolerances.CustomTolerance() : theEntity->SensitivityFactor();
 157 }
 158
 159 //=======================================================================
 160 // function: checkOverlap
 161 // purpose : Internal function that checks if a particular sensitive
 162 //           entity theEntity overlaps current selecting volume precisely
 163 //=======================================================================
 164 void SelectMgr_ViewerSelector::checkOverlap (const Handle(SelectBasics_SensitiveEntity)& theEntity,
 165                                              const gp_GTrsf& theInversedTrsf,
 166                                              SelectMgr_SelectingVolumeManager& theMgr)
 167 {
 168   Handle(SelectMgr_EntityOwner) anOwner (Handle(SelectMgr_EntityOwner)::DownCast (theEntity->OwnerId()));
 169   Handle(SelectMgr_SelectableObject) aSelectable;
 170   Standard_Boolean toRestoresViewClipEnabled = Standard_False;
 171   if (!anOwner.IsNull())
 172   {
 173     aSelectable = anOwner->Selectable();
 174     if (aSelectable->TransformPersistence().Flags == Graphic3d_TMF_TriedronPers
 175      || aSelectable->TransformPersistence().Flags == Graphic3d_TMF_2d
 176      || (!aSelectable->ClipPlanes().IsNull() && aSelectable->ClipPlanes()->ToOverrideGlobal()))
 177     {
 178       theMgr.SetViewClippingEnabled (Standard_False);
 179       toRestoresViewClipEnabled = Standard_True;
 180     }
 181   }
 182
 183   SelectBasics_PickResult aPickResult;
 184   const Standard_Boolean isMatched = theEntity->Matches(theMgr, aPickResult);
 185   if (toRestoresViewClipEnabled)
 186   {
 187     theMgr.SetViewClippingEnabled (Standard_True);
 188   }
 189
 190   if (!isMatched
 191     || anOwner.IsNull())
 192   {
 193     return;
 194   }
 195
 196   if (HasDepthClipping (anOwner)
 197   &&  theMgr.GetActiveSelectionType() == SelectMgr_SelectingVolumeManager::Point)
 198   {
 199     Standard_Boolean isClipped = mySelectingVolumeMgr.IsClipped (*aSelectable->ClipPlanes(),
 200                                                                   aPickResult.Depth());
 201     if (isClipped)
 202       return;
 203   }
 204
 205   SelectMgr_SortCriterion aCriterion;
 206   myZLayerOrderMap.Find (aSelectable->ZLayer(), aCriterion.ZLayerPosition);
 207   aCriterion.Entity    = theEntity;
 208   aCriterion.Priority  = anOwner->Priority();
 209   aCriterion.Depth     = aPickResult.Depth();
 210   aCriterion.MinDist   = aPickResult.DistToGeomCenter();
 211   aCriterion.Tolerance = theEntity->SensitivityFactor() / 33.0;
 212   aCriterion.ToPreferClosest = preferclosest;
 213
 214   const Standard_Integer aPrevStoredIndex = mystored.FindIndex (anOwner);
 215   if (aPrevStoredIndex != 0)
 216   {
 217     if (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Box)
 218     {
 219       SelectMgr_SortCriterion& aPrevCriterion = mystored.ChangeFromIndex (aPrevStoredIndex);
 220       if (aCriterion > aPrevCriterion)
 221       {
 222         updatePoint3d (aCriterion, theInversedTrsf, theMgr);
 223         aPrevCriterion = aCriterion;
 224       }
 225     }
 226   }
 227   else
 228   {
 229     updatePoint3d (aCriterion, theInversedTrsf, theMgr);
 230     mystored.Add (anOwner, aCriterion);
 231   }
 232 }
 233
 234 //=======================================================================
 235 // function: computeFrustum
 236 // purpose : Internal function that checks if a current selecting frustum
 237 //           needs to be scaled and transformed for the entity and performs
 238 //           necessary calculations
 239 //=======================================================================
 240 void SelectMgr_ViewerSelector::computeFrustum (const Handle(SelectBasics_SensitiveEntity)& theEnt,
 241                                                const SelectMgr_SelectingVolumeManager&     theMgr,
 242                                                const gp_GTrsf&                             theInvTrsf,
 243                                                SelectMgr_FrustumCache&                     theCachedMgrs,
 244                                                SelectMgr_SelectingVolumeManager&           theResMgr)
 245 {
 246   Standard_Integer aScale = isToScaleFrustum (theEnt) ? sensitivity (theEnt) : 1;
 247   const gp_GTrsf aTrsfMtr = theEnt->HasInitLocation() ? theEnt->InvInitLocation() * theInvTrsf : theInvTrsf;
 248   const Standard_Boolean toScale = aScale != 1;
 249   const Standard_Boolean toTransform = aTrsfMtr.Form() != gp_Identity;
 250   if (toScale && toTransform)
 251   {
 252     theResMgr = theMgr.ScaleAndTransform (aScale, aTrsfMtr, NULL);
 253   }
 254   else if (toScale)
 255   {
 256     if (!theCachedMgrs.IsBound (aScale))
 257     {
 258       theCachedMgrs.Bind (aScale, theMgr.ScaleAndTransform (aScale, gp_Trsf(), NULL));
 259     }
 260     theResMgr = theCachedMgrs.Find (aScale);
 261   }
 262   else if (toTransform)
 263   {
 264     theResMgr = theMgr.ScaleAndTransform (1, aTrsfMtr, NULL);
 265   }
 266 }
 267
 268 //=======================================================================
 269 // function: traverseObject
 270 // purpose : Internal function that checks if there is possible overlap
 271 //           between some entity of selectable object theObject and
 272 //           current selecting volume
 273 //=======================================================================
 274 void SelectMgr_ViewerSelector::traverseObject (const Handle(SelectMgr_SelectableObject)& theObject,
 275                                                const SelectMgr_SelectingVolumeManager& theMgr,
 276                                                const Handle(Graphic3d_Camera)& theCamera,
 277                                                const Graphic3d_Mat4d& theProjectionMat,
 278                                                const Graphic3d_Mat4d& theWorldViewMat,
 279                                                const Standard_Integer theViewportWidth,
 280                                                const Standard_Integer theViewportHeight)
 281 {
 282   NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet =
 283     myMapOfObjectSensitives.ChangeFind (theObject);
 284
 285   if (anEntitySet->Size() == 0)
 286     return;
 287
 288   const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& aSensitivesTree = anEntitySet->BVH();
 289
 290   gp_GTrsf aInversedTrsf;
 291
 292   if (theObject->HasTransformation() || theObject->TransformPersistence().Flags)
 293   {
 294     if (!theObject->TransformPersistence().Flags)
 295     {
 296       aInversedTrsf = theObject->InversedTransformation();
 297     }
 298     else
 299     {
 300       gp_GTrsf aTPers;
 301       Graphic3d_Mat4d aMat = theObject->TransformPersistence().Compute (
 302         theCamera, theProjectionMat, theWorldViewMat, theViewportWidth, theViewportHeight);
 303
 304       aTPers.SetValue (1, 1, aMat.GetValue (0, 0));
 305       aTPers.SetValue (1, 2, aMat.GetValue (0, 1));
 306       aTPers.SetValue (1, 3, aMat.GetValue (0, 2));
 307       aTPers.SetValue (2, 1, aMat.GetValue (1, 0));
 308       aTPers.SetValue (2, 2, aMat.GetValue (1, 1));
 309       aTPers.SetValue (2, 3, aMat.GetValue (1, 2));
 310       aTPers.SetValue (3, 1, aMat.GetValue (2, 0));
 311       aTPers.SetValue (3, 2, aMat.GetValue (2, 1));
 312       aTPers.SetValue (3, 3, aMat.GetValue (2, 2));
 313       aTPers.SetTranslationPart (gp_XYZ (aMat.GetValue (0, 3), aMat.GetValue (1, 3), aMat.GetValue (2, 3)));
 314
 315       aInversedTrsf = (aTPers * gp_GTrsf (theObject->Transformation())).Inverted();
 316     }
 317   }
 318
 319   SelectMgr_SelectingVolumeManager aMgr = aInversedTrsf.Form() != gp_Identity
 320                                         ? theMgr.ScaleAndTransform (1, aInversedTrsf, NULL)
 321                                         : theMgr;
 322
 323   SelectMgr_FrustumCache aScaledTrnsfFrustums;
 324
 325   Standard_Integer aNode = 0; // a root node
 326   if (!aMgr.Overlaps (aSensitivesTree->MinPoint (0),
 327                       aSensitivesTree->MaxPoint (0)))
 328   {
 329     return;
 330   }
 331   Standard_Integer aStack[32];
 332   Standard_Integer aHead = -1;
 333   for (;;)
 334   {
 335     if (!aSensitivesTree->IsOuter (aNode))
 336     {
 337       const Standard_Integer aLeftChildIdx  = aSensitivesTree->Child<0> (aNode);
 338       const Standard_Integer aRightChildIdx = aSensitivesTree->Child<1> (aNode);
 339       const Standard_Boolean isLeftChildIn  =  aMgr.Overlaps (aSensitivesTree->MinPoint (aLeftChildIdx),
 340                                                               aSensitivesTree->MaxPoint (aLeftChildIdx));
 341       const Standard_Boolean isRightChildIn = aMgr.Overlaps (aSensitivesTree->MinPoint (aRightChildIdx),
 342                                                              aSensitivesTree->MaxPoint (aRightChildIdx));
 343       if (isLeftChildIn
 344           && isRightChildIn)
 345       {
 346         aNode = aLeftChildIdx;
 347         ++aHead;
 348         aStack[aHead] = aRightChildIdx;
 349       }
 350       else if (isLeftChildIn
 351         || isRightChildIn)
 352       {
 353         aNode = isLeftChildIn ? aLeftChildIdx : aRightChildIdx;
 354       }
 355       else
 356       {
 357         if (aHead < 0)
 358         {
 359           break;
 360         }
 361
 362         aNode = aStack[aHead];
 363         --aHead;
 364       }
 365     }
 366     else
 367     {
 368       Standard_Integer aStartIdx = aSensitivesTree->BegPrimitive (aNode);
 369       Standard_Integer anEndIdx = aSensitivesTree->EndPrimitive (aNode);
 370       for (Standard_Integer anIdx = aStartIdx; anIdx <= anEndIdx; ++anIdx)
 371       {
 372         const Handle(SelectMgr_SensitiveEntity)& aSensitive =
 373           anEntitySet->GetSensitiveById (anIdx);
 374         if (aSensitive->IsActiveForSelection())
 375         {
 376           const Handle(SelectBasics_SensitiveEntity)& anEnt = aSensitive->BaseSensitive();
 377           SelectMgr_SelectingVolumeManager aTmpMgr = aMgr;
 378           computeFrustum (anEnt, theMgr, aInversedTrsf, aScaledTrnsfFrustums, aTmpMgr);
 379           checkOverlap (anEnt, aInversedTrsf, aTmpMgr);
 380         }
 381       }
 382       if (aHead < 0)
 383       {
 384         break;
 385       }
 386
 387       aNode = aStack[aHead];
 388       --aHead;
 389     }
 390   }
 391 }
 392
 393 //=======================================================================
 394 // function: TraverseSensitives
 395 // purpose : Traverses BVH containing all added selectable objects and
 396 //           finds candidates for further search of overlap
 397 //=======================================================================
 398 void SelectMgr_ViewerSelector::TraverseSensitives()
 399 {
 400   mystored.Clear();
 401
 402   Standard_Integer aWidth;
 403   Standard_Integer aHeight;
 404   mySelectingVolumeMgr.WindowSize (aWidth, aHeight);
 405   mySelectableObjects.UpdateBVH (mySelectingVolumeMgr.Camera(),
 406                                  mySelectingVolumeMgr.ProjectionMatrix(),
 407                                  mySelectingVolumeMgr.WorldViewMatrix(),
 408                                  mySelectingVolumeMgr.WorldViewProjState(),
 409                                  aWidth, aHeight);
 410
 411   for (Standard_Integer aBVHSetIt = 0; aBVHSetIt < SelectMgr_SelectableObjectSet::BVHSubsetNb; ++aBVHSetIt)
 412   {
 413     SelectMgr_SelectableObjectSet::BVHSubset aBVHSubset =
 414       static_cast<SelectMgr_SelectableObjectSet::BVHSubset> (aBVHSetIt);
 415
 416     if (mySelectableObjects.IsEmpty (aBVHSubset))
 417     {
 418       continue;
 419     }
 420
 421     gp_GTrsf aTFrustum;
 422
 423     SelectMgr_SelectingVolumeManager aMgr (Standard_False);
 424
 425     // for 2D space selection transform selecting volumes to perform overap testing
 426     // directly in camera's eye space omitting the camera position, which is not
 427     // needed there at all
 428     if (aBVHSubset == SelectMgr_SelectableObjectSet::BVHSubset_2dPersistent)
 429     {
 430       const Graphic3d_Mat4d& aMat = mySelectingVolumeMgr.WorldViewMatrix();
 431       aTFrustum.SetValue (1, 1, aMat.GetValue (0, 0));
 432       aTFrustum.SetValue (1, 2, aMat.GetValue (0, 1));
 433       aTFrustum.SetValue (1, 3, aMat.GetValue (0, 2));
 434       aTFrustum.SetValue (2, 1, aMat.GetValue (1, 0));
 435       aTFrustum.SetValue (2, 2, aMat.GetValue (1, 1));
 436       aTFrustum.SetValue (2, 3, aMat.GetValue (1, 2));
 437       aTFrustum.SetValue (3, 1, aMat.GetValue (2, 0));
 438       aTFrustum.SetValue (3, 2, aMat.GetValue (2, 1));
 439       aTFrustum.SetValue (3, 3, aMat.GetValue (2, 2));
 440       aTFrustum.SetTranslationPart (gp_XYZ (aMat.GetValue (0, 3), aMat.GetValue (1, 3), aMat.GetValue (2, 3)));
 441
 442       // define corresponding frustum builder parameters
 443       Handle(SelectMgr_FrustumBuilder) aBuilder = new SelectMgr_FrustumBuilder();
 444       aBuilder->SetProjectionMatrix (mySelectingVolumeMgr.ProjectionMatrix());
 445       aBuilder->SetWorldViewMatrix (THE_IDENTITY_MAT);
 446       aBuilder->SetWindowSize (aWidth, aHeight);
 447       aMgr = mySelectingVolumeMgr.ScaleAndTransform (1, aTFrustum, aBuilder);
 448     }
 449     else
 450     {
 451       aMgr = mySelectingVolumeMgr;
 452     }
 453
 454     const Handle(Graphic3d_Camera)& aCamera = mySelectingVolumeMgr.Camera();
 455     const Graphic3d_Mat4d& aProjectionMat   = mySelectingVolumeMgr.ProjectionMatrix();
 456     const Graphic3d_Mat4d& aWorldViewMat    = aBVHSubset != SelectMgr_SelectableObjectSet::BVHSubset_2dPersistent
 457                                             ? mySelectingVolumeMgr.WorldViewMatrix()
 458                                             : THE_IDENTITY_MAT;
 459
 460     const NCollection_Handle<BVH_Tree<Standard_Real, 3> >& aBVHTree = mySelectableObjects.BVH (aBVHSubset);
 461
 462     Standard_Integer aNode = 0;
 463     if (!aMgr.Overlaps (aBVHTree->MinPoint (0), aBVHTree->MaxPoint (0)))
 464     {
 465       continue;
 466     }
 467
 468     Standard_Integer aStack[32];
 469     Standard_Integer aHead = -1;
 470     for (;;)
 471     {
 472       if (!aBVHTree->IsOuter (aNode))
 473       {
 474         const Standard_Integer aLeftChildIdx  = aBVHTree->Child<0> (aNode);
 475         const Standard_Integer aRightChildIdx = aBVHTree->Child<1> (aNode);
 476         const Standard_Boolean isLeftChildIn  =
 477           aMgr.Overlaps (aBVHTree->MinPoint (aLeftChildIdx), aBVHTree->MaxPoint (aLeftChildIdx));
 478         const Standard_Boolean isRightChildIn =
 479           aMgr.Overlaps (aBVHTree->MinPoint (aRightChildIdx), aBVHTree->MaxPoint (aRightChildIdx));
 480         if (isLeftChildIn
 481           && isRightChildIn)
 482         {
 483           aNode = aLeftChildIdx;
 484           ++aHead;
 485           aStack[aHead] = aRightChildIdx;
 486         }
 487         else if (isLeftChildIn
 488           || isRightChildIn)
 489         {
 490           aNode = isLeftChildIn ? aLeftChildIdx : aRightChildIdx;
 491         }
 492         else
 493         {
 494           if (aHead < 0)
 495           {
 496             break;
 497           }
 498
 499           aNode = aStack[aHead];
 500           --aHead;
 501         }
 502       }
 503       else
 504       {
 505         Standard_Integer aStartIdx = aBVHTree->BegPrimitive (aNode);
 506         Standard_Integer anEndIdx  = aBVHTree->EndPrimitive (aNode);
 507         for (Standard_Integer anIdx = aStartIdx; anIdx <= anEndIdx; ++anIdx)
 508         {
 509           const Handle(SelectMgr_SelectableObject)& aSelectableObject =
 510             mySelectableObjects.GetObjectById (aBVHSubset, anIdx);
 511
 512           traverseObject (aSelectableObject, aMgr, aCamera, aProjectionMat, aWorldViewMat, aWidth, aHeight);
 513         }
 514         if (aHead < 0)
 515         {
 516           break;
 517         }
 518
 519         aNode = aStack[aHead];
 520         --aHead;
 521       }
 522     }
 523   }
 524
 525   SortResult();
 526 }
 527
 528 //==================================================
 529 // Function: Picked
 530 // Purpose :
 531 //==================================================
 532 Handle(SelectMgr_EntityOwner) SelectMgr_ViewerSelector
 533 ::Picked() const
 534 {
 535   Standard_Integer RankInMap = myIndexes->Value (myCurRank);
 536   const Handle(SelectBasics_EntityOwner)& toto = mystored.FindKey(RankInMap);
 537   Handle(SelectMgr_EntityOwner) Ownr = Handle(SelectMgr_EntityOwner)::DownCast (toto);
 538   return Ownr;
 539 }
 540
 541 //=======================================================================
 542 //function : Picked
 543 //purpose  :
 544 //=======================================================================
 545 Handle(SelectMgr_EntityOwner) SelectMgr_ViewerSelector::Picked (const Standard_Integer theRank) const
 546 {
 547   Handle(SelectMgr_EntityOwner) anOwner;
 548   if (theRank < 1 || theRank > NbPicked())
 549   {
 550     return anOwner;
 551   }
 552
 553   const Standard_Integer anOwnerIdx = myIndexes->Value (theRank);
 554   const Handle(SelectBasics_EntityOwner)& aStoredOwner = mystored.FindKey (anOwnerIdx);
 555   anOwner = Handle(SelectMgr_EntityOwner)::DownCast (aStoredOwner);
 556   return anOwner;
 557 }
 558
 559 //=======================================================================
 560 //function : PickedData
 561 //purpose  :
 562 //=======================================================================
 563 const SelectMgr_SortCriterion& SelectMgr_ViewerSelector::PickedData(const Standard_Integer theRank) const
 564 {
 565   Standard_OutOfRange_Raise_if (theRank < 1 || theRank > NbPicked(), "SelectMgr_ViewerSelector::PickedData() out of range index");
 566   const Standard_Integer anOwnerIdx = myIndexes->Value (theRank);
 567   return mystored.FindFromIndex (anOwnerIdx);
 568 }
 569
 570 //===================================================
 571 //
 572 //       INTERNAL METHODS ....
 573 //
 574 //==================================================
 575
 576 //==================================================
 577 // Function: Contains
 578 // Purpose :
 579 //==================================================
 580 Standard_Boolean SelectMgr_ViewerSelector::Contains (const Handle(SelectMgr_SelectableObject)& theObject) const
 581 {
 582   return mySelectableObjects.Contains (theObject);
 583 }
 584
 585 //==================================================
 586 // Function: ActiveModes
 587 // Purpose : return all the  modes with a given state for an object
 588 //==================================================
 589 Standard_Boolean SelectMgr_ViewerSelector::Modes (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
 590                                                   TColStd_ListOfInteger& theModeList,
 591                                                   const SelectMgr_StateOfSelection theWantedState) const
 592 {
 593   Standard_Boolean hasActivatedStates = Contains (theSelectableObject);
 594   for (theSelectableObject->Init(); theSelectableObject->More(); theSelectableObject->Next())
 595   {
 596       if (theWantedState == SelectMgr_SOS_Any)
 597       {
 598         theModeList.Append (theSelectableObject->CurrentSelection()->Mode());
 599       }
 600       else if (theWantedState == theSelectableObject->CurrentSelection()->GetSelectionState())
 601       {
 602         theModeList.Append (theSelectableObject->CurrentSelection()->Mode());
 603       }
 604   }
 605
 606   return hasActivatedStates;
 607 }
 608
 609 //==================================================
 610 // Function: IsActive
 611 // Purpose :
 612 //==================================================
 613 Standard_Boolean SelectMgr_ViewerSelector::IsActive (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
 614                                                      const Standard_Integer theMode) const
 615 {
 616   if (!Contains (theSelectableObject))
 617     return Standard_False;
 618
 619   for (theSelectableObject->Init(); theSelectableObject->More(); theSelectableObject->Next())
 620   {
 621     if (theMode == theSelectableObject->CurrentSelection()->Mode())
 622     {
 623       return theSelectableObject->CurrentSelection()->GetSelectionState() == SelectMgr_SOS_Activated;
 624     }
 625   }
 626
 627   return Standard_False;
 628 }
 629
 630 //==================================================
 631 // Function: IsInside
 632 // Purpose :
 633 //==================================================
 634 Standard_Boolean SelectMgr_ViewerSelector::IsInside (const Handle(SelectMgr_SelectableObject)& theSelectableObject,
 635                                                      const Standard_Integer theMode) const
 636 {
 637   if (!Contains (theSelectableObject))
 638     return Standard_False;
 639
 640   for (theSelectableObject->Init(); theSelectableObject->More(); theSelectableObject->Next())
 641   {
 642     if (theMode == theSelectableObject->CurrentSelection()->Mode())
 643     {
 644       return theSelectableObject->CurrentSelection()->GetSelectionState() != SelectMgr_SOS_Unknown;
 645     }
 646   }
 647
 648   return Standard_False;
 649 }
 650
 651
 652 //=======================================================================
 653 //function : Status
 654 //purpose  :
 655 //=======================================================================
 656
 657 SelectMgr_StateOfSelection SelectMgr_ViewerSelector::Status (const Handle(SelectMgr_Selection)& theSelection) const
 658 {
 659   return theSelection->GetSelectionState();
 660 }
 661
 662 //==================================================
 663 // Function: Status
 664 // Purpose : gives Information about selectors
 665 //==================================================
 666
 667 TCollection_AsciiString SelectMgr_ViewerSelector::Status (const Handle(SelectMgr_SelectableObject)& theSelectableObject) const
 668 {
 669   TCollection_AsciiString aStatus ("Status Object :\n\t");
 670
 671   for (theSelectableObject->Init(); theSelectableObject->More(); theSelectableObject->Next())
 672   {
 673     if (theSelectableObject->CurrentSelection()->GetSelectionState() != SelectMgr_SOS_Unknown)
 674     {
 675       aStatus = aStatus + "Mode " +
 676         TCollection_AsciiString (theSelectableObject->CurrentSelection()->Mode()) +
 677         " present - ";
 678       if (theSelectableObject->CurrentSelection()->GetSelectionState() == SelectMgr_SOS_Activated)
 679       {
 680         aStatus = aStatus + " Active \n\t";
 681       }
 682       else
 683       {
 684         aStatus = aStatus + " Inactive \n\t";
 685       }
 686     }
 687   }
 688
 689   if (!Contains (theSelectableObject))
 690   {
 691     aStatus = aStatus + "Not Present in the selector\n\n";
 692   }
 693
 694   return aStatus;
 695 }
 696
 697 //=======================================================================
 698 //function : SortResult
 699 //purpose  :  there is a certain number of entities ranged by criteria
 700 //            (depth, size, priority, mouse distance from borders or
 701 //            CDG of the detected primitive. Parsing :
 702 //             maximum priorities .
 703 //             then a reasonable compromise between depth and distance...
 704 // finally the ranges are stored in myindexes depending on the parsing.
 705 // so, it is possible to only read
 706 //=======================================================================
 707 void SelectMgr_ViewerSelector::SortResult()
 708 {
 709   if(mystored.IsEmpty()) return;
 710
 711   const Standard_Integer anExtent = mystored.Extent();
 712   if(myIndexes.IsNull() || anExtent != myIndexes->Length())
 713     myIndexes = new TColStd_HArray1OfInteger (1, anExtent);
 714
 715   // to work faster...
 716   TColStd_Array1OfInteger& thearr = myIndexes->ChangeArray1();
 717
 718   // indices from 1 to N are loaded
 719   Standard_Integer I ;
 720   for (I=1; I <= anExtent; I++)
 721     thearr(I)=I;
 722
 723   std::sort (thearr.begin(), thearr.end(), CompareResults (mystored));
 724
 725 }
 726
 727 //=======================================================================
 728 //function : HasDepthClipping
 729 //purpose  : Stub
 730 //=======================================================================
 731 Standard_Boolean SelectMgr_ViewerSelector::HasDepthClipping (const Handle(SelectMgr_EntityOwner)& /*theOwner*/) const
 732 {
 733   return Standard_False;
 734 }
 735
 736 //=======================================================================
 737 // function : AddSelectableObject
 738 // purpose  : Adds new object to the map of selectable objects
 739 //=======================================================================
 740 void SelectMgr_ViewerSelector::AddSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
 741 {
 742   if (!myMapOfObjectSensitives.IsBound (theObject))
 743   {
 744     mySelectableObjects.Append (theObject);
 745     NCollection_Handle<SelectMgr_SensitiveEntitySet> anEntitySet = new SelectMgr_SensitiveEntitySet();
 746     myMapOfObjectSensitives.Bind (theObject, anEntitySet);
 747   }
 748 }
 749
 750 //=======================================================================
 751 // function : AddSelectionToObject
 752 // purpose  : Adds new selection to the object and builds its BVH tree
 753 //=======================================================================
 754 void SelectMgr_ViewerSelector::AddSelectionToObject (const Handle(SelectMgr_SelectableObject)& theObject,
 755                                                      const Handle(SelectMgr_Selection)& theSelection)
 756 {
 757   if (myMapOfObjectSensitives.IsBound (theObject))
 758   {
 759     NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet =
 760       myMapOfObjectSensitives.ChangeFind (theObject);
 761     anEntitySet->Append (theSelection);
 762     anEntitySet->BVH();
 763   }
 764   else
 765   {
 766     AddSelectableObject (theObject);
 767     AddSelectionToObject (theObject, theSelection);
 768   }
 769 }
 770
 771 //=======================================================================
 772 // function : MoveSelectableObject
 773 // purpose  :
 774 //=======================================================================
 775 void SelectMgr_ViewerSelector::MoveSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
 776 {
 777   mySelectableObjects.ChangeSubset (theObject);
 778 }
 779
 780 //=======================================================================
 781 // function : RemoveSelectableObject
 782 // purpose  : Removes selectable object from map of selectable ones
 783 //=======================================================================
 784 void SelectMgr_ViewerSelector::RemoveSelectableObject (const Handle(SelectMgr_SelectableObject)& theObject)
 785 {
 786   if (myMapOfObjectSensitives.IsBound (theObject))
 787   {
 788     mySelectableObjects.Remove (theObject);
 789     myMapOfObjectSensitives.UnBind (theObject);
 790   }
 791 }
 792
 793 //=======================================================================
 794 // function : RemoveSelectionOfObject
 795 // purpose  : Removes selection of the object and marks its BVH tree
 796 //            for rebuild
 797 //=======================================================================
 798 void SelectMgr_ViewerSelector::RemoveSelectionOfObject (const Handle(SelectMgr_SelectableObject)& theObject,
 799                                                         const Handle(SelectMgr_Selection)& theSelection)
 800 {
 801   if (myMapOfObjectSensitives.IsBound (theObject))
 802   {
 803     NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet =
 804       myMapOfObjectSensitives.ChangeFind (theObject);
 805     anEntitySet->Remove (theSelection);
 806   }
 807 }
 808
 809 //=======================================================================
 810 // function : RebuildObjectsTree
 811 // purpose  : Marks BVH of selectable objects for rebuild
 812 //=======================================================================
 813 void SelectMgr_ViewerSelector::RebuildObjectsTree (const Standard_Boolean theIsForce)
 814 {
 815   mySelectableObjects.MarkDirty();
 816
 817   if (theIsForce)
 818   {
 819     Standard_Integer aViewportWidth, aViewportHeight;
 820     mySelectingVolumeMgr.WindowSize (aViewportWidth, aViewportHeight);
 821
 822     Standard_Integer aWidth;
 823     Standard_Integer aHeight;
 824     mySelectingVolumeMgr.WindowSize (aWidth, aHeight);
 825     mySelectableObjects.UpdateBVH (mySelectingVolumeMgr.Camera(),
 826                                    mySelectingVolumeMgr.ProjectionMatrix(),
 827                                    mySelectingVolumeMgr.WorldViewMatrix(),
 828                                    mySelectingVolumeMgr.WorldViewProjState(),
 829                                    aWidth, aHeight);
 830   }
 831 }
 832
 833 //=======================================================================
 834 // function : RebuildSensitivesTree
 835 // purpose  : Marks BVH of sensitive entities of particular selectable
 836 //            object for rebuild
 837 //=======================================================================
 838 void SelectMgr_ViewerSelector::RebuildSensitivesTree (const Handle(SelectMgr_SelectableObject)& theObject,
 839                                                       const Standard_Boolean theIsForce)
 840 {
 841   if (!Contains (theObject))
 842     return;
 843
 844   NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet = myMapOfObjectSensitives.ChangeFind (theObject);
 845   anEntitySet->MarkDirty();
 846
 847   if (theIsForce)
 848   {
 849     anEntitySet->BVH();
 850   }
 851 }
 852
 853 //=======================================================================
 854 // function : resetSelectionActivationStatus
 855 // purpose  : Marks all added sensitive entities of all objects as
 856 //            non-selectable
 857 //=======================================================================
 858 void SelectMgr_ViewerSelector::ResetSelectionActivationStatus()
 859 {
 860   SelectMgr_MapOfObjectSensitivesIterator aSensitivesIter (myMapOfObjectSensitives);
 861   for ( ; aSensitivesIter.More(); aSensitivesIter.Next())
 862   {
 863     NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet =
 864       aSensitivesIter.ChangeValue();
 865     Standard_Integer anEntitiesNb = anEntitySet->Size();
 866     for (Standard_Integer anIdx = 0; anIdx < anEntitiesNb; ++anIdx)
 867     {
 868       anEntitySet->GetSensitiveById (anIdx)->ResetSelectionActiveStatus();
 869     }
 870   }
 871 }
 872
 873 //=======================================================================
 874 // function : DetectedEntity
 875 // purpose  : Returns sensitive entity that was detected during the
 876 //            previous run of selection algorithm
 877 //=======================================================================
 878 const Handle(SelectBasics_SensitiveEntity)& SelectMgr_ViewerSelector::DetectedEntity() const
 879 {
 880   const Standard_Integer aRankInMap = myIndexes->Value(myCurRank);
 881   return mystored.FindFromIndex (aRankInMap).Entity;
 882 }
 883
 884 //=======================================================================
 885 // function : ActiveOwners
 886 // purpose  : Returns the list of active entity owners
 887 //=======================================================================
 888 void SelectMgr_ViewerSelector::ActiveOwners (NCollection_List<Handle(SelectBasics_EntityOwner)>& theOwners) const
 889 {
 890   for (SelectMgr_MapOfObjectSensitivesIterator anIter (myMapOfObjectSensitives); anIter.More(); anIter.Next())
 891   {
 892     const NCollection_Handle<SelectMgr_SensitiveEntitySet>& anEntitySet = anIter.Value();
 893     Standard_Integer anEntitiesNb = anEntitySet->Size();
 894     for (Standard_Integer anIdx = 0; anIdx < anEntitiesNb; ++anIdx)
 895     {
 896       if (anEntitySet->GetSensitiveById (anIdx)->IsActiveForSelection())
 897       {
 898         theOwners.Append (anEntitySet->GetSensitiveById (anIdx)->BaseSensitive()->OwnerId());
 899       }
 900     }
 901   }
 902 }
 903
 904 //=======================================================================
 905 //function : AllowOverlapDetection
 906 //purpose  : Sets the detection type: if theIsToAllow is false,
 907 //           only fully included sensitives will be detected, otherwise
 908 //           the algorithm will mark both included and overlapped entities
 909 //           as matched
 910 //=======================================================================
 911 void SelectMgr_ViewerSelector::AllowOverlapDetection (const Standard_Boolean theIsToAllow)
 912 {
 913   mySelectingVolumeMgr.AllowOverlapDetection (theIsToAllow);
 914 }