reconstruction/src/occ_fonction.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuillière et Vincent FRANCOIS
//  Département de Génie Mécanique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du département
//  de génie mécanique de l'Université du Québec à
//  Trois Rivières
//  Les librairies ne peuvent être utilisées sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       occ_fonction.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 à 11H22
//------------------------------------------------------------
//------------------------------------------------------------
#include "gestionversion.h"

#pragma hdrstop

#include "OCC_fonction.h"
#include "tpl_map_entite.h"
#include <atl\atlmod.h>

//---------------------------------------------------------------------------

#pragma package(smart_init)

OCC_FONCTION::OCC_FONCTION()
{
}

OCC_FONCTION::~OCC_FONCTION()
{
}
//******************************************************************************
//fonction:  Creer_Coquille
//purpose:
//******************************************************************************

int OCC_FONCTION::Creer_Coquille()
{
        Cons_Brep.MakeShell(Cons_Coquille);
        return true;
}
//******************************************************************************
//fonction: Ajouter_face_coquille
//purpose:
//******************************************************************************
int OCC_FONCTION::Ajouter_face_Coquille()
{
        Cons_Brep.Add(Cons_Coquille,Cons_Face);
        return true;
}
//******************************************************************************
//fonction: Enregistrer
//purpose:
//******************************************************************************
int OCC_FONCTION::Enregistrer(char* path)
{

        TopoDS_Solid Sol;
        Cons_Brep.MakeSolid(Sol);
        Cons_Brep.Add(Sol,Cons_Coquille);
        STEPControl_Writer writer;
        writer.Transfer(Sol, STEPControl_ManifoldSolidBrep);
        writer.Write(path);
        return true;

}
//******************************************************************************
//fonction: Ajouter_Contour_Face
//purpose:
//******************************************************************************
int OCC_FONCTION::Ajouter_Contour_Face(int num_loop)
{
       TopoDS_Wire W11 = Cons_Contour;
        if (num_loop==0)
        {
                //W11.Reverse();
                Cons_Face = BRepBuilderAPI_MakeFace(Cons_Surface,W11,Standard_True);

                BRepBuilderAPI_MakeFace F3(Cons_Surface);
                F3.Init(Cons_Surface,Standard_False);
                F3.Add(W11);

                Cons_Face = F3;

                Face_Revol = F3.IsDone();
        }
        if(num_loop > 0)
                                {
                                        BRepBuilderAPI_MakeFace F2(Cons_Surface);
                                        F2.Init(Cons_Surface,Standard_False);
                                        F2.Add(W11);

                                        if(F2.IsDone())
                                        {
                                                W11.Reverse();
                                        }
                                        Cons_Face = BRepBuilderAPI_MakeFace(Cons_Face,W11);
                                }
        return true;
}

//******************************************************************************
//fonction: Face_Revolution
//purpose:
//******************************************************************************
int OCC_FONCTION::Face_Revolution()
{
       return Face_Revol;
}

//******************************************************************************
//fonction:Creer_Surface_Cylindrique
//purpose:
//******************************************************************************
int OCC_FONCTION::Creer_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);

        Cons_Surface= new Geom_CylindricalSurface(gp_Cylinder(Axe, Rayon));
        return true;
}
//******************************************************************************
//fonction:Creer_Surface_Conique
//purpose:
//******************************************************************************
int OCC_FONCTION::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);

        Cons_Surface = new Geom_ConicalSurface(Axe,Angle,Rayon);
        return true;

}
//******************************************************************************
//fonction:Creer_Surface_Torique
//purpose:
//******************************************************************************
int OCC_FONCTION::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);

        Cons_Surface = new Geom_ToroidalSurface(Axe,GRayon,PRayon);
        return true;
}
//******************************************************************************
//fonction: Creer_Surf_Spherique
//purpose:
//******************************************************************************
int OCC_FONCTION::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);

        Cons_Surface = new Geom_SphericalSurface(Axe,Rayon);
        return true;
}
//******************************************************************************
//fonction: Initialiser_Surface
//purpose:
//******************************************************************************
int OCC_FONCTION::Initialiser_Surface()
{
       BPSurf = GeomPlate_BuildPlateSurface(3,10,3);
        return true;

}
//******************************************************************************
//fonction: Rapprocher_Surface_Point
//purpose:
//******************************************************************************
int OCC_FONCTION::Rapprocher_Surface_Point(double x1, double y1, double z1)
{
        gp_Pnt P(x1,y1,z1);
        Handle(GeomPlate_PointConstraint) PCont= new GeomPlate_PointConstraint(P,0);
        BPSurf.Add(PCont);

        return true;
}
//******************************************************************************
//fonction: Calculer_Surface
//purpose:
//******************************************************************************

int OCC_FONCTION::Calculer_Surface()
{
       BPSurf.Perform();
       return true;
}
//******************************************************************************
//fonction: Determiner_Surface
//purpose:
//******************************************************************************
int OCC_FONCTION::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);
        Cons_Surface = Mapp1.Surface();
        return true;
}

//******************************************************************************
//fonction: Ajouter_Point_Courbe
//purpose:
//******************************************************************************
TColgp_Array1OfPnt Array(1,1000);
int OCC_FONCTION::Ajouter_Point_Courbe(double x1, double y1, double z1, int i1)
{
       Array.SetValue(i1,gp_Pnt(x1,y1,z1));
        return true;
}

//******************************************************************************
//fonction: Ajouter_courbe_liste
//purpose:
//******************************************************************************
TColGeom_Array1OfBSplineCurve ArrayCurve(1,4);
int OCC_FONCTION::Ajouter_courbe_liste(int nb_pts,int num)
{
         TColgp_Array1OfPnt Array00(1,nb_pts);

        for(int ii = 1; ii<=nb_pts;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;
}
//******************************************************************************
//fonction: Construire_Surface_Contour
//purpose:
//******************************************************************************
int OCC_FONCTION::Construire_Surface_Contour(int num)
{
       if(num==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);   
                Cons_Surface = aConstrained.Surface();
        }

        if(num ==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);
                Cons_Surface = aConstrained.Surface();
        }
        return true;

}

//******************************************************************************
//fonction: Creer_Face_Surface
//purpose:
//******************************************************************************
int OCC_FONCTION::Creer_Face_Surface()
{
       Cons_Face = BRepBuilderAPI_MakeFace(Cons_Surface);
        return true;
}


//******************************************************************************
//fonction:Creer_Contour
//purpose:
//******************************************************************************
int OCC_FONCTION::Creer_Contour()
{
        TopoDS_Wire W;
        Cons_Contour = W;

        return true;
}


//******************************************************************************
//fonction: Creer_Arete_Lineaire
//purpose:
//******************************************************************************

int OCC_FONCTION::Creer_Arete_Lineaire(double P1[3], double P2[3])
{
        GeomAPI_ProjectPointOnSurf Proj1(gp_Pnt(P1[0],P1[1],P1[2]),Cons_Surface);
        Proj1.LowerDistanceParameters(U, V);
        gp_Pnt2d P1_2D(U,V);

        GeomAPI_ProjectPointOnSurf Proj2(gp_Pnt(P2[0],P2[1],P2[2]),Cons_Surface);
        Proj2.LowerDistanceParameters(U, V);
        gp_Pnt2d P2_2D(U,V);    

        Cons_Courbe2d = GCE2d_MakeSegment (P1_2D, P2_2D);

        Cons_Arete = BRepBuilderAPI_MakeEdge(Cons_Courbe2d,Cons_Surface);

        Cons_Contour.Add(Cons_Arete);

        return true;
}

//******************************************************************************
//fonction: Creer_Arete_Circulaire
//purpose:
//******************************************************************************
int OCC_FONCTION::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]),Cons_Surface);
        Proj.LowerDistanceParameters(U, V);
        gp_Pnt2d Pnt_Ins2D(U,V);

        GeomAPI_ProjectPointOnSurf Proj1(gp_Pnt(P1[0],P1[1],P1[2]),Cons_Surface);
        Proj1.LowerDistanceParameters(U, V);
        gp_Pnt2d P1_2D(U,V);

        GeomAPI_ProjectPointOnSurf Proj2(gp_Pnt(P2[0],P2[1],P2[2]),Cons_Surface);
        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);      
        

        Cons_Courbe2d = GCE2d_MakeArcOfCircle (Circ, P1_2D, P2_2D, Standard_True);
        Cons_Arete= BRepBuilderAPI_MakeEdge(Cons_Courbe2d,Cons_Surface);
        Cons_Contour.Add(Cons_Arete);

        return true;
}
////****************************************************************************
//fonction:Creer_Arete_Elliptique
//purpose:
//******************************************************************************
int OCC_FONCTION::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]),Cons_Surface);
        Proj.LowerDistanceParameters(U, V);
        gp_Pnt2d Pnt_Ins2D(U,V);

        GeomAPI_ProjectPointOnSurf Proj1(gp_Pnt(P1[0],P1[1],P1[2]),Cons_Surface);
        Proj1.LowerDistanceParameters(U, V);
        gp_Pnt2d P1_2D(U,V);

        GeomAPI_ProjectPointOnSurf Proj2(gp_Pnt(P2[0],P2[1],P2[2]),Cons_Surface);
        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); 
        
        Cons_Courbe2d = GCE2d_MakeArcOfEllipse (Ellipse, P1_2D, P2_2D, Standard_True);
        Cons_Arete = BRepBuilderAPI_MakeEdge(Cons_Courbe2d,Cons_Surface);

        return true;
}

//******************************************************************************
//fonction: Ajouter_Point_Arete
//purpose:
//******************************************************************************

TColgp_Array1OfPnt2d Array01(1,1000);
int OCC_FONCTION::Ajouter_Point_Arete(double x, double y, double z, int i)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnSurf Proj(P,Cons_Surface);
        Proj.LowerDistanceParameters(U, V);
        Array01.SetValue(i,gp_Pnt2d(U,V));

        return true;
}

//******************************************************************************
//fonction: Rapprocher_Surface_Courbe_Spline
//purpose:
//******************************************************************************
int OCC_FONCTION::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;
}
//******************************************************************************
//fonction: Ajouter_Arete_Contour
//purpose:
//******************************************************************************
int OCC_FONCTION::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,Cons_Surface);
        Cons_Contour.Add(E);


        return true;
}
//******************************************************************************
//fonction: Initialiser_Surface_Cylindrique
//purpose:
//******************************************************************************
int OCC_FONCTION::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;
}
//******************************************************************************
//fonction: Initialiser_Surface_Surface
//purpose:
//******************************************************************************
int OCC_FONCTION::Initialiser_Surface_Surface()
{
        BPSurf = GeomPlate_BuildPlateSurface(Cons_Surface,3,10,3);
        return true;
}


//******************************************************************************
//fonction:Ajouter_Point_Array_Ideal
//purpose:
//******************************************************************************

TColgp_Array1OfPnt Array_Point_Ideal(1,1000);

int OCC_FONCTION::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;
}

//******************************************************************************
//fonction: Determiner_Param_Boite
//purpose:
//******************************************************************************

gp_Pnt P_def;
gp_Vec V11_def;
gp_Vec V22_def;
gp_Vec V33_def;
double Array_Boite[12];

int OCC_FONCTION::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;
}

//******************************************************************************
//fonction: Get_Param_Boite
//purpose:
//******************************************************************************

double OCC_FONCTION::Get_Param_Boite(int ii)
{
        return Array_Boite[ii];
}

//******************************************************************************
//fonction:  Determiner_Plan
//purpose:   idéalisation d'une surface plane //méthode des moindres carrés
//******************************************************************************

int OCC_FONCTION::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();
        Cons_Surface = new Geom_Plane(Plan);

        return true;
}
//******************************************************************************
//fonction: Ligne_Revolution
//purpose:
//******************************************************************************

int OCC_FONCTION::Ligne_Revolution(double Pnt_Inser[], double Vect_Direc[])
{
        gp_Pnt P(Pnt_Inser[0],Pnt_Inser[1],Pnt_Inser[2]);
        gp_Dir V(Vect_Direc[0],Vect_Direc[1],Vect_Direc[2]);

        Handle(Geom_Line) Line = new Geom_Line (P,V);
        Curve_Projection = Line;

        return true;
}

//******************************************************************************
//fonction:  Distance_Point_Curve
//purpose:
//******************************************************************************
double OCC_FONCTION::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;
}

//******************************************************************************
//fonction: Creer_Surface_Cylindrique_Revolution
//purpose:
//******************************************************************************
int OCC_FONCTION::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);       
        Cons_Surface= new Geom_SurfaceOfRevolution(C1,gp_Ax1(gp_Pnt(Pnt_Insersion[0],Pnt_Insersion[1],Pnt_Insersion[2]),Vect));

        return true;
}

//******************************************************************************
//fonction: Pt_Proj_Ligne
//purpose:
//******************************************************************************
double Pt_Proj_Line[3];
int OCC_FONCTION::Pt_Proj_Ligne()
{
        Pt_Proj_Line[1] = N.X();
        Pt_Proj_Line[2] = N.Y();
        Pt_Proj_Line[3] = N.Z();

        return true;
}
//******************************************************************************
//fonction: Pnt_Proj_Ligne
//purpose:
//******************************************************************************
double OCC_FONCTION::Pnt_Proj_Ligne(int ii)
{
        return Pt_Proj_Line[ii];
}
//******************************************************************************
//fonction: GCercle_Tore
//purpose:
//******************************************************************************

int OCC_FONCTION::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;

}
//******************************************************************************
//fonction: Ajouter_Surface_liste_Ideal
//purpose:
//******************************************************************************

TColGeom_Array1OfSurface Array_Surface_Ideal(1,100);

int OCC_FONCTION::Ajouter_Surface_liste_Ideal(int num)
{
        Array_Surface_Ideal.SetValue(num,Cons_Surface);
        return true;
}

//******************************************************************************
//fonction: Projeter_Point_Surface_Idealisee
//purpose:
//******************************************************************************
int OCC_FONCTION::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;
}
//******************************************************************************
//fonction: Pt_Proj_Surface_Ideal
//purpose:
//******************************************************************************
double Pt_Proj_Surf_Ideal[3];
int OCC_FONCTION::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;
}
//******************************************************************************
//fonction: Pnt_Proj_Surface_Ideal
//purpose:
//******************************************************************************

double OCC_FONCTION::Pnt_Proj_Surface_Ideal(int ii)
{
        return Pt_Proj_Surf_Ideal[ii];
}
//******************************************************************************
//fonction: Projeter_Point_Plan_Idealisee
//purpose:
//******************************************************************************

int OCC_FONCTION::Projeter_Point_Plan_Idealisee(double x, double y,double z)
{
        gp_Pnt P(x,y,z);

        GeomAPI_ProjectPointOnSurf Proj(P,Cons_Surface);

        Point_Projetee = Proj.NearestPoint();

        return true;
}
//******************************************************************************
//fonction: Ajouter_Point_AreteUV
//purpose:
//******************************************************************************
int OCC_FONCTION::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,Cons_Surface);
        Proj.LowerDistanceParameters(U, V);
        if((testU==1) && (U<=PI/2))
        {
        U = U+ 2*PI;
        }

        if((testV==1) && (V<=PI/2))
        {
        V = V+ 2*PI;
        }
        Array01.SetValue(i,gp_Pnt2d(U,V));

        return true;
}
//******************************************************************************
//fonction: Analyser_interval_AreteU
//purpose:
//******************************************************************************
double OCC_FONCTION::Analyser_interval_AreteU(double x, double y, double z)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnSurf Proj(P,Cons_Surface);
        Proj.LowerDistanceParameters(U, V);

        return U;
}
//******************************************************************************
//fonction: Analyser_interval_AreteV
//purpose:
//******************************************************************************
double OCC_FONCTION::Analyser_interval_AreteV(double x, double y, double z)
{
        gp_Pnt P(x,y,z);
        GeomAPI_ProjectPointOnSurf Proj(P,Cons_Surface);
        Proj.LowerDistanceParameters(U, V);

        return V;

}
Revision:	116
Committed:	Thu Jun 26 16:23:07 2008 UTC (16 years, 10 months ago) by souaissa
Original Path:	*magic/lib/reconstruction/reconstruction/src/OCC_fonction.cpp*
File size:	26451 byte(s)
Log Message:	mise a jour de OCC_FONCTION version open_cascade 6.2