Index: /trunk/SophyaPI/PI/pidrawer.cc
===================================================================
--- /trunk/SophyaPI/PI/pidrawer.cc	(revision 1927)
+++ /trunk/SophyaPI/PI/pidrawer.cc	(revision 1928)
@@ -307,38 +307,17 @@
 }
 
-/* --Methode-Static-- */
-void PIDrawer::BestTicks(double rmin,double rmax,int nticks,double& majt)
-{
-double d = rmax - rmin;
-//if (d < 1.e-39) d = 1.e-39; 
-if (d < 1.e-100) d = 1.e-100; 
-double ld = log10(d);
-double fld = floor(fabs(ld));
-double del,del0;
-double fac[4] = {2.,5.,10.,20.};
-if(ld>=0.) { fld -= 1.; del0 = del = pow(10.,fld); }
-else { fld += 2.; del0 = del = pow(10., -fld); }
-int k=0;
-while( d/del > (double) nticks && k<4 ) { del = fac[k]*del0; k++; }
-majt = del;
-}
-
 void
 PIDrawer::CalcTicks()
 {
   int ntick_x = (aXlog) ? 6 : 10;
-  BestTicks(xMin,xMax,ntick_x,xMajTickStep);
+  BestTicks(xMin,xMax,ntick_x,xMajTickStep,xFirstMajTick);
   xMinTickStep = xMajTickStep/5;
-  xFirstMajTick = int(xMin / xMajTickStep) * xMajTickStep;
-  if (xFirstMajTick < xMin) xFirstMajTick += xMajTickStep;
-  xFirstMinTick = int(xMin / xMinTickStep) * xMinTickStep;
+  xFirstMinTick = floor(xMin / xMinTickStep) * xMinTickStep;
   if (xFirstMinTick < xMin) xFirstMinTick += xMinTickStep;
 
   int ntick_y = (aYlog) ? 6 : 12;
-  BestTicks(yMin,yMax,ntick_y,yMajTickStep);
+  BestTicks(yMin,yMax,ntick_y,yMajTickStep,yFirstMajTick);
   yMinTickStep = yMajTickStep/5;
-  yFirstMajTick = int(yMin / yMajTickStep) * yMajTickStep;
-  if (yFirstMajTick < yMin) yFirstMajTick += yMajTickStep;
-  yFirstMinTick = int(yMin / yMinTickStep) * yMinTickStep;
+  yFirstMinTick = floor(yMin / yMinTickStep) * yMinTickStep;
   if (yFirstMinTick < yMin) yFirstMinTick += yMinTickStep;
 
@@ -524,5 +503,5 @@
   // Choix du bon format pour les labels des axes;
   string format;
-  BonFormatAxes(xBeg,xMax,xStep,format);
+  BonFormatAxes(xBeg,xMax,xStep,format,1);
 
   double xlastlabelfin = xBeg - 2.*(xMax-xBeg);
@@ -555,5 +534,5 @@
   // Choix du bon format pour les labels des axes;
   string format;
-  BonFormatAxes(yBeg,yMax,yStep,format);
+  BonFormatAxes(yBeg,yMax,yStep,format,1);
 
   for (double y=yBeg; y<=yMax; y += yStep) {
@@ -590,16 +569,52 @@
 
 /* --Methode-Static-- */
-int PIDrawer::BonFormatAxes(double xmin,double xmax,double dx,string& format, int add_digit)
+void PIDrawer::BestTicks(double xmin,double xmax,int nticks,double& steptick,double& xfirsttick)
+{
+double d=xmax-xmin; if(d<1.e-100) d=1.e-100; //if (d<1.e-39) d=1.e-39;
+double ld  = log10(d);
+double fld = floor( ((ld<0.)? -ld: ld) );
+double del,del0;
+if(ld>=0.) {fld-=1.; del0=del=pow(10.,fld);}
+  else     {fld+=2.; del0=del=pow(10.,-fld);}
+// xmin  xmax    d       ld       fld -->fld  del0
+// 1     1500    1499    3.17     3      2    10^2
+// 1     9500    9499    3.98     3      2    10^2
+// 1     1.005   0.005   -2.3     2      4    10^-4
+// 1     1.995   0.995   -0.0022  0      2    10^-2
+// - Et recherche de la valeur del={del0,2*del0,...,20*del0}
+// telle que "nticks*del" soit le plus petit nombre ">=d"
+// Par exemple, si nticks=10:
+// 1-/ pour le 2sd cas ou d=9499 et del0=100 :
+// del        =    100    200    500    1000    2000
+// nticks*del =   1000   2000   5000   10000   20000
+// d/del      =   94.9   47.4   18.9 | 9.499   4.749  ==> majt = 1000
+// 2-/ pour le 3ieme cas ou d=5e-3 et del0=1e-4 :
+// del        =  1e-4   2e-4   5e-4  1e-3   2e-3
+// nticks*del =  1e-3   2e-3   5e-3  1e-2   2e-2
+// d/del      =  50     25   | 10    5      2.5       ==> majt = 5e-4
+int k=0;
+double fac[4] = {2.,5.,10.,20.};
+while(d/del>(double)nticks && k<4 ) {del=fac[k]*del0; k++;}
+steptick=del;
+xfirsttick = floor(xmin/steptick) * steptick;
+if(xfirsttick<xmin) xfirsttick += steptick;
+}
+
+/* --Methode-Static-- */
+int PIDrawer::BonFormatAxes(double xmin,double xmax,double dx,string& format,int add_digit)
 // Calcul format optimal pour ecrire les axes
-// double = 17 digits : +d.(17digits)e+ddd  -> min 25%17e  -> securite 26%18e
+// double = 17 digits : +a.bbbbbbbbe+ccc  -> securite 26%18e
 // ** add_digit nombre de digit a ajouter au nombre de digit minimum.
+// But: calculer "ndig" nombre de digits necessaires pour distinguer
+//      les valeurs xmin+k*dx (<=xmax)
 {
  format = "%-6g";  // format par default
- if(xmin>=xmax || dx<=0.) return -1;
+ if(xmin>=xmax) return -1;
+ if(dx<=0.) dx = 0.9999*(xmax-xmin);
 
  //////////// Calcul du nombre de digits necessaires
  char str[32],str0[32];
  int ndig = 0;
- //printf("           1         2         3\n");
+ //printf("           1         2         3 \n");
  //printf("|0123456789012345678901234567890|\n");
  int npass = 0;  // au cas ou dx est tout petit et "x+=dx == x" !
@@ -608,5 +623,5 @@
    // Il faut gerer le zero car 0 -> 0.000e+00 mais -0 -> -0.000e+00
    if(x>0.)      sprintf(str,"+%-26.18e",x);
-   else if(x<0.) sprintf(str,"-%-26.18e",fabs(x));
+   else if(x<0.) sprintf(str,"-%-26.18e",-x);
    else          sprintf(str,"+%-26.18e",0.);
    //printf("|%s|",str);
@@ -623,14 +638,18 @@
 
  //////////// Calcul du bon format
+ // on differe dans les signes: #1.2345e+123
+ if(ndig==0) return 0;
+
+ // on differe dans les puissances 1.2345e+###
  // position du "e"
  char* cdum = index(str,'e');
  int pose = cdum - str;
  //printf("pose=%d   strlen=%d\n",pose,strlen(str));
-
- // on differe dans les puissances ..e+ddd
  if(ndig>pose) return 0;
 
  // on calcule le nombre de digits necessaires
- ndig -= 2;  // +1 - 3 (car par ex:"+9.")
+ // ... ndig==1 : +9    --> ndig=1
+ // ... ndig>1  : +9.1  --> ndig-=1
+ if(ndig>1) ndig -= 1;
 
  // on ajoute des digits au cas ou on veut plus que le minimum requis
@@ -641,16 +660,27 @@
  if(ndig<6) return ndig;
 
- // Calcule du nombre nn devant le format %nn.ddde
- //                        +a.<---ddd--->e+123
- //                       nndig = ddd + 8
- int nndig = ndig + 8; if(nndig<=0) nndig = 26;
-
- // On evite d'ecrire d.ddde+00   -> format %f
- if(  (xmin>=1. && xmin<10. && xmax>=1. && xmax<10.) 
-   || (xmin>-10. && xmin<=-1. && xmax>-10. && xmax<=-1.) ) {
-   sprintf(str,"%%-%d.%df",nndig,ndig);
+ double axmin=fabs(xmin), axmax=fabs(xmax);
+ if(axmax<axmin) {dx=axmin; axmin=axmax; axmax=dx;}
+ if(axmin>=0.01 && axmax<1000.) {
+   // On evite d'ecrire +a.bbbe+ccc pour ccc=-1,0,1,2 -> format %f
+   // Ex: 1.2345e+2 -> 123.45   /  -1.2345e+2 -> -123.45
+   //     1.2345e-1 -> 0.12345  /  -1.2345e-1 -> -0.12345
+   // Calcul du format %-nn.mmf
+   int mm=-1, nn;
+   if(axmax<0.1)        {mm=ndig+1; nn=mm+3;} // +0.012345
+   else if(axmax<1.)    {mm=ndig;   nn=mm+3;} // +0.12345
+   else if(axmax<10.)   {mm=ndig-1; nn=mm+3;} // +1.2345
+   else if(axmax<100.)  {mm=ndig-2; nn=mm+4;} // +12.345
+   else if(axmax<1000.) {mm=ndig-3; nn=mm+5;} // +123.45
+   if(mm<0.) {mm=ndig; nn=mm+3;}              // +0.12345 (defaut)
+   sprintf(str,"%%-%d.%df",nn,mm);
  } else {
-   sprintf(str,"%%-%d.%de",nndig,ndig);
+   // Calcul du nombre "nn" devant le format %-nn.mme
+   //   +d.<--ddd-->e+123
+   //   1 2         34567
+   //   nn = ndig+7   mm = ndig-1
+   sprintf(str,"%%-%d.%de",ndig+7,ndig-1);
  }
+
  format = str;
  //printf("format= %s\n",format.c_str());
Index: /trunk/SophyaPI/PI/pidrawer.h
===================================================================
--- /trunk/SophyaPI/PI/pidrawer.h	(revision 1927)
+++ /trunk/SophyaPI/PI/pidrawer.h	(revision 1928)
@@ -100,5 +100,5 @@
 //  --- Methode- static ----
 //  Calcul des Distances optimales des subdivisions 
-  static void        BestTicks(double rmin,double rmax,int nticks,double& majt);
+  static void BestTicks(double xmin,double xmax,int nticks,double& steptick,double& xfirsttick);
 //  Calcul du format optimal pour les axes
   static int BonFormatAxes(double xmin,double xmax,double dx,string& format, int add_digit=0);
Index: /trunk/SophyaPI/PI/piscdrawwdg.cc
===================================================================
--- /trunk/SophyaPI/PI/piscdrawwdg.cc	(revision 1927)
+++ /trunk/SophyaPI/PI/piscdrawwdg.cc	(revision 1928)
@@ -608,10 +608,7 @@
 {
   string format = "%-g";
-  //PIDrawer::BonFormatAxes(xmin,xmax,(xmax-xmin)*0.9999,format,2);
   double xm = (fabs(xmax)>fabs(xmin)) ? fabs(xmax): fabs(xmin);
   double dx = fabs(xmax-xmin)/500.;
-  PIDrawer::BonFormatAxes(xm,xm+dx,dx*0.9999,format,0);
+  PIDrawer::BonFormatAxes(xm,xm+dx,dx*0.9999,format,1);
   return format;
 }
-
-
