Merge pull request #151 from LIHPC-Computational-Geometry/issue#208

Issue#208

Author: mpoudot

src/Core/Geom/CommandEditGeom.cpp

@@ -45,36 +45,18 @@ void CommandEditGeom::internalExecute()
     internalSpecificPreExecute();
 
     // on recupere toutes les entites concernes par l'opération géométrique
-    std::map<GeomEntity*,MementoEntity> ref;
-    std::vector<std::list<GeomEntity*>*> refEntities;
+    std::map<GeomEntity*, MementoEntity> mementos_by_entity;
+    std::set<GeomEntity*> to_mem_entities[4];
 
-    refEntities.push_back(&(getRefEntities(0))); //sommets
-    refEntities.push_back(&(getRefEntities(1))); //courbes
-    refEntities.push_back(&(getRefEntities(2))); //surfaces
-    refEntities.push_back(&(getRefEntities(3))); //volumes
-
-    // MODIF - LES ENTITES ADJ NE SONT PAS DES ENTITES DE REF
-//    refEntities[0]->insert(refEntities[0]->begin(),getAdjEntities(0).begin(),getAdjEntities(0).end());
-//    refEntities[1]->insert(refEntities[1]->begin(),getAdjEntities(1).begin(),getAdjEntities(1).end());
-//    refEntities[2]->insert(refEntities[2]->begin(),getAdjEntities(2).begin(),getAdjEntities(2).end());
-//    refEntities[3]->insert(refEntities[3]->begin(),getAdjEntities(3).begin(),getAdjEntities(3).end());
-
-#ifdef _DEBUG2
-    std::cerr<<"nb refs sommets = "<<getRefEntities(0).size()<<std::endl;
-    std::cerr<<"nb refs curves  = "<<getRefEntities(1).size()<<std::endl;
-    std::cerr<<"nb refs surfaces= "<<getRefEntities(2).size()<<std::endl;
-    std::cerr<<"nb refs volumes = "<<getRefEntities(3).size()<<std::endl;
-#endif
-    for(unsigned int i=0;i<4;i++){
-        std::list<GeomEntity*>* refList = refEntities[i];
-        std::list<GeomEntity*>::iterator it;
-        for(it=refList->begin();it!=refList->end();it++){
-            GeomEntity* e = *it;
+    for(unsigned int i=0;i<4;i++) {
+        to_mem_entities[i].insert(getRefEntities(i).begin(), getRefEntities(i).end());
+        to_mem_entities[i].insert(getAdjEntities(i).begin(), getAdjEntities(i).end());
+        for (GeomEntity* e : to_mem_entities[i]) {
             MementoEntity mem = m_memento_manager.createMemento(e);
 #ifdef _DEBUG2
            std::cerr<<"Memento cree pour "<<e->getName()<<std::endl;
 #endif
-            ref.insert({e, mem});
+            mementos_by_entity.insert({e, mem});
         }
     }
 //    gmds::Timer t2;
@@ -134,19 +116,27 @@ void CommandEditGeom::internalExecute()
     }
 #endif
 
-    //sauvegarde des mementos pour le undo/redo
+    // Sauvegarde des mementos pour le undo/redo
+    // Utiliser at en lecture pour avoir une exception si
+    // la clef est absente (ne pas utiliser l'opérateur [])
     std::map<GeomEntity*,MementoEntity> keeped_ref;
     for(unsigned int i=0;i<mod_entities.size();i++){
         GeomEntity* e = mod_entities[i];
-        keeped_ref[e] = ref[e];
+        if (mementos_by_entity.find(e) == mementos_by_entity.end())
+            std::cout << "*** MOD les mementos ne contiennent pas " << e->getName() << std::endl;
+        keeped_ref[e] = mementos_by_entity.at(e);
     }
     for(unsigned int i=0;i<mov_entities.size();i++){
         GeomEntity* e = mov_entities[i];
-        keeped_ref[e] = ref[e];
+        if (mementos_by_entity.find(e) == mementos_by_entity.end())
+            std::cout << "*** MOV les mementos ne contiennent pas " << e->getName() << std::endl;
+        keeped_ref[e] = mementos_by_entity.at(e);
     }
     for(unsigned int i=0;i<rem_entities.size();i++){
         GeomEntity* e = rem_entities[i];
-        keeped_ref[e] = ref[e];
+        if (mementos_by_entity.find(e) == mementos_by_entity.end())
+            std::cout << "*** REM les mementos ne contiennent pas " << e->getName() << std::endl;
+        keeped_ref[e] = mementos_by_entity.at(e);
     }
     saveMementos(keeped_ref);
     getInfoCommand().setDestroyAndUpdateConnectivity(rem_entities);

src/Core/Geom/CommandJoinEntities.cpp

@@ -90,6 +90,11 @@ std::list<GeomEntity*>& CommandJoinEntities::getRefEntities(const int dim)
     return m_ref_entities[dim];
 }
 /*----------------------------------------------------------------------------*/
+std::list<GeomEntity*>& CommandJoinEntities::getAdjEntities(const int dim)
+{
+    return m_adj_entities[dim];
+}
+/*----------------------------------------------------------------------------*/
 std::map<GeomEntity*,std::vector<GeomEntity*> >& CommandJoinEntities::getReplacedEntities()
 {
     return m_replacedEntities;

src/Core/Geom/GeomEntity.cpp

@@ -99,7 +99,7 @@ getRepresentation(Utils::DisplayRepresentation& dr, bool checkDestroyed) const
 template<typename T>
 void GeomEntity::
 buildSerializedRepresentation(Utils::SerializedRepresentation& description, const std::string& title, 
-    const std::set<T*, decltype(&Utils::Entity::compareEntity)> elements) const
+    const Utils::EntitySet<T*> elements) const
 {
     if (!elements.empty()){
         Utils::SerializedRepresentation	sr (title,TkUtil::NumericConversions::toStr(elements.size()));

src/Core/Geom/GeomModificationBaseClass.cpp

@@ -69,22 +69,20 @@ void GeomModificationBaseClass::init(std::vector<GeomEntity*>& es)
 {
     // pour chacune des entités passées en argument, on ajoute les entités de
     // dimension inférieure et supérieure ou égale en référence.
-    for(unsigned int i=0;i<es.size();i++){
-        GeomEntity* esi = es[i];
+    for(GeomEntity* esi : es){
         m_init_entities.push_back(esi);
         addReference(esi);
         addDownIncidentReference(esi);
         addUpIncidentReference(esi);
     }
 
-    for(unsigned int i=0;i<es.size();i++){
-        GeomEntity* esi = es[i];
-        addAdjacencyReference(esi);
-    }
+    for(int i=0 ; i<4 ; i++)
+        for(GeomEntity* esi : m_ref_entities[i])
+            addAdjacencyReference(esi);
 
     // une entité a pu être ajoutée plusieurs fois, on élimine maintenant les
     // occurrences multiples
-    for(int i=0;i<4;i++){
+    for(int i=0 ; i<4 ; i++){
         m_ref_entities[i].sort(Utils::Entity::compareEntity);
         m_ref_entities[i].unique();
         m_adj_entities[i].sort(Utils::Entity::compareEntity);
@@ -165,8 +163,28 @@ addAdjacencyReference(GeomEntity* e)
     for (auto ei : va.get())
     {
         int dim = ei->getDim();
-        if (dim > 0 && std::find(m_ref_entities[dim].begin(),m_ref_entities[dim].end(),ei)==m_ref_entities[dim].end())
+        auto& ref = m_ref_entities[dim];
+        if (std::find(ref.begin(), ref.end(), ei) == ref.end()) {
             m_adj_entities[dim].push_back(ei);
+
+            // issue#208 : split d'un volume Vol0 à gauche collé (glue) à un volume Vol1 à droite
+            // la surface Surf0007 de droite de Vol1 n'est pas adjacente à Vol0 mais ses relations
+            // géométriques vont être changées car elle est adjacente à des surfaces
+            // qui vont être recréées (changement nb arêtes et shape OCC).
+            // Il faut donc que Surf0007 soit prise en compte par les mementos en cas de undo
+            // => on garde les objets "down incident" aux objets adjacents car Surf0007 est
+            // "down incidente" de Vol1.
+            GetDownIncidentGeomEntitiesVisitor v_down;
+            ei->accept(v_down);
+            for (auto e_down : v_down.get())
+            {
+                int dim_down = e_down->getDim();
+                auto& ref_down = m_ref_entities[dim_down];
+                if (std::find(ref_down.begin(), ref_down.end(), e_down) == ref_down.end()) {
+                    m_adj_entities[dim_down].push_back(e_down);
+                }
+            }
+        }
     }
 }
 /*----------------------------------------------------------------------------*/
@@ -598,13 +616,6 @@ createGeomEntities(const TopoDS_Shape& shape, const bool replaceVolumes, const b
     //===================================================================
     rebuildAdjacencyEntities(shape);
 
-
-    //    std::vector<Volume*>::iterator it_vKeep = m_toKeepVolumes.begin();
-    //    while(it_vKeep!=m_toKeepVolumes.end()){
-    //        Volume* v = *it_vKeep;
-    //        std::cout<<"\t keep "<<v->getName()<<std::endl;
-    //        it_vKeep++;
-    //    }
     std::vector<GeomEntity*>::iterator it_rem = m_removedEntities.begin();
     std::vector<GeomEntity*> toErase;
     while(it_rem!=m_removedEntities.end()){
@@ -2048,7 +2059,7 @@ void GeomModificationBaseClass::createNewSurfaces(
 #endif
     	}
 
-    } // end for i
+    }
 
 }
 /*----------------------------------------------------------------------------*/
@@ -2217,6 +2228,8 @@ void GeomModificationBaseClass::createNewAdjVolumes(
                 to_keep = true;
                 newVolume = current;
                 newOCCVolume = V;
+                // il faut mettre à jour la OCC shape en cas de non conformité d'une face (issue#208)
+                newVolume->m_occ_shape = V;
                 m_toKeepVolumes.push_back(current);
 #ifdef _DEBUG2
                 std::cout<<"=*= VOLUME ADJ CONSERVE "<<newVolume->getName()<<std::endl;

src/Core/Geom/GeomSectionByPlaneImplementation.cpp

@@ -86,26 +86,35 @@ void GeomSectionByPlaneImplementation::splitEntities(std::vector<GeomEntity*>& r
 #ifdef _DEBUG2
 	std::cout<<"m_init_entities.size = "<<m_init_entities.size()<<std::endl;
 #endif
-    GeomEntity* e1 = m_init_entities[0];
-    TopoDS_Shape s_fuse;
-    getUniqueOCCShape(e1, s_fuse);
-    for(unsigned int i=1;i<m_init_entities.size();i++){
-        GeomEntity* e2 = m_init_entities[i];
-        TopoDS_Shape s2;
-        getUniqueOCCShape(e2, s2);
+    bool all_volumes = std::all_of(m_init_entities.begin(), m_init_entities.end(), [](GeomEntity* x) {
+        return (x->getDim() == 3);
+    });
 
-        BRepAlgoAPI_Fuse fuse_operator(s_fuse,s2);
-        if(fuse_operator.IsDone())
-            s_fuse = fuse_operator.Shape();
+    if (all_volumes) {
+        GeomEntity* e1 = m_init_entities[0];
+        TopoDS_Shape s_fuse;
+        getUniqueOCCShape(e1, s_fuse);
+        for(unsigned int i=1;i<m_init_entities.size();i++){
+            GeomEntity* e2 = m_init_entities[i];
+            TopoDS_Shape s2;
+            getUniqueOCCShape(e2, s2);
+
+            BRepAlgoAPI_Fuse fuse_operator(s_fuse,s2);
+            if(fuse_operator.IsDone())
+                s_fuse = fuse_operator.Shape();
+            else
+                throw TkUtil::Exception (TkUtil::UTF8String ("Problème OCC lors de l'union avant coupe", TkUtil::Charset::UTF_8));
+        }
+        // On recupere l'intersection de la surface wf et de l'union des entites à couper
+        BRepAlgoAPI_Common common_operator(s_fuse, wf);
+        if(common_operator.IsDone())
+            m_restricted_section_tool = common_operator.Shape();
         else
-            throw TkUtil::Exception (TkUtil::UTF8String ("Problème OCC lors de l'union avant coupe", TkUtil::Charset::UTF_8));
+            throw TkUtil::Exception (TkUtil::UTF8String ("Problème OCC lors de l'intersection avant coupe", TkUtil::Charset::UTF_8));
+    } else {
+        // les opérations fuse + common ne fonctionnent pas s'il y a une surface
+        m_restricted_section_tool = wf;
     }
-    // On recupere l'intersection de la surface wf et de l'union des entites à couper
-    BRepAlgoAPI_Common common_operator(s_fuse,wf);
-    if(common_operator.IsDone())
-        m_restricted_section_tool = common_operator.Shape();
-    else
-        throw TkUtil::Exception (TkUtil::UTF8String ("Problème OCC lors de l'intersection avant coupe", TkUtil::Charset::UTF_8));
 
     //========================================================================
     // 3 - Decoupe des entités
@@ -120,7 +129,7 @@ void GeomSectionByPlaneImplementation::splitEntities(std::vector<GeomEntity*>& r
         getUniqueOCCShape(ei, si);
         list_of_arguments.Append(si);
     }
-    list_of_arguments.Append(wf);
+    list_of_arguments.Append(m_restricted_section_tool);
     splitter.SetArguments(list_of_arguments);
     splitter.Build();
 
@@ -138,9 +147,7 @@ void GeomSectionByPlaneImplementation::splitEntities(std::vector<GeomEntity*>& r
             rep_ei.push_back(m_newVolumes[j]);
     }
 
-    //    res.insert(res.end(),new_volumes.begin(),new_volumes.end());
-
-    res.insert(res.end(), entities_new.begin(), entities_new.end());
+    res.insert(res.end(), m_newEntities.begin(), m_newEntities.end());
 }
 /*----------------------------------------------------------------------------*/
 std::vector<GeomEntity*> GeomSectionByPlaneImplementation::getEntitiesOnPlane()

src/Core/Geom/OCCHelper.cpp

@@ -34,7 +34,7 @@
 #include <ShapeFix_Wireframe.hxx>
 #include <ShapeFix_FixSmallFace.hxx>
 #include <ShapeBuild_ReShape.hxx>
-
+#include <ShapeAnalysis_ShapeContents.hxx>
 /*----------------------------------------------------------------------------*/
 namespace Mgx3D {
 /*----------------------------------------------------------------------------*/
@@ -1336,6 +1336,54 @@ addShapeToLists(TopoDS_Shape& shape,
 
 }
 /*----------------------------------------------------------------------------*/
+void OCCHelper::
+printInfos(const TopoDS_Shape& shape, const std::string& indent)
+{
+    std::cout << indent << "Shape de type ";
+    TopAbs_ShapeEnum type = shape.ShapeType();
+    switch (type) {
+        case TopAbs_COMPOUND: std::cout << "Compound"; break;
+        case TopAbs_COMPSOLID: std::cout << "CompSolid"; break;
+        case TopAbs_SOLID: std::cout << "Solid"; break;
+        case TopAbs_SHELL: std::cout << "Shell"; break;
+        case TopAbs_FACE: std::cout << "Face"; break;
+        case TopAbs_WIRE: std::cout << "Wire"; break;
+        case TopAbs_EDGE: std::cout << "Edge"; break;
+        case TopAbs_VERTEX: std::cout << "Vertex"; break;
+        case TopAbs_SHAPE: std::cout << "Generic Shape"; break;
+    }
+    std::cout << " : " << std::endl;
+
+    ShapeAnalysis_ShapeContents analysis;
+    analysis.Perform(shape);
+    std::cout << indent << "\tNb solids : " << analysis.NbSolids() << std::endl;
+    std::cout << indent << "\tNb faces : " << analysis.NbFaces() << std::endl;
+
+    if (type == TopAbs_COMPOUND) {
+        std::cout << indent << "\tDétails du compound :" << std::endl;
+        exploreCompound(TopoDS::Compound(shape), indent);
+    }
+}
+/*----------------------------------------------------------------------------*/
+void OCCHelper::
+printInfos(const TopTools_ListOfShape& shapes)
+{
+    for (TopTools_ListIteratorOfListOfShape it(shapes); it.More(); it.Next()) {
+        TopoDS_Shape shape = it.Value();
+        printInfos(shape);
+    }
+}
+/*----------------------------------------------------------------------------*/
+void OCCHelper::
+exploreCompound(const TopoDS_Compound& compound, const std::string& indent)
+{
+    std::string new_indent = indent + "\t";
+    for (TopExp_Explorer exp(compound, TopAbs_SOLID); exp.More(); exp.Next()) {
+        TopoDS_Shape sub_shape = exp.Current();
+        printInfos(sub_shape, new_indent);
+    }
+}
+/*----------------------------------------------------------------------------*/
 } // end namespace Geom
 /*----------------------------------------------------------------------------*/
 } // end namespace Mgx3D

src/Core/Topo/CoEdge.cpp

@@ -157,6 +157,12 @@ replace(Topo::Vertex* v1, Topo::Vertex* v2, bool propagate_up, bool propagate_do
 
     // transmet aux Edges
 	if (propagate_up)
+		/* 
+		 * 9/7/2025  ** ATTENTION **
+		 * Ne pas passer en "modern C++ loop" : for (Edge* e : getEdges())
+		 * car Edge::replace appelle Edge::free qui modifie la liste
+		 * des edges de la coedge ce qui perturbe le parcours de la boucle.
+		*/
 		for (uint j=0; j<getNbEdges(); j++)
 			getEdge(j)->replace(v1, v2, propagate_up, propagate_down, icmd);
 

src/Core/protected/Geom/CommandJoinEntities.h

@@ -72,6 +72,7 @@ class CommandJoinEntities: public CommandEditGeom
      *          l'algorithme travaille
      */
     virtual std::list<GeomEntity*>& getRefEntities(const int dim);
+    virtual std::list<GeomEntity*>& getAdjEntities(const int dim);
 
     /*------------------------------------------------------------------------*/
     /** \brief  retourne une référence sur une map indiquant par quelles
@@ -119,6 +120,8 @@ class CommandJoinEntities: public CommandEditGeom
 
     /// référence sur toutes les entités  sur lesquelles l'algorithme travaille
     std::list<GeomEntity*> m_ref_entities[4];
+    /// liste inutilisée : juste pour répondre à la méthode get de la classe mère
+    std::list<GeomEntity*> m_adj_entities[4];
 
     /* entités que l'on a conservées (modifiées ou non)*/
     std::vector<Vertex*> m_toKeepVertices;

src/Core/protected/Geom/GeomEntity.h

@@ -169,7 +169,7 @@ class GeomEntity : public Internal::InternalEntity{
 #ifndef SWIG
     template<typename T>
     void buildSerializedRepresentation(Utils::SerializedRepresentation& description, const std::string& title, 
-                                                const std::set<T*, decltype(&Utils::Entity::compareEntity)> elements) const;
+                                                const Utils::EntitySet<T*> elements) const;
 #endif
 
 private: