#ifndef IMGNUMOPS_HH
#define IMGNUMOPS_HH
//! file="amma/Image/BasImage/ImgNumOps.hh"
//! lib=Image
//! userlevel=Default
//! rcsid="$Id: ImgNumOps.hh,v 1.3 1999/11/05 15:33:41 ees1cg Exp $"

//! docentry="Image.Image Processing"


#include "amma/Image.hh"
#include "amma/ImagIter.hh"
#include "amma/Image2Iter.hh"


template <class PixelT, class ScalarT>
ImageC<PixelT> & operator+=(ImageC<PixelT> & im, ScalarT alpha);
// Adds `alpha' to all pixel values.
  
template <class PixelT, class ScalarT>
ImageC<PixelT> & operator-=(ImageC<PixelT> & im, ScalarT alpha);
// Subtracts `alpha' from all pixel values.
  
template <class PixelT, class ScalarT>
ImageC<PixelT> & operator*=(ImageC<PixelT> & im, ScalarT alpha);
// Multiplies all pixel values by `alpha'.
  
template <class PixelT, class ScalarT>
ImageC<PixelT> & operator/=(ImageC<PixelT> & im, ScalarT alpha);
// Divides all pixel values by `alpha'.

template <class Pixel1T, class Pixel2T>
ImageC<Pixel1T> & operator+=(ImageC<Pixel1T> & im1, ImageC<Pixel2T> im2);
  // Adds `image' values pixel by pixel to `this' image.
  
template <class Pixel1T, class Pixel2T>
ImageC<Pixel1T> & operator-=(ImageC<Pixel1T> & im1, ImageC<Pixel2T> im2);
  // Subtracts `image' values pixel by pixel from `this' image.
  
template <class Pixel1T, class Pixel2T>
ImageC<Pixel1T> & operator*=(ImageC<Pixel1T> & im1, ImageC<Pixel2T> im2);
  // Multiplies all values of `this' image pixel-by-pixel.
  
template <class Pixel1T, class Pixel2T>
ImageC<Pixel1T> & operator/=(ImageC<Pixel1T> & im1, ImageC<Pixel2T> im2);
  // Divides all values of `this' image pixel-by-pixel.

template <class PixelT, class ScalarT>
ImageC<PixelT> & operator+=(ImageC<PixelT> & im, ScalarT alpha)
//=========================================
{
  for(ImageIterC<PixelT > it(im);it.IsElm();it.Next())
    it.Data() += alpha;
  return(im);
}

template <class PixelT, class ScalarT>
ImageC<PixelT> & operator-=(ImageC<PixelT> & im, ScalarT alpha)
//=========================================
{
  for(ImageIterC<PixelT > it(im);it.IsElm();it.Next())
    it.Data() -= alpha;
  return(im);
}

template <class PixelT, class ScalarT>
ImageC<PixelT> & operator*=(ImageC<PixelT> & im, ScalarT alpha)
//=========================================
{
  for(ImageIterC<PixelT > it(im);it.IsElm();it.Next())
    it.Data() *= alpha;
  return(im);
}
  
template <class PixelT, class ScalarT>
ImageC<PixelT> & operator/=(ImageC<PixelT> & im, ScalarT alpha)
//=========================================
{
  for(ImageIterC<PixelT > it(im);it.IsElm();it.Next())
    it.Data() /= alpha;
  return(im);
}

template <class Pixel1T, class Pixel2T>
ImageC<Pixel1T> & operator+=(ImageC<Pixel1T> & im1, ImageC<Pixel2T> im2)
//=========================================
{
  for(Image2IterC<Pixel1T, Pixel2T> it(im1,im2);it.IsElm();it.Next())
    it.Data1() += it.Data2();
  return(im1);
}
  
template <class Pixel1T, class Pixel2T>
ImageC<Pixel1T> & operator-=(ImageC<Pixel1T> & im1, ImageC<Pixel2T> im2)
//=========================================
{
  for(Image2IterC<Pixel1T, Pixel2T> it(im1,im2);it.IsElm();it.Next())
    it.Data1() -= it.Data2();
  return(im1);
}
  
template <class Pixel1T, class Pixel2T>
ImageC<Pixel1T> & operator*=(ImageC<Pixel1T> & im1, ImageC<Pixel2T> im2)
//=========================================
{
  for(Image2IterC<Pixel1T, Pixel2T> it(im1,im2);it.IsElm();it.Next())
    it.Data1() *= it.Data2();
  return(im1);
}
  
template <class Pixel1T, class Pixel2T>
ImageC<Pixel1T> & operator/=(ImageC<Pixel1T> & im1, ImageC<Pixel2T> im2)
//=========================================
{
  for(Image2IterC<Pixel1T, Pixel2T> it(im1,im2);it.IsElm();it.Next())
    it.Data1() /= it.Data2();
  return(im1);
}

#endif