ccdimage.h

#ifndef CCDIMAGE__H
#define CCDIMAGE__H

#include <string>

#include "measuredstar.h"
#include <frame.h>


class ReducedImage;
class FitsHeader;





void SetZpKey(const std::string &AKey);


class CcdImage : public RefCount
{
 private:

  Frame imageFrame; // in pixels
  MeasuredStarList wholeCatalog; // the catalog of measured objets
  MeasuredStarList catalogForFit;

  // these 2 transfos are NOT updated when fitting
  Gtransfo *readWcs; // i.e. from pix to sky
  Gtransfo *inverseReadWcs; // i.e. from sky to pix

  // The following ones should probably be mostly removed.
  Gtransfo *CTP2TP; // go from CommonTangentPlane to this tangent plane.
  Gtransfo *TP2CTP; // reverse one
  Gtransfo *pix2CommonTangentPlane;// pixels -> CTP
  Gtransfo *pix2TP;
  
  Gtransfo* sky2TP;
  
  std::string riName;
  std::string riDir;
  std::string instrument;
  int chip; // CCD number
  int shoot; // Same value for all CcdImages from the same exposure
  unsigned bandRank; // some incremental band indicator.
  

  double expTime; // seconds
  double airMass; // airmass value.
  double fluxCoeff; // coefficient to convert ADUs to ADUs/sec at airmass 1
  double jd; // julian date
  double toadsZeroPoint;
  double elixirZP;
  double photk;
  double photc;
  double zp;
  double psfzp;
  double seeing;
  double gfseeing;
  double sigmaback;
  std::string dateObs;
  // refraction
  double sineta,coseta,tgz,hourAngle;  // eta : parallactic angle, z: zenithal angle (X = 1/cos(z))
  
  std::string band;
  std::string flatName;
  //  std::string flat; // full flat name
  //  std::string baseflat; // full baseflat name
  std::string cfhtscatter; // full scatter name
  std::string snlsgrid; // our grid corrections
  std::string flatcvmap; // a multiplicative map to apply to the fluxes
  int    bandIndex;
  int    index;
  int    expindex;
  
  Point  commonTangentPoint;

 public:
 
  CcdImage(const ReducedImage &Ri, const Point &CommonTangentPoint, const CatalogLoader * LoadIt);

  std::string Name() const { return riName;}
  
  std::string Dir() const { return riDir; }

  const MeasuredStarList & WholeCatalog() const { return wholeCatalog;}

  const MeasuredStarList & CatalogForFit() const { return catalogForFit;}

  MeasuredStarList & CatalogForFit()  { return catalogForFit;}

  const Gtransfo* Pix2CommonTangentPlane() const 
    { return pix2CommonTangentPlane;}

  const Gtransfo* CommonTangentPlane2TP() const 
    { return CTP2TP;}
  
  const Gtransfo* TP2CommonTangentPlane() const 
    { return TP2CTP;}
  
  const Gtransfo* Pix2TangentPlane() const 
    { return pix2TP;}

  const Gtransfo* Sky2TP() const 
    { return sky2TP;}
  
  int Chip() const { return chip;}

  std::string Instrument() const {return instrument;}

  unsigned BandRank() const {return bandRank;}

  double Seeing() const { return seeing;}
  
  double GFSeeing() const { return gfseeing;}
  
  double SigmaBack() const { return sigmaback;}
  
  int Shoot() const { return shoot;}
  
  double ExpTime() const { return expTime;}
  
  double AirMass() const {return airMass;}
  
  std::string DateObs() const { return dateObs; }

  double JD() const { return jd; }

  
  double ElixirZP() const { return elixirZP;}

  double ZP() const { return zp;}

  double PSFZP() const { return psfzp;}
  
  double PhotK() const { return photk; }
  
  double PhotC() const { return photc; }

  double HourAngle() const { return hourAngle; }

  double SinEta() const { return sineta; }

  double CosEta() const { return coseta; }

  double TanZ() const { return tgz; }

  Point ParallacticVector() const {return Point(tgz*coseta, tgz*sineta);}

  double FluxCoeff() const { return fluxCoeff;}
  
  std::string Band() const { return band;}
  
  int BandIndex() const { return bandIndex; }
  
  std::string FlatName() const { return flatName;}

  std::string CFHTScatter() const { return cfhtscatter; }
  
  std::string SNLSGrid() const { return snlsgrid; }
  
  std::string FlatCVMap() const { return flatcvmap; }
  
  void SetPix2TangentPlane(const Gtransfo *);
  
  const Gtransfo *ReadWCS() const {return readWcs;}
  
  const Gtransfo *InverseReadWCS() const {return inverseReadWcs;}
  
  const Frame& ImageFrame() const { return imageFrame;}
  
  Frame RaDecFrame() const;
  
  //  void             SetFittedCcd(FittedCcd* ccd) { if(ccd) fittedccd=ccd; }
  //  FittedCcd*       GetFittedCcd() { return fittedccd; }
  //  FittedCcd const* GetFittedCcd() const { return fittedccd; }
  
  //  bool Overlaps(const CcdImage &Other) const;
  
  int     Index() const { return index; }
  void    SetIndex(int idx) { index = idx; }
  
  int     ExpIndex() const { return expindex; }
  void    SetExpIndex(int idx) { expindex = idx; }
  
  Point const&       CommonTangentPoint() const { return commonTangentPoint; }
  
 private:
  CcdImage(const CcdImage &); // forbid copies


};


/********* CcdImageList *************/

#include <list>
#include <vector>

class CcdImageList : public std::list<CountedRef<CcdImage> >
{
  public:
  std::vector<int> Shoots() const;

  std::list<std::string> FlatNames() const;
  
  std::list<std::string> DateObs() const;
  
  std::list<std::string> Bands() const;
  
  double       MeanAirmass() const;
  
  template<class Accept> CcdImageList SubList(const Accept &OP) const
    {
      CcdImageList out;
      for (const_iterator i = begin(); i != end() ; ++i)
    if (OP(**i)) out.push_back(*i);
      return out;
    }
  
  // find the matching image. Chip==-1 means any chip
  double AirMass(const int Shoot, const int Chip = -1) const;
};


typedef CcdImageList::iterator CcdImageIterator;
typedef CcdImageList::const_iterator CcdImageCIterator;



#endif /* CCDIMAGE__H */