Index: trunk/SophyaLib/NTools/objfitter.cc
===================================================================
--- trunk/SophyaLib/NTools/objfitter.cc	(revision 1204)
+++ trunk/SophyaLib/NTools/objfitter.cc	(revision 1206)
@@ -7,88 +7,87 @@
 //===========================================================================
 
+//============================= Matrix et Vector ============================
 TMatrix<int_4>
-ObjectFitter::FitResidus(TMatrix<int_4> const & mtx, GeneralFit& gfit,
-			 double xorg, double yorg, double dx, double dy)
-{
-  return( ArrayFitter<int_4>::FitResidus(mtx, gfit, xorg, yorg, dx, dy) );
-}
+ObjectFitter::FitResidus(TMatrix<int_4> const & mtx,GeneralFit& gfit,
+			 double xorg,double yorg,double dx,double dy)
+{return( ArrayFitter<int_4>::FitResidus(mtx,gfit,xorg,yorg,dx,dy) );}
 
 TMatrix<r_4>
-ObjectFitter::FitResidus(TMatrix<r_4> const & mtx, GeneralFit& gfit,
-			 double xorg, double yorg, double dx, double dy)
-{
-  return( ArrayFitter<r_4>::FitResidus(mtx, gfit, xorg, yorg, dx, dy) );
-}
+ObjectFitter::FitResidus(TMatrix<r_4> const & mtx,GeneralFit& gfit,
+			 double xorg,double yorg,double dx,double dy)
+{return( ArrayFitter<r_4>::FitResidus(mtx,gfit,xorg,yorg,dx,dy) );}
 
 TMatrix<r_8>
-ObjectFitter::FitResidus(TMatrix<r_8> const & mtx, GeneralFit& gfit,
-			 double xorg, double yorg, double dx, double dy)
-{
-  return( ArrayFitter<r_8>::FitResidus(mtx, gfit, xorg, yorg, dx, dy) );
-}
+ObjectFitter::FitResidus(TMatrix<r_8> const & mtx,GeneralFit& gfit,
+			 double xorg,double yorg,double dx,double dy)
+{return( ArrayFitter<r_8>::FitResidus(mtx,gfit,xorg,yorg,dx,dy) );}
 
 TMatrix<int_4>
-ObjectFitter::FitFunction(TMatrix<int_4> const & mtx, GeneralFit& gfit,
-			 double xorg, double yorg, double dx, double dy)
-{
-  return( ArrayFitter<int_4>::FitFunction(mtx, gfit, xorg, yorg, dx, dy) );
-}
+ObjectFitter::FitFunction(TMatrix<int_4> const & mtx,GeneralFit& gfit,
+			  double xorg,double yorg,double dx,double dy)
+{return( ArrayFitter<int_4>::FitFunction(mtx,gfit,xorg,yorg,dx,dy) );}
 
 TMatrix<r_4>
-ObjectFitter::FitFunction(TMatrix<r_4> const & mtx, GeneralFit& gfit,
-			 double xorg, double yorg, double dx, double dy)
-{
-  return( ArrayFitter<r_4>::FitFunction(mtx, gfit, xorg, yorg, dx, dy) );
-}
+ObjectFitter::FitFunction(TMatrix<r_4> const & mtx,GeneralFit& gfit,
+			  double xorg,double yorg,double dx,double dy)
+{return( ArrayFitter<r_4>::FitFunction(mtx,gfit,xorg,yorg,dx,dy) );}
 
 TMatrix<r_8>
-ObjectFitter::FitFunction(TMatrix<r_8> const & mtx, GeneralFit& gfit,
-			 double xorg, double yorg, double dx, double dy)
-{
-  return( ArrayFitter<r_8>::FitFunction(mtx, gfit, xorg, yorg, dx, dy) );
-}
+ObjectFitter::FitFunction(TMatrix<r_8> const & mtx,GeneralFit& gfit,
+			  double xorg,double yorg,double dx,double dy)
+{return( ArrayFitter<r_8>::FitFunction(mtx,gfit,xorg,yorg,dx,dy) );}
 
 TVector<int_4>
-ObjectFitter::FitResidus(TVector<int_4> const & vec, GeneralFit& gfit,
-			       double xorg, double dx)
-{  
-  return( ArrayFitter<int_4>::FitResidus(vec, gfit, xorg, dx) );
-}
+ObjectFitter::FitResidus(TVector<int_4> const & vec,GeneralFit& gfit,
+			 double xorg,double dx)
+{return( ArrayFitter<int_4>::FitResidus(vec,gfit,xorg,dx) );}
 
 TVector<r_4>
-ObjectFitter::FitResidus(TVector<r_4> const & vec, GeneralFit& gfit,
-			       double xorg, double dx)
-{  
-  return( ArrayFitter<r_4>::FitResidus(vec, gfit, xorg, dx) );
-}
+ObjectFitter::FitResidus(TVector<r_4> const & vec,GeneralFit& gfit,
+			 double xorg,double dx)
+{return( ArrayFitter<r_4>::FitResidus(vec,gfit,xorg,dx) );}
 
 TVector<r_8>
-ObjectFitter::FitResidus(TVector<r_8> const & vec, GeneralFit& gfit,
-			       double xorg, double dx)
-{  
-  return( ArrayFitter<r_8>::FitResidus(vec, gfit, xorg, dx) );
-}
+ObjectFitter::FitResidus(TVector<r_8> const & vec,GeneralFit& gfit,
+			 double xorg,double dx)
+{return( ArrayFitter<r_8>::FitResidus(vec,gfit,xorg,dx) );}
 
 TVector<int_4>
-ObjectFitter::FitFunction(TVector<int_4> const & vec, GeneralFit& gfit,
-			       double xorg, double dx)
-{  
-  return( ArrayFitter<int_4>::FitFunction(vec, gfit, xorg, dx) );
-}
+ObjectFitter::FitFunction(TVector<int_4> const & vec,GeneralFit& gfit,
+			  double xorg,double dx)
+{return( ArrayFitter<int_4>::FitFunction(vec,gfit,xorg,dx) );}
 
 TVector<r_4>
-ObjectFitter::FitFunction(TVector<r_4> const & vec, GeneralFit& gfit,
-			       double xorg, double dx)
-{  
-  return( ArrayFitter<r_4>::FitFunction(vec, gfit, xorg, dx) );
-}
+ObjectFitter::FitFunction(TVector<r_4> const & vec,GeneralFit& gfit,
+			  double xorg,double dx)
+{return( ArrayFitter<r_4>::FitFunction(vec,gfit,xorg,dx) );}
 
 TVector<r_8>
-ObjectFitter::FitFunction(TVector<r_8> const & vec, GeneralFit& gfit,
-			       double xorg, double dx)
-{  
-  return( ArrayFitter<r_8>::FitFunction(vec, gfit, xorg, dx) );
-}
-
+ObjectFitter::FitFunction(TVector<r_8> const & vec,GeneralFit& gfit,
+			  double xorg,double dx)
+{return( ArrayFitter<r_8>::FitFunction(vec,gfit,xorg,dx) );}
+
+//============================= Matrix et Vector ============================
+Image<uint_2> ObjectFitter::FitResidus(Image<uint_2> const & im,GeneralFit& gfit)
+{ return( ImageFitter<uint_2>::FitResidus(im,gfit) ); }
+Image<int_4> ObjectFitter::FitResidus(Image<int_4> const & im,GeneralFit& gfit)
+{ return( ImageFitter<int_4>::FitResidus(im,gfit) ); }
+Image<int_8> ObjectFitter::FitResidus(Image<int_8> const & im,GeneralFit& gfit)
+{ return( ImageFitter<int_8>::FitResidus(im,gfit) ); }
+Image<r_4> ObjectFitter::FitResidus(Image<r_4> const & im,GeneralFit& gfit)
+{ return( ImageFitter<r_4>::FitResidus(im,gfit) ); }
+Image<r_8> ObjectFitter::FitResidus(Image<r_8> const & im,GeneralFit& gfit)
+{ return( ImageFitter<r_8>::FitResidus(im,gfit) ); }
+
+Image<uint_2> ObjectFitter::FitFunction(Image<uint_2> const & im,GeneralFit& gfit)
+{ return( ImageFitter<uint_2>::FitFunction(im,gfit) ); }
+Image<int_4> ObjectFitter::FitFunction(Image<int_4> const & im,GeneralFit& gfit)
+{ return( ImageFitter<int_4>::FitFunction(im,gfit) ); }
+Image<int_8> ObjectFitter::FitFunction(Image<int_8> const & im,GeneralFit& gfit)
+{ return( ImageFitter<int_8>::FitFunction(im,gfit) ); }
+Image<r_4> ObjectFitter::FitFunction(Image<r_4> const & im,GeneralFit& gfit)
+{ return( ImageFitter<r_4>::FitFunction(im,gfit) ); }
+Image<r_8> ObjectFitter::FitFunction(Image<r_8> const & im,GeneralFit& gfit)
+{ return( ImageFitter<r_8>::FitFunction(im,gfit) ); }
 
 //=============================== Histo =====================================
@@ -129,26 +128,11 @@
 /*!
   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
+  \param errtype,errscale,errmin : pour definir les erreurs
+  \sa GeneralFitData::ComputeError(double,err,FitErrType,double,double,bool)
 */
-int_4 ObjectFitter::Fit(Histo const& h, GeneralFit& gfit,unsigned short typ_err)
+int_4 ObjectFitter::Fit(Histo const& h, GeneralFit& gfit
+      ,GeneralFitData::FitErrType errtype,double errscale,double errmin)
 {
 if(h.NBins()<=0) return -1000;
-if(typ_err>5) typ_err=0;
 
 GeneralFitData mydata(1,h.NBins());
@@ -157,12 +141,6 @@
   r_8 x =  h.BinCenter(i);
   r_8 f =  h(i);
-  r_8 saf = sqrt(fabs( f)); if(saf<1.) saf=1.;
-  r_8 e=0.;
-  if(typ_err==0)      {if(h.HasErrors()) e=h.Error(i); else e=1.;}
-  else if(typ_err==1) {if(h.HasErrors()) e=h.Error(i); else e=saf;}
-  else if(typ_err==2) e=1.;
-  else if(typ_err==3) e=saf;
-  else if(typ_err==4) e=(f==0.)?0.:1.;
-  else if(typ_err==5) e=(f==0.)?0.:saf;
+  r_8 e = (h.HasErrors()) ? h.Error(i) : 1.;
+  e = GeneralFitData::ComputeError(f,e,errtype,errscale,errmin);
   mydata.AddData1(x,f,e);
 }
@@ -214,41 +192,19 @@
 /*!
   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
+  \param errtype,errscale,errmin : pour definir les erreurs
+  \sa GeneralFitData::ComputeError(double,err,FitErrType,double,double,bool)
 */
-int_4 ObjectFitter::Fit(Histo2D const & h, GeneralFit& gfit,unsigned short typ_err)
+int_4 ObjectFitter::Fit(Histo2D const & h, GeneralFit& gfit
+      ,GeneralFitData::FitErrType errtype,double errscale,double errmin)
 {
 if(h.NBinX()*h.NBinY()<=0) return -1000;
-if(typ_err>5) typ_err=0;
 
 GeneralFitData mydata(2,h.NBinX()*h.NBinY());
 
 for(int_4 i=0;i<h.NBinX();i++) for(int_4 j=0;j<h.NBinY();j++) {
-  r_8 x,y;
-  h.BinCenter(i,j,x,y);
+  r_8 x,y; h.BinCenter(i,j,x,y);
   r_8 f = h(i,j);
-  r_8 saf = sqrt(fabs(f)); if(saf<1.) saf=1.;
-  r_8 e=0.;
-  if(typ_err==0)      {if(h.HasErrors()) e=h.Error(i,j); else e=1.;}
-  else if(typ_err==1) {if(h.HasErrors()) e=h.Error(i,j); else e=saf;}
-  else if(typ_err==2) e=1.;
-  else if(typ_err==3) e=saf;
-  else if(typ_err==4) e=(f==0.)?0.:1.;
-  else if(typ_err==5) e=(f==0.)?0.:saf;
+  r_8 e = (h.HasErrors()) ? h.Error(i,j) : 1.;
+  e = GeneralFitData::ComputeError(f,e,errtype,errscale,errmin);
   mydata.AddData2(x,y,f,e);
 }
@@ -265,8 +221,9 @@
 //===========================================================================
 
+/*! Retourne une classe contenant les residus du fit ``gfit''. */
 template <class T>
 TMatrix<T> 
 ArrayFitter<T>::FitResidus(TMatrix<T> const & mtx, GeneralFit& gfit,
-			 double xorg,double yorg,double dx,double dy)
+			   double xorg,double yorg,double dx,double dy)
 // Retourne une classe contenant les residus du fit ``gfit''.
 // On suppose que x=j (colonnes) et y=i (lignes) pour m(i,j).
@@ -284,5 +241,5 @@
 double* par = new double[npar];
 {for(int i=0;i<npar;i++) par[i] = gfit.GetParm(i);}
-TMatrix<T> m(mtx);
+TMatrix<T> m(mtx,false);
 m.SetTemp(true);
 for(uint_4 i=0;i<mtx.NRows();i++) for(uint_4 j=0;j<mtx.NCols();j++) {
@@ -295,8 +252,9 @@
 
 
+/*! Retourne une classe contenant la fonction du fit ``gfit''. */
 template <class T>
 TMatrix<T> 
 ArrayFitter<T>::FitFunction(TMatrix<T> const & mtx, GeneralFit& gfit,
-			  double xorg,double yorg,double dx,double dy)
+			    double xorg,double yorg,double dx,double dy)
 
 // Retourne une classe contenant la fonction du fit ``gfit''.
@@ -327,9 +285,10 @@
 }
 
+/*! Retourne une classe contenant les residus du fit ``gfit''. */
 template <class T>
 TVector<T> 
 ArrayFitter<T>::FitResidus(TVector<T> const & vec, GeneralFit& gfit,
-			 double xorg,double dx)
-// Retourne une classe contenant les residus du fit ``gfit''.
+			   double xorg,double dx)
+// Retourne une classe contenant la fonction fittee du fit ``gfit''.
 // La coordonnee de l'element (i) est -> x = xorg + i*dx
 {
@@ -344,5 +303,5 @@
 double* par = new double[npar];
 {for(int i=0;i<npar;i++) par[i] = gfit.GetParm(i);}
-TVector<T> v(vec);
+TVector<T> v(vec,false);
 v.SetTemp(true);
 for(uint_4 i=0;i<vec.NElts();i++) {
@@ -354,9 +313,10 @@
 }
 
+/*! Retourne une classe contenant la fonction du fit ``gfit''. */
 template <class T>
 TVector<T> 
 ArrayFitter<T>::FitFunction(TVector<T> const & vec, GeneralFit& gfit,
-			  double xorg,double dx)
-// Retourne une classe contenant les residus du fit ``gfit''.
+			    double xorg,double dx)
+// Retourne une classe contenant la function fittee du fit ``gfit''.
 // La coordonnee de l'element (i) est -> x = xorg + i*dx
 {
@@ -381,4 +341,59 @@
 }
 
+//===========================================================================
+//===========================================================================
+//========================== ImageFitter<T> =================================
+//===========================================================================
+//===========================================================================
+
+/*! Retourne une classe contenant les residus du fit ``gfit''. */
+template <class T>
+Image<T> 
+ImageFitter<T>::FitResidus(Image<T> const & ima, GeneralFit& gfit)
+{
+if(ima.XSize()<=0||ima.YSize()<=0)
+  throw(SzMismatchError("ImageFitter::FitResidus(Image<T>...) size mismatch\n"));
+GeneralFunction* f = gfit.GetFunction();
+if(f==NULL)
+  throw(NullPtrError("ImageFitter::FitResidus(Image<T>...) GeneraFit==NULL\n"));
+int npar =  gfit.GetNPar();
+if(npar==0)
+  throw(SzMismatchError("ImageFitter::FitResidus(Image<T>...) GeneraFit 0 parametre\n"));
+double* par = new double[npar];
+{for(int i=0;i<npar;i++) par[i] = gfit.GetParm(i);}
+Image<T> im(ima,false);
+im.SetTemp(true);
+for(uint_4 i=0;i<ima.XSize();i++) for(uint_4 j=0;j<ima.YSize();j++) {
+  double x[2] = {ima.XPos(i),ima.YPos(j)};
+  im(i,j) -= f->Value(x,par);
+}
+delete [] par;
+return im;
+}
+
+/*! Retourne une classe contenant la function fittee du fit ``gfit''. */
+template <class T>
+Image<T> 
+ImageFitter<T>::FitFunction(Image<T> const & ima, GeneralFit& gfit)
+{
+if(ima.XSize()<=0||ima.YSize()<=0)
+  throw(SzMismatchError("ImageFitter::FitFunction(Image<T>...) size mismatch\n"));
+GeneralFunction* f = gfit.GetFunction();
+if(f==NULL)
+  throw(NullPtrError("ImageFitter::FitFunction(Image<T>...) GeneraFit==NULL\n"));
+int npar =  gfit.GetNPar();
+if(npar==0)
+  throw(SzMismatchError("ImageFitter::FitFunction(Image<T>...) GeneraFit 0 parametre\n"));
+double* par = new double[npar];
+{for(int i=0;i<npar;i++) par[i] = gfit.GetParm(i);}
+Image<T> im(ima.XSize(),ima.YSize());
+im.SetTemp(true);
+for(uint_4 i=0;i<ima.XSize();i++) for(uint_4 j=0;j<ima.YSize();j++) {
+  double x[2] = {ima.XPos(i),ima.YPos(j)};
+  im(i,j) = f->Value(x,par);
+}
+delete [] par;
+return im;
+}
 
 ///////////////////////////////////////////////////////////////
@@ -389,4 +404,9 @@
 #pragma define_template ArrayFitter< complex<r_4> >
 #pragma define_template ArrayFitter< complex<r_8> >
+#pragma define_template ImageFitter<uint_2>
+#pragma define_template ImageFitter<int_4>
+#pragma define_template ImageFitter<int_8>
+#pragma define_template ImageFitter<r_4>
+#pragma define_template ImageFitter<r_8>
 #endif
 
@@ -397,4 +417,8 @@
 template class ArrayFitter< complex<r_4> >;
 template class ArrayFitter< complex<r_8> >;
+template class ImageFitter<uint_2>;
+template class ImageFitter<int_4>;
+template class ImageFitter<int_8>;
+template class ImageFitter<r_4>;
+template class ImageFitter<r_8>;
 #endif
-
Index: trunk/SophyaLib/NTools/objfitter.h
===================================================================
--- trunk/SophyaLib/NTools/objfitter.h	(revision 1204)
+++ trunk/SophyaLib/NTools/objfitter.h	(revision 1206)
@@ -10,4 +10,5 @@
 
 #include "tmatrix.h"
+#include "cimage.h"
 #include "tvector.h"
 #include "histos.h"
@@ -67,13 +68,30 @@
 				double xorg=0.,double dx=1.);
 
+  // Residus et fonction fittees sur Image
+  static Image<uint_2> FitResidus(Image<uint_2> const & im, GeneralFit& gfit);
+  static Image<int_4> FitResidus(Image<int_4> const & im, GeneralFit& gfit);
+  static Image<int_8> FitResidus(Image<int_8> const & im, GeneralFit& gfit);
+  static Image<r_4> FitResidus(Image<r_4> const & im, GeneralFit& gfit);
+  static Image<r_8> FitResidus(Image<r_8> const & im, GeneralFit& gfit);
+
+  static Image<uint_2> FitFunction(Image<uint_2> const & im, GeneralFit& gfit);
+  static Image<int_4> FitFunction(Image<int_4> const & im, GeneralFit& gfit);
+  static Image<int_8> FitFunction(Image<int_8> const & im, GeneralFit& gfit);
+  static Image<r_4> FitFunction(Image<r_4> const & im, GeneralFit& gfit);
+  static Image<r_8> FitFunction(Image<r_8> const & im, GeneralFit& gfit);
+
   // Residus et fonction fittees sur Histo
   static Histo FitResidus(Histo const& h, GeneralFit& gfit);
   static Histo FitFunction(Histo const& h, GeneralFit& gfit);
-  static int_4 Fit(Histo const & h, GeneralFit& gfit,unsigned short typ_err=0);
+  static int_4 Fit(Histo const & h, GeneralFit& gfit
+          ,GeneralFitData::FitErrType errtype=GeneralFitData::DefaultError
+          ,double errscale=1.,double errmin=1.);
 
   // Residus et fonction fittees sur Histo2D
   static Histo2D FitResidus(Histo2D const& h, GeneralFit& gfit);
   static Histo2D FitFunction(Histo2D const& h, GeneralFit& gfit);
-  static int_4 Fit(Histo2D const & h, GeneralFit& gfit,unsigned short typ_err=0);
+  static int_4 Fit(Histo2D const & h, GeneralFit& gfit
+          ,GeneralFitData::FitErrType errtype=GeneralFitData::DefaultError
+          ,double errscale=1.,double errmin=0.);
 
   // Residus et fonction fittees sur HProf
@@ -82,6 +100,9 @@
   static inline Histo FitFunction(HProf const& h, GeneralFit& gfit)
          {h.UpdateHisto(); return FitFunction((Histo const&) h,gfit);}
-  static int_4 Fit(HProf const & h, GeneralFit& gfit)
-         {h.UpdateHisto(); return Fit((Histo const&) h,gfit,0);}
+  static int_4 Fit(HProf const & h, GeneralFit& gfit
+          ,GeneralFitData::FitErrType errtype=GeneralFitData::DefaultError
+          ,double errscale=1.,double errmin=0.)
+          {h.UpdateHisto();
+           return Fit((Histo const&) h,gfit,errtype,errscale,errmin);}
 
   // Residus et fonction fittees sur GeneralFitData
@@ -108,4 +129,12 @@
 };
 
+//  Classe template pour ajustement sur images
+template <class T>
+class  ImageFitter {
+public:
+  static Image<T> FitResidus(Image<T> const & mtx, GeneralFit& gfit);
+  static Image<T> FitFunction(Image<T> const & mtx, GeneralFit& gfit);
+};
+
 }  // Fin du namespace
 
