CAD4FE_EdgeCollapseCriteria.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_EdgeCollapseCriteria.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#pragma hdrstop
 
 
 
#include "gestionversion.h"
#include <vector>
using namespace std;
 
#include "CAD4FE_EdgeCollapseCriteria.h"
#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;
 
EdgeCollapseCriteria::EdgeCollapseCriteria(MCEdge * __mcEdge, MCVertex * __deleteVertex, MCAA * __mcaa)
: _mcaa(__mcaa), _mcEdge(__mcEdge)
{
    MCVertex *v1, *v2;
    v1 = (MCVertex*) _mcEdge->get_cosommet1()->get_sommet();
    v2 = (MCVertex*) _mcEdge->get_cosommet2()->get_sommet();
 
    if (__deleteVertex == v1)
    {
        _deleteVertex = v1;
        _targetVertex = v2;
    }
    else if (__deleteVertex == v2)
    {
        _deleteVertex = v2;  
        _targetVertex = v1;
    }
    else // problem
    {
        _deleteVertex = _targetVertex = NULL;
        printf(" EdgeCollapseCriteria : vertex %lu is not adjacent to edge %lu !\n", __deleteVertex->get_id(), __mcEdge->get_id());
    }
}
 
double EdgeCollapseCriteria::GetScore()
{
    if (_mcaa->GetMCBody()->G21()->GetArc(_mcEdge->get_id())->Rank() != 2)
        return 0;
 
    if (_deleteVertex == _targetVertex) // the collapse edge is a cycle
        return 0;
 
        // don't use edge collapse when you can use vertex deletion
    if (_mcaa->GetMCBody()->G10()->GetArc(_deleteVertex->get_id())->Rank() < 3)
        return 0;
 
    return EdgeLength();
}
 
double EdgeCollapseCriteria::EdgeLength()
{
    double deleteVertex_xyz[3];
    double LMin, minEdgeLength;
    int extendEdgeCount;
 
    _deleteVertex->get_point()->evaluer(deleteVertex_xyz);
    LMin = _mcaa->GetMinSize(deleteVertex_xyz);
 
    double collapseEdgeLength = _mcEdge->GetPolyCurve()->get_longueur();
    if (collapseEdgeLength >= LMin)
        return 0;
 
    std::vector<MCEdge *> adjEdges;
    _mcaa->GetMCBody()->Vertex_GetAdjacentEdges(_deleteVertex, adjEdges);
 
    // Verify that adjacent edges have the same color as the deleted edge
    {        
        unsigned char rgba1[4];
        int is_colored1 = CAD4FE::GeometricTools::MG_TOPO_GetColor(_mcEdge, rgba1);
        for (std::vector<MCEdge*>::iterator itEdge =  adjEdges.begin();
        itEdge != adjEdges.end(); itEdge++)
        {
                MCEdge * edge = *itEdge;  
                unsigned char rgba2[4];
                int is_colored2 = CAD4FE::GeometricTools::MG_TOPO_GetColor(edge, rgba2);
                  
                if (is_colored2 != is_colored1)
                    return 0;
                else if ( rgba1[0] !=  rgba2[0] || rgba1[1] !=  rgba2[1] || rgba1[2] !=  rgba2[2] || rgba1[3] !=  rgba2[3])
                    return 0;
        }
    }
 
    minEdgeLength = 1E100;
    extendEdgeCount = 0;
    for (std::vector<MCEdge*>::iterator itEdge =  adjEdges.begin();
        itEdge != adjEdges.end(); itEdge++)
        {
                MCEdge * edge = *itEdge;
                if (edge == _mcEdge)
                    continue;
 
                double edgeLength = edge->GetPolyCurve()->get_longueur();
 
                minEdgeLength = std::min(minEdgeLength,edgeLength);
                extendEdgeCount++;
        }
 
 
    if (minEdgeLength < LMin)
    {
        return 0;
    }
 
    return 1-collapseEdgeLength/LMin;
}