CAD4FE_LocalEdgeCriteria.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_LocalEdgeCriteria.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include <fstream>
#include <sstream>
              
#include "gestionversion.h"
#include <mg_geometrie.h>
#include <mg_maillage.h>
#include <mg_maillage_outils.h>
#include <ot_mathematique.h>
 
#include "CAD4FE_MCEdge.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"
#include "CAD4FE_Criteria.h"
#include "CAD4FE_ColorMap.h"
 
#pragma hdrstop
 
#include "CAD4FE_LocalEdgeCriteria.h"
 
 
#pragma package(smart_init)
 
using namespace CAD4FE;
 
 
LocalEdgeCriteria::LocalEdgeCriteria(MG_SEGMENT * __seg, MCAA * __mcaa, MG_MAILLAGE * __mesh, MG_SEGMENT * __startSeg)
: _seg(__seg), _mcaa(__mcaa), _mesh(__mesh), _startSeg(__startSeg), _normalOffset(NULL)
{
        double x[2][3];
        MG_UTILS::MG_NOEUD_GET_XYZ(_seg->get_noeud1(), x[0]);
        MG_UTILS::MG_NOEUD_GET_XYZ(_seg->get_noeud2(), x[1]);
        //        _deletionScoreOppositeEdge = 0;
 
        /* GF Debug int nb_triangles_adj_start_segment = __startSeg->get_lien_triangle()->get_nb();
        printf("start seg %ld : %d triangles adjacents\n", __startSeg->get_id(), nb_triangles_adj_start_segment);*/
 
        for (unsigned i=0; i<3; i++)
        {
                _P[i] = .5*(x[0][i]+x[1][i]);
                _N[i] = x[1][i]-_P[i];
        }   
                     
        _meshSize = 0;
        _normalOffset = 0;
 
        _mcEdge = NULL;
 
        Update();       
        if (_mcEdge) time = _mcEdge->time;
}
 
LocalEdgeCriteria::~LocalEdgeCriteria()
{
        delete  _normalOffset;
}
 
void
LocalEdgeCriteria::Update(bool __reconstructNormalOffset)
{
    _meshSize = _mcaa->GetSize(_P);
    
    double targetLength = .86*_meshSize;
    if ( __reconstructNormalOffset
        ||!_normalOffset                                                   )
    {
        if (_normalOffset) delete _normalOffset;
        _normalOffset = new Intersection_Plane_MG_MAILLAGE(_P, _N, _mesh, targetLength, _startSeg, NULL);
    }
 
    InitSetOfTouchingEdges();
 
        std::vector <Intersection_Plane_MG_MAILLAGE::Vertex> & pl  = _normalOffset->GetPolyline();
        int nb_pts = pl.size();
        int o = _normalOffset->GetOriginIndex();
 
        // Get the mc edge attached to the start segment
        {
                MG_SEGMENT * seg = pl[o].E;
                MG_ELEMENT_TOPOLOGIQUE * topo = seg->get_lien_topologie();
                if ( topo && topo->get_dimension() == 1)
                {
                        MCEdge * edge = (MCEdge*) topo;
                        _mcEdge = edge;
                        time = _mcEdge->time;
                }
                else
                {
                    _mcEdge = (MCEdge*)_seg->get_lien_topologie();
                }
        }
 
        for (unsigned i=0; i<2; i++)
        {
                _lengthToOppositeEdges[i] = 0;
                _oppositeEdgesPolylineIndices[i] = -1;
                _oppositeEdges[i] = NULL;
        }
 
        for (int j = 0; j < 2; j++)
        {
                for (int i = 0; i+1 < nb_pts; i++)
                {
                        int k[2];
                        if (j == 0)
                        {
                                k[0] = o - i;
                                k[1] = o - i - 1;
                                if (k[1] < 0 || k[1] >= nb_pts)
                                        break;
                        }
                        else if (j == 1)
                        {
                                k[0] = o + i;
                                k[1] = o + i + 1;
                                if (k[1] < 0 || k[1] >= nb_pts)
                                        break;
                        }
 
                        MG_SEGMENT * Seg [2];
                        MG_NOEUD * No [2];
                        OT_VECTEUR_3D xyz[2];
                        double dl;
 
                        for (unsigned l = 0; l < 2; l++)
                        {
                                xyz[l] = pl[k[l]].X;
                                Seg[l] = pl[k[l]].E;
                                No[l] = pl[k[l]].V;
                        }
 
                        MG_ELEMENT_TOPOLOGIQUE * topo;
                        topo = Seg[1]->get_lien_topologie();
 
                        if (topo  && topo->get_dimension() == 1 )
                        {
                                _oppositeEdges[j] = (MCEdge *) topo;
                                _oppositeEdgesPolylineIndices[j] = k[1];
                        }
                        else
                        {
                                _oppositeEdges[j] = NULL;
                                _oppositeEdgesPolylineIndices[j] = -1;
                        }
 
                        dl = (xyz[0] - xyz[1]).get_longueur();
                        _lengthToOppositeEdges[j] += dl;
 
                        if ( _oppositeEdges[j] )
                                break;
                }
        }
                                 
        _point = pl[o].X;
        double * segStart = pl[0].X, * segEnd = pl[nb_pts-1].X;
        for (unsigned i=0;i<3;i++)
        {
                _segment [0][i] = segStart[i];
                _segment [1][i] = segEnd[i];
        }
 
        // Face width
        _faceWidth = std::min( _lengthToOppositeEdges[0], _lengthToOppositeEdges[1] );
        // Epsilon (distance between the mesh and the geometry
        _epsilon = OT_ALGORITHME_GEOMETRIQUE::Dist3D_Point_Segment( _segment [0], _segment [1], _point);
        // Angle between the 2 edge segments
        if ( _segment [0] == _point || _segment [1] == _point )
            _deviationAngle = 0;
        else
            _deviationAngle = OT_ALGORITHME_GEOMETRIQUE::Angle3D_Segment_Segment( _segment [0], _point, _segment [1] );
}
 
double LocalEdgeCriteria::DeletionScore_FaceWidth() const
{
    double criterionFaceWidth;
    double limitFaceWidth = _meshSize / _mcaa->GetMaxOverdensity();
 
    if ( _oppositeEdges[0] || _oppositeEdges[1] )
    {
        if (_faceWidth <  limitFaceWidth)
            criterionFaceWidth = 1 - _faceWidth / limitFaceWidth;
        else
            criterionFaceWidth = .05 * (1 - _faceWidth / limitFaceWidth);
    }
    else
        criterionFaceWidth = -.05;
 
    return criterionFaceWidth;
}          
 
double LocalEdgeCriteria::DeletionScore_DeviationAngle() const
{             
    double criterionAngle;                 
    double limitAngle = _mcaa->GetLimitAngle();
 
        if (_deviationAngle < limitAngle)
                criterionAngle = 1 - _deviationAngle / limitAngle;
        else
                criterionAngle = .2*(1 - _deviationAngle / limitAngle);
 
    return criterionAngle;
}
 
double LocalEdgeCriteria::DeletionScore() const
{
        int i, NB_CRITERIA = 0;
        double score = 0;
        double val[10];
 
        if (_mcaa->GetMCBody()->G21()->GetArc(_mcEdge->get_id())->Rank() != 2)
            return 0;
 
        if (_mcEdge && _mcEdge->get_nb_ccf())
            return 0;
 
        val[NB_CRITERIA++] = DeletionScore_FaceWidth();
        val[NB_CRITERIA++] = DeletionScore_DeviationAngle();
        //        val[NB_CRITERIA++] = DeletionScore_OppositeEdge();
 
        for (i=0;i<NB_CRITERIA;i++)
        {
            if (score < val[i])
            {
                score = val[i];
            }
        }
 
        return score;
}
 
void LocalEdgeCriteria::GetPolylineVertex(int i, float * __vec3f) const
{
    const double * vec3d = _normalOffset->GetPolyline()[i].X;
    for (int i=0; i<3; i++)
        __vec3f[i] = vec3d[i];
}
 
unsigned LocalEdgeCriteria::GetPolylineVerticesCount() const
{
    return _normalOffset->GetPolyline().size();
}
 
std::string
LocalEdgeCriteria::InventorText()
{
        std::ostringstream out;
 
        unsigned char rgb[3];
        ColorMap::jetColorMap(rgb, 1-DeletionScore(), 0, 1);
        _normalOffset->SetColor(rgb);
        out << _normalOffset->InventorText();
 
        for (unsigned j=0; j<2; j++)
        if (_oppositeEdgesPolylineIndices[j] != -1) {
                int i = _oppositeEdgesPolylineIndices[j];
                std::vector <Intersection_Plane_MG_MAILLAGE::Vertex> & pl  = _normalOffset->GetPolyline();
                out << "\nSeparator { #sep1 \n";
                out <<  "\n Coordinate3 {\n point [ \n";
                out <<  pl[i].X[0] << " " <<pl[i].X[1] << " " << pl[i].X[2] << " \n";
                out <<  "\n]\n}\n";
                out << "PolygonOffset { \n";
                out << "styles POINTS \n";
                out << "factor 4.0   \n";
                out << "units 1.0    \n";
                out << "}          \n";
                out <<  "DrawStyle {\npointSize 4\n}\n";
                out <<  "BaseColor { \n rgb  1.0 0.0 0.0\n }\n";
                out <<  "PointSet {\nstartIndex "<<0<<"\nnumPoints "<<1<<"\n}\n";
                out << "} # end Sep1 \n";
        }
 
        return out.str();
}
 
MCEdge * LocalEdgeCriteria::GetEdge()
{
        return _mcEdge;
}
 
MG_SEGMENT * LocalEdgeCriteria::GetSegment() 
{       
    return _seg;
}
 
double  LocalEdgeCriteria::GetFaceWidth()
{
        return _faceWidth;
}
 
double LocalEdgeCriteria::GetEpsilon()
{
        return _epsilon;
}
 
double  LocalEdgeCriteria::GetDeviationAngle()
{                    
        return _deviationAngle;
}
bool LocalEdgeCriteria::IsTouchingEdge(MCEdge * __mcEdge)
{
        return _setTouchingEdge.find(__mcEdge) != _setTouchingEdge.end();
}                                                                              
bool LocalEdgeCriteria::IsTouchingSegment(MG_SEGMENT * __segment)
{
        if (__segment == NULL)
            return false;
 
        std::vector <Intersection_Plane_MG_MAILLAGE::Vertex> & pl  = _normalOffset->GetPolyline();
        unsigned nb_pts = pl.size();
 
        // Get the mc edge attached to the start segment
        for (unsigned i = 0; i < nb_pts; i++)
        {
                MG_SEGMENT * seg = pl[i].E;
 
                if (seg == __segment)
                    return true;
        }
 
        return false;
}                                                                             
bool LocalEdgeCriteria::IsStartSegment(MG_SEGMENT * __segment)
{                             
        if (__segment == NULL)
            return false;
            
        std::vector <Intersection_Plane_MG_MAILLAGE::Vertex> & pl  = _normalOffset->GetPolyline();
        unsigned int o = _normalOffset->GetOriginIndex();
 
        return (pl[o].E == __segment);
}
 
MCEdge * LocalEdgeCriteria::GetTouchingEdge(int __index)
{
        if (__index >= 0 && __index < 2)
            return _oppositeEdges[__index];
        else
        {
            printf("Error GetTouchingEdge: __index = %d\n", __index);
            return NULL;
        }
}
 
double LocalEdgeCriteria::GetLengthToTouchingEdge(int __index)
{
        if (__index >= 0 && __index < 2)
            return _lengthToOppositeEdges[__index];
        else
        {
            printf("Error GetLengthToTouchingEdge: __index = %d\n", __index);
            return -1;
        }
}
MCEdge * LocalEdgeCriteria::GetClosestTouchingEdge()
{
        return (_lengthToOppositeEdges[0] < _lengthToOppositeEdges[1])
              ?  _oppositeEdges[0]
              : _oppositeEdges[1];
}
double * LocalEdgeCriteria::GetClosestTouchingEdgePoint()
{
        int i = (_lengthToOppositeEdges[0] < _lengthToOppositeEdges[1])
              ?  0
              : 1;
        return _normalOffset->GetPolyline()[ _oppositeEdgesPolylineIndices [i] ].X;
}
 
double * LocalEdgeCriteria::GetTouchingEdgePoint(int __index)
{
        if (__index >= 0 && __index < 2)
            return _normalOffset->GetPolyline()[ _oppositeEdgesPolylineIndices [__index] ].X;
        else
        {             
            printf("Error GetLengthToTouchingEdge: __index = %d\n", __index);
            return 0;
        }
}
void LocalEdgeCriteria::CheckMCTess()
{
        std::vector <Intersection_Plane_MG_MAILLAGE::Vertex> & pl  = _normalOffset->GetPolyline();
        int nb_pts = pl.size();
        int o = _normalOffset->GetOriginIndex();
 
        for (int j = 0; j < 2; j++)
        {
                for (int i = 0; i+1 < nb_pts; i++)
                {
                        int k[2];
                        if (j == 0)
                        {
                                k[0] = o - i;
                                k[1] = o - i - 1;
                                if (k[1] < 0 || k[1] >= nb_pts)
                                        break;
                        }
                        else if (j == 1)
                        {
                                k[0] = o + i;
                                k[1] = o + i + 1;
                                if (k[1] < 0 || k[1] >= nb_pts)
                                        break;
                        }
 
                        MG_SEGMENT * Seg [2];
                        MG_NOEUD * No [2];
                        OT_VECTEUR_3D xyz[2];
                        double dl;
 
                        for (unsigned l = 0; l < 2; l++)
                        {
                                xyz[l] = pl[k[l]].X;
                                Seg[l] = pl[k[l]].E;
                                No[l] = pl[k[l]].V;
                        }
 
                        MG_ELEMENT_TOPOLOGIQUE * topo;
                        topo = Seg[1]->get_lien_topologie();
 
                        if ( ! _mcaa->GetMCTess()->contient(Seg[1]))
                            printf("The MC Tessellation does not contains a segment crossed by LEC's polyline !\n");
                        _mcaa->CheckIfTopoExists(topo);
                        if (topo->get_dimension() < 2)
                            break;
                }
        }
}
 
 
 
double LocalEdgeCriteria::GetMeshSize()
{
    return _meshSize;
}
 
void LocalEdgeCriteria::InitSetOfTouchingEdges()
{
    std::vector <Intersection_Plane_MG_MAILLAGE::Vertex> & pl  = _normalOffset->GetPolyline();
    unsigned nb_pts = pl.size();
                                     
    _setTouchingEdge.clear();
    for (unsigned i = 0; i < nb_pts; i++)
    {
            MG_SEGMENT * seg = pl[i].E;
            MG_ELEMENT_TOPOLOGIQUE * topo = seg->get_lien_topologie();
            if (topo && topo->get_dimension() == 1)
                _setTouchingEdge.insert((MCEdge*)topo);
    }
}