Changeset 307 in Sophya for trunk/SophyaLib/NTools/histos2.cc


Ignore:
Timestamp:
May 19, 1999, 5:58:06 PM (26 years ago)
Author:
ansari
Message:

FIO_... + grosses modifs cmv 19/5/99

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/SophyaLib/NTools/histos2.cc

    r244 r307  
    1616#include "generalfit.h"
    1717
     18using namespace PlanckDPC;
     19
    1820//++
    1921// Class        Histo2D
     
    132134for(int i=0;i<3;i++) for(int j=0;j<3;j++) over[i][j]=0.;
    133135b_s.H = NULL;
    134 END_CONSTRUCTOR
    135 }
    136 
    137 //++
    138 Histo2D::Histo2D(char *flnm)
    139 //
    140 //      Constructeur par lecture d'un fichier ppersist.
    141 //--
    142       : data(NULL), err2(NULL)
    143       , nHist(0), nEntries(0)
    144       , nx(0), ny(0), nxy(0)
    145       , xmin(0), xmax(0), ymin(0), ymax(0)
    146       , wbinx(0), wbiny(0)
    147       , hprojx(NULL), hprojy(NULL)
    148 {
    149 b_s.H = NULL;
    150 PInPersist s(flnm);
    151 Read(s);
    152136END_CONSTRUCTOR
    153137}
     
    582566//--
    583567{
    584 if (b.nx!=a.nx || b.ny!=a.ny) THROW(sizeMismatchErr);
     568if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
    585569Histo2D c(a);
    586570return (c += b);
     
    592576//--
    593577{
    594 if (b.nx!=a.nx || b.ny!=a.ny) THROW(sizeMismatchErr);
     578if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
    595579Histo2D c(a);
    596580return (c -= b);
     
    602586//--
    603587{
    604 if (b.nx!=a.nx || b.ny!=a.ny) THROW(sizeMismatchErr);
     588if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
    605589Histo2D c(a);
    606590return (c *= b);
     
    612596//--
    613597{
    614 if (b.nx!=a.nx || b.ny!=a.ny) THROW(sizeMismatchErr);
     598if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
    615599Histo2D c(a);
    616600return (c /= b);
     
    11131097
    11141098//++
    1115 Histo2D* Histo2D::FitResidus(GeneralFit& gfit)
     1099Histo2D Histo2D::FitResidus(GeneralFit& gfit)
    11161100//
    11171101//      Retourne une classe contenant les residus du fit ``gfit''.
    11181102//--
    11191103{
    1120 if(NBinX()<=0 || NBinY()<=0) return NULL;
     1104if(NBinX()<=0 || NBinY()<=0)
     1105  throw(SzMismatchError("Histo2D::FitResidus: size mismatch\n"));
    11211106GeneralFunction* f = gfit.GetFunction();
    1122 if(f==NULL) return NULL;
     1107if(f==NULL)
     1108  throw(NullPtrError("Histo2D::FitResidus: NULL pointer\n"));
    11231109Vector par = gfit.GetParm();
    1124 Histo2D* h2 = new Histo2D(*this);
     1110Histo2D h2(*this);
    11251111for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {
    11261112  float xc,yc;
    11271113  BinCenter(i,j,xc,yc);
    11281114  double x[2] = {(double)xc,(double)yc};
    1129   (*h2)(i,j) -= (float) f->Value(x,par.Data());
     1115  h2(i,j) -= (float) f->Value(x,par.Data());
    11301116}
    11311117return h2;
     
    11331119
    11341120//++
    1135 Histo2D* Histo2D::FitFunction(GeneralFit& gfit)
     1121Histo2D Histo2D::FitFunction(GeneralFit& gfit)
    11361122//
    11371123//      Retourne une classe contenant la fonction du fit ``gfit''.
    11381124//--
    11391125{
    1140 if(NBinX()<=0 || NBinY()<=0) return NULL;
     1126if(NBinX()<=0 || NBinY()<=0)
     1127  throw(SzMismatchError("Histo2D::FitFunction: size mismatch\n"));
    11411128GeneralFunction* f = gfit.GetFunction();
    1142 if(f==NULL) return NULL;
     1129if(f==NULL)
     1130  throw(NullPtrError("Histo2D::FitFunction: NULL pointer\n"));
    11431131Vector par = gfit.GetParm();
    1144 Histo2D* h2 = new Histo2D(*this);
     1132Histo2D h2(*this);
    11451133for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {
    11461134  float xc,yc;
    11471135  BinCenter(i,j,xc,yc);
    11481136  double x[2] = {(double)xc,(double)yc};
    1149   (*h2)(i,j) = (float) f->Value(x,par.Data());
     1137  h2(i,j) = (float) f->Value(x,par.Data());
    11501138}
    11511139return h2;
     
    17921780
    17931781
    1794 ///////////////////////////////////////////////////////////////////
    1795 //++
    1796 // Titre        Methodes pour ecriture ppersist
    1797 //--
    1798 
    1799 //++
    1800 void  Histo2D::WriteSelf(POutPersist& s)  const
    1801 //
    1802 //      Ecriture fichier de type ppersist.
    1803 //--
     1782///////////////////////////////////////////////////////////
     1783// --------------------------------------------------------
     1784//   Les objets delegues pour la gestion de persistance
     1785// --------------------------------------------------------
     1786///////////////////////////////////////////////////////////
     1787
     1788FIO_Histo2D::FIO_Histo2D()
     1789{
     1790dobj=new Histo2D;
     1791ownobj=true;
     1792}
     1793
     1794FIO_Histo2D::FIO_Histo2D(string const & filename)
     1795{
     1796dobj=new Histo2D;
     1797ownobj=true;
     1798Read(filename);
     1799}
     1800
     1801FIO_Histo2D::FIO_Histo2D(const Histo2D & obj)
     1802{
     1803dobj = new Histo2D(obj);
     1804ownobj=true;
     1805}
     1806
     1807FIO_Histo2D::FIO_Histo2D(Histo2D * obj)
     1808{
     1809dobj = obj;
     1810ownobj=false;
     1811}
     1812
     1813FIO_Histo2D::~FIO_Histo2D()
     1814{
     1815if (ownobj && dobj) delete dobj;
     1816}
     1817
     1818AnyDataObj* FIO_Histo2D::DataObj()
     1819{
     1820return(dobj);
     1821}
     1822
     1823void FIO_Histo2D::ReadSelf(PInPersist& is)
    18041824{
    18051825char strg[256];
    1806 int j;
     1826
     1827if(dobj==NULL) dobj=new Histo2D;
     1828  else         dobj->Delete();
     1829
    18071830float min,max;
    18081831Histo* h;
     1832int_4 errok, projx, projy, nslix, nsliy, nbanx, nbany;
     1833
     1834// Lecture entete
     1835is.GetLine(strg, 255);
     1836is.GetLine(strg, 255);
     1837is.GetLine(strg, 255);
     1838is.GetLine(strg, 255);
     1839is.GetLine(strg, 255);
     1840is.GetLine(strg, 255);
     1841
     1842// Lecture variables de definitions
     1843is.Get(dobj->nx);
     1844is.Get(dobj->ny);
     1845is.Get(dobj->nxy);
     1846is.Get(errok);
     1847is.Get(dobj->nEntries);
     1848is.Get(dobj->nHist);
     1849
     1850is.Get(dobj->xmin);
     1851is.Get(dobj->xmax);
     1852is.Get(dobj->ymin);
     1853is.Get(dobj->ymax);
     1854is.Get(dobj->wbinx);
     1855is.Get(dobj->wbiny);
     1856
     1857is.Get(&(dobj->over[0][0]),9);
     1858
     1859is.Get(projx);
     1860is.Get(projy);
     1861is.Get(nslix);
     1862is.Get(nsliy);
     1863is.Get(nbanx);
     1864is.Get(nbany);
     1865
     1866// Lecture histo2D
     1867dobj->data = new float[dobj->nxy];
     1868is.GetLine(strg, 255);
     1869{for(int j=0;j<dobj->ny;j++) is.Get(dobj->data+j*dobj->nx,dobj->nx);}
     1870
     1871// Lecture erreurs
     1872if(errok) {
     1873  is.GetLine(strg, 255);
     1874  dobj->err2 = new double[dobj->nxy];
     1875  for(int j=0;j<dobj->ny;j++) is.Get(dobj->err2+j*dobj->nx,dobj->nx);
     1876}
     1877
     1878// Lecture des projections
     1879if(projx) {
     1880  is.GetLine(strg, 255);
     1881  dobj->SetProjX();
     1882  FIO_Histo fio_h(dobj->hprojx);
     1883  fio_h.Read(is);
     1884}
     1885if(projy) {
     1886  is.GetLine(strg, 255);
     1887  dobj->SetProjY();
     1888  FIO_Histo fio_h(dobj->hprojy);
     1889  fio_h.Read(is);
     1890}
     1891
     1892// Lecture des slices
     1893if(nslix>0) {
     1894  is.GetLine(strg, 255);
     1895  dobj->SetSliX(nslix);
     1896  DBASSERT (nslix==dobj->NSliX());
     1897  for(int j=0;j<dobj->NSliX();j++)
     1898    {FIO_Histo fio_h(dobj->HSliX(j)); fio_h.Read(is);}
     1899}
     1900if(nsliy>0) {
     1901  is.GetLine(strg, 255);
     1902  dobj->SetSliY(nsliy);
     1903  DBASSERT (nsliy==dobj->NSliY());
     1904  for(int j=0;j<dobj->NSliY();j++)
     1905    {FIO_Histo fio_h(dobj->HSliY(j)); fio_h.Read(is);}
     1906}
     1907
     1908// Lecture des bandes
     1909if( nbanx>0 ) {
     1910  is.GetLine(strg, 255);
     1911  {for(int j=0; j<nbanx; j++) {
     1912    is.Get(min); is.Get(max);
     1913    dobj->SetBandX(min,max);
     1914  }}
     1915  DBASSERT (nbanx==dobj->NBandX());
     1916  {for(int j=0; j<dobj->NBandX(); j++) {
     1917    FIO_Histo fio_h(dobj->HBandX(j));
     1918    fio_h.Read(is);
     1919  }}
     1920}
     1921if( nbany>0 ) {
     1922  is.GetLine(strg, 255);
     1923  {for(int j=0; j<nbany; j++) {
     1924    is.Get(min); is.Get(max);
     1925    dobj->SetBandY(min,max);
     1926  }}
     1927  DBASSERT (nbany==dobj->NBandY());
     1928  {for(int j=0; j<dobj->NBandY(); j++) {
     1929    FIO_Histo fio_h(dobj->HBandY(j));
     1930    fio_h.Read(is);
     1931  }}
     1932}
     1933
     1934return;
     1935}
     1936
     1937void FIO_Histo2D::WriteSelf(POutPersist& os) const
     1938{
     1939if (dobj == NULL)   return;
     1940char strg[256];
    18091941
    18101942// Que faut-il ecrire?
    1811 int_4 errok = (err2) ? 1 : 0;
    1812 int_4 projx = (hprojx) ? 1 : 0;
    1813 int_4 projy = (hprojy) ? 1 : 0;
    1814 int_4 nslix = NSliX();
    1815 int_4 nsliy = NSliY();
    1816 int_4 nbanx = NBandX();
    1817 int_4 nbany = NBandY();
     1943int_4 errok = (dobj->err2) ? 1 : 0;
     1944int_4 projx = (dobj->hprojx) ? 1 : 0;
     1945int_4 projy = (dobj->hprojy) ? 1 : 0;
     1946int_4 nslix = dobj->NSliX();
     1947int_4 nsliy = dobj->NSliY();
     1948int_4 nbanx = dobj->NBandX();
     1949int_4 nbany = dobj->NBandY();
    18181950
    18191951// Ecriture entete pour identifier facilement
    1820 sprintf(strg,"nx=%d  ny=%d  nxy=%d errok=%1d",nx,ny,nxy,errok);
    1821 s.PutLine(strg);
    1822 sprintf(strg,"nHist=%g nEntries=%d",nHist,nEntries);
    1823 s.PutLine(strg);
    1824 sprintf(strg,"wbinx=%g wbiny=%g",wbinx,wbiny);
    1825 s.PutLine(strg);
    1826 sprintf(strg,"xmin=%g xmax=%g ymin=%g ymax=%g",xmin,xmax,ymin,ymax);
    1827 s.PutLine(strg);
     1952sprintf(strg,"nx=%d  ny=%d  nxy=%d errok=%1d"
     1953       ,dobj->nx,dobj->ny,dobj->nxy,errok);
     1954os.PutLine(strg);
     1955sprintf(strg,"nHist=%g nEntries=%d",dobj->nHist,dobj->nEntries);
     1956os.PutLine(strg);
     1957sprintf(strg,"wbinx=%g wbiny=%g",dobj->wbinx,dobj->wbiny);
     1958os.PutLine(strg);
     1959sprintf(strg,"xmin=%g xmax=%g ymin=%g ymax=%g"
     1960       ,dobj->xmin,dobj->xmax,dobj->ymin,dobj->ymax);
     1961os.PutLine(strg);
    18281962sprintf(strg,"projx/y=%d %d nbandx/y=%d %d nbslix/y=%d %d"
    18291963       ,projx,projy,nbanx,nbany,nslix,nsliy);
    1830 s.PutLine(strg);
     1964os.PutLine(strg);
    18311965sprintf(strg,"over %g %g %g %g %g %g %g %g %g"
    1832        ,over[0][0],over[0][1],over[0][2]
    1833        ,over[1][0],over[1][1],over[1][2]
    1834        ,over[2][0],over[2][1],over[2][2]);
    1835 s.PutLine(strg);
     1966       ,dobj->over[0][0],dobj->over[0][1],dobj->over[0][2]
     1967       ,dobj->over[1][0],dobj->over[1][1],dobj->over[1][2]
     1968       ,dobj->over[2][0],dobj->over[2][1],dobj->over[2][2]);
     1969os.PutLine(strg);
    18361970
    18371971// Ecriture variables de definitions
    1838 s.PutI4(nx);
    1839 s.PutI4(ny);
    1840 s.PutI4(nxy);
    1841 s.PutI4(errok);
    1842 s.PutI4(nEntries);
    1843 s.PutR8(nHist);
    1844 
    1845 s.PutR4(xmin);
    1846 s.PutR4(xmax);
    1847 s.PutR4(ymin);
    1848 s.PutR4(ymax);
    1849 s.PutR4(wbinx);
    1850 s.PutR4(wbiny);
    1851 
    1852 s.PutR4s(&over[0][0],9);
    1853 
    1854 s.PutI4(projx);
    1855 s.PutI4(projy);
    1856 s.PutI4(nslix);
    1857 s.PutI4(nsliy);
    1858 s.PutI4(nbanx);
    1859 s.PutI4(nbany);
     1972os.Put(dobj->nx);
     1973os.Put(dobj->ny);
     1974os.Put(dobj->nxy);
     1975os.Put(errok);
     1976os.Put(dobj->nEntries);
     1977os.Put(dobj->nHist);
     1978
     1979os.Put(dobj->xmin);
     1980os.Put(dobj->xmax);
     1981os.Put(dobj->ymin);
     1982os.Put(dobj->ymax);
     1983os.Put(dobj->wbinx);
     1984os.Put(dobj->wbiny);
     1985
     1986os.Put(&(dobj->over[0][0]),9);
     1987
     1988os.Put(projx);
     1989os.Put(projy);
     1990os.Put(nslix);
     1991os.Put(nsliy);
     1992os.Put(nbanx);
     1993os.Put(nbany);
    18601994
    18611995// Ecriture histo2D
    1862 sprintf(strg,"Histo2D: Tableau des donnees %d = %d * %d",nxy,nx,ny);
    1863 s.PutLine(strg);
    1864 for(j=0;j<ny;j++) s.PutR4s(data+j*nx,nx);
    1865 
     1996sprintf(strg,"Histo2D: Tableau des donnees %d = %d * %d"
     1997       ,dobj->nxy,dobj->nx,dobj->ny);
     1998os.PutLine(strg);
     1999{for(int j=0;j<dobj->ny;j++) os.Put(dobj->data+j*dobj->nx,dobj->nx);}
    18662000
    18672001// Ecriture erreurs
    18682002if(errok) {
    1869   sprintf(strg,"Histo2D: Tableau des erreurs %d = %d * %d",nxy,nx,ny);
    1870   s.PutLine(strg);
    1871   for(j=0;j<ny;j++) s.PutR8s(err2+j*nx,nx);
     2003  sprintf(strg,"Histo2D: Tableau des erreurs %d = %d * %d"
     2004         ,dobj->nxy,dobj->nx,dobj->ny);
     2005  os.PutLine(strg);
     2006  for(int j=0;j<dobj->ny;j++) os.Put(dobj->err2+j*dobj->nx,dobj->nx);
    18722007}
    18732008
     
    18752010if(projx) {
    18762011  sprintf(strg,"Histo2D: Projection X");
    1877   s.PutLine(strg);
    1878   hprojx->Write(s);
     2012  os.PutLine(strg);
     2013  FIO_Histo fio_h(dobj->hprojx); fio_h.Write(os);
    18792014}
    18802015if(projy) {
    18812016  sprintf(strg,"Histo2D: Projection Y");
    1882   s.PutLine(strg);
    1883   hprojy->Write(s);
     2017  os.PutLine(strg);
     2018  FIO_Histo fio_h(dobj->hprojy); fio_h.Write(os);
    18842019}
    18852020
     
    18872022if(nslix>0) {
    18882023  sprintf(strg,"Histo2D: Slices X %d",nslix);
    1889   s.PutLine(strg);
    1890   for(j=0;j<nslix;j++) {
    1891     h = HSliX(j);
    1892     h->Write(s);
     2024  os.PutLine(strg);
     2025  for(int j=0;j<nslix;j++) {
     2026    Histo* h = dobj->HSliX(j);
     2027    FIO_Histo fio_h(h); fio_h.Write(os);
    18932028  }
    18942029}
    18952030if(nsliy>0) {
    18962031  sprintf(strg,"Histo2D: Slices Y %d",nsliy);
    1897   s.PutLine(strg);
    1898   for(j=0;j<nsliy;j++) {
    1899     h = HSliY(j);
    1900     h->Write(s);
     2032  os.PutLine(strg);
     2033  for(int j=0;j<nsliy;j++) {
     2034    Histo* h = dobj->HSliY(j);
     2035    FIO_Histo fio_h(h); fio_h.Write(os);
    19012036  }
    19022037}
     
    19052040if( nbanx>0 ) {
    19062041  sprintf(strg,"Histo2D: Bandes X %d",nbanx);
    1907   s.PutLine(strg);
    1908   list<bande_slice>::const_iterator it;
    1909   for(it = lbandx.begin(); it != lbandx.end(); it++) {
    1910     min = (*it).min;
    1911     max = (*it).max;
    1912     s.PutR4(min);
    1913     s.PutR4(max);
    1914   }
    1915   for(it = lbandx.begin(); it != lbandx.end(); it++) {
    1916     h = (*it).H;
    1917     h->Write(s);
     2042  os.PutLine(strg);
     2043  list<Histo2D::bande_slice>::const_iterator it;
     2044  for(it = dobj->lbandx.begin(); it != dobj->lbandx.end(); it++) {
     2045    float min = (*it).min; float max = (*it).max;
     2046    os.Put(min); os.Put(max);
     2047  }
     2048  for(it = dobj->lbandx.begin(); it != dobj->lbandx.end(); it++) {
     2049    Histo* h = (*it).H;
     2050    FIO_Histo fio_h(h); fio_h.Write(os);
    19182051  }
    19192052}
    19202053if( nbany>0 ) {
    19212054  sprintf(strg,"Histo2D: Bandes Y %d",nbany);
    1922   s.PutLine(strg);
    1923   list<bande_slice>::const_iterator it;
    1924   for(it = lbandy.begin(); it != lbandy.end(); it++) {
    1925     min = (*it).min;
    1926     max = (*it).max;
    1927     s.PutR4(min);
    1928     s.PutR4(max);
    1929   }
    1930   for(it = lbandy.begin(); it != lbandy.end(); it++) {
    1931     h = (*it).H;
    1932     h->Write(s);
     2055  os.PutLine(strg);
     2056  list<Histo2D::bande_slice>::const_iterator it;
     2057  for(it = dobj->lbandy.begin(); it != dobj->lbandy.end(); it++) {
     2058    float min = (*it).min; float max = (*it).max;
     2059    os.Put(min); os.Put(max);
     2060  }
     2061  for(it = dobj->lbandy.begin(); it != dobj->lbandy.end(); it++) {
     2062    Histo* h = (*it).H;
     2063    FIO_Histo fio_h(h); fio_h.Write(os);
    19332064  }
    19342065}
     
    19362067return;
    19372068}
    1938 
    1939 //++
    1940 void  Histo2D::ReadSelf(PInPersist& s)
    1941 //
    1942 //      Lecture fichier de type ppersist.
    1943 //--
    1944 {
    1945 Delete();
    1946 
    1947 int j;
    1948 float min,max;
    1949 Histo* h;
    1950 char strg[256];
    1951 int_4 errok, projx, projy, nslix, nsliy, nbanx, nbany;
    1952 
    1953 // Lecture entete
    1954 s.GetLine(strg, 255);
    1955 s.GetLine(strg, 255);
    1956 s.GetLine(strg, 255);
    1957 s.GetLine(strg, 255);
    1958 s.GetLine(strg, 255);
    1959 s.GetLine(strg, 255);
    1960 
    1961 
    1962 // Lecture variables de definitions
    1963 s.GetI4(nx);
    1964 s.GetI4(ny);
    1965 s.GetI4(nxy);
    1966 s.GetI4(errok);
    1967 s.GetI4(nEntries);
    1968 s.GetR8(nHist);
    1969 
    1970 s.GetR4(xmin);
    1971 s.GetR4(xmax);
    1972 s.GetR4(ymin);
    1973 s.GetR4(ymax);
    1974 s.GetR4(wbinx);
    1975 s.GetR4(wbiny);
    1976 
    1977 s.GetR4s(&over[0][0],9);
    1978 
    1979 s.GetI4(projx);
    1980 s.GetI4(projy);
    1981 s.GetI4(nslix);
    1982 s.GetI4(nsliy);
    1983 s.GetI4(nbanx);
    1984 s.GetI4(nbany);
    1985 
    1986 // Lecture histo2D
    1987 data = new float[nxy];
    1988 s.GetLine(strg, 255);
    1989 for(j=0;j<ny;j++) s.GetR4s(data+j*nx,nx);
    1990 
    1991 // Lecture erreurs
    1992 if(errok) {
    1993   s.GetLine(strg, 255);
    1994   err2 = new double[nxy];
    1995   for(j=0;j<ny;j++) s.GetR8s(err2+j*nx,nx);
    1996 }
    1997 
    1998 // Lecture des projections
    1999 if(projx) {
    2000   s.GetLine(strg, 255);
    2001   SetProjX();
    2002   hprojx->Read(s);
    2003 }
    2004 if(projy) {
    2005   s.GetLine(strg, 255);
    2006   SetProjY();
    2007   hprojy->Read(s);
    2008 }
    2009 
    2010 // Lecture des slices
    2011 if(nslix>0) {
    2012   s.GetLine(strg, 255);
    2013   SetSliX(nslix);
    2014   DBASSERT (nslix==NSliX());
    2015   for(j=0;j<NSliX();j++) HSliX(j)->Read(s);
    2016 }
    2017 if(nsliy>0) {
    2018   s.GetLine(strg, 255);
    2019   SetSliY(nsliy);
    2020   DBASSERT (nsliy==NSliY());
    2021   for(j=0;j<NSliY();j++) HSliY(j)->Read(s);
    2022 }
    2023 
    2024 // Lecture des bandes
    2025 if( nbanx>0 ) {
    2026   s.GetLine(strg, 255);
    2027   for( j=0; j<nbanx; j++) {
    2028     s.GetR4(min);
    2029     s.GetR4(max);
    2030     SetBandX(min,max);
    2031   }
    2032   DBASSERT (nbanx==NBandX());
    2033   for( j=0; j<NBandX(); j++) {
    2034     h = HBandX(j);
    2035     h->Read(s);
    2036   }
    2037 }
    2038 if( nbany>0 ) {
    2039   s.GetLine(strg, 255);
    2040   for( j=0; j<nbany; j++) {
    2041     s.GetR4(min);
    2042     s.GetR4(max);
    2043     SetBandY(min,max);
    2044   }
    2045   DBASSERT (nbany==NBandY());
    2046   for( j=0; j<NBandY(); j++) {
    2047     h = HBandY(j);
    2048     h->Read(s);
    2049   }
    2050 }
    2051 
    2052 return;
    2053 }
Note: See TracChangeset for help on using the changeset viewer.