//#include "tutil.h"

//#include "tgl.h"

#include "colorfxutils.h"

#include "drawutil.h"

#include "tregion.h"

#include "tflash.h"

RubberDeform::RubberDeform() : m_pPolyOri(0), m_polyLoc()

{

}

RubberDeform::RubberDeform(std::vector<t3dpointd> *pPolyOri, const double rf) : m_pPolyOri(pPolyOri),</t3dpointd>

																		   m_polyLoc()

{

	copyOri2Loc();

	TRectD bbox;

	getBBox(bbox);

	double d = tdistance(TPointD(bbox.x0, bbox.y0), TPointD(bbox.x1, bbox.y1));

	d = d / 20;

	refinePoly(d);

}

RubberDeform::~RubberDeform()

{

}

void RubberDeform::deformStep()

{

	std::vector<t3dpointd> tmpv;</t3dpointd>

	std::vector<t3dpointd>::iterator itb = m_polyLoc.begin();</t3dpointd>

	std::vector<t3dpointd>::iterator ite = m_polyLoc.end();</t3dpointd>

	for (std::vector<t3dpointd>::iterator it = itb; it != ite; ++it) {</t3dpointd>

		std::vector<t3dpointd>::iterator it1 = it == (ite - 1) ? itb : it + 1;</t3dpointd>

		double q = 0.5;

		double qq = 1.0 - q;

		tmpv.push_back(T3DPointD(qq * it->x + q * it1->x, qq * it->y + q * it1->y, qq * it->z + q * it1->z));

	}

	m_polyLoc = tmpv;

}

void RubberDeform::deform(const double n)

{

	if (n <= 0 || n >= 100)

		return;

	double q = (double)n / 100.0;

	TRectD bbox;

	getBBox(bbox);

	double d0 = ((bbox.y1 - bbox.y0) * 0.5 + (bbox.x1 - bbox.x0) * 0.5) * 0.5;

	double d = d0;

	while ((d / d0) > q) {

		deformStep();

		getBBox(bbox);

		d = ((bbox.y1 - bbox.y0) * 0.5 + (bbox.x1 - bbox.x0) * 0.5) * 0.5;

	}

	copyLoc2Ori();

}

double RubberDeform::avgLength()

{

	if (m_polyLoc.size() <= 0)

		return 0.0;

	double avgD = 0.0;

	std::vector<t3dpointd>::iterator itb = m_polyLoc.begin();</t3dpointd>

	std::vector<t3dpointd>::iterator ite = m_polyLoc.end();</t3dpointd>

	for (std::vector<t3dpointd>::iterator it = itb; it != ite; ++it) {</t3dpointd>

		std::vector<t3dpointd>::iterator it1 = it == (ite - 1) ? itb : it + 1;</t3dpointd>

		avgD += tdistance(*it, *it1);

	}

	return avgD / (double)m_polyLoc.size();

}

void RubberDeform::getBBox(TRectD &bbox)

{

	if (m_polyLoc.size() <= 0) {

		bbox.x0 = bbox.y0 = 0;

		bbox.x1 = bbox.y1 = -1;

		return;

	}

	bbox.x0 = bbox.x1 = m_polyLoc[0].x;

	bbox.y0 = bbox.y1 = m_polyLoc[0].y;

	for (int i = 1; i < (int)m_polyLoc.size(); i++) {

		bbox.x0 = tmin(bbox.x0, m_polyLoc[i].x);

		bbox.x1 = tmax(bbox.x1, m_polyLoc[i].x);

		bbox.y0 = tmin(bbox.y0, m_polyLoc[i].y);

		bbox.y1 = tmax(bbox.y1, m_polyLoc[i].y);

	}

}

void RubberDeform::refinePoly(const double rf)

{

	double refineL = rf <= 0.0 ? avgLength() : rf;

	std::vector<t3dpointd> tmpv;</t3dpointd>

	int nb = m_polyLoc.size();

	for (int j = 0; j < nb; j++) {

		T3DPointD a(m_polyLoc[j]);

		T3DPointD b(j == (nb - 1) ? m_polyLoc[0] : m_polyLoc[j + 1]);

		tmpv.push_back(a);

		double d = tdistance(a, b);

		if (d > refineL) {

			int n = (int)(d / refineL) + 1;

			double q = 1.0 / (double)n;

			for (int i = 1; i < n; i++) {

				double qq = q * (double)i;

				double qq1 = 1.0 - qq;

				T3DPointD p(T3DPointD(qq1 * a.x + qq * b.x, qq1 * a.y + qq * b.y, qq1 * a.z + qq * b.z));

				tmpv.push_back(p);

			}

		}

	}

	m_polyLoc = tmpv;

}

// ------------------- SFlashUtils -------------------------------------------

void SFlashUtils::computeOutline(const TRegion *region,

								 TRegionOutline::PointVector &polyline) const

{

	if (!region)

		return;

	const double pixelSize = 1.0;

	polyline.clear();

	std::vector<tpointd> polyline2d;</tpointd>

	int edgeSize = region->getEdgeCount();

	for (int i = 0; i < edgeSize; i++) {

		TEdge &edge = *region->getEdge(i);

		stroke2polyline(polyline2d, *edge.m_s, pixelSize, edge.m_w0, edge.m_w1);

	}

	int pointNumber = polyline2d.size();

	polyline.reserve(pointNumber);

	for (int j = 0; j < pointNumber; j++) {

		polyline.push_back(T3DPointD(polyline2d[j], 0.0));

	}

}

void SFlashUtils::computeRegionOutline()

{

	if (!m_r)

		return;

	int subRegionNumber = m_r->getSubregionCount();

	TRegionOutline::PointVector app;

	m_ro.m_exterior.clear();

	computeOutline(m_r, app);

	m_ro.m_exterior.push_back(app);

	m_ro.m_interior.clear();

	m_ro.m_interior.reserve(subRegionNumber);

	for (int i = 0; i < subRegionNumber; i++) {

		app.clear();

		computeOutline(m_r->getSubregion(i), app);

		m_ro.m_interior.push_back(app);

	}

	m_ro.m_bbox = m_r->getBBox();

}

void SFlashUtils::PointVector2QuadsArray(const std::vector<t3dpointd> &pv,</t3dpointd>

										 std::vector<tquadratic *=""> &quadArray,</tquadratic>

										 std::vector<tquadratic *=""> &toBeDeleted,</tquadratic>

										 const bool isRounded) const

{

	std::vector<t3dpointd>::const_iterator ipv = pv.begin();</t3dpointd>

	std::vector<t3dpointd>::const_iterator ipve = pv.end();</t3dpointd>

	int nbPv = pv.size();

	quadArray.clear();

	if (isRounded) {

		if (nbPv <= 2) {

			if (nbPv == 1) {

				TPointD p0, p1, p2;

				p0 = TPointD(pv[0].x, pv[0].y);

				p1 = TPointD(pv[0].x, pv[0].y);

				p2 = TPointD(pv[0].x, pv[0].y);

				quadArray.push_back(new TQuadratic(p0, p1, p2));

				toBeDeleted.push_back(quadArray.back());

			}

			if (nbPv == 2) {

				TPointD p0, p1, p2;

				p0 = TPointD(pv[0].x, pv[0].y);

				p1 = TPointD((pv[0].x + pv[1].x) / 2, (pv[0].y + pv[1].y) / 2);

				p2 = TPointD(pv[1].x, pv[1].y);

				quadArray.push_back(new TQuadratic(p0, p1, p2));

				toBeDeleted.push_back(quadArray.back());

			}

			return;

		}

		for (int i = 0; i < (nbPv - 2); i++) {

			TPointD p0, p1, p2;

			p0 = TPointD((pv[i].x + pv[i + 1].x) / 2, (pv[i].y + pv[i + 1].y) / 2);

			p1 = TPointD(pv[i + 1].x, pv[i + 1].y);

			p2 = TPointD((pv[i + 1].x + pv[i + 2].x) / 2, (pv[i + 1].y + pv[i + 2].y) / 2);

			quadArray.push_back(new TQuadratic(p0, p1, p2));

			toBeDeleted.push_back(quadArray.back());

		}

		TPointD p0, p1, p2;

		p0 = TPointD((pv[nbPv - 2].x + pv[nbPv - 1].x) / 2, (pv[nbPv - 2].y + pv[nbPv - 1].y) / 2);

		p1 = TPointD(pv[nbPv - 1].x, pv[nbPv - 1].y);

		p2 = TPointD((pv[0].x + pv[1].x) / 2, (pv[0].y + pv[1].y) / 2);

		quadArray.push_back(new TQuadratic(p0, p1, p2));

		toBeDeleted.push_back(quadArray.back());

	} else {

		for (int i = 0; i < (nbPv - 1); i++) {

			TPointD p0, p1, p2;

			p0 = TPointD(pv[i].x, pv[i].y);

			p2 = TPointD(pv[i + 1].x, pv[i + 1].y);

			p1 = TPointD((p0.x + p2.x) * 0.5, (p0.y + p2.y) * 0.5);

			quadArray.push_back(new TQuadratic(p0, p1, p2));

			toBeDeleted.push_back(quadArray.back());

		}

		TPointD p0, p1, p2;

		p0 = TPointD(pv[nbPv - 1].x, pv[nbPv - 1].y);

		p2 = TPointD(pv[0].x, pv[0].y);

		p1 = TPointD((p0.x + p2.x) * 0.5, (p0.y + p2.y) * 0.5);

		quadArray.push_back(new TQuadratic(p0, p1, p2));

		toBeDeleted.push_back(quadArray.back());

	}

}

void SFlashUtils::drawRegionOutline(TFlash &flash, const bool isRounded) const

{

	if (!m_r)

		return;

	std::vector<std::vector<tquadratic *="">> quads;</std::vector<tquadratic>

	std::vector<tquadratic *=""> toBeDeleted;</tquadratic>

	std::vector<tquadratic *=""> quadArray;</tquadratic>

	PointVector2QuadsArray(*(m_ro.m_exterior.begin()), quadArray, toBeDeleted, isRounded);

	quads.push_back(quadArray);

	TRegionOutline::Boundary::const_iterator iinter = m_ro.m_interior.begin();

	TRegionOutline::Boundary::const_iterator iinter_end = m_ro.m_interior.end();

	for (; iinter != iinter_end; iinter++) {

		PointVector2QuadsArray(*iinter, quadArray, toBeDeleted, isRounded);

		quads.push_back(quadArray);

	}

	flash.drawPolygon(quads);

	clearPointerContainer(toBeDeleted);

}

int SFlashUtils::nbDiffVerts(const std::vector<tpointd> &pv) const</tpointd>

{

	std::vector<tpointd> lpv;</tpointd>

	bool isMissing[4] = {true, true, true, true};

	if (pv.size() == 0)

		return 0;

	lpv.push_back(pv[0]);

	isMissing[0] = false;

	for (int i = 1; i < (int)pv.size(); i++) {

		bool isDiff = true;

		for (int j = 0; j < (int)lpv.size() && isDiff; j++)

			isDiff = lpv[j] == pv[i] ? false : isDiff;

		if (isDiff) {

			lpv.push_back(pv[i]);

			isMissing[i] = false;

		}

	}

	return lpv.size();

}

/*

	TPointD p[3];

	TPixel32 col[2];

//	TPixel32 lc1,lc2;

	if ( pv[0]==pv[1] ) {

		p[0]=pv[0];

		p[1]=pv[2];

		p[2]=pv[3];

		col[0]=c1;

		col[1]=c2;

	} else if ( pv[0]==pv[2] ) {

		p[0]=pv[3];

		p[1]=pv[0];

		p[2]=pv[1];

		col[0]=c2;

		col[1]=c1;

	} else if ( pv[0]==pv[3] ) {

		p[0]=pv[2];

		p[1]=pv[0];

		p[2]=pv[1];

		col[0]=c2;

		col[1]=c1;

	} else if ( pv[1]==pv[2] ) {

		p[0]=pv[3];

		p[1]=pv[0];

		p[2]=pv[1];

		col[0]=c2;

		col[1]=c1;

	} else if ( pv[1]==pv[3] ) {

		p[0]=pv[2];

		p[1]=pv[0];

		p[2]=pv[1];

		col[0]=c2;

		col[1]=c1;

	} else if ( pv[2]==pv[3] ) {

		p[0]=pv[2];

		p[1]=pv[0];

		p[2]=pv[1];

		col[0]=c2;

		col[1]=c1;

	} 

	TPointD pt1[4]={pv[0],pv[1],pv[2],pv[3]};	

	TPointD pt2[3]={p[0],p[1],p[2]};	

	TPointD uu=p[0]-p[1];

	TPointD up=(p[0]+p[1])*0.5;

	uu=normalize(uu);

	uu=rotate90(uu);

	TPointD up1=up+uu;

	TPointD up2=up-uu;

	double d1=tdistance(up1,p[2]);

	double d2=tdistance(up2,p[2]);

	std::vector<tpointd> lpv;</tpointd>

	if ( d1>d2 ) {

		lpv=pv;

	} else {

		TPointD sw=p[1];

		p[1]=p[2];

		p[2]=sw;

	}

	double a=tdistance(p[1],p[2]);

	double b=tdistance(p[2],p[0]);

	double c=tdistance(p[0],p[1]);

	double x=(b*b-c*c-a*a)/(-2.0*a);

	double m=sqrt(c*c-x*x);

	TPointD u=p[2]-p[1];

	u=normalize(u);

	TPointD q(p[1]+u*x);

    const double flashGrad=16384.0;  // size of gradient square

    flash.setGradientFill(true,col[0],col[1]);

//	TPointD center=pv[0]*0.75+((p[1]+p[2])*0.5)*0.25;

	TPointD center=pv[0];

	TPointD e(p[2]-p[1]);

	double angle=rad2degree(atan(e));

	angle= angle<=0 ? 270+angle : angle-90;

    TRotation rM(angle);

	TTranslation tM(center.x,center.y);

	TScale sM(m/flashGrad,2*tmax(x,a-x)/flashGrad);

    flash.setFillStyleMatrix(tM*rM*sM);

	std::vector<tpointd> pp;</tpointd>

	pp.push_back(p[0]);

	pp.push_back(p[1]);

	pp.push_back(p[2]);

    flash.drawPolyline(pp);	

*/

void SFlashUtils::Triangle2Quad(std::vector<tpointd> &p) const</tpointd>

{

	TPointD e;

	int i, j;

	i = j = -1;

	if (p[0] == p[1]) {

		i = 0;

		j = 1;

		e = p[2] - p[3];

	} else if (p[0] == p[2]) {

	} else if (p[0] == p[3]) {

		i = 0;

		j = 3;

		e = p[2] - p[1];

	} else if (p[1] == p[2]) {

		i = 1;

		j = 2;

		e = p[3] - p[0];

	} else if (p[1] == p[3]) {

	} else if (p[2] == p[3]) {

		i = 2;

		j = 3;

		e = p[0] - p[1];

	}

	e = normalize(e);

	p[j] = p[i] + e * 0.001;

}

void SFlashUtils::drawGradedPolyline(TFlash &flash,

									 std::vector<tpointd> &pvv,</tpointd>

									 const TPixel32 &c1,

									 const TPixel32 &c2) const

{

	std::vector<tpointd> pv;</tpointd>

	pv = pvv;

	int nbDV = nbDiffVerts(pv);

	if (nbDV < 3 || nbDV > 4)

		return;

	if (nbDV == 3)

		Triangle2Quad(pv);

	// Direction Of polyline

	TPointD u = pv[0] - pv[1];

	TPointD up = (pv[0] + pv[1]) * 0.5;

	u = normalize(u);

	u = rotate90(u);

	TPointD up1 = up + u;

	TPointD up2 = up - u;

	double d1 = (tdistance(up1, pv[2]) + tdistance(up1, pv[3])) * 0.5;

	double d2 = (tdistance(up2, pv[2]) + tdistance(up2, pv[3])) * 0.5;

	std::vector<tpointd> lpv;</tpointd>

	if (d1 > d2) {

		lpv = pv;

	} else {

		lpv.push_back(pv[1]);

		lpv.push_back(pv[0]);

		lpv.push_back(pv[3]);

		lpv.push_back(pv[2]);

	}

	// Transformation of gradient square

	const double flashGrad = 16384.0; // size of gradient square

	flash.setGradientFill(true, c1, c2, 0);

	TPointD p0((lpv[0] + lpv[3]) * 0.5);

	TPointD p1((lpv[1] + lpv[2]) * 0.5);

	double lv = (tdistance(p0, p1));

	double lh = 0.5 * (tdistance(lpv[0], lpv[3]) + tdistance(lpv[1], lpv[2]));

	TPointD center = 0.25 * lpv[0] + 0.25 * lpv[1] + 0.25 * lpv[2] + 0.25 * lpv[3];

	TPointD e(p0 - p1);

	double angle = rad2degree(atan(e));

	angle = angle <= 0 ? 270 + angle : angle - 90;

	TRotation rM(angle);

	TTranslation tM(center.x, center.y);

	TScale sM(lh / (flashGrad), lv / (flashGrad));

	flash.setFillStyleMatrix(tM * sM * rM);

	flash.drawPolyline(pv);

}

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

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

void SFlashUtils::drawGradedRegion(TFlash &flash,

								   std::vector<tpointd> &pvv,</tpointd>

								   const TPixel32 &c1,

								   const TPixel32 &c2, const TRegion &r) const

{

	std::vector<tpointd> pv;</tpointd>

	pv = pvv;

	int nbDV = nbDiffVerts(pv);

	if (nbDV < 3 || nbDV > 4)

		return;

	if (nbDV == 3)

		Triangle2Quad(pv);

	// Direction Of polyline

	TPointD u = pv[0] - pv[1];

	TPointD up = (pv[0] + pv[1]) * 0.5;

	u = normalize(u);

	u = rotate90(u);

	TPointD up1 = up + u;

	TPointD up2 = up - u;

	double d1 = (tdistance(up1, pv[2]) + tdistance(up1, pv[3])) * 0.5;

	double d2 = (tdistance(up2, pv[2]) + tdistance(up2, pv[3])) * 0.5;

	std::vector<tpointd> lpv;</tpointd>

	if (d1 > d2) {

		lpv = pv;

	} else {

		lpv.push_back(pv[1]);

		lpv.push_back(pv[0]);

		lpv.push_back(pv[3]);

		lpv.push_back(pv[2]);

	}

	// Transformation of gradient square

	const double flashGrad = 16384.0; // size of gradient square

	flash.setGradientFill(true, c1, c2, 0);

	TPointD p0((lpv[0] + lpv[3]) * 0.5);

	TPointD p1((lpv[1] + lpv[2]) * 0.5);

	double lv = (tdistance(p0, p1));

	double lh = 0.5 * (tdistance(lpv[0], lpv[3]) + tdistance(lpv[1], lpv[2]));

	TPointD center = 0.25 * lpv[0] + 0.25 * lpv[1] + 0.25 * lpv[2] + 0.25 * lpv[3];

	TPointD e(p0 - p1);

	double angle = rad2degree(atan(e));

	angle = angle <= 0 ? 270 + angle : angle - 90;

	TRotation rM(angle);

	TTranslation tM(center.x, center.y);

	TScale sM(lh / (flashGrad), lv / (flashGrad));

	flash.setFillStyleMatrix(tM * sM * rM);

	flash.drawRegion(r);

}