Index: trunk/SophyaLib/NTools/dynccd.cc
===================================================================
--- trunk/SophyaLib/NTools/dynccd.cc	(revision 270)
+++ trunk/SophyaLib/NTools/dynccd.cc	(revision 1104)
@@ -46,12 +46,12 @@
 //--
 //++
-// DynCCD(int TypNoise=0, float MinADU=-9.e19, float MaxADU=9.e19, float Gain=1., float RONoise=0., float RefFond=0., float RefSFond=0.);
+// DynCCD(int_4TypNoise=0, r_8 MinADU=-9.e19, r_8 MaxADU=9.e19, r_8 Gain=1., r_8 RONoise=0., r_8 RefFond=0., r_8 RefSFond=0.);
 //	Creation d'un objet DynCCD ("typ" determine la methode de calcul du bruit)
 //	|Test verbatim 
 //
-// void Set(int TypNoise=0, float MinADU=-9.e19, float MaxADU=9.e19, float Gain=1., float RONoise=0., float RefFond=0., float RefSFond=0.);
+// void Set(int_4TypNoise=0, r_8 MinADU=-9.e19, r_8 MaxADU=9.e19, r_8 Gain=1., r_8 RONoise=0., r_8 RefFond=0., r_8 RefSFond=0.);
 //	Modification des parametres de la dynamique
 // void Print()
-// float Noise(float pixel) const
+// r_8 Noise(r_8 pixel) const
 //	Renvoie la valeur du bruit pour "pixel" en ADU.
 //--
@@ -62,6 +62,6 @@
 
 /* --Methode-- */
-DynCCD::DynCCD(int typ, float min, float max, float g,
-               float ron, float rf, float rfs)
+DynCCD::DynCCD(int_4 typ, r_8 min, r_8 max, r_8 g,
+               r_8 ron, r_8 rf, r_8 rfs)
 {
 if ( (typ >= kConstantNoise) && (typ <= kSqrtADUNoise) )  TypNoise = typ;
@@ -73,6 +73,6 @@
 
 /* --Methode-- */
-void DynCCD::Set(int typ, float min, float max, float g,
-               float ron, float rf, float rfs)
+void DynCCD::Set(int_4 typ, r_8 min, r_8 max, r_8 g,
+               r_8 ron, r_8 rf, r_8 rfs)
 {
 if ( (typ >= kConstantNoise) && (typ <= kSqrtADUNoise) )  TypNoise = typ;
@@ -93,5 +93,5 @@
 
 /* --Methode-- */
-float DynCCD::Noise(float pixel) const
+r_8 DynCCD::Noise(r_8 pixel) const
 
 /* Cette fonction calcule la valeur du bruit pour pixel     */
@@ -108,6 +108,6 @@
 
 {
-float h,s,ronsq;
-float fond;
+r_8 h,s,ronsq;
+r_8 fond;
 
 if ( (pixel > MaxADU) || (pixel < MinADU) )   return(0.);
@@ -122,5 +122,5 @@
   ronsq = RONoise/Gain;  ronsq *= ronsq; }
 
-h = (pixel>fond) ? (float)(pixel-fond) : 0.;
+h = (pixel>fond) ? (r_8)(pixel-fond) : 0.;
 s = ronsq+h/Gain;
 s = fsqrt(s);
@@ -161,5 +161,5 @@
 /* Nouvelle-Fonction */
 template <class T>
-Image<T> * NoiseImage(Image<T> const * pim, DynCCD const * dynccd)
+Image<T>  NoiseImage(Image<T> const & pim, DynCCD const & dynccd)
 
 /* Creation et Calcul d'une image de bruit a partir de l'image */
@@ -168,85 +168,19 @@
 
 {
-float h,s,ronsq;
-float fond, min,max;
-int i, npix;
-float minois, offnois;
-
-if (pim == NULL)  return(NULL);
-
-const T * pix = pim->ImagePtr();
-npix = pim->XSize()*pim->YSize();
-Image<T> * nois = new Image<T>(pim->XSize(), pim->YSize(), false);
-nois->SetOrg(pim->XOrg(), pim->YOrg());
-T * pno = nois->ImagePtr();
-
-min = dynccd->MinADU;   max = dynccd->MaxADU;
-
-
-switch (dynccd->TypNoise)
-  {
-  case kConstantNoise :
-    for(i=0; i<npix; i++)
-      {
-      if ( (*pix <= max) && (*pix >= min) )  *pno = 1;
-      else *pno = 0;
-      pix++;   pno++;
-      }
-    break;
-
-  case kSqrtADUNoise :
-    for(i=0; i<npix; i++)
-      {
-      if ( (*pix <= max) && (*pix >= min) )  *pno = 1;
-      else *pno = (T) fsqrt(fabsf((float)(*pix)));    
-      pix++;   pno++;
-      }
-    break;
-
-  case kPhotonNoise :
-  case kSigFondNoise :
-    if ( dynccd->TypNoise == kSigFondNoise)
-      { fond = dynccd->RefFond;
-      ronsq = dynccd->RefSFond * dynccd->RefSFond; }
-    else
-      { fond = 0;
-      ronsq = dynccd->RONoise/dynccd->Gain;  ronsq *= ronsq; }
-
-// Calcul de minois / offnois pour obtenir un bruit correct malgre 
-// les conversions (float) -> (entier)
-
-    switch(pim->PixelType())
-      {
-      case kuint_2:
-      case kint_2:
-      case kint_4:
-        minois = 1.001;
-        offnois = 0.5;
-        break;
-      case kr_4:
-      case kr_8:
-        minois = 1.e-9;
-        offnois = 0.;
-        break;
-      default:
-        minois = 1.e-9;
-        offnois = 0.;
-        break;
-      }
-
-    for(i=0; i<npix; i++)
-      {
-      if ( (*pix <= max) && (*pix >= min) ) 
-        {
-        h = (*pix>fond) ? (float)(*pix)-fond : 0.;
-        s = ronsq+h/dynccd->Gain;
-        s = fsqrt(s)+offnois;
-        *pno = (s > minois) ? (T)s : (T)minois;
-        } 
-      else *pno = 0;
-      pix++;   pno++;
-      }
-    break;
-  }
+r_8 h,s,ronsq;
+r_8 fond, min,max;
+int_4 k, npix;
+r_8 minois, offnois;
+
+npix = pim.XSize()*pim.YSize();
+Image<T> nois(pim.XSize(), pim.YSize());
+nois.SetOrg(pim.XOrg(), pim.YOrg());
+
+min = dynccd.MinADU;   max = dynccd.MaxADU;
+for(k=0; k<npix; k++)      {
+  if ( (pim[k] <= max) && (pim[k] >= min) )  nois[k] = (T)1;
+  else nois[k] = 0;
+}
+
 
 return(nois);
@@ -258,89 +192,12 @@
 void ImgAddNoise(Image<T>& img, DynCCD const& dyn)
 {
-	T* p = img.ImagePtr();
-	int nPix = img.XSize() * img.YSize();
+  int_4 nPix = img.XSize() * img.YSize();
 	
-	for (int i=0; i<nPix; i++, p++)
-		*p += (T) (dyn.Noise(*p)*NorRand());
-}
-
-
-
-/* Nouvelle-Fonction */
-RzImage * NoiseImage(RzImage const * pim, DynCCD const * dynccd)
-
-/* Creation et Calcul d'une image de bruit a partir de l'image */
-/* pim et de dynccd. Voir la methode DynCCD::Noise() pour la   */
-/* description du calcul                                       */
-{
-RzImage * nois = NULL;
-
-switch (pim->PixelType()) 
-  {
-  case kuint_2: 
-    {
-    ImageU2 pix((RzImage&)(*pim));
-    nois = NoiseImage(&pix, dynccd);
-    break;
-    }
-  case kint_2:
-    {
-    ImageI2 pix((RzImage&)(*pim));
-    nois = NoiseImage(&pix, dynccd);
-    break;
-    }
-  case kint_4:
-    {
-    ImageI4 pix((RzImage&)(*pim));
-    nois = NoiseImage(&pix, dynccd);
-    break;
-    }
-  case kr_4:
-    {
-    ImageR4 pix((RzImage&)(*pim));
-    nois = NoiseImage(&pix, dynccd);
-    break;
-    }  
-  case kuint_4:
-  case kr_8:
-    cerr << "NoiseImage(RzImage, ...) Unsupported image type (kuint_4/kr_8) " 
-         << int(pim->PixelType()) << "\n" ; 
-    break;
-  default:
-    cerr << "NoiseImage(RzImage, ...) Unknown image type !! " << int(pim->PixelType()) << "\n" ;
-    break;
-  }   
-
-return(nois);
-}
-
-
-// ******** INSTANCES
-
-#if defined(__xlC) || defined(__aCC__)
-void instancetempdynccd(int n)
-{
-/* Cette fonction sert uniquement a forcer le compilo a instancier les
-  classes/fonctions template   */
-
-ImageU2  iu2(n,n), *piu2;
-ImageI2  ii2(n,n), *pii2;
-ImageI4  ii4(n,n), *pii4;
-ImageR4  ir4(n,n), *pir4;
-DynCCD dyn(1,0.,65000., 4., 20.);
-
-piu2 = NoiseImage(&iu2, &dyn);
-pii2 = NoiseImage(&ii2, &dyn);
-pii4 = NoiseImage(&ii4, &dyn);
-pir4 = NoiseImage(&ir4, &dyn);
-
-ImgAddNoise(*piu2, dyn);
-ImgAddNoise(*pii2, dyn);
-ImgAddNoise(*pii4, dyn);
-ImgAddNoise(*pir4, dyn);
-
-return;
-}
-#endif
+  for (int_4 i=0; i<nPix; i++)
+    img[i] += (T) (dyn.Noise(img[i])*NorRand());
+}
+
+
+
 
 
@@ -348,10 +205,8 @@
 
 #pragma define_template NoiseImage<uint_2>
-#pragma define_template NoiseImage<int_2>
 #pragma define_template NoiseImage<int_4>
 #pragma define_template NoiseImage<r_4>
 
 #pragma define_template ImgAddNoise<uint_2>
-#pragma define_template ImgAddNoise<int_2>
 #pragma define_template ImgAddNoise<int_4>
 #pragma define_template ImgAddNoise<r_4>
@@ -360,12 +215,10 @@
 
 
-#if ( defined(ANSI_TEMPLATES) && !defined(__aCC__) )
+#if defined(ANSI_TEMPLATES) 
 template Image<uint_2> * NoiseImage<uint_2>(Image<uint_2> const * , DynCCD const *);
-template Image< int_2> * NoiseImage< int_2>(Image< int_2> const * , DynCCD const *);
 template Image< int_4> * NoiseImage< int_4>(Image< int_4> const * , DynCCD const *);
 template Image<   r_4> * NoiseImage<   r_4>(Image<   r_4> const * , DynCCD const *);
 
 template void ImgAddNoise<uint_2>(Image<uint_2>&, DynCCD const&);
-template void ImgAddNoise< int_2>(Image< int_2>&, DynCCD const&);
 template void ImgAddNoise< int_4>(Image< int_4>&, DynCCD const&);
 template void ImgAddNoise<   r_4>(Image<   r_4>&, DynCCD const&);
@@ -375,10 +228,8 @@
 #if defined(__GNU_TEMPLATES__)
 template Image<uint_2> * NoiseImage(Image<uint_2> const *, DynCCD const *);
-template Image< int_2> * NoiseImage(Image< int_2> const *, DynCCD const *);
 template Image< int_4> * NoiseImage(Image< int_4> const *, DynCCD const *);
 template Image<   r_4> * NoiseImage(Image<   r_4> const *, DynCCD const *);
 
 template void ImgAddNoise(Image<uint_2>&, DynCCD const&);
-template void ImgAddNoise(Image< int_2>&, DynCCD const&);
 template void ImgAddNoise(Image< int_4>&, DynCCD const&);
 template void ImgAddNoise(Image<   r_4>&, DynCCD const&);
