//-----------------------------------------------------------------------------
//    ____ _               
//   | ___| |   ___  _  _  
//   | ___| |  / __)\ \/ / 
//   | |  | |_| ___) |  |
//   |_|  \___|\___)/_/\_\ Image Library 
//		
//	  2006, Intel Corporation, licensed under Apache 2.0 
//
// file :		FlexOperators.h 
// author :		Scott Ettinger - scott.m.ettinger@intel.com
// description: FlexImage definition.  Templated image object.  Typed 
//				functions are called through specializations.
//
// modified : 
//-----------------------------------------------------------------------------

#ifndef FLEXOPS_H
#define FLEXOPS_H

#if defined(HAVE_CONFIG_H)
# include "config.h"
#endif

#include "FlexImage.h"

//NOTE : only use images of equal size or unexpected results may occur!  
//Additional error checking may be added to this code to provide warnings or 
//	abort in the case of unequal image size. 

//NOTE : all constants must be type cast to the proper type when using operators.
//		 this can be fixed , but may risk portability between
//		 compilers.

/////////////////  binary image operators //////////////////////


//Addition of two images
template<class T, int C>
FlexImage<T,C> operator +(const FlexImage<T,C> &srcR, const FlexImage<T,C> &srcL)
{	FlexImage<T,C> tmp(srcR.Width(), srcR.Height());
	int w = srcR.Width() * C;								//this constant is calculated first to allow 
	for(int y = 0; y < srcR.Height(); y++)					//compilers to vectorize
	{	T *p = &tmp(0,y), *pr = &srcR(0,y), *pl = &srcL(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = *(pr++) + *(pl++);
	}
	return(tmp);
}

//Subtraction of two images
template<class T, int C>
FlexImage<T,C> operator -(const FlexImage<T,C> &srcR, const FlexImage<T,C> &srcL)
{	FlexImage<T,C> tmp(srcR.Width(), srcR.Height());
	int w = srcR.Width() * C;
	for(int y = 0; y < srcR.Height(); y++)
	{	T *p = &tmp(0,y), *pr = &srcR(0,y), *pl = &srcL(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = *(pr++) - *(pl++);
	}
	return(tmp);
}

//Multiplication of two images
template<class T, int C>
FlexImage<T,C> operator *(const FlexImage<T,C> &srcR, const FlexImage<T,C> &srcL)
{	FlexImage<T,C> tmp(srcR.Width(), srcR.Height());
	int w = srcR.Width() * C;	
	for(int y = 0; y < srcR.Height(); y++)
	{	T *p = &tmp(0,y), *pr = &srcR(0,y), *pl = &srcL(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = *(pr++) * *(pl++);
	}
	return(tmp);
}

//Division of two images
template<class T, int C>
FlexImage<T,C> operator /(const FlexImage<T,C> &srcR, const FlexImage<T,C> &srcL)
{	FlexImage<T,C> tmp(srcR.Width(), srcR.Height());
	int w = srcR.Width() * C;
	for(int y = 0; y < srcR.Height(); y++)
	{	T *p = &tmp(0,y), *pr = &srcR(0,y), *pl = &srcL(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = *(pr++) / *(pl++);
	}
	return(tmp);
}

/////////////////  image assignment operators //////////////////////

//In place Addition of two images
template<class T, int C>
void operator +=(FlexImage<T,C> &dst, const FlexImage<T,C> &src)
{	int w = src.Width() * C;
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &dst(0,y,0), *ps = &src(0,y,0);
		for(int x = 0; x < w; x++)
			p[x] = p[x] + ps[x];
	}
}

//In place Subtraction of two images
template<class T, int C>
void operator -=(FlexImage<T,C> &dst, const FlexImage<T,C> &src)
{	int w = src.Width() * C;
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &dst(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			p[x] = p[x] - ps[x];
	}
}

//In place Multiplication of two images
template<class T, int C>
void operator *=(FlexImage<T,C> &dst, const FlexImage<T,C> &src)
{	int w = src.Width() * C;
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &dst(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			p[x] = p[x] * ps[x];
	}
}

//In place Division of two images
template<class T, int C>
void operator /=(FlexImage<T,C> &dst, const FlexImage<T,C> &src)
{	int w = src.Width() * C;
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &dst(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			p[x] = p[x] / ps[x];
	}
}

////////////////// Binary image and constant operators ////////////////

//Addition of a constant
template<class T, int C>
FlexImage<T,C> operator +(const FlexImage<T,C> &src, T c)
{	FlexImage<T,C> tmp(src.Width(), src.Height());
	int w = src.Width() * C;
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &tmp(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = *(ps++) + c;
	}
	return(tmp);
}

//Subtraction of a constant
template<class T, int C>
FlexImage<T,C> operator -(const FlexImage<T,C> &src, T c)
{	FlexImage<T,C> tmp(src.Width(), src.Height());
	int w = src.Width() * C;
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &tmp(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = *(ps++) - c;
	}
	return(tmp);
}

//Multiplication by a constant
template<class T, int C>
FlexImage<T,C> operator *(const FlexImage<T,C> &src, T c)
{	int w = src.Width() * C;
	FlexImage<T,C> tmp(src.Width(), src.Height());
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &tmp(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = *(ps++) * c;
	}
	return(tmp);
}

//Division by a constant
template<class T, int C>
FlexImage<T,C> operator /(const FlexImage<T,C> &src, T c)
{	int w = src.Width() * C;
	FlexImage<T,C> tmp(src.Width(), src.Height());
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &tmp(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = *(ps++) / c;
	}
	return(tmp);
}

//Addition of an image to a constant
template<class T, int C>
FlexImage<T,C> operator +(T c, const FlexImage<T,C> &src)
{	return src + c;
}

//Subtraction of an image from a constant
template<class T, int C>
FlexImage<T,C> operator -(T c, const FlexImage<T,C> &src)
{	FlexImage<T,C> tmp(src.Width(), src.Height());
	int w = src.Width() * C;
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &tmp(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = c - *(ps++);
	}
	return(tmp);
}

//Multiplication of a constant by an image
template<class T, int C>
FlexImage<T,C> operator *(T c, const FlexImage<T,C> &src)
{	return src * c;
}

//Division of a constant by an image
template<class T, int C>
FlexImage<T,C> operator /(T c, const FlexImage<T,C> &src)
{	FlexImage<T,C> tmp(src.Width(), src.Height());
	int w = src.Width() * C;
	for(int y = 0; y < src.Height(); y++)
	{	T *p = &tmp(0,y), *ps = &src(0,y);
		for(int x = 0; x < w; x++)
			*(p++) = c / *(ps++);
	}
	return(tmp);
}

/////////////// Multi-channel  constant assignment operators ////////////////

//In Place Addition of a constant
template<class T, int C> 
void operator +=(FlexImage<T,C> &dst, T c)
{	int w = dst.Width() * C;
	for(int y = 0; y < dst.Height(); y++)
	{	T *p = &dst(0,y);
		for(int x = 0; x < w; x++)
			p[x] = p[x] + c;
	}
}

//In Place Subtraction of a constant
template<class T, int C> 
void operator -=(FlexImage<T,C> &dst, T c)
{	int w = dst.Width() * C;
	for(int y = 0; y < dst.Height(); y++)
	{	T *p = &dst(0,y);
		for(int x = 0; x < w; x++)
			p[x] = p[x] - c;
	}
}

//In Place Multiplication by a constant
template<class T, int C> 
void operator *=(FlexImage<T,C> &dst, T c)
{	int w = dst.Width() * C;
	for(int y = 0; y < dst.Height(); y++)
	{	T *p = &dst(0,y);
		for(int x = 0; x < w; x++)
			p[x] = p[x] * c;
	}
}

//In Place Division by a constant
template<class T, int C> 
void operator /=(FlexImage<T,C> &dst, T c)
{	int w = dst.Width() * C;
	for(int y = 0; y < dst.Height(); y++)
	{	T *p = &dst(0,y);
		for(int x = 0; x < w; x++)
			p[x] = p[x] / c;
	}
}

#endif