reconstruction/src/occ_fonction.cpp

//---------------------------------------------------------------------------
#include "gestionversion.h"
#ifdef BREP_OCC

#pragma hdrstop

#include "occ_fonction.h"
#include "tpl_map_entite.h"


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

#pragma package(smart_init)


OCC_FONCTION::OCC_FONCTION()
{

}

OCC_FONCTION::~OCC_FONCTION()
{
}


//********************************** Classe Reconstruction generale ************
int OCC_FONCTION::Creer_Coquille()
{
        B.MakeShell(Sh);
        return true;

}
int OCC_FONCTION::Ajouter_face_Coquille()
{
        B.Add(Sh,F1);
        return true;
}
int OCC_FONCTION::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;
}

//************************************ Classe Face Plane ***********************


int OCC_FONCTION::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 == 8) && (OCC_VERSION_MINOR >= 0)
                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 == 8) && (OCC_VERSION_MINOR >= 0)
                                        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;
}


//************************************* Classe Face Cylindrique ****************

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

//************************************* Classe Face Conique ********************

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);

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


//************************************ Classe Tore *****************************

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);

        Surf1 = new Geom_ToroidalSurface(Axe,GRayon,PRayon);    
        return true;
}

//*********************************** Classe Spherique *************************

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);

        Surf1 = new Geom_SphericalSurface(Axe,Rayon);   
        return true;
}


//*********************************** Classe Face NURBS ************************

int OCC_FONCTION::Initialiser_Surface()
{
        BPSurf = GeomPlate_BuildPlateSurface(3,10,3);
        return true;
}
int OCC_FONCTION::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::Calculer_Surface()
{
        BPSurf.Perform();
        return true;
}
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);
        Surf1 = Mapp1.Surface();
        return true;
}


//******************************************************************************


TColgp_Array1OfPnt Array(1,1000);

int OCC_FONCTION::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::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::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::Creer_Face_Surface()
{
        #if (OCC_VERSION_MAJOR == 8) && (OCC_VERSION_MINOR >= 0)
        F1 = BRepBuilderAPI_MakeFace(Surf1,1e-6);                                               
        #else
        F1 = BRepBuilderAPI_MakeFace(Surf1);                                            
        #endif
        return true;
}

//*************************** Classe Contour ***********************************

//BRepBuilderAPI_MakeWire W1;
int OCC_FONCTION::Creer_Contour()
{
        TopoDS_Wire W;
        W1 = W;

        return true;
}


//*************************** Classe Arete Lineaire ****************************

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

        E = BRepBuilderAPI_MakeEdge(Curve,Surf1);

        W1.Add(E);

        return true;

}


//**************************** Classe Arete Circulaire *************************
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]),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);
        E = BRepBuilderAPI_MakeEdge(Curve,Surf1);
        W1.Add(E);
        return true;
}


//*************************** Classe Arete Elliptique **************************

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]),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);
        E = BRepBuilderAPI_MakeEdge(Curve,Surf1);

        return true;
}


//*************************** Classe Arete Spline ******************************

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,Surf1);
        Proj.LowerDistanceParameters(U, V);
        Array01.SetValue(i,gp_Pnt2d(U,V));      
        
        return true;
}


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;
}


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,Surf1);
        W1.Add(E);


        return true;
}


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;
}

int OCC_FONCTION::Initialiser_Surface_Surface()
{
        BPSurf = GeomPlate_BuildPlateSurface(Surf1,3,10,3);
        return true;
}

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;
}

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;
}

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

}


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();
        Surf1 = new Geom_Plane(Plan);

        return true;
}


int OCC_FONCTION::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::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::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::Face_Revolution()
{
        return Face_Revol;
}


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;
}

double OCC_FONCTION::Pnt_Proj_Ligne(int ii)
{
        return Pt_Proj_Line[ii];
}


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;

}

TColGeom_Array1OfSurface Array_Surface_Ideal(1,100);

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


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;
}

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;
}


double OCC_FONCTION::Pnt_Proj_Surface_Ideal(int ii)
{
        return Pt_Proj_Surf_Ideal[ii];
}


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


Revision:	548
Committed:	Wed Sep 10 16:18:01 2014 UTC (10 years, 8 months ago) by francois
File size:	17261 byte(s)
Log Message:	mise a jour compatibilite linux 14.04