#include "trop.h"

namespace

{

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

template <typename channel_type="" pixel,="" typename=""></typename>

void computeBBox(TRasterPT<pixel> ras, TRect &bbox)</pixel>

{

	bbox = ras->getBounds();

	int lx = ras->getLx();

	int ly = ras->getLy();

	// se c'e' un pixel opaco in alto a sin e in basso a destra allora bbox = bounds

	if (ras->pixels(0)[0].m != 0 &&

		ras->pixels(ly - 1)[lx - 1].m != 0)

		return;

	int y;

	ras->lock();

	for (y = 0; y < ly; y++) {

		CHANNEL_TYPE *pix = &(ras->pixels(y)->m);

		CHANNEL_TYPE *endPix = pix + 4 * lx;

		while (pix < endPix && *pix == 0)

			pix += 4;

		if (pix < endPix)

			break;

	}

	if (y == ly) {

		// tutta trasparente

		bbox = TRect();

		ras->unlock();

		return;

	}

	bbox.y0 = y;

	for (y = ly - 1; y > bbox.y0; y--) {

		CHANNEL_TYPE *pix = &(ras->pixels(y)->m);

		CHANNEL_TYPE *endPix = pix + 4 * lx;

		while (pix < endPix && *pix == 0)

			pix += 4;

		if (pix < endPix)

			break;

	}

	bbox.y1 = y;

	assert(bbox.y0 <= bbox.y1);

	bbox.x0 = lx;

	bbox.x1 = -1;

	for (y = bbox.y0; y <= bbox.y1; y++) {

		CHANNEL_TYPE *row = &(ras->pixels(y)->m);

		int x = 0;

		for (x = 0; x < bbox.x0 && row[x * 4] == 0; x++) {

		}

		bbox.x0 = x;

		for (x = lx - 1; x > bbox.x1 && row[x * 4] == 0; x--) {

		}

		bbox.x1 = x;

	}

	assert(bbox.x0 <= bbox.x1);

	ras->unlock();

	/*

	UCHAR *row_m = &(ras->pixels()->m);

  // se c'e' un pixel opaco in alto a sin e in basso a destra allora bbox = bounds

  if(row_m[0] && row_m[(ly-1)*wrap4 + (lx-1)*4])

	  return;

  int y;

  UCHAR *m, *max_m, *min_m;

  for(y=0;y

	  {   

     max_m = row_m + lx * 4;

		 for(m = row_m; m

		 if(m

		 row_m += wrap4;

		}

  if(y>=ly)

	  {

		 // tutta trasparente

		 return;

		}

	bbox.y0 = bbox.y1 = y;

  bbox.x0 = (m - row_m)/4;

  assert(0<=bbox.x0 && bbox.x0

  assert(ras->pixels(bbox.y0)[bbox.x0].m>0);

  assert(bbox.x0 == 0 || ras->pixels(bbox.y0)[bbox.x0-1].m==0);

  min_m = m;

  for(m = max_m - 4;m>min_m && *m==0;m-=4) {}

  bbox.x1 = (m - row_m)/4;

  assert(0<=bbox.x1 && bbox.x1

  assert(ras->pixels(bbox.y0)[bbox.x1].m>0);

  assert(bbox.x1 == lx-1 || ras->pixels(bbox.y0)[bbox.x1+1].m==0);

	row_m += wrap4;

  for(y++;y

	  {   

     max_m = row_m + lx * 4;

		 for(m = row_m; m

		 if(m

		   {

			  int x = (m - row_m)/4;

				if(x

				  {

					 bbox.x0 = x;

           assert(0<=bbox.x0 && bbox.x0

           assert(ras->pixels(y)[bbox.x0].m>0);

           assert(bbox.x0 == 0 || ras->pixels(y)[bbox.x0-1].m==0);

          }

        min_m = row_m + bbox.x1*4;

			  for(m = max_m - 4;m>min_m && *m==0;m-=4) {}

				if(m>min_m) 

				  {

					 x = (m - row_m)/4;

					 assert(x>bbox.x1);

					 bbox.x1 = x;

					}

				bbox.y1 = y;

			 }

		 row_m += wrap4;

		}

*/

}

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

inline bool isTransparent(TPixelCM32 *pix)

{

	return (!pix->isPureInk() &&

			//  (pix->getPaint()==BackgroundStyle

			(pix->getPaint() == 0 && pix->isPurePaint()));

}

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

void computeBBoxCM32(TRasterCM32P ras, TRect &bbox)

{

	bbox = ras->getBounds();

	int lx = ras->getLx();

	int ly = ras->getLy();

	// se c'e' un pixel opaco in alto a sin e in basso a destra allora bbox = bounds

	if (!isTransparent(&(ras->pixels(0)[0])) &&

		!isTransparent(&(ras->pixels(ly - 1)[lx - 1])))

		return;

	int y;

	ras->lock();

	for (y = 0; y < ly; y++) {

		TPixelCM32 *pix = ras->pixels(y);

		TPixelCM32 *endPix = pix + lx;

		while (pix < endPix && isTransparent(pix))

			++pix;

		if (pix < endPix)

			break;

	}

	if (y == ly) {

		// tutta trasparente

		bbox = TRect();

		ras->unlock();

		return;

	}

	bbox.y0 = y;

	for (y = ly - 1; y > bbox.y0; y--) {

		TPixelCM32 *pix = ras->pixels(y);

		TPixelCM32 *endPix = pix + lx;

		while (pix < endPix && isTransparent(pix))

			++pix;

		if (pix < endPix)

			break;

	}

	bbox.y1 = y;

	assert(bbox.y0 <= bbox.y1);

	bbox.x0 = lx;

	bbox.x1 = -1;

	for (y = bbox.y0; y <= bbox.y1; y++) {

		TPixelCM32 *row = ras->pixels(y);

		int x = 0;

		for (x = 0; x < bbox.x0 && isTransparent(&row[x]); x++) {

		}

		bbox.x0 = x;

		for (x = lx - 1; x > bbox.x1 && isTransparent(&row[x]); x--) {

		}

		bbox.x1 = x;

	}

	assert(bbox.x0 <= bbox.x1);

	ras->unlock();

}

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

} //namespace

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

void TRop::computeBBox(TRasterP ras, TRect &bbox)

{

	TRaster32P ras32 = ras;

	if (ras32) {

		::computeBBox<tpixel32, uchar="">(ras32, bbox);</tpixel32,>

		return;

	}

	TRaster64P ras64 = ras;

	if (ras64) {

		::computeBBox<tpixel64, ushort="">(ras64, bbox);</tpixel64,>

		return;

	}

	TRasterCM32P rasCM32 = ras;

	if (rasCM32) {

		computeBBoxCM32(rasCM32, bbox);

		return;

	}

	TRasterGR8P ras8 = ras;

	if (ras8) {

		bbox = ras->getBounds();

		return;

	}

	assert(0);

}