CAD4FE_MCBody.h

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       CAD4FE_MCBody.h
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#ifndef CAD4FE_MCBodyh
#define CAD4FE_MCBodyh
                                   
#include "CAD4FE_MCT_Platform.h"
 
#include "gestionversion.h"
#include <mg_geometrie.h>
#include "CAD4FE_Graph.h"
#include <map>  
#include <vector>
 
#pragma hdrstop
 
#define MCBODY_FOR_EACH_MCEDGE(M,E)\
        HypergraphLib::Graph *G21graph_tmp=M->G21(); \
        HypergraphLib::Graph::MapArcsById::const_iterator iteratorArcs_tmp; \
        iteratorArcs_tmp = G21graph_tmp->GetArcs().begin(); \
        CAD4FE::MCEdge * E = (iteratorArcs_tmp->second != NULL) ? M->GetMCEdge(iteratorArcs_tmp->second) : NULL;  \
        for (iteratorArcs_tmp = G21graph_tmp->GetArcs().begin();    \
        E != NULL;                          \
        iteratorArcs_tmp++ , E = (iteratorArcs_tmp != G21graph_tmp->GetArcs().end() && iteratorArcs_tmp->second != NULL) ? M->GetMCEdge(iteratorArcs_tmp->second) : NULL )
 
 
#define MCBODY_FOR_EACH_MCFACE(M,F)\
        HypergraphLib::Graph *G21graph_tmp=M->G21(); \
        CAD4FE::MCFace * F=M->GetMCFace(G21graph_tmp->GetNodes().begin()->second);  \
    if (G21graph_tmp->GetNodes().size() != 0)\
        for (HypergraphLib::Graph::MapNodesById::const_iterator iteratorNodes_tmp = G21graph_tmp->GetNodes().begin() \
        ;    \
        F != NULL;                          \
        iteratorNodes_tmp++ , F = (iteratorNodes_tmp != G21graph_tmp->GetNodes().end()) ? M->GetMCFace(iteratorNodes_tmp->second) : NULL )
 
        
#define MCBODY_FOR_EACH_MCVERTEX(M,V)\
        HypergraphLib::Graph *G10graph_tmp=M->G10();\
        CAD4FE::MCVertex * V=M->GetMCVertex(G10graph_tmp->GetArcs().begin()->second);  \
    if (G10graph_tmp->GetArcs().size() != 0) \
        for (HypergraphLib::Graph::MapArcsById::const_iterator iteratorArcs_tmp = G10graph_tmp->GetArcs().begin() \
        ;    \
        V != NULL ;                          \
        iteratorArcs_tmp++ , V = (iteratorArcs_tmp != G10graph_tmp->GetArcs().end()) ? M->GetMCVertex(iteratorArcs_tmp->second)  : NULL )
 
class MG_ELEMENT_TOPOLOGIQUE;
class MG_GEOMETRIE;
class MG_COARETE;
 
namespace CAD4FE {
 
        class MCEdge;
        class MCFace;                 
        class MCVertex;
        class Vector3dKey;
    class PolyCurve;           
 
    class RTChanges {
    public:
        RTChanges(){};
        std::multimap < MG_FACE   *, MG_FACE   *  > F;
        std::multimap < MG_ARETE  *, MG_ARETE  *  > E;
        std::multimap < MG_SOMMET *, MG_SOMMET *  > V;
        void Merge(RTChanges&);
    };
 
    class MCTChanges {
    public:
        MCTChanges(){};
        std::multimap < MCFace   * , MCFace   * > F;
        std::multimap < MCEdge   * , MCEdge   * > E;
        std::multimap < MCVertex * , MCVertex * > V;
        void Merge(MCTChanges&);
    };
 
        class  MCBody {
        public:
                typedef std::map<int, MCFace*> MapMCFaceById;
                typedef std::map<int, MCEdge*> MapMCEdgeById;
                typedef std::map<int, MCVertex*> MapMCVertexById;
 
                MCBody(MG_GEOMETRIE * __refGeom, MG_VOLUME * __refBody);
                // Destruction routines
                ~MCBody();
 
                // Construction routines
                void ReInit();
                void InitHyperGraphs();
                double EvaluateBoundaryShape(Graph::Arc *__arcG2V, double __RMin);
                void InitializeRealGeomData();
                void InitializeCopyRealToVirtualHyperGraphs();
                int G2ToNeatoFile (Graph::Graph * __G2, char * __filename, char *__graphname);
                int G1ToNeatoFile (Graph::Graph * __G1, char * __filename, char *__graphname);
 
                Graph::Arc * GetG2ArcFromG1Node(const Graph::Node *) const;
 
                Graph::Graph * G10() const;
                Graph::Graph * G21() const;
                Graph::Graph * G20() const;
 
        MG_GEOMETRIE * GetGeometry(){return _refGeom;};
 
        // Link userdata in hypergraphs
        void Graph_SetUserData(MG_ELEMENT_TOPOLOGIQUE * __topo);
        void Graph_SetUserData(Graph::Graph * __G, MG_ELEMENT_TOPOLOGIQUE * __topo);
 
                // MC Face
                MCFace * AddMCFace(MG_FACE * __refFace);
                MCFace * AddMCFace(MCFace *__a, MCFace *__b);
                MCFace* GetMCFace(const int) const;
                static MCFace* GetMCFace(Graph::GraphObject * __graphObject);
        bool Contains(MCFace *) const;
        void DeleteMCFace(MCFace * __mcFace);
                // MC Edge
                MCEdge * AddMCEdge(MG_ARETE * __refEdge);
        void AddMCEdgeCovertices(MCEdge * __mcEdge, std::vector<MCVertex *> __mcVertex);
        void DeleteMCEdgeCovertices(MCEdge * __mcEdge);
        void DeleteMCEdge(MCEdge *__mcEdge);
                MCEdge * AddMCEdge(MCEdge *__A, MCEdge *__B);
                MCEdge * AddMCEdge(PolyCurve * );
                MCEdge* GetMCEdge(const int ) const;
                static MCEdge* GetMCEdge(Graph::GraphObject * __graphObject);
        bool Contains(MCEdge *) const;
                // MC Vertex
                MCVertex * AddMCVertex(MG_SOMMET * __refVertex);
                MCVertex * GetMCVertex(const int)const ;              
        void DeleteMCVertex(MCVertex * __mcVertex);
                static MCVertex * GetMCVertex(Graph::GraphObject * __graphObject);
        bool Contains(MCVertex *) const;
 
        // Create a MCVertex with a defined label
        MCVertex * CreateMCVertex (MG_SOMMET *);
        // Split an MC edge at one specified position
        void SplitEdge(MCEdge * __mcEdge, double __xyz[3], MCTChanges * __mctChanges = 0, RTChanges * __rtChanges = 0);
        void SuppressMCEdge(MCEdge*, MCFace * __replMCFace[3]);
        // Vertex suppression algorithm
        void SuppressMCVertex(MCVertex *, MCTChanges * __mctChanges = 0);
                // Edge-Vertex Contraction operator
                void ContractEdgeToVertex(MCEdge * __mcEdge, MCVertex * __targetVertex, std::set <MCEdge*> & , std::set <MCEdge*> &);
        void MergeVertices(MCVertex * __deleteVertex, MCVertex * __targetVertex, std::set<MCEdge*> & edges);
 
        // Topological properties of MCEdges
        std::set < MCFace * >  Edge_GetAdjacentFaces(MCEdge * __mcEdge);
        void Edge_GetVertices (MCEdge *, std::vector<MCVertex*> & __mcVertices);
 
        // Topological properties of MCFaces
        void Face_GetMCVertices (MCFace * __mcFace, std::vector<MCVertex*> & __mcVertices);
        std::set < MCEdge * >  Face_GetAdjacentEdges(MCFace * __mcFace);
        Graph::Graph * Face_G10SubGraph(MCFace * __mcFace);
        std::vector < std::vector < MCEdge * > > Face_GetUnsortedLoops(MCFace * __mcFace);
        std::vector < std::vector < MCEdge * > > Face_GetCycles(MCFace * __mcFace);
 
        // Topological properties of MCVertices
        void Vertex_GetAdjacentEdges(MCVertex * __mcVertex, std::vector<MCEdge *> & __list);
        void Vertex_GetAdjacentEdges(MCVertex * __mcVertex, std::set<MCEdge *> & __list);
        void Vertex_GetAdjacentFaces(MCVertex * __mcVertex, std::set<MCFace *> & __list);
        int TestInteriorVertexIsolatedInFace(MCVertex * __mcVertex, MCFace ** __mcFace);
 
        // number of faces, edges, vertices of reference body and mc body
        void GetFEVCount(int * __faceCount,int * __edgeCount,int * __vertexCount);
        void GetRefBodyFEVCount(int * __faceCount,int * __edgeCount,int * __vertexCount);
 
        // Generate Loops of MC Faces
        void MCFace_GetLoops(MCFace* __mcFace, const std::set < Graph::Node * > & scc, std::vector < std::vector < std::pair < int, MCEdge * > > > & __loops );
        MG_COARETE * CreateCoEdge(MCFace * mcFace, MG_BOUCLE * mcLoop, MCEdge * mcEdge);
        MG_COARETE * CreateCoEdge(MCFace * mcFace, MG_BOUCLE * mcLoop, MCEdge * mcEdge, int sense);  
        int ExportBRep_MCEdgeSense(MCFace * __mcFace, MCEdge * __mcEdge);
        int ExportBRep_CreateInteriorVertexIsolatedInFace(MCVertex * __mcVertex, MCFace * __mcFace);
        // Export MC Body hypergraphs to BRep volume
        MG_VOLUME * ExportBRep();
        // delete all B-Rep MC entites 
        int DeleteBRep(MG_GESTIONNAIRE * gest, MG_GEOMETRIE * mggeo);
 
        int time;
        
        private:
        MG_GEOMETRIE * _refGeom;
        MG_VOLUME * _refBody;
        MG_VOLUME * _brep;
                Graph::Graph *_G10;
                Graph::Graph *_G20;
                Graph::Graph *_G21;
        };
 
}
 
#endif // CAD4FE_VIRTUALTOPOLOGYMODEL_H