bw / opentoonz

Clone
Source Code
GIT

Files

  1.   1660e0d6271878a4ce63788238931d0d32bc9f30
  2.   toonz
  3.   sources
  4.   colorfx
  5.   colorfxutils.cpp
Blob Blame Raw 


//#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),
																		   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;
	std::vector<T3DPointD>::iterator itb = m_polyLoc.begin();
	std::vector<T3DPointD>::iterator ite = m_polyLoc.end();
	for (std::vector<T3DPointD>::iterator it = itb; it != ite; ++it) {
		std::vector<T3DPointD>::iterator it1 = it == (ite - 1) ? itb : it + 1;
		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();
	std::vector<T3DPointD>::iterator ite = m_polyLoc.end();
	for (std::vector<T3DPointD>::iterator it = itb; it != ite; ++it) {
		std::vector<T3DPointD>::iterator it1 = it == (ite - 1) ? itb : it + 1;
		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;
	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;

	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,
										 std::vector<TQuadratic *> &quadArray,
										 std::vector<TQuadratic *> &toBeDeleted,
										 const bool isRounded) const
{
	std::vector<T3DPointD>::const_iterator ipv = pv.begin();
	std::vector<T3DPointD>::const_iterator ipve = pv.end();
	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 *> toBeDeleted;
	std::vector<TQuadratic *> quadArray;
	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
{
	std::vector<TPointD> lpv;
	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;
	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;
	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 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,
									 const TPixel32 &c1,
									 const TPixel32 &c2) const
{
	std::vector<TPointD> pv;
	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;
	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,
								   const TPixel32 &c1,
								   const TPixel32 &c2, const TRegion &r) const
{
	std::vector<TPointD> pv;
	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;
	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);
}

Powered by Pagure 5.7.4

SSH Hostkey/Fingerprint | Documentation | About

© 2014-2019 Red Hat, Inc. and others.

Logo by Pavel Lashutin