OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-04 13:13:25 +03:00
Code Activity

0022312: Translation of french commentaries in OCCT files

Browse Source
This commit is contained in:
YSN
2011-10-27 07:50:55 +00:00
committed by bugmaster
parent b2342827fa
commit 0d9695538c
214 changed files with 8746 additions and 10449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
src/Approx/Approx_SameParameter.cxx
View File

@@ -35,8 +35,7 @@ static Standard_Boolean AffichFw = Standard_False;
static Standard_Integer NbCurve = 0;
#endif
//
// sert a tester si Extrema raconte pas des betises
//
// allows testing if Extrema produces correct results/
static void ProjectPointOnCurve(const Standard_Real InitValue,
@@ -204,9 +203,9 @@ static Standard_Boolean Check(const TColStd_Array1OfReal& FlatKnots,
#ifdef DEB
if (Voir) {
cout<<endl;
cout<<"Controle du changement de variable : "<<endl;
cout<<"baillement mesure par projection : "<<d<<endl;
cout<<"Nombre de points : "<<nbp<<endl;
cout<<"Control the change of variable : "<<endl;
cout<<"yawn mesured by projection : "<<d<<endl;
cout<<"Number of points : "<<nbp<<endl;
}
#endif
#if 0
@@ -226,8 +225,8 @@ static Standard_Boolean Check(const TColStd_Array1OfReal& FlatKnots,
dglis = sqrt(dglis);
#ifdef DEB
if ( Voir) {
cout<<"glissement de parametre aux points imposes : "<<glis<<endl;
cout<<"distance de glissement aux points imposes : "<<dglis<<endl;
cout<<"shift of parameter to the imposed points : "<<glis<<endl;
cout<<"shift distance at the imposed points : "<<dglis<<endl;
}
#endif
dglis = 0.;
@@ -281,7 +280,7 @@ static Standard_Boolean Check(const TColStd_Array1OfReal& FlatKnots,
tol = sqrt(d2);
#ifdef DEB
if (Voir)
cout<<"distance max sur "<<nn<<" points : "<<tol<<endl<<endl;
cout<<"distance max on "<<nn<<" points : "<<tol<<endl<<endl;
#endif
return ((tol <= d) || (tol > 0.8 * oldtol));
}
@@ -359,9 +358,9 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
if(Continuity > GeomAbs_C1) Continuity = GeomAbs_C1;
//On controle les tangentes aux extremites pour savoir si le
//reparametrage est possible et on calcule les tangentes aux
//extremites de la fonction de changement de variable.
//Control tangents at the extremities to know if the
//reparametring is possible and calculate the tangents
//at the extremities of the function of change of variable.
Standard_Real tangent[2];
gp_Pnt Pcons,Pc3d;
gp_Vec Vcons,Vc3d;
@@ -399,8 +398,8 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
if(dmax2 > besttol2) besttol2 = dmax2;
//On prend un multiple de l echantillon du CheckShape,
//au moins les points de controle seront bons. No comment!!!
//Take a multiple of the sample pof CheckShape,
//at least the control points will be correct. No comment!!!
Standard_Integer NCONTROL = 22;
#ifdef DEB
@@ -409,8 +408,8 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
Standard_Boolean interpolok = 0;
Standard_Real tolsov = 1.e200;
//On prend des parametres a pas constant sur la curve on surface
//et sur la courbe 3d.
//Take parameters with constant step on the curve on surface
//and on curve 3d.
Standard_Real deltacons = lcons - fcons;
deltacons /= (NCONTROL);
Standard_Real deltac3d = lc3d - fc3d;
@@ -530,10 +529,10 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
return;
}
if(!extrok) { // Si pas deja SameP et tgte aux fraise, on abandonne.
if(!extrok) { // If not already SameP and tangent to mill, abandon.
mySameParameter = Standard_False;
#ifdef DEB
cout<<"SameParameter probleme : tangente nulle aux extremites"<<endl;
cout<<"SameParameter problem : zero tangent to extremities"<<endl;
#endif
return;
}
@@ -563,7 +562,7 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
#endif
while(!interpolok){
// Les tableaux et leurs bornes pour l interpolation.
// The tables and their limits for the interpolation.
Standard_Integer num_knots = count + 7;
Standard_Integer num_poles = count + 3;
TColStd_Array1OfReal Paramc3d(*pc3d,1,count+1);
@@ -573,7 +572,7 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
TColStd_Array1OfReal InterpolationParameters(1,num_poles) ;
TColStd_Array1OfReal FlatKnots(1,num_knots) ;
// On remplit les tableaux en faisant attention aux valeurs des bouts.
// Fill tables taking attention to end values.
ContactOrder.Init(0);
ContactOrder(2) = ContactOrder(num_poles - 1) = 1;
@@ -721,7 +720,7 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
if (Precision::IsInfinite(algtol)) {
mySameParameter = Standard_False;
#ifdef DEB
cout<<"SameParameter probleme : fonction d'interpolation du parametrage aux fraises !!"<<endl;
cout<<"SameParameter problem : function of interpolation of parametration at mills !!"<<endl;
#endif
return;
}
@@ -735,7 +734,7 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
#ifdef DEB
if (Voir) {
if(algtol > besttol){
cout<<"SameParameter : Tol non atteinte avant approx"<<endl;
cout<<"SameParameter : Tol can't be reached before approx"<<endl;
}
}
#endif
@@ -760,7 +759,7 @@ void Approx_SameParameter::Build(const Standard_Real Tolerance)
else {
#ifdef DEB
if (Voir)
cout<<"SameParameter : Pas assez de points, on enrichit"<<endl;
cout<<"SameParameter : Not enough points, enrich"<<endl;
#endif
Standard_Integer newcount = 0;

101
src/Approx/Approx_SweepApproximation.cxx
View File

@@ -58,7 +58,7 @@ Approx_SweepApproximation::
Approx_SweepApproximation(const Handle(Approx_SweepFunction)& Func)
{
myFunc = Func;
// Init des variables de controles
// Init of variables of control
myParam = 0;
myOrder = -1;
first = 1.e100; last = -1.e100;
@@ -79,7 +79,7 @@ void Approx_SweepApproximation::Perform(const Standard_Real First,
Standard_Real Tol, Tol3dMin = Tol3d, The3D2DTol=0 ;
GeomAbs_Shape continuity = Continuity;
// (1) Caracteristiques d'une section
// (1) Characteristics of a section
myFunc->SectionShape(NbPolSect, NbKnotSect, udeg);
Num2DSS = myFunc->Nb2dCurves();
tabUKnots = new (TColStd_HArray1OfReal) (1, NbKnotSect);
@@ -87,11 +87,11 @@ void Approx_SweepApproximation::Perform(const Standard_Real First,
myFunc->Knots(tabUKnots->ChangeArray1());
myFunc->Mults(tabUMults->ChangeArray1());
// (2) Decompositition en sous espaces
// (2) Decompositition into sub-spaces
Handle(TColStd_HArray1OfReal) OneDTol, TwoDTol, ThreeDTol;
Num3DSS = NbPolSect;
// (2.1) Tolerance 3d et 1d
// (2.1) Tolerance 3d and 1d
OneDTol = new (TColStd_HArray1OfReal) (1, Num3DSS);
ThreeDTol = new (TColStd_HArray1OfReal) (1, Num3DSS);
@@ -110,24 +110,24 @@ void Approx_SweepApproximation::Perform(const Standard_Real First,
Translation.SetXYZ
(myFunc->BarycentreOfSurf().XYZ());
for (ii=1; ii<=Num3DSS; ii++) {
Tol = ThreeDTol->Value(ii)/2; //Afin de respecter l'erreur sur le resultat final.
Tol = ThreeDTol->Value(ii)/2; // To take accout of the error on the final result.
OneDTol->SetValue(ii, Tol * Wmin(ii) / Size);
Tol *= Wmin(ii); //Facteur de projection
Tol *= Wmin(ii); //Factor of projection
ThreeDTol->SetValue(ii, Max(Tol, 1.e-20) );
}
}
else { Num1DSS = 0; }
// (2.2) Tolerance et Transformation 2d.
// (2.2) Tolerance and Transformation 2d.
if (Num2DSS == 0) {TwoDTol.Nullify();}
else {
// pour le 2d on definit une affinite a partir des resolutions, afin
// d'avoir une tolerance d'approximation homogene (u/v et 2d/3d)
// for 2d define affinity using resolutions, to
// avoid homogenuous tolerance of approximation (u/v and 2d/3d)
Standard_Real res, tolu, tolv;
TwoDTol = new (TColStd_HArray1OfReal) (1, Num2DSS);
AAffin = new (Approx_HArray1OfGTrsf2d) (1, Num2DSS);
The3D2DTol= 0.9*BoundTol; // 10% de securite
The3D2DTol= 0.9*BoundTol; // 10% of security
for (ii=1; ii<=Num2DSS; ii++) {
myFunc->Resolution(ii, The3D2DTol, tolu, tolv);
if ( tolu> tolv ) {
@@ -159,7 +159,7 @@ void Approx_SweepApproximation::Perform(const Standard_Real First,
myD2Poles2d = new (TColgp_HArray1OfVec2d)(1, Num2DSS);
COnSurfErr = new (TColStd_HArray1OfReal)(1, Num2DSS);
}
// Controle que myFunc->D2 est implemente
// Checks if myFunc->D2 is implemented
if (continuity >= GeomAbs_C2) {
Standard_Boolean B;
B = myFunc->D2(First, First, Last,
@@ -171,7 +171,7 @@ void Approx_SweepApproximation::Perform(const Standard_Real First,
myD2Weigths->ChangeArray1());
if (!B) continuity = GeomAbs_C1;
}
// Controle que myFunc->D1 est implemente
// Checks if myFunc->D1 is implemented
if (continuity == GeomAbs_C1) {
Standard_Boolean B;
B = myFunc->D1(First, First, Last,
@@ -181,14 +181,14 @@ void Approx_SweepApproximation::Perform(const Standard_Real First,
if (!B) continuity = GeomAbs_C0;
}
//Pour que F soit au moins 20 fois plus precise que son approx
// So that F was at least 20 times more exact than its approx
myFunc->SetTolerance(Tol3dMin/20, Tol2d/20);
Standard_Integer NbIntervalC2 = myFunc->NbIntervals(GeomAbs_C2);
Standard_Integer NbIntervalC3 = myFunc->NbIntervals(GeomAbs_C3);
if (NbIntervalC3 > 1) {
// (3.1) Approximation avec decoupe preferentiel
// (3.1) Approximation with preferential cut
TColStd_Array1OfReal Param_de_decoupeC2 (1, NbIntervalC2+1);
myFunc->Intervals(Param_de_decoupeC2, GeomAbs_C2);
TColStd_Array1OfReal Param_de_decoupeC3 (1, NbIntervalC3+1);
@@ -208,7 +208,7 @@ void Approx_SweepApproximation::Perform(const Standard_Real First,
Preferentiel);
}
else {
// (3.2) Approximation sans decoupe preferentiel
// (3.2) Approximation without preferential cut
AdvApprox_DichoCutting Dichotomie;
Approx_SweepApproximation_Eval ev (*this);
Approximation(OneDTol, TwoDTol, ThreeDTol,
@@ -223,7 +223,7 @@ void Approx_SweepApproximation::Perform(const Standard_Real First,
//========================================================================
//function : Approximation
//purpose : Appel F(t) et stocke les resultats
//purpose : Call F(t) and store the results
//========================================================================
void Approx_SweepApproximation::
Approximation(const Handle(TColStd_HArray1OfReal)& OneDTol,
@@ -252,14 +252,13 @@ Approximation(const Handle(TColStd_HArray1OfReal)& OneDTol,
done = Approx.HasResult();
if (done) {
// --> Remplissage des Champs de la surface ----
// --> Fill Champs of the surface ----
Standard_Integer ii, jj;
vdeg = Approx.Degree();
// Malheureusement Adv_Approx stock la transpose de
// ce que l'on souhaite, donc l'ecriture
// tabPoles = Approx.Poles() donnerait un resultat errone
// Il n'y a plus qu'a allouer et recopier termes a termes...
// Unfortunately Adv_Approx stores the transposition of the required
// so, writing tabPoles = Approx.Poles() will give an erroneous result
// It is only possible to allocate and recopy term by term...
tabPoles = new (TColgp_HArray2OfPnt)
(1, Num3DSS, 1, Approx.NbPoles());
tabWeights = new (TColStd_HArray2OfReal)
@@ -272,7 +271,7 @@ Approximation(const Handle(TColStd_HArray1OfReal)& OneDTol,
for (jj=1; jj <=Approx.NbPoles() ; jj++) {
P = Approx.Poles()->Value(jj,ii);
wpoid = Approx.Poles1d()->Value(jj,ii);
P.ChangeCoord() /= wpoid; // Il faut diviser les poles par les poids
P.ChangeCoord() /= wpoid; // It is necessary to divide poles by weight
P.Translate(Translation);
tabPoles->SetValue (ii, jj, P);
tabWeights->SetValue(ii, jj, wpoid );
@@ -288,13 +287,13 @@ Approximation(const Handle(TColStd_HArray1OfReal)& OneDTol,
}
}
// ici cela va mieux
// this is better
tabVKnots = Approx.Knots();
tabVMults = Approx.Multiplicities();
// --> Remplissage des courbes 2d ----------
// --> Filling of curves 2D ----------
if (Num2DSS>0) {
gp_GTrsf2d TrsfInv;
deg2d = vdeg;
@@ -306,14 +305,14 @@ Approximation(const Handle(TColStd_HArray1OfReal)& OneDTol,
Handle(TColgp_HArray1OfPnt2d) P2d =
new (TColgp_HArray1OfPnt2d) (1, Approx.NbPoles());
Approx.Poles2d( ii, P2d->ChangeArray1() );
// On n'oublie pas d'appliquer l'homothetie inverse.
// do not forget to apply inverted homothety.
for (jj=1; jj<=Approx.NbPoles(); jj++) {
TrsfInv.Transforms(P2d->ChangeValue(jj).ChangeCoord());
}
seqPoles2d.Append(P2d);
}
}
// ---> Remplissage des erreurs
// ---> Filling of errors
MError3d = new (TColStd_HArray1OfReal) (1,Num3DSS);
AError3d = new (TColStd_HArray1OfReal) (1,Num3DSS);
for (ii=1; ii<=Num3DSS; ii++) {
@@ -375,21 +374,20 @@ Standard_Boolean Approx_SweepApproximation::D0(const Standard_Real Param,
Standard_Boolean Ok=Standard_True;
Standard_Real * LocalResult = &Result;
// Gestion des Bornes
// Management of limits
if ((first!=First) || (Last!=last)) {
myFunc->SetInterval(First, Last);
}
if (! ( (Param==myParam) && (myOrder>=0)
&& (first==First) && (Last==last)) ) {
// Positionement dans le cas ou l'on ne repete pas
// la derniere operation
// Positioning in case when the last operation is not repeated.
Ok = myFunc->D0(Param, First, Last,
myPoles->ChangeArray1(),
myPoles2d->ChangeArray1(),
myWeigths->ChangeArray1());
// On multiplie les poles3d par les poids apres tranlations.
// poles3d are multiplied by weight after tranlation.
for (ii=1; ii<=Num1DSS; ii++) {
myPoles->ChangeValue(ii).ChangeCoord()
-= Translation.XYZ();
@@ -397,19 +395,19 @@ Standard_Boolean Approx_SweepApproximation::D0(const Standard_Real Param,
*= myWeigths->Value(ii);
}
// On applique la transformation aux poles 2d.
// The transformation is applied to poles 2d.
for (ii=1; ii<=Num2DSS; ii++) {
AAffin->Value(ii).Transforms(myPoles2d->ChangeValue(ii).ChangeCoord());
}
// Mise a jour des variable de controles et retour
// Update variables of controle and return
first = First;
last = Last;
myOrder = 0;
myParam = Param;
}
// Extraction des resultats
// Extraction of results
index = 0;
for (ii=1; ii<=Num1DSS; ii++) {
LocalResult[index] = myWeigths->Value(ii);
@@ -448,7 +446,7 @@ Standard_Boolean Approx_SweepApproximation::D1(const Standard_Real Param,
if (! ( (Param==myParam) && (myOrder>=1)
&& (first==First) && (Last==last)) ){
// Positionement
// Positioning
Ok = myFunc->D1(Param, First, Last,
myPoles->ChangeArray1(),
myDPoles->ChangeArray1(),
@@ -457,22 +455,22 @@ Standard_Boolean Approx_SweepApproximation::D1(const Standard_Real Param,
myWeigths->ChangeArray1(),
myDWeigths->ChangeArray1());
// On tient compte de la multiplication des poles3d par les poids.
// et de la translation.
// Take into account the multiplication of poles3d by weights.
// and the translation.
for ( ii=1; ii<=Num1DSS; ii++) {
//Translation sur la section
//Translation on the section
myPoles->ChangeValue(ii).ChangeCoord()
-= Translation.XYZ();
// Homothetie sur tout
// Homothety on all.
myDPoles->ChangeValue(ii) *= myWeigths->Value(ii);
Vaux.SetXYZ( myPoles->Value(ii).Coord());
myDPoles->ChangeValue(ii) += myDWeigths->Value(ii)*Vaux;
myPoles->ChangeValue(ii).ChangeCoord()
*= myWeigths->Value(ii); // Pour le cache
*= myWeigths->Value(ii); // for the cash
}
// On applique les transformation 2d aux vecteurs idoines
// Apply transformation 2d to suitable vectors
for (ii=1; ii<=Num2DSS; ii++) {
Vcoord = myDPoles2d->Value(ii).XY();
AAffin->Value(ii).Transforms(Vcoord);
@@ -480,14 +478,14 @@ Standard_Boolean Approx_SweepApproximation::D1(const Standard_Real Param,
AAffin->Value(ii).Transforms(myPoles2d->ChangeValue(ii).ChangeCoord());
}
// Mise a jour des variable de controles et retour
// Update control variables and return
first = First;
last = Last;
myOrder = 1;
myParam = Param;
}
// Extraction des resultats
// Extraction of results
index = 0;
for (ii=1; ii<=Num1DSS; ii++) {
LocalResult[index] = myDWeigths->Value(ii);
@@ -517,15 +515,14 @@ Standard_Boolean Approx_SweepApproximation::D2(const Standard_Real Param,
Standard_Boolean Ok=Standard_True;
Standard_Real * LocalResult = &Result;
// Gestion des Bornes
// management of limits
if ((first!=First) || (Last!=last)) {
myFunc->SetInterval(First, Last);
}
if (! ( (Param==myParam) && (myOrder>=2)
&& (first==First) && (Last==last)) ) {
// Positionement dans le cas ou l'on ne repete pas
// la derniere operation
// Positioning in case when the last operation is not repeated
Ok = myFunc->D2(Param, First, Last,
myPoles->ChangeArray1(),
myDPoles->ChangeArray1(),
@@ -537,20 +534,20 @@ Standard_Boolean Approx_SweepApproximation::D2(const Standard_Real Param,
myDWeigths->ChangeArray1(),
myD2Weigths->ChangeArray1());
// On multiplie les poles3d par les poids apres tranlations.
// Multiply poles3d by the weight after tranlations.
for (ii=1; ii<=Num1DSS; ii++) {
// D'abord on translate
// First translate
myPoles->ChangeValue(ii).ChangeCoord()
-= Translation.XYZ();
//On calcul la derive seconde
//Calculate the second derivative
myD2Poles->ChangeValue(ii) *= myWeigths->Value(ii);
Vaux.SetXYZ( myDPoles->Value(ii).XYZ());
myD2Poles->ChangeValue(ii) += (2*myDWeigths->Value(ii))*Vaux;
Vaux.SetXYZ( myPoles->Value(ii).Coord());
myD2Poles->ChangeValue(ii) += myD2Weigths->Value(ii)*Vaux;
//Puis le reste pour le cache
//Then the remainder for the cash
myDPoles->ChangeValue(ii) *= myWeigths->Value(ii);
Vaux.SetXYZ( myPoles->Value(ii).Coord());
myDPoles->ChangeValue(ii) += myDWeigths->Value(ii)*Vaux;
@@ -558,7 +555,7 @@ Standard_Boolean Approx_SweepApproximation::D2(const Standard_Real Param,
*= myWeigths->Value(ii);
}
// On applique la transformation aux poles 2d.
// Apply transformation to poles 2d.
for (ii=1; ii<=Num2DSS; ii++) {
Vcoord = myD2Poles2d->Value(ii).XY();
AAffin->Value(ii).Transforms(Vcoord);
@@ -569,14 +566,14 @@ Standard_Boolean Approx_SweepApproximation::D2(const Standard_Real Param,
AAffin->Value(ii).Transforms(myPoles2d->ChangeValue(ii).ChangeCoord());
}
// Mise a jour des variable de controles et retour
// Update variables of control and return
first = First;
last = Last;
myOrder = 2;
myParam = Param;
}
// Extraction des resultats
// Extraction of results
index = 0;
for (ii=1; ii<=Num1DSS; ii++) {
LocalResult[index] = myD2Weigths->Value(ii);