CAD4FE/src/CAD4FE_EdgeCollapseCriteria.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_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;
}
Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (11 months ago) by francois
File size:	4673 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_EdgeCollapseCriteria.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:56 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	foucault	27
23
24			#pragma hdrstop
25
26
27	foucault	176
28			#include "gestionversion.h"
29			#include <vector>
30			using namespace std;
31	foucault	27
32	foucault	176	#include "CAD4FE_EdgeCollapseCriteria.h"
33	foucault	27	#include "CAD4FE_MCBody.h"
34			#include "CAD4FE_MCAA.h"
35			#include "CAD4FE_MCEdge.h"
36			#include "CAD4FE_MCVertex.h"
37			#include "CAD4FE_mg_utils.h"
38			#include "ot_algorithme_geometrique.h"
39			#include "CAD4FE_Criteria.h"
40			#include "CAD4FE_ColorMap.h"
41			#include "CAD4FE_VertexCriteria.h"
42			#include "CAD4FE_PolyCurve.h"
43			#include "CAD4FE_GlobalEdgeCriteria.h"
44	foucault	569	#include "CAD4FE_CoVertexCriteria.h"
45			#include "CAD4FE_Geometric_Tools.h"
46	foucault	27
47			#pragma package(smart_init)
48
49			using namespace CAD4FE;
50
51			EdgeCollapseCriteria::EdgeCollapseCriteria(MCEdge * __mcEdge, MCVertex * __deleteVertex, MCAA * __mcaa)
52			: _mcaa(__mcaa), _mcEdge(__mcEdge)
53			{
54			MCVertex v1, v2;
55			v1 = (MCVertex*) _mcEdge->get_cosommet1()->get_sommet();
56			v2 = (MCVertex*) _mcEdge->get_cosommet2()->get_sommet();
57
58			if (__deleteVertex == v1)
59			{
60			_deleteVertex = v1;
61			_targetVertex = v2;
62			}
63			else if (__deleteVertex == v2)
64			{
65			_deleteVertex = v2;
66			_targetVertex = v1;
67			}
68			else // problem
69			{
70			_deleteVertex = _targetVertex = NULL;
71	foucault	569	printf(" EdgeCollapseCriteria : vertex %lu is not adjacent to edge %lu !\n", __deleteVertex->get_id(), __mcEdge->get_id());
72	foucault	27	}
73			}
74
75			double EdgeCollapseCriteria::GetScore()
76			{
77	foucault	569	if (_mcaa->GetMCBody()->G21()->GetArc(_mcEdge->get_id())->Rank() != 2)
78			return 0;
79
80	foucault	27	if (_deleteVertex == _targetVertex) // the collapse edge is a cycle
81			return 0;
82
83			// don't use edge collapse when you can use vertex deletion
84			if (_mcaa->GetMCBody()->G10()->GetArc(_deleteVertex->get_id())->Rank() < 3)
85			return 0;
86
87			return EdgeLength();
88			}
89
90			double EdgeCollapseCriteria::EdgeLength()
91			{
92			double deleteVertex_xyz[3];
93			double LMin, minEdgeLength;
94			int extendEdgeCount;
95
96			_deleteVertex->get_point()->evaluer(deleteVertex_xyz);
97			LMin = _mcaa->GetMinSize(deleteVertex_xyz);
98
99			double collapseEdgeLength = _mcEdge->GetPolyCurve()->get_longueur();
100			if (collapseEdgeLength >= LMin)
101			return 0;
102
103			std::vector<MCEdge *> adjEdges;
104			_mcaa->GetMCBody()->Vertex_GetAdjacentEdges(_deleteVertex, adjEdges);
105
106	foucault	569	// Verify that adjacent edges have the same color as the deleted edge
107			{
108			unsigned char rgba1[4];
109			int is_colored1 = CAD4FE::GeometricTools::MG_TOPO_GetColor(_mcEdge, rgba1);
110			for (std::vector<MCEdge*>::iterator itEdge = adjEdges.begin();
111			itEdge != adjEdges.end(); itEdge++)
112			{
113			MCEdge * edge = *itEdge;
114			unsigned char rgba2[4];
115			int is_colored2 = CAD4FE::GeometricTools::MG_TOPO_GetColor(edge, rgba2);
116
117			if (is_colored2 != is_colored1)
118			return 0;
119			else if ( rgba1[0] != rgba2[0] \|\| rgba1[1] != rgba2[1] \|\| rgba1[2] != rgba2[2] \|\| rgba1[3] != rgba2[3])
120			return 0;
121			}
122			}
123
124	foucault	27	minEdgeLength = 1E100;
125			extendEdgeCount = 0;
126			for (std::vector<MCEdge*>::iterator itEdge = adjEdges.begin();
127			itEdge != adjEdges.end(); itEdge++)
128			{
129			MCEdge * edge = *itEdge;
130			if (edge == _mcEdge)
131			continue;
132
133			double edgeLength = edge->GetPolyCurve()->get_longueur();
134
135			minEdgeLength = std::min(minEdgeLength,edgeLength);
136			extendEdgeCount++;
137			}
138
139
140			if (minEdgeLength < LMin)
141			{
142			return 0;
143			}
144
145			return 1-collapseEdgeLength/LMin;
146			}