#ifndef T_RASTER_INCLUDED

#define T_RASTER_INCLUDED

#include "tutil.h"

#include "tgeometry.h"

#include "tpixel.h"

#include "tpixelgr.h"

#include "tsmartpointer.h"

#include "tbigmemorymanager.h"

#undef DVAPI

#undef DVVAR

#ifdef TRASTER_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//=========================================================

class DVAPI TRasterType

{

	int m_id;

	/*

public:

	enum Type {

		None,

		BW,

		WB,

		RGBM32,  // LPIXEL, matte channel considered

		RGBM64,  // SPIXEL, matte channel considered 

		CM8,     // color-mapped,  8 bits 

		GR8,     // grey tones, 8 bits 

		CM16,    // color-mapped, 16 bits 

		GR16,    // grey tones, 16 bits 

		RGB555,

		RGB565,

		CM24,    // cmapped, 8+8+8 bits (ink, paint, ramp), +8 bits spare (MSB)

		CM16S12,

		CM16S8   // cmapped, 16 bits, standard SGI 256-color colormap

		// ....

	};

*/

public:

	TRasterType(int id) : m_id(id){};

	int getId() const { return m_id; };

	bool operator==(TRasterType a) { return m_id == a.m_id; };

	bool operator!=(TRasterType a) { return m_id != a.m_id; };

};

//=========================================================

// forward declaration

template <class t=""></class>

class TRasterPT;

class TRaster;

typedef TSmartPointerT<traster> TRasterP;</traster>

//=========================================================

/*!This class stores bitmap images. */

class DVAPI TRaster : public TSmartObject

{

	DECLARE_CLASS_CODE

protected:

	int m_pixelSize;

	int m_lx, m_ly;

	int m_wrap;

	int m_lockCount;

	TRaster *m_parent; // nel caso di sotto-raster

	UCHAR *m_buffer;

	bool m_bufferOwner;

	// i costruttori sono qui per centralizzare la gestione della memoria

	// e' comunque impossibile fare new TRaster perche' e' una classe astratta (clone, extract)

	// crea il buffer associato (NON fa addRef())

	TRaster(int lx, int ly, int pixelSize);

	// si attacca ad un buffer pre-esistente (NON fa addRef() - neanche a parent)

	TRaster(int lx, int ly, int pixelSize,

			int wrap, UCHAR *buffer, TRaster *parent, bool bufferOwner = false);

private:

	static TAtomicVar m_totalMemory;

	TThread::Mutex m_mutex;

	// not implemented

	TRaster(const TRaster &);

	TRaster &operator=(const TRaster &);

public:

#ifdef _DEBUG

	bool m_cashed;

	static unsigned long getTotalMemoryInKB();

#endif

	virtual ~TRaster();

	// accessors

	// TRasterType getType() const {return m_type;};

	int getLx() const { return m_lx; };

	int getLy() const { return m_ly; };

	TDimension getSize() const { return TDimension(m_lx, m_ly); };

	//!Returns the length of a row in pixel.

	int getWrap() const { return m_wrap; }; // lunghezza di una riga in pixel

	TPointD getCenterD() const { return TPointD(0.5 * m_lx, 0.5 * m_ly); };

	TPoint getCenter() const { return TPoint(m_lx / 2, m_ly / 2); };

	TRect getBounds() const { return TRect(0, 0, m_lx - 1, m_ly - 1); };

	int getPixelSize() const { return m_pixelSize; };

	int getRowSize() const { return m_pixelSize * m_lx; };

	// in bytes

	//when the bigMemoryManager is active, remapping can change buffers...need to to lock/unlock them o use them.

	void lock()

	{

		if (!TBigMemoryManager::instance()->isActive())

			return;

		TThread::MutexLocker sl(&m_mutex);

		if (m_parent)

			m_parent->lock();

		else

			++m_lockCount;

	}

	void unlock()

	{

		if (!TBigMemoryManager::instance()->isActive())

			return;

		TThread::MutexLocker sl(&m_mutex);

		if (m_parent)

			m_parent->unlock();

		else {

			assert(m_lockCount > 0);

			--m_lockCount;

		}

	}

	void beginRemapping();

	void endRemapping();

	//!Returns a pointer to the image buffer.

	//WARNING!!!!! before getting the buffer with getRawData(),

	//you have to lock the raster with'lock method, and unlock

	//it when you've done with the buffer

	const UCHAR *getRawData() const { return m_buffer; };

	UCHAR *getRawData() { return m_buffer; };

	//!Returns a pointer to the image buffer positioned in the (x,y) coords.

	const UCHAR *getRawData(int x, int y) const

	{

		assert(0 <= x && x < m_lx && 0 <= y && y < m_ly);

		return m_buffer + (y * m_wrap + x) * m_pixelSize;

	};

	UCHAR *getRawData(int x, int y)

	{

		assert(0 <= x && x < m_lx && 0 <= y && y < m_ly);

		return m_buffer + (y * m_wrap + x) * m_pixelSize;

	};

	bool isEmpty() const { return getSize() == TDimension(); };

	TRasterP getParent() { return m_parent; }

	// creazione di TRaster derivati

	// devono essere virtuali puri perche' il nuovo raster creato deve essere del tipo giusto

	virtual TRasterP clone() const = 0;

	virtual TRasterP extract(TRect &rect) = 0;

	virtual TRasterP create() const = 0;

	virtual TRasterP create(int lx, int ly) const = 0;

	// definita in termini di extract(rect); non lo posso fare subito perche' manca il

	// costruttore di copia di TRasterP

	inline virtual TRasterP extract(int x0, int y0, int x1, int y1);

	// operazioni sui pixel

	// Copia il contenuto di src (spostato di offset) nel raster corrente.

	// Il tipo deve essere lo stesso

	// In caso di dimensione diversa l'area copiata e' l'intersezione dei due getBounds()

	// e i due raster sono allineati in basso a sinistra (src[0,0] -> dst[offset])

	/*!Copies the content of the source raster in the current raster.

     */

	void copy(const TRasterP &src, const TPoint &offset = TPoint());

	void xMirror();

	void yMirror();

	void rotate180();

	void rotate90();

	void clear();

	void clearOutside(const TRect &rect);

	friend class TBigMemoryManager;

protected:

	void fillRawData(const UCHAR *pixel);

	void fillRawDataOutside(const TRect &rect, const UCHAR *pixel);

private:

	void remap(UCHAR *newLocation);

};

//------------------------------------------------------------

//

// Smart Pointer a TRaster

//

#ifdef _WIN32

template class DVAPI TSmartPointerT<traster>;</traster>

#endif

//------------------------------------------------------------

inline void detach(TRasterP &r)

{

	if (!r || r->getRefCount() == 1)

		return;

	TRasterP tmp(r->clone());

	r = tmp;

}

//=========================================================

// forward declaration

template <class t=""></class>

class TRasterT;

//

// TRasterPT<pixel>:</pixel>

//

// Smart Pointer to TRasterT<pixel></pixel>

//

//!\include raster_ex1.cpp

//! \include rasterpt_ex1.cpp

// class TRasterPT<t></t>

template <class t=""></class>

class TRasterPT : public TSmartPointerT<trastert<t>></trastert<t>

{

public:

	typedef T Pixel;

	typedef TRasterT<t> Raster;</t>

	TRasterPT(){};

	TRasterPT(int lx, int ly) { create(lx, ly); };

	TRasterPT(const TDimension &d) { create(d.lx, d.ly); };

	inline TRasterPT(const TRasterP &src);

	inline TRasterPT(int lx, int ly, int wrap, T *buffer, bool bufferOwner = false);

	~TRasterPT(){};

	void create(int lx, int ly);

	void create(const TDimension &d) { create(d.lx, d.ly); };

	inline void detach();

	operator TRasterP() const;

};

//=========================================================

//

// TRasterT<pixel></pixel>

//

// e' la classe concreta che discende da TRaster

template <class t=""></class>

class TRasterT : public TRaster

{

protected:

	// Constructors are protected to prevent direct allocation of TRasterT instances.

	// Users must adopt the TRasterPT smart pointer syntax instead.

	// Buffer Allocation

	TRasterT(int lx, int ly) : TRaster(lx, ly, sizeof(T)) {}

	// Buffer Attachment

	TRasterT(int lx, int ly, int wrap, T *buffer, TRasterT<t> *parent, bool bufferOwner = false)</t>

		: TRaster(lx, ly, sizeof(T), wrap, reinterpret_cast<uchar *="">(buffer), parent, bufferOwner) {}</uchar>

public:

	typedef T Pixel;

	~TRasterT(){};

	// accessors

	//WARNING!!!!! before getting the buffer with pixels(int y),

	//you have to lock the raster with'lock method, and unlock

	//it when you've done with the buffer

	const T *pixels(int y = 0) const

	{

		assert(0 <= y && y < getLy());

		return reinterpret_cast<t *="">(m_buffer) + getWrap() * y;</t>

	};

	T *pixels(int y = 0)

	{

		assert(0 <= y && y < getLy());

		return reinterpret_cast<t *="">(m_buffer) + getWrap() * y;</t>

	};

	// Derived rasters creation

	TRasterP clone() const

	{

		TRasterP dst = TRasterPT<t>(m_lx, m_ly);</t>

		TRasterP src(const_cast<traster *="">((const TRaster *)this));</traster>

		dst->copy(src);

		return dst;

	}

	TRasterP create() const

	{

		return TRasterPT<t>(m_lx, m_ly);</t>

	}

	virtual TRasterP create(int lx, int ly) const

	{

		return TRasterPT<t>(lx, ly);</t>

	}

	//!\include raster_ex2.cpp

	TRasterP extract(int x0, int y0, int x1, int y1)

	{

		TRect rect(x0, y0, x1, y1);

		return extract(rect);

	};

	TRasterP extract(TRect &rect)

	{

		if (isEmpty() || getBounds().overlaps(rect) == false)

			return TRasterP();

		rect = getBounds() * rect;

		//addRef();

		return TRasterP(

			new TRasterT<t>(rect.getLx(), rect.getLy(), m_wrap,</t>

							pixels(rect.y0) + rect.x0, this));

	};

	TRasterPT<t> extractT(TRect &rect);</t>

	TRasterPT<t> extractT(int x0, int y0, int x1, int y1)</t>

	{

		TRect rect(x0, y0, x1, y1);

		return extractT(rect);

	};

	friend class TRasterPT<t>;</t>

	// Pixel Operations

	void fill(const T &a)

	{

		fillRawData(reinterpret_cast<const *="" uchar="">(&a));</const>

	}

	void fillOutside(const TRect &rect, const T &a)

	{

		fillRawDataOutside(rect, reinterpret_cast<const *="" uchar="">(&a));</const>

	}

};

//---------------------------------------------------------

inline TRasterP TRaster::extract(int x0, int y0, int x1, int y1)

{

	TRect rect(x0, y0, x1, y1);

	return extract(rect);

}

//---------------------------------------------------------

template <class t=""></class>

TRasterPT<t> TRasterT<t>::extractT(TRect &rect)</t></t>

{

	if (isEmpty() || getBounds().overlaps(rect) == false) {

		return TRasterPT<t>();</t>

	}

	rect = getBounds() * rect;

	//addRef();

	return TRasterPT<t>(</t>

		new TRasterT<t>(rect.getLx(), rect.getLy(), m_wrap,</t>

						pixels(rect.y0) + rect.x0, this));

}

//=========================================================

//

// metodi inline di TRasterPT

// (n.b. se non si fanno esplicitament "inline" NT si confonde con dll exort/import)

//

template <class t=""></class>

inline TRasterPT<t>::TRasterPT(const TRasterP &src)</t>

{

	TSmartPointerT<trastert<t>>::m_pointer = dynamic_cast<trastert<t> *>(src.getPointer());</trastert<t></trastert<t>

	if (TSmartPointerT<trastert<t>>::m_pointer)</trastert<t>

		TSmartPointerT<trastert<t>>::m_pointer->addRef();</trastert<t>

}

template <class t=""></class>

inline void TRasterPT<t>::create(int lx, int ly)</t>

{

	TRasterT<t> *raster = new TRasterT<t>(lx, ly);</t></t>

	*this = TRasterPT<t>(raster);</t>

}

template <class t=""></class>

inline void TRasterPT<t>::detach()</t>

{

	if (!TSmartPointerT<trastert<t>>::m_pointer || TSmartPointerT<trastert<t>>::m_pointer->getRefCount() == 1)</trastert<t></trastert<t>

		return;

	*this = TRasterPT(TSmartPointerT<trastert<t>>::m_pointer->clone());</trastert<t>

	// uso l'operator di assign per aggiornare correttamente

	// i reference counts del vecchio e del nuovo raster

}

template <class t=""></class>

inline TRasterPT<t>::operator TRasterP() const</t>

{

	return TRasterP(TSmartPointerT<trastert<t>>::m_pointer);</trastert<t>

}

//---------------------------------------------------------

template <class t=""></class>

inline TRasterPT<t>::TRasterPT(int lx, int ly, int wrap, T *buffer, bool bufferOwner)</t>

{

	TSmartPointerT<trastert<t>>::m_pointer = new TRasterT<t>(lx, ly, wrap, buffer, 0, bufferOwner);</t></trastert<t>

	TSmartPointerT<trastert<t>>::m_pointer->addRef();</trastert<t>

}

//---------------------------------------------------------

#ifdef _WIN32

// su NT e' necessario per evitare un warning nelle classi

// esportate che si riferiscono a TRaster32P/TRaster64P

// su IRIX non compila perche' non riesce ad instanziare le

// funzioni online (!!!)

template class DVAPI TSmartPointerT<trastert<tpixel32>>;</trastert<tpixel32>

template class DVAPI TRasterPT<tpixel32>;</tpixel32>

template class DVAPI TSmartPointerT<trastert<tpixel64>>;</trastert<tpixel64>

template class DVAPI TRasterPT<tpixel64>;</tpixel64>

template class DVAPI TSmartPointerT<trastert<tpixelgr8>>;</trastert<tpixelgr8>

template class DVAPI TRasterPT<tpixelgr8>;</tpixelgr8>

template class DVAPI TSmartPointerT<trastert<tpixelgr16>>;</trastert<tpixelgr16>

template class DVAPI TRasterPT<tpixelgr16>;</tpixelgr16>

template class DVAPI TSmartPointerT<trastert<tpixelgrd>>;</trastert<tpixelgrd>

template class DVAPI TRasterPT<tpixelgrd>;</tpixelgrd>

template class DVAPI TSmartPointerT<trastert<tpixelcy>>;</trastert<tpixelcy>

template class DVAPI TRasterPT<tpixelcy>;</tpixelcy>

#endif

typedef TRasterPT<tpixel32> TRaster32P;</tpixel32>

typedef TRasterPT<tpixel64> TRaster64P;</tpixel64>

typedef TRasterPT<tpixelgr8> TRasterGR8P;</tpixelgr8>

typedef TRasterPT<tpixelgr16> TRasterGR16P;</tpixelgr16>

typedef TRasterPT<tpixelgrd> TRasterGRDP;</tpixelgrd>

typedef TRasterPT<tpixelcy> TRasterYUV422P;</tpixelcy>

//=========================================================

//=========================================================

#endif //__T_RASTER_INCLUDED