occ_fonction_reconstruction.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       occ_fonction_reconstruction.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "gestionversion.h"
#ifdef BREP_OCC
 
#pragma hdrstop
 
#include "occ_fonction_reconstruction.h"
#include "tpl_map_entite.h"
#include "Geom_BSplineSurface.hxx"
#include "Geom2d_Curve.hxx"
 
 
#pragma package(smart_init)
 
 
 
OCC_FONCTION_RECONSTRUCTION::OCC_FONCTION_RECONSTRUCTION()
{
 
}
 
OCC_FONCTION_RECONSTRUCTION::~OCC_FONCTION_RECONSTRUCTION()
{
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Coquille()
{
        B.MakeShell(Sh);
        return true;
 
}
int OCC_FONCTION_RECONSTRUCTION::Ajouter_face_Coquille()
{
        B.Add(Sh,F1);
        return true;
}
int OCC_FONCTION_RECONSTRUCTION::Enregistrer(char* fich)
{
        TopoDS_Solid Sol;
        B.MakeSolid(Sol);
        B.Add(Sol,Sh);
        STEPControl_Writer writer;      
        writer.Transfer(Sol, STEPControl_ManifoldSolidBrep);    
        writer.Write(fich);
        return true;
}
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Ajouter_Contour_Face(int num_loop)
{
        TopoDS_Wire W11 = W1;
        if (num_loop==0)
        {
                //W11.Reverse();
    const Handle_Geom_Surface Surf=Surf1;
                F1 = BRepBuilderAPI_MakeFace(Surf,W11,Standard_True);
                
        #if (((OCC_VERSION_MAJOR == 6) && (OCC_VERSION_MINOR >= 7)) || (OCC_VERSION_MAJOR > 6))
                BRepBuilderAPI_MakeFace F3(Surf,1e-6);
                F3.Init(Surf,Standard_False,1e-6);
        #else
                BRepBuilderAPI_MakeFace F3(Surf);
                F3.Init(Surf,Standard_False);
        #endif
                F3.Add(W11);
 
                F1 = F3;
                
                Face_Revol = F3.IsDone();
        }
        if(num_loop > 0)
                                {
                                        #if (((OCC_VERSION_MAJOR == 6) && (OCC_VERSION_MINOR >= 7))|| (OCC_VERSION_MAJOR > 6))
                                        BRepBuilderAPI_MakeFace F2(Surf1,1e-6);
                                        F2.Init(Surf1,Standard_False,1e-6);
                                        #else
                                        BRepBuilderAPI_MakeFace F2(Surf1);
                                        F2.Init(Surf1,Standard_False);
                                        #endif
                                        F2.Add(W11);
                                
                                        if(F2.IsDone())
                                        {
                                                W11.Reverse();
                                        }
                                        F1 = BRepBuilderAPI_MakeFace(F1,W11);
                                }                       
        return true;
}
 
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Surface_Cylindrique(double Pnt_Insersion[], double Vect_Directeur[], double Rayon)
{
        gp_Pnt Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]);
        gp_Dir Vect(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
 
        gp_Ax3 Axe(Pnt,Vect);   
 
        Surf1 = new Geom_CylindricalSurface(gp_Cylinder(Axe, Rayon));   
        return true;
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Surface_Conique(double Pnt_Insersion[3], double Vect_Directeur[3],double Rayon, double Angle)
{
        gp_Pnt Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]);
        gp_Dir Vect(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
 
        gp_Ax3 Axe(Pnt,Vect);
 
        Surf1 = new Geom_ConicalSurface(Axe,Angle,Rayon);       
        return true;
}
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Surface_Torique(double Pnt_Insersion[], double Vect_Directeur[], double GRayon, double PRayon)
{
        gp_Pnt Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]);
        gp_Dir Vect(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
 
        gp_Ax3 Axe(Pnt,Vect);
 
        Surf1 = new Geom_ToroidalSurface(Axe,GRayon,PRayon);    
        return true;
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Surf_Spherique(double Pnt_Insersion[], double Vect_Directeur[], double Rayon)
{
        gp_Pnt Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]);
        gp_Dir Vect(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
 
        gp_Ax3 Axe(Pnt,Vect);
 
        Surf1 = new Geom_SphericalSurface(Axe,Rayon);   
        return true;
}
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Initialiser_Surface()
{
        BPSurf = GeomPlate_BuildPlateSurface(3,10,3);
        return true;
}
int OCC_FONCTION_RECONSTRUCTION::Rapprocher_Surface_Point(double x, double y, double z)
{
        gp_Pnt P(x,y,z);
        Handle(GeomPlate_PointConstraint) PCont= new GeomPlate_PointConstraint(P,0);
        BPSurf.Add(PCont);              
 
        return true;
}
int OCC_FONCTION_RECONSTRUCTION::Calculer_Surface()
{
        BPSurf.Perform();
        return true;
}
int OCC_FONCTION_RECONSTRUCTION::Determiner_Surface()
{
        Standard_Integer MaxSeg = 50;
        Standard_Integer MaxDegree=8;
        Standard_Integer CritOrder=4;
        Standard_Real dmax,Tol;
        Handle(GeomPlate_Surface) PSurf1 = BPSurf.Surface();
        dmax = Max(0.0001,10*BPSurf.G0Error());
        Tol=0.0;
        GeomPlate_MakeApprox Mapp1(PSurf1,Tol,MaxSeg,MaxDegree,dmax,0);
        Surf1 = Mapp1.Surface();
        return true;
}
 
 
 
 
TColgp_Array1OfPnt Array(1,1000);
 
int OCC_FONCTION_RECONSTRUCTION::Ajouter_Point_Courbe(double x, double y, double z, int i)
{
        Array.SetValue(i,gp_Pnt(x,y,z));
        return true;
}
 
 
 
TColGeom_Array1OfBSplineCurve ArrayCurve(1,4);
 
int OCC_FONCTION_RECONSTRUCTION::Ajouter_courbe_liste(int nbpts,int num)
{
        TColgp_Array1OfPnt Array00(1,nbpts);
        
        for(int ii = 1; ii<=nbpts;ii++)
        {
                Array00.SetValue(ii,Array(ii));
        }
 
        Handle(Geom_BSplineCurve) SPL0 = GeomAPI_PointsToBSpline(Array00,3,8,GeomAbs_C1,0.).Curve();                                                                    
        ArrayCurve.SetValue(num,SPL0);
 
        return true;
}
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Construire_Surface_Contour(int nb_aretes_ext)
{
        if(nb_aretes_ext ==3)
        {
                Handle(GeomAdaptor_HCurve) SPL1Adaptor = new GeomAdaptor_HCurve(ArrayCurve(1));
                Handle(GeomFill_SimpleBound) B1 = new GeomFill_SimpleBound(SPL1Adaptor,Precision::Approximation(),Precision::Angular());
                Handle(GeomAdaptor_HCurve) SPL2Adaptor = new GeomAdaptor_HCurve(ArrayCurve(2));
                Handle(GeomFill_SimpleBound) B2 = new GeomFill_SimpleBound(SPL2Adaptor,Precision::Approximation(),Precision::Angular());
                Handle(GeomAdaptor_HCurve) SPL3Adaptor = new GeomAdaptor_HCurve(ArrayCurve(3));
                Handle(GeomFill_SimpleBound) B3 = new GeomFill_SimpleBound(SPL3Adaptor,Precision::Approximation(),Precision::Angular());
 
                Standard_Boolean NoCheck= Standard_False;
                Standard_Integer MaxDeg = 8;
 
                Standard_Integer MaxSeg = 50;
 
                GeomFill_ConstrainedFilling aConstrained(MaxDeg, MaxSeg);
                aConstrained.Init(B1,B2,B3, NoCheck);
                Surf1 = aConstrained.Surface();
        }
 
        if(nb_aretes_ext ==4)
        {
 
                Handle(GeomAdaptor_HCurve) SPL1Adaptor = new GeomAdaptor_HCurve(ArrayCurve(1));
                Handle(GeomFill_SimpleBound) B1 = new GeomFill_SimpleBound(SPL1Adaptor,Precision::Approximation(),Precision::Angular());
                Handle(GeomAdaptor_HCurve) SPL2Adaptor = new GeomAdaptor_HCurve(ArrayCurve(2));
                Handle(GeomFill_SimpleBound) B2 = new GeomFill_SimpleBound(SPL2Adaptor,Precision::Approximation(),Precision::Angular());
                Handle(GeomAdaptor_HCurve) SPL3Adaptor = new GeomAdaptor_HCurve(ArrayCurve(3));
                Handle(GeomFill_SimpleBound) B3 = new GeomFill_SimpleBound(SPL3Adaptor,Precision::Approximation(),Precision::Angular());
                Handle(GeomAdaptor_HCurve) SPL4Adaptor = new GeomAdaptor_HCurve(ArrayCurve(4));
                Handle(GeomFill_SimpleBound) B4 = new GeomFill_SimpleBound(SPL4Adaptor,Precision::Approximation(),Precision::Angular());
 
                Standard_Boolean NoCheck= Standard_False;
                Standard_Integer MaxDeg = 8;
 
                Standard_Integer MaxSeg = 50;
 
                GeomFill_ConstrainedFilling aConstrained(MaxDeg, MaxSeg);
                aConstrained.Init(B1,B2,B3,B4, NoCheck);        
                Surf1 = aConstrained.Surface();
        }
        return true;
}
 
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Face_Surface()
{
        #if (((OCC_VERSION_MAJOR == 6) && (OCC_VERSION_MINOR >= 7)) || (OCC_VERSION_MAJOR > 6))
        F1 = BRepBuilderAPI_MakeFace(Surf1,1e-6);                                               
        #else
        F1 = BRepBuilderAPI_MakeFace(Surf1);                                            
        #endif
        return true;
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Contour()
{
        TopoDS_Wire W;
        W1 = W;
 
        return true;
}
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Arete_Lineaire(double P1[3], double P2[3])
{
 
        GeomAPI_ProjectPointOnSurf Proj1(gp_Pnt(P1[0],P1[1],P1[2]),Surf1);
        Proj1.LowerDistanceParameters(U, V);
        gp_Pnt2d P1_2D(U,V);
 
        GeomAPI_ProjectPointOnSurf Proj2(gp_Pnt(P2[0],P2[1],P2[2]),Surf1);
        Proj2.LowerDistanceParameters(U, V);
        gp_Pnt2d P2_2D(U,V);
 
        Curve = GCE2d_MakeSegment(P1_2D, P2_2D).Value();
 
        E = BRepBuilderAPI_MakeEdge(Curve,Surf1);
 
        W1.Add(E);
 
        return true;
 
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Arete_Circulaire(double Pnt_Insersion[3], double Normal[3],double P1[3], double P2[3], double Rayon)
{
        GeomAPI_ProjectPointOnSurf Proj(gp_Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]),Surf1);
        Proj.LowerDistanceParameters(U, V);
        gp_Pnt2d Pnt_Ins2D(U,V);
 
        GeomAPI_ProjectPointOnSurf Proj1(gp_Pnt(P1[0],P1[1],P1[2]),Surf1);
        Proj1.LowerDistanceParameters(U, V);
        gp_Pnt2d P1_2D(U,V);
 
        GeomAPI_ProjectPointOnSurf Proj2(gp_Pnt(P2[0],P2[1],P2[2]),Surf1);
        Proj2.LowerDistanceParameters(U, V);
        gp_Pnt2d P2_2D(U,V);
 
 
        gp_Dir2d Vect(P1_2D.X()-Pnt_Ins2D.X(),P1_2D.Y()-Pnt_Ins2D.Y());
 
        gp_Ax2d Axe(Pnt_Ins2D,Vect);
 
        gp_Circ2d Circ(Axe, Rayon, Standard_True);
 
 
        Curve = GCE2d_MakeArcOfCircle (Circ, P1_2D, P2_2D, Standard_True).Value();
        E = BRepBuilderAPI_MakeEdge(Curve,Surf1);
        W1.Add(E);
        return true;
}
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Arete_Elliptique(double Pnt_Insersion[3], double P1[3], double P2[3], double GRayon, double PRayon)
{
        GeomAPI_ProjectPointOnSurf Proj(gp_Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]),Surf1);
        Proj.LowerDistanceParameters(U, V);
        gp_Pnt2d Pnt_Ins2D(U,V);
 
        GeomAPI_ProjectPointOnSurf Proj1(gp_Pnt(P1[0],P1[1],P1[2]),Surf1);
        Proj1.LowerDistanceParameters(U, V);
        gp_Pnt2d P1_2D(U,V);
 
        GeomAPI_ProjectPointOnSurf Proj2(gp_Pnt(P2[0],P2[1],P2[2]),Surf1);
        Proj2.LowerDistanceParameters(U, V);
        gp_Pnt2d P2_2D(U,V);
 
 
        gp_Dir2d Vect(P1_2D.X()-Pnt_Ins2D.X(),P1_2D.Y()-Pnt_Ins2D.Y());
 
        gp_Ax2d Axe(Pnt_Ins2D,Vect);
 
        gp_Elips2d Ellipse(Axe, GRayon, PRayon, Standard_True);
        
        Curve = GCE2d_MakeArcOfEllipse (Ellipse, P1_2D, P2_2D, Standard_True).Value();
        E = BRepBuilderAPI_MakeEdge(Curve,Surf1);
 
        return true;
}
 
 
 
TColgp_Array1OfPnt2d Array01(1,1000);
 
int OCC_FONCTION_RECONSTRUCTION::Ajouter_Point_Arete(double x, double y, double z, int i)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnSurf Proj(P,Surf1);
        Proj.LowerDistanceParameters(U, V);
        Array01.SetValue(i,gp_Pnt2d(U,V));      
        
        return true;
}
 
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Rapprocher_Surface_Courbe_Spline(int nb_pts)
{
        TColgp_Array1OfPnt Arr(1,nb_pts);
        
        for(int ii = 1; ii<=nb_pts;ii++)
        {
                Arr.SetValue(ii,Array(ii));             
        }
 
        Handle(Geom_BSplineCurve) SPL = GeomAPI_PointsToBSpline (Arr,3,8,GeomAbs_C1,0.).Curve();
        Handle(GeomAdaptor_HCurve) SPL1Adaptor =  new GeomAdaptor_HCurve(SPL);
        Handle(BRepFill_CurveConstraint) Cont= new BRepFill_CurveConstraint(SPL1Adaptor,0);     
        BPSurf.Add(Cont);
 
        return true;
}
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Ajouter_Arete_Contour(int nbpts)
{
        TColgp_Array1OfPnt2d Array02(1,nbpts);
 
        for(int ii = 1; ii<=nbpts;ii++)
        {
                gp_Pnt2d PP = Array01(ii);
                Array02.SetValue(ii,PP);                
        }
 
        Handle(Geom2d_BSplineCurve) SSPL1 = Geom2dAPI_PointsToBSpline(Array02,3,8,GeomAbs_C1,0.).Curve();                               
        TopoDS_Edge E = BRepBuilderAPI_MakeEdge(SSPL1,Surf1);
        W1.Add(E);
 
 
        return true;
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Initialiser_Surface_Cylindrique(double Pnt_Insersion[3], double Vect_Directeur[3],double Rayon)
{
        gp_Pnt Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]);
        gp_Dir Vect(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
        gp_Ax3 Axe(Pnt,Vect);
 
        Handle (Geom_Surface) Surf = new Geom_CylindricalSurface(Axe, Rayon);
        BPSurf = GeomPlate_BuildPlateSurface(Surf,3,10,3);
        return true;
}
 
int OCC_FONCTION_RECONSTRUCTION::Initialiser_Surface_Surface()
{
        BPSurf = GeomPlate_BuildPlateSurface(Surf1,3,10,3);
        return true;
}
 
TColgp_Array1OfPnt Array_Point_Ideal(1,1000);
 
int OCC_FONCTION_RECONSTRUCTION::Ajouter_Point_Array_Ideal(double x, double y, double z, int i)
{
        gp_Pnt Pnt(x,y,z);
        Array_Point_Ideal.SetValue(i,Pnt);
 
        return true;
}
 
int OCC_FONCTION_RECONSTRUCTION::Determiner_Param_Boite(int nb)
{
        TColgp_Array1OfPnt Array_Point_Ideal1(1,nb);
 
        for(int i = 1; i<=nb;i++)
        {
                Array_Point_Ideal1.SetValue(i,Array_Point_Ideal(i));
        }
 
        GProp_PEquation Boite = GProp_PEquation(Array_Point_Ideal1,0);
 
        Boite.Box(P_def, V11_def, V22_def, V33_def);
 
        Array_Boite[1] = P_def.X();
        Array_Boite[2] = P_def.Y();
        Array_Boite[3] = P_def.Z();
 
        Array_Boite[4] = V11_def.X();
        Array_Boite[5] = V11_def.Y();
        Array_Boite[6] = V11_def.Z();
 
        Array_Boite[7] = V22_def.X();
        Array_Boite[8] = V22_def.Y();
        Array_Boite[9] = V22_def.Z();
 
        Array_Boite[10] = V33_def.X();
        Array_Boite[11] = V33_def.Y();
        Array_Boite[12] = V33_def.Z();
 
        return true;
}
 
double OCC_FONCTION_RECONSTRUCTION::Get_Param_Boite(int ii)
{
        return Array_Boite[ii];
 
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Determiner_Plan(int nb, double Epsilon)
{
        TColgp_Array1OfPnt Array_Point_Ideal1(1,nb);
 
        for(int i = 1; i<=nb;i++)
        {
                Array_Point_Ideal1.SetValue(i,Array_Point_Ideal(i));            
        }
 
        GProp_PEquation Equa_plan(Array_Point_Ideal1,Epsilon);
        gp_Pln Plan = Equa_plan.Plane();
        Surf1 = new Geom_Plane(Plan);
 
        return true;
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Ligne_Revolution(double Pnt_Insersion[], double Vect_Directeur[])
{
        gp_Pnt P(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]);
        gp_Dir V(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
 
        Handle(Geom_Line) Line = new Geom_Line (P,V);   
        Curve_Projection = Line;
 
        return true;
}
 
double OCC_FONCTION_RECONSTRUCTION::Distance_Point_Curve(double x, double y, double z)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnCurve PPC (P,Curve_Projection);                      
        N = PPC.NearestPoint();
        
        double distance = PPC.LowerDistance();
        
        return distance;
 
}
 
int OCC_FONCTION_RECONSTRUCTION::Creer_Surface_Cylindrique_Revolution(double Pnt_Insersion[3], double Vect_Directeur[3],double Vecteur1[3],double Rayon)
{
        gp_Pnt Pnt(Pnt_Insersion[0]+Rayon*Vecteur1[0],Pnt_Insersion[1]+Rayon*Vecteur1[1],Pnt_Insersion[2]+Rayon*Vecteur1[2]);
        gp_Dir Vect(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
        
        Handle (Geom_Curve) C1 = new Geom_Line(Pnt,Vect);       
        Surf1 = new Geom_SurfaceOfRevolution(C1,gp_Ax1(gp_Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]),Vect));
 
        return true;
}
 
int OCC_FONCTION_RECONSTRUCTION::Face_Revolution()
{
        return Face_Revol;
}
 
 
 
 
 
 
 
int OCC_FONCTION_RECONSTRUCTION::Pt_Proj_Ligne()
{
        Pt_Proj_Line[1] = N.X();
        Pt_Proj_Line[2] = N.Y();
        Pt_Proj_Line[3] = N.Z();
 
        return true;
}
 
double OCC_FONCTION_RECONSTRUCTION::Pnt_Proj_Ligne(int ii)
{
        return Pt_Proj_Line[ii];
}
 
 
int OCC_FONCTION_RECONSTRUCTION::GCercle_Tore(double Pnt_Insersion[3], double Vect_Directeur[3],double Rayon)
{
        gp_Pnt P(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]);
        gp_Dir V(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
 
        Handle(Geom_Circle) GCercle = new Geom_Circle (gp_Ax2(P,V),Rayon);
        Curve_Projection = GCercle;
 
        return true;
 
}
 
TColGeom_Array1OfSurface Array_Surface_Ideal(1,100);
 
int OCC_FONCTION_RECONSTRUCTION::Ajouter_Surface_liste_Ideal(int num)
{
        Array_Surface_Ideal.SetValue(num,Surf1);
        return true;
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Projeter_Point_Surface_Idealisee(double x, double y,double z, int num)
{
        gp_Pnt P(x,y,z);
        Handle (Geom_Surface) Surf = Array_Surface_Ideal(num);
        GeomAPI_ProjectPointOnSurf Proj(P,Surf);
        
        Point_Projetee = Proj.NearestPoint();
 
        return true;
}
 
int OCC_FONCTION_RECONSTRUCTION::Pt_Proj_Surface_Ideal()
{
        Pt_Proj_Surf_Ideal[1] = Point_Projetee.X();
        Pt_Proj_Surf_Ideal[2] = Point_Projetee.Y();
        Pt_Proj_Surf_Ideal[3] = Point_Projetee.Z();
 
        return true;
}
 
 
double OCC_FONCTION_RECONSTRUCTION::Pnt_Proj_Surface_Ideal(int ii)
{
        return Pt_Proj_Surf_Ideal[ii];
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Projeter_Point_Plan_Idealisee(double x, double y,double z)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnSurf Proj(P,Surf1);
        Point_Projetee = Proj.NearestPoint();
 
        return true;
}
 
 
int OCC_FONCTION_RECONSTRUCTION::Ajouter_Point_AreteUV(int testU, int testV, double x, double y, double z, int i)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnSurf Proj(P,Surf1);
        Proj.LowerDistanceParameters(U, V);
        if((testU==1) && (U<=M_PI/2))
        {
        U = U+ 2*M_PI;
        }
 
        if((testV==1) && (V<=M_PI/2))
        {
        V = V+ 2*M_PI;
        }
        Array01.SetValue(i,gp_Pnt2d(U,V));      
        
        return true;
}
 
double OCC_FONCTION_RECONSTRUCTION::Analyser_interval_AreteU(double x, double y, double z)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnSurf Proj(P,Surf1);
        Proj.LowerDistanceParameters(U, V);
        return U;
}
 
double OCC_FONCTION_RECONSTRUCTION::Analyser_interval_AreteV(double x, double y, double z)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnSurf Proj(P,Surf1);
        Proj.LowerDistanceParameters(U, V);
        return V;
}
 
 
 
#endif