sld_import_tessellation.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       sld_import_tessellation.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#pragma hdrstop
 
#include "gestionversion.h"
#ifdef BREP_SLD
 
#include "mg_maillage_outils.h"
#include "sld_import.h"
#include "mg_geometrie.h"
#include "mg_gestionnaire.h"
#include "sld_surface.h"
#include "sld_point.h"
#include "sld_courbe.h"
#include "lc_point.h"
#include "sld_fonction.h"
#include "tpl_grille.h"
#include "ot_algorithme_geometrique.h"
#include "ot_root_find.h"
#include "CAD4FE_MG_ARETE_ClosestPointOn.h"
 
 
#include <atl\atlmod.h>
#include "smartvars.h"
#include <string.h>
#include <stdio.h>
#include <math.h>
 
#include "sld_import_tessellation.h"
#pragma package(smart_init)
 
SLD_IMPORT_TESSELLATION::SLD_IMPORT_TESSELLATION()
{
    tess = NULL;
}
 
SLD_IMPORT_TESSELLATION::~SLD_IMPORT_TESSELLATION()
{
    for (std::map<MG_FACE *, double *>::const_iterator it_face_tessPts = lst_face_tessPts.begin();
            it_face_tessPts != lst_face_tessPts.end();
            it_face_tessPts ++)
    {
        double * tessPts = it_face_tessPts->second;
        delete [] tessPts;
    }
}
 
void SLD_IMPORT_TESSELLATION::GetFaceMeshNormal(MG_FACE * __face, MG_NOEUD * __node, double __normal[3])
{
    double angleTot=0;
    OT_VECTEUR_3D normalTriangle(0,0,0);
 
    TPL_LISTE_ENTITE<MG_TRIANGLE*>* adjacentTriangles = __node->get_lien_triangle();
    int itTriang;
    for (itTriang=0;itTriang <adjacentTriangles->get_nb(); itTriang++)
    {
        MG_TRIANGLE* t = adjacentTriangles->get(itTriang);
        MG_FACE * refFace = (MG_FACE*) t->get_lien_topologie();
        if ( __face != refFace )
            continue;
        int id=-1;
        MG_NOEUD * nos[3]={t->get_noeud1(),t->get_noeud2(),t->get_noeud3()};
        for (int j=0;j<3;j++)
            if (nos[j] == __node)
            {
                id = j;
                break;
            }
        OT_VECTEUR_3D x[3];
        for (int j=0;j<3;j++)
            x[j]=OT_VECTEUR_3D(nos[j]->get_coord());
        OT_VECTEUR_3D x1x2 = x[id]-x[(id+2)%3];
        x1x2.norme();
        OT_VECTEUR_3D x2x3 = x[(id+1)%3]-x[id];
        x2x3.norme();
        OT_VECTEUR_3D normal = x1x2&x2x3;
        double angle = acos(-(x1x2*x2x3));
        normal *= angle;
        angleTot += angle;
        normalTriangle += normal;
    }
    if (angleTot != 0)
    {
        normalTriangle /= angleTot;
        for (int j=0;j<3;j++)
            __normal[j]=normalTriangle[j];
    }
    else
    {
        for (int j=0;j<3;j++)
            __normal[j]=0;
    }
}
 
/*
int SLD_IMPORT_TESSELLATION::VerifyFaceOrientation(MG_FACE * __face)
{
        std::set <MG_NOEUD*> testedNodes;
        int nbNodeInSameSense = 0;
        int nbNodeInOppositeSense = 0;
        for (int itLoop=0; itLoop!=__face->get_nb_mg_boucle(); itLoop++)
                for (int itCoEdge=0; itCoEdge!=__face->get_mg_boucle(itLoop)->get_nb_mg_coarete(); itCoEdge++)
                {
                        MG_ARETE * edge = __face->get_mg_boucle(itLoop)->get_mg_coarete(itCoEdge)->get_arete();
                        TPL_SET< MG_ELEMENT_MAILLAGE * > * tess=edge->get_lien_maillage();
                        TPL_SET< MG_ELEMENT_MAILLAGE * >::ITERATEUR itSeg;
                        for (MG_SEGMENT * seg = (MG_SEGMENT *)tess->get_premier(itSeg); seg; seg = (MG_SEGMENT *)tess->get_suivant(itSeg) )
                        {
                                testedNodes.insert(seg->get_noeud1());
                                testedNodes.insert(seg->get_noeud2());
                        }
                }
                for (std::set<MG_NOEUD*>::iterator itNode=testedNodes.begin();itNode!=testedNodes.end();itNode++)
                {
                        MG_NOEUD * node=*itNode;
                        double uv[2];
                        double xyzFaceNormal[3];
                        __face->inverser(uv,node->get_coord());
                        double dist;
                        __face->calcul_normale_unitaire(uv,xyzFaceNormal);
                        double xyzTessNormal[3];
                        GetFaceMeshNormal(__face,node,xyzTessNormal);
                        double sense = OT_ALGORITHME_GEOMETRIQUE::VEC3_DOT_VEC3(xyzTessNormal,xyzFaceNormal);
                        if (sense > 0)
                                nbNodeInSameSense++;
                        if (sense < 0)
                                nbNodeInOppositeSense++;
                }
                if (nbNodeInSameSense > 0 && nbNodeInOppositeSense == 0)
                        return 1;
                if (nbNodeInSameSense == 0 && nbNodeInOppositeSense > 0)
                        return -1;
                VerifyFaceOrientation(__face);
                return 0;
}
 
int
SLD_IMPORT_TESSELLATION::ProjectPointToEdge(MG_ARETE * __edge, double __maxDist, double __x[3], double __newX[3])
{
    double t;
    __edge->inverser(t,__x);
    double brackT[2]={t,t};
 
    CAD4FE::MG_ARETE_ClosestPointOn tool(__x, __edge);
    OT_ROOT_FIND_1D::ZeroBracOut(
        CAD4FE::MG_ARETE_ClosestPointOn::_Function_Plane_Edge_SquaredDist,
        __edge->get_tmin(), __edge->get_tmax(),
        brackT[0],
        brackT[1],
        &tool);
 
    double newT = OT_ROOT_FIND_1D::RootSafe(
        CAD4FE::MG_ARETE_ClosestPointOn::_Function_Plane_Edge_SquaredDist,
        CAD4FE::MG_ARETE_ClosestPointOn::_Derivative_Plane_Edge_SquaredDist,
            brackT[0], brackT[1], 1E-6*( __edge->get_tmax() - __edge->get_tmin() ),
            &tool);
 
    if (newT > 1E100)
    {
        for (int i=0;i<3;i++) __newX[i]=__x[i];
        printf("Error while projecting point to edge %d\n", __edge->get_id());
        return 0;
    }
 
    __edge->evaluer(newT, __newX);
    double dist = OT_ALGORITHME_GEOMETRIQUE::VEC3_DISTANCE_VEC3(__newX,__x);
 
    if (dist > __maxDist)
    {
        for (int i=0;i<3;i++) __newX[i]=__x[i];
        printf("Error while projecting point to edge %d\n", __edge->get_id());
        return 0;
    }
 
    return 1;
}        */
 
template <class A>
void
cstr_grid(double __bbox[6], int __nb_steps[3], TPL_GRILLE<A> & __grid)
{
    double center[3];
    for (int i=0; i<3; i++)
        center[i] = .5*(__bbox[i] + __bbox[3+i]);
 
    double step[3];
    for (int i=0; i<3; i++)
        step[i] =  (__bbox[3+i] - __bbox[i])/__nb_steps[i];
 
 
    double bbox[6];
    for (int i=0; i<6; i++) bbox[i] = __bbox[i];
 
    for (int i=0; i<3; i++)
        bbox[i+3] += .1*step[i];
    for (int i=0; i<3; i++)
        bbox[i] -= .1*step[i];
 
    __grid.initialiser(bbox[0], bbox[1], bbox[2], bbox[3], bbox[4], bbox[5], __nb_steps[0], __nb_steps[1], __nb_steps[2]);
}
 
MG_GEOMETRIE*
SLD_IMPORT_TESSELLATION::importer(class MG_GESTIONNAIRE& gest,char *path, double tessellationTolerance)
{
    MG_GEOMETRIE * geom = SLD_IMPORT::importer(gest,path);
    return importer_tessellation(gest,geom, gest.get_sld_fonction(),tessellationTolerance);
}
 
MG_GEOMETRIE*
SLD_IMPORT_TESSELLATION::importer_tessellation(class MG_GESTIONNAIRE& gest,MG_GEOMETRIE * geom,SLD_FONCTION& fonction, double tessellationTolerance)
{
    if (tessellationTolerance != 0)
    {
        fonction.Modeler_SetToleranceValue(4,tessellationTolerance);
        fonction.Modeler_SetToleranceValue(6,tessellationTolerance);
    }
 
    // Get the tessellation of each face
    MG_VOLUME * body = gest.get_mg_geometrie(0)->get_mg_volume(0);
    unsigned nb_shells = body->get_nb_mg_coquille ();
    for (unsigned it_shells = 0; it_shells < nb_shells; it_shells++)
    {
        MG_COQUILLE * shell = body->get_mg_coquille(it_shells);
        unsigned nb_coface = shell->get_nb_mg_coface();
        for (unsigned it_coface = 0; it_coface < nb_coface; it_coface++)
        {
            MG_FACE * face = shell->get_mg_coface(it_coface)->get_face();
            double * tessPts;
            long nbTessTriang;
 
            CComPtr<IFace2> sld_face;
            fonction.GetParID((char*)face->get_idoriginal().c_str(), sld_face);
            fonction.get_face_tessellation(sld_face, &(nbTessTriang), &(tessPts));
            lst_face_tessPts[face] = tessPts;
            lst_face_nbTessTriangles[face] = nbTessTriang;
            printf("Face \"%s\" has %d triangles\n", face->get_idoriginal().c_str(), nbTessTriang);
        }
    }
 
    // Compute the boundary box of the tessellation
    // bbox [6] = {x_min, y_min, z_min, x_max, y_max, z_max}
    double bbox[6] = {1E308, 1E308, 1E308, -1E308, -1E308, -1E308};
    for (std::map<MG_FACE *, double *>::const_iterator it_face_tessPts = lst_face_tessPts.begin();
            it_face_tessPts != lst_face_tessPts.end();
            it_face_tessPts ++)
    {
        MG_FACE * face = it_face_tessPts->first;
        double * tessPts = it_face_tessPts->second;
        long nbTessTriang = lst_face_nbTessTriangles[face];
 
        // scan each point of the tessellation
        for (long itPt = 0; itPt < 9*nbTessTriang; itPt += 3)
        {
            double vertex [3];
            for (int i=0; i<3; i++)
            {
                vertex[i] = tessPts[ itPt + i ];
                if (vertex[i] < bbox[i])
                    bbox[i+0] = vertex[i];
                if (vertex[i] > bbox[i+3])
                    bbox[i+3] = vertex[i];
            }
        }
    }
 
 
    // Construct the tessellation of the bodies
    tess = new MG_MAILLAGE (geom);
    gest.ajouter_mg_maillage(tess);
    TPL_GRILLE<MG_NOEUD*> grid;
    int nb_step_grid [3] = {34,34,34};
    cstr_grid<MG_NOEUD*>(bbox, nb_step_grid, grid);
    double epsilon = 1E-8*sqrt(pow(bbox[3]-bbox[0],2)+pow(bbox[4]-bbox[1],2)+pow(bbox[5]-bbox[2],2));
    epsilon = std::max(1E-14,epsilon);
    for (std::map<MG_FACE *, double *>::const_iterator it_face_tessPts = lst_face_tessPts.begin();
            it_face_tessPts != lst_face_tessPts.end();
            it_face_tessPts ++)
    {
        MG_FACE * face = it_face_tessPts->first;
        double * tessPts = it_face_tessPts->second;
        long nbTessTriang = lst_face_nbTessTriangles[face];
 
        // Create triangles on the faces of the body
        for (long iTriang = 0; iTriang < nbTessTriang; iTriang ++)
        {
            MG_NOEUD * triangNodes[3];
            MG_TRIANGLE * triang;
 
            for (int iVert = 0; iVert < 3; iVert ++)
            {
                double vertex[3];
                for (int j = 0; j < 3; j++)
                    vertex [j] = tessPts[ 9*iTriang + 3*iVert + j ];
 
                // Check if vertex exist in the grid
                TPL_MAP_ENTITE<MG_NOEUD*> neighbouring_nodes;
                grid.rechercher(vertex[0], vertex[1], vertex[2], epsilon, neighbouring_nodes);
 
                int nb_neighbours = neighbouring_nodes.get_nb();
                double distance_closest_node = 1E308;
                MG_NOEUD * closest_node = NULL;
                for (int itNode=0; itNode<nb_neighbours; itNode++)
                {
                    MG_NOEUD * n = neighbouring_nodes.get(itNode);
                    double node_vertex_distance = pow(n->get_x()-vertex[0],2) + pow(n->get_y()-vertex[1],2) + pow(n->get_z()-vertex[2],2);
                    if ( node_vertex_distance < distance_closest_node )
                    {
                        distance_closest_node = node_vertex_distance;
                        closest_node = n;
                    }
                }
                if ( distance_closest_node > epsilon*epsilon )
                {
                    // if no nodes exist in the neighbouring of the vertex, then add a new node
                    triangNodes[iVert] = tess->ajouter_mg_noeud (face, vertex[0], vertex[1], vertex[2],TRIANGULATION);
                    // Add the new node to the grid
                    grid.inserer( triangNodes[iVert] );
                }
                else
                {
                    triangNodes[iVert] = closest_node;
                }
            }
            tess->ajouter_mg_triangle(face, triangNodes[0], triangNodes[1], triangNodes[2],TRIANGULATION);
        }
        std::vector<MG_SEGMENT*> tmp;
        lst_face_contourSegments[face] = tmp;
    }
 
 
 
 
    // vector containing missing vertex nodes
    // (node that have to be inserted in the tessellation
    // to represent a vertex missing in the tessellation)
    std::vector<MG_NOEUD*> missing_vertex_node;
    double epsilon_vertex = 1E-6*sqrt(pow(bbox[3]-bbox[0],2)+pow(bbox[4]-bbox[1],2)+pow(bbox[5]-bbox[2],2));
    // Construct the tessellation of the vertices of the body
    long nb_vertices = geom->get_nb_mg_sommet();
    for (long iVert = 0; iVert < nb_vertices; iVert++)
    {
        MG_SOMMET * vertex = geom->get_mg_sommet(iVert);
        double vertex_pos [3];
        vertex->get_point()->evaluer(vertex_pos);
 
        // Check if vertex exist in the grid
        TPL_MAP_ENTITE<MG_NOEUD*> neighbouring_nodes;
        grid.rechercher(vertex_pos[0], vertex_pos[1], vertex_pos[2], epsilon_vertex, neighbouring_nodes);
 
        int nb_neighbours = neighbouring_nodes.get_nb();
        double distance_closest_node = 1E308;
        MG_NOEUD * closest_node = NULL;
        for (int itNode=0; itNode<nb_neighbours; itNode++)
        {
            MG_NOEUD * n = neighbouring_nodes.get(itNode);
            double node_vertex_distance = pow(n->get_x()-vertex_pos[0],2)+pow(n->get_y()-vertex_pos[1],2)+pow(n->get_z()-vertex_pos[2],2);
            if ( node_vertex_distance < distance_closest_node && node_vertex_distance < epsilon_vertex*epsilon_vertex )
            {
                distance_closest_node = node_vertex_distance;
                closest_node = n;
            }
        }
        if (closest_node)
        {
            closest_node->change_lien_topologie(vertex);
            closest_node->change_coord(vertex_pos);
        }
        else
        {
            // if no nodes exist in the neighbouring of the vertex_pos, then
            // it is an error in the tessellation of the body
            printf("Warning : while importing SW tessellation, the distance between the vertex and the tessellation node is\n");
            printf("%e while the tolerance is %e\n", sqrt(distance_closest_node), epsilon_vertex);
            printf("Warning : while importing the tessellation from SW no tessellation node was found for vertex id %d\n", vertex->get_id());
            printf("A new node located of the missing vertex \n is gonna be inserted on the closest contour segment\n");
            MG_NOEUD * n = new MG_NOEUD(vertex, vertex_pos[0], vertex_pos[1], vertex_pos[2],TRIANGULATION);
            tess->ajouter_mg_noeud(n);
            missing_vertex_node.push_back(n);
        }
    }
 
    // Construct the tessellation of the edges of the body
    LISTE_MG_SEGMENT::iterator itSeg;
    for (MG_SEGMENT * seg=tess->get_premier_segment(itSeg);
            seg; seg=tess->get_suivant_segment(itSeg))
    {
        TPL_LISTE_ENTITE<MG_TRIANGLE*> * lst_triangle = seg->get_lien_triangle();
 
        unsigned nb_adj_triang = lst_triangle->get_nb();
        if (nb_adj_triang == 0)
            continue;
        if (nb_adj_triang == 1)
        {
            continue;
        }
 
        std::set <MG_FACE * > adjacent_faces;
 
        for (unsigned it_triang = 0; it_triang < nb_adj_triang; it_triang++)
        {
            MG_ELEMENT_TOPOLOGIQUE * topo = lst_triangle->get(it_triang)->get_lien_topologie();
            MG_FACE * face = (MG_FACE*) topo;
 
            adjacent_faces.insert(face);
        }
        if (adjacent_faces.size() > 1)
        {
            for (std::set <MG_FACE*>::const_iterator it_adjacent_face = adjacent_faces.begin();
                    it_adjacent_face != adjacent_faces.end();
                    it_adjacent_face++)
            {
                MG_FACE * adj_face = *it_adjacent_face;
                lst_face_contourSegments[adj_face].push_back(seg);
            }
        }
    }
 
    std::set <MG_ARETE *> lst_missing_vertex_edge;
    for (unsigned it_node = 0; it_node < missing_vertex_node.size(); it_node++)
    {
        MG_NOEUD * n = missing_vertex_node[it_node];
        MG_SOMMET * vertex = (MG_SOMMET*) n->get_lien_topologie();
 
        // Get the edges adjacent to this vertex
        std::set <MG_FACE*> lst_adjacent_faces;
        int it_cov;
        for (it_cov = 0; it_cov < vertex->get_nb_mg_cosommet(); it_cov++)
        {
            MG_ARETE * edge = vertex->get_mg_cosommet(it_cov)->get_arete();
            int nb_adjacent_faces = edge->get_nb_mg_coarete();
 
            lst_missing_vertex_edge.insert(edge);
 
            for (int j=0; j < nb_adjacent_faces; j++)
                lst_adjacent_faces.insert ( edge->get_mg_coarete(j)->get_boucle()->get_mg_face() );
        }
 
        // Get the tessellation of the contours of the faces
        // that are shared by several faces
        // These segments are the tessellation of edges
        // which join adjacent faces
        std::set<MG_SEGMENT*> visited_segs;
        std::set<MG_SEGMENT*> shared_segs;
        for (std::set<MG_FACE *>::iterator
                it_face =  lst_adjacent_faces.begin();
                it_face != lst_adjacent_faces.end();
                it_face ++)
        {
            MG_FACE * face = *it_face;
 
            const std::vector < MG_SEGMENT *> & segs = lst_face_contourSegments[face];
 
            for (std::vector<MG_SEGMENT *>::const_iterator
                    itSegs =  segs.begin();
                    itSegs != segs.end();
                    itSegs ++ )
            {
                bool segment_shared_by_several_faces = (visited_segs.find(*itSegs) != visited_segs.end() );
                if (segment_shared_by_several_faces)
                    shared_segs.insert(*itSegs);
                else
                    visited_segs.insert(*itSegs);
            }
        }
 
        double n_xyz[3];
        n_xyz[0] = n->get_x();
        n_xyz[1] = n->get_y();
        n_xyz[2] = n->get_z();
 
        // Find the closest segment to this node
        double minDist = 1E99;
        MG_SEGMENT * closestSeg = NULL;
        for (std::set<MG_SEGMENT *>::iterator it_seg = shared_segs.begin();
                it_seg != shared_segs.end(); it_seg++)
        {
            MG_SEGMENT * seg = *it_seg;
            double seg_xyz[2][3];
            MG_NOEUD *seg_nodes [2];
            seg_nodes[0] = seg->get_noeud1();
            seg_nodes[1] = seg->get_noeud2();
            seg_xyz[0][0] = seg_nodes[0]->get_x();
            seg_xyz[0][1] = seg_nodes[0]->get_y();
            seg_xyz[0][2] = seg_nodes[0]->get_z();
            seg_xyz[1][0] = seg_nodes[1]->get_x();
            seg_xyz[1][1] = seg_nodes[1]->get_y();
            seg_xyz[1][2] = seg_nodes[1]->get_z();
            double distance = OT_ALGORITHME_GEOMETRIQUE::Dist3D_Point_Segment(seg_xyz[0],seg_xyz[1],n_xyz);
            if (distance < minDist)
            {
                minDist = distance;
                closestSeg = seg;
            }
        }
 
        MG_SEGMENT * splitSegs[2];
        MG_MAILLAGE_OUTILS::inserer_noeud_segment(tess, n, closestSeg, splitSegs);
 
 
        for (std::set<MG_FACE *>::iterator
                it_face =  lst_adjacent_faces.begin();
                it_face != lst_adjacent_faces.end();
                it_face ++)
        {
            MG_FACE * face = *it_face;
 
            std::vector < MG_SEGMENT *> & segs = lst_face_contourSegments[face];
 
            std::vector<MG_SEGMENT*>::iterator itSeg = std::find(segs.begin(), segs.end(), closestSeg);
            if (itSeg != segs.end())
            {
                segs.erase(itSeg);
                segs.push_back(splitSegs[0]);
                segs.push_back(splitSegs[1]);
            }
        }
    }
 
 
 
    long nb_edges = geom->get_nb_mg_arete();
    std::set<MG_ARETE *> lst_recognized_edge;
    for (long it_edge = 0; it_edge < nb_edges; it_edge++)
    {
        MG_ARETE * edge = geom->get_mg_arete(it_edge);
 
        // Get the faces adjacent to edge
        int nb_adjacent_faces = edge->get_nb_mg_coarete();
        std::set<MG_FACE *> lst_adjacent_faces;
        for (int j=0; j < nb_adjacent_faces; j++)
            lst_adjacent_faces.insert ( edge->get_mg_coarete(j)->get_boucle()->get_mg_face() );
 
 
        // Get the tessellation of the contours of the faces
        // that are shared by several faces
        // These segments are the tessellation of edges
        // which join adjacent faces
        std::set<MG_SEGMENT*> visited_segs;
        std::set<MG_SEGMENT*> shared_segs;
        for (std::set<MG_FACE *>::iterator
                it_face =  lst_adjacent_faces.begin();
                it_face != lst_adjacent_faces.end();
                it_face ++)
        {
            MG_FACE * face = *it_face;
 
            const std::vector < MG_SEGMENT *> & segs = lst_face_contourSegments[face];
 
            for (std::vector<MG_SEGMENT *>::const_iterator
                    itSegs =  segs.begin();
                    itSegs != segs.end();
                    itSegs ++ )
            {
                bool segment_shared_by_several_faces = (visited_segs.find(*itSegs) != visited_segs.end() );
                if (segment_shared_by_several_faces)
                    shared_segs.insert(*itSegs);
                else
                    visited_segs.insert(*itSegs);
            }
        }
 
        std::set<MG_ARETE*> lst_candidate_edge;
        MG_MAILLAGE_OUTILS::FindCommonEdgesOfFaces(lst_adjacent_faces, lst_candidate_edge);
 
        std::set < MG_SEGMENT * > segs = shared_segs;
        // Tant que (segs) n'est pas vide :
        while (segs.size())
        {
            //((segs^E), N^i') = Parcourir ( (segs), (Nv), (visited_seg), (visited_N)) :
            std::vector <MG_SEGMENT *> visitedSegs;
            std::vector <MG_NOEUD * > visitedNodes;
 
            if (lst_missing_vertex_edge.find(edge) != lst_missing_vertex_edge.end())
                printf("Trying to recognize segments of an edge which had a missing vertex !\n");
 
            MG_MAILLAGE_OUTILS::classe_elements_dimension1(segs, visitedSegs, visitedNodes);
            std::set < MG_SOMMET * > edgeExtremities;
            MG_SOMMET * vertex1=(MG_SOMMET*) visitedNodes[ 0 ]->get_lien_topologie();
            MG_SOMMET * vertex2=((MG_SOMMET*) visitedNodes[ visitedNodes.size()-1 ]->get_lien_topologie());
            edgeExtremities.insert ( vertex1 );
            edgeExtremities.insert ( vertex2 );
 
            MG_ARETE * coincident_edge=0;
 
            if (visitedSegs.size() == 0)
                printf("No segments were found for edge %d", edge->get_id());
 
            // if there is no more segments for other edges, then
            // use edge in priority !
 
            if (lst_candidate_edge.size() == 1)
            {
                coincident_edge = *(lst_candidate_edge.begin());
            }
            else
            {
                MG_MAILLAGE_OUTILS::IdentifyEdge3 ( edgeExtremities, lst_candidate_edge, visitedNodes, &coincident_edge );
 
                std::set<MG_ARETE*>::iterator it_candidate_edge = lst_candidate_edge.find(coincident_edge);
                if (it_candidate_edge != lst_candidate_edge.end())
                    lst_candidate_edge.erase(it_candidate_edge);
            }
 
            lst_recognized_edge.insert(coincident_edge);
 
            if (coincident_edge != edge)
                continue;
 
            for (std::vector<MG_SEGMENT*>::iterator it_visitedSegs = visitedSegs.begin();
                    it_visitedSegs != visitedSegs.end();
                    it_visitedSegs++)
            {
                MG_SEGMENT * segment = (*it_visitedSegs);
                segment->change_lien_topologie(coincident_edge);
                MG_NOEUD * nos[2];
                nos[0]=segment->get_noeud1();
                nos[1]=segment->get_noeud2();
                for (int j=0;j<2;j++)
                {
                    if (nos[j]->get_lien_topologie()->get_dimension() >= 1)
                    {
                        nos[j]->change_lien_topologie(coincident_edge);
                        //ProjectPointToEdge(coincident_edge, 1E-4, nos[j]->get_coord(), nos[j]->get_coord());
                    }
                }
            }
        }
 
        if (lst_recognized_edge.find(edge) == lst_recognized_edge.end())
        {
            printf("Problem while classifying the segments of this edge no segment was found for edge %d\n", edge->get_id());
            it_edge--;
        }
    }
 
 
    /*    for (std::map<MG_FACE *, double *>::const_iterator it_face_tessPts = lst_face_tessPts.begin();
    it_face_tessPts != lst_face_tessPts.end();
    it_face_tessPts ++)
    {
    MG_FACE * face = it_face_tessPts->first;
    int sense = VerifyFaceOrientation(face);
    if (sense != 1)
    printf("Warning: SLD_IMPORT::importer() method returned a face with bad orientation!\n");
    }*/
 
    return geom;
}
 
 
#endif