CAD4FE_FaceBoundaryPoint.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_FaceBoundaryPoint.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#pragma hdrstop
 
#include "gestionversion.h"
 
#include "CAD4FE_FaceBoundaryPoint.h"
#include "mg_face.h"
#include <math.h>
#include "CAD4FE_MCNode.h"
#include "CAD4FE_Geometric_Tools.h"
 
 
#pragma package(smart_init)
 
using namespace CAD4FE;
 
FaceBoundaryPoint::FaceBoundaryPoint(MCNode * __n, MG_FACE *__refFace)
: _face(__refFace), _node(__n)
{
    if (__n->GetRefEdgeMapping().size() != 0)
        Initialize();
}
 
FaceBoundaryPoint::FaceBoundaryPoint(MCNode * __n,const FaceBoundaryPoint & __fbp)
{            
    coedge1=__fbp.coedge1;
    coedge1T=__fbp.coedge1T;
    coedge2=__fbp.coedge2;
    vecTpCoedge1Der[0]=__fbp.vecTpCoedge1Der[0];
    vecTpCoedge1Der[1]=__fbp.vecTpCoedge1Der[1];
    coedge2T=__fbp.coedge2T;
    vecTpCoedge2Der[0]=__fbp.vecTpCoedge2Der[0];
    vecTpCoedge2Der[1]=__fbp.vecTpCoedge2Der[1];
    _face=__fbp._face;
    _node=__n;
    _tangentFrame=__fbp._tangentFrame;
    _tangentTransform=__fbp._tangentTransform;
    _mergedVertex=__fbp._mergedVertex;
}
 
FaceBoundaryPoint::~FaceBoundaryPoint()
{
}
 
void FaceBoundaryPoint::Initialize()
{
    coedge1 = NULL;
    coedge2 = NULL;
    _mergedVertex = NULL;
 
    OT_VECTEUR_3D faceNormal;
    _face->calcul_normale_unitaire(_node->UV(_face), faceNormal);
    _tangentFrame = GeometricTools::GetPlaneFrame(faceNormal);
    _tangentFrame.transpose(_tangentTransform);
 
    int dimension = _node->get_lien_topologie_reference()->get_dimension();
    for (MCNode::EMapIterator itEdge = _node->GetRefEdgeMapping().begin();
        itEdge != _node->GetRefEdgeMapping().end();
        itEdge++)
    {
        MG_ARETE * edge = itEdge->first;
        unsigned nb_adjacent_face = edge->get_nb_mg_coarete();
        for (unsigned i=0; i<nb_adjacent_face; i++)
        {
            MG_COARETE *coedge = edge->get_mg_coarete(i);
            MG_FACE * adjacent_face = coedge->get_boucle()->get_mg_face();
 
            if (adjacent_face == _face)
            {
                if (dimension == 0)
                {
                    MG_SOMMET *v1 = edge->get_cosommet1()->get_sommet();
                    MG_SOMMET *v2 = edge->get_cosommet2()->get_sommet();  
                    if (coedge->get_orientation() == -1 ) std::swap(v1,v2);
                    MG_SOMMET *v=(MG_SOMMET*)_node->get_lien_topologie_reference();
                    if (!GeometricTools::MG_FACE_Contains_MG_SOMMET(_face, v))
                    {
                        if (_node->IsInVertex(v1))
                        {
                            coedge2 = coedge;
                            coedge2T = itEdge->second;
                            if (_node->GetRefVertexMapping().size()>1)
                            {
                                _mergedVertex = v1;
                            }
                        }
                        if (_node->IsInVertex(v2))
                        {coedge1 = coedge; coedge1T = itEdge->second; }
                    }
                    else
                    {                                                                
                        if (v==v1) {coedge2 = coedge; coedge2T = itEdge->second; }
                        if (v==v2) {coedge1 = coedge; coedge1T = itEdge->second; }
                    }
                }
                else
                {
                  coedge1 = coedge; coedge1T = itEdge->second;
                  break;
                }
            }
        }
    }
 
    OT_VECTEUR_3D vecCoedge1Der, vecTpCoedge1DerTemp;
    coedge1->get_arete()->deriver(coedge1T, vecCoedge1Der);
    vecCoedge1Der *=  coedge1->get_orientation();
    vecTpCoedge1DerTemp = _tangentTransform*vecCoedge1Der;
    vecTpCoedge1Der[0]=vecTpCoedge1DerTemp[0];
    vecTpCoedge1Der[1]=vecTpCoedge1DerTemp[1];
 
    if (dimension == 0 && coedge2)
    {
        OT_VECTEUR_3D vecCoedge2Der, vecTpCoedge2DerTemp;
        coedge2->get_arete()->deriver(coedge2T, vecCoedge2Der);
        vecCoedge2Der *=  coedge2->get_orientation();
        vecTpCoedge2DerTemp = _tangentTransform*vecCoedge2Der;
        vecTpCoedge2Der[0]=vecTpCoedge2DerTemp[0];
        vecTpCoedge2Der[1]=vecTpCoedge2DerTemp[1];
    }
}
 
int FaceBoundaryPoint::TestInteriorDirection(double __direction[3])
{
    if (_node->GetRefEdgeMapping().size() == 0)
        return 1;
 
    OT_VECTEUR_3D vecDir(__direction), vecTpDir;
    vecTpDir = _tangentTransform*vecDir;
    double angleMin, angleMax, angle;
 
    if (coedge2) // the point is on a vertex
        angleMin = GeometricTools::AngleInPlane(vecTpCoedge1Der, vecTpCoedge2Der);
    else
        angleMin = 0;
 
    angleMax = M_PI;
 
    angle = GeometricTools::AngleInPlane( vecTpCoedge1Der, vecTpDir );
 
    double angularTol = 1E-2;
    if ( fabs(angle-angleMax) <= angularTol || fabs(angle-angleMin) <= angularTol )
        return 0;
    else if ( ( angle > angleMax) || (angle < angleMin) )
        return -1;
        
    return +1;
}
               
double FaceBoundaryPoint::GetInteriorDirectionAngle(double __direction[3])
{
    if (_node->GetRefEdgeMapping().size() == 0)
        return 1;
 
    OT_VECTEUR_3D vecDir(__direction), vecTpDir;
    vecTpDir = _tangentTransform*vecDir;
    double angleMin, angleMax, angle;
 
    if (coedge2) // the point is on a vertex
        angleMin = GeometricTools::AngleInPlane(vecTpCoedge1Der, vecTpCoedge2Der);
    else
        angleMin = 0;
 
    angleMax = M_PI;
 
    angle = GeometricTools::AngleInPlane( vecTpCoedge1Der, vecTpDir );
    if (angle < 0 && fabs(angle+M_PI) < 1E-6*M_PI)
        angle += 2*M_PI;        
 
    if ( (angle == angleMax) || (angle == angleMin) )
        return 0;
    else if ( angle > angleMax)
        return (angleMax-angle);
    else if (angle < angleMin)
        return (angle-angleMin);
        
    return angleMax - angle;
}
 
MG_SOMMET * FaceBoundaryPoint::GetMergedVertex()
{
    return _mergedVertex;
}
 
 
MCNode * FaceBoundaryPoint::GetNode()
{
    return _node;
}