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

0029158: Visualization - suspicious pass-through of case labels in switch statements

Browse Source 
MeshVS_Mesh::ComputeSelection() - fixed incorrect fall-through
from MeshVS_SMF_Mesh to MeshVS_SMF_Group.
This commit is contained in:
kgv 2017-09-13 17:12:57 +02:00 committed by bugmaster
parent fc8918ad91
commit 022d142b24
1 changed files with 282 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

360
src/MeshVS/MeshVS_Mesh.cxx
View File

@ -246,100 +246,105 @@ void MeshVS_Mesh::ComputeSelection ( const Handle(SelectMgr_Selection)& theSelec
const Standard_Integer theMode) const Standard_Integer theMode)
{ {
OSD_Timer gTimer; OSD_Timer gTimer;
Standard_Boolean toShowComputeSelectionTime = Standard_True;
Standard_Boolean ShowComputeSelectionTime = Standard_True; myCurrentDrawer->GetBoolean( MeshVS_DA_ComputeSelectionTime, toShowComputeSelectionTime);
myCurrentDrawer->GetBoolean( MeshVS_DA_ComputeSelectionTime, ShowComputeSelectionTime ); if (toShowComputeSelectionTime)
if ( ShowComputeSelectionTime )
{ {
gTimer.Reset(); gTimer.Reset();
gTimer.Start(); gTimer.Start();
} }
Standard_Integer aMaxFaceNodes; Standard_Integer aMaxFaceNodes = 0;
Handle(MeshVS_DataSource) aSource = GetDataSource(); Handle(MeshVS_DataSource) aSource = GetDataSource();
if (aSource.IsNull()
if ( aSource.IsNull() || myCurrentDrawer.IsNull() || !myCurrentDrawer->GetInteger || myCurrentDrawer.IsNull()
( MeshVS_DA_MaxFaceNodes, aMaxFaceNodes ) || aMaxFaceNodes<=0 ) || !myCurrentDrawer->GetInteger (MeshVS_DA_MaxFaceNodes, aMaxFaceNodes)
|| aMaxFaceNodes <= 0)
{
return; return;
}
const Standard_Integer aMode = HasDisplayMode() ? DisplayMode() : DefaultDisplayMode();
if (myHilighter.IsNull()
|| (aMode & MeshVS_DMF_OCCMask) == 0)
{
return;
}
// Make two array aliases pointing to the same memory:
// - TColStd_Array1OfReal for getting values from MeshVS_DataSource interface
// - array of gp_Pnt for convenient work with array of points
MeshVS_Buffer aCoordsBuf (3 * aMaxFaceNodes * sizeof(Standard_Real)); MeshVS_Buffer aCoordsBuf (3 * aMaxFaceNodes * sizeof(Standard_Real));
TColStd_Array1OfReal aCoords (aCoordsBuf, 1, 3*aMaxFaceNodes); NCollection_Array1<gp_Pnt> aPntArray (aCoordsBuf, 1, aMaxFaceNodes);
Standard_Integer NbNodes; TColStd_Array1OfReal aPntArrayAsCoordArray (aCoordsBuf, 1, 3 * aMaxFaceNodes);
MeshVS_EntityType aType;
Standard_Address anAddr;
TColStd_MapIteratorOfPackedMapOfInteger anIter;
Standard_Real x, y, z;
Standard_Integer aMode = HasDisplayMode() ? DisplayMode() : DefaultDisplayMode();
if ( myHilighter.IsNull() || ( aMode & MeshVS_DMF_OCCMask ) == 0 )
return;
const TColStd_PackedMapOfInteger& anAllNodesMap = aSource->GetAllNodes(); const TColStd_PackedMapOfInteger& anAllNodesMap = aSource->GetAllNodes();
const TColStd_PackedMapOfInteger& anAllElementsMap = aSource->GetAllElements(); const TColStd_PackedMapOfInteger& anAllElementsMap = aSource->GetAllElements();
//agv Standard_Integer i; if (aSource->IsAdvancedSelectionEnabled())
{
// skt: advanced mesh selection
if( aSource->IsAdvancedSelectionEnabled() ) {
Handle(MeshVS_MeshOwner) anOwner; Handle(MeshVS_MeshOwner) anOwner;
// Get the owner if it is already created for (MeshVS_DataMapIteratorOfDataMapOfIntegerOwner anIt (GetOwnerMaps (Standard_False)); anIt.More(); anIt.Next())
MeshVS_DataMapIteratorOfDataMapOfIntegerOwner anIt( GetOwnerMaps( Standard_False ) );
for( ; anIt.More(); anIt.Next() )
{ {
anOwner = Handle(MeshVS_MeshOwner)::DownCast (anIt.Value()); anOwner = Handle(MeshVS_MeshOwner)::DownCast (anIt.Value());
// clear selected entities
if (!anOwner.IsNull()) if (!anOwner.IsNull())
{
// get the owner if it is already created
break; break;
} }
}
if (anOwner.IsNull()) if (anOwner.IsNull())
// Create one owner for the whole mesh and for all selection modes {
// create one owner for the whole mesh and for all selection modes
anOwner = new MeshVS_MeshOwner (this, aSource, 5); anOwner = new MeshVS_MeshOwner (this, aSource, 5);
}
// Save the owner. It will be available via GetOwnerMaps method // Save the owner. It will be available via GetOwnerMaps method
if (!myMeshOwners.IsBound (1)) if (!myMeshOwners.IsBound (1))
{
myMeshOwners.Bind (1, anOwner); myMeshOwners.Bind (1, anOwner);
// Create one sensitive entity. It should detect mesh entities correspondingly }
// to selection mode // Create one sensitive entity. It should detect mesh entities correspondingly to selection mode
Handle(MeshVS_SensitiveMesh) aSensMesh = new MeshVS_SensitiveMesh (anOwner, theMode); Handle(MeshVS_SensitiveMesh) aSensMesh = new MeshVS_SensitiveMesh (anOwner, theMode);
theSelection->Add (aSensMesh); theSelection->Add (aSensMesh);
} }
else { else
{
switch (theMode) switch (theMode)
{ {
case MeshVS_SMF_Node: // Nodes case MeshVS_SMF_Node:
{
myNodeOwners.Clear(); myNodeOwners.Clear();
for (TColStd_MapIteratorOfPackedMapOfInteger anIter (anAllNodesMap); anIter.More(); anIter.Next())
for ( anIter.Initialize( anAllNodesMap ); anIter.More(); anIter.Next() ) {
const Standard_Integer aKey = anIter.Key();
Standard_Integer aNbNodes = 0;
MeshVS_EntityType aType = MeshVS_ET_NONE;
if (!myDataSource->GetGeom (aKey, Standard_False, aPntArrayAsCoordArray, aNbNodes, aType))
{ {
Standard_Integer aKey = anIter.Key();
if ( !myDataSource->GetGeom ( aKey, Standard_False, aCoords, NbNodes, aType ) )
continue; continue;
}
anAddr = myDataSource->GetAddr ( aKey, Standard_False ); Standard_Address anAddr = myDataSource->GetAddr (aKey, Standard_False);
Handle(MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner (this, aKey, anAddr, aType, 5);
Handle (MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner
( this, aKey, anAddr, aType, 5 );
myNodeOwners.Bind (aKey, anOwner); myNodeOwners.Bind (aKey, anOwner);
if (IsSelectableNode (aKey)) if (IsSelectableNode (aKey))
{ {
x = aCoords(1); Handle(Select3D_SensitivePoint) aPoint = new Select3D_SensitivePoint (anOwner, aPntArray.First());
y = aCoords(2);
z = aCoords(3);
Handle (Select3D_SensitivePoint) aPoint = new Select3D_SensitivePoint
( anOwner, gp_Pnt (x, y, z) );
theSelection->Add (aPoint); theSelection->Add (aPoint);
} }
else else
{
theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner)); theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner));
} }
}
break; break;
}
case MeshVS_SMF_Mesh: case MeshVS_SMF_Mesh:
{
if (myWholeMeshOwner.IsNull()) if (myWholeMeshOwner.IsNull())
{
myWholeMeshOwner = new SelectMgr_EntityOwner (this); myWholeMeshOwner = new SelectMgr_EntityOwner (this);
}
switch (mySelectionMethod) switch (mySelectionMethod)
{ {
@ -348,14 +353,16 @@ void MeshVS_Mesh::ComputeSelection ( const Handle(SelectMgr_Selection)& theSelec
Bnd_Box aBndBox; Bnd_Box aBndBox;
BoundingBox (aBndBox); BoundingBox (aBndBox);
if (!aBndBox.IsVoid()) if (!aBndBox.IsVoid())
{
theSelection->Add (new Select3D_SensitiveBox (myWholeMeshOwner, aBndBox)); theSelection->Add (new Select3D_SensitiveBox (myWholeMeshOwner, aBndBox));
} }
break; break;
}
case MeshVS_MSM_NODES: case MeshVS_MSM_NODES:
{ {
theSelection->Add (new MeshVS_CommonSensitiveEntity (myWholeMeshOwner, this, MeshVS_MSM_NODES)); theSelection->Add (new MeshVS_CommonSensitiveEntity (myWholeMeshOwner, this, MeshVS_MSM_NODES));
}
break; break;
}
case MeshVS_MSM_PRECISE: case MeshVS_MSM_PRECISE:
{ {
theSelection->Add (new MeshVS_CommonSensitiveEntity (myWholeMeshOwner, this, MeshVS_MSM_PRECISE)); theSelection->Add (new MeshVS_CommonSensitiveEntity (myWholeMeshOwner, this, MeshVS_MSM_PRECISE));
@ -366,39 +373,41 @@ void MeshVS_Mesh::ComputeSelection ( const Handle(SelectMgr_Selection)& theSelec
scanFacesForSharedNodes (anAllElementsMap, aMaxFaceNodes, aSharedNodes); scanFacesForSharedNodes (anAllElementsMap, aMaxFaceNodes, aSharedNodes);
// create sensitive entities for free edges, if there are any // create sensitive entities for free edges, if there are any
Standard_Integer aNbNodes = 0;
MeshVS_EntityType aType = MeshVS_ET_NONE;
for (TColStd_MapIteratorOfPackedMapOfInteger anElemIter (anAllElementsMap); anElemIter.More(); anElemIter.Next()) for (TColStd_MapIteratorOfPackedMapOfInteger anElemIter (anAllElementsMap); anElemIter.More(); anElemIter.Next())
{ {
const Standard_Integer anElemIdx = anElemIter.Key(); const Standard_Integer anElemIdx = anElemIter.Key();
if (IsSelectableElem (anElemIdx)
if (IsSelectableElem (anElemIdx) && && myDataSource->GetGeomType (anElemIdx, Standard_True, aType)
myDataSource->GetGeomType (anElemIdx, Standard_True, aType) && && aType == MeshVS_ET_Link)
aType == MeshVS_ET_Link) {
myDataSource->GetGeom (anElemIdx, Standard_True, aPntArrayAsCoordArray, aNbNodes, aType);
if (aNbNodes == 0)
{ {
myDataSource->GetGeom (anElemIdx, Standard_True, aCoords, NbNodes, aType);
if (NbNodes == 0)
continue; continue;
}
MeshVS_Buffer aNodesBuf (NbNodes * sizeof (Standard_Integer)); MeshVS_Buffer aNodesBuf (aNbNodes * sizeof(Standard_Integer));
TColStd_Array1OfInteger aElemNodes (aNodesBuf, 1, NbNodes); TColStd_Array1OfInteger aElemNodes (aNodesBuf, 1, aNbNodes);
if (!myDataSource->GetNodesByElement (anElemIdx, aElemNodes, NbNodes)) if (!myDataSource->GetNodesByElement (anElemIdx, aElemNodes, aNbNodes))
{
continue; continue;
}
MeshVS_Buffer aPntsBuf (NbNodes * 3 * sizeof (Standard_Real)); MeshVS_Buffer aPntsBuf (aNbNodes * 3 * sizeof(Standard_Real));
TColgp_Array1OfPnt aLinkPnts (aPntsBuf, 1, NbNodes); TColgp_Array1OfPnt aLinkPnts (aPntsBuf, 1, aNbNodes);
Standard_Boolean isVertsShared = Standard_True; Standard_Boolean isVertsShared = Standard_True;
for (Standard_Integer aPntIdx = 1; aPntIdx <= NbNodes; ++aPntIdx) for (Standard_Integer aPntIdx = 1; aPntIdx <= aNbNodes; ++aPntIdx)
{ {
aLinkPnts (aPntIdx) = gp_Pnt (aCoords (3 * aPntIdx - 2), aLinkPnts (aPntIdx) = aPntArray.Value (aPntIdx);
aCoords (3 * aPntIdx - 1),
aCoords (3 * aPntIdx));
isVertsShared = isVertsShared && aSharedNodes.Contains (aElemNodes (aPntIdx)); isVertsShared = isVertsShared && aSharedNodes.Contains (aElemNodes (aPntIdx));
aSharedNodes.Add (aElemNodes (aPntIdx)); aSharedNodes.Add (aElemNodes (aPntIdx));
} }
if (!isVertsShared) if (!isVertsShared)
{ {
Handle(Select3D_SensitiveEntity) aLinkEnt Handle(Select3D_SensitiveEntity) aLinkEnt = new Select3D_SensitiveSegment (myWholeMeshOwner, aLinkPnts.Value (1), aLinkPnts.Value (2));
= new Select3D_SensitiveSegment (myWholeMeshOwner, aLinkPnts.Value (1), aLinkPnts.Value (2));
theSelection->Add (aLinkEnt); theSelection->Add (aLinkEnt);
} }
} }
@ -408,19 +417,19 @@ void MeshVS_Mesh::ComputeSelection ( const Handle(SelectMgr_Selection)& theSelec
for (TColStd_MapIteratorOfPackedMapOfInteger aNodesIter (anAllNodesMap); aNodesIter.More(); aNodesIter.Next()) for (TColStd_MapIteratorOfPackedMapOfInteger aNodesIter (anAllNodesMap); aNodesIter.More(); aNodesIter.Next())
{ {
const Standard_Integer aNodeIdx = aNodesIter.Key(); const Standard_Integer aNodeIdx = aNodesIter.Key();
if (IsSelectableNode (aNodeIdx) && if (IsSelectableNode (aNodeIdx)
myDataSource->GetGeom (aNodeIdx, Standard_False, aCoords, NbNodes, aType) && && myDataSource->GetGeom (aNodeIdx, Standard_False, aPntArrayAsCoordArray, aNbNodes, aType)
!aSharedNodes.Contains (aNodeIdx)) && !aSharedNodes.Contains (aNodeIdx))
{ {
Handle(Select3D_SensitiveEntity) aNodeEnt Handle(Select3D_SensitiveEntity) aNodeEnt = new Select3D_SensitivePoint (myWholeMeshOwner, aPntArray.First());
= new Select3D_SensitivePoint (myWholeMeshOwner, gp_Pnt ( aCoords(1), aCoords(2), aCoords(3)));
theSelection->Add (aNodeEnt); theSelection->Add (aNodeEnt);
} }
} }
} }
break; break;
} }
break;
}
case MeshVS_SMF_Group: case MeshVS_SMF_Group:
{ {
myGroupOwners.Clear(); myGroupOwners.Clear();
@ -429,99 +438,88 @@ void MeshVS_Mesh::ComputeSelection ( const Handle(SelectMgr_Selection)& theSelec
aSource->GetAllGroups (anAllGroupsMap); aSource->GetAllGroups (anAllGroupsMap);
Handle(MeshVS_HArray1OfSequenceOfInteger) aTopo; Handle(MeshVS_HArray1OfSequenceOfInteger) aTopo;
for (TColStd_MapIteratorOfPackedMapOfInteger anIter (anAllGroupsMap); anIter.More(); anIter.Next())
for ( anIter.Initialize( anAllGroupsMap ); anIter.More(); anIter.Next() )
{ {
Standard_Integer aKeyGroup = anIter.Key(); const Standard_Integer aKeyGroup = anIter.Key();
MeshVS_EntityType aGroupType = MeshVS_ET_NONE;
MeshVS_EntityType aGroupType;
TColStd_PackedMapOfInteger aGroupMap; TColStd_PackedMapOfInteger aGroupMap;
if (!myDataSource->GetGroup (aKeyGroup, aGroupType, aGroupMap)) if (!myDataSource->GetGroup (aKeyGroup, aGroupType, aGroupMap))
{
continue; continue;
}
anAddr = myDataSource->GetGroupAddr ( aKeyGroup ); Standard_Address anAddr = myDataSource->GetGroupAddr (aKeyGroup);
Standard_Integer aPrior = 0; Standard_Integer aPrior = 0;
switch (aGroupType)
{
case MeshVS_ET_Volume: aPrior = 1; break;
case MeshVS_ET_Face: aPrior = 2; break;
case MeshVS_ET_Link: aPrior = 3; break;
case MeshVS_ET_0D: aPrior = 4; break;
case MeshVS_ET_Node: aPrior = 5; break;
default: break;
}
if( aGroupType == MeshVS_ET_Volume ) Handle(MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner (this, aKeyGroup, anAddr, aGroupType, aPrior, Standard_True);
aPrior = 1;
if ( aGroupType == MeshVS_ET_Face )
aPrior = 2;
else if ( aGroupType == MeshVS_ET_Link )
aPrior = 3;
else if ( aGroupType == MeshVS_ET_0D )
aPrior = 4;
else if ( aGroupType == MeshVS_ET_Node )
aPrior = 5;
Handle (MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner
( this, aKeyGroup, anAddr, aGroupType, aPrior, Standard_True );
myGroupOwners.Bind (aKeyGroup, anOwner); myGroupOwners.Bind (aKeyGroup, anOwner);
Standard_Boolean added = Standard_False; Standard_Boolean added = Standard_False;
for ( TColStd_MapIteratorOfPackedMapOfInteger anIterMG (aGroupMap); Standard_Integer aNbNodes = 0;
anIterMG.More(); anIterMG.Next() ) MeshVS_EntityType aType = MeshVS_ET_NONE;
for (TColStd_MapIteratorOfPackedMapOfInteger anIterMG (aGroupMap); anIterMG.More(); anIterMG.Next())
{ {
Standard_Integer aKey = anIterMG.Key(); Standard_Integer aKey = anIterMG.Key();
if ( aGroupType == MeshVS_ET_Node ) { if (aGroupType == MeshVS_ET_Node)
if( myDataSource->GetGeom( aKey, Standard_False, aCoords, NbNodes, aType ) && {
IsSelectableNode/*!IsHiddenNode*/( aKey ) ) { if (myDataSource->GetGeom (aKey, Standard_False, aPntArrayAsCoordArray, aNbNodes, aType)
theSelection->Add( new Select3D_SensitivePoint( anOwner, gp_Pnt ( aCoords(1), aCoords(2), aCoords(3) ) ) ); && IsSelectableNode/*!IsHiddenNode*/(aKey))
{
theSelection->Add (new Select3D_SensitivePoint (anOwner, aPntArray.First ()));
added = Standard_True; added = Standard_True;
} }
} }
else if ( myDataSource->GetGeomType ( aKey, Standard_True, aType ) && else if (myDataSource->GetGeomType (aKey, Standard_True, aType)
IsSelectableElem/*!IsHiddenElem*/( aKey ) ) { && IsSelectableElem/*!IsHiddenElem*/(aKey))
myDataSource->GetGeom ( aKey, Standard_True, aCoords, NbNodes, aType );
TColgp_Array1OfPnt anArr( 1, NbNodes );
for ( Standard_Integer i=1; i<=NbNodes; i++ )
{ {
x = aCoords(3*i-2); myDataSource->GetGeom (aKey, Standard_True, aPntArrayAsCoordArray, aNbNodes, aType);
y = aCoords(3*i-1); if (aType == MeshVS_ET_Face && aNbNodes > 0) // Faces: 2D-elements
z = aCoords(3*i);
anArr.SetValue ( i, gp_Pnt ( x, y, z ) );
}
if ( aType == MeshVS_ET_Face && NbNodes > 0 ) // Faces: 2D-elements
{ {
Handle(Select3D_SensitiveEntity) aSensFace; Handle(Select3D_SensitiveEntity) aSensFace;
if (NbNodes == 3) if (aNbNodes == 3)
{ {
aSensFace = new Select3D_SensitiveTriangle (anOwner, aSensFace = new Select3D_SensitiveTriangle (anOwner,
anArr.Value (1), anArr.Value (2), anArr.Value (3), aPntArray.Value (1), aPntArray.Value (2), aPntArray.Value (3),
Select3D_TOS_INTERIOR); Select3D_TOS_INTERIOR);
} }
else if (NbNodes == 4) else if (aNbNodes == 4)
{ {
aSensFace = new MeshVS_SensitiveQuad (anOwner, anArr); aSensFace = new MeshVS_SensitiveQuad (anOwner, aPntArray);
} }
else else
{ {
aSensFace = new MeshVS_SensitiveFace (anOwner, anArr); aSensFace = new MeshVS_SensitiveFace (anOwner, aPntArray);
} }
theSelection->Add (aSensFace); theSelection->Add (aSensFace);
added = Standard_True; added = Standard_True;
} }
else if ( aType == MeshVS_ET_Link && NbNodes > 0 ) // Links: 1D-elements else if (aType == MeshVS_ET_Link && aNbNodes > 0) // Links: 1D-elements
{ {
Handle (MeshVS_SensitiveSegment) aSeg = new MeshVS_SensitiveSegment Handle (MeshVS_SensitiveSegment) aSeg = new MeshVS_SensitiveSegment (anOwner, aPntArray (1), aPntArray (2));
( anOwner, anArr(1), anArr(2) );
theSelection->Add (aSeg); theSelection->Add (aSeg);
added = Standard_True; added = Standard_True;
} }
else if( aType == MeshVS_ET_Volume && aSource->Get3DGeom( aKey, NbNodes, aTopo ) ) else if (aType == MeshVS_ET_Volume
&& aSource->Get3DGeom (aKey, aNbNodes, aTopo))
{ {
Handle( MeshVS_SensitivePolyhedron ) aPolyhedron = Handle(MeshVS_SensitivePolyhedron) aPolyhedron = new MeshVS_SensitivePolyhedron (anOwner, aPntArray, aTopo);
new MeshVS_SensitivePolyhedron( anOwner, anArr, aTopo );
theSelection->Add (aPolyhedron); theSelection->Add (aPolyhedron);
added = Standard_True; added = Standard_True;
} }
else //if ( aType == MeshVS_ET_0D ) // Custom : not only 0D-elements !!! else //if ( aType == MeshVS_ET_0D ) // Custom : not only 0D-elements !!!
{ {
Handle (SelectBasics_SensitiveEntity) anEnt = Handle(SelectBasics_SensitiveEntity) anEnt = myHilighter->CustomSensitiveEntity (anOwner, aKey);
myHilighter->CustomSensitiveEntity ( anOwner, aKey ); if (!anEnt.IsNull())
if (!anEnt.IsNull()) { {
theSelection->Add (anEnt); theSelection->Add (anEnt);
added = Standard_True; added = Standard_True;
} }
@ -529,104 +527,98 @@ void MeshVS_Mesh::ComputeSelection ( const Handle(SelectMgr_Selection)& theSelec
} }
} }
if (!added) if (!added)
{
theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner)); theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner));
} }
} }
break; break;
}
default: // all residuary modes default: // all residuary modes
{ {
Handle(MeshVS_HArray1OfSequenceOfInteger) aTopo; Handle(MeshVS_HArray1OfSequenceOfInteger) aTopo;
myElementOwners.Clear(); myElementOwners.Clear();
MeshVS_DataMapOfIntegerOwner* CurMap = &my0DOwners; MeshVS_DataMapOfIntegerOwner* aCurMap = &my0DOwners;
if (theMode == MeshVS_ET_Link) if (theMode == MeshVS_ET_Link)
CurMap = &myLinkOwners; {
aCurMap = &myLinkOwners;
}
else if (theMode == MeshVS_ET_Face) else if (theMode == MeshVS_ET_Face)
CurMap = &myFaceOwners; {
aCurMap = &myFaceOwners;
}
else if (theMode == MeshVS_ET_Volume) else if (theMode == MeshVS_ET_Volume)
CurMap = &myVolumeOwners; {
aCurMap = &myVolumeOwners;
}
aCurMap->Clear();
CurMap->Clear(); Standard_Integer aNbNodes = 0;
MeshVS_EntityType aType = MeshVS_ET_NONE;
for (TColStd_MapIteratorOfPackedMapOfInteger anIterMV (anAllElementsMap); for (TColStd_MapIteratorOfPackedMapOfInteger anIterMV (anAllElementsMap); anIterMV.More(); anIterMV.Next())
anIterMV.More(); anIterMV.Next() )
{ {
Standard_Integer aKey = anIterMV.Key(); Standard_Integer aKey = anIterMV.Key();
if (myDataSource->GetGeomType (aKey, Standard_True, aType)
if ( myDataSource->GetGeomType ( aKey, Standard_True, aType ) && theMode == aType ) && theMode == aType)
{ {
myDataSource->GetGeom ( aKey, Standard_True, aCoords, NbNodes, aType ); myDataSource->GetGeom (aKey, Standard_True, aPntArrayAsCoordArray, aNbNodes, aType);
anAddr = myDataSource->GetAddr ( aKey, Standard_True ); Standard_Address anAddr = myDataSource->GetAddr (aKey, Standard_True);
Standard_Integer aPrior = 0; Standard_Integer aPrior = 0;
switch (aType)
{
case MeshVS_ET_Volume: aPrior = 1; break;
case MeshVS_ET_Face: aPrior = 2; break;
case MeshVS_ET_Link: aPrior = 3; break;
case MeshVS_ET_0D: aPrior = 4; break;
default: break;
}
if( aType == MeshVS_ET_Volume ) Handle(MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner (this, aKey, anAddr, aType, aPrior);
aPrior = 1; aCurMap->Bind (aKey, anOwner);
if ( aType == MeshVS_ET_Face )
aPrior = 2;
else if ( aType == MeshVS_ET_Link )
aPrior = 3;
else if ( aType == MeshVS_ET_0D )
aPrior = 4;
Handle (MeshVS_MeshEntityOwner) anOwner = new MeshVS_MeshEntityOwner
( this, aKey, anAddr, aType, aPrior );
CurMap->Bind ( aKey, anOwner );
if (IsSelectableElem (aKey)) // The element is selectable if (IsSelectableElem (aKey)) // The element is selectable
{ {
TColgp_Array1OfPnt anArr( 1, NbNodes ); if (aType == MeshVS_ET_Face && aNbNodes > 0) // Faces: 2D-elements
for ( Standard_Integer i=1; i<=NbNodes; i++ )
{
x = aCoords(3*i-2);
y = aCoords(3*i-1);
z = aCoords(3*i);
anArr.SetValue ( i, gp_Pnt ( x, y, z ) );
}
if ( aType == MeshVS_ET_Face && NbNodes > 0 ) // Faces: 2D-elements
{ {
Handle(Select3D_SensitiveEntity) aSensFace; Handle(Select3D_SensitiveEntity) aSensFace;
if (NbNodes == 3) if (aNbNodes == 3)
{ {
aSensFace = new Select3D_SensitiveTriangle (anOwner, aSensFace = new Select3D_SensitiveTriangle (anOwner,
anArr.Value (1), anArr.Value (2), anArr.Value (3), aPntArray.Value (1), aPntArray.Value (2), aPntArray.Value (3),
Select3D_TOS_INTERIOR); Select3D_TOS_INTERIOR);
} }
else if (NbNodes == 4) else if (aNbNodes == 4)
{ {
aSensFace = new MeshVS_SensitiveQuad (anOwner, anArr); aSensFace = new MeshVS_SensitiveQuad (anOwner, aPntArray);
} }
else else
{ {
aSensFace = new MeshVS_SensitiveFace (anOwner, anArr); aSensFace = new MeshVS_SensitiveFace (anOwner, aPntArray);
} }
theSelection->Add (aSensFace); theSelection->Add (aSensFace);
} }
else if ( aType == MeshVS_ET_Link && NbNodes > 0 ) // Links: 1D-elements else if (aType == MeshVS_ET_Link && aNbNodes > 0) // Links: 1D-elements
{ {
Handle (MeshVS_SensitiveSegment) aSeg = new MeshVS_SensitiveSegment Handle(MeshVS_SensitiveSegment) aSeg = new MeshVS_SensitiveSegment (anOwner, aPntArray (1), aPntArray (2));
( anOwner, anArr(1), anArr(2) );
theSelection->Add (aSeg); theSelection->Add (aSeg);
} }
else if( aType == MeshVS_ET_Volume && aSource->Get3DGeom( aKey, NbNodes, aTopo ) ) else if (aType == MeshVS_ET_Volume
&& aSource->Get3DGeom (aKey, aNbNodes, aTopo))
{ {
Handle( MeshVS_SensitivePolyhedron ) aPolyhedron = Handle(MeshVS_SensitivePolyhedron) aPolyhedron = new MeshVS_SensitivePolyhedron (anOwner, aPntArray, aTopo);
new MeshVS_SensitivePolyhedron( anOwner, anArr, aTopo );
theSelection->Add (aPolyhedron); theSelection->Add (aPolyhedron);
} }
else //if ( aType == MeshVS_ET_0D ) // Custom : not only 0D-elements !!! else //if ( aType == MeshVS_ET_0D ) // Custom : not only 0D-elements !!!
{ {
Handle (SelectBasics_SensitiveEntity) anEnt = Handle(SelectBasics_SensitiveEntity) anEnt = myHilighter->CustomSensitiveEntity (anOwner, aKey);
myHilighter->CustomSensitiveEntity ( anOwner, aKey );
if (!anEnt.IsNull()) if (!anEnt.IsNull())
{
theSelection->Add (anEnt); theSelection->Add (anEnt);
} }
} }
}
else else
{
theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner)); theSelection->Add (new MeshVS_DummySensitiveEntity (anOwner));
} }
} }
@ -634,18 +626,18 @@ void MeshVS_Mesh::ComputeSelection ( const Handle(SelectMgr_Selection)& theSelec
break; break;
} }
} }
}
StdSelect_BRepSelectionTool::PreBuildBVH (theSelection); StdSelect_BRepSelectionTool::PreBuildBVH (theSelection);
if ( ShowComputeSelectionTime ) if (toShowComputeSelectionTime)
{ {
Standard_Real sec, cpu; Standard_Real sec, cpu;
Standard_Integer min, hour; Standard_Integer min, hour;
gTimer.Show (sec, min, hour, cpu); gTimer.Show (sec, min, hour, cpu);
cout << "SelectionMode : " << theMode << endl; std::cout << "SelectionMode : " << theMode << "\n";
cout << "Compute selection: " << sec << " sec" << endl; std::cout << "Compute selection: " << sec << " sec\n";
cout << "Compute selection CPU : " << cpu << " sec" << endl << endl; std::cout << "Compute selection CPU : " << cpu << " sec\n\n";
gTimer.Stop(); gTimer.Stop();
} }
} }