#ifndef ROOT_TBitmap
#define ROOT_TBitmap
 
#include <TModel.h>
#include <TASImage.h>
 
#include <iostream>
#include <math.h>

class TBitmap
{

protected:
   UInt_t        fWidth;        // width of image in pixels
   UInt_t        fHeight;       // height of image in pixels
   Double_t     *fImage;        // image data, stored row-wise
   TASImage     *fTimage;       // graphical image object for visualization

   UInt_t	 fDeg;		// maximum degree of basis functions
   Double_t	*fXbasis;	// array of precalculated basis functions in x
   Double_t	*fYbasis;	// array of precalculated basis functions in y

   TModel	*fHasModel;	// model used for last Compute(), or 0
   UInt_t	 fHasModelCtr;  // counter of how many times HasModel was used

public:
   TBitmap(UInt_t width, UInt_t height);
   TBitmap(const TBitmap& map);
   virtual ~TBitmap();

   Double_t* operator[](UInt_t i);
   TBitmap& operator=(const TBitmap& source);
   TBitmap& operator+=(const TBitmap& source);
   TBitmap& operator-=(const TBitmap& source);
   TBitmap& operator*=(const TBitmap& source);
   TBitmap& operator/=(const TBitmap& source);
   TBitmap& operator*=(Double_t factor);
   TBitmap& operator/=(Double_t factor);
   TBitmap operator-() const;
   Bool_t operator==(const TBitmap& other) const;
   Bool_t operator!=(const TBitmap& other) const;

   UInt_t GetWidth() const;
   UInt_t GetHeight() const;
   void Draw(Option_t* option="z");
   void WriteBMP(const char* filename);
   void ReadBMP(const char* filename);
   void Compute(const TModel& model);
   void Precompute(UInt_t degree);
   void Interfere(const TModel& refa, 
                  const TModel& sig1a, const TModel& sig2a,
                  const TModel& sig1ph, const TModel& sig2ph);
   void Interfere(TBitmap& refa,
                  TBitmap& sig1a, TBitmap& sig2a,
                  TBitmap& sig1ph, TBitmap& sig2ph);
   Double_t ChiSquared(const TBitmap& map) const;

   friend TBitmap operator+(const TBitmap& v1, const TBitmap& v2);
   friend TBitmap operator-(const TBitmap& v1, const TBitmap& v2);
   friend TBitmap operator*(const TBitmap& v1, const TBitmap& v2);
   friend TBitmap operator/(const TBitmap& v1, const TBitmap& v2);
   friend TBitmap operator*(const TBitmap& v1, Double_t factor);
   friend TBitmap operator*(Double_t factor, const TBitmap& v1);
   friend TBitmap operator/(const TBitmap& v1, Double_t factor);
   friend TBuffer& operator>>(TBuffer& buf, TBitmap* &obj);
   friend TBuffer& operator<<(TBuffer& buf, const TBitmap* obj);
   friend std::istream& operator>>(std::istream& in, TBitmap* &obj);
   friend std::ostream& operator<<(std::ostream& out, const TBitmap* obj);

   ClassDef(TBitmap,1)  // Real 2D rectangular bitmap array

private:
   void ComputeFast(const TModel& model);
   void InterfereFast(const TModel& refa, 
                      const TModel& sig1a, const TModel& sig2a,
                      const TModel& sig1ph, const TModel& sig2ph);
};


//----- inlines ----------------------------------------------------------------
 
inline Double_t* TBitmap::operator[](UInt_t i)
{
   return &fImage[i*fWidth];
}

inline TBitmap operator+(const TBitmap& v1, const TBitmap& v2)
{
   TBitmap map(v1);
   return map+=v2;
}

inline TBitmap operator-(const TBitmap& v1, const TBitmap& v2)
{
   TBitmap map(v1);
   return map-=v2;
}

inline TBitmap operator*(const TBitmap& v1, const TBitmap& v2)
{
   TBitmap map(v1);
   return map*=v2;
}

inline TBitmap operator/(const TBitmap& v1, const TBitmap& v2)
{
   TBitmap map(v1);
   return map/=v2;
}

inline TBitmap operator*(const TBitmap& v1, Double_t factor)
{
   TBitmap map(v1);
   return map*=factor;
}

inline TBitmap operator*(Double_t factor, const TBitmap& v1)
{
   TBitmap map(v1);
   return map*=factor;
}

inline TBitmap operator/(const TBitmap& v1, Double_t factor)
{
   TBitmap map(v1);
   return map/=factor;
}

inline Bool_t TBitmap::operator!=(const TBitmap& other) const
{
   return !(*this == other);
}

inline UInt_t TBitmap::GetWidth() const
{
   return fWidth;
}

inline UInt_t TBitmap::GetHeight() const
{
   return fHeight;
}

inline TBuffer &operator>>(TBuffer& buf, TBitmap* &obj)
{
   int width, height;
   buf >> width >> height;
   obj = new TBitmap(width,height);
   buf.ReadStaticArray((Double_t *)&obj->fImage);
   obj->fDeg = 0;
   return buf;
}

inline TBuffer &operator<<(TBuffer& buf, const TBitmap* obj)
{
   buf << obj->fWidth << obj->fHeight;
   buf.WriteArray((Double_t *)&obj->fImage, obj->fWidth*obj->fHeight);
   return buf;
}

inline std::istream &operator>>(std::istream &in, TBitmap* &obj)
{
   int width, height;
   in >> width >> height;
   obj = new TBitmap(width,height);
   int k=0;
   for (int i=0; i<height; i++) {
      for (int j=0; j<width; j++,k++) {
         in >> obj->fImage[k];
      }
   }
   obj->fDeg = 0;
   return in;
}

inline std::ostream &operator<<(std::ostream &out, const TBitmap* obj)
{
   out << " " << obj->fWidth;
   out << " " << obj->fHeight;
   int k=0;
   for (int i=0; i<(int)obj->fHeight; i++) {
      for (int j=0; j<(int)obj->fWidth; j++,k++) {
         out << " " << obj->fImage[k];
      }
   }
   return out;
}

#endif