CAD4FE_GlobalEdgeCriteria.cpp

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_GlobalEdgeCriteria.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#pragma hdrstop
 
#include "gestionversion.h"
 
#include "CAD4FE_GlobalEdgeCriteria.h"
 
 
#pragma package(smart_init)
 
#include "gestionversion.h"
#include <mg_geometrie.h>
#include <mg_maillage.h>
#include <mg_maillage_outils.h>
#include <mg_gestionnaire.h>
#include <mailleur0d.h>
#include <mailleur1d.h>
#include <mailleur2d.h>
#include <fct_generateur_3d.h>
#include <fct_generateur_constante.h>
#include <fct_taille.h>
#include <ot_algorithme_geometrique.h>
 
#include "CAD4FE_MCBody.h"   
#include "CAD4FE_MCAA.h"
#include "CAD4FE_PolyCurve.h"   
#include "CAD4FE_PolySurface.h"
#include "CAD4FE_MCFace.h"
#include "CAD4FE_MCEdge.h"
#include "CAD4FE_MCVertex.h"
#include "CAD4FE_LocalEdgeCriteria.h"
#include "CAD4FE_VertexCriteria.h"
#include "CAD4FE_mg_utils.h"
#include "CAD4FE_InventorText_MCAA.h"
#include "CAD4FE_Intersection_Plane_MG_MAILLAGE.h"
#include "CAD4FE_Intersection_Plane_MG_SEGMENT.h"
#include "ot_algorithme_geometrique.h"
#include "CAD4FE_ColorMap.h"              
#include "CAD4FE_Criteria.h"               
 
 
using namespace CAD4FE;
 
GlobalEdgeCriteria::GlobalEdgeCriteria(MCEdge *__mcEdge, MCAA * __mcaa)
:
_mcEdge(__mcEdge), _mcaa(__mcaa)
{
}
 
GlobalEdgeCriteria::~GlobalEdgeCriteria()
{
    for ( LEC_Iterator it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
        LocalEdgeCriteria * ec = it_lec->second;
        delete ec;
    }
}
 
LocalEdgeCriteria * GlobalEdgeCriteria::GetLocalEdgeCriteria(MG_SEGMENT * __seg)
{  
    LEC_Iterator it_lec = _lec.find(__seg);
    if (it_lec != _lec.end())
        return it_lec->second;
    else
        return NULL;
}
 
void GlobalEdgeCriteria::Init()
{
        TPL_SET<MG_ELEMENT_MAILLAGE*> * lien_maillage2 = _mcEdge->get_lien_maillage();
        TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it2;
        MG_ELEMENT_MAILLAGE* element2;
        for (element2 = lien_maillage2->get_premier(it2); element2; element2 = lien_maillage2->get_suivant(it2) )
        {
                MG_SEGMENT * seg = (MG_SEGMENT *)element2;
                       
                if (seg == NULL)
                        continue;
                if ( ! _mcaa->GetFEMesh()->contient(seg) )
                        continue;
 
                Init(seg);
        }
}
 
void GlobalEdgeCriteria::Init(MG_SEGMENT * __seg)
{
    LEC_Iterator it_lec = _lec.find(__seg);
    if (it_lec != _lec.end() )
    {
        delete it_lec->second;
        _lec.erase (it_lec);
    }
 
    LocalEdgeCriteria * lec = CreateLocalEdgeCriteria(__seg);
 
    _lec.insert ( std::make_pair(__seg,lec) );
}
 
LocalEdgeCriteria * GlobalEdgeCriteria::CreateLocalEdgeCriteria(MG_SEGMENT* __seg)
{
 
    double point[3], normal[3];
    double x[2][3];
    MG_UTILS::MG_NOEUD_GET_XYZ(__seg->get_noeud1(), x[0]);
    MG_UTILS::MG_NOEUD_GET_XYZ(__seg->get_noeud2(), x[1]);
 
    for (unsigned i=0; i<3; i++)
    {
            point[i] = .5*(x[0][i]+x[1][i]);
            normal[i] = x[1][i] - point[i];
    }
 
    MG_SEGMENT * startSeg = _mcaa->FindClosestSeg(_mcEdge, point, normal);
 
    if (startSeg == NULL)
    {
        startSeg = _mcaa->FindClosestSeg(_mcEdge, point, normal);
    }
 
    return new LocalEdgeCriteria ( __seg,
        _mcaa,
        _mcaa->GetMCTess(),
        startSeg);
}
 
bool GlobalEdgeCriteria::Delete(MG_SEGMENT * __seg)
{
    LEC_Iterator it_lec = _lec.find(__seg);
    if (it_lec != _lec.end() )
    {
        delete it_lec->second;
        _lec.erase (it_lec);
        return true;
    }
    else
    {
        return false;
    }
}
 
void GlobalEdgeCriteria::Update(bool __reconstructNormalOffsets)
{
    LEC_Iterator it_lec;
 
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
        LocalEdgeCriteria * lec = it_lec->second;
        lec->Update(__reconstructNormalOffsets);
    }
 
    _Update();
}
 
void GlobalEdgeCriteria::Update(MCEdge * __touchingEdge, bool __reconstructNormalOffsets)
{   
    LEC_Iterator it_lec;
 
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {          
        LocalEdgeCriteria * lec = it_lec->second;
        if (lec->IsTouchingEdge(__touchingEdge))
            lec->Update(__reconstructNormalOffsets);
    }
 
    _Update();
}
   
void GlobalEdgeCriteria::Update(MG_SEGMENT * __touchingSeg, bool __reconstructNormalOffsets)
{   
    LEC_Iterator it_lec;
 
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {          
        LocalEdgeCriteria * ec = it_lec->second;
        if (ec->IsTouchingSegment(__touchingSeg))
            ec->Update(__reconstructNormalOffsets);
    }
 
    _Update();
}
 
void GlobalEdgeCriteria::ReInit(MG_SEGMENT * __touchingSeg)
{
    int touchingSegCount;
    LEC_Iterator it_lec;
 
    touchingSegCount = 0;
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
        LocalEdgeCriteria * ec = it_lec->second;
        if (ec->IsTouchingSegment(__touchingSeg))
        {
            MG_SEGMENT * seg = ec->GetSegment();
            delete ec;
            it_lec->second = CreateLocalEdgeCriteria ( seg );
            touchingSegCount++;
        }
    }
 
    if (touchingSegCount > 1)
        _Update();
}
 
void GlobalEdgeCriteria::_Update()
{                   
    LEC_Iterator it_lec;
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
        LocalEdgeCriteria * lec = it_lec->second;
        if (lec->GetEdge() == NULL)
        {
             printf("Warning: while updating local criteria of MCEdge %lu, local edge criteria's edge became null\n", _mcEdge->get_id());
             lec->Update();
             delete lec;
             _lec.erase(it_lec);
        }
    }
    
    it_lec = _lec.begin();
    LocalEdgeCriteria * ec = it_lec->second;
    _mcEdge = ec->GetEdge();
                     
    for ( LEC_Iterator it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
        LocalEdgeCriteria * lec = it_lec->second;
        if (lec->GetEdge() != _mcEdge)
        {
            printf("Warning: while updating local criteria of MCEdge %lu, the MCEdge %lu is different than the first one\n", _mcEdge->get_id(), ec->GetEdge()->get_id() );
        }
    }
}
 
MCEdge * GlobalEdgeCriteria::GetEdge()
{
    return _mcEdge;
}
 
double GlobalEdgeCriteria::DeletionScore_EdgeLength() const
{                        
    MCVertex * mcVertexRank1 = NULL;
    MCVertex * otherVertex = NULL;
    std::vector < MCVertex * > mcVertices;
 
    _mcaa->GetMCBody()->Edge_GetVertices(_mcEdge, mcVertices);
 
    double xyz[2][3 ];
    int i;
    mcVertices[0]->get_point()->evaluer(xyz[0]); 
    mcVertices[1]->get_point()->evaluer(xyz[1]);
    double meshSize = .5*(_mcaa->GetSize(xyz[0])+_mcaa->GetSize(xyz[1]));
    
    double criterionEdgeLength;   
    double limitLength = meshSize / _mcaa->GetMaxOverdensity();
 
 
    // Requirement 1                                    
    // length < limit
    double length = _mcEdge->GetPolyCurve()->get_longueur();
    if (length > limitLength)
    {
        return 0;   
    }
 
 
    // requirements :
    // at least one vertex has rank = 1
    // the other vertex must have deletion score = 0
    if (mcVertices.size() == 2 && mcVertices[0] != mcVertices[1] )
    {
        for (i=0;i<2;i++)
        {
            MCVertex * v = mcVertices[i];
            std::set < MCEdge * > vertex_edges;
            _mcaa->GetMCBody()->Vertex_GetAdjacentEdges(v,vertex_edges);
            if (vertex_edges.size() == 1)
            {
                mcVertexRank1 = v;
                break;
            }
        }
 
        if (mcVertexRank1 == NULL)
        {
                return -1; // DO NOT DELETE SMALL EDGES THAT HAVE UNDELETABLE EXTREMITIES
        }
 
        if (mcVertexRank1 == mcVertices[0] )
            otherVertex = mcVertices[1];
        else                     
            otherVertex = mcVertices[0];
                                                 
        return ( -1 + length / limitLength );
 
  /*      if (_mcaa->VC_Get(otherVertex)->GetScore() <= 0)
        {
            return 0;
        }
        else
        {
            return 1 - length / limitLength;
        }*/
    }
    else
    {
        mcVertexRank1 = mcVertices[0];
                 
        return ( -1 + length / limitLength );
    }
 
            
 
    return 0;
}
 
double GlobalEdgeCriteria::SplitScore(double __splitPoint[3])
{
    int i;
    // for each node of the 1D FE mesh :
    // if the node is on a edge (not on a vertex)
    // if the 2 adjacent segments have incompatible suppression
    // criteria ie. 1st edge non-suppressable, 2nd suppressable
    // then split the MCEdge at the node's position
 
    
   /* LEC_Iterator it_lec;
    std::set<MG_NOEUD*> nodes;
 
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
        MG_SEGMENT * seg = it_lec->first;
 
        MG_NOEUD * no[2];
        MG_SEGMENT_GET_NOEUDS(seg, no);
        for (i=0;i<2;i++)
        {
            nodes.insert(no[i]);
        }
    }
 
    LISTE_MG_NOEUD::iterator itNode;
    for ( std::set<MG_NOEUD*>::iterator it_nodes = nodes.begin();
        it_nodes != nodes.end();
        it_nodes++ )
    {
        MG_NOEUD * node = *it_nodes;*/
 
    LEC_Iterator it_lec;
    std::set<MG_NOEUD*> nodes;
 
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
        MG_SEGMENT * seg = it_lec->first;
        MG_NOEUD * node = seg->get_noeud1();
        
        if (node->get_lien_topologie()
            && node->get_lien_topologie()->get_dimension() == 1
            && node->get_lien_segment()->get_nb() == 2 )
        {
            MG_SEGMENT * segs[2];
            segs[0] = node->get_lien_segment()->get(0);
            segs[1] = node->get_lien_segment()->get(1);
            LocalEdgeCriteria * vecEC[2];
            for (i=0;i<2;i++)
                vecEC[i]=GetLocalEdgeCriteria(segs[i]);
 
            MG_UTILS::MG_NOEUD_GET_XYZ(node, __splitPoint);
 
            double score = SplitScore(vecEC);
            if (score > 0)
                return score; 
        }
    }
 
    return 0;
}
 
double GlobalEdgeCriteria::SplitScore(MCAA * __mcaa, MCVertex * __mcVertex)
{
    int i;
    MG_NOEUD * node;
    MG_MAILLAGE * feMesh = __mcaa->GetFEMesh();
 
    TPL_SET<MG_ELEMENT_MAILLAGE*> * lien_maillage2 = __mcVertex->get_lien_maillage();
    TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it2;
    MG_ELEMENT_MAILLAGE* element2;
    for (element2 = lien_maillage2->get_premier(it2); element2; element2 = lien_maillage2->get_suivant(it2) )
    {
        if (feMesh->contient(element2))
        {
            node = (MG_NOEUD*) element2;
            break;
        }
    }
 
    if (node->get_lien_segment()->get_nb() != 2 )
        return 0;
 
    MG_SEGMENT * segs[2];
    segs[0] = node->get_lien_segment()->get(0);
    segs[1] = node->get_lien_segment()->get(1);
    LocalEdgeCriteria * vecEC[2];
    for (i=0;i<2;i++)
    {
        MCEdge * mcEdge = (MCEdge*) segs[i]->get_lien_topologie();
        GlobalEdgeCriteria * gec = __mcaa->GetGlobalEdgeCriteria(mcEdge);
        vecEC[i] = gec->GetLocalEdgeCriteria(segs[i]);
    }
 
    return SplitScore(vecEC);
}
 
double GlobalEdgeCriteria::SplitScore(LocalEdgeCriteria * vecEC[2])
{   
    if ( vecEC[0] && vecEC[1]
        && (vecEC[0]->DeletionScore() > 0.005) != (vecEC[1]->DeletionScore() > 0.005))
    {
        return 1.0;
    }
    else
        return 0.0;
}
 
double GlobalEdgeCriteria::GetLength() const
{
    double edge_length=0;
    LEC_CIterator it_lec;
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
                    MG_SEGMENT * seg =  it_lec->first;
            LocalEdgeCriteria * lec = it_lec->second;
                    double length = seg->get_longueur();
                    edge_length += length;
    }          
    return edge_length;
}
 
double GlobalEdgeCriteria::DeletionScore()
{
    double result;
    LEC_Iterator it_lec;
 
    result = 0;
    double edge_length = 0;
 
    // Deny deletion of there exist some boundary conditions on the edge
    if (_mcEdge->get_nb_ccf())
    {        
        return 0;
    }
 
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
                    MG_SEGMENT * seg =  it_lec->first;
            LocalEdgeCriteria * lec = it_lec->second;
            if (lec->GetEdge() != _mcEdge)
                continue;
                    double length = seg->get_longueur();
            if (length == 0.0)
                result += lec->DeletionScore();
            else
            {
                result += length*lec->DeletionScore();
                        edge_length += length;
            }
    }
 
    if (edge_length != 0.0)
        result /= edge_length;
 
    double lengthScore = DeletionScore_EdgeLength();
 
    if (lengthScore < 0)
        result = std::min(result, .01);
    else if (lengthScore > result)
        result = lengthScore;
 
    if (edge_length == 0.0)
        result = 1;
 
    return result;                      
}
 
std::vector <LocalEdgeCriteria*> GlobalEdgeCriteria::GetLocalEdgeCriteria()
{
    std::vector <LocalEdgeCriteria*> result;
          
    LEC_Iterator it_lec;
 
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
            LocalEdgeCriteria * lec = it_lec->second;
            result.push_back(lec);
    }
 
    return result;
}
 
LocalEdgeCriteria * GlobalEdgeCriteria::GetFirstLocalEdgeCriteria(LEC_Iterator & __it)
{
    __it = _lec.begin();
    if (__it != _lec.end() )
        return __it->second;
    else
        return NULL;
}
 
LocalEdgeCriteria * GlobalEdgeCriteria::GetNextLocalEdgeCriteria(LEC_Iterator & __it)
{
    __it ++;
    if (__it != _lec.end() )
        return __it->second;
    else
        return NULL;
}
 
void
GlobalEdgeCriteria::ChangeTopo(GlobalEdgeCriteria * __src)
{
    LEC_Iterator it_lec;
 
    for ( it_lec = __src->_lec.begin();
        it_lec != __src->_lec.end();
        it_lec ++ )
    {
            LocalEdgeCriteria * lec = it_lec->second;
            MG_SEGMENT * seg = it_lec->first;
            _lec.insert(std::make_pair(seg,lec));
    }
 
    __src->_lec.clear();
}
 
 
void GlobalEdgeCriteria::CheckMCTess()
{
    LEC_Iterator it_lec;
 
    for ( it_lec = _lec.begin();
        it_lec != _lec.end();
        it_lec ++ )
    {
            LocalEdgeCriteria * lec = it_lec->second;
            lec->CheckMCTess();
    }
}