OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity

0031716: Visualization, Select3D_SensitiveSet::matches() - avoid building BVH in case of full overlapping by the volume

Browse Source
This commit is contained in:
age 2020-08-18 10:08:06 +03:00 committed by bugmaster
parent 63e5cfcaab
commit f3269ef5f1
2 changed files with 134 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

194
src/Select3D/Select3D_SensitiveSet.cxx
View File

@ -78,6 +78,51 @@ namespace
}; };
} }
//=======================================================================
// function : processElements
// purpose :
//=======================================================================
Standard_Boolean Select3D_SensitiveSet::processElements (SelectBasics_SelectingVolumeManager& theMgr,
Standard_Integer theFirstElem,
Standard_Integer theLastElem,
Standard_Boolean theIsFullInside,
Standard_Boolean theToCheckAllInside,
SelectBasics_PickResult& thePickResult,
Standard_Integer& theMatchesNb)
{
SelectBasics_PickResult aPickResult;
for (Standard_Integer anIdx = theFirstElem; anIdx <= theLastElem; anIdx++)
{
if (!theMgr.IsOverlapAllowed()) // inclusion test
{
if (!elementIsInside (theMgr, anIdx, theIsFullInside))
{
if (theToCheckAllInside)
{
continue;
}
return Standard_False;
}
}
else // overlap test
{
if (!overlapsElement (aPickResult, theMgr, anIdx, theIsFullInside))
{
continue;
}
if (thePickResult.Depth() > aPickResult.Depth())
{
thePickResult = aPickResult;
myDetectedIdx = anIdx;
}
}
++theMatchesNb;
}
return Standard_True;
}
//======================================================================= //=======================================================================
// function : Matches // function : Matches
// purpose : // purpose :
@ -87,116 +132,113 @@ Standard_Boolean Select3D_SensitiveSet::matches (SelectBasics_SelectingVolumeMan
Standard_Boolean theToCheckAllInside) Standard_Boolean theToCheckAllInside)
{ {
myDetectedIdx = -1; myDetectedIdx = -1;
const BVH_Tree<Standard_Real, 3, BVH_BinaryTree>* aBVH = myContent.GetBVH().get();
if (myContent.Size() < 1 || !theMgr.Overlaps (aBVH->MinPoint (0), if (myContent.Size() < 1)
aBVH->MaxPoint (0)))
{ {
return Standard_False; return Standard_False;
} }
NodeInStack aStack[BVH_Constants_MaxTreeDepth]; const Select3D_BndBox3d& aGlobalBox = myContent.Box();
NodeInStack aNode; Standard_Boolean isFullInside = Standard_True;
Standard_Integer aHead = -1; if (!theMgr.Overlaps(aGlobalBox.CornerMin(),
aGlobalBox.CornerMax(),
&isFullInside))
{
return Standard_False;
}
Standard_Integer aMatchesNb = -1; Standard_Integer aMatchesNb = -1;
SelectBasics_PickResult aPickResult;
const bool toCheckFullInside = (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Point); const bool toCheckFullInside = (theMgr.GetActiveSelectionType() != SelectBasics_SelectingVolumeManager::Point);
for (;;) if (toCheckFullInside && isFullInside)
{ {
const BVH_Vec4i& aData = aBVH->NodeInfoBuffer()[aNode.Id]; Standard_Integer aSize = myContent.Size();
if (!processElements (theMgr, 0, aSize - 1, Standard_True, theToCheckAllInside, thePickResult, aMatchesNb))
if (aData.x() == 0) // is inner node
{ {
NodeInStack aLeft (aData.y(), toCheckFullInside), aRight(aData.z(), toCheckFullInside); return Standard_False;
Standard_Boolean toCheckLft = Standard_True, toCheckRgh = Standard_True; }
if (!aNode.IsFullInside) }
{ else
toCheckLft = theMgr.Overlaps (aBVH->MinPoint (aLeft.Id), aBVH->MaxPoint (aLeft.Id), toCheckFullInside ? &aLeft.IsFullInside : NULL); {
if (!toCheckLft) const BVH_Tree<Standard_Real, 3, BVH_BinaryTree>* aBVH = myContent.GetBVH().get();
{ NodeInStack aStack[BVH_Constants_MaxTreeDepth];
aLeft.IsFullInside = Standard_False; NodeInStack aNode;
}
toCheckRgh = theMgr.Overlaps (aBVH->MinPoint (aRight.Id), aBVH->MaxPoint (aRight.Id), toCheckFullInside ? &aRight.IsFullInside : NULL); Standard_Integer aHead = -1;
if (!toCheckRgh)
{
aRight.IsFullInside = Standard_False;
}
}
if (!theMgr.IsOverlapAllowed()) // inclusion test for (;;)
{
const BVH_Vec4i& aData = aBVH->NodeInfoBuffer()[aNode.Id];
if (aData.x() == 0) // is inner node
{ {
if (!theToCheckAllInside) NodeInStack aLeft (aData.y(), toCheckFullInside), aRight(aData.z(), toCheckFullInside);
Standard_Boolean toCheckLft = Standard_True, toCheckRgh = Standard_True;
if (!aNode.IsFullInside)
{ {
if (!toCheckLft || !toCheckRgh) toCheckLft = theMgr.Overlaps (aBVH->MinPoint (aLeft.Id), aBVH->MaxPoint (aLeft.Id), toCheckFullInside ? &aLeft.IsFullInside : NULL);
if (!toCheckLft)
{ {
return Standard_False; // no inclusion aLeft.IsFullInside = Standard_False;
} }
// skip extra checks toCheckRgh = theMgr.Overlaps (aBVH->MinPoint (aRight.Id), aBVH->MaxPoint (aRight.Id), toCheckFullInside ? &aRight.IsFullInside : NULL);
toCheckLft &= !aLeft.IsFullInside; if (!toCheckRgh)
toCheckRgh &= !aRight.IsFullInside; {
aRight.IsFullInside = Standard_False;
}
} }
}
if (toCheckLft || toCheckRgh) if (!theMgr.IsOverlapAllowed()) // inclusion test
{
aNode = toCheckLft ? aLeft : aRight;
if (toCheckLft && toCheckRgh)
{ {
aStack[++aHead] = aRight; if (!theToCheckAllInside)
{
if (!toCheckLft || !toCheckRgh)
{
return Standard_False; // no inclusion
}
// skip extra checks
toCheckLft &= !aLeft.IsFullInside;
toCheckRgh &= !aRight.IsFullInside;
}
}
if (toCheckLft || toCheckRgh)
{
aNode = toCheckLft ? aLeft : aRight;
if (toCheckLft && toCheckRgh)
{
aStack[++aHead] = aRight;
}
}
else
{
if (aHead < 0)
break;
aNode = aStack[aHead--];
} }
} }
else else
{ {
if (!processElements (theMgr, aData.y(), aData.z(), aNode.IsFullInside, theToCheckAllInside, thePickResult, aMatchesNb))
{
return Standard_False;
}
if (aHead < 0) if (aHead < 0)
break; break;
aNode = aStack[aHead--]; aNode = aStack[aHead--];
} }
} }
else
{
for (Standard_Integer anElemIdx = aData.y(); anElemIdx <= aData.z(); ++anElemIdx)
{
if (!theMgr.IsOverlapAllowed()) // inclusion test
{
if (!elementIsInside (theMgr, anElemIdx, aNode.IsFullInside))
{
if (theToCheckAllInside)
{
continue;
}
return Standard_False;
}
}
else // overlap test
{
if (!overlapsElement (aPickResult, theMgr, anElemIdx, aNode.IsFullInside))
{
continue;
}
if (thePickResult.Depth() > aPickResult.Depth())
{
thePickResult = aPickResult;
myDetectedIdx = anElemIdx;
}
}
++aMatchesNb;
}
if (aHead < 0)
break;
aNode = aStack[aHead--];
}
} }
if (aMatchesNb != -1) if (aMatchesNb != -1)
{ {
thePickResult.SetDistToGeomCenter(distanceToCOG(theMgr)); thePickResult.SetDistToGeomCenter (distanceToCOG (theMgr));
} }
return aMatchesNb != -1 return aMatchesNb != -1

16
src/Select3D/Select3D_SensitiveSet.hxx
View File

@ -135,6 +135,22 @@ protected:
//! Calculates distance from the 3d projection of used-picked screen point to center of the geometry //! Calculates distance from the 3d projection of used-picked screen point to center of the geometry
virtual Standard_Real distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr) = 0; virtual Standard_Real distanceToCOG (SelectBasics_SelectingVolumeManager& theMgr) = 0;
//! Process elements overlapped by the selection volume
//! @param theMgr selection manager
//! @param theFirstElem index of the first element
//! @param theLastElem index of the last element
//! @param theIsFullInside when TRUE indicates that entire BVH node is already inside selection volume
//! @param thePickResult [OUT] picking result (for picking by ray)
//! @param theMatchesNb [OUT] number of processed elements
//! @return FALSE if some element is outside the selection volume (if IsOverlapAllowed is FALSE); TRUE otherwise
Standard_EXPORT Standard_Boolean processElements (SelectBasics_SelectingVolumeManager& theMgr,
Standard_Integer theFirstElem,
Standard_Integer theLastElem,
Standard_Boolean theIsFullInside,
Standard_Boolean theToCheckAllInside,
SelectBasics_PickResult& thePickResult,
Standard_Integer& theMatchesNb);
protected: protected:
//! The purpose of this class is to provide a link between BVH_PrimitiveSet //! The purpose of this class is to provide a link between BVH_PrimitiveSet