source: Sophya/trunk/SophyaPI/PIext/piafitting.cc@ 379

//CMVBUG reste pb suivant:
//openppf cmvwppf.ppf
//fitw h1g g2 p:4500,45,10,900
//delobjs h1g
//clic sur FIT  -> OK
//clic sur FIT 2sd fois -> core dump!!!
//
//
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#include <iostream.h>

#include <typeinfo>

#include "piafitting.h"
#include "strutil.h"

#include "generalfit.h"

#include "fct1dfit.h"
#include "fct2dfit.h"

#include "matrix.h"
#include "cvector.h"
#include "ntuple.h"
#include "cimage.h"

#include "histos.h"
#include "histos2.h"
#include "ntuple.h"
#include "hisprof.h"

#include "nobjmgr.h"
#include "pistdimgapp.h"

////////////////////////////////////////////////////////////////////
////---------- Classe de fenetre de fit interactive ------------////
////////////////////////////////////////////////////////////////////
class PIAFitterWind :  public PIWindow {
public :
                PIAFitterWind(PIStdImgApp* par, PIAFitter* fiter);
  virtual       ~PIAFitterWind();
  virtual void  Show();
  virtual void  Process(PIMessage msg, PIMsgHandler* sender, void* data=NULL);
  void SetState(void);
protected :
  PIStdImgApp* mDap;
  PIAFitter*   mFitter;
  PILabel**    lab; int nlab;
  PIText**     txt; int ntxt;
  PIButton**   but; int nbut;
  PICheckBox** ckb; int nckb;
  bool ReFillGData;
};

////////////////////////////////////////////////////////////////////////
//| --------------- Fit Lineaire a 1 et 2 dimensions ---------------
//| Syntaxe:
//| fitlin nom pnn [o:.aa,bb,cc, o;dd,ee,ff o:gg,hh,jj,kk etc...]
//| avec:
//| nom  : cf commentaire ordre "fit"
//| pnn  : fit polynome degre nn avec classe Poly (lineaire) 1D ou 2D
//| o:aa,...,bb : cf commentaires ordre "fit"
//|
////////////////////////////////////////////////////////////////////////
//| --------------- Fit d'objets a 1 et 2 dimensions ---------------
//|                 avec interface d'aide graphique
//| Syntaxe:
//| fitw nom func
//|     [p:p1,p2,...,pn s:s1,s2,...,sn m:m1,m2,...,mn M:M1,mM2,...,Mn f:f1,...,fn]
//|     [o:.aa,bb,cc, o;dd,ee,ff o:gg,hh,jj,kk etc...]
//| cf commentaire ordre "fit"
//|
////////////////////////////////////////////////////////////////////////
//| --------------- Fit d'objets a 1 et 2 dimensions ---------------
//| Syntaxe:
//| fit nom func
//|     [p:p1,p2,...,pn s:s1,s2,...,sn m:m1,m2,...,mn M:M1,mM2,...,Mn f:f1,...,fn]
//|     [o:.aa,bb,cc, o;dd,ee,ff o:gg,hh,jj,kk etc...]
//|----- OBJET -----
//| nom  : nom de l'objet qui peut etre:
//|        fit-1D:  Vector,Histo1D,HProf ou GeneraFitData(1D)
//|        fit-2D:  Matrix,Histo2D,Image<T> ou GeneraFitData(2D)
//|
//|----- FUNCTION -----
//| func : pnn : fit polynome degre nn avec GeneralFit (non-lineaire) 1D ou 2D
//|      : gnn : fit gaussienne (hauteur) + polynome de degre nn 1D
//|      : g   : fit gaussienne (hauteur) 1D
//|      : enn : fit exponentielle + polynome de degre nn 1D
//|      : e   : fit exponentielle 1D
//|      : Gnn : fit gaussienne (volume) + polynome de degre nn 1D
//|      : G   : fit gaussienne (volume) 1D
//|      :     : fit gaussienne+fond (volume) 2D
//|      : Gi  : fit gaussienne+fond integree (volume) 2D
//|      : d   : fit DL de gaussienne+fond (volume) 2D
//|      : di  : fit DL de gaussienne+fond integree (volume) 2D
//|      : D   : fit DL de gaussienne+fond avec coeff variable p6 (volume) 2D
//|      : Di  : fit DL de gaussienne+fond integree avec coeff variable p6 (volume) 2D
//|      : M   : fit Moffat+fond (expos=p6) (volume) 2D
//|      : Mi  : fit Moffat+fond integree (expos=p6) (volume) 2D
//|
//|----- INIT PARAMETRES ET ETAT DU FIT -----
//| p    : p1,...,pn : valeur d'initialisation des parametres (def=0)
//| s    : s1,...,sn : valeur des steps de depart (def=1)
//| m    : m1,...,mn : valeur des minima (def=1)
//| M    : M1,...,Mn : valeur des maxima (def=-1) (max<=min : pas de limite)
//| f    : f1,...,fn : si >=1 parametre fixe sinon libre (def=0)
//| - Remarque: si pi,si,mi ou Mi = '!' la valeur correspondante n'est pas changee
//|
//|----- OPTIONS -----
//| o    : options "o:Eaa.b,eaa.b,f,r,caa.b,Xaa.b"
//|      F : initialisation a partir des resultats et de l'etat du fit precedent
//|          (option non prioritaire sur les definitions p:,s:,m:,M:,f:o:)
//|      f : generation d'un Objet identique contenant la fonction fittee
//|      r : generation d'un Objet identique contenant les residus
//|      Xaa.b : aa.b valeur du DXi2 d'arret (def=1.e-3)
//|      Naa : aa nombre maximum d'iterations (def=100)
//|      la : niveau "a" de print: a=niveau de print Fit1/2D
//|      da : niveau "a" de debug: a=niveau de GeneralFit
//|      Ii1/i2 : numeros des bins X de l'histos utilises pour le fit [i1,i2]
//|2D    Jj1/j2 : numeros des bins Y de l'histos utilises pour le fit [j1,j2]
//|    - L'erreur est celle associee a l'objet (si elle existe),
//|      elle est mise a 1 sinon, sauf si E... ou e... est precise:
//|      Eaa.b : si |val|>=1 erreur = aa.b*sqrt(|val|)
//|              si |val|<1  erreur = aa.b
//|              si aa.b <=0 alors aa.b=1.0
//|              E seul est equivalent a E1.0
//|      eaa.b : erreur = aa.b
//|              si aa.b <=0 alors aa.b=1.0
//|              e seul est equivalent a e1.0
//|      xaa.b : demande de centrage: on fit x-aa.b au lieu de x)
//|      x : demande de centrage: on fit x-xc au lieu de x
//|          avec xc=abscisse du milieu de l'histogramme
//|          Actif pour  exp+poly 1D, poly 1D
//|          Pour gauss+poly 1D, xc est le centre de la gaussienne.
//|2D    yaa.b et y : idem "xaa.b et x" mais pour y
////////////////////////////////////////////////////////////////////////

/* --Methode-- */
PIAFitter::PIAFitter(PIACmd *piac, PIStdImgApp* app)
: mApp(app), FWindFit(NULL)
, mNObj(""), mObj(NULL), mFunc(NULL), mFName(""), mGData(NULL)
, mNPar(0), mNVar(0),  mNBinX(0), mNBinY(0), mNData(0)
, mPar(1), mStep(1), mMin(1), mMax(1), mFix(1)
, mParSave(1), mStepSave(1), mMinSave(1), mMaxSave(1), mFixSave(1)
, mFit(NULL)
, mV(NULL), mH(NULL), mM(NULL), mH2(NULL), mIm(NULL), mG(NULL)
{
// Init et Set des options
mPar=0.; mStep=1.; mMin=1.; mMax=-1.; mFix=0.;
mParSave=0.; mStepSave=1.; mMinSave=1.; mMaxSave=-1.; mFixSave=0.;
ResetOptions();
mOptSave = mOpt;

// enregistrement des ordres de fit
string kw, usage;

kw = "fit";
usage = "Fitting function to DataObjects (Histo, Histo2D, Vector, ...)";
usage += "\n Usage: fit nomobj func [Options]";
usage += "\n [p:p1,...,pn s:s1,...,sn m:m1,...,mn M:M1,...,Mn o:... o:...]";
piac->RegisterCommand(kw,usage,this,"Fitting");

kw = "fitw";
usage = "Fitting function to DataObjects with Interactive Window Help";
usage += "\n Usage: fitw nomobj func [Options]";
usage += "\n [p:p1,...,pn s:s1,...,sn m:m1,...,mn M:M1,...,Mn o:... o:...]";
piac->RegisterCommand(kw,usage,this,"Fitting");

kw = "fitlin";
usage = "Linear Fitting of Polynoms to DataObjects";
usage += "\n Usage: fitlin nomobj func [o:... o:...]";
piac->RegisterCommand(kw,usage,this,"Fitting");
}

/* --Methode-- */
PIAFitter::~PIAFitter()
{
if(mFit != NULL) {delete mFit; mFit=NULL;}
if(mFunc != NULL) {delete mFunc; mFunc=NULL;}
if(mGData != NULL) {delete mGData; mGData=NULL;}
if(FWindFit != NULL) {delete FWindFit; FWindFit=NULL;}
}

/* --Methode-- */
void PIAFitter::ResetDPointer(void)
// Reset des pointeurs sur les donnees
{
mNObj = ""; mObj=NULL;
mV=NULL; mH=NULL; mM=NULL; mH2=NULL; mIm=NULL; mG=NULL;
}

/* --Methode-- */
void PIAFitter::ResetOptions(void)
// Reset des options
{
mOpt.okres = mOpt.okfun = false;
mOpt.polcx = mOpt.polcy = 0;
mOpt.xc = mOpt.yc = 0.;
mOpt.stc2 = 1.e-3;
mOpt.nstep = 100;
mOpt.err_e = mOpt.err_E = -1.;
mOpt.lp = 1; mOpt.lpg = 0;
mOpt.i1 = mOpt.j1 = mOpt.i2 = mOpt.j2 = -1;
mOpt.fromlastfit = false;
}

/* --Methode-- */
void PIAFitter::DecodeOptions(string opt)
// Decodage des options a partir des chaines de caracteres
{
ResetOptions();
if(opt.length()<=0) return;

size_t p,q; string dum;
opt = "," + opt + ",";

if(strstr(opt.c_str(),",F,"))  // init options/param a partir du fit precedent
  {mOpt = mOptSave; mOpt.fromlastfit = true;}
if(strstr(opt.c_str(),",r,")) mOpt.okres = true;  // residus
if(strstr(opt.c_str(),",f,")) mOpt.okfun = true;  // fonction fittee
if(strstr(opt.c_str(),",x")) { // Demande de centrage (fit X=x-xc)
  mOpt.polcx = 2; // Le centrage est calcule automatiquement
  p = opt.find(",x"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) {
    sscanf(dum.c_str(),",x%lf",&mOpt.xc);
    mOpt.polcx = 1; // Le centrage est fixe par la valeur lue
  }
}
if(strstr(opt.c_str(),",y")) { // Demande de centrage (fit Y=y-yc)
  mOpt.polcy = 2; // Le centrage est calcule automatiquement
  p = opt.find(",y"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) {
    sscanf(dum.c_str(),",y%lf",&mOpt.yc);
    mOpt.polcy = 1; // Le centrage est fixe par la valeur lue
  }
}
if(strstr(opt.c_str(),",E")) { // Erreurs imposees a "sqrt(val)" ou "aa.b*sqrt(val)"
  p = opt.find(",E"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) sscanf(dum.c_str(),",E%lf",&mOpt.err_E);
  if(mOpt.err_E<=0.) mOpt.err_E = 1.;  //mOpt.err_e=-1.;
}
if(strstr(opt.c_str(),",e")) { // Erreurs imposees a "1" ou "aa.b"
  p = opt.find(",e"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) sscanf(dum.c_str(),",e%lf",&mOpt.err_e);
  if(mOpt.err_e<=0.) mOpt.err_e = 1.;  //mOpt.err_E=-1.;
}
if(strstr(opt.c_str(),",X")) { // Valeur du StopChi2
  p = opt.find(",X"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) sscanf(dum.c_str(),",X%lf",&mOpt.stc2);
}
if(strstr(opt.c_str(),",N")) { // Nombre maximum d'iterations
  p = opt.find(",N"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) sscanf(dum.c_str(),",N%d",&mOpt.nstep);
}
if(strstr(opt.c_str(),",l")) { // niveau de print
  p = opt.find(",l"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) sscanf(dum.c_str(),",l%d",&mOpt.lp);
}
if(strstr(opt.c_str(),",d")) { // niveau de debug du fit
  p = opt.find(",d"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) sscanf(dum.c_str(),",d%d",&mOpt.lpg);
}
if(strstr(opt.c_str(),",I")) { // intervalle de fit selon X
  p = opt.find(",I"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) sscanf(dum.c_str(),",I%d/%d",&mOpt.i1,&mOpt.i2);
}
if(strstr(opt.c_str(),",J")) { // intervalle de fit selon Y
  p = opt.find(",J"); q = opt.find_first_of(',',p+1);
  dum = opt.substr(p,q-p);
  if(dum.length()>2) sscanf(dum.c_str(),",J%d/%d",&mOpt.j1,&mOpt.j2);
}

return;
}

/* --Methode-- */
void PIAFitter::DecodeObject(string obj)
// Decodage de l'objet a fitter
{
NamedObjMgr omg;
AnyDataObj* mobj = omg.GetObj(obj);
if(mobj == NULL)
  {cout<<"PIAFitter::DecodeObject Error , Pas d'objet de nom "<<obj<<endl;
   return;}

// Reset
ResetDPointer();
mNVar = mNBinX = mNBinY = mNData = 0;

mObj = mobj; mNObj = obj;
string ctyp = typeid(*mObj).name();

// 1D
if (typeid(*mObj) == typeid(Vector)) {
  mNVar = 1;
  mV = (Vector*) mObj; mNBinX = mV->NElts(); mNBinY = 1;
  }
else if ( (typeid(*mObj) == typeid(HProf)) || (typeid(*mObj) == typeid(Histo)) ) {
  mNVar = 1;
  mH = (Histo*)  mObj; mNBinX = mH->NBins(); mNBinY = 1;
  }
// 2D
else if (typeid(*mObj) == typeid(Matrix)) {
  mNVar = 2;
  mM = (Matrix*) mObj; mNBinX = mM->NCol(); mNBinY =mM->NRows();
  }
else if (typeid(*mObj) == typeid(Histo2D)) {
  mNVar = 2;
  mH2 = (Histo2D*) mObj; mNBinX = mH2->NBinX(); mNBinY = mH2->NBinY();
  }
else if (typeid(*mObj) == typeid(GeneralFitData)) {
  mG = (GeneralFitData*) mObj; mNBinX = mG->NData(); mNBinY = 1;
  if(     mG->NVar()==1) mNVar = 1;
  else if(mG->NVar()==2) mNVar = 2;
  else
     {cout<<"PIAFitter::DecodeObject Error: \n"
         <<" GeneralFitData ne peut avoir que 1 ou 2 variables d'abscisse: "
         <<((GeneralFitData*) mObj)->NVar()<<endl;
     return;}
  }
else if (dynamic_cast<RzImage*>(mObj)) {
  mNVar = 2;
  mIm = (RzImage*) mObj; mNBinX = mIm->XSize(); mNBinY = mIm->YSize();
  }
else {
  cout<<"PIAFitter::DecodeObject Error , Objet n'est pas un "
      <<"Histo1D/HProf/Vector/Histo2D/Image/Matrix/GeneralFitData "<<ctyp<<endl;
  return;
  }

mNData = mNBinX*mNBinY;
if(mNData<=0) {
  cout<<"L'objet a "<<mNBinX<<","<<mNBinY<<" bins ("<<mNData<<")"<<endl;
  return;
}

return;
}

/* --Methode-- */
void PIAFitter::CheckOptions(void)
// Check consistence des choix des options
// ATTENTION: cette methode a besoin que l'objet a fitter soit deja lu
{
if(mOpt.lp<0) mOpt.lp = 0;
if(mOpt.lpg<0) mOpt.lpg = 0;
mOpt.i1 = (mOpt.i1<0||mOpt.i1>=mNBinX)? 0: mOpt.i1;
mOpt.i2 = (mOpt.i2<0||mOpt.i2>=mNBinX||mOpt.i2<mOpt.i1)? mNBinX-1: mOpt.i2;
if(mNVar>=2) {
  mOpt.j1 = (mOpt.j1<0||mOpt.j1>=mNBinY)? 0: mOpt.j1;
  mOpt.j2 = (mOpt.j2<0||mOpt.j2>=mNBinY||mOpt.j2<mOpt.j1)? mNBinY-1: mOpt.j2;
} else mOpt.j2 = mOpt.j1 = 0;
if(mOpt.polcx==2) {
  if(mV||mM)   mOpt.xc = (mOpt.i2-mOpt.i1+1)/2.;
  else if(mH)  mOpt.xc = (mH->XMin()+mH->XMax())/2.;
  else if(mH2) mOpt.xc = (mH2->XMin()+mH2->XMax())/2.;
  else if(mG)  {double mini,maxi; mG->GetMinMax(2,mini,maxi); mOpt.xc=(mini+maxi)/2.;}
  else if(mIm) {mOpt.xc = mIm->XOrg() * mIm->XPxSize()*(mOpt.i2-mOpt.i1+1)/2.;}
}
if(mOpt.polcy==2 && mNVar>=2) {
  if(mM)  mOpt.yc = (mOpt.j2-mOpt.j1+1)/2.;
  if(mH2) mOpt.yc = (mH2->YMin()+mH2->YMax())/2.;
  if(mG)  {double mini,maxi; mG->GetMinMax(12,mini,maxi); mOpt.yc=(mini+maxi)/2.;}
  if(mIm) {mOpt.yc = mIm->YOrg() * mIm->YPxSize()*(mOpt.j2-mOpt.j1+1)/2.;}
}
if(mOpt.err_e>0.) mOpt.err_E=-1.;
if(mOpt.err_E>0.) mOpt.err_e =-1.;
if(mOpt.stc2<=0.) mOpt.stc2 = 1.e-3;
if(mOpt.nstep<2) mOpt.nstep = 100;

return;
}

/* --Methode-- */
void PIAFitter::PrintOptions(void)
// Print des options
{
cout<<"Fit["<<mNBinX<<","<<mNBinY<<"] ("<<mNData<<") dim="<<mNVar<<":"
    <<" Int=["<<mOpt.i1<<","<<mOpt.i2<<"],["<<mOpt.j1<<","<<mOpt.j2<<"]"<<endl
    <<" Cent="<<mOpt.polcx<<","<<mOpt.polcy<<","<<mOpt.xc<<"+x"<<","<<mOpt.yc<<"+y"
    <<" TypE="<<mOpt.err_e<<","<<mOpt.err_E
    <<" StpX2="<<mOpt.stc2<<" Nstep="<<mOpt.nstep<<" Init.LFit="<<mOpt.fromlastfit
    <<" lp,lpg="<<mOpt.lp<<","<<mOpt.lpg<<endl;
return;
}

/* --Methode-- */
void PIAFitter::FillGData(void)
// Fill generalfitdata pour le fit
// ATTENTION: cette methode a besoin que les options soient decodees et checkees
{
if(mNData<=0) return;
if(mGData!=NULL) {delete mGData; mGData=NULL;}
mGData = new GeneralFitData(mNVar,mNData,0);

for(int i=mOpt.i1;i<=mOpt.i2;i++) for(int j=mOpt.j1;j<=mOpt.j2;j++) {
  double x,y=0.,f,e;

  if(mV)
    {x= (double) i; f=(*mV)(i); e=1.;}
  else if(mH)
    {x=mH->BinCenter(i); f=(*mH)(i); e=(mH->HasErrors())?mH->Error(i):1.;}
  else if(mM)
    {x=(double) i; y=(double) j; f=(*mM)(j,i); e=1.;}
  else if(mH2)
    {float xf,yf; mH2->BinCenter(i,j,xf,yf); x=(double)xf; y=(double)yf;
     f=(*mH2)(i,j); e=(mH2->HasErrors())?mH2->Error(i,j):1.;}
  else if(mIm)
    {x=mIm->XOrg()+(i+0.5)*mIm->XPxSize(); y=mIm->YOrg()+(j+0.5)*mIm->YPxSize();
     f=mIm->DValue(i,j); e=1.;}
  else if(mG&&mNVar==1) {x= mG->X(i); f=mG->Val(i); e=mG->EVal(i);}
  else if(mG&&mNVar==2) {x= mG->X(i); y=mG->Y(i); f=mG->Val(i); e=mG->EVal(i);}
  else x=y=f=e=0.;

  // Gestion des erreurs a utiliser
  if(mOpt.err_e>0.) e=mOpt.err_e;
  else if(mOpt.err_E>0.) {e=(f<-1.||f>1.)?mOpt.err_E*sqrt(fabs(f)):mOpt.err_E;}

  // Remplissage de generalfitdata
  if(mFName[0]=='p') {x -= mOpt.xc; if(mNVar>=2) y -= mOpt.yc;}
  if(mNVar==1)      mGData->AddData1(x,f,e);
  else if(mNVar==2) mGData->AddData2(x,y,f,e);
}

if(mGData->NData()<=0) {
  cout<<"Pas de donnees dans GeneralFitData: "<<mGData->NData()<<endl;
  return;
}

if(mOpt.lpg>1) {
  mGData->PrintStatus();
  mGData->PrintData(0);
  mGData->PrintData(mGData->NData()-1);
}

return;
}

/* --Methode-- */
void PIAFitter::DecodeFunction(string func)
// Fonction a fitter
// ATTENTION: cette methode a besoin que les donnees soient lues
{
if(func.length()<=0) {
  cout<<"PIAFitter::DecodeFunction Donnez un nom de fonction a fitter."<<endl;
  return;
}
if(mFunc!=NULL) {delete mFunc; mFunc=NULL;}

mNPar=0;
mFName = func;

if(func[0]=='p' && mNVar==1) { //polynome
  int degre = 0;
  if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
  cout<<"Fit polynome 1D de degre "<<degre<<endl;
  Polyn1D* myf = new Polyn1D(degre,mOpt.xc);
  mFunc = myf; mNPar = mFunc->NPar();

} else if(func[0]=='e' && mNVar==1) { //exponentielle
  int degre =-1;
  if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
  cout<<"Fit d'exponentielle+polynome 1D de degre "<<degre<<endl;
  Exp1DPol* myf;
  if(degre>=0) myf = new Exp1DPol((unsigned int)degre,mOpt.xc);
       else    myf = new Exp1DPol(mOpt.xc);
  mFunc = myf; mNPar = mFunc->NPar();

} else if(func[0]=='g' && mNVar==1) { //gaussienne en hauteur
  int degre =-1;
  if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
  cout<<"Fit de Gaussienne_en_hauteur+polynome 1D de degre "<<degre<<endl;
  Gauss1DPol* myf;
  if(degre>=0) myf = new Gauss1DPol((unsigned int)degre,((mOpt.polcx)?true:false));
  else { bool bfg = (mOpt.polcx)?true:false;   myf = new Gauss1DPol(bfg); }
  mFunc = myf; mNPar = mFunc->NPar();

} else if(func[0]=='G' && mNVar==1) { //gaussienne en volume
  int degre =-1;
  if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
  cout<<"Fit de Gaussienne_en_volume+polynome 1D de degre "<<degre<<endl;
  GaussN1DPol* myf;
  if(degre>=0) myf = new GaussN1DPol((unsigned int)degre,((mOpt.polcx)?true:false));
  else  { bool bfg = (mOpt.polcx)?true:false;   myf = new GaussN1DPol(bfg); }
  mFunc = myf; mNPar = mFunc->NPar();

} else if(func[0]=='p' && mNVar==2) { //polynome 2D
  int degre = 0;
  if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
  cout<<"Fit polynome 2D de degre "<<degre<<endl;
  Polyn2D* myf = new Polyn2D(degre,mOpt.xc,mOpt.yc);
  mFunc = myf; mNPar = mFunc->NPar();

} else if(func[0]=='G' && mNVar==2) { //gaussienne+fond en volume
  int integ = 0;
  if(func.length()>1) if(func[1]=='i') integ=1;
  cout<<"Fit de Gaussienne+Fond 2D integ="<<integ<<endl;
  if(integ) {GauRhInt2D* myf = new GauRhInt2D; mFunc = myf;}
    else    {GauRho2D* myf = new GauRho2D; mFunc = myf;}
  mNPar = mFunc->NPar();

} else if(func[0]=='d' && mNVar==2) { //DL gaussienne+fond en volume
  int integ = 0;
  if(func.length()>1) if(func[1]=='i') integ=1;
  cout<<"Fit de DL de Gaussienne+Fond 2D integ="<<integ<<endl;
  if(integ) {GdlRhInt2D* myf = new GdlRhInt2D; mFunc = myf;}
    else    {GdlRho2D* myf = new GdlRho2D; mFunc = myf;}
  mNPar = mFunc->NPar();

} else if(func[0]=='D' && mNVar==2) { //DL gaussienne+fond avec coeff variable p6 en volume
  int integ = 0;
  if(func.length()>1) if(func[1]=='i') integ=1;
  cout<<"Fit de DL de Gaussienne+Fond avec coeff variable (p6) 2D integ="<<integ<<endl;
  if(integ) {Gdl1RhInt2D* myf = new Gdl1RhInt2D; mFunc = myf;}
    else    {Gdl1Rho2D* myf = new Gdl1Rho2D; mFunc = myf;}
  mNPar = mFunc->NPar();

} else if(func[0]=='M' && mNVar==2) { //Moffat+fond (volume)
  int integ = 0;
  if(func.length()>1) if(func[1]=='i') integ=1;
  cout<<"Fit de Moffat+Fond (expos=p6) 2D integ="<<integ<<endl;
  if(integ) {MofRhInt2D* myf = new MofRhInt2D; mFunc = myf;}
    else    {MofRho2D* myf = new MofRho2D; mFunc = myf;}
  mNPar = mFunc->NPar();

} else {
  cout<<"Fonction "<<func<<" inconnue pour la dim "<<mNVar<<endl;
  mNPar = 0;
  return;
}

return;
}

/* --Methode-- */
void PIAFitter::ReSetParam(void)
// Pour (re)dimensionner les tableaux des parametres
// ATTENTION: cette methode a besoin que la fonction soit connue
{
if(mNPar==0) return;
mPar.Realloc(mNPar);  mPar=0.;
mStep.Realloc(mNPar); mStep=1.;
mMin.Realloc(mNPar);  mMin=1.;
mMax.Realloc(mNPar);  mMax=-1.;
mFix.Realloc(mNPar);  mFix=0.;
return;
}

/* --Methode-- */
void PIAFitter::InitParFromLastFit(void)
// Initialisation du fit a partir des resultats du fit precedent
// (Les arguments de la ligne de commande sont prioritaires)
// ATTENTION: cette methode a besoin que la fonction soit connue
{
if(mNPar==0) return;
int n = mParSave.NElts();
if(n==0) return;

for(int i=0;i<mNPar;i++) {
  if(i>=n) break;
  mPar(i)  = mParSave(i);
  mStep(i) = mStepSave(i);
  mMin(i)  = mMinSave(i);
  mMax(i)  = mMaxSave(i);
  mFix(i)  = mFixSave(i);
}

return;
}

/* --Methode-- */
void PIAFitter::DecodeParam(string par,string step,string min,string max,string fix)
// Decodage des parametres
// ATTENTION: cette methode a besoin que la fonction soit connue
//                            et que les options soient decodees
{
if(mNPar==0) return;
ReSetParam();
if(mOpt.fromlastfit) InitParFromLastFit();
Vector* v=NULL; string* s=NULL;
for(int j=0;j<5;j++) {
  if(j==0) {v=&mPar; s=&par;} else if(j==1) {v=&mStep; s=&step;}
  else if(j==2) {v=&mMin; s=&min;} else if(j==3) {v=&mMax; s=&max;}
  else if(j==4) {v=&mFix; s=&fix;}
  if(s->length()>0) *s += ",";
  for(int i=0;i<mNPar;i++) {
    if(s->length()<=0) break;
    if((*s)[0]!='!') sscanf(s->c_str(),"%lf",&(*v)(i));
    size_t p = s->find_first_of(',') + 1;
    if(p>=s->length()) *s = ""; else *s = s->substr(p);
  }
}
return;
}

/* --Methode-- */
int PIAFitter::DoFit(void)
// Fit avec generalfit
{
if(mNPar==0) return -1000;
if(mFunc==NULL || mGData==NULL) {
  cout<<"PIAFitter::DoFit error: mFunc="<<mFunc<<" mGData="<<mGData<<endl;
  return -1001;
}
// classe GeneraFit
if(mFit != NULL) {delete mFit; mFit= NULL;}
mFit= new GeneralFit(mFunc);
// Options et Set de GeneralFit
mFit->SetDebug(mOpt.lpg);
mFit->SetData(mGData);
mFit->SetStopChi2(mOpt.stc2);
mFit->SetMaxStep(mOpt.nstep);
{for(int i=0;i<mFunc->NPar();i++) {
  char str[10];
  sprintf(str,"P%d",i);
  mFit->SetParam(i,str,mPar(i),mStep(i),mMin(i),mMax(i));
  if((int)(mFix(i)+0.001)>=1.) mFit->SetFix(i);
}}
if(mOpt.lp>1) mFit->PrintFit();

// Fit
mParSave = mPar;
mStepSave = mStep; mMinSave = mMin; mMaxSave = mMax; mFixSave = mFix;
mOptSave = mOpt;
double c2r = -1.;
int rcfit = mFit->Fit();
if(mOpt.lp>0) mFit->PrintFit();
if(rcfit>0) {
  c2r = mFit->GetChi2Red();
  cout<<"C2r_Reduit = "<<c2r<<" nstep="<<mFit->GetNStep()<<" rc="<<rcfit<<endl;
  for(int i=0;i<mFunc->NPar();i++) mParSave(i)=mFit->GetParm(i);
} else {
  cout<<"echec Fit, rc = "<<rcfit<<"  nstep="<<mFit->GetNStep()<<endl;
  mFit->PrintFitErr(rcfit);
}

return rcfit;
}

/* --Methode-- */
void PIAFitter::FitFunRes(void)
// Mise a disposition des resultats (fonction fitee et residus)
{
if(mFunc && (mOpt.okres||mOpt.okfun)) {
  NamedObjMgr omg;
  string nomres = mNObj + "res";
  string nomfun = mNObj + "fun";
  if(mV) {
    if(mOpt.okres) {Vector* ob = mV->FitResidus(*mFit);  if(ob) omg.AddObj(ob,nomres);}
    if(mOpt.okfun) {Vector* ob = mV->FitFunction(*mFit); if(ob) omg.AddObj(ob,nomfun);}
  } else if(mH) {
    if(mOpt.okres) {Histo* ob = mH->FitResidus(*mFit);  if(ob) omg.AddObj(ob,nomres);}
    if(mOpt.okfun) {Histo* ob = mH->FitFunction(*mFit); if(ob) omg.AddObj(ob,nomfun);}
  } else if(mM) {
    if(mOpt.okres) {Matrix* ob = mM->FitResidus(*mFit);  if(ob) omg.AddObj(ob,nomres);}
    if(mOpt.okfun) {Matrix* ob = mM->FitFunction(*mFit); if(ob) omg.AddObj(ob,nomfun);}
  } else if(mH2) {
    if(mOpt.okres) {Histo2D* ob = mH2->FitResidus(*mFit);  if(ob) omg.AddObj(ob,nomres);}
    if(mOpt.okfun) {Histo2D* ob = mH2->FitFunction(*mFit); if(ob) omg.AddObj(ob,nomfun);}
  } else if(mIm) {
    if(mOpt.okres) {RzImage* ob = mIm->FitResidus(*mFit);  if(ob) omg.AddObj(ob,nomres);}
    if(mOpt.okfun) {RzImage* ob = mIm->FitFunction(*mFit); if(ob) omg.AddObj(ob,nomfun);}
  } else if(mG) {
    if(mOpt.okres) {GeneralFitData* ob = mG->FitResidus(*mFit);  if(ob) omg.AddObj(ob,nomres);}
    if(mOpt.okfun) {GeneralFitData* ob = mG->FitFunction(*mFit); if(ob) omg.AddObj(ob,nomfun);}
  }
}
return;
}

/* --Methode-- */
void PIAFitter::LinFit(void)
// Fit lineaire de polynomes
{
if(mFName.length()<=0)
  {cout<<"PIAFitter::LinFit Donnez un nom de fonction a fitter."<<endl;
   return;}
if(!mGData)
  {cout<<"PIAFitter::LinFit pas de Data."<<endl; return;}
if(mFName[0]!='p') 
  {cout<<"PIAFitter::LinFit fonction non prevue "<<mFName<<endl;
   return;}
int degre = 0;
if(mFName.length()>1) sscanf(mFName.c_str()+1,"%d",&degre);

if(mNVar==1) {  // Fit lineaire de polynome 1D
  cout<<"Fit (lineaire) 1D polynome de degre "<<degre<<endl;
  Poly p1(0);
  double c2rl = mGData->PolFit(0,p1,degre);
  cout<<"C2r_lineaire = "<<c2rl<<endl;
  if(mOpt.lp>0) cout<<p1<<endl;
} else if(mNVar==2) {  // Fit lineaire de polynome 2D
  cout<<"Fit (lineaire) polynome 2D de degre "<<degre<<endl;
  Poly2 p2(0);
  double c2rl = mGData->PolFit(0,1,p2,degre);
  cout<<"C2r_lineaire = "<<c2rl<<endl;
  if(mOpt.lp>0) cout<<p2<<endl;
}

return;
}

/* --Methode-- */
int PIAFitter::Execute(string& kw, vector<string>& tokens)
// Execution des commandes de fit : "fit" et "fitw"
{
if(tokens.size() < 2) {
  cout
  <<"Usage:fit  nomobj func [Options]\n"
  <<" ou   fitw nomobj func [Options]\n"
  <<" avec Options: [p:p1,...,pn s:s1,...,sn m:m1,...,mn \n"
  <<"                M:M1,...,Mn f:f1,...,fn o:.,.,. o:.,.,.]\n"
  <<" ou   fitlin nomobj func [o:.,.,. o:.,.,.]\n";
  return(-1);
}
// decodage des arguments de la commande
string mSp,mSs,mSm,mSM,mSf,mSo;
mSp=""; mSs=""; mSm=""; mSM=""; mSf=""; mSo="";
if(tokens.size()>2)
  for(int ip=2;ip<(int)tokens.size();ip++) {
    if(tokens[ip].length()<=2) continue;
    const char *c = tokens[ip].c_str();
    if(c[1]!=':') continue;
    if(c[0]=='p')      mSp=c+2;
    else if(c[0]=='s') mSs=c+2;
    else if(c[0]=='m') mSm=c+2;
    else if(c[0]=='M') mSM=c+2;
    else if(c[0]=='f') mSf=c+2;
    else if(c[0]=='o') {mSo += ","; mSo += c+2;}
  }
// Execution des commandes
DecodeOptions(mSo);
DecodeObject(tokens[0]);
CheckOptions();
if(mOpt.lp>0) PrintOptions();
FillGData();
DecodeFunction(tokens[1]);
DecodeParam(mSp,mSs,mSm,mSM,mSf);
if (kw == "fit") {
  int rc = DoFit();
  if(rc>=0) FitFunRes();
} else if (kw == "fitlin") {
  LinFit();
} else if (kw == "fitw") {
  if(FWindFit!=NULL) {delete FWindFit; FWindFit=NULL;}
  FWindFit = new PIAFitterWind(mApp,this);
  FWindFit->Show();
}

return(0);
}

////////////////////////////////////////////////////////////////////
////---------- Classe de fenetre de fit interactive ------------////
////////////////////////////////////////////////////////////////////

/* --Methode-- */
PIAFitterWind::PIAFitterWind(PIStdImgApp* par, PIAFitter* fiter)
 : PIWindow((PIMsgHandler*)par, "PIAFitter", PIWK_normal, 240, 240, 150, 150)
{
ReFillGData = false;
mDap = par;
mFitter = fiter;
string obj = mFitter->mNObj;
string fun = mFitter->mFName;
int npar = mFitter->mNPar;

// Alloc de la taille
nlab = 20+npar;   lab = new PILabel*[nlab];    {for(int i=0;i<nlab;i++) lab[i]=NULL;}
ntxt = 20+4*npar; txt = new PIText*[ntxt];     {for(int i=0;i<ntxt;i++) txt[i]=NULL;}
nbut = 20;        but = new PIButton*[nbut];   {for(int i=0;i<nbut;i++) but[i]=NULL;}
nckb = 20+npar;   ckb = new PICheckBox*[nckb]; {for(int i=0;i<nckb;i++) ckb[i]=NULL;}

// On definit la taille a partir de la taille par defaut des composantes
// bsx,bsy = environ 6 lettres
int bsx,bsy;
par->PrefCompSz(bsx, bsy);
int spx = (bsx>=10) ? bsx/10 : 1;  // intervalle entre lettres X
int spy = (bsy>=6) ? bsy/6 : 1;    // intervalle entre lettres Y

int wszx = (5*bsx+5*spx)+spx;
int wszy = 8*(bsy+spy)+npar*(bsy+spy)+spy;
SetSize(wszx, wszy);
int cpx,cpy;

// 1 ere ligne
cpx=spx; cpy=spy;
but[0] = new PIButton(this,"Fr.Last",111,bsx,bsy,cpx,cpy);
but[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx += bsx+spx;
but[1] = new PIButton(this,"Default",222,bsx,bsy,cpx,cpy);
but[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
ckb[0] = new PICheckBox(this,"Gen Fun",1001,bsx,bsy,cpx,cpy);
ckb[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx += bsx+2*spx;
ckb[1] = new PICheckBox(this,"Res",1002,bsx,bsy,cpx,cpy);
ckb[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);

// 2 ieme ligne
cpx=spx; cpy += bsy+spy;
ckb[2] = new PICheckBox(this,"Cent X",1003,bsx,bsy,cpx,cpy);
ckb[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
txt[0] = new PIText(this,"",bsx,bsy,cpx,cpy);
txt[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+2*spx;
ckb[3] = new PICheckBox(this,"Y",1004,bsx/2,bsy,cpx,cpy);
ckb[3]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx/2+spx;
txt[1] = new PIText(this,"",bsx,bsy,cpx,cpy);
txt[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);

// 3 ieme ligne
cpx=spx; cpy += bsy+spy;
lab[0] = new PILabel(this,"Err cste",1.25*bsx,bsy,cpx,cpy);
lab[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=1.25*bsx+spx;
txt[2] = new PIText(this,"",bsx,bsy,cpx,cpy);
txt[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+2*spx;
lab[1] = new PILabel(this,"sqrt",bsx,bsy,cpx,cpy);
lab[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
txt[3] = new PIText(this,"",bsx,bsy,cpx,cpy);
txt[3]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);

// 4 ieme ligne
cpx=spx; cpy += bsy+spy;
lab[2] = new PILabel(this,"Stop Xi2",1.25*bsx,bsy,cpx,cpy);
lab[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=1.25*bsx+spx;
txt[4] = new PIText(this,"",bsx,bsy,cpx,cpy);
txt[4]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
lab[3] = new PILabel(this,"Iter",bsx, bsy, cpx, cpy);
lab[3]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
txt[5] = new PIText(this,"",bsx,bsy,cpx,cpy);
txt[5]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);

// 5 ieme ligne
cpx=spx; cpy += bsy+spy;
lab[4] = new PILabel(this,"Print",bsx,bsy,cpx,cpy);
lab[4]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
txt[6] = new PIText(this,"",bsx/2,bsy,cpx,cpy);
txt[6]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx/2+spx;
lab[5] = new PILabel(this,"Debug",bsx,bsy,cpx,cpy);
lab[5]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
txt[7] = new PIText(this,"",bsx/2,bsy,cpx,cpy);
txt[7]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);

// 6 ieme ligne
cpx=spx; cpy += bsy+spy;
lab[6] = new PILabel(this,"Range X",bsx,bsy,cpx,cpy);
lab[6]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
txt[8] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
txt[8]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=0.75*bsx+spx;
txt[9] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
txt[9]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=0.75*bsx+spx;
lab[7] = new PILabel(this,"Y",bsx/2,bsy,cpx,cpy);
lab[7]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx/2+spx;
txt[10] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
txt[10]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=0.75*bsx+spx;
txt[11] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
txt[11]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);

// 7 ieme ligne
cpx=spx; cpy+=bsy+spy;
but[2] = new PIButton(this, "Dismiss",777,bsx,bsy,cpx,cpy);
but[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx += bsx+spx;
but[3] = new PIButton(this, "Refesh",666,bsx,bsy,cpx,cpy);
but[3]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx += bsx+spx;
but[4] = new PIButton(this, "Fit",333,bsx,bsy,cpx,cpy);
but[4]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
lab[8] = new PILabel(this,fun.c_str(),bsx/2,bsy,cpx,cpy);
lab[8]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);

// Parametres (npar lignes)
cpx=spx; cpy+=bsy+spy;
lab[9] = new PILabel(this,"Par",bsx/2,bsy,cpx,cpy);
lab[9]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx/2+spx;
lab[10] = new PILabel(this,"F",bsx/3,bsy,cpx,cpy);
lab[10]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx/3+spx;
lab[11] = new PILabel(this,"Init",bsx,bsy,cpx,cpy);
lab[11]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
lab[12] = new PILabel(this,"Step",bsx,bsy,cpx,cpy);
lab[12]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
lab[13] = new PILabel(this,"Min",bsx,bsy,cpx,cpy);
lab[13]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
cpx+=bsx+spx;
lab[14] = new PILabel(this,"Max",bsx,bsy,cpx,cpy);
lab[14]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
if(npar>0) {
  for(int i=0;i<npar;i++) {
    cpx=spx; cpy+=bsy+spy;
    char str[8]; sprintf(str,"P%d",i);
    lab[20+i] = new PILabel(this,str,bsx/2,bsy,cpx,cpy);
    lab[20+i]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
    cpx+=bsx/2+spx;
    // Attention pas de message entre 1500 et 2000 (permet 500 parametres!)
    ckb[20+i] = new PICheckBox(this,"",1500+i,bsx/3,bsy,cpx,cpy);
    ckb[20+i]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
    cpx+=bsx/3+spx;
    for(int j=0;j<4;j++) {
      txt[20+4*i+j] = new PIText(this,"",bsx,bsy,cpx,cpy);
      txt[20+4*i+j]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
      cpx+=bsx+spx;
    }
  }
}

return;
}

/* --Methode-- */
PIAFitterWind::~PIAFitterWind()
{
int i;
for(i=0;i<nlab;i++) if(lab[i]) {delete lab[i]; lab[i]=NULL;}
for(i=0;i<ntxt;i++) if(txt[i]) {delete txt[i]; txt[i]=NULL;}
for(i=0;i<nbut;i++) if(but[i]) {delete but[i]; but[i]=NULL;}
for(i=0;i<nckb;i++) if(ckb[i]) {delete ckb[i]; ckb[i]=NULL;}
if(lab) {delete lab; lab=NULL; nlab=0;}
if(txt) {delete txt; txt=NULL; ntxt=0;}
if(but) {delete but; but=NULL; nbut=0;}
if(ckb) {delete ckb; ckb=NULL; nckb=0;}
}

/* --Methode-- */
void PIAFitterWind::Show()
{
//mDap->SetBlocked();
SetState();
PIWindow::Show();
return;
}

/* --Methode-- */
void PIAFitterWind::SetState(void)
// Ecriture et positionnement des ckb et txt
{
int npar = mFitter->mNPar;

// Les check-boxes
ckb[0]->SetState(mFitter->mOpt.okfun);
ckb[1]->SetState(mFitter->mOpt.okres);
ckb[2]->SetState((mFitter->mOpt.polcx>0)?true:false);
ckb[3]->SetState((mFitter->mOpt.polcy>0)?true:false);
if(npar>0)
  for(int i=0;i<npar;i++) ckb[20+i]->SetState((mFitter->mFix(i)>=1.)?true:false);

// Les champs textes
char str[128]; string dum;
sprintf(str,"%f",mFitter->mOpt.xc);    dum=str; txt[0]->SetText(dum);
sprintf(str,"%f",mFitter->mOpt.yc);    dum=str; txt[1]->SetText(dum);
sprintf(str,"%f",mFitter->mOpt.err_e); dum=str; txt[2]->SetText(dum);
sprintf(str,"%f",mFitter->mOpt.err_E); dum=str; txt[3]->SetText(dum);
sprintf(str,"%f",mFitter->mOpt.stc2);  dum=str; txt[4]->SetText(dum);
sprintf(str,"%d",mFitter->mOpt.nstep); dum=str; txt[5]->SetText(dum);
sprintf(str,"%d",mFitter->mOpt.lp);    dum=str; txt[6]->SetText(dum);
sprintf(str,"%d",mFitter->mOpt.lpg);   dum=str; txt[7]->SetText(dum);
sprintf(str,"%d",mFitter->mOpt.i1);    dum=str; txt[8]->SetText(dum);
sprintf(str,"%d",mFitter->mOpt.i2);    dum=str; txt[9]->SetText(dum);
sprintf(str,"%d",mFitter->mOpt.j1);    dum=str; txt[10]->SetText(dum);
sprintf(str,"%d",mFitter->mOpt.j2);    dum=str; txt[11]->SetText(dum);
if(npar>0) {
  for(int i=0;i<npar;i++) {
    sprintf(str,"%f",mFitter->mPar(i));  dum=str; txt[20+4*i+0]->SetText(dum);
    sprintf(str,"%f",mFitter->mStep(i)); dum=str; txt[20+4*i+1]->SetText(dum);
    sprintf(str,"%f",mFitter->mMin(i));  dum=str; txt[20+4*i+2]->SetText(dum);
    sprintf(str,"%f",mFitter->mMax(i));  dum=str; txt[20+4*i+3]->SetText(dum);
  }
}

return;
}

/* --Methode-- */
void PIAFitterWind::Process(PIMessage msg, PIMsgHandler* sender, void* data)
{
int lp = 1;
int npar = mFitter->mNPar;

// L'objet existe t-il encore?
NamedObjMgr omg;
if(omg.GetObj(mFitter->mNObj) == NULL) {
  cout<<"PIAFitterWind::Process Error , Pas d'objet de nom "<<mFitter->mNObj<<endl;
  mFitter->ResetDPointer(); return;
}

// On recupere les champs textes
string dum; char str[128];
int lenxc=0, lenyc=0;
dum=txt[0]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%lf",&(mFitter->mOpt.xc)); lenxc = strlen(str);
dum=txt[1]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%lf",&(mFitter->mOpt.yc)); lenyc = strlen(str);
dum=txt[2]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%lf",&(mFitter->mOpt.err_e));
dum=txt[3]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%lf",&(mFitter->mOpt.err_E));
dum=txt[4]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%lf",&(mFitter->mOpt.stc2));
dum=txt[5]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%d",&(mFitter->mOpt.nstep));
dum=txt[6]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%d",&(mFitter->mOpt.lp));
dum=txt[7]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%d",&(mFitter->mOpt.lpg));
dum=txt[8]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%d",&(mFitter->mOpt.i1));
dum=txt[9]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%d",&(mFitter->mOpt.i2));
dum=txt[10]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
sscanf(str,"%d",&(mFitter->mOpt.j1));
dum=txt[11]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
  sscanf(str,"%d",&(mFitter->mOpt.j2));
if(npar>0) {
  for(int i=0;i<npar;i++) {
    dum=txt[20+4*i+0]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
      sscanf(str,"%lf",&(mFitter->mPar(i)));
    dum=txt[20+4*i+1]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
      sscanf(str,"%lf",&(mFitter->mStep(i)));
    dum=txt[20+4*i+2]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
      sscanf(str,"%lf",&(mFitter->mMin(i)));
    dum=txt[20+4*i+3]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
      sscanf(str,"%lf",&(mFitter->mMax(i)));
  }
}

// Decodage des messages
msg = UserMsg(msg);
if(msg ==777) {
  if(lp) cout<<"Dismiss"<<endl;
  //mDap->SetReady();
  Hide();
  return;
}
if(msg ==666) {
  if(lp) cout<<"Refresh"<<endl;
  if(ReFillGData) mFitter->FillGData();
  ReFillGData = false;
}
if(msg ==111) {
  if(lp) cout<<"Update from last"<<endl;
  mFitter->ResetOptions();
  mFitter->mOpt = mFitter->mOptSave;
  mFitter->ReSetParam();
  mFitter->InitParFromLastFit();
  ReFillGData = true;
}
if(msg ==222) {
  if(lp) cout<<"Default options/par"<<endl;
  mFitter->ResetOptions();
  mFitter->ReSetParam();
  ReFillGData = true;
}
if(msg ==333) {
  if(lp) cout<<"Do the fit"<<endl;
  if(ReFillGData) mFitter->FillGData();
  ReFillGData = false;
  int rc = mFitter->DoFit();
  if(rc>=0) mFitter->FitFunRes();
}
if(msg==1001) {
  if(ckb[0]->GetState()) {
    if(lp) cout<<"Gen fitted function"<<endl;
    mFitter->mOpt.okfun = true;
  } else if(!ckb[0]->GetState()) {
    if(lp) cout<<"No Gen fitted function"<<endl;
    mFitter->mOpt.okfun = false;
  }
}
if(msg==1002) {
  if(ckb[1]->GetState()) {
    if(lp) cout<<"Gen fitted residus"<<endl;
    mFitter->mOpt.okres = true;
  } else if(!ckb[1]->GetState()) {
    if(lp) cout<<"No Gen fitted residus"<<endl;
    mFitter->mOpt.okres = false;
  }
}
if(msg==1003) {
  if(ckb[2]->GetState()) {
    if(lp) cout<<"Centrage X"<<endl;
    if(lenxc>0) mFitter->mOpt.polcx = 1; else mFitter->mOpt.polcx = 2;
  } else if(!ckb[2]->GetState()) {
    if(lp) cout<<"No Centrage X"<<endl;
    mFitter->mOpt.polcx = 0;
  }
  ReFillGData = true;
}
if(msg==1004) {
  if(ckb[3]->GetState()) {
    if(lp) cout<<"Centrage Y"<<endl;
    if(lenyc>0) mFitter->mOpt.polcy = 1; else mFitter->mOpt.polcy = 2;
  } else if(!ckb[3]->GetState()) {
    if(lp) cout<<"No Centrage Y"<<endl;
    mFitter->mOpt.polcy = 0;
  }
  ReFillGData = true;
}
if(msg>=1500 && msg<2000) {
  int ip = msg-1500;
  if(ckb[20+ip]->GetState()) {
    if(lp) cout<<"Fix Param "<<ip<<endl;
    mFitter->mFix(ip) = 1.001;
  } else if(!ckb[20+ip]->GetState()) {
    if(lp) cout<<"Not Fix Param "<<ip<<endl;
    mFitter->mFix(ip) = 0.;
  }
}

mFitter->CheckOptions();
SetState();
if(mFitter->mOpt.lp>1) mFitter->PrintOptions();

return;
}