CAD4FE_VertexCriteria.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_VertexCriteria.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#include <sstream>
 
#pragma hdrstop
 
#include <vector>
using namespace std;
 
#include "CAD4FE_MCBody.h"
#include "CAD4FE_MCAA.h"
#include "CAD4FE_MCEdge.h"
#include "CAD4FE_MCVertex.h"
#include "CAD4FE_mg_utils.h"
#include "ot_algorithme_geometrique.h"
#include "CAD4FE_Criteria.h"
#include "CAD4FE_ColorMap.h"
#include "CAD4FE_VertexCriteria.h"     
#include "CAD4FE_PolyCurve.h"   
#include "CAD4FE_GlobalEdgeCriteria.h" 
#include "CAD4FE_CoVertexCriteria.h" 
#include "CAD4FE_Geometric_Tools.h"
 
 
#pragma package(smart_init)
 
using namespace CAD4FE;
 
 
int MG_TOPO_ccf_identique(      MG_ELEMENT_TOPOLOGIQUE *__A,    MG_ELEMENT_TOPOLOGIQUE  * __B)
{
    if (__A->get_nb_ccf() < __B->get_nb_ccf())
    {
        MG_ELEMENT_TOPOLOGIQUE *tmp = __A;
        __A = __B;
        __B = tmp; 
    }
    for (int i=0; i<__A->get_nb_ccf(); i++)
    {
        char nom_A [3];
        __A->get_type_ccf(i, nom_A);
        double val_A = __A->get_valeur_ccf(i);
 
        int found = 0;
        int same = 0;
 
        for (int j=0; j<__B->get_nb_ccf(); j++)
        {
 
            char nom_B [3];
            __B->get_type_ccf(j, nom_B);
            double val_B = __B->get_valeur_ccf(j);
 
            if (strcmp(nom_A, nom_B) == 0)
            {
                found = 1;
                if (val_A == val_B)
                {
                    same = 1;
                }
                break;
            }
        }
 
        if (found == 0 || same == 0)
        {
            return 0;
        }
    }
    return 1;
}
 
VertexCriteria::VertexCriteria (MCVertex * __mcVertex, MCAA * __mcaa)
: _mcaa(__mcaa), _mcVertex(__mcVertex)
{
        _mcVertex->get_point()->evaluer(_point);
        
        Update();
}
 
VertexCriteria::~VertexCriteria()
{
    for (unsigned i=0; i<_covertexProps.size(); i++)
    {
        CovertexCriteria * covp = _covertexProps[i];
        delete covp;
    }
}
 
void
VertexCriteria::Update()
{
        if (_mcaa->GetMCBody()->G10()->GetArc(_mcVertex->get_id())->Rank() == 0)
        { /* vertex isolated in the domain of a face */
                _score = 1; // UpdateDiscreteCurvatureCriterion();
        }
        else if ( _mcaa->GetMCBody()->G10()->GetArc(_mcVertex->get_id())->Rank() == 2
            && ! _mcaa->GetMCBody()->G10()->GetArc(_mcVertex->get_id())->IsLoop() )
        {
         /* vertex bounding 2 edges */
                _score = UpdateShapeCriteria();
        }
        // vertex interior to an edge 
        else if ( _mcaa->GetMCBody()->G10()->GetArc(_mcVertex->get_id())->IsLoop() )
        {
                _score = -1;
        }
}
 
double
VertexCriteria::UpdateShapeCriteria()
{                       
        std::vector <CovertexCriteria *>::iterator it;
 
        _meshSize = _mcaa->GetSize(_point);
 
        std::vector<MCEdge *> adjEdges;
        _mcaa->GetMCBody()->Vertex_GetAdjacentEdges(_mcVertex, adjEdges);
        
        for (it = _covertexProps.begin();
                it != _covertexProps.end();
                it++)
        {
                        delete *it;
                        _covertexProps.erase(it);
        }
 
        for (std::vector<MCEdge*>::iterator itEdge =  adjEdges.begin();
                itEdge != adjEdges.end(); itEdge++)
        {
                MCEdge * edge = *itEdge;
                MG_COSOMMET * cov;
                if (edge->get_cosommet1()->get_sommet() == _mcVertex)
                        cov = edge->get_cosommet1();
                else
                        cov = edge->get_cosommet2();
 
                CovertexCriteria * covc =  new CovertexCriteria(cov, _meshSize);
                _covertexProps.push_back(covc);
        }
 
        //_edgeLen, _epsilon, _deviationAngle, _score;  *
        _edgeLen = _meshSize;
        for (it = _covertexProps.begin();
                it != _covertexProps.end();
                it++)
        {                
                CovertexCriteria * covc = (*it);
                double covertexLength = covc->GetLength();
                if (covertexLength < _edgeLen)
                        _edgeLen = covertexLength;
        }
 
        std::map < MCFace * , std::set<MCEdge *> > subset_face_edges;
        for (std::vector<MCEdge*>::iterator itEdge =  adjEdges.begin();
                itEdge != adjEdges.end(); itEdge++)
        {
                std::set < MCFace * > adjfaces = _mcaa->GetMCBody()->Edge_GetAdjacentFaces(*itEdge);
 
                for ( std::set < MCFace * >::iterator itF = adjfaces.begin();
                        itF != adjfaces.end();
                        itF++)
                {
                        MCFace * f = *itF;
                        /*if (subset_face_edges.find(f) == subset_face_edges.end())
                        {
                                std::set<MCEdge *> new_edgeSet;
                                subset_face_edges.insert(std::make_pair(f, new_edgeSet));
                        }      */
                        subset_face_edges[f].insert( *itEdge );
                }
        }
 
        _deviationAngle = 0;
        
        for  (std::map < MCFace * , std::set<MCEdge *> >::iterator itFSE = subset_face_edges.begin();
              itFSE != subset_face_edges.end();
              itFSE++)
        {
                std::vector<OT_VECTEUR_3D> points;
                for (std::set<MCEdge *>::iterator itE = (itFSE->second).begin();
                     itE != (itFSE->second).end();
                     itE++)
                {
                        MCEdge * edge = *itE;
                        MG_COSOMMET * cov;
                        if (edge->get_cosommet1()->get_sommet() == _mcVertex)
                                cov = edge->get_cosommet1();
                        else
                                cov = edge->get_cosommet2();
 
 
                        for (it = _covertexProps.begin();
                                it != _covertexProps.end();
                                it++)
                        {
                                if ((*it)->GetCovertex() == cov)
                                        break;
                        }
 
                        if (it != _covertexProps.end())
                        {
                                OT_VECTEUR_3D p = (*it)->GetPoint();
                                points.push_back(p);
                        }
                }
                if (points.size() == 2)
                {
                        double deviationAngle = OT_ALGORITHME_GEOMETRIQUE::Angle3D_Segment_Segment(points[0],_point,points[1]);
                        if ( deviationAngle > _deviationAngle )
                                _deviationAngle = deviationAngle;
/*                        double epsilon = Dist3D_Point_Segment
( points [0], points [1], _point);
                        if (epsilon > _epsilon)
                               _epsilon = epsilon;*/
                }
        }
 
 
    _score = std::max(GetDeviationAngleScore(),GetEdgeLengthScore());
    return _score;
}
 
double VertexCriteria::GetDeviationAngle()
{
        return _deviationAngle;
}
 
 
double VertexCriteria::GetDeviationAngleScore()
{
    double criterionAngle;
 
        if (_deviationAngle < _mcaa->GetLimitAngle())
                criterionAngle = 1 - _deviationAngle / _mcaa->GetLimitAngle();
        else
                criterionAngle = .1*(1 - _deviationAngle / _mcaa->GetLimitAngle());
        
    return criterionAngle;
}
 
double VertexCriteria::GetEdgeLengthScore()
{
    double criterionEdgeLen;
    double limitEdgeLen =  _meshSize / _mcaa->GetMaxOverdensity();
    criterionEdgeLen = 1 - std::min(limitEdgeLen, _edgeLen) / limitEdgeLen;
    return criterionEdgeLen;
}
 
double VertexCriteria::GetScore()
{
        // Vertex having boundary conditions
        if (_mcVertex->get_nb_ccf())
            return -1;
 
        Graph::Arc * arc = _mcaa->GetMCBody()->G10()->GetArc(_mcVertex->get_id());
        int iVertexRank = arc->Rank();
        bool bIsLoop = arc->IsLoop();
 
 
        if (iVertexRank == 0)
        { /* vertex isolated in the domain of a face */
                _score = 1; // UpdateDiscreteCurvatureCriterion();
        }
        else if ( iVertexRank == 2
            && ! bIsLoop )
        {
         /* vertex bounding 2 edges */
 
                _score = std::max(GetDeviationAngleScore(), GetEdgeLengthScore());
                                                                             
                std::vector<MCEdge *> edges2;
                _mcaa->GetMCBody()->Vertex_GetAdjacentEdges(_mcVertex, edges2);
 
                // keep vertices that bouond two edges having different ccf
                {
                    if (MG_TOPO_ccf_identique(edges2[0], edges2[1]) == 0)
                    {
                        return -1;
                    }
                }
 
                // keep vertices that bound two edges with different colors
                {
 
                    unsigned char rgba1[4];
                    int is_colored1 = CAD4FE::GeometricTools::MG_TOPO_GetColor(edges2[0], rgba1);
                    unsigned char rgba2[4];
                    int is_colored2 = CAD4FE::GeometricTools::MG_TOPO_GetColor(edges2[1], rgba2);
 
                    if (is_colored2 != is_colored1)
                        return -1;
                    else if ( rgba1[0] !=  rgba2[0] || rgba1[1] !=  rgba2[1] || rgba1[2] !=  rgba2[2] || rgba1[3] !=  rgba2[3])
                        return -1;
                }
 
                // keep vertices that bound two edges with different deletion scores
                if (GlobalEdgeCriteria::SplitScore(_mcaa, _mcVertex)>0)
                    _score = 0;
 
                // merge small edges
                std::vector<MCEdge *> edges;
                _mcaa->GetMCBody()->Vertex_GetAdjacentEdges(_mcVertex, edges);
                
                if (edges.size() != 2)
                    return -1;
                    
                for (int i=0; i<2; i++)
                {
                    MCEdge * e = edges[i];
                    
                    double limitLength = _meshSize / _mcaa->GetMaxOverdensity();
                    double edgeLength = e->GetPolyCurve()->get_longueur();
 
                    if (edgeLength<limitLength)
                        _score = 1;
                }
                
        }
        // vertex interior to an edge or bounding more than 2 edges !
        else 
        {
                _score = -1;
        }
 
    return _score;
}
 
double VertexCriteria::GetEdgeLength()
{
        return _edgeLen;
}
 
MCVertex * VertexCriteria::GetVertex()
{
        return _mcVertex;
}
 
std::string VertexCriteria::InventorText()
{
        std::ostringstream out;
 
        unsigned char rgb[3];
        ColorMap::jetColorMap(rgb, 1-GetScore(), 0, 1);
 
 
        std::vector <CovertexCriteria *>::iterator it;    
        double * point;
        point = _point;
 
        out << "\nSeparator { #sep1 \n";
        out <<  "\n Coordinate3 {\n point [ \n";
        out <<  point[0] << " " << point[1] << " " << point[2] << " \n";
        out <<  "\n]\n}\n";
        out << "PolygonOffset { \n";
        out << "styles POINTS \n";
        out << "factor 5.0   \n";
        out << "units 1.0    \n";
        out << "}          \n";
        out <<  "DrawStyle {\npointSize 6\n}\n";
        out <<  "BaseColor { \n rgb "<<((double)rgb[0])/255<< " " <<((double)rgb[1])/255<<" "<<((double)rgb[2])/255<< "\n }\n";
        out <<  "PointSet {\nstartIndex "<<0<<"\nnumPoints "<<1<<"\n}\n";
        out << "} # end Sep1 \n";
 
        /* rgb[0]=0;rgb[1]=255;rgb[2]=0;
        for (it = _covertexProps.begin();
                it != _covertexProps.end();
                it++)
        {
        CovertexCriteria * cov = *it;
 
        double * point;
        point = cov->GetPoint();
 
        out << "\nSeparator { #sep1 \n";
        out <<  "\n Coordinate3 {\n point [ \n";
        out <<  point[0] << " " << point[1] << " " << point[2] << " \n";
        out <<  "\n]\n}\n";
        out << "PolygonOffset { \n";
        out << "styles POINTS \n";
        out << "factor 5.0   \n";
        out << "units 1.0    \n";
        out << "}          \n";
        out <<  "DrawStyle {\npointSize 6\n}\n";
        out <<  "BaseColor { \n rgb "<<((double)rgb[0])/255<< " " <<((double)rgb[1])/255<<" "<<((double)rgb[2])/255<< "\n }\n";
        out <<  "PointSet {\nstartIndex "<<0<<"\nnumPoints "<<1<<"\n}\n";
        out << "} # end Sep1 \n";
 
        }   */
 
 
        return out.str();
}