CAD4FE_LoopCriteria.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_LoopCriteria.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
                   
#include "gestionversion.h"
#include <mg_geometrie.h>
#include <mg_maillage.h>
#include <mg_maillage_outils.h>
#include <ot_mathematique.h>
#include <ot_quadrature_gauss.h>
 
#include "CAD4FE_MCEdge.h"
#include "CAD4FE_MCFace.h"
#include "CAD4FE_PolyCurve.h"
#include "CAD4FE_MCAA.h"
#include "CAD4FE_MCBody.h"
#include "CAD4FE_mg_utils.h"
#include "CAD4FE_Intersection_Plane_MG_MAILLAGE.h"
#include "ot_algorithme_geometrique.h"
 
#pragma hdrstop
 
#include "CAD4FE_LoopCriteria.h"
 
 
#pragma package(smart_init)
 
using namespace CAD4FE;
 
LoopCriteria::LoopCriteria(MCAA * __mcaa, MCFace * __mcFace, std::vector < MCEdge * > __loop, int __nbSegMin)
: _loop(__loop), _mcaa(__mcaa), _mcFace(__mcFace)
{
    _nbSegMin = __nbSegMin;
    Update();
}
 
void LoopCriteria::Update()
{
    MCEdge *  mcEdge; MG_ARETE * refEdge; PolyCurve * pc;
    if (_mcFace->get_nb_ccf() != 0)
    {
        _score = 0;
        return;
    }
    
    for (unsigned itMCEdge = 0; itMCEdge < _loop.size(); itMCEdge++)
    {
        mcEdge = _loop[itMCEdge];
        if (mcEdge->get_nb_ccf() != 0)
        {
            _score = 0;
            return;
        }
    }
 
    _nbSeg=0;
    for (unsigned itMCEdge = 0; itMCEdge < _loop.size(); itMCEdge++){
        MCEdge * mcEdge = _loop[itMCEdge];
        _nbSeg += _mcaa->GetFEMeshSegmentCount(mcEdge);
    }
 
    if ( _nbSeg < _nbSegMin )
    {
        _score = 1-((double)_nbSeg)/_nbSegMin;
    }
    else
    {
        _score = 0;
    }
}
 
int LoopCriteria::GetNbFEMeshSeg()
{
    return _nbSeg;
}
 
int LoopCriteria::GetNbFEMeshSegMin()
{
    return _nbSegMin;
}
 
double LoopCriteria::EdgeSplitScore(MCEdge * __mcEdge, double __splitPoint[3])
{
    std::vector<MCVertex*> extremities;
    _mcaa->GetMCBody()->Edge_GetVertices(__mcEdge, extremities);
    if (! (extremities.size () == 1 || (extremities.size()==2 && extremities[0] == extremities[1])))
        return 0;
 
 
    int mcEdgeSegCount = _mcaa->GetFEMeshSegmentCount(__mcEdge);
 
    if ( mcEdgeSegCount >= 2 )
    {   
        double L = __mcEdge->GetPolyCurve()->get_longueur();
        double xyz[3];
        __mcEdge->evaluer(.5*L,xyz);
        double meshSize = _mcaa->GetSize(xyz);
        __mcEdge->evaluer(meshSize,__splitPoint);
        return 1;
    }
 
    return 0;
}
 
double LoopCriteria::DeletionScore()
{
    return _score;
}
 
std::vector < MCEdge * > & LoopCriteria::GetLoop()
{
    return _loop;
}
 
MCFace * LoopCriteria::GetFace()
{
    return _mcFace;
}