Index: trunk/SophyaLib/HiStats/histos2.cc
===================================================================
--- trunk/SophyaLib/HiStats/histos2.cc	(revision 763)
+++ trunk/SophyaLib/HiStats/histos2.cc	(revision 914)
@@ -16,24 +16,11 @@
 #include "generalfit.h"
 
-//++
-// Class	Histo2D
-// Lib	Outils++ 
-// include	histos2.h
-//
-//	Classe d'histogrammes 2D
-//--
-
-///////////////////////////////////////////////////////////////////
-//++
-// Titre	Constructeurs
-//--
-
-//++
+///////////////////////////////////////////////////////////////////
+/*!
+  Createur d'un histogramme 2D ayant nxBin,nyBin bins
+  entre xMin,xMax et yMin,yMax.
+*/
 Histo2D::Histo2D(float xMin, float xMax, int nxBin
                 ,float yMin, float yMax, int nyBin)
-//
-//	Createur d'un histogramme 2D ayant nxBin,nyBin bins
-//	entre xMin,xMax et yMin,yMax.
-//--
       : data(new float[nxBin*nyBin]), err2(NULL)
       , nHist(0), nEntries(0)
@@ -50,9 +37,8 @@
 }
 
-//++
+/*!
+  Constructeur par copie.
+*/
 Histo2D::Histo2D(const Histo2D& h)
-//
-//	Constructeur par copie.
-//--
 {
 int i,j;
@@ -118,9 +104,8 @@
 }
 
-//++
+/*!
+  Constructeur par defaut.
+*/
 Histo2D::Histo2D()
-//
-//	Constructeur par defaut.
-//--
       : data(NULL), err2(NULL)
       , nHist(0), nEntries(0)
@@ -136,9 +121,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Desallocation de la place de l'histogramme (fct privee).
+*/
 void Histo2D::Delete()
-//
-//	Desallocation de la place de l'histogramme (fct privee).
-//--
 {
   if( data != NULL ) { delete[] data; data = NULL;}
@@ -163,9 +147,8 @@
 }
 
-//++
+/*!
+  Destructeur.
+*/
 Histo2D::~Histo2D()
-//
-//	Destructeur.
-//--
 {
 Delete();
@@ -173,13 +156,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
-// Titre	Methodes generales
-//--
-
-//++
+/*!
+  Remise a zero du contenu, des erreurs et des valeurs.
+*/
 void Histo2D::Zero()
-//
-//	Remise a zero du contenu, des erreurs et des valeurs.
-//--
 {
   nHist = nEntries = 0;
@@ -200,9 +178,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Pour avoir le calcul des erreurs.
+*/
 void Histo2D::Errors()
-//
-//	Pour avoir le calcul des erreurs.
-//--
 {
  if( nxy > 0 ) {
@@ -213,8 +190,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H2 = H1
+*/
 Histo2D& Histo2D::operator = (const Histo2D& h)
-//
-//--
 {
   int i,j,nb;
@@ -286,8 +263,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H *= b
+*/
 Histo2D& Histo2D::operator *= (double b)
-//
-//--
 {
 int i,j;
@@ -310,8 +287,8 @@
 }
 
-//++
+/*!
+  Operateur H /= b
+*/
 Histo2D& Histo2D::operator /= (double b)
-//
-//--
 {
 int i,j;
@@ -335,8 +312,8 @@
 }
 
-//++
+/*!
+  Operateur H += b
+*/
 Histo2D& Histo2D::operator += (double b)
-//
-//--
 {
 int i,j;
@@ -362,8 +339,8 @@
 }
 
-//++
+/*!
+  Operateur H -= b
+*/
 Histo2D& Histo2D::operator -= (double b)
-//
-//--
 {
 int i,j;
@@ -390,8 +367,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H2 = H1 * b
+*/
 Histo2D operator * (const Histo2D& a, double b)
-//
-//--
 {
   Histo2D result(a);
@@ -399,8 +376,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b * H1
+*/
 Histo2D operator * (double b, const Histo2D& a)
-//
-//--
 {
   Histo2D result(a);
@@ -408,8 +385,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 / b
+*/
 Histo2D operator / (const Histo2D& a, double b)
-//
-//--
 {
   Histo2D result(a);
@@ -417,8 +394,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 + b
+*/
 Histo2D operator + (const Histo2D& a, double b)
-//
-//--
 {
   Histo2D result(a);
@@ -426,8 +403,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b + H1
+*/
 Histo2D operator + (double b, const Histo2D& a)
-//
-//--
 {
   Histo2D result(a);
@@ -435,8 +412,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = H1 - b
+*/
 Histo2D operator - (const Histo2D& a, double b)
-//
-//--
 {
   Histo2D result(a);
@@ -444,8 +421,8 @@
 }
 
-//++
+/*!
+  Operateur H2 = b - H1
+*/
 Histo2D operator - (double b, const Histo2D& a)
-//
-//--
 {
   Histo2D result(a);
@@ -455,8 +432,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H += H1
+*/
 Histo2D& Histo2D::operator += (const Histo2D& a)
-//
-//--
 {
 int i,j;
@@ -478,8 +455,8 @@
 }
 
-//++
+/*!
+  Operateur H -= H1
+*/
 Histo2D& Histo2D::operator -= (const Histo2D& a)
-//
-//--
 {
 int i,j;
@@ -501,8 +478,8 @@
 }
 
-//++
+/*!
+  Operateur H *= H1
+*/
 Histo2D& Histo2D::operator *= (const Histo2D& a)
-//
-//--
 {
 int i,j;
@@ -526,8 +503,8 @@
 }
 
-//++
+/*!
+  Operateur H /= H1
+*/
 Histo2D& Histo2D::operator /= (const Histo2D& a)
-//
-//--
 {
 int i,j;
@@ -559,8 +536,9 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Operateur H = H1 + H2
+*/
+
 Histo2D operator + (const Histo2D& a, const Histo2D& b)
-//
-//--
 {
 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
@@ -569,8 +547,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 - H2
+*/
 Histo2D operator - (const Histo2D& a, const Histo2D& b)
-//
-//--
 {
 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
@@ -579,8 +557,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 * H2
+*/
 Histo2D operator * (const Histo2D& a, const Histo2D& b)
-//
-//--
 {
 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
@@ -589,8 +567,8 @@
 }
 
-//++
+/*!
+  Operateur H = H1 / H2
+*/
 Histo2D operator / (const Histo2D& a, const Histo2D& b)
-//
-//--
 {
 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
@@ -600,9 +578,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs des abscisses.
+*/
 void Histo2D::GetXCoor(Vector &v)
-//
-//	Remplissage d'un tableau avec les valeurs des abscisses.
-//--
 {
 float x,y;
@@ -612,9 +589,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs des ordonnees.
+*/
 void Histo2D::GetYCoor(Vector &v)
-//
-//	Remplissage d'un tableau avec les valeurs des ordonnees.
-//--
 {
 float x,y;
@@ -624,26 +600,8 @@
 }
 
-//++
-//| Remarque sur les indices:
-//|  H(i,j)   -> i  = coord x (0<i<nx),     j  = coord y (0<j<ny)
-//|  v(ii,jj) -> ii = ligne (0<i<NRows()),  jj = colonne (0<i<NCol())
-//|  On fait une correspondance directe i<->ii et j<->jj
-//|  ce qui, en representation classique des histos2D et des matrices
-//|  entraine une inversion x<->y cad une symetrie / diagonale principale
-//|  H(0,...)  represente ^         mais v(0,...) represente
-//|                       |x.......               |xxxxxxxx|
-//|                       |x.......               |........|
-//|                       |x.......               |........|
-//|                       |x.......               |........|
-//|                       |x.......               |........|
-//|                       --------->
-//|                       colonne no 1            ligne no 1
-//--
-
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs du contenu.
+*/
 void Histo2D::GetValue(Matrix &v)
-//
-//	Remplissage d'un tableau avec les valeurs du contenu.
-//--
 {
 v.Realloc(nx,ny);
@@ -653,9 +611,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs du carre des erreurs.
+*/
 void Histo2D::GetError2(Matrix &v)
-//
-//	Remplissage d'un tableau avec les valeurs du carre des erreurs.
-//--
 {
 int i,j;
@@ -667,9 +624,8 @@
 }
 
-//++
+/*!
+  Remplissage d'un tableau avec les valeurs des erreurs.
+*/
 void Histo2D::GetError(Matrix &v)
-//
-//	Remplissage d'un tableau avec les valeurs des erreurs.
-//--
 {
 int i,j;
@@ -682,9 +638,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Remplissage du contenu de l'histo avec les valeurs d'un tableau.
+*/
 void Histo2D::PutValue(Matrix &v, int ierr)
-//
-//	Remplissage du contenu de l'histo avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -697,9 +652,8 @@
 }
 
-//++
+/*!
+  Addition du contenu de l'histo avec les valeurs d'un tableau.
+*/
 void Histo2D::PutValueAdd(Matrix &v, int ierr)
-//
-//	Addition du contenu de l'histo avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -712,10 +666,9 @@
 }
 
-//++
+/*!
+  Remplissage des erreurs au carre de l'histo
+  avec les valeurs d'un tableau.
+*/
 void Histo2D::PutError2(Matrix &v)
-//
-//	Remplissage des erreurs au carre de l'histo
-//	avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -726,10 +679,9 @@
 }
 
-//++
+/*!
+  Addition des erreurs au carre de l'histo
+  avec les valeurs d'un tableau.
+*/
 void Histo2D::PutError2Add(Matrix &v)
-//
-//	Addition des erreurs au carre de l'histo
-//	avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -741,9 +693,8 @@
 }
 
-//++
+/*!
+  Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
+*/
 void Histo2D::PutError(Matrix &v)
-//
-//	Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
-//--
 {
 int i,j;
@@ -757,9 +708,8 @@
 ///////////////////////////////////////////////////////////////////
 /********* Methode *********/
-//++
+/*!
+  Addition du contenu de l'histo pour x,y poids w.
+*/
 void Histo2D::Add(float x, float y, float w)
-//
-//	Addition du contenu de l'histo pour x,y poids w.
-//--
 {
 list<bande_slice>::iterator it;
@@ -801,9 +751,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Recherche du bin du maximum dans le pave [il,ih][jl,jh].
+*/
 void Histo2D::IJMax(int& imax,int& jmax,int il,int ih,int jl,int jh)
-//
-//	Recherche du bin du maximum dans le pave [il,ih][jl,jh].
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -823,9 +772,8 @@
 }
 
-//++
+/*!
+  Recherche du bin du minimum dans le pave [il,ih][jl,jh].
+*/
 void Histo2D::IJMin(int& imax,int& jmax,int il,int ih,int jl,int jh)
-//
-//	Recherche du bin du minimum dans le pave [il,ih][jl,jh].
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -846,9 +794,8 @@
 
 
-//++
+/*!
+  Recherche du maximum dans le pave [il,ih][jl,jh].
+*/
 float Histo2D::VMax(int il,int ih,int jl,int jh) const
-//
-//	Recherche du maximum dans le pave [il,ih][jl,jh].
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -867,9 +814,8 @@
 }
 
-//++
+/*!
+  Recherche du minimum dans le pave [il,ih][jl,jh].
+*/
 float Histo2D::VMin(int il,int ih,int jl,int jh) const
-//
-//	Recherche du minimum dans le pave [il,ih][jl,jh].
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -889,18 +835,19 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Renvoie les under.overflow dans les 8 quadrants.
+  \verbatim
+     over[3][3]:        20 | 21 | 22
+                           |    |
+                       --------------
+                           |    |
+                        10 | 11 | 12        11 = all overflow+underflow
+                           |    |
+                       --------------
+                           |    |
+                        00 | 01 | 02
+  \endverbatim
+*/
 float Histo2D::NOver(int i,int j) const
-//
-//	Renvoie les under.overflow dans les 8 quadrants.
-//|  over[3][3]:        20 | 21 | 22
-//|                        |    |
-//|                    --------------
-//|                        |    |
-//|                     10 | 11 | 12        11 = all overflow+underflow
-//|                        |    |
-//|                    --------------
-//|                        |    |
-//|                     00 | 01 | 02
-//--
 {
 if( i < 0 || i>=3 || j < 0 || j>=3 ) return over[1][1];
@@ -910,9 +857,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Retourne le nombre de bins non-nuls.
+*/
 int Histo2D::BinNonNul() const
-//
-//	Retourne le nombre de bins non-nuls.
-//--
 {
 int non=0;
@@ -921,9 +867,8 @@
 }
 
-//++
+/*!
+  Retourne le nombre de bins avec erreurs non-nulles.
+*/
 int Histo2D::ErrNonNul() const
-//
-//	Retourne le nombre de bins avec erreurs non-nulles.
-//--
 {
 if(err2==NULL) return -1;
@@ -934,10 +879,9 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Idem EstimeMax(int...) mais retourne x,y.
+*/
 int Histo2D::EstimeMax(float& xm,float& ym,int SzPav
                       ,int il,int ih,int jl,int jh)
-//
-//	Idem EstimeMax(int...) mais retourne x,y.
-//--
 {
 int im,jm;
@@ -946,16 +890,17 @@
 }
 
-//++
+/*!
+  Determine les abscisses et ordonnees du maximum donne par im,jm
+  en moyennant dans un pave SzPav x SzPav autour du maximum.
+  \verbatim
+     Return:
+       0 = si fit maximum reussi avec SzPav pixels
+       1 = si fit maximum reussi avec moins que SzPav pixels
+                                   dans au moins 1 direction
+       2 = si fit maximum echoue et renvoit BinCenter()
+      -1 = si echec: SzPav <= 0 ou im,jm hors limites
+  \endverbatim
+*/
 int Histo2D::EstimeMax(int im,int jm,float& xm,float& ym,int SzPav)
-//
-//	Determine les abscisses et ordonnees du maximum donne par im,jm
-//	en moyennant dans un pave SzPav x SzPav autour du maximum.
-//|  Return:
-//|    0 = si fit maximum reussi avec SzPav pixels
-//|    1 = si fit maximum reussi avec moins que SzPav pixels
-//|                                dans au moins 1 direction
-//|    2 = si fit maximum echoue et renvoit BinCenter()
-//|   -1 = si echec: SzPav <= 0 ou im,jm hors limites
-//--
 {
 xm = ym = 0;
@@ -992,25 +937,26 @@
 }
 
-//++
+/*!
+  Pour trouver le maximum de l'histogramme en tenant compte
+  des fluctuations.
+  \verbatim
+    Methode:
+    1-/ On recherche le bin maximum MAX de l'histogramme
+    2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX]
+        peuvent etre des pixels maxima.
+    3-/ On identifie le bin maximum en choissisant le pixel du 2-/
+        tel que la somme des pixels dans un pave SzPav x SzPav soit maximale.
+    INPUT:
+     SzPav = taille du pave pour departager
+     Dz    = tolerance pour identifier tous les pixels "maximum"
+    OUTPUT:
+     im,jm = pixel maximum trouve
+    RETURN:
+      <0 =  Echec
+      >0 =  nombre de pixels possibles pour le maximum
+  \endverbatim
+*/
 int Histo2D::FindMax(int& im,int& jm,int SzPav,float Dz
                     ,int il,int ih,int jl,int jh)
-//
-//	Pour trouver le maximum de l'histogramme en tenant compte
-//	des fluctuations.
-//| Methode:
-//| 1-/ On recherche le bin maximum MAX de l'histogramme
-//| 2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX]
-//|     peuvent etre des pixels maxima.
-//| 3-/ On identifie le bin maximum en choissisant le pixel du 2-/
-//|     tel que la somme des pixels dans un pave SzPav x SzPav soit maximale.
-//| INPUT:
-//|  SzPav = taille du pave pour departager
-//|  Dz    = tolerance pour identifier tous les pixels "maximum"
-//| OUTPUT:
-//|  im,jm = pixel maximum trouve
-//| RETURN:
-//|   <0 =  Echec
-//|   >0 =  nombre de pixels possibles pour le maximum
-//--
 {
 if( il > ih ) { il = 0; ih = nx-1; }
@@ -1046,24 +992,25 @@
 
 //////////////////////////////////////////////////////////
-//++
+/*!
+  Fit de l'histogramme par ``gfit''.
+  \verbatim
+    typ_err = 0 :
+       - erreur attachee au bin si elle existe
+       - sinon 1
+    typ_err = 1 :
+       - erreur attachee au bin si elle existe
+       - sinon max( sqrt(abs(bin) ,1 )
+    typ_err = 2 :
+       - erreur forcee a 1
+    typ_err = 3 :
+       - erreur forcee a max( sqrt(abs(bin) ,1 )
+    typ_err = 4 :
+       - erreur forcee a 1, nulle si bin a zero.
+    typ_err = 5 :
+       - erreur forcee a max( sqrt(abs(bin) ,1 ),
+         nulle si bin a zero.
+  \endverbatim
+*/
 int  Histo2D::Fit(GeneralFit& gfit,unsigned short typ_err)
-//
-//	Fit de l'histogramme par ``gfit''.
-//| typ_err = 0 :
-//|    - erreur attachee au bin si elle existe
-//|    - sinon 1
-//| typ_err = 1 :
-//|    - erreur attachee au bin si elle existe
-//|    - sinon max( sqrt(abs(bin) ,1 )
-//| typ_err = 2 :
-//|    - erreur forcee a 1
-//| typ_err = 3 :
-//|    - erreur forcee a max( sqrt(abs(bin) ,1 )
-//| typ_err = 4 :
-//|    - erreur forcee a 1, nulle si bin a zero.
-//| typ_err = 5 :
-//|    - erreur forcee a max( sqrt(abs(bin) ,1 ),
-//|      nulle si bin a zero.
-//--
 {
 if(NBinX()*NBinY()<=0) return -1000;
@@ -1092,9 +1039,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant les residus du fit ``gfit''.
+*/
 Histo2D Histo2D::FitResidus(GeneralFit& gfit)
-//
-//	Retourne une classe contenant les residus du fit ``gfit''.
-//--
 {
 if(NBinX()<=0 || NBinY()<=0)
@@ -1114,9 +1060,8 @@
 }
 
-//++
+/*!
+  Retourne une classe contenant la fonction du fit ``gfit''.
+*/
 Histo2D Histo2D::FitFunction(GeneralFit& gfit)
-//
-//	Retourne une classe contenant la fonction du fit ``gfit''.
-//--
 {
 if(NBinX()<=0 || NBinY()<=0)
@@ -1137,9 +1082,8 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Impression des informations sur l'histogramme.
+*/
 void Histo2D::PrintStatus()
-//
-//	Impression des informations sur l'histogramme.
-//--
 {
 printf("~Histo::Print    nHist=%g nEntries=%d\n",nHist,nEntries);
@@ -1153,16 +1097,17 @@
 
 ///////////////////////////////////////////////////////////////////
-//++
+/*!
+  Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh].
+  \verbatim
+    numero d'index:  00000000001111111111222222222233333
+                     01234567890123456789012345678901234
+    valeur entiere:  00000000001111111111222222222233333
+                     12345678901234567890123456789012345
+  \endverbatim
+*/
 void Histo2D::Print(float min,float max
                    ,int il,int ih,int jl,int jh)
-//
-//	Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh].
-//--
 {
 int ns = 35;
-// numero d'index:  00000000001111111111222222222233333
-//                  01234567890123456789012345678901234
-// valeur entiere:  00000000001111111111222222222233333
-//                  12345678901234567890123456789012345
 const char *s =    "+23456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
@@ -1245,96 +1190,11 @@
 }
 
-// Rappel des inline functions pour commentaires
-//++
-// inline float   XMin()
-//	Retourne l'abscisse minimum.
-//--
-//++
-// inline float   XMax()
-//	Retourne l'abscisse maximum.
-//--
-//++
-// inline float   YMin()
-//	Retourne l'ordonnee minimum.
-//--
-//++
-// inline float   YMax()
-//	Retourne l'ordonnee maximum.
-//--
-//++
-// inline int     NBinX()
-//	Retourne le nombre de bins selon X.
-//--
-//++
-// inline int     NBinY()
-//	Retourne le nombre de bins selon Y.
-//--
-//++
-// inline float   WBinX()
-//	Retourne la largeur du bin selon X.
-//--
-//++
-// inline float   WBinY()
-//	Retourne la largeur du bin selon Y.
-//--
-//++
-// inline float*  Bins() const
-//	Retourne le pointeur sur le tableaux des contenus.
-//--
-//++
-// inline float   operator()(int i,int j) const
-//	Retourne le contenu du bin i,j.
-//--
-//++
-// inline float&  operator()(int i,int j)
-//	Remplit le contenu du bin i,j.
-//--
-//++
-// inline float   Error(int i,int j)  const
-//	Retourne l'erreur du bin i,j.
-//--
-//++
-// inline double  Error2(int i,int j) const
-//	Retourne l'erreur au carre du bin i,j.
-//--
-//++
-// inline double& Error2(int i,int j)
-//	Remplit l'erreur au carre du bin i,j.
-//--
-//++
-// inline float   NData() const
-//	Retourne la somme ponderee.
-//--
-//++
-// inline int     NEntries() const
-//	Retourne le nombre d'entrees.
-//--
-//++
-// inline void BinLowEdge(int i,int j,float& x,float& y)
-//	Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j.
-//--
-//++
-// inline void BinCenter(int i,int j,float& x,float& y)
-//	Retourne l'abscisse et l'ordonnee du centre du bin i,j.
-//--
-//++
-// inline void BinHighEdge(int i,int j,float& x,float& y)
-//	Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j.
-//--
-//++
-// inline void FindBin(float x,float y,int& i,int& j)
-//	Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y.
-//--
-
-///////////////////////////////////////////////////////////////////
-//++
+///////////////////////////////////////////////////////////////////
 // Titre	Methodes pour gerer les projections
-//--
-
-//++
+
+/*!
+  Pour creer la projection X.
+*/
 void Histo2D::SetProjX()
-//
-//	Pour creer la projection X.
-//--
 {
 if( hprojx != NULL ) DelProjX();
@@ -1343,9 +1203,8 @@
 }
 
-//++
+/*!
+  Pour creer la projection Y.
+*/
 void Histo2D::SetProjY()
-//
-//	Pour creer la projection Y.
-//--
 {
 if( hprojy != NULL ) DelProjY();
@@ -1354,9 +1213,8 @@
 }
 
-//++
+/*!
+  Pour creer les projections X et Y.
+*/
 void Histo2D::SetProj()
-//
-//	Pour creer les projections X et Y.
-//--
 {
 SetProjX();
@@ -1364,9 +1222,8 @@
 }
 
-//++
+/*!
+  Informations sur les projections.
+*/
 void Histo2D::ShowProj()
-//
-//	Informations sur les projections.
-//--
 {
 if( hprojx != NULL ) cout << ">>>> Projection X set : "<< hprojx <<endl;
@@ -1376,9 +1233,8 @@
 }
 
-//++
+/*!
+  Destruction de l'histogramme de la projection selon X.
+*/
 void Histo2D::DelProjX()
-//
-//	Destruction de l'histogramme de la projection selon X.
-//--
 {
 if( hprojx == NULL ) return;
@@ -1387,9 +1243,8 @@
 }
 
-//++
+/*!
+  Destruction de l'histogramme de la projection selon X.
+*/
 void Histo2D::DelProjY()
-//
-//	Destruction de l'histogramme de la projection selon X.
-//--
 {
 if( hprojy == NULL ) return;
@@ -1398,9 +1253,8 @@
 }
 
-//++
+/*!
+  Destruction des histogrammes des projections selon X et Y.
+*/
 void Histo2D::DelProj()
-//
-//	Destruction des histogrammes des projections selon X et Y.
-//--
 {
 DelProjX();
@@ -1408,9 +1262,8 @@
 }
 
-//++
+/*!
+  Remise a zero de la projection selon X.
+*/
 void Histo2D::ZeroProjX()
-//
-//	Remise a zero de la projection selon X.
-//--
 {
 if( hprojx == NULL ) return;
@@ -1418,9 +1271,8 @@
 }
 
-//++
+/*!
+  Remise a zero de la projection selon Y.
+*/
 void Histo2D::ZeroProjY()
-//
-//	Remise a zero de la projection selon Y.
-//--
 {
 if( hprojy == NULL ) return;
@@ -1428,9 +1280,8 @@
 }
 
-//++
+/*!
+  Remise a zero des projections selon X et Y.
+*/
 void Histo2D::ZeroProj()
-//
-//	Remise a zero des projections selon X et Y.
-//--
 {
 ZeroProjX();
@@ -1438,24 +1289,11 @@
 }
 
-// Rappel des inline functions pour commentaires
-//++
-// inline Histo*  HProjX()
-//	Retourne le pointeur sur l'histo 1D de la projection selon X.
-//--
-//++
-// inline Histo*  HProjY()
-//	Retourne le pointeur sur l'histo 1D de la projection selon Y.
-//--
-
-///////////////////////////////////////////////////////////////////
-//++
+///////////////////////////////////////////////////////////////////
 // Titre	Methodes pour gerer les bandes
-//--
-
-//++
+
+/*!
+  Pour creer une bande en X entre ybmin et ybmax.
+*/
 int Histo2D::SetBandX(float ybmin,float ybmax)
-//
-//	Pour creer une bande en X entre ybmin et ybmax.
-//--
 {
 b_s.num = lbandx.size();
@@ -1468,9 +1306,8 @@
 }
 
-//++
+/*!
+  Pour creer une bande en Y entre xbmin et xbmax.
+*/
 int Histo2D::SetBandY(float xbmin,float xbmax)
-//
-//	Pour creer une bande en Y entre xbmin et xbmax.
-//--
 {
 b_s.num = lbandy.size();
@@ -1483,9 +1320,8 @@
 }
 
-//++
+/*!
+  Destruction des histogrammes des bandes selon X.
+*/
 void Histo2D::DelBandX()
-//
-//	Destruction des histogrammes des bandes selon X.
-//--
 {
 if( lbandx.size() <= 0 ) return;
@@ -1495,9 +1331,8 @@
 }
 
-//++
+/*!
+  Destruction des histogrammes des bandes selon Y.
+*/
 void Histo2D::DelBandY()
-//
-//	Destruction des histogrammes des bandes selon Y.
-//--
 {
 if( lbandy.size() <= 0 ) return;
@@ -1507,9 +1342,8 @@
 }
 
-//++
+/*!
+  Remise a zero des bandes selon X.
+*/
 void Histo2D::ZeroBandX()
-//
-//	Remise a zero des bandes selon X.
-//--
 {
 if( lbandx.size() <= 0 ) return;
@@ -1519,9 +1353,8 @@
 }
 
-//++
+/*!
+  Remise a zero des bandes selon Y.
+*/
 void Histo2D::ZeroBandY()
-//
-//	Remise a zero des bandes selon Y.
-//--
 {
 if( lbandy.size() <= 0 ) return;
@@ -1531,9 +1364,8 @@
 }
 
-//++
+/*!
+  Retourne un pointeur sur la bande numero `n' selon X.
+*/
 Histo* Histo2D::HBandX(int n) const
-//
-//	Retourne un pointeur sur la bande numero `n' selon X.
-//--
 {
 if( lbandx.size() <= 0 || n < 0 || n >= (int) lbandx.size() ) return NULL;
@@ -1543,9 +1375,8 @@
 }
 
-//++
+/*!
+  Retourne un pointeur sur la bande numero `n' selon Y.
+*/
 Histo* Histo2D::HBandY(int n) const
-//
-//	Retourne un pointeur sur la bande numero `n' selon Y.
-//--
 {
 if( lbandy.size() <= 0 || n < 0 || n >= (int) lbandy.size() ) return NULL;
@@ -1555,9 +1386,8 @@
 }
 
-//++
+/*!
+  Retourne les limites de la bande numero `n' selon X.
+*/
 void Histo2D::GetBandX(int n,float& ybmin,float& ybmax) const
-//
-//	Retourne les limites de la bande numero `n' selon X.
-//--
 {
 ybmin = 0.; ybmax = 0.;
@@ -1568,9 +1398,8 @@
 }
 
-//++
+/*!
+  Retourne les limites de la bande numero `n' selon Y.
+*/
 void Histo2D::GetBandY(int n,float& xbmin,float& xbmax) const
-//
-//	Retourne les limites de la bande numero `n' selon Y.
-//--
 {
 xbmin = 0.; xbmax = 0.;
@@ -1581,9 +1410,8 @@
 }
 
-//++
+/*!
+  Informations sur les bandes.
+*/
 void Histo2D::ShowBand(int lp)
-//
-//	Informations sur les bandes.
-//--
 {
   cout << ">>>> Nombre de bande X : " << lbandx.size() << endl;
@@ -1608,24 +1436,11 @@
 }
 
-// Rappel des inline functions pour commentaires
-//++
-// inline int     NBandX()
-//	Retourne le nombre de bandes selon X
-//--
-//++
-// inline int     NBandY()
-//	Retourne le nombre de bandes selon Y
-//--
-
-///////////////////////////////////////////////////////////////////
-//++
-// Titre	Methodes pour gerer les bandes equidistantes
-//--
-
-//++
+///////////////////////////////////////////////////////////////////
+// Titre  Methodes pour gerer les bandes equidistantes ou slices
+
+/*!
+  Pour creer `nsli' bandes equidistantes selon X.
+*/
 int Histo2D::SetSliX(int nsli)
-//
-//	Pour creer `nsli' bandes equidistantes selon X.
-//--
 {
 if( nsli <= 0 ) return -1;
@@ -1645,9 +1460,8 @@
 }
 
-//++
+/*!
+  Pour creer `nsli' bandes equidistantes selon Y.
+*/
 int Histo2D::SetSliY(int nsli)
-//
-//	Pour creer `nsli' bandes equidistantes selon Y.
-//--
 {
 if( nsli <= 0 ) return -1;
@@ -1667,9 +1481,8 @@
 }
 
-//++
+/*!
+  Destruction des bandes equidistantes selon X.
+*/
 void Histo2D::DelSliX()
-//
-//	Destruction des bandes equidistantes selon X.
-//--
 {
 if( lslix.size() <= 0 ) return;
@@ -1679,9 +1492,8 @@
 }
 
-//++
+/*!
+  Destruction des bandes equidistantes selon Y.
+*/
 void Histo2D::DelSliY()
-//
-//	Destruction des bandes equidistantes selon Y.
-//--
 {
 if( lsliy.size() <= 0 ) return;
@@ -1691,9 +1503,8 @@
 }
 
-//++
+/*!
+  Remise a zero des bandes equidistantes selon X.
+*/
 void Histo2D::ZeroSliX()
-//
-//	Remise a zero des bandes equidistantes selon X.
-//--
 {
 if( lslix.size() <= 0 ) return;
@@ -1703,9 +1514,8 @@
 }
 
-//++
+/*!
+  Remise a zero des bandes equidistantes selon Y.
+*/
 void Histo2D::ZeroSliY()
-//
-//	Remise a zero des bandes equidistantes selon Y.
-//--
 {
 if( lsliy.size() <= 0 ) return;
@@ -1715,10 +1525,9 @@
 }
 
-//++
+/*!
+  Retourne un pointeur sur la bande equidistante numero `n'
+  selon X.
+*/
 Histo* Histo2D::HSliX(int n) const
-//
-//	Retourne un pointeur sur la bande equidistante numero `n'
-//	selon X.
-//--
 {
 if( lslix.size() <= 0 || n < 0 || n >= (int) lslix.size() ) return NULL;
@@ -1728,10 +1537,9 @@
 }
 
-//++
+/*!
+  Retourne un pointeur sur la bande equidistante numero `n'
+  selon Y.
+*/
 Histo* Histo2D::HSliY(int n) const
-//
-//	Retourne un pointeur sur la bande equidistante numero `n'
-//	selon Y.
-//--
 {
 if( lsliy.size() <= 0 || n < 0 || n >= (int) lsliy.size() ) return NULL;
@@ -1741,9 +1549,8 @@
 }
 
-//++
+/*!
+  Informations sur les bandes equidistantes.
+*/
 void Histo2D::ShowSli(int lp)
-//
-//	Informations sur les bandes equidistantes.
-//--
 {
 list<bande_slice>::iterator i;
@@ -1764,15 +1571,4 @@
   }
 }
-
-// Rappel des inline functions pour commentaires
-//++
-// inline int     NSliX()
-//	Retourne le nombre de slices selon X
-//--
-//++
-// inline int     NSliY()
-//	Retourne le nombre de slices selon Y
-//--
-
 
 ///////////////////////////////////////////////////////////
