Changeset 1104 in Sophya


Ignore:
Timestamp:
Jul 27, 2000, 7:30:57 PM (25 years ago)
Author:
ansari
Message:

Heritage classe Image<T> de TMatrix<T> Reza+CMV 27/7/2000

Location:
trunk/SophyaLib/NTools
Files:
2 deleted
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/NTools/NTools.o.list

    r896 r1104  
    1717generaldata.o
    1818generalfit.o
    19 imageop.o
    2019integ.o
    2120matxop.o
    … …  
    2928poly.o
    3029rk4cdifeq.o
    31 rzimage.o
    3230simplesort.o
    3331tabmath.o

  • trunk/SophyaLib/NTools/cimage.cc

    r1092 r1104  
    1 //  Classes image typee     
    2 //                    E.Aubourg , E. Lesquoy  01-03/95   
    3 //                    Modifs R. Ansari   04/95
    4 
     1//  Classes image heritant de TMatrix<T>
     2//                       R.Ansari, C.Magneville 07/2000   
    53// LAL (Orsay) / IN2P3-CNRS  DAPNIA/SPP (Saclay) / CEA
    64
    7 // $Id: cimage.cc,v 1.6 2000-07-26 13:15:29 ansari Exp $       
    8 
    9 
    105#include "machdefs.h"
    11 #include <string.h>
    126#include <stdio.h>
    13 
    14 #include "perrors.h"
     7#include <stdlib.h>
     8#include "pexceptions.h"
    159#include "cimage.h"
    16 #include "fct1dfit.h"
    17 #include "histos.h"
    18 #include "nbconst.h"
    19 #include "utils.h"
    20 
    21 /* ..............   Classe  Image<T>    ...............   */
    22 
    23 //++
    24 // Class        Image<T>
    25 // Lib          Images++
    26 // include      cimage.h
    27 //
    28 //
    29 //      Classe descendant (heritier) de la classe *RzImage*, permettant
    30 //      l'instantiation d'objets image avec un typage fort (entier, reel, ...)
    31 //
    32 //      Des objets de type "Image<uint_1>, Image<uint_2>, Image<int_2>, Image<int_4>"
    33 //      (entier) et "Image<r_4>" (flottant) peuvent etre crees.
    34 //      Des typedef (*ImageU1*, *ImageU2*, *ImageI2*, *ImageI4*, *ImageR4*)
    35 //      facilite l'utilisation de ces classes.
    36 //--
    37 //++
    38 // Links        Parents
    39 // RzImage
    40 //--
    41 //++
    42 // Links        Descendants
    43 // FitsImage<T>
    44 //--
    45 //++
    46 // Links        Voir aussi
    47 // DVList
    48 //--
    49 
    50 //++
    51 // Titre        Constructeurs
    52 //--
    53 
    54 //++
    55 // Image<T>(int sizx, sizy, int zero)
    56 //      Creation d'une image de type "T", de taille "sizx*sizy" pixels.
    57 //      Si "zero" non nul, tous les pixels de l'image sont mis a zero.
    58 // Image<T>(char* flnm)
    59 //      Cree une image a partir du fichier "flnm". Celui-ci doit etre
    60 //      au format "PPF" et cree par la methode "Save() ou "Write()".
    61 //--
    6210
    6311template <class T>
    64 Image<T>::Image(int sizx, int sizy, int zero)
    65 : RzImage(DataType((T)0), sizx, sizy), imagePtr( (T*) voidP )
     12Image<T>::Image()
     13// Constructeur par defaut.
     14  : TMatrix<T>()
    6615{
    67   if (zero) Zero();
    68   END_CONSTRUCTOR
    69 }
    70 
    71 /* --Methode-- */
    72 template <class T>
    73 Image<T>::Image()
    74 : RzImage(DataType((T)0)), imagePtr(0)
    75 {
    76   END_CONSTRUCTOR
    77 }
    78 
    79 
    80 /* --Methode-- */
    81 template <class T>
    82 void Image<T>::Allocate(int sizx, int sizy, int zero, ImgVectP* pvpsh)
    83 {
    84   RzImage::Allocate(DataType((T)0), sizx, sizy, pvpsh);
    85   imagePtr = (T*) voidP;
    86   if (!imagePtr) THROW(allocationErr);
    87   if (zero) Zero();
     16  SetOrg();
     17  SetPixelSize();
    8818}
    8919
    9020template <class T>
    91 void Image<T>::SetPixels(int szx, int szy, T* pim)
     21Image<T>::Image(uint_4 sizx, uint_4 sizy, r_8 szpx, r_8 szpy, r_8 orgx, r_8 orgy)
     22// Constructeur par defaut.
     23  : TMatrix<T>(sizy, sizx)
    9224{
    93   RzImage::SetPixels(DataType((T)0), szx, szy, pim);
    94   imagePtr = pim;
     25  SetOrg(orgx, orgy);
     26  SetPixelSize(szpx, szpy);
    9527}
    9628
    97 /* --Methode-- */
     29template <class T>
     30Image<T>::Image(const Image<T>& a)
     31  : TMatrix<T>(a)
     32{
     33  SetOrg(a.XOrg(), a.YOrg() );
     34  SetPixelSize(a.XPixSize(), a.YPixSize());
     35}
     36
     37template <class T>
     38Image<T>::Image(const Image<T>& a, bool share)
     39  : TMatrix<T>(a, share)
     40{
     41  SetOrg(a.XOrg(), a.YOrg() );
     42  SetPixelSize(a.XPixSize(), a.YPixSize());
     43}
    9844template <class T>
    9945Image<T>::~Image()
    100 {}
    101 
    102 
    103 //++
    104 // Image<T>(const Image<T>& src, int sharePixels)
    105 //      Constructeur par copie. Fabrique une image identique a l'image "src".
    106 //      Si "sharePixels" est non nul, le tableau des pixels est commun
    107 //      aux deux images ("src" et celle creee)
    108 // Image<T>(const Image<T>& src, int orgx, int orgy, int sizx, int sizy)
    109 //      Construit une image de type "T", a partir des pixels de l'image
    110 //      "src" (du meme type), de taille "sizx*sizy" et de l'origine
    111 //      "orgx, orgy" dans "src". Si "orgx" et/ou "orgy" sont negatifs,
    112 //      la taille de la nouvelle image est automatiquement calculee
    113 //      pour contenir toute l'image source a partir de l'origine specifiee.
    114 //      Genere l'exception "sizeMismatchErr" en cas d'incompatibilite
    115 //      taille/origine.
    116 //--
    117 
    118 /* --Methode-- */
    119 template <class T>
    120 Image<T>::Image(const Image<T>& src, int sharePixels)
    121 : RzImage(src, sharePixels)
    12246{
    123   imagePtr = (T*) voidP;
    124   if (!imagePtr) THROW(allocationErr);
    125   END_CONSTRUCTOR
    12647}
    12748
    128 /* --Methode-- */
    129 template <class T>
    130 Image<T>::Image(const Image<T>& src, int orgx, int orgy, int sizx, int sizy)
    131 :RzImage()
    132 {
    133   // A optimiser...
    134   if (sizx < 0) sizx = src.XSize()-orgx;
    135   if (sizy < 0) sizy = src.YSize()-orgy;
    136   if (orgx+sizx > src.XSize() || orgy+sizy > src.YSize())
    137     THROW(sizeMismatchErr);
    138 
    139   Allocate(sizx, sizy);
    140   for (int i=0; i<sizx; i++)
    141     for (int j=0; j<sizy; j++)
    142       (*this)(i,j) = src(i+orgx, j+orgy);
    143 
    144   SetOrg(src.XOrg()+orgx, src.YOrg()+orgy);
    145   SetPxSize(src.XPxSize(), src.YPxSize());   
    146   END_CONSTRUCTOR
    147 }
    148 
    149 //++
    150 // LaTeX        Pour contrer un mauvais espacement des paragraphes de LaTeX
    151 // \newpage
    152 //--
    153 //++
    154 // Image<T>()
    155 //      Creation d'une image de type "T" sans allocation du tableau des pixels.
    156 //      Le tableau des pixels devra etre ensuite alloue par la methode "Allocate()"
    157 //--
    158 
    159 //++
    160 // Image<T>(const RzImage& rzimg)
    161 //      Permet de construire une image typee a partir d'une RzImage ("rzimg")
    162 //      Le tableau des pixels est commun aux deux images.
    163 //      Les pixels de l'image "rzimg" doivent etre du type "T", sinon
    164 //      l'exception "typeMismatchErr" est generee.
    165 //--
    166 /* --Methode-- */
    167 template <class T>
    168 Image<T>::Image(const RzImage& rzimg)
    169 :RzImage(rzimg,1)
    170 {
    171 
    172   if (rzimg.PixelType() != DataType((T)0))
    173     THROW(typeMismatchErr);
    174   imagePtr = (T*) voidP;
    175   if (!imagePtr) THROW(allocationErr);
    176 
    177   END_CONSTRUCTOR
    178 }
    179 
    180 //++
    181 // void Allocate(int sizx, int sizy, int zero=1, ImgVectP* pvpsh=NULL)
    182 //      Alloue le tableau des pixels.
    183 //--
    184 //++
    185 // ~Image<T>
    186 //      Destructeur. supprime le tableau des pixels en memoire si celui-ci
    187 //      n'est pas utilise par d'autres objets image.
    188 //--
    189 
    190 /* --Methode-- */
    191 template <class T>
    192 Image<T>::Image(char *flnm)
    193 :RzImage(flnm)
    194 {
    195   imagePtr = (T*) voidP;
    196   if (!imagePtr) THROW(allocationErr);
    197 
    198   END_CONSTRUCTOR
    199 }
    200 
    201 
    202 /* --Methode-- */
    203 template <class T>
    204 void  Image<T>::ReadSelf(PInPersist& s)
    205 {
    206   RzImage::ReadSelf(s);
    207   imagePtr = (T*) voidP;
    208 }
    209 
    210 //++
    211 // Titre        Operateurs
    212 //      Un grand nombre des operations pouvant etre effectuees sur un
    213 //      tableau de nombre ont ete defini pour les objets "Image<T>"
    214 //      Dans les operations faisant intervenir deux images, l'exception
    215 //      "sizeMismatchErr" est generee si les tailles (en X ou en Y) des
    216 //      deux images ne sont pas identiques.
    217 //--
    218 
    219 //++
    220 // Image<T>& operator= (const Image<T>& rhs)
    221 //      Copie le contenu (valeurs des pixels) de l'image "rhs".
    222 //      Si l'image destination (membre gauche de =) n'a pas son
    223 //      tableau de pixels alloue, celui-ci est cree a une taille
    224 //      identique a celle de "rhs"
    225 // Image<T>& operator= (T val)
    226 //      Met tous les pixels de l'image a la valeur "val"
    227 //--
    228 
    229 /* --Methode-- */
    230 template <class T>
    231 Image<T>& Image<T>::operator = (const Image<T>& src)
    232 {
    233   if (imagePtr) {
    234     if (siz_x != src.siz_x || siz_y != src.siz_y)
    235       THROW(sizeMismatchErr);
    236   } else
    237     Allocate(src.siz_x, src.siz_y);
    238  
    239   (RzImage)(*this) = (RzImage)src;
    240   return *this;
    241 }
    242 
    243 /* --Methode-- */
    244 template <class T>
    245 Image<T>& Image<T>::operator = (T a)
    246 {
    247   T* pDst = imagePtr;
    248   int nPix = siz_x * siz_y;
    249 
    250   for (int i=0; i<nPix; i++, pDst++)
    251     *pDst = a;
    252 
    253   return *this;
    254 }
    255 
    256 /* --Methode-- */
    257 template <class T>
    258 void Image<T>::Zero()
    259 {
    260   memset(imagePtr,0,siz_x * siz_y * sizeof(T));
    261 }
    262 
    263 /* --Methode-- */
    264 #if 0 // a la mort de RzImage
    265 template <class T>
    266 void Image<T>::Clear()
    267 {
    268   if (imagePtr) {
    269     delete[] imagePtr;
    270     imagePtr = 0;
    271     siz_x = 0;
    272     siz_y = 0;
    273   }
    274 }
     49///////////////////////////////////////////////////////////////
     50#ifdef __CXX_PRAGMA_TEMPLATES__
     51#pragma define_template Image<uint_2>
     52#pragma define_template Image<int_4>
     53#pragma define_template Image<int_8>
     54#pragma define_template Image<r_4>
     55#pragma define_template Image<r_8>
     56//#pragma define_template Image< complex<r_4> >
     57//#pragma define_template Image< complex<r_8> >
    27558#endif
    27659
    277 /* --Methode-- */
    278 template <class T>
    279 Image<T>& Image<T>::operator+= (Image<T> const& a)
    280 {
    281   if (siz_x != a.siz_x || siz_y != a.siz_y)
    282     THROW(sizeMismatchErr);
    283   T* pSrc = a.imagePtr;
    284   T* pDst = imagePtr;
    285   int nPix = siz_x * siz_y;
    286 
    287   for (int i=0; i<nPix; i++, pSrc++, pDst++)
    288     *pDst = PutInRange((double)*pSrc + (double)*pDst, *pDst);
    289 
    290   return *this;
    291 }
    292 
    293 
    294 /* --Methode-- */
    295 template <class T>
    296 Image<T>& Image<T>::operator-= (Image<T> const& a)
    297 {
    298   if (siz_x != a.siz_x || siz_y != a.siz_y)
    299     THROW(sizeMismatchErr);
    300   T* pSrc = a.imagePtr;
    301   T* pDst = imagePtr;
    302   int nPix = siz_x * siz_y;
    303 
    304   for (int i=0; i<nPix; i++, pSrc++, pDst++)
    305     *pDst = PutInRange((double)*pDst - (double)*pSrc, *pDst);
    306 
    307   return *this;
    308 }
    309 
    310 /* --Methode-- */
    311 template <class T>
    312 Image<T>& Image<T>::operator*= (Image<T> const& a)
    313 {
    314   if (siz_x != a.siz_x || siz_y != a.siz_y)
    315     THROW(sizeMismatchErr);
    316   T* pSrc = a.imagePtr;
    317   T* pDst = imagePtr;
    318   int nPix = siz_x * siz_y;
    319 
    320   for (int i=0; i<nPix; i++, pSrc++, pDst++)
    321     *pDst = PutInRange((double)*pDst * (double)*pSrc, *pDst);
    322 
    323   return *this;
    324 }
    325 
    326 /* --Methode-- */
    327 template <class T>
    328 Image<T>& Image<T>::operator/= (Image<T> const& a)
    329 {
    330   if (siz_x != a.siz_x || siz_y != a.siz_y)
    331     THROW(sizeMismatchErr);
    332   T* pSrc = a.imagePtr;
    333   T* pDst = imagePtr;
    334   int nPix = siz_x * siz_y;
    335 
    336   for (int i=0; i<nPix; i++, pSrc++, pDst++)
    337     if (*pSrc)
    338       *pDst = PutInRange((double)*pDst / (double)*pSrc, *pDst);
    339     else *pDst = (T) MaxRange(*pDst);
    340 
    341   return *this;
    342 }
    343 
    344 //++
    345 //  Image<T>& operator += -= *= /= (Image<T> const& rhs)
    346 //      Ajoute (+=), soustrait(-=), multiplie(*=), divise(/=) les valeurs des pixels
    347 //      de l'image a gauche de l'operateur par les pixels correspondants
    348 //      de l'image a droite de l'operateur ("rhs")
    349 //  Image<T>& operator += -= *= /= (double crhs)
    350 //      Ajoute (+=), soustrait(-=), multiplie(*=), divise(/=) les valeurs des pixels
    351 //      de l'image a gauche de l'operateur par la constante "crhs"
    352 //--
    353 
    354 
    355 /* --Methode-- */
    356 template <class T>
    357 Image<T>& Image<T>::operator+= (double a)
    358 {
    359   T* pDst = imagePtr;
    360   int nPix = siz_x * siz_y;
    361 
    362   for (int i=0; i<nPix; i++, pDst++)
    363     *pDst = PutInRange((double)*pDst + a, *pDst);
    364 
    365   return *this;
    366 }
    367 
    368 /* --Methode-- */
    369 template <class T>
    370 Image<T>& Image<T>::operator-= (double a)
    371 {
    372   T* pDst = imagePtr;
    373   int nPix = siz_x * siz_y;
    374 
    375   for (int i=0; i<nPix; i++, pDst++)
    376     *pDst = PutInRange((double)*pDst - a, *pDst);
    377 
    378   return *this;
    379 }
    380 
    381 /* --Methode-- */
    382 template <class T>
    383 Image<T>& Image<T>::operator*= (double a)
    384 {
    385   T* pDst = imagePtr;
    386   int nPix = siz_x * siz_y;
    387 
    388   for (int i=0; i<nPix; i++, pDst++)
    389     *pDst = PutInRange((double)*pDst * a, *pDst);
    390 
    391   return *this;
    392 }
    393 
    394 
    395 /* --Methode-- */
    396 template <class T>
    397 Image<T>& Image<T>::operator/= (double a)
    398 {
    399   T* pDst = imagePtr;
    400   int nPix = siz_x * siz_y;
    401  
    402   for (int i=0; i<nPix; i++, pDst++)
    403     *pDst = PutInRange((double)*pDst / a, *pDst);
    404  
    405   return *this;
    406 }
    407 
    408 
    409 
    410 //++
    411 // Image<T> operator + - * / (Image<T> const& a, Image<T> const& b)
    412 //      Ajoute, soustrait, multiplie, divise les pixels des deux
    413 //      images "a" et "b" et l'affecte a gauche de l'operateur egal.
    414 // operator + - * / (Image<T> const& a, double cb)
    415 //      Ajoute, soustrait, multiplie, divise le contenu de l'image "a"
    416 //      par la constante "cb" et l'affecte a l'image a gauche de l'operateur = .
    417 //
    418 //      Il est preferable d'utiliser dans la mesure du possible, les
    419 //      operateurs "+=", "-=", "*=", "/=" afin d'eviter des copies
    420 //      inutiles.
    421 //
    422 //      *Exemples:*
    423 //| // Creation des images
    424 //| ImageR4  ai(200,300), bi, ci;
    425 //| // Tous les pixels a 238.5
    426 //| ai = 238.5;
    427 //| // Image bi meme taille, meme valeurs de pixels que ai
    428 //| bi = ai;   
    429 //| // On soustrait 13.2 a tous les pixels de ai
    430 //| ai -= 13.2;
    431 //| // Je divise bi par ai (pixel par pixel) qu'on affecte a bi
    432 //| bi /= ai;
    433 //| // On somme ai et bi (pixel par pixel) qu'on affecte a ci
    434 //| ci = ai + bi;
    435 //--
    436 
    437 
    438 /* --Methode-- */
    439 template <class T>
    440 Image<T> Image<T>::WhereNonZero()
    441 {
    442   Image<T> c(*this);
    443   for (int i=0; i<XSize(); i++)
    444     for (int j=0; j<YSize(); j++)
    445       c(i,j) = c(i,j) ? 1 : 0;
    446   return c;
    447 }
    448 
    449 //++
    450 // void PrintImage(ostream& os) const
    451 //      Envoie le contenu de l'image (formatte, texte) sur le
    452 //      flot (stream) de sortie "os".
    453 //      Attention: Ca peut faire beaucoup de ligne !
    454 // void PrintImage() const
    455 //      Appel a PrintImage(cout) - Sortie sur cout .
    456 //--
    457 
    458 
    459 /* --Methode-- */
    460 template <class T>
    461 void Image<T>::PrintImage(ostream& os) const
    462 //  Impression de tout le contenu de l'image
    463 {
    464 #define PrPvLn 10
    465 #define PrSize 6
    466 int i,j,k,ido,ideb,ifin;
    467 int siz_x,siz_y;
    468 
    469 siz_x= XSize();
    470 siz_y= YSize();
    471 
    472 os << " Image::PrintImage: type pixel " ;
    473 os << DataName(dataType) ; 
    474 os << ", NbPix=("<<siz_x<<","<<siz_y<<") \n"; 
    475 
    476 
    477 /* segmentation avec des lignes de PrPvLn valeurs */
    478 
    479 ido = (siz_x-1) / PrPvLn + 1;
    480 
    481 char buff[256];
    482 
    483 for(k=0;k<ido;k++)
    484   {
    485   ideb = k*PrPvLn;
    486   ifin = ideb + PrPvLn;
    487   if ( ifin >siz_x ) ifin =  siz_x ;
    488   sprintf(buff, "    ---- colonnes   %d   a   %d  ----\n",ideb,ifin-1);
    489   os << buff ;
    490   for(j=0; j<siz_y; j++)
    491     {
    492     sprintf(buff, "%3d - ",j);
    493     os << buff;
    494     for (i=ideb; i<ifin; i++)
    495       {
    496         os.width(PrSize);
    497 // les uint_1 sont traites comme characteres par les ostream ...
    498         if (PixelType() == kuint_1) os << ((int)((*this)(i,j))) << " ";
    499         else os << (*this)(i,j) << " ";
    500       }
    501      os << endl;
    502      }
    503    }
    504 
    505  return;
    506 }
    507 
    508 
    509 //++
    510 // Titre        Acces aux pixels
    511 //--
    512 //++
    513 // T&  operator() (int x, int y)
    514 //      Acces au pixel "(x,y)" de l'image (lecture/ecriture)
    515 // T&  operator[] (int i)
    516 //      Acces au pixel numero "i" de l'image (lecture/ecriture)
    517 //
    518 //| ImageU2 img(100,100);
    519 //| int i,j,k;
    520 //| // Remplissage de la moitie de l'image
    521 //| for(k=0; k<100*50; k++)  img[k] = k%500;
    522 //| img(50, 10); // Valeur du pixel (50, 10)
    523 //
    524 // T*  ImagePtr()
    525 //      Renvoie un pointeur du type "T (uint_2, r_4, ...)" sur le
    526 //      tableau des pixels de l'image. A n'utiliser que si un reelle
    527 //      optimisation de l'acces aux pixels peut etre effectuee.
    528 //--
    529 
    530 
    531 
    532 //++
    533 // Titre        Traitements simples
    534 //--
    535 //++
    536 // int  CheckDyn(double min=-9.e19, double max=9.e19)
    537 //      Cette methode retourne le nombre de pixels hors dynamique "( <min ou >max )"
    538 //      Met a jour les donnees membres "min/maxPix nbNul/Sat".
    539 //      Calcule aussi la moyenne et le sigma des pixels -> "moyPix, sigPix"
    540 //      Implementation plus efficace de la methode "RzImage::CheckDyn()"
    541 //--
    542 
    543 /* --Methode-- */
    544 template <class T>
    545 int Image<T>::CheckDyn(double min, double max)
    546 
    547 /*  Cette methode retourne le nombre de pixels hors dynamique    */
    548 /* ds le pave ( <min ou >max )                                   */
    549 /* Met a jour la structure image Min/MaxPix nbNul/Sat            */
    550 /* Calcule aussi la moyenne et le sigma des pixels, met a jour   */
    551 /* moypix et sigpix dans la structure                            */
    552 
    553 {
    554 T pixv=0;
    555 double dv;
    556 
    557 T minadu = PutInRange(min, pixv);
    558 T maxadu = PutInRange(max, pixv);
    559 T minpix = PutInRange(maxadu+1, pixv);
    560 T maxpix = PutInRange(minadu-1, pixv);
    561 
    562 double m = 0.;
    563 double s = 0.;
    564 int n9 = 0;
    565 int n0 = 0;
    566 int n = XSize()*YSize();
    567 for(int i=0; i<n; i++)
    568   {
    569   pixv = imagePtr[i];
    570   if (pixv <= maxadu && pixv >= minadu)
    571     { 
    572     if (pixv < minpix)  minpix = pixv;
    573     else if (pixv > maxpix)  maxpix = pixv; 
    574     dv = (double)pixv;
    575     m += dv;  s += (dv*dv);
    576     }
    577   else
    578     { 
    579     if (pixv > maxadu)  n9++;
    580     if (pixv < minadu)  n0++;
    581     }
    582   }
    583 
    584 nbNul = n0;
    585 nbSat = n9;
    586 minPix = minpix;
    587 maxPix = maxpix;
    588 
    589 n -= (n0+n9);
    590 if (n > 0)
    591   { dv = (double)n;  m /= dv;  s = s/dv - m*m;
    592   if (s>0.)  s = sqrt(s);  else s = 0.;
    593   moyPix = m;  sigPix = s; }
    594 else { moyPix = 0.;  sigPix = -1.; }
    595 
    596 return(n0+n9);
    597 }
    598 
    599 //++
    600 // SeuilBas(double seuil, double val)
    601 //      Met les pixels en dessous du "seuil" (< seuil) a la valeur "val".
    602 // SeuilBas(double seuil)
    603 //      Met les pixels en dessous du "seuil" (< seuil) a zero
    604 // SeuilHaut(double seuil, double val)
    605 //      Met les pixels au dessus du "seuil" (> seuil) a la valeur "val".
    606 // SeuilHaut(double seuil)
    607 //      Met les pixels au dessus du "seuil" (> seuil) a zero
    608 //--
    609 
    610 /* --Methode-- */
    611 template <class T>
    612 void Image<T>::SeuilBas(double seuil, double val)
    613 
    614 /*   Met a une valeur definie tous les pixels    */
    615 /*   en dessous du seuil                         */
    616 
    617 {
    618   if (!ImagePtr())   THROW(nullPtrErr);
    619   T* PtPix=ImagePtr();
    620   int nPix=XSize()*YSize();
    621   for(int i=0 ; i<nPix;i++,PtPix++) {if(*PtPix < (T) seuil) *PtPix = (T) val;};
    622 }
    623 
    624 /* --Methode-- */
    625 template <class T>
    626 void Image<T>::SeuilHaut(double seuil, double val)
    627 
    628 /*   Met a une valeur definie tous les pixels    */
    629 /*   en dessus du seuil                         */
    630 
    631 {
    632   if (!ImagePtr())   THROW(nullPtrErr);
    633   T* PtPix=ImagePtr();
    634   int nPix=XSize()*YSize();
    635   for(int i=0 ; i<nPix;i++,PtPix++) {if(*PtPix > (T) seuil) *PtPix = (T) val;};
    636 }
    637 
    638 /* --Methode-- */
    639 template <class T>
    640 void Image<T>::SeuilBas(double seuil)
    641 {
    642   SeuilBas(seuil,seuil);
    643 }
    644 
    645 /* --Methode-- */
    646 template <class T>
    647 void Image<T>::SeuilHaut(double seuil)
    648 {
    649   SeuilHaut(seuil,seuil);
    650 }
    651 
    652 /* --Methode-- (cmv 23/09/96) */
    653 template <class T>
    654 //++
    655 void Image<T>::HBinInt(int& nbin,float& xmin,float& xmax)
    656 //
    657 //      Valeur pour avoir un bin entier quand on fait un
    658 //      histogramme 1D des pixels (pour les images entieres).
    659 //--
    660 {
    661 if( PixelType()<kuint_2 || PixelType()>kint_4 ) return;
    662 double binw = (xmax-xmin)/nbin;
    663 binw = (double) ( (int)(binw+0.5) );
    664 if( binw <= 0. ) binw = 1.;
    665 xmin = (float) ( (int) xmin );
    666 xmax = (float) ( (int) (xmax + binw) );
    667 nbin = (int)( (xmax-xmin)/binw + 0.1 );
    668 }
    669 
    670 /* --Methode-- (cmv 23/09/96) */
    671 template <class T>
    672 //++
    673 int Image<T>::EstimeFdSg(float& xbmax,float& sgbmax
    674              ,float nbsig,float frac,float lowbad,float highbad,int deb)
    675 //
    676 //      Pour donner une estimation  du fond de ciel et du sigma ciel.
    677 //      Il est conseille de faire ceci sur une image partielle.
    678 //      Une premiere estimation du fond et du sigma est faite en nettoyant
    679 //      iterativement (cf MoySigmaIter).
    680 //      Puis un histogramme est rempli et rebinne jusqu'a ce que son maximum
    681 //      soit statistiquement significatif. Le fond et le sigma sont ensuite
    682 //      calcules par les methodes `FitMax' et `EstimeWidthS' de la classe Histo.
    683 //| xbmax = position du maximum
    684 //| sgbmax = valeur du sigma
    685 //| nbsig = dimensionnement de l'histo de depart en nombre
    686 //|         de sigma autour de la valeur maximum
    687 //| frac = valeur maximum principale / maximum secondaire a partir
    688 //|        de laquelle on considere qu'elle a une signification
    689 //|        statistique.
    690 //| lowbad,highbad = dynamique utile de l'image traitee
    691 //| deb = niveau de debug
    692 //| Return : 0 = OK, -1 = echec MoySigmaIter, -2 = echec FitMax,
    693 //|                  -3 = echec FindWidth
    694 //--
    695 {
    696 T pixv=0;
    697 T minadu = PutInRange((double) lowbad , pixv);
    698 T maxadu = PutInRange((double) highbad, pixv);
    699 bool testl = (lowbad<highbad) ? true : false;
    700 lowbad  = (float) minadu;  highbad = (float) maxadu;
    701 
    702 if(deb<0) deb=0;
    703 int envd = 0;
    704 GetIntEnv("PDEBUG_FOND", envd);
    705 if (deb < envd) deb = envd;
    706 
    707 // moyenne et sigma bruts (iteratifs)
    708 int rc;
    709 float fd,sg;
    710 rc = MoySigmaIter(fd,sg,lowbad,highbad,1,5,0.1,3.5,deb-1);
    711 if(deb>0) cout<<"EstimeFdSg: MoySigmaIter rc="<<rc<<" fd="<<fd<<" sg="<<sg<<endl;
    712 if(rc<=0) return -1;
    713 
    714 // remplissage histogramme avec beaucoup de bins
    715 int nbin;
    716 float xmin,xmax;
    717 xmin = fd - nbsig*sg; if(testl && xmin<lowbad ) xmin = lowbad;
    718 xmax = fd + nbsig*sg; if(testl && xmax>highbad) xmax = highbad;
    719 nbin = XSize()*YSize()/20; if(nbin>2000) nbin=2000;
    720 Histo H(xmin,xmax,nbin);
    721 for(int i=0;i<XSize()*YSize();i++) H.Add((float) (*this)[i],1.);
    722 
    723 // redimensionnement de l'histo pour avoir une bonne signification stat.
    724 for(;;) {
    725   r_8 max1,max2;
    726   int_4 imax1,imax2;
    727   rc = H.MaxiLocal(max1,imax1,max2,imax2);
    728   float rap = 1.;
    729   if( max1 != 0. ) rap = max2/max1;
    730   // if(nbin<100) H.Print(80);
    731   if(deb>1)
    732      cout<<"nbin="<<nbin
    733          <<"   maxloc="<<rc
    734          <<"   maxi="<<max1<<" imax="<<imax1<<" xmax="<<H.BinCenter(imax1)
    735          <<"   maxn="<<max2<<" imaxn="<<imax2<<" xmaxn="<<H.BinCenter(imax2)
    736          <<" -> "<<rap<<endl;
    737   if( rap<frac || nbin<=10 ) break;
    738   nbin = (int)(nbin/1.5);
    739   H.HRebin(nbin);
    740 }
    741 if(deb>1) { if(nbin<250) H.Print(80); else H.Print(80,-1.,1.,-1);}
    742 
    743 TRY {
    744   xbmax = H.FitMax(2,0.5,deb-2);
    745   if(deb>1) cout<<"H.FitMax = "<<xbmax<<endl;
    746 } CATCHALL {
    747    if(deb) cout<< "Echec H.FitMax"<< endl;
    748    return(-2);
    749 } ENDTRY
    750 
    751 TRY {
    752   r_8 sdroit = -2., dum=sgbmax;
    753   H.EstimeWidthS(0.5,dum,sdroit);
    754   if(dum<=0.) dum = H.FindWidth(0.5,deb-2);
    755   dum /= 2.36;
    756   sgbmax = dum;
    757   if(deb>1) cout<<"H.FindWidth = "<<sgbmax<<" (droit="<<sdroit<<")"<<endl;
    758 } CATCHALL {
    759    cout<< "Echec H.FindWidth"<< endl;
    760    return(-3);
    761 } ENDTRY
    762 
    763 return 0;
    764 }
    765 
    766 /* --Methode--  (cmv 23/09/96) */
    767 template <class T>
    768 //++
    769 float Image<T>::FondCiel(int nbin,float bin_low,float bin_high
    770                          ,int degre,float frac,int modu,int deb)
    771 //
    772 //      Calcul du fond de ciel:
    773 //      Remplissage d'un histogramme avec le contenu des pixels du pave,
    774 //      recherche du bin contenant le maximum,
    775 //      recheche des limites a frac% de chaque cote du maximum
    776 //      et fit d'un polynome du 2sd ou 3ieme degre dans cette zone.
    777 //| Input:
    778 //|   nbin,bin_low,bin_high : definition de l'histogramme
    779 //|   degre : degre du fit (2 ou 3)
    780 //|   frac : definition de la zone de fit a frac% du maximum
    781 //|   modu : on prend 1 px sur modu
    782 //|   deb : debug flag
    783 //| Output: renvoie le maximum de l'histogramme (fond de ciel)
    784 //|         et update le membre protected fond (si succes)
    785 //--
    786 {
    787 T pixv;
    788 
    789 if(modu<=0) modu = 1;
    790 if(frac<=0.) frac = 0.5;
    791 if(degre<2 || degre>3) degre = 2;
    792 if(deb>0)
    793   printf("Image::FondCiel: nbin=%d dyn=%g,%g deg=%d frac=%g modu=%d\n"
    794         ,nbin,bin_low,bin_high,degre,frac,modu);
    795 if(nbin<=degre) THROW(inconsistentErr);
    796 
    797 TRY {
    798 
    799   Histo tab(bin_low,bin_high,nbin);
    800   double sum = 0.;
    801   volatile int n = 0, nsum = 0;
    802   for(int i=0;i<XSize()*YSize();i++) {
    803     n++;
    804     if( n%modu != 0 ) continue;
    805     pixv = imagePtr[i];
    806     tab.Add( (float) pixv );
    807     sum += (double) pixv;
    808     nsum++;
    809   }
    810   if(deb>1) { int im = tab.IMax();
    811               tab.Print(80,1.,-1.,0,im-50,im+50); }
    812 
    813   float xf = 0.;
    814   // tout dans moins de degre bins
    815   if( tab.BinNonNul() <= degre ) {
    816     if(nsum<=0) THROW(inconsistentErr);
    817     xf = sum / (double) nsum;
    818     if(deb>0) printf("%d bins <= %d -> Succes Mean = %g\n"
    819                     ,tab.BinNonNul(),degre,xf);
    820     fond = xf;
    821     RETURN(xf);
    822   }
    823 
    824   TRY {
    825     xf = tab.FitMax(degre,frac,deb-1);
    826     if(deb>0) printf("Succes tab.FitMax = %g\n",xf);
    827     fond = xf;
    828     RETURN(xf);
    829   } CATCHALL {
    830     if(deb>0)
    831        printf("Echec tab.FitMax BinNonNul=%d\n",tab.BinNonNul());
    832     THROW(inconsistentErr);
    833   } ENDTRY
    834 
    835 } CATCHALL {
    836    THROW_SAME;
    837 } ENDTRY
    838 }
    839 
    840 /* --Methode-- (cmv 23/09/96) */
    841 template <class T>
    842 //++
    843 float Image<T>::SigmaCiel(int nbin,float bin_low,float bin_high
    844                          ,float& means,float lowbad,float highbad
    845                          ,float nsig,int modu,int deb)
    846 //
    847 //      Calcul du sigma du fond de ciel:
    848 //      Remplissage d'un histogramme avec px-<px8> pour les pixels
    849 //      entre lowbad et highbad (px=valeur du pixel etudie,
    850 //      <px8>=moyenne des 8 pixels qui lui sont contigus).
    851 //      Une premiere estimation du sigma (s1) et realisee en cherchant
    852 //      la largeur a mi-hauteur de cet histogramme. Puis un fit non-lineaire
    853 //      d'une gaussienne est effectue dans +/- nsig*s1
    854 //| Input:
    855 //|   nbin,bin_low,bin_high : definition de l'histogramme
    856 //|   lowbad,highbad : limites des pixels a utiliser
    857 //|   nsig : la zone de fit est definie a +/- nsig*sigma du maximum
    858 //|   modu : on prend 1 px sur modu
    859 //|   deb : debug flag
    860 //| Output:
    861 //|   means = moyenne fittee de l'histogramme (normalement -> 0)
    862 //|   renvoie le sigma du fond de ciel
    863 //|     et update le membre protected sigmaFond (si succes)
    864 //--
    865 {
    866 T pixv=0;
    867 T minadu = PutInRange((double) lowbad , pixv);
    868 T maxadu = PutInRange((double) highbad, pixv);
    869 volatile bool testl = (lowbad<highbad) ? true : false;
    870 
    871 if(nbin<5) THROW(inconsistentErr);
    872 if(nsig<=0.) nsig = 4.;
    873 if(modu<=0) modu = 1;
    874 means = 0.;
    875 if(deb>0)
    876   cout << "SigmaCiel( nbin=" << nbin
    877        << ", bin_low=" << bin_low
    878        << ", bin_high=" << bin_high
    879        << ", lowbad=" << lowbad
    880        << ", highbad=" << highbad
    881        << ", nsig=" << nsig
    882        << ", modu=" << modu
    883        << ", deb=" << deb << endl;
    884 
    885 // coeff pour corriger le sigma de (S-<S8>) par rapport au sigma de S
    886 // sigma(S) = sigma(S-<S8>) * 1/sqrt(1+1/8) = 2*sqrt(2)/3
    887 double coeff = 2.*Rac2/3.;
    888 
    889 TRY {
    890 
    891   Histo tab(bin_low,bin_high,nbin);
    892   tab.Errors();
    893 
    894   int nmod = 0, nsum = 0;
    895   double sum= 0., sum2 = 0.;
    896   for(int j=1;j<YSize()-1;j++) for(int i=1;i<XSize()-1;i++) {
    897     nmod++;
    898     if( nmod%modu != 0 ) continue;
    899     pixv = (*this)(i,j);
    900     if ( testl && (pixv < minadu || pixv > maxadu) ) continue;
    901     double vp = (double) pixv;
    902     double pxv = 0.;
    903     volatile int n = 0;
    904     for(int j1=j-1;j1<=j+1;j1++) for(int i1=i-1;i1<=i+1;i1++) {
    905       if ( i1 == i && j1 == j ) continue;
    906       pixv = (*this)(i1,j1);
    907       if ( testl && (pixv < minadu || pixv > maxadu) ) continue;
    908       pxv += (double) pixv;
    909       n++;
    910     }
    911     if ( n != 8 ) continue;
    912     vp = vp - pxv/(double) n;
    913     tab.Add( (float) vp );
    914     nsum++;
    915     sum += vp;
    916     sum2 += vp*vp;
    917   }
    918 
    919   float ms = tab.BinCenter( tab.IMax() );
    920   volatile float sg = 0.;
    921   if( tab.BinNonNul() == 1 ) {
    922     if(deb>0) cout << tab.BinNonNul()
    923                    << " bins non nul dans l'histogramme" << endl;
    924     if(nsum<=1) THROW(inconsistentErr);
    925     sum /= (double) nsum;
    926     sum2 = sum2/(double) nsum - sum*sum;
    927     if(sum2<0.) THROW(inconsistentErr);
    928     means = sum;
    929     sum2 = sqrt(sum2) * coeff;
    930     sigmaFond = sum2;
    931     RETURN((float) sum2);
    932   } else {
    933     TRY {
    934       sg = tab.FindWidth(0.5,deb-1) / 2.36;
    935     } CATCHALL {
    936       THROW_SAME;
    937     } ENDTRY
    938   }
    939   double h = tab.VMax();
    940   if(deb>0) cout << "from histo: ms=" << ms
    941                            << "  sg=" << sg
    942                            << "  h=" << h << endl;
    943 
    944   float xmin = ms - nsig*sg;
    945   float xmax = ms + nsig*sg;
    946   int imin = tab.FindBin(xmin);
    947   int imax = tab.FindBin(xmax);
    948   if( imax-imin+1 < 4 ) {imax++; imin--;}
    949   if(imin<0) imin=0;
    950   if(imax>=tab.NBins()) imax=tab.NBins()-1;
    951   int nb = imax-imin+1;
    952   if( nb < 4 ) THROW(inconsistentErr);
    953   if(deb>0) printf("xrange=[%g,%g] irange=[%d,%d] nb=%d\n"
    954                   ,xmin,xmax,imin,imax,nb);
    955   if(deb>2) tab.Print(80,1.,-1.,0,imin,imax);
    956 
    957   Gauss1DPol     myfunc;
    958   GeneralFit     myfit(&myfunc);
    959   GeneralFitData mydata(1,nb);
    960   for(int i=imin;i<=imax;i++) {
    961      float e = tab.Error(i);
    962      if( e <= 0. ) e = 1.;
    963      mydata.AddData1(tab.BinCenter(i),tab(i),e);
    964    }
    965 
    966   myfit.SetData(&mydata);
    967   myfit.SetParam(0,h,h/50.);
    968   myfit.SetParam(1,ms,sg/10.);
    969   myfit.SetParam(2,sg,sg/10.);
    970   myfit.SetBound(2,0.,sg*5.);
    971   int rc = myfit.Fit();
    972   if(rc<0) THROW(inconsistentErr);
    973   if(deb>1) myfit.PrintFit();
    974 
    975   means = myfit.GetParm(1);
    976   sum2 = myfit.GetParm(2) * coeff;
    977   sigmaFond = sum2;
    978   RETURN((float) sum2);
    979 
    980 } CATCHALL {
    981    THROW_SAME;
    982 } ENDTRY
    983 
    984 }
    985 
    986 
    987 /* --Methode-- (cmv 23/09/96) */
    988 template <class T>
    989 //++
    990 int Image<T>::MoySigma(float& mean,float& sigma,float lowbad,float highbad,int modu)
    991 //
    992 //      Calcul de la moyenne (mean) et du sigma (sigma) dans un pave
    993 //      en ne considerant que les pixels compris entre lowbad et highbad.
    994 //      Seul 1 px sur modu est utilise.
    995 //      La fonction retourne le nombre de pixels utilises pour le calcul.
    996 //--
    997 {
    998 T pixv=0;
    999 T minadu = PutInRange((double) lowbad , pixv);
    1000 T maxadu = PutInRange((double) highbad, pixv);
    1001 bool testl = (lowbad<highbad) ? true : false;
    1002 
    1003 if(modu<=0) modu = 1;
    1004 mean = sigma = 0.;
    1005 
    1006 int rc = 0, n = 0;
    1007 double m = 0., s = 0., mm, ss, v;
    1008 
    1009 for(int j=0;j<YSize();j++) {
    1010   mm = ss = 0.;
    1011   for(int i=0;i<XSize();i++) {
    1012     n++;
    1013     if( n%modu != 0 ) continue;
    1014     pixv = (*this)(i,j);
    1015     if( testl && (pixv < minadu || pixv > maxadu) ) continue;
    1016     v = (double) pixv;
    1017     rc++;
    1018     mm += v;
    1019     ss += v*v;
    1020   }
    1021   m += mm;
    1022   s += ss;
    1023 }
    1024 
    1025 if(rc==0) return(-1);
    1026 
    1027 m /= (double) rc;
    1028 s = s/(double) rc - m*m;
    1029 if(s<0.) return(-2);
    1030 
    1031 mean  = (float) m;
    1032 sigma = (float) sqrt(s);
    1033 
    1034 moyPix = mean;     // Mise a jour de la structure
    1035 sigPix = sigma;
    1036 
    1037 return rc;
    1038 }
    1039 
    1040 /* --Methode-- (cmv 23/09/96) */
    1041 template <class T>
    1042 //++
    1043 int Image<T>::MoySigmaIter(float& mean,float& sigma,float lowbad,float highbad
    1044                           ,int modu,int nitermx,float perdiff,float scut,int deb)
    1045 //
    1046 //      Calcul de moyenne et sigma iterativement:
    1047 //| lowbad,highbad = dynamique permise pour la valeur
    1048 //|                  des pixels en ADU
    1049 //| modu = 1 px sur modu est utilise
    1050 //| nitermx = nombre maximum d'iterations permises
    1051 //| perdiff = condition d'arret en pourcent sur la variation du sigma
    1052 //| scut = coupure en nombre de sigma courant pour l'iteration suivante
    1053 //| mean = moyenne retournee
    1054 //| sigma = sigma retourne
    1055 //| return <= 0 probleme, sinon (>0) nombre de pixels utilises
    1056 //--
    1057 {
    1058 if( scut<=0. || nitermx<=0 || perdiff<=0. ) return 0;
    1059 if(modu<=0) modu = 1;
    1060 bool testl = (lowbad<highbad) ? true : false;
    1061 
    1062 mean = sigma = 0.;
    1063 float sigmaold = 0;
    1064 float xmin = lowbad;
    1065 float xmax = highbad;
    1066 int rc = 0;
    1067 
    1068 for(int it=0;it<nitermx;it++) {
    1069   rc = MoySigma(mean,sigma,xmin,xmax,modu);
    1070   if(deb>0) cout<<"MoySigmaIter mean="<<mean<<" sigma="<<sigma
    1071                 <<" npix="<<rc<<" entre "<<xmin<<","<<xmax<<endl;
    1072   if( rc <= 0 || sigma<=0. ) return rc;
    1073   if( it>=1 && fabs((double)(sigma-sigmaold))/sigma < perdiff ) break;
    1074   xmin = mean - scut*sigma; if(testl && xmin<lowbad ) xmin = lowbad;
    1075   xmax = mean + scut*sigma; if(testl && xmax>highbad) xmax = highbad;
    1076   sigmaold = sigma;
    1077 }
    1078 
    1079 return rc;
    1080 }
    1081 
    1082 /* --Methode-- (cmv 23/09/96) */
    1083 template <class T>
    1084 //++
    1085 int Image<T>::FondSigmaCiel(float lowbad,float highbad,int pvsz
    1086               ,float nbsig1,float nbsig2,float nbsig3
    1087               ,float binsg,float frac,int modu,int deb)
    1088 //
    1089 //      Calcul automatique du fond de ciel et du sigma ciel en utilisant
    1090 //      les methodes precedentes et en calculant au mieux le binning.
    1091 //| lowbad,highbad: dynamoque utile de l'image (ADU)
    1092 //| pvsz : taille du pave a traiter (centre au milieu de l'image)
    1093 //| nbsig1 : pour EstimeFdSg  -> calcul sgbmax (def=3.5).
    1094 //| nbsig2 : pour FondCiel (histo entre X maxi +/- nbsig2*sgbmax
    1095 //|                        nbin = 2.*nbsig2*binsg) (def=5).
    1096 //| nbsig3 : pour SigmaCiel (histo entre 0 +/- nbsig3*sgbmax
    1097 //|                         nbin = 2.*nbsig3*binsg) (def=5).
    1098 //| binsg : taille du bin pour les histos de FondCiel et SigmaCiel
    1099 //|                        (def=0.33)
    1100 //| frac : pour EstimeFdSg(...,frac,...)  (def=0.33)
    1101 //--
    1102 {
    1103 if(pvsz<=0) pvsz = 100;
    1104 if(nbsig1<=0) nbsig1 = 3.5;
    1105 if(nbsig2<=0) nbsig2 = 5.0;
    1106 if(nbsig3<=0) nbsig3 = 5.0;
    1107 if(binsg<=0) binsg = 0.33; binsg = 1./binsg;
    1108 if(frac<=0.) frac = 0.33;
    1109 if(deb<0) deb=0;
    1110 int lpdb = (deb>=3) ? deb-2 : 0;
    1111 int envd = 0;
    1112 GetIntEnv("PDEBUG_FOND", envd);
    1113 if (lpdb < envd) lpdb = envd;
    1114 if (deb < envd) deb = envd;
    1115 float xbmax = 0., sgbmax = 0.;
    1116 int nbin,rc;
    1117 float xmin,xmax,binw,means;
    1118 
    1119 // creation sous image
    1120 int pvsx = pvsz, pvsy = pvsz;
    1121 if( pvsx > XSize() ) pvsx = XSize();
    1122 if( pvsy > YSize() ) pvsy = YSize();
    1123 Image<T> *ssima = NULL;
    1124 bool cree = false;
    1125 if( pvsx == XSize() && pvsy == YSize() ) {
    1126   ssima = this;
    1127 } else {
    1128   int orgx = XSize()/2 - pvsx/2;  if( orgx < 0 ) orgx = 0;
    1129   int orgy = YSize()/2 - pvsy/2;  if( orgy < 0 ) orgy = 0;
    1130   if( orgx + pvsx > XSize() ) pvsx = XSize() - orgx;
    1131   if( orgy + pvsy > YSize() ) pvsy = YSize() - orgy;
    1132   ssima = new Image<T>(pvsx,pvsy);
    1133   cree = true;
    1134   CopieImageF(*ssima,*this,orgx,orgy,pvsx,pvsy,0,0,0.,0.);
    1135 }
    1136 
    1137 // moyenne et sigma approches sur sous-image
    1138 rc = ssima->EstimeFdSg(xbmax,sgbmax,nbsig1,frac,lowbad,highbad,deb-1);
    1139 if( cree ) delete ssima;
    1140 if(rc<0) return -2;
    1141 fond = xbmax;
    1142 sigmaFond = sgbmax;
    1143 
    1144 // bin entier... pas forcement necessaire.
    1145 xmin = xbmax - nbsig2*sgbmax;
    1146 xmax = xbmax + nbsig2*sgbmax;
    1147 nbin = (int)(2.*nbsig2*binsg); if(nbin<5) nbin=5;
    1148 binw = (xmax-xmin)/nbin;
    1149 if(deb>0) cout<<"bin auto: xmin="<<xmin<<" xmax="<<xmax
    1150               <<" nbin="<<nbin<<" binw="<<binw<<endl;
    1151 HBinInt(nbin,xmin,xmax);
    1152 binw = (xmax-xmin)/nbin;
    1153 if(deb>0) cout<<"bin auto entier:  nbin="<<nbin<<" binw="<<binw
    1154               <<" entre "<<xmin<<","<<xmax<<endl;
    1155 
    1156 // Optimisation de modu
    1157 if( modu <= 0 ) {
    1158   // 4 fois plus de pixels que dans le pre-pave
    1159   int npv = 4*pvsz*pvsz;
    1160   int nima = XSize()*YSize();
    1161   if( npv >= nima || nima < 10000 ) modu = 1;
    1162       else modu = (int)( (float) nima / (float) npv );
    1163   if(deb) cout<<"modulo choisi a "<<modu<<endl;
    1164 }
    1165 
    1166 // moyenne evoluee
    1167 TRY {
    1168   fond = FondCiel(nbin,xmin,xmax,3,0.5,modu,lpdb);
    1169   if(deb>0) cout <<"Fond de ciel = "<<fond<< endl;
    1170 } CATCHALL {
    1171   if(deb>0) cout << "Echec FondCiel" << endl;
    1172   return(-3);
    1173 } ENDTRY
    1174  
    1175 // sigma evolue
    1176 TRY {
    1177   float dyn = nbsig3*sgbmax;
    1178   int nbins = (int) (2.*nbsig3*binsg);
    1179   float binws = (2.*dyn)/nbins;
    1180   sigmaFond = SigmaCiel(nbins,-dyn,dyn,means,lowbad,highbad,4.,modu,lpdb);
    1181   if(deb>0) cout <<"Sigma fond de ciel = "<<sigmaFond
    1182                 <<" (ms="<<means<<") sur "<<nbins
    1183                 <<" bins de largeur "<<binws<< endl;
    1184 } CATCHALL {
    1185   if(deb>0) cout << "Echec SigmaCiel" << endl;
    1186   return(-4);
    1187 } ENDTRY
    1188 
    1189 // Impression finale
    1190 if(deb) cout <<"ImgSigmaCiel: fond= "<<xbmax<<" / "<< fond
    1191              <<"   sigma= "<<sgbmax<<" / "<<sigmaFond<<endl;
    1192 
    1193 return 0;
    1194 }
    1195 
    1196 
    1197 
    1198 /*  .......................................................  */
    1199 /*         Fonctions de copie d'images et de paves           */
    1200 /*  .......................................................  */
    1201 
    1202 
    1203 /* Nouvelle-Fonction */
    1204 template <class T2, class T1>
    1205 void CopieImageF(Image<T2>& copie, Image<T1> const& pim,
    1206          int org_pim_x, int org_pim_y,            /* origine pave a copier */
    1207          int pim_lpav_x, int pim_lpav_y,          /* largeur pave a copier */
    1208          int org_copie_x, int org_copie_y,        /* origine copie         */
    1209          double cutmin, double cutmax)            /* coupure pour max range*/
    1210 
    1211 /* Copie d'une image (pim) ds l'autre (copie) a partir d'un  */
    1212 /* offset specifie en pixel                                  */
    1213 /* attention: pas d'offset -> org_x = org_y = 0              */
    1214 {
    1215 int i,j;
    1216 // int x,y;  $CHECK$ Reza 21/06/99 changement de methode de calcul des bornes
    1217 const T1* pt_pim;
    1218 T2* pt_copie;
    1219 double pim_pix;
    1220 int l_copie_x,l_copie_y;
    1221 int step_copie_x;
    1222 int step_pim_x;
    1223 int pim_siz_x, pim_siz_y;
    1224 // int copie_siz_x, copie_siz_y;  $CHECK$ Reza 21/06/99 changement de methode de calcul des bornes
    1225 int switch_copie;
    1226 
    1227 pim_siz_x=pim.XSize();
    1228 pim_siz_y=pim.YSize();
    1229 if((org_pim_x < 0) || (org_pim_x > pim_siz_x))
    1230   { cout<< "CopieImage_erreure : org_pim_x: " <<org_pim_x<<" < 0 ou > a "<<pim_siz_x<<endl;
    1231     THROW(rangeCheckErr);}
    1232 if((org_pim_y < 0) || (org_pim_y > pim_siz_y))
    1233   { cout<< "CopieImage_erreure : org_pim_y: " <<org_pim_y<<" < 0 ou > a "<<pim_siz_y<<endl;
    1234     THROW(rangeCheckErr);}
    1235 
    1236 if( (org_copie_x < 0) || (org_copie_x > copie.XSize()) )
    1237   { cout<< "CopieImage_erreure : org_copie_x: " <<org_copie_x<<" < 0 ou > a "<< copie.XSize() << endl;
    1238     THROW(rangeCheckErr);}
    1239 if( (org_copie_y < 0) || (org_copie_y > copie.YSize()) )
    1240   { cout<< "CopieImage_erreure : org_copie_y: " <<org_copie_y<<" < 0 ou > a "<< copie.YSize() << endl;
    1241     THROW(rangeCheckErr);}
    1242 
    1243 /* $CHECK$ Reza 21/06/99  Changement de methode de calcul ------
    1244 $CHECK$ Reza 21/06/99 , je change la taille a copier en fonction de l'origine de copie
    1245 copie_siz_x=copie.XSize()-org_copie_x;
    1246 copie_siz_y=copie.YSize()-org_copie_y;
    1247 
    1248 x=pim_lpav_x;
    1249 if(x > (pim_siz_x-org_pim_x)) x=pim_siz_x-org_pim_x;
    1250 step_pim_x = pim_siz_x-x;
    1251 
    1252 if(x < copie_siz_x)
    1253   {
    1254    l_copie_x=x;
    1255    step_copie_x=copie_siz_x-x;
    1256   }
    1257 else
    1258   {
    1259    l_copie_x=copie_siz_x;
    1260    step_copie_x=0;
    1261    step_pim_x=step_pim_x+x-copie_siz_x;
    1262    }
    1263 
    1264 if(org_copie_x  > 0 )
    1265   {
    1266   int x=copie_siz_x-org_copie_x;
    1267   if(x < l_copie_x )
    1268     {
    1269      step_pim_x=step_pim_x+l_copie_x-x;
    1270      l_copie_x=x;
    1271      step_copie_x=org_copie_x;
    1272     }
    1273   else
    1274     {
    1275      step_copie_x=copie_siz_x-l_copie_x;
    1276     }
    1277   }
    1278 
    1279 y=pim_lpav_y;
    1280 if(y > (pim_siz_y-org_pim_y)) y=pim_siz_y-org_pim_y;
    1281 
    1282 if(y < copie_siz_y)
    1283   {
    1284    l_copie_y=y;
    1285   }
    1286 else
    1287   {
    1288    l_copie_y=copie_siz_y;
    1289    }
    1290 
    1291 */
    1292 
    1293 l_copie_x = copie.XSize()-org_copie_x;
    1294 l_copie_y = copie.YSize()-org_copie_y;
    1295 if ( pim_lpav_x > (pim.XSize()-org_pim_x) )  pim_lpav_x = pim.XSize()-org_pim_x;
    1296 if ( pim_lpav_y > (pim.YSize()-org_pim_y) )  pim_lpav_y = pim.YSize()-org_pim_y;
    1297 if ( (pim_lpav_x > 0) && (l_copie_x > pim_lpav_x) )  l_copie_x = pim_lpav_x;
    1298 if ( (pim_lpav_y > 0) && (l_copie_y > pim_lpav_y) )  l_copie_y = pim_lpav_y;
    1299 step_pim_x = pim.XSize()-l_copie_x;
    1300 step_copie_x = copie.XSize()-l_copie_x;
    1301 
    1302 pt_pim  = pim.ImagePtr() + org_pim_y*pim.XSize() + org_pim_x;
    1303 pt_copie=copie.ImagePtr() + org_copie_y*copie.XSize() + org_copie_x;
    1304 
    1305 switch((int)ConvType(*pt_pim,*pt_copie)) {
    1306   case t_same: case t_up:
    1307     switch_copie=0;
    1308   break;
    1309   case t_spe: case t_down:
    1310     switch_copie=1;
    1311   break;
    1312 }
    1313 
    1314 if(cutmin < cutmax) switch_copie *= 2;
    1315 
    1316 switch(switch_copie) {
    1317   case 0:
    1318     for (j=0; j< l_copie_y; j++)
    1319       {
    1320       for(i=0; i< l_copie_x; i++)
    1321         {
    1322         *pt_copie++ =(T2)*pt_pim++;
    1323         }
    1324       pt_pim   += step_pim_x;
    1325       pt_copie += step_copie_x;
    1326       }
    1327   break;
    1328   case 1:
    1329     for (j=0; j< l_copie_y; j++)
    1330       {
    1331       for(i=0; i< l_copie_x; i++)
    1332         {
    1333         pim_pix = *pt_pim++;
    1334         *pt_copie++ = PutInRange(pim_pix, *pt_copie);
    1335         }
    1336       pt_pim   += step_pim_x;
    1337       pt_copie += step_copie_x;
    1338       }
    1339   break;
    1340   case 2:
    1341     for (j=0; j< l_copie_y; j++)
    1342       {
    1343       for(i=0; i< l_copie_x; i++)
    1344         {
    1345         pim_pix = *pt_pim++;
    1346         *pt_copie++ = (T2)SharePix(pim_pix,*pt_copie,cutmin,cutmax);
    1347         }
    1348       pt_pim   += step_pim_x;
    1349       pt_copie += step_copie_x;
    1350       }
    1351   break;
    1352 }
    1353 
    1354 copie.SetOrg( pim.XOrg()+org_pim_x-org_copie_x, pim.YOrg()+org_pim_y-org_copie_y);
    1355 }
    1356 
    1357 
    1358 /* Nouvelle-Fonction */
    1359 template <class T2, class T1>
    1360 void CopieImage(Image<T2>& copie , Image<T1> const& pim)
    1361 {
    1362 if (!pim.ImagePtr())   THROW(nullPtrErr);
    1363 if (!copie.ImagePtr()) copie.Allocate(pim.XSize(),pim.YSize());
    1364 
    1365 CopieImageF(copie, pim,0,0,pim.XSize(),pim.YSize(),0,0,0., 0.);
    1366 }
    1367 
    1368 /* Nouvelle-Fonction */
    1369 template <class T2, class T1>
    1370 void CopieImage(Image<T2>& copie , Image<T1> const& pim,
    1371                 int org_pim_x    , int org_pim_y,
    1372                 int pim_lpav_x   , int pim_lpav_y,
    1373                 int org_copie_x  , int org_copie_y,
    1374                 double cutmin    , double cutmax )
    1375 {
    1376 if (!pim.ImagePtr())   THROW(nullPtrErr);
    1377 if (!copie.ImagePtr()) THROW(nullPtrErr);
    1378 copie.SetOrg( pim.XOrg()+org_pim_x-org_copie_x, pim.YOrg()+org_pim_y-org_copie_y);
    1379 // copie.SetOrg(org_pim_x,org_pim_y);
    1380 
    1381 /* Reza 28/04/95 : Je protege pour le moment contre les pave en
    1382 dehors de l'image, mais je veux pouvoir copier des paves decale par
    1383 rapport aux bornes de l'image source  Re- CMV+Reza 30/09/96 */
    1384 /* $CHECK$ Reza 21/06/99 - Ca devrait etre OK  */
    1385 if ( (org_pim_x < 0) || (org_pim_y < 0) ||
    1386      (org_pim_x >= pim.XSize() ) || (org_pim_y >= pim.YSize() ) ||
    1387      ((org_pim_x+copie.XSize()) > pim.XSize()) ||
    1388      ((org_pim_y+copie.YSize()) > pim.YSize()) ) copie.Zero();
    1389 
    1390 if ( (org_pim_x >= pim.XSize()) || (org_pim_y >= pim.YSize()) ) {
    1391   copie.SetOrg( pim.XOrg()+org_pim_x-org_copie_x, pim.YOrg()+org_pim_y-org_copie_y);
    1392   return;
    1393 }   
    1394 // if ( (org_pim_x < 0) || (org_pim_y < 0) ||
    1395 //      (org_pim_x >= pim.XSize() ) || (org_pim_y >= pim.YSize() )) return;
    1396 
    1397 int oox = org_pim_x;
    1398 int ooy = org_pim_y;
    1399 int ocx = org_copie_x;
    1400 int ocy = org_copie_y;
    1401 if (oox < 0)  { ocx -= oox;  oox = 0; }
    1402 if (ooy < 0)  { ocy -= ooy;  ooy = 0; }
    1403 /*  Fin de $CHECK$  */
    1404 
    1405 // void CopieImageF(Image<T2>& copie, Image<T1> const& pim,
    1406 //         int org_pim_x, int org_pim_y,            /* origine pave a copier */
    1407 //         int pim_lpav_x, int pim_lpav_y,          /* largeur pave a copier */
    1408 //         int org_copie_x, int org_copie_y,        /* origine copie         */
    1409 //         double cutmin, double cutmax)            /* coupure pour max range*/
    1410 
    1411 if((pim_lpav_x <= 0) || (pim_lpav_x > pim.XSize())) pim_lpav_x=pim.XSize();
    1412 if((pim_lpav_y <= 0) || (pim_lpav_y > pim.YSize())) pim_lpav_y=pim.YSize();
    1413 try {
    1414   CopieImageF(copie, pim, oox, ooy,
    1415               pim_lpav_x, pim_lpav_y,
    1416               ocx, ocy, cutmin,cutmax);
    1417   }  catch(RangeCheckError) {
    1418 // $PLANCKCHECK$   if (merr != rangeCheckErr) THROW(merr);  // Re- $CHECK$ CMV+Reza 30/09/96
    1419   } ENDTRY
    1420 
    1421 copie.SetOrg( pim.XOrg()+org_pim_x-org_copie_x, pim.YOrg()+org_pim_y-org_copie_y);
    1422 }
    1423 
    1424 
    1425 /* Nouvelle-Fonction */
    1426 template <class T2, class T1>
    1427 void CopiePave ( Image<T2>& pave , Image<T1> const& pim,
    1428                  float xc, float yc,
    1429                  double cutmin, double cutmax)
    1430 {
    1431 int ix, iy;
    1432 
    1433 xc -= 0.5 * (float)(pave.XSize()-1);
    1434 yc -= 0.5 * (float)(pave.YSize()-1);
    1435 //  CopiePave tient compte de l'origine de l'image de depart   Reza 18/9/96
    1436 xc -= pim.XOrg();     yc -= pim.YOrg();
    1437 
    1438 if ( xc >= 0.)  ix = (int)xc;
    1439 else ix = (int)(xc-1.0);
    1440 if ( yc >= 0.)  iy = (int)yc;
    1441 else iy = (int)(yc-1.0);
    1442 CopieImage(pave, pim, ix, iy, 0, 0, 0, 0, cutmin, cutmax ) ;
    1443 }
    1444 
    1445 
    1446 /* Nouvelle-Fonction */
    1447 template <class T>
    1448 void RzCopieImage(Image<T>& copie, RzImage const& pim,
    1449                   int org_pim_x , int org_pim_y,
    1450                   int pim_lpav_x, int pim_lpav_y,
    1451                   int org_copie_x, int org_copie_y,
    1452                   double cutmin , double cutmax)
    1453 {
    1454   switch (pim.PixelType()) {
    1455   case kuint_2: {
    1456     ImageU2 src((RzImage&)pim);
    1457     CopieImage(copie, src, org_pim_x , org_pim_y,
    1458                pim_lpav_x, pim_lpav_y, org_copie_x,
    1459                org_copie_y, cutmin, cutmax );
    1460     break;
    1461     }
    1462   case kint_2: {
    1463     ImageI2 src((RzImage&)pim);
    1464     CopieImage(copie, src, org_pim_x , org_pim_y,
    1465                pim_lpav_x, pim_lpav_y, org_copie_x,
    1466                org_copie_y, cutmin, cutmax );
    1467     break;
    1468     }
    1469   case kint_4: {
    1470     ImageI4 src((RzImage&)pim);
    1471     CopieImage(copie, src, org_pim_x , org_pim_y,
    1472                pim_lpav_x, pim_lpav_y, org_copie_x,
    1473                org_copie_y, cutmin, cutmax );
    1474     break;
    1475     }
    1476   case kr_4: {
    1477     ImageR4 src((RzImage&)pim);
    1478     CopieImage(copie, src, org_pim_x , org_pim_y,
    1479                pim_lpav_x, pim_lpav_y, org_copie_x,
    1480                org_copie_y, cutmin, cutmax );
    1481     break;
    1482     }
    1483   case kr_8:
    1484   case kuint_4:
    1485   case kuint_1:
    1486   case kint_1:
    1487     cerr << " RzCopieImage(...) / Error, Unsupported image type (kr_8/ kuint_4/ kuint_1/ kint_1) "
    1488          << (int)pim.PixelType() << "\n";
    1489     break;
    1490   default:
    1491     cerr << " RzCopieImage(...) / Error, Unknown image type !" <<  (int)pim.PixelType() << "\n";
    1492     break;
    1493   }
    1494 }
    1495 
    1496 
    1497 /* Nouvelle-Fonction */
    1498 template <class T>
    1499 void RzCopieImage(Image<T>& copie, RzImage const& pim)
    1500 {
    1501   switch (pim.PixelType()) {
    1502   case kuint_2: {
    1503     ImageU2 src((RzImage&)pim);
    1504     CopieImage(copie, src);
    1505     break;
    1506     }
    1507   case kint_2: {
    1508     ImageI2 src((RzImage&)pim);
    1509     CopieImage(copie, src);
    1510     break;
    1511     }
    1512   case kint_4: {
    1513     ImageI4 src((RzImage&)pim);
    1514     CopieImage(copie, src);
    1515     break;
    1516     }
    1517   case kr_4: {
    1518     ImageR4 src((RzImage&)pim);
    1519     CopieImage(copie, src);
    1520     break;
    1521     }
    1522   case kr_8:
    1523   case kuint_4:
    1524   case kuint_1:
    1525   case kint_1:
    1526     cerr << " RzCopieImage() / Error, Unsupported image type (kr_8/ kuint_4/ kuint_1/ kint_1) "
    1527          << (int)pim.PixelType() << "\n";
    1528     break;
    1529   default:
    1530     cerr << " RzCopieImage() / Error, Unknown image type ! " <<  (int)pim.PixelType() << "\n";
    1531     break;
    1532   }
    1533 }
    1534 
    1535 /* Nouvelle-Fonction */
    1536 template <class T>
    1537 void RzCopiePave(Image<T> & pave, RzImage const & pim,
    1538                  float xc, float yc,
    1539                  double cutmin, double cutmax)
    1540 {
    1541 int ix, iy;
    1542 
    1543 xc -= 0.5 * (float)(pave.XSize()-1);
    1544 yc -= 0.5 * (float)(pave.YSize()-1);
    1545 //  RzCopiePave tient compte de l'origine de l'image de depart   Reza 18/9/96
    1546 xc -= pim.XOrg();     yc -= pim.YOrg();
    1547 
    1548 if ( xc >= 0.)  ix = (int)xc;
    1549 else ix = (int)(xc-1.0);
    1550 if ( yc >= 0.)  iy = (int)yc;
    1551 else iy = (int)(yc-1.0);
    1552 
    1553 RzCopieImage(pave, pim, ix, iy, 0, 0, 0, 0, cutmin, cutmax) ;
    1554 }
    1555 
    1556 
    1557 /* Nouvelle-Fonction */
    1558 void RzPrintImage(RzImage & img)
    1559 {
    1560 switch (img.PixelType())
    1561   {
    1562   case kuint_1:
    1563     {
    1564     ImageU1 src((RzImage&)img);
    1565     cout << src ;
    1566     break;
    1567     }
    1568   case kuint_2:
    1569     {
    1570     ImageU2 src((RzImage&)img);
    1571     cout << src ;
    1572     break;
    1573     }
    1574   case kint_2:
    1575     {
    1576     ImageI2 src((RzImage&)img);
    1577     cout << src ;
    1578     break;
    1579     }
    1580   case kint_4:
    1581     {
    1582     ImageI4 src((RzImage&)img);
    1583     cout << src ;
    1584     break;
    1585     }
    1586   case kr_4:
    1587     {
    1588     ImageR4 src((RzImage&)img);
    1589     cout << src ;
    1590     break;
    1591     }
    1592   case kr_8:
    1593   case kuint_4:
    1594   case kint_1:
    1595     cerr << " RzPrintImage() / Error, Unsupported image type (kr_8/kuint_4/ kint_1) "
    1596          << (int)img.PixelType() << "\n";
    1597     break;
    1598   default:
    1599     cerr << " RzPrintImage() / Error, Unknown image type " <<  (int)img.PixelType() << "\n";
    1600     break;
    1601   }
    1602 }
    1603 
    1604 
    1605 // ********** INSTANCES
    1606 #if defined(__xlC) || defined(__aCC__)
    1607 void instancetempcimage(int n)
    1608 {
    1609 // #pragma define_template
    1610 /* Cette fonction sert uniquement a forcer le compilo a instancier les
    1611   classes/fonctions template   */
    1612 
    1613 int m = n-50;
    1614 ImageU1  iu1(n,n), xiu1(m,m);
    1615 ImageU2  iu2(n,n), xiu2(m,m);
    1616 ImageI2  ii2(n,n), xii2(m,m);
    1617 ImageI4  ii4(n,n), xii4(m,m);
    1618 ImageR4  ir4(n,n), xir4(m,m);
    1619 RzImage  rzi(kr_4, n, n);
    1620 
    1621 cout << iu1;
    1622 cout << iu2;
    1623 cout << ii2;
    1624 cout << ii4;
    1625 cout << ir4;
    1626 
    1627 CopieImageF(iu2, xiu2, 50, 50);
    1628 CopieImageF(iu2, xii2, 50, 50);
    1629 CopieImageF(iu2, xii4, 50, 50);
    1630 CopieImageF(iu2, xir4, 50, 50);
    1631 CopieImageF(ii2, xiu2, 50, 50);
    1632 CopieImageF(ii2, xii2, 50, 50);
    1633 CopieImageF(ii2, xii4, 50, 50);
    1634 CopieImageF(ii2, xir4, 50, 50);
    1635 CopieImageF(ii4, xiu2, 50, 50);
    1636 CopieImageF(ii4, xii2, 50, 50);
    1637 CopieImageF(ii4, xii4, 50, 50);
    1638 CopieImageF(ii4, xir4, 50, 50);
    1639 CopieImageF(ir4, xiu2, 50, 50);
    1640 CopieImageF(ir4, xii2, 50, 50);
    1641 CopieImageF(ir4, xii4, 50, 50);
    1642 CopieImageF(ir4, xir4, 50, 50);
    1643 
    1644 CopieImage(iu2, xiu2);
    1645 CopieImage(iu2, xii2);
    1646 CopieImage(iu2, xii4);
    1647 CopieImage(iu2, xir4);
    1648 CopieImage(ii2, xiu2);
    1649 CopieImage(ii2, xii2);
    1650 CopieImage(ii2, xii4);
    1651 CopieImage(ii2, xir4);
    1652 CopieImage(ii4, xiu2);
    1653 CopieImage(ii4, xii2);
    1654 CopieImage(ii4, xii4);
    1655 CopieImage(ii4, xir4);
    1656 CopieImage(ir4, xiu2);
    1657 CopieImage(ir4, xii2);
    1658 CopieImage(ir4, xii4);
    1659 CopieImage(ir4, xir4);
    1660 
    1661 CopieImage(iu2, xiu2, 50, 50);
    1662 CopieImage(iu2, xii2, 50, 50);
    1663 CopieImage(iu2, xii4, 50, 50);
    1664 CopieImage(iu2, xir4, 50, 50);
    1665 CopieImage(ii2, xiu2, 50, 50);
    1666 CopieImage(ii2, xii2, 50, 50);
    1667 CopieImage(ii2, xii4, 50, 50);
    1668 CopieImage(ii2, xir4, 50, 50);
    1669 CopieImage(ii4, xiu2, 50, 50);
    1670 CopieImage(ii4, xii2, 50, 50);
    1671 CopieImage(ii4, xii4, 50, 50);
    1672 CopieImage(ii4, xir4, 50, 50);
    1673 CopieImage(ir4, xiu2, 50, 50);
    1674 CopieImage(ir4, xii2, 50, 50);
    1675 CopieImage(ir4, xii4, 50, 50);
    1676 CopieImage(ir4, xir4, 50, 50);
    1677 
    1678 CopiePave(iu2, xiu2, (float)25., (float)25.);
    1679 CopiePave(iu2, xii2, (float)25., (float)25.);
    1680 CopiePave(iu2, xii4, (float)25., (float)25.);
    1681 CopiePave(iu2, xir4, (float)25., (float)25.);
    1682 CopiePave(ii2, xiu2, (float)25., (float)25.);
    1683 CopiePave(ii2, xii2, (float)25., (float)25.);
    1684 CopiePave(ii2, xii4, (float)25., (float)25.);
    1685 CopiePave(ii2, xir4, (float)25., (float)25.);
    1686 CopiePave(ii4, xiu2, (float)25., (float)25.);
    1687 CopiePave(ii4, xii2, (float)25., (float)25.);
    1688 CopiePave(ii4, xii4, (float)25.,(float) 25.);
    1689 CopiePave(ii4, xir4, (float)25., (float)25.);
    1690 CopiePave(ir4, xiu2, (float)25., (float)25.);
    1691 CopiePave(ir4, xii2, (float)25., (float)25.);
    1692 CopiePave(ir4, xii4, (float)25., (float)25.);
    1693 CopiePave(ir4, xir4, (float)25., (float)25.);
    1694 
    1695 RzCopieImage(iu2, rzi, 50, 50);
    1696 RzCopieImage(ii2, rzi, 50, 50);
    1697 RzCopieImage(ii4, rzi, 50, 50);
    1698 RzCopieImage(ir4, rzi, 50, 50);
    1699 
    1700 RzCopieImage(iu2, rzi);
    1701 RzCopieImage(ii2, rzi);
    1702 RzCopieImage(ii4, rzi);
    1703 RzCopieImage(ir4, rzi);
    1704 
    1705 RzCopiePave(iu2, rzi, (float)25., (float)25.);
    1706 RzCopiePave(ii2, rzi, (float)25., (float)25.);
    1707 RzCopiePave(ii4, rzi, (float)25., (float)25.);
    1708 RzCopiePave(ir4, rzi, (float)25., (float)25.);
    1709 
    1710 return;
    1711 }
    1712 
     60#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
     61template class Image<uint_2>;
     62template class Image<int_4>;
     63template class Image<int_8>;
     64template class Image<r_4>;
     65template class Image<r_8>;
     66//template class Image< complex<r_4> >;
     67//template class Image< complex<r_8> >;
    171368#endif
    1714 
    1715 #ifdef __CXX_PRAGMA_TEMPLATES__
    1716 #pragma define_template Image<uint_1>
    1717 #pragma define_template Image<uint_2>
    1718 #pragma define_template Image<int_2>
    1719 #pragma define_template Image<int_4>
    1720 #pragma define_template Image<r_4>
    1721 
    1722 // pour supprimer les message Warning: Unresolved:
    1723 //                                     __ls__XR7ostreamRC10Image__TUc
    1724 
    1725 ostream& operator << (ostream& s, ImageU1 const& pim)
    1726 {
    1727 cout << "operator << (ostream, ImageU1) Not implemented ..." << endl;
    1728 return(s);
    1729 }
    1730 
    1731 // CopieImageF
    1732 #pragma define_template CopieImageF < uint_1 , uint_1 >
    1733 #pragma define_template CopieImageF < uint_1 , uint_2 >
    1734 #pragma define_template CopieImageF < uint_1 , int_2 >
    1735 #pragma define_template CopieImageF < uint_1 , int_4 >
    1736 #pragma define_template CopieImageF < uint_1 , r_4 >
    1737 
    1738 #pragma define_template CopieImageF < uint_2 , uint_2 >
    1739 #pragma define_template CopieImageF < uint_2 , int_2 >
    1740 #pragma define_template CopieImageF < uint_2 , int_4 >
    1741 #pragma define_template CopieImageF < uint_2 , r_4 >
    1742 
    1743 #pragma define_template CopieImageF < int_2 , uint_2 >
    1744 #pragma define_template CopieImageF < int_2 , int_2 >
    1745 #pragma define_template CopieImageF < int_2 , int_4 >
    1746 #pragma define_template CopieImageF < int_2 , r_4 >
    1747 
    1748 #pragma define_template CopieImageF < int_4 , uint_2 >
    1749 #pragma define_template CopieImageF < int_4 , int_2 >
    1750 #pragma define_template CopieImageF < int_4 , int_4 >
    1751 #pragma define_template CopieImageF < int_4 , r_4 >
    1752 
    1753 #pragma define_template CopieImageF < r_4 , uint_2 >
    1754 #pragma define_template CopieImageF < r_4 , int_2 >
    1755 #pragma define_template CopieImageF < r_4 , int_4 >
    1756 #pragma define_template CopieImageF < r_4 , r_4 >
    1757 
    1758 // CopieImage
    1759 #pragma define_template CopieImage < uint_2 , uint_2 >
    1760 #pragma define_template CopieImage < uint_2 , int_2 >
    1761 #pragma define_template CopieImage < uint_2 , int_4 >
    1762 #pragma define_template CopieImage < uint_2 , r_4 >
    1763 
    1764 #pragma define_template CopieImage < int_2 , uint_2 >
    1765 #pragma define_template CopieImage < int_2 , int_2 >
    1766 #pragma define_template CopieImage < int_2 , int_4 >
    1767 #pragma define_template CopieImage < int_2 , r_4 >
    1768 
    1769 #pragma define_template CopieImage < int_4 , uint_2 >
    1770 #pragma define_template CopieImage < int_4 , int_2 >
    1771 #pragma define_template CopieImage < int_4 , int_4 >
    1772 #pragma define_template CopieImage < int_4 , r_4 >
    1773 
    1774 #pragma define_template CopieImage < r_4 , uint_2 >
    1775 #pragma define_template CopieImage < r_4 , int_2 >
    1776 #pragma define_template CopieImage < r_4 , int_4 >
    1777 #pragma define_template CopieImage < r_4 , r_4 >
    1778 
    1779 // CopiePave
    1780 #pragma define_template CopiePave < uint_2 , uint_2 >
    1781 #pragma define_template CopiePave < uint_2 , int_2 >
    1782 #pragma define_template CopiePave < uint_2 , int_4 >
    1783 #pragma define_template CopiePave < uint_2 , r_4 >
    1784 
    1785 #pragma define_template CopiePave < int_2 , uint_2 >
    1786 #pragma define_template CopiePave < int_2 , int_2 >
    1787 #pragma define_template CopiePave < int_2 , int_4 >
    1788 #pragma define_template CopiePave < int_2 , r_4 >
    1789 
    1790 #pragma define_template CopiePave < int_4 , uint_2 >
    1791 #pragma define_template CopiePave < int_4 , int_2 >
    1792 #pragma define_template CopiePave < int_4 , int_4 >
    1793 #pragma define_template CopiePave < int_4 , r_4 >
    1794 
    1795 #pragma define_template CopiePave < r_4 , uint_2 >
    1796 #pragma define_template CopiePave < r_4 , int_2 >
    1797 #pragma define_template CopiePave < r_4 , int_4 >
    1798 #pragma define_template CopiePave < r_4 , r_4 >
    1799 
    1800 //RzCopieImage
    1801 #pragma define_template RzCopieImage < uint_2 >
    1802 #pragma define_template RzCopieImage < int_2 >
    1803 #pragma define_template RzCopieImage < int_4 >
    1804 #pragma define_template RzCopieImage < r_4 >
    1805 
    1806 //RzCopiePave
    1807 #pragma define_template RzCopiePave < uint_2 >
    1808 #pragma define_template RzCopiePave < int_2 >
    1809 #pragma define_template RzCopiePave < int_4 >
    1810 #pragma define_template RzCopiePave < r_4 >
    1811 
    1812 
    1813 #endif
    1814 
    1815 
    1816 #if defined(ANSI_TEMPLATES)
    1817 template class Image<uint_1>;
    1818 template class Image<uint_2>;
    1819 template class Image<int_2>;
    1820 template class Image<int_4>;
    1821 template class Image<r_4>;
    1822 
    1823 #if !defined(__aCC__)     // HP - aCC a du mal avec les fonctions templates
    1824 
    1825 template void CopieImageF<uint_2, uint_2>(Image<uint_2>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1826 template void CopieImageF<uint_2,  int_2>(Image<uint_2>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1827 template void CopieImageF<uint_2,  int_4>(Image<uint_2>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1828 template void CopieImageF<uint_2,    r_4>(Image<uint_2>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1829 template void CopieImageF< int_2, uint_2>(Image< int_2>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1830 template void CopieImageF< int_2,  int_2>(Image< int_2>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1831 template void CopieImageF< int_2,  int_4>(Image< int_2>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1832 template void CopieImageF< int_2,    r_4>(Image< int_2>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1833 template void CopieImageF< int_4, uint_2>(Image< int_4>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1834 template void CopieImageF< int_4,  int_2>(Image< int_4>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1835 template void CopieImageF< int_4,  int_4>(Image< int_4>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1836 template void CopieImageF< int_4,    r_4>(Image< int_4>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1837 template void CopieImageF<   r_4, uint_2>(Image<   r_4>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1838 template void CopieImageF<   r_4,  int_2>(Image<   r_4>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1839 template void CopieImageF<   r_4,  int_4>(Image<   r_4>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1840 template void CopieImageF<   r_4,    r_4>(Image<   r_4>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1841 
    1842 template void CopieImage<uint_2, uint_2>(Image<uint_2>&, Image<uint_2> const&);
    1843 template void CopieImage<uint_2,  int_2>(Image<uint_2>&, Image< int_2> const&);
    1844 template void CopieImage<uint_2,  int_4>(Image<uint_2>&, Image< int_4> const&);
    1845 template void CopieImage<uint_2,    r_4>(Image<uint_2>&, Image<   r_4> const&);
    1846 template void CopieImage< int_2, uint_2>(Image< int_2>&, Image<uint_2> const&);
    1847 template void CopieImage< int_2,  int_2>(Image< int_2>&, Image< int_2> const&);
    1848 template void CopieImage< int_2,  int_4>(Image< int_2>&, Image< int_4> const&);
    1849 template void CopieImage< int_2,    r_4>(Image< int_2>&, Image<   r_4> const&);
    1850 template void CopieImage< int_4, uint_2>(Image< int_4>&, Image<uint_2> const&);
    1851 template void CopieImage< int_4,  int_2>(Image< int_4>&, Image< int_2> const&);
    1852 template void CopieImage< int_4,  int_4>(Image< int_4>&, Image< int_4> const&);
    1853 template void CopieImage< int_4,    r_4>(Image< int_4>&, Image<   r_4> const&);
    1854 template void CopieImage<   r_4, uint_2>(Image<   r_4>&, Image<uint_2> const&);
    1855 template void CopieImage<   r_4,  int_2>(Image<   r_4>&, Image< int_2> const&);
    1856 template void CopieImage<   r_4,  int_4>(Image<   r_4>&, Image< int_4> const&);
    1857 template void CopieImage<   r_4,    r_4>(Image<   r_4>&, Image<   r_4> const&);
    1858 
    1859 template void CopieImage<uint_2, uint_2>(Image<uint_2>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1860 template void CopieImage<uint_2,  int_2>(Image<uint_2>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1861 template void CopieImage<uint_2,  int_4>(Image<uint_2>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1862 template void CopieImage<uint_2,    r_4>(Image<uint_2>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1863 template void CopieImage< int_2, uint_2>(Image< int_2>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1864 template void CopieImage< int_2,  int_2>(Image< int_2>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1865 template void CopieImage< int_2,  int_4>(Image< int_2>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1866 template void CopieImage< int_2,    r_4>(Image< int_2>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1867 template void CopieImage< int_4, uint_2>(Image< int_4>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1868 template void CopieImage< int_4,  int_2>(Image< int_4>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1869 template void CopieImage< int_4,  int_4>(Image< int_4>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1870 template void CopieImage< int_4,    r_4>(Image< int_4>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1871 template void CopieImage<   r_4, uint_2>(Image<   r_4>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1872 template void CopieImage<   r_4,  int_2>(Image<   r_4>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1873 template void CopieImage<   r_4,  int_4>(Image<   r_4>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1874 template void CopieImage<   r_4,    r_4>(Image<   r_4>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1875 
    1876 template void CopiePave<uint_2, uint_2>(Image<uint_2>&, Image<uint_2> const&, float, float, double, double);
    1877 template void CopiePave<uint_2,  int_2>(Image<uint_2>&, Image< int_2> const&, float, float, double, double);
    1878 template void CopiePave<uint_2,  int_4>(Image<uint_2>&, Image< int_4> const&, float, float, double, double);
    1879 template void CopiePave<uint_2,    r_4>(Image<uint_2>&, Image<   r_4> const&, float, float, double, double);
    1880 template void CopiePave< int_2, uint_2>(Image< int_2>&, Image<uint_2> const&, float, float, double, double);
    1881 template void CopiePave< int_2,  int_2>(Image< int_2>&, Image< int_2> const&, float, float, double, double);
    1882 template void CopiePave< int_2,  int_4>(Image< int_2>&, Image< int_4> const&, float, float, double, double);
    1883 template void CopiePave< int_2,    r_4>(Image< int_2>&, Image<   r_4> const&, float, float, double, double);
    1884 template void CopiePave< int_4, uint_2>(Image< int_4>&, Image<uint_2> const&, float, float, double, double);
    1885 template void CopiePave< int_4,  int_2>(Image< int_4>&, Image< int_2> const&, float, float, double, double);
    1886 template void CopiePave< int_4,  int_4>(Image< int_4>&, Image< int_4> const&, float, float, double, double);
    1887 template void CopiePave< int_4,    r_4>(Image< int_4>&, Image<   r_4> const&, float, float, double, double);
    1888 template void CopiePave<   r_4, uint_2>(Image<   r_4>&, Image<uint_2> const&, float, float, double, double);
    1889 template void CopiePave<   r_4,  int_2>(Image<   r_4>&, Image< int_2> const&, float, float, double, double);
    1890 template void CopiePave<   r_4,  int_4>(Image<   r_4>&, Image< int_4> const&, float, float, double, double);
    1891 template void CopiePave<   r_4,    r_4>(Image<   r_4>&, Image<   r_4> const&, float, float, double, double);
    1892 
    1893 
    1894 template void RzCopieImage<uint_2>(Image<uint_2> &, RzImage const &, int, int, int, int, int, int, double, double);
    1895 template void RzCopieImage< int_2>(Image< int_2> &, RzImage const &, int, int, int, int, int, int, double, double);
    1896 template void RzCopieImage< int_4>(Image< int_4> &, RzImage const &, int, int, int, int, int, int, double, double);
    1897 template void RzCopieImage<   r_4>(Image<   r_4> &, RzImage const &, int, int, int, int, int, int, double, double);
    1898 
    1899 template void RzCopieImage<uint_2>(Image<uint_2> &, RzImage const &);
    1900 template void RzCopieImage< int_2>(Image< int_2> &, RzImage const &);
    1901 template void RzCopieImage< int_4>(Image< int_4> &, RzImage const &);
    1902 template void RzCopieImage<   r_4>(Image<   r_4> &, RzImage const &);
    1903 
    1904 template void RzCopiePave<uint_2>(Image<uint_2> &, RzImage const &, float, float, double, double);
    1905 template void RzCopiePave< int_2>(Image< int_2> &, RzImage const &, float, float, double, double);
    1906 template void RzCopiePave< int_4>(Image< int_4> &, RzImage const &, float, float, double, double);
    1907 template void RzCopiePave<   r_4>(Image<   r_4> &, RzImage const &, float, float, double, double);
    1908 
    1909 #endif   // Pb avec HP aCC
    1910 
    1911 #endif
    1912 
    1913 
    1914 #ifdef __GNU_TEMPLATES__
    1915 template class Image<bool>;
    1916 template class Image<uint_1>;
    1917 template class Image<uint_2>;
    1918 template class Image<int_2>;
    1919 template class Image<int_4>;
    1920 template class Image<r_4>;
    1921 
    1922 
    1923 template void CopieImageF(Image<uint_2>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1924 template void CopieImageF(Image<uint_2>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1925 template void CopieImageF(Image<uint_2>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1926 template void CopieImageF(Image<uint_2>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1927 template void CopieImageF(Image< int_2>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1928 template void CopieImageF(Image< int_2>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1929 template void CopieImageF(Image< int_2>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1930 template void CopieImageF(Image< int_2>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1931 template void CopieImageF(Image< int_4>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1932 template void CopieImageF(Image< int_4>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1933 template void CopieImageF(Image< int_4>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1934 template void CopieImageF(Image< int_4>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1935 template void CopieImageF(Image<   r_4>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1936 template void CopieImageF(Image<   r_4>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1937 template void CopieImageF(Image<   r_4>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1938 template void CopieImageF(Image<   r_4>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1939 
    1940 template void CopieImage(Image<uint_2>&, Image<uint_2> const&);
    1941 template void CopieImage(Image<uint_2>&, Image< int_2> const&);
    1942 template void CopieImage(Image<uint_2>&, Image< int_4> const&);
    1943 template void CopieImage(Image<uint_2>&, Image<   r_4> const&);
    1944 template void CopieImage(Image< int_2>&, Image<uint_2> const&);
    1945 template void CopieImage(Image< int_2>&, Image< int_2> const&);
    1946 template void CopieImage(Image< int_2>&, Image< int_4> const&);
    1947 template void CopieImage(Image< int_2>&, Image<   r_4> const&);
    1948 template void CopieImage(Image< int_4>&, Image<uint_2> const&);
    1949 template void CopieImage(Image< int_4>&, Image< int_2> const&);
    1950 template void CopieImage(Image< int_4>&, Image< int_4> const&);
    1951 template void CopieImage(Image< int_4>&, Image<   r_4> const&);
    1952 template void CopieImage(Image<   r_4>&, Image<uint_2> const&);
    1953 template void CopieImage(Image<   r_4>&, Image< int_2> const&);
    1954 template void CopieImage(Image<   r_4>&, Image< int_4> const&);
    1955 template void CopieImage(Image<   r_4>&, Image<   r_4> const&);
    1956 
    1957 template void CopieImage(Image<uint_2>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1958 template void CopieImage(Image<uint_2>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1959 template void CopieImage(Image<uint_2>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1960 template void CopieImage(Image<uint_2>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1961 template void CopieImage(Image< int_2>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1962 template void CopieImage(Image< int_2>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1963 template void CopieImage(Image< int_2>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1964 template void CopieImage(Image< int_2>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1965 template void CopieImage(Image< int_4>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1966 template void CopieImage(Image< int_4>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1967 template void CopieImage(Image< int_4>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1968 template void CopieImage(Image< int_4>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1969 template void CopieImage(Image<   r_4>&, Image<uint_2> const&, int, int, int, int, int, int, double, double);
    1970 template void CopieImage(Image<   r_4>&, Image< int_2> const&, int, int, int, int, int, int, double, double);
    1971 template void CopieImage(Image<   r_4>&, Image< int_4> const&, int, int, int, int, int, int, double, double);
    1972 template void CopieImage(Image<   r_4>&, Image<   r_4> const&, int, int, int, int, int, int, double, double);
    1973 
    1974 template void CopiePave(Image<uint_2>&, Image<uint_2> const&, float, float, double, double);
    1975 template void CopiePave(Image<uint_2>&, Image< int_2> const&, float, float, double, double);
    1976 template void CopiePave(Image<uint_2>&, Image< int_4> const&, float, float, double, double);
    1977 template void CopiePave(Image<uint_2>&, Image<   r_4> const&, float, float, double, double);
    1978 template void CopiePave(Image< int_2>&, Image<uint_2> const&, float, float, double, double);
    1979 template void CopiePave(Image< int_2>&, Image< int_2> const&, float, float, double, double);
    1980 template void CopiePave(Image< int_2>&, Image< int_4> const&, float, float, double, double);
    1981 template void CopiePave(Image< int_2>&, Image<   r_4> const&, float, float, double, double);
    1982 template void CopiePave(Image< int_4>&, Image<uint_2> const&, float, float, double, double);
    1983 template void CopiePave(Image< int_4>&, Image< int_2> const&, float, float, double, double);
    1984 template void CopiePave(Image< int_4>&, Image< int_4> const&, float, float, double, double);
    1985 template void CopiePave(Image< int_4>&, Image<   r_4> const&, float, float, double, double);
    1986 template void CopiePave(Image<   r_4>&, Image<uint_2> const&, float, float, double, double);
    1987 template void CopiePave(Image<   r_4>&, Image< int_2> const&, float, float, double, double);
    1988 template void CopiePave(Image<   r_4>&, Image< int_4> const&, float, float, double, double);
    1989 template void CopiePave(Image<   r_4>&, Image<   r_4> const&, float, float, double, double);
    1990 
    1991 
    1992 template void RzCopieImage(Image<uint_2> &, RzImage const &, int, int, int, int, int, int, double, double);
    1993 template void RzCopieImage(Image< int_2> &, RzImage const &, int, int, int, int, int, int, double, double);
    1994 template void RzCopieImage(Image< int_4> &, RzImage const &, int, int, int, int, int, int, double, double);
    1995 template void RzCopieImage(Image<   r_4> &, RzImage const &, int, int, int, int, int, int, double, double);
    1996 
    1997 template void RzCopieImage(Image<uint_2> &, RzImage const &);
    1998 template void RzCopieImage(Image< int_2> &, RzImage const &);
    1999 template void RzCopieImage(Image< int_4> &, RzImage const &);
    2000 template void RzCopieImage(Image<   r_4> &, RzImage const &);
    2001 
    2002 template void RzCopiePave(Image<uint_2> &, RzImage const &, float, float, double, double);
    2003 template void RzCopiePave(Image< int_2> &, RzImage const &, float, float, double, double);
    2004 template void RzCopiePave(Image< int_4> &, RzImage const &, float, float, double, double);
    2005 template void RzCopiePave(Image<   r_4> &, RzImage const &, float, float, double, double);
    2006 
    2007 #endif
    2008 

  • trunk/SophyaLib/NTools/cimage.h

    r896 r1104  
    11// This may look like C code, but it is really -*- C++ -*-
    2 //  Classes image typee      E.Aubourg , E. Lesquoy     
    3 //                           Modifs R. Ansari   04/95
    4 
     2//  Classes image heritant de TMatrix<T>
     3//                       R.Ansari, C.Magneville 07/2000   
    54// LAL (Orsay) / IN2P3-CNRS  DAPNIA/SPP (Saclay) / CEA
    65
    … …  
    87#define CIMAGE_SEEN
    98
    10 #include <iostream.h>
    11 #include <iomanip.h>
    12 #include "rzimage.h"
    13 
    14 // Flags de verifications sur les indices  dans rzimage.h
    15 
    16 //#define IMGRGCHECK
    17 //#define IMGVOIDCHECK
     9#include "tmatrix.h"
    1810
    1911
    … …  
    2113// Classe Image
    2214
     15namespace SOPHYA {
    2316
    2417template <class T>
    25 class Image : public RzImage {
     18class Image : public TMatrix<T> {
    2619
    2720public:
    28   Image(int sizx, int sizy, int zero=1);
    2921  Image();
    30   Image(const Image<T>&, int sharePixels=0);
    31   Image(const Image<T>&, int orgx, int orgy, int sizx=-1, int sizy=-1);
    32   EXPLICIT Image(const RzImage&); // Pour Reza. Partage les pixels
    33   Image(char *flnm);
     22  Image(uint_4 sizx, uint_4 sizy, r_8 szpx=1., r_8 szpy=1., r_8 orgx=0., r_8 orgy=0.);
     23  Image(const Image<T>& a);
     24  Image(const Image<T>& a, bool share);
     25
    3426  virtual ~Image();
    3527
    36   static PPersist*      Create()              { return new Image<T>;}
     28  // Inline element acces methods
     29  inline T const& operator()(uint_4 ix,uint_4 jy) const;
     30  inline T&       operator()(uint_4 ix,uint_4 jy);
    3731
    38   virtual void    ReadSelf(PInPersist&);
     32  inline uint_4  XSize() const {return NCols();}
     33  inline uint_4  YSize() const {return NRows();}
    3934
    40   Image<T>&       operator= (const Image<T> &);
    41   Image<T>&       operator= (T);
     35  inline r_8     XOrg() const {return org_x;}
     36  inline r_8     YOrg() const {return org_y;}
    4237
    43   Image<T>&       operator+= (Image<T> const&);
    44   Image<T>&       operator-= (Image<T> const&);
    45   Image<T>&       operator*= (Image<T> const&);
    46   Image<T>&       operator/= (Image<T> const&);
     38  inline r_8     XPixSize() const {return pxsz_x;}
     39  inline r_8     YPixSize() const {return pxsz_y;}
    4740
    48   Image<T>&       operator+= (double);
    49   Image<T>&       operator-= (double);
    50   Image<T>&       operator*= (double);
    51   Image<T>&       operator/= (double);
    52 
    53   Image<T>        WhereNonZero();
    54 
    55 
    56 //   Impression de tout le contenu de l'image
    57   virtual void    PrintImage(ostream& os) const;
    58   inline void     PrintImage() const  { PrintImage(cout); }
    59 
    60   void            Zero();
    61   void            Allocate(int sizx, int sizy, int zero=1, ImgVectP* pvpsh=NULL);
    62 
    63   inline T&       operator() (int x, int y);
    64   inline T        operator() (int x, int y) const;
    65   inline T&       operator[] (int i);
    66   inline T        operator[] (int i) const;
    67   T*              ImagePtr()         {return imagePtr;}
    68   const T*        ImagePtr() const   {return imagePtr;}
    69                                            
    70   int             CheckDyn(double min=-9.e19, double max=9.e19);
    71 
    72   void            SeuilBas(double seuil, double val);
    73   void            SeuilHaut(double seuil, double val);
    74   void            SeuilBas(double seuil);
    75   void            SeuilHaut(double seuil);
    76   void            SetPixels(int szx, int szy, T* pim);
    77 
    78   int EstimeFdSg(float& xbmax,float& sgbmax,float nbsig=3.5,float frac=0.33
    79                 ,float lowbad=1.,float highbad=-1.,int deb=0);
    80   float FondCiel(int nbin,float bin_low,float bin_high
    81                 ,int degre=2,float frac=0.5f,int modu=1,int deb=0);
    82   float SigmaCiel(int nbin,float bin_low,float bin_high,float& means
    83                  ,float lowbad=1.,float highbad=-1.
    84                  ,float nsig=4.f,int modu=1,int deb=0);
    85   int   MoySigma(float& mean,float& sigma
    86                 ,float lowbad=1.,float highbad=-1.,int modu=1);
    87   int   MoySigmaIter(float& mean,float& sigma,float lowbad=1.,float highbad=-1.
    88                     ,int modu=1,int nitermx=10
    89                     ,float perdiff=0.1f,float scut=3.5f, int deb=0);
    90   int   FondSigmaCiel(float lowbad,float highbad,int pvsz=100
    91               ,float nbsig1=3.5f,float nbsig2=7.f,float nbsig3=5.f
    92               ,float binsg=0.5f,float frac=0.33f,int modu=1,int deb=0);
    93 
     41  inline void    SetOrg(r_8 orgx=0., r_8 orgy=0.)
     42                       { org_x = orgx;  org_y = orgy; } 
     43  inline void    SetPixelSize(r_8 szx=1., r_8 szy=1.)
     44                       { pxsz_x = szx;   pxsz_y = szy; }
    9445
    9546protected:
    96 
    97   void HBinInt(int& nbin,float& xmin,float& xmax);
    98 
    99   T*              imagePtr;
     47  r_8   org_x,org_y;        //  Coordonnees pixel(0,0)
     48  r_8   pxsz_x, pxsz_y;     //  Taille des pixels
    10049};
    10150
    102 // Definition de l'operateur <<
    103 //template <class T>
    104 //ostream& operator << (ostream& s, Image<T> const& img)
    105 //  {  img.Print(s);  return(s);  }
    106 
    107 
    108 /*  .......................................................  */
    109 /*          Implementation inline des acces pixels           */
    110 /*  .......................................................  */
    111 
    112 // ----- Macro de verification des indices  ------
    113 
    114 #ifdef IMGRGCHECK
    115 #define CHECKIMG(_x_,_y_)                                  \
    116       if ((_x_ >= siz_x) || (_y_ >= siz_y) ||              \
    117           (_x_ < 0) || (_y_ < 0)) THROW(rangeCheckErr);  \
    118       if (!imagePtr) THROW(nullPtrErr)
    119 #else
    120 #if defined(IMGVOIDCHECK)
    121 #define CHECKIMG(_x_,_y_) \
    122       if (!imagePtr) THROW(NullPtrErr)
    123 #else
    124 #define CHECKIMG(_x_,_y_)
    125 #endif
    126 #endif /* IMGRGCHECK */
    127 
    128 #define INRANGE(_x_,_y_) ((_x_ < siz_x) && (_y_ < siz_y) && \
    129                           (_x_ >= 0) && (_y_ >= 0))
    130 
    131 
    132 // Fin des macros  ------
    133 
    134 
    13551template <class T>
    136 inline T & Image<T>::operator() (int x, int y)
     52inline T const& Image<T>::operator()(uint_4 ix, uint_4 jy) const
    13753{
    138   CHECKIMG(x,y);
    139   return imagePtr[x+y*siz_x];
     54  return (TMatrix<T>::operator() (jy, ix));
    14055}
    14156
    14257template <class T>
    143 inline T Image<T>::operator() (int x, int y) const
     58inline T & Image<T>::operator()(uint_4 ix, uint_4 jy)
    14459{
    145   CHECKIMG(x,y);
    146   return imagePtr[x+y*siz_x];
    147 }
    148 
    149 template <class T>
    150 inline T & Image<T>::operator[] (int i)
    151 {
    152   CHECKIMG(0,0);
    153   return imagePtr[i];
    154 }
    155 
    156 template <class T>
    157 inline T Image<T>::operator[] (int i) const
    158 {
    159   CHECKIMG(0,0);
    160   return imagePtr[i];
    161 }
    162 
    163 // Operateurs addition, multiplication, ... (+ - * / ) avec des doubles
    164 
    165 template <class T>
    166 Image<T> operator+ (Image<T> const& a, double b)
    167 {
    168   Image<T> c(a);
    169   c += b;
    170   return c;
    171 }
    172 
    173 template <class T>
    174 Image<T> operator- (Image<T> const& a, double b)
    175 {
    176   Image<T> c(a);
    177   c -= b;
    178   return c;
    179 }
    180 
    181 template <class T>
    182 Image<T> operator* (Image<T> const& a, double b)
    183 {
    184   Image<T> c(a);
    185   c *= b;
    186   return c;
    187 }
    188 
    189 template <class T>
    190 Image<T> operator/ (Image<T> const& a, double b)
    191 {
    192   Image<T> c(a);
    193   c /= b;
    194   return c;
    195 }
    196 
    197 // Operateurs addition, multiplication, ... (+ - * / ) entre images
    198 template <class T>
    199 Image<T> operator+ (Image<T> const& a, Image<T> const& b)
    200 {
    201   Image<T> c(a);
    202   c += b;
    203   return c;
    204 }
    205 
    206 template <class T>
    207 Image<T> operator- (Image<T> const& a, Image<T> const& b)
    208 {
    209   Image<T> c(a);
    210   c -= b;
    211   return c;
    212 }
    213 
    214 template <class T>
    215 Image<T> operator* (Image<T> const& a, Image<T> const& b)
    216 {
    217   Image<T> c(a);
    218   c *= b;
    219   return c;
    220 }
    221 
    222 template <class T>
    223 Image<T> operator/ (Image<T> const& a, Image<T> const& b)
    224 {
    225   Image<T> c(a);
    226   c /= b;
    227   return c;
     60  return (TMatrix<T>::operator() (jy, ix));
    22861}
    22962
    23063
    231 /*  .......................................................  */
    232 /*         Fonctions de copie d'images et de paves           */
    233 /*  .......................................................  */
    234 
    235 template <class T2, class T1>
    236 void CopieImageF(Image<T2>& copie, Image<T1> const& pim,
    237                  int org_pim_x=0, int org_pim_y=0,
    238                  int pim_lpav_x=0, int pim_lpav_y=0,
    239                  int org_copie_x=0, int org_copie_y=0,
    240                  double cutmin=0., double cutmax=0.);
    241                
    242 template <class T2, class T1>
    243 void CopieImage(Image<T2>& copie, Image<T1> const& pim);
    244 
    245 template <class T2, class T1>
    246 void CopieImage(Image<T2>& copie, Image<T1> const& pim,
    247                 int org_pim_x, int org_pim_y,
    248                 int pim_lpav_x=0, int pim_lpav_y=0,
    249                 int org_copie_x=0, int org_copie_y=0,
    250                 double cutmin=0, double cutmax=0);
    251 
    252 
    253 template <class T2, class T1>
    254 void
    255 CopiePave(Image<T2>& pave, Image<T1> const& pim,
    256           float xc, float yc,
    257           double cutmin=0, double cutmax=0);
    258 
    259 
    260 template <class T>
    261 void
    262 RzCopieImage(Image<T>& copie, RzImage const& pim,
    263              int org_pim_x, int org_pim_y,
    264              int pim_lpav_x=0, int pim_lpav_y=0,
    265              int org_copie_x=0, int org_copie_y=0,
    266              double cutmin=0, double cutmax=0);
    267 
    268 template <class T>
    269 void
    270 RzCopieImage(Image<T>& copie, RzImage const& pim);
    271 
    272 template <class T>
    273 void
    274 RzCopiePave(Image<T> & pave, RzImage const & pim,
    275             float xc, float yc,
    276             double cutmin=0, double cutmax=0);
    277 /*  .......................................................  */
    278 /*         Autres fonctions utilitaires pour RzImage         */
    279 /*  .......................................................  */
    280 
    281 void RzPrintImage(RzImage & img);
    282 
    283 /*  Images de types usuels   */
    284 
    285 typedef Image<uint_1> ImageU1;
    28664typedef Image<uint_2> ImageU2;
    287 typedef Image<int_2>  ImageI2;
    28865typedef Image<int_4>  ImageI4;
    28966typedef Image<r_4>    ImageR4;
     67typedef Image<r_8>    ImageR8;
    29068
     69class GeneralFit;
     70class RzImage {
     71public:
     72  RzImage() { }
     73  ~RzImage() { }
     74  inline uint_4  XSize() const {return 0;}
     75  inline uint_4  YSize() const {return 0;}
    29176
    292 #ifdef __MWERKS__
    293 template <class T>
    294 ostream& operator << (ostream& s, Image<T> const& pim);
    295 #endif
     77  inline r_8     XOrg() const {return 0;}
     78  inline r_8     YOrg() const {return 0;}
    29679
     80  inline r_8     XPixSize() const {return 1.;}
     81  inline r_8     YPixSize() const {return 1.;}
     82  inline r_8     DValue(int i, int j) const { return 0.; }
     83  // Resultats d'un GeneralFit
     84  inline RzImage*      FitResidus(GeneralFit& gfit) { return NULL; }
     85  inline RzImage*      FitFunction(GeneralFit& gfit) { return NULL; }
     86
     87};
     88
     89}  // End of namespace SOPHYA
    29790
    29891#endif

  • trunk/SophyaLib/NTools/dynccd.cc

    r270 r1104  
    4646//--
    4747//++
    48 // DynCCD(int TypNoise=0, float MinADU=-9.e19, float MaxADU=9.e19, float Gain=1., float RONoise=0., float RefFond=0., float RefSFond=0.);
     48// 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.);
    4949//      Creation d'un objet DynCCD ("typ" determine la methode de calcul du bruit)
    5050//      |Test verbatim
    5151//
    52 // 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.);
     52// 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.);
    5353//      Modification des parametres de la dynamique
    5454// void Print()
    55 // float Noise(float pixel) const
     55// r_8 Noise(r_8 pixel) const
    5656//      Renvoie la valeur du bruit pour "pixel" en ADU.
    5757//--
    … …  
    6262
    6363/* --Methode-- */
    64 DynCCD::DynCCD(int typ, float min, float max, float g,
    65                float ron, float rf, float rfs)
     64DynCCD::DynCCD(int_4 typ, r_8 min, r_8 max, r_8 g,
     65               r_8 ron, r_8 rf, r_8 rfs)
    6666{
    6767if ( (typ >= kConstantNoise) && (typ <= kSqrtADUNoise) )  TypNoise = typ;
    … …  
    7373
    7474/* --Methode-- */
    75 void DynCCD::Set(int typ, float min, float max, float g,
    76                float ron, float rf, float rfs)
     75void DynCCD::Set(int_4 typ, r_8 min, r_8 max, r_8 g,
     76               r_8 ron, r_8 rf, r_8 rfs)
    7777{
    7878if ( (typ >= kConstantNoise) && (typ <= kSqrtADUNoise) )  TypNoise = typ;
    … …  
    9393
    9494/* --Methode-- */
    95 float DynCCD::Noise(float pixel) const
     95r_8 DynCCD::Noise(r_8 pixel) const
    9696
    9797/* Cette fonction calcule la valeur du bruit pour pixel     */
    … …  
    108108
    109109{
    110 float h,s,ronsq;
    111 float fond;
     110r_8 h,s,ronsq;
     111r_8 fond;
    112112
    113113if ( (pixel > MaxADU) || (pixel < MinADU) )   return(0.);
    … …  
    122122  ronsq = RONoise/Gain;  ronsq *= ronsq; }
    123123
    124 h = (pixel>fond) ? (float)(pixel-fond) : 0.;
     124h = (pixel>fond) ? (r_8)(pixel-fond) : 0.;
    125125s = ronsq+h/Gain;
    126126s = fsqrt(s);
    … …  
    161161/* Nouvelle-Fonction */
    162162template <class T>
    163 Image<T> * NoiseImage(Image<T> const * pim, DynCCD const * dynccd)
     163Image<T>  NoiseImage(Image<T> const & pim, DynCCD const & dynccd)
    164164
    165165/* Creation et Calcul d'une image de bruit a partir de l'image */
    … …  
    168168
    169169{
    170 float h,s,ronsq;
    171 float fond, min,max;
    172 int i, npix;
    173 float minois, offnois;
    174 
    175 if (pim == NULL)  return(NULL);
    176 
    177 const T * pix = pim->ImagePtr();
    178 npix = pim->XSize()*pim->YSize();
    179 Image<T> * nois = new Image<T>(pim->XSize(), pim->YSize(), false);
    180 nois->SetOrg(pim->XOrg(), pim->YOrg());
    181 T * pno = nois->ImagePtr();
    182 
    183 min = dynccd->MinADU;   max = dynccd->MaxADU;
    184 
    185 
    186 switch (dynccd->TypNoise)
    187   {
    188   case kConstantNoise :
    189     for(i=0; i<npix; i++)
    190       {
    191       if ( (*pix <= max) && (*pix >= min) )  *pno = 1;
    192       else *pno = 0;
    193       pix++;   pno++;
    194       }
    195     break;
    196 
    197   case kSqrtADUNoise :
    198     for(i=0; i<npix; i++)
    199       {
    200       if ( (*pix <= max) && (*pix >= min) )  *pno = 1;
    201       else *pno = (T) fsqrt(fabsf((float)(*pix)));   
    202       pix++;   pno++;
    203       }
    204     break;
    205 
    206   case kPhotonNoise :
    207   case kSigFondNoise :
    208     if ( dynccd->TypNoise == kSigFondNoise)
    209       { fond = dynccd->RefFond;
    210       ronsq = dynccd->RefSFond * dynccd->RefSFond; }
    211     else
    212       { fond = 0;
    213       ronsq = dynccd->RONoise/dynccd->Gain;  ronsq *= ronsq; }
    214 
    215 // Calcul de minois / offnois pour obtenir un bruit correct malgre
    216 // les conversions (float) -> (entier)
    217 
    218     switch(pim->PixelType())
    219       {
    220       case kuint_2:
    221       case kint_2:
    222       case kint_4:
    223         minois = 1.001;
    224         offnois = 0.5;
    225         break;
    226       case kr_4:
    227       case kr_8:
    228         minois = 1.e-9;
    229         offnois = 0.;
    230         break;
    231       default:
    232         minois = 1.e-9;
    233         offnois = 0.;
    234         break;
    235       }
    236 
    237     for(i=0; i<npix; i++)
    238       {
    239       if ( (*pix <= max) && (*pix >= min) )
    240         {
    241         h = (*pix>fond) ? (float)(*pix)-fond : 0.;
    242         s = ronsq+h/dynccd->Gain;
    243         s = fsqrt(s)+offnois;
    244         *pno = (s > minois) ? (T)s : (T)minois;
    245         }
    246       else *pno = 0;
    247       pix++;   pno++;
    248       }
    249     break;
    250   }
     170r_8 h,s,ronsq;
     171r_8 fond, min,max;
     172int_4 k, npix;
     173r_8 minois, offnois;
     174
     175npix = pim.XSize()*pim.YSize();
     176Image<T> nois(pim.XSize(), pim.YSize());
     177nois.SetOrg(pim.XOrg(), pim.YOrg());
     178
     179min = dynccd.MinADU;   max = dynccd.MaxADU;
     180for(k=0; k<npix; k++)      {
     181  if ( (pim[k] <= max) && (pim[k] >= min) )  nois[k] = (T)1;
     182  else nois[k] = 0;
     183}
     184
    251185
    252186return(nois);
    … …  
    258192void ImgAddNoise(Image<T>& img, DynCCD const& dyn)
    259193{
    260         T* p = img.ImagePtr();
    261         int nPix = img.XSize() * img.YSize();
     194  int_4 nPix = img.XSize() * img.YSize();
    262195       
    263         for (int i=0; i<nPix; i++, p++)
    264                 *p += (T) (dyn.Noise(*p)*NorRand());
    265 }
    266 
    267 
    268 
    269 /* Nouvelle-Fonction */
    270 RzImage * NoiseImage(RzImage const * pim, DynCCD const * dynccd)
    271 
    272 /* Creation et Calcul d'une image de bruit a partir de l'image */
    273 /* pim et de dynccd. Voir la methode DynCCD::Noise() pour la   */
    274 /* description du calcul                                       */
    275 {
    276 RzImage * nois = NULL;
    277 
    278 switch (pim->PixelType())
    279   {
    280   case kuint_2:
    281     {
    282     ImageU2 pix((RzImage&)(*pim));
    283     nois = NoiseImage(&pix, dynccd);
    284     break;
    285     }
    286   case kint_2:
    287     {
    288     ImageI2 pix((RzImage&)(*pim));
    289     nois = NoiseImage(&pix, dynccd);
    290     break;
    291     }
    292   case kint_4:
    293     {
    294     ImageI4 pix((RzImage&)(*pim));
    295     nois = NoiseImage(&pix, dynccd);
    296     break;
    297     }
    298   case kr_4:
    299     {
    300     ImageR4 pix((RzImage&)(*pim));
    301     nois = NoiseImage(&pix, dynccd);
    302     break;
    303     } 
    304   case kuint_4:
    305   case kr_8:
    306     cerr << "NoiseImage(RzImage, ...) Unsupported image type (kuint_4/kr_8) "
    307          << int(pim->PixelType()) << "\n" ;
    308     break;
    309   default:
    310     cerr << "NoiseImage(RzImage, ...) Unknown image type !! " << int(pim->PixelType()) << "\n" ;
    311     break;
    312   }   
    313 
    314 return(nois);
    315 }
    316 
    317 
    318 // ******** INSTANCES
    319 
    320 #if defined(__xlC) || defined(__aCC__)
    321 void instancetempdynccd(int n)
    322 {
    323 /* Cette fonction sert uniquement a forcer le compilo a instancier les
    324   classes/fonctions template   */
    325 
    326 ImageU2  iu2(n,n), *piu2;
    327 ImageI2  ii2(n,n), *pii2;
    328 ImageI4  ii4(n,n), *pii4;
    329 ImageR4  ir4(n,n), *pir4;
    330 DynCCD dyn(1,0.,65000., 4., 20.);
    331 
    332 piu2 = NoiseImage(&iu2, &dyn);
    333 pii2 = NoiseImage(&ii2, &dyn);
    334 pii4 = NoiseImage(&ii4, &dyn);
    335 pir4 = NoiseImage(&ir4, &dyn);
    336 
    337 ImgAddNoise(*piu2, dyn);
    338 ImgAddNoise(*pii2, dyn);
    339 ImgAddNoise(*pii4, dyn);
    340 ImgAddNoise(*pir4, dyn);
    341 
    342 return;
    343 }
    344 #endif
     196  for (int_4 i=0; i<nPix; i++)
     197    img[i] += (T) (dyn.Noise(img[i])*NorRand());
     198}
     199
     200
     201
    345202
    346203
    … …  
    348205
    349206#pragma define_template NoiseImage<uint_2>
    350 #pragma define_template NoiseImage<int_2>
    351207#pragma define_template NoiseImage<int_4>
    352208#pragma define_template NoiseImage<r_4>
    353209
    354210#pragma define_template ImgAddNoise<uint_2>
    355 #pragma define_template ImgAddNoise<int_2>
    356211#pragma define_template ImgAddNoise<int_4>
    357212#pragma define_template ImgAddNoise<r_4>
    … …  
    360215
    361216
    362 #if ( defined(ANSI_TEMPLATES) && !defined(__aCC__) )
     217#if defined(ANSI_TEMPLATES)
    363218template Image<uint_2> * NoiseImage<uint_2>(Image<uint_2> const * , DynCCD const *);
    364 template Image< int_2> * NoiseImage< int_2>(Image< int_2> const * , DynCCD const *);
    365219template Image< int_4> * NoiseImage< int_4>(Image< int_4> const * , DynCCD const *);
    366220template Image<   r_4> * NoiseImage<   r_4>(Image<   r_4> const * , DynCCD const *);
    367221
    368222template void ImgAddNoise<uint_2>(Image<uint_2>&, DynCCD const&);
    369 template void ImgAddNoise< int_2>(Image< int_2>&, DynCCD const&);
    370223template void ImgAddNoise< int_4>(Image< int_4>&, DynCCD const&);
    371224template void ImgAddNoise<   r_4>(Image<   r_4>&, DynCCD const&);
    … …  
    375228#if defined(__GNU_TEMPLATES__)
    376229template Image<uint_2> * NoiseImage(Image<uint_2> const *, DynCCD const *);
    377 template Image< int_2> * NoiseImage(Image< int_2> const *, DynCCD const *);
    378230template Image< int_4> * NoiseImage(Image< int_4> const *, DynCCD const *);
    379231template Image<   r_4> * NoiseImage(Image<   r_4> const *, DynCCD const *);
    380232
    381233template void ImgAddNoise(Image<uint_2>&, DynCCD const&);
    382 template void ImgAddNoise(Image< int_2>&, DynCCD const&);
    383234template void ImgAddNoise(Image< int_4>&, DynCCD const&);
    384235template void ImgAddNoise(Image<   r_4>&, DynCCD const&);

  • trunk/SophyaLib/NTools/dynccd.h

    r896 r1104  
    66#include "machdefs.h"
    77#include "pexceptions.h"
     8#include "cimage.h"
    89#include "ppersist.h"
    910
    … …  
    1718
    1819  int_4 TypNoise;        // Type de calcul du bruit
    19   float MinADU,MaxADU;   // Valeur min et max des pixels
    20   float Gain;            // Gain en electron/ADU
    21   float RONoise;         // Bruit de lecture en electron 
    22   float RefFond;         // Fond de ciel de ref (TypNoise=2)
    23   float RefSFond;        // Sigma du fond  (TypNoise=2) */
     20  r_8 MinADU,MaxADU;   // Valeur min et max des pixels
     21  r_8 Gain;            // Gain en electron/ADU
     22  r_8 RONoise;         // Bruit de lecture en electron 
     23  r_8 RefFond;         // Fond de ciel de ref (TypNoise=2)
     24  r_8 RefSFond;        // Sigma du fond  (TypNoise=2) */
    2425
    2526/*    ===>  Les methodes   */
    26   DynCCD(int typ=0, float min=-9.e19, float max=9.e19,
    27          float g=1., float ron=0., float rf=0., float rfs=0.);
     27  DynCCD(int_4 typ=0, r_8 min=-9.e19, r_8 max=9.e19,
     28         r_8 g=1., r_8 ron=0., r_8 rf=0., r_8 rfs=0.);
    2829
    29   void Set(int typ=0, float min=-9.e19, float max=9.e19,
    30          float g=1., float ron=0., float rf=0., float rfs=0.);
     30  void Set(int_4 typ=0, r_8 min=-9.e19, r_8 max=9.e19,
     31         r_8 g=1., r_8 ron=0., r_8 rf=0., r_8 rfs=0.);
    3132  void Print();
    32   float Noise(float pixel) const;
     33  r_8 Noise(r_8 pixel) const;
    3334};
    3435
    3536} // Fin du namespace
    3637
    37 // Quelques fonctions pour manipuler des images de bruit
    38 
    39 class RzImage;
    40 RzImage * NoiseImage(RzImage const *pim, DynCCD const * dynccd);
    41 
    42 template <class T> class Image;
    4338
    4439template <class T>
    45 Image<T> * NoiseImage(Image<T> const * pim, DynCCD const * dynccd);
     40Image<T> NoiseImage(Image<T> const & pim, DynCCD const & dynccd);
    4641
    4742template <class T>
    … …  
    5348{
    5449  c.PutI4(data.TypNoise);
    55   c.PutR4s(&data.MinADU, 6);
     50  c.PutR8s(&data.MinADU, 6);
    5651  return c;
    5752}
    … …  
    6156{
    6257  c.GetI4(data.TypNoise);
    63   c.GetR4s(&data.MinADU, 6);
     58  c.GetR8s(&data.MinADU, 6);
    6459  return c;
    6560}
    6661
    67 //STRUCTPERSISTIO(DynCCD, TypNoise, sizeof(int_4)+6*sizeof(float))
     62
    6863
    6964

  • trunk/SophyaLib/NTools/exclude

    r750 r1104  
    1 
     1imageop.cc

  • trunk/SophyaLib/NTools/ntoolsinit.cc

    r1069 r1104  
    4141  DObjRegister(ObjFileIO<GeneralFitData>, GeneralFitData);
    4242
    43   PPRegister(RzImage);
    44   PPRegister(ImageU2);
    45   PPRegister(ImageI2);
    46   PPRegister(ImageI4);
    47   PPRegister(ImageR4);
    48 
     43  DObjRegister(FIO_TArray<uint_2>, Image<uint_2>);
     44  DObjRegister(FIO_TArray<int_4>, Image<int_4>);
     45  DObjRegister(FIO_TArray<r_4>, Image<r_4>);
    4946
    5047
Note: See TracChangeset for help on using the changeset viewer.