Merge pull request #162 from LIHPC-Computational-Geometry/sheet_and_chord_selection

Sheet and chord selection

Author: lelandaisb

Docs/pages/raccourcis.rst

@@ -90,7 +90,10 @@ suivants :
 
 -  **Sélection** d’une entité : touche **P** (ou **clic gauche**
    souris). Possibilité d’étendre la sélection en pressant simultanément
-   la touche **CTRL**.
+   la touche **CTRL**. La combinaison **ALT+clic gauche** permet la sélection
+   de feuillets en fonction du filtre de sélection appliqué. La combinaison
+   **SHIFT+clic gauche** permet la sélection de corde en fonction du filtre
+   de sélection appliqué.
 
    Il est possible d'annuler la dernière opération de sélection effectuée : combinaison de touches **SHIFT-Z**
 

src/Core/Group/GroupManager.cpp

@@ -320,10 +320,10 @@ Group0D* GroupManager::getGroup0D(const std::string& gr_name, const bool excepti
     return gr;
 }
 /*----------------------------------------------------------------------------*/
-void GroupManager::getGroups(std::vector<GroupEntity*>& grp, Utils::SelectionManager::DIM dimensions, const bool onlyLive) const
+void GroupManager::getGroups(std::vector<GroupEntity*>& grp, Internal::SelectionManager::DIM dimensions, const bool onlyLive) const
 {
 	for (int i = 0; i < 4; i++){
-		const Utils::SelectionManager::DIM dim = Utils::SelectionManager::dimensionToDimensions(i);
+		const Internal::SelectionManager::DIM dim = Internal::SelectionManager::dimensionToDimensions(i);
 		if (0 == (dimensions&dim))
 			continue;
 		switch (i)

src/Core/Internal/Context.cpp

@@ -344,8 +344,8 @@ Context::Context(const std::string& name, bool withStdOutputs)
 		Mgx3D::Utils::GraphicalRepresentationFactoryIfc::setInstance (
 				new Mgx3D::Utils::DefaultGraphicalRepresentationFactory ( ));
 
-	Utils::SelectionManager*	selectionManager	=
-		new Utils::SelectionManager (createName ("SelectionManager"), getLogStream ( ));
+	Internal::SelectionManager*	selectionManager	=
+		new Internal::SelectionManager (createName ("SelectionManager"), getLogStream ( ));
 	m_selection_manager	= selectionManager;
 	Utils::CommandManager*	commandManager	=
 					new Utils::CommandManager (createName ("CommandManager"));
@@ -867,19 +867,19 @@ Mgx3D::Utils::CommandManager& Context::getLocalCommandManager()
     return *manager;
 }
 /*----------------------------------------------------------------------------*/
-Mgx3D::Utils::SelectionManager& Context::getSelectionManager ( )
+Mgx3D::Internal::SelectionManager& Context::getSelectionManager ( )
 {
 	CHECK_NULL_PTR_ERROR (m_selection_manager)
 	return *m_selection_manager;
 }
 /*----------------------------------------------------------------------------*/
-const Mgx3D::Utils::SelectionManager& Context::getSelectionManager ( ) const
+const Mgx3D::Internal::SelectionManager& Context::getSelectionManager ( ) const
 {
 	CHECK_NULL_PTR_ERROR (m_selection_manager)
 	return *m_selection_manager;
 }
 /*----------------------------------------------------------------------------*/
-void Context::setSelectionManager (Mgx3D::Utils::SelectionManager* mgr)
+void Context::setSelectionManager (Mgx3D::Internal::SelectionManager* mgr)
 {
 	delete m_selection_manager;
 	m_selection_manager	= mgr;

src/Core/Internal/SelectionHelper.cpp

@@ -0,0 +1,48 @@
+//
+// Created by calderans on 06/08/25.
+//
+#include "Internal/Context.h"
+#include "Internal/SelectionHelper.h"
+#include "Topo/TopoEntity.h"
+#include "Topo/TopoHelper.h"
+
+/*----------------------------------------------------------------------------*/
+namespace Mgx3D {
+/*----------------------------------------------------------------------------*/
+    namespace Internal {
+/*------------------------------------------------------------------------*/
+        SelectionHelper::SelectionHelper() {
+            MGX_FORBIDDEN("SelectionHelper::SelectionHelper is not allowed.");
+        }   // SelectionHelper::SelectionHelper
+
+/*----------------------------------------------------------------------------*/
+        SelectionHelper::SelectionHelper(const SelectionHelper &) {
+            MGX_FORBIDDEN("SelectionHelper::SelectionHelper is not allowed.");
+        }   // SelectionHelper::SelectionHelper(const SelectionHelper&)
+
+/*----------------------------------------------------------------------------*/
+        SelectionHelper &SelectionHelper::operator=(const SelectionHelper &) {
+            MGX_FORBIDDEN("SelectionHelper::operator = is not allowed.");
+            return *this;
+        }   // SelectionHelper::operator =
+
+/*----------------------------------------------------------------------------*/
+        SelectionHelper::~SelectionHelper() {
+            MGX_FORBIDDEN("SelectionHelper::~SelectionHelper is not allowed.");
+        }   // SelectionHelper::~SelectionHelper
+
+/*------------------------------------------------------------------------*/
+
+        std::vector<Topo::TopoEntity*> SelectionHelper::selectSheet(Topo::TopoEntity *entity, double* point) {
+            return Topo::TopoHelper::getSheet(entity, point);
+        }
+
+        /*------------------------------------------------------------------------*/
+
+        std::vector<Topo::TopoEntity*> SelectionHelper::selectChord(Topo::TopoEntity *entity, double* point) {
+            return Topo::TopoHelper::getChord(entity, point);
+        }
+    }
+}
+
+

src/Utils/SelectionManager.cpp renamed to src/Core/Internal/SelectionManager.cpp

@@ -1,4 +1,5 @@
-#include "Utils/SelectionManager.h"
+#include "Internal/SelectionManager.h"
+#include "Internal/SelectionHelper.h"
 #include "Utils/Common.h"
 #include "Utils/DisplayProperties.h"
 
@@ -20,7 +21,7 @@ using namespace std;
 /*----------------------------------------------------------------------------*/
 namespace Mgx3D {
 /*----------------------------------------------------------------------------*/
-namespace Utils {
+namespace Internal {
 /*----------------------------------------------------------------------------*/
 
 
@@ -89,7 +90,7 @@ void SelectionManagerObserver::selectionCleared ( )
 }	// SelectionManagerObserver::selectionCleared
 
 
-void SelectionManagerObserver::entitiesAddedToSelection (const vector<Entity*>&)
+void SelectionManagerObserver::entitiesAddedToSelection (const vector<Utils::Entity*>&)
 {
 }	// SelectionManagerObserver::entitiesAddedToSelection
 
@@ -98,7 +99,7 @@ void SelectionManagerObserver::entitiesAddedToSelection (const vector<string>& u
 }	// SelectionManagerObserver::entitiesAddedToSelection
 
 
-void SelectionManagerObserver::entitiesRemovedFromSelection (const vector<Entity*>& entities, bool clear)
+void SelectionManagerObserver::entitiesRemovedFromSelection (const vector<Utils::Entity*>& entities, bool clear)
 {
 }	// SelectionManagerObserver::entitiesRemovedFromSelection
 
@@ -198,7 +199,7 @@ void SelectionManager::getBounds (double bounds [6])
 
 	AutoMutex	autoMutex (getMutex ( ));
 
-	for (vector<Entity*>::iterator	it = _entities.begin ( ); _entities.end ( ) != it; it++)
+	for (vector<Utils::Entity*>::iterator	it = _entities.begin ( ); _entities.end ( ) != it; it++)
 	{
 		double	entityBounds [6];
 		(*it)->getBounds (entityBounds);
@@ -217,17 +218,17 @@ bool SelectionManager::isSelectionEmpty ( ) const
 }	// SelectionManager::isSelectionEmpty
 
 
-vector<Entity*> SelectionManager::getEntities ( ) const
+vector<Utils::Entity*> SelectionManager::getEntities ( ) const
 {
 	return _entities;
 }	// SelectionManager::getMeshes
 
 vector<unsigned long> SelectionManager::getEntitiesIds ( ) const
 {
 	vector<unsigned long>		ids;
-	const vector<Entity*>		entities	= getEntities ( );
+	const vector<Utils::Entity*>		entities	= getEntities ( );
 
-	for (vector<Entity*>::const_iterator it = entities.begin ( );
+	for (vector<Utils::Entity*>::const_iterator it = entities.begin ( );
 		 entities.end ( ) != it; it++)
 		ids.push_back ((*it)->getUniqueId ( ));
 
@@ -243,7 +244,7 @@ std::vector<std::string> SelectionManager::getEntitiesNames ( ) const
         return entites;
 }
 
-std::vector<Mgx3D::Utils::Entity*> SelectionManager::getEntities (Entity::objectType type) const
+std::vector<Mgx3D::Utils::Entity*> SelectionManager::getEntities (Utils::Entity::objectType type) const
 {
     std::vector<Mgx3D::Utils::Entity*> entites_filtrees;
 
@@ -255,7 +256,7 @@ std::vector<Mgx3D::Utils::Entity*> SelectionManager::getEntities (Entity::object
 }
 
 
-std::vector<std::string> SelectionManager::getEntitiesNames (Entity::objectType type) const
+std::vector<std::string> SelectionManager::getEntitiesNames (Utils::Entity::objectType type) const
 {
     std::vector<std::string> entites_filtrees;
 
@@ -267,7 +268,7 @@ std::vector<std::string> SelectionManager::getEntitiesNames (Entity::objectType
 }
 
 
-std::vector<std::string> SelectionManager::getEntitiesNames (FilterEntity::objectType mask) const
+std::vector<std::string> SelectionManager::getEntitiesNames (Utils::FilterEntity::objectType mask) const
 {
 	std::vector<std::string> entites_filtrees;
 
@@ -279,19 +280,19 @@ std::vector<std::string> SelectionManager::getEntitiesNames (FilterEntity::objec
 }
 
 
-void SelectionManager::addToSelection (const vector<Entity*>& entities)
+void SelectionManager::addToSelection (const vector<Utils::Entity*>& entities)
 {
 	addToSelection (entities, true);
 }	// SelectionManager::addToSelection
 
 
-void SelectionManager::removeFromSelection (const vector<Entity*>& entities)
+void SelectionManager::removeFromSelection (const vector<Utils::Entity*>& entities)
 {
 	removeFromSelection (entities, true);
 }	// SelectionManager::removeFromSelection
 
 
-bool SelectionManager::isSelected (const Entity& entity) const
+bool SelectionManager::isSelected (const Utils::Entity& entity) const
 {
     // TODO [EB]: {Optimisation} partie pouvant être couteuse il me semble
     // [CP] : OPTIMISATION
@@ -301,7 +302,7 @@ bool SelectionManager::isSelected (const Entity& entity) const
 	// A priori on ne devrait pas passer ci-dessous :
 	AutoMutex	autoMutex (getMutex ( ));
 
-	for (vector<Entity*>::const_iterator it = _entities.begin ( ); _entities.end ( ) != it; it++)
+	for (vector<Utils::Entity*>::const_iterator it = _entities.begin ( ); _entities.end ( ) != it; it++)
 		if (*it == &entity)
 			return true;
 
@@ -386,7 +387,7 @@ bool SelectionManager::isRedoable ( ) const
 }	// SelectionManager::isRedoable
 
 
-void SelectionManager::addToSelection (const vector<Entity*>& entities, bool undoable)
+void SelectionManager::addToSelection (const vector<Utils::Entity*>& entities, bool undoable)
 {
 	AutoMutex	autoMutex (getMutex ( ));
 
@@ -398,13 +399,13 @@ void SelectionManager::addToSelection (const vector<Entity*>& entities, bool und
 	UTF8String   message (Charset::UTF_8);
 	message << (1 == entities.size ( ) ? "Sélection de l'entité " : "Sélection des entités ");
 
-	for (vector<Entity*>::const_iterator it = entities.begin ( ); entities.end ( ) != it; it++)
+	for (vector<Utils::Entity*>::const_iterator it = entities.begin ( ); entities.end ( ) != it; it++)
 	{
 		CHECK_NULL_PTR_ERROR (*it)
 
 		// On filtre, certaines entités peuvent être présentes 2 fois (acteurs VTK filaire + isofilaire par ex) :
-		vector<Entity*>::const_iterator itnext	= it;	itnext++;
-		vector<Entity*>::const_iterator itfound	= find (itnext, entities.end ( ), *it);
+		vector<Utils::Entity*>::const_iterator itnext	= it;	itnext++;
+		vector<Utils::Entity*>::const_iterator itfound	= find (itnext, entities.end ( ), *it);
 		if (entities.end ( ) != itfound)
 			continue;	// La dernière occurence sera ajoutée
 
@@ -439,7 +440,7 @@ void SelectionManager::addToSelection (const vector<Entity*>& entities, bool und
 }	// SelectionManager::addToSelection
 
 
-void SelectionManager::removeFromSelection (const vector<Entity*>& entities, bool undoable)
+void SelectionManager::removeFromSelection (const vector<Utils::Entity*>& entities, bool undoable)
 {
 	AutoMutex	autoMutex (getMutex ( ));
 
@@ -451,12 +452,12 @@ void SelectionManager::removeFromSelection (const vector<Entity*>& entities, boo
 	UTF8String   message (Charset::UTF_8);
 	message << (1 == entities.size ( ) ? "Désélection de l'entité " : "Désélection des entités ");
 
-	for (vector<Entity*>::const_iterator it1 = entities.begin ( ); entities.end ( ) != it1; it1++)
+	for (vector<Utils::Entity*>::const_iterator it1 = entities.begin ( ); entities.end ( ) != it1; it1++)
 	{
 		CHECK_NULL_PTR_ERROR (*it1)
 
 		bool	removed	= false;
-		for (vector<Entity*>::iterator it2 = _entities.begin ( ); _entities.end ( ) != it2; it2++)
+		for (vector<Utils::Entity*>::iterator it2 = _entities.begin ( ); _entities.end ( ) != it2; it2++)
 		{
 			if (*it1 == *it2)
 			{
@@ -504,7 +505,7 @@ void SelectionManager::clearSelection (bool undoable)
 	// effet, ceux-ci peuvent etre tentés d'effectuer des requêtes auprès de ce gestionnaire de sélection, notamment un removeFromSelection. C'est
 	// par exemple le cas d'un observateur Qt où il est difficile de savoir si l'évènement de désenregistrement provient de ce gestionnaire ou d'un 
 	// évenement au niveau de l'IHM.
-	const vector<Entity*>	unselected	= _entities;
+	const vector<Utils::Entity*>	unselected	= _entities;
 	if (0 != _entities.size ( ))
 	{
 		_entities.clear ( );
@@ -634,15 +635,15 @@ int SelectionManager::dimensionsToDimension (SelectionManager::DIM dimensions)
 }	// SelectionManager::dimensionsToDimension
 
 
-bool SelectionManager::isSelectionActivated (const Entity& e) const
+bool SelectionManager::isSelectionActivated (const Utils::Entity& e) const
 {
 	return false;
 }   // SelectionManager::isSelectionActivated
 
 
-FilterEntity::objectType SelectionManager::getFilteredTypes ( ) const
+		Utils::FilterEntity::objectType SelectionManager::getFilteredTypes ( ) const
 {
-	return FilterEntity::NoneEntity;
+	return Utils::FilterEntity::NoneEntity;
 }	// SelectionManager::getFilteredTypes
 
 
@@ -676,7 +677,7 @@ bool SelectionManager::is3DSelectionActivated ( ) const
 }	// SelectionManager::is3DSelectionActivated
 
 
-void SelectionManager::activateSelection (SelectionManager::DIM dimensions, FilterEntity::objectType mask)
+void SelectionManager::activateSelection (SelectionManager::DIM dimensions, Utils::FilterEntity::objectType mask)
 {
 }	// SelectionManager::activate3DSelection
 
@@ -734,6 +735,47 @@ void SelectionManager::notifyObserversForNewPolicy (void* smp)
 }	// SelectionManager::notifyObserversForNewPolicy
 
 
+void SelectionManager::selectSheet(Utils::Entity* e, double* point){
+	//We need to filter to topoEntities
+	std::vector<Utils::Entity::objectType> validTypes =
+			{Utils::Entity::TopoBlock,Utils::Entity::TopoFace,Utils::Entity::TopoCoFace,
+			 Utils::Entity::TopoEdge,Utils::Entity::TopoCoEdge};
+
+	if(std::find(validTypes.begin(), validTypes.end(),e->getType()) != validTypes.end()) {
+		std::vector<Topo::TopoEntity *> topoEntities =
+				Internal::SelectionHelper::selectSheet(dynamic_cast<Topo::TopoEntity *>(e), point);
+
+		std::vector<Utils::Entity *> entities;
+		entities.reserve(topoEntities.size());
+		for (auto topoEntity: topoEntities) {
+			entities.push_back(topoEntity);
+		}
+
+		addToSelection(entities);
+	}
+	//If not topoEntity do nothing
+}
+
+void SelectionManager::selectChord(Utils::Entity* e, double* point){
+	//We need to filter to topoEntities
+	std::vector<Utils::Entity::objectType> validTypes =
+			{Utils::Entity::TopoBlock,Utils::Entity::TopoFace,Utils::Entity::TopoCoFace,
+			 Utils::Entity::TopoEdge,Utils::Entity::TopoCoEdge};
+
+	if(std::find(validTypes.begin(), validTypes.end(),e->getType()) != validTypes.end()) {
+		std::vector<Topo::TopoEntity *> topoEntities =
+				Internal::SelectionHelper::selectChord(dynamic_cast<Topo::TopoEntity *>(e), point);
+
+		std::vector<Utils::Entity *> entities;
+		entities.reserve(topoEntities.size());
+		for (auto topoEntity: topoEntities) {
+			entities.push_back(topoEntity);
+		}
+
+		addToSelection(entities);
+	}
+	//If not topoEntity do nothing
+}
 /*----------------------------------------------------------------------------*/
 } // end namespace Utils
 /*----------------------------------------------------------------------------*/

src/Utils/SelectionManagerDimFilter.cpp renamed to src/Core/Internal/SelectionManagerDimFilter.cpp

@@ -4,7 +4,7 @@
  * \date		14/10/2013
  */
 
-#include "Utils/SelectionManagerDimFilter.h"
+#include "Internal/SelectionManagerDimFilter.h"
 
 #include <TkUtil/UTF8String.h>
 #include <TkUtil/Exception.h>
@@ -22,7 +22,7 @@ using namespace std;
 namespace Mgx3D {
 
 /*----------------------------------------------------------------------------*/
-namespace Utils {
+namespace Internal {
 
 /*----------------------------------------------------------------------------*/