CAD4FE/src/CAD4FE_LoopCriteria.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  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;
}
Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months ago) by francois
File size:	3641 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière
#	User	Rev	Content
1	francois	1158	//####//------------------------------------------------------------
2			//####//------------------------------------------------------------
3			//####// MAGiC
4			//####// Jean Christophe Cuilliere et Vincent FRANCOIS
5			//####// Departement de Genie Mecanique - UQTR
6			//####//------------------------------------------------------------
7			//####// MAGIC est un projet de recherche de l equipe ERICCA
8			//####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9			//####// http://www.uqtr.ca/ericca
10			//####// http://www.uqtr.ca/
11			//####//------------------------------------------------------------
12			//####//------------------------------------------------------------
13			//####//
14			//####// CAD4FE_LoopCriteria.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:56 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	foucault	27
23
24			#include "gestionversion.h"
25	foucault	569	#include <mg_geometrie.h>
26			#include <mg_maillage.h>
27			#include <mg_maillage_outils.h>
28	foucault	27	#include <ot_mathematique.h>
29			#include <ot_quadrature_gauss.h>
30
31			#include "CAD4FE_MCEdge.h"
32			#include "CAD4FE_MCFace.h"
33			#include "CAD4FE_PolyCurve.h"
34			#include "CAD4FE_MCAA.h"
35			#include "CAD4FE_MCBody.h"
36			#include "CAD4FE_mg_utils.h"
37			#include "CAD4FE_Intersection_Plane_MG_MAILLAGE.h"
38			#include "ot_algorithme_geometrique.h"
39
40			#pragma hdrstop
41
42			#include "CAD4FE_LoopCriteria.h"
43
44
45			#pragma package(smart_init)
46
47			using namespace CAD4FE;
48
49			LoopCriteria::LoopCriteria(MCAA * __mcaa, MCFace * __mcFace, std::vector < MCEdge * > __loop, int __nbSegMin)
50			: _loop(__loop), _mcaa(__mcaa), _mcFace(__mcFace)
51			{
52			_nbSegMin = __nbSegMin;
53			Update();
54			}
55
56			void LoopCriteria::Update()
57			{
58			MCEdge * mcEdge; MG_ARETE * refEdge; PolyCurve * pc;
59			if (_mcFace->get_nb_ccf() != 0)
60			{
61			_score = 0;
62			return;
63			}
64
65			for (unsigned itMCEdge = 0; itMCEdge < _loop.size(); itMCEdge++)
66			{
67			mcEdge = _loop[itMCEdge];
68			if (mcEdge->get_nb_ccf() != 0)
69			{
70			_score = 0;
71			return;
72			}
73			}
74
75			_nbSeg=0;
76			for (unsigned itMCEdge = 0; itMCEdge < _loop.size(); itMCEdge++){
77			MCEdge * mcEdge = _loop[itMCEdge];
78			_nbSeg += _mcaa->GetFEMeshSegmentCount(mcEdge);
79			}
80
81			if ( _nbSeg < _nbSegMin )
82			{
83			_score = 1-((double)_nbSeg)/_nbSegMin;
84			}
85			else
86			{
87			_score = 0;
88			}
89			}
90
91			int LoopCriteria::GetNbFEMeshSeg()
92			{
93			return _nbSeg;
94			}
95
96			int LoopCriteria::GetNbFEMeshSegMin()
97			{
98			return _nbSegMin;
99			}
100
101			double LoopCriteria::EdgeSplitScore(MCEdge * __mcEdge, double __splitPoint[3])
102			{
103			std::vector<MCVertex*> extremities;
104			_mcaa->GetMCBody()->Edge_GetVertices(__mcEdge, extremities);
105			if (! (extremities.size () == 1 \|\| (extremities.size()==2 && extremities[0] == extremities[1])))
106			return 0;
107
108
109			int mcEdgeSegCount = _mcaa->GetFEMeshSegmentCount(__mcEdge);
110
111			if ( mcEdgeSegCount >= 2 )
112			{
113			double L = __mcEdge->GetPolyCurve()->get_longueur();
114			double xyz[3];
115			__mcEdge->evaluer(.5*L,xyz);
116			double meshSize = _mcaa->GetSize(xyz);
117			__mcEdge->evaluer(meshSize,__splitPoint);
118			return 1;
119			}
120
121			return 0;
122			}
123
124			double LoopCriteria::DeletionScore()
125			{
126			return _score;
127			}
128
129			std::vector < MCEdge * > & LoopCriteria::GetLoop()
130			{
131			return _loop;
132			}
133
134			MCFace * LoopCriteria::GetFace()
135			{
136			return _mcFace;
137			}