|
Toshihiro Shimizu |
890ddd |
|
|
Toshihiro Shimizu |
890ddd |
|
|
Toshihiro Shimizu |
890ddd |
//#include "tutil.h"
|
|
Toshihiro Shimizu |
890ddd |
//#include "tgl.h"
|
|
Toshihiro Shimizu |
890ddd |
#include "colorfxutils.h"
|
|
Toshihiro Shimizu |
890ddd |
#include "drawutil.h"
|
|
Toshihiro Shimizu |
890ddd |
#include "tregion.h"
|
|
Toshihiro Shimizu |
890ddd |
#include "tflash.h"
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
RubberDeform::RubberDeform() : m_pPolyOri(0), m_polyLoc() {}
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
RubberDeform::RubberDeform(std::vector<t3dpointd> *pPolyOri, const double rf)</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
: m_pPolyOri(pPolyOri), m_polyLoc() {
|
|
Shinya Kitaoka |
120a6e |
copyOri2Loc();
|
|
Shinya Kitaoka |
120a6e |
TRectD bbox;
|
|
Shinya Kitaoka |
120a6e |
getBBox(bbox);
|
|
Shinya Kitaoka |
120a6e |
double d = tdistance(TPointD(bbox.x0, bbox.y0), TPointD(bbox.x1, bbox.y1));
|
|
Shinya Kitaoka |
120a6e |
d = d / 20;
|
|
Shinya Kitaoka |
120a6e |
refinePoly(d);
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
RubberDeform::~RubberDeform() {}
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
void RubberDeform::deformStep() {
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd> tmpv;</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd>::iterator itb = m_polyLoc.begin();</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd>::iterator ite = m_polyLoc.end();</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
for (std::vector<t3dpointd>::iterator it = itb; it != ite; ++it) {</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd>::iterator it1 = it == (ite - 1) ? itb : it + 1;</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
double q = 0.5;
|
|
Shinya Kitaoka |
120a6e |
double qq = 1.0 - q;
|
|
Shinya Kitaoka |
120a6e |
tmpv.push_back(T3DPointD(qq * it->x + q * it1->x, qq * it->y + q * it1->y,
|
|
Shinya Kitaoka |
120a6e |
qq * it->z + q * it1->z));
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
m_polyLoc = tmpv;
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
void RubberDeform::deform(const double n) {
|
|
Shinya Kitaoka |
120a6e |
if (n <= 0 || n >= 100) return;
|
|
Shinya Kitaoka |
120a6e |
double q = (double)n / 100.0;
|
|
Shinya Kitaoka |
120a6e |
TRectD bbox;
|
|
Shinya Kitaoka |
120a6e |
getBBox(bbox);
|
|
Shinya Kitaoka |
120a6e |
double d0 = ((bbox.y1 - bbox.y0) * 0.5 + (bbox.x1 - bbox.x0) * 0.5) * 0.5;
|
|
Shinya Kitaoka |
120a6e |
double d = d0;
|
|
Shinya Kitaoka |
120a6e |
while ((d / d0) > q) {
|
|
Shinya Kitaoka |
120a6e |
deformStep();
|
|
Shinya Kitaoka |
120a6e |
getBBox(bbox);
|
|
Shinya Kitaoka |
120a6e |
d = ((bbox.y1 - bbox.y0) * 0.5 + (bbox.x1 - bbox.x0) * 0.5) * 0.5;
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
copyLoc2Ori();
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
double RubberDeform::avgLength() {
|
|
Shinya Kitaoka |
120a6e |
if (m_polyLoc.size() <= 0) return 0.0;
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
double avgD = 0.0;
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd>::iterator itb = m_polyLoc.begin();</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd>::iterator ite = m_polyLoc.end();</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
for (std::vector<t3dpointd>::iterator it = itb; it != ite; ++it) {</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd>::iterator it1 = it == (ite - 1) ? itb : it + 1;</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
avgD += tdistance(*it, *it1);
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
return avgD / (double)m_polyLoc.size();
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
void RubberDeform::getBBox(TRectD &bbox) {
|
|
Shinya Kitaoka |
120a6e |
if (m_polyLoc.size() <= 0) {
|
|
Shinya Kitaoka |
120a6e |
bbox.x0 = bbox.y0 = 0;
|
|
Shinya Kitaoka |
120a6e |
bbox.x1 = bbox.y1 = -1;
|
|
Shinya Kitaoka |
120a6e |
return;
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
bbox.x0 = bbox.x1 = m_polyLoc[0].x;
|
|
Shinya Kitaoka |
120a6e |
bbox.y0 = bbox.y1 = m_polyLoc[0].y;
|
|
Shinya Kitaoka |
120a6e |
for (int i = 1; i < (int)m_polyLoc.size(); i++) {
|
|
Shinya Kitaoka |
120a6e |
bbox.x0 = std::min(bbox.x0, m_polyLoc[i].x);
|
|
Shinya Kitaoka |
120a6e |
bbox.x1 = std::max(bbox.x1, m_polyLoc[i].x);
|
|
Shinya Kitaoka |
120a6e |
bbox.y0 = std::min(bbox.y0, m_polyLoc[i].y);
|
|
Shinya Kitaoka |
120a6e |
bbox.y1 = std::max(bbox.y1, m_polyLoc[i].y);
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
void RubberDeform::refinePoly(const double rf) {
|
|
Shinya Kitaoka |
120a6e |
double refineL = rf <= 0.0 ? avgLength() : rf;
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd> tmpv;</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
int nb = m_polyLoc.size();
|
|
Shinya Kitaoka |
120a6e |
for (int j = 0; j < nb; j++) {
|
|
Shinya Kitaoka |
120a6e |
T3DPointD a(m_polyLoc[j]);
|
|
Shinya Kitaoka |
120a6e |
T3DPointD b(j == (nb - 1) ? m_polyLoc[0] : m_polyLoc[j + 1]);
|
|
Shinya Kitaoka |
120a6e |
tmpv.push_back(a);
|
|
Shinya Kitaoka |
120a6e |
double d = tdistance(a, b);
|
|
Shinya Kitaoka |
120a6e |
if (d > refineL) {
|
|
Shinya Kitaoka |
120a6e |
int n = (int)(d / refineL) + 1;
|
|
Shinya Kitaoka |
120a6e |
double q = 1.0 / (double)n;
|
|
Shinya Kitaoka |
120a6e |
for (int i = 1; i < n; i++) {
|
|
Shinya Kitaoka |
120a6e |
double qq = q * (double)i;
|
|
Shinya Kitaoka |
120a6e |
double qq1 = 1.0 - qq;
|
|
Shinya Kitaoka |
120a6e |
T3DPointD p(T3DPointD(qq1 * a.x + qq * b.x, qq1 * a.y + qq * b.y,
|
|
Shinya Kitaoka |
120a6e |
qq1 * a.z + qq * b.z));
|
|
Shinya Kitaoka |
120a6e |
tmpv.push_back(p);
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
m_polyLoc = tmpv;
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Toshihiro Shimizu |
890ddd |
// ------------------- SFlashUtils -------------------------------------------
|
|
Toshihiro Shimizu |
890ddd |
|
|
Toshihiro Shimizu |
890ddd |
void SFlashUtils::computeOutline(const TRegion *region,
|
|
Shinya Kitaoka |
120a6e |
TRegionOutline::PointVector &polyline) const {
|
|
Shinya Kitaoka |
120a6e |
if (!region) return;
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
const double pixelSize = 1.0;
|
|
Shinya Kitaoka |
120a6e |
polyline.clear();
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
std::vector<tpointd> polyline2d;</tpointd>
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
int edgeSize = region->getEdgeCount();
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
for (int i = 0; i < edgeSize; i++) {
|
|
Shinya Kitaoka |
120a6e |
TEdge &edge = *region->getEdge(i);
|
|
Shinya Kitaoka |
120a6e |
stroke2polyline(polyline2d, *edge.m_s, pixelSize, edge.m_w0, edge.m_w1);
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
int pointNumber = polyline2d.size();
|
|
Shinya Kitaoka |
120a6e |
polyline.reserve(pointNumber);
|
|
Shinya Kitaoka |
120a6e |
for (int j = 0; j < pointNumber; j++) {
|
|
Shinya Kitaoka |
120a6e |
polyline.push_back(T3DPointD(polyline2d[j], 0.0));
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
void SFlashUtils::computeRegionOutline() {
|
|
Shinya Kitaoka |
120a6e |
if (!m_r) return;
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
int subRegionNumber = m_r->getSubregionCount();
|
|
Shinya Kitaoka |
120a6e |
TRegionOutline::PointVector app;
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
m_ro.m_exterior.clear();
|
|
Shinya Kitaoka |
120a6e |
computeOutline(m_r, app);
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
m_ro.m_exterior.push_back(app);
|
|
Shinya Kitaoka |
120a6e |
m_ro.m_interior.clear();
|
|
Shinya Kitaoka |
120a6e |
m_ro.m_interior.reserve(subRegionNumber);
|
|
Shinya Kitaoka |
120a6e |
for (int i = 0; i < subRegionNumber; i++) {
|
|
Shinya Kitaoka |
120a6e |
app.clear();
|
|
Shinya Kitaoka |
120a6e |
computeOutline(m_r->getSubregion(i), app);
|
|
Shinya Kitaoka |
120a6e |
m_ro.m_interior.push_back(app);
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
m_ro.m_bbox = m_r->getBBox();
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
3bfa54 |
void SFlashUtils::PointVector2QuadsArray(const std::vector<t3dpointd> &pv,</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
std::vector<tquadratic *=""> &quadArray,</tquadratic>
|
|
Shinya Kitaoka |
120a6e |
std::vector<tquadratic *=""> &toBeDeleted,</tquadratic>
|
|
Shinya Kitaoka |
120a6e |
const bool isRounded) const {
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd>::const_iterator ipv = pv.begin();</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
std::vector<t3dpointd>::const_iterator ipve = pv.end();</t3dpointd>
|
|
Shinya Kitaoka |
120a6e |
int nbPv = pv.size();
|
|
Shinya Kitaoka |
120a6e |
quadArray.clear();
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
if (isRounded) {
|
|
Shinya Kitaoka |
120a6e |
if (nbPv <= 2) {
|
|
Shinya Kitaoka |
120a6e |
if (nbPv == 1) {
|
|
Shinya Kitaoka |
120a6e |
TPointD p0, p1, p2;
|
|
Shinya Kitaoka |
120a6e |
p0 = TPointD(pv[0].x, pv[0].y);
|
|
Shinya Kitaoka |
120a6e |
p1 = TPointD(pv[0].x, pv[0].y);
|
|
Shinya Kitaoka |
120a6e |
p2 = TPointD(pv[0].x, pv[0].y);
|
|
Shinya Kitaoka |
120a6e |
quadArray.push_back(new TQuadratic(p0, p1, p2));
|
|
Shinya Kitaoka |
120a6e |
toBeDeleted.push_back(quadArray.back());
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
if (nbPv == 2) {
|
|
Shinya Kitaoka |
120a6e |
TPointD p0, p1, p2;
|
|
Shinya Kitaoka |
120a6e |
p0 = TPointD(pv[0].x, pv[0].y);
|
|
Shinya Kitaoka |
120a6e |
p1 = TPointD((pv[0].x + pv[1].x) / 2, (pv[0].y + pv[1].y) / 2);
|
|
Shinya Kitaoka |
120a6e |
p2 = TPointD(pv[1].x, pv[1].y);
|
|
Shinya Kitaoka |
120a6e |
quadArray.push_back(new TQuadratic(p0, p1, p2));
|
|
Shinya Kitaoka |
120a6e |
toBeDeleted.push_back(quadArray.back());
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
return;
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
for (int i = 0; i < (nbPv - 2); i++) {
|
|
Shinya Kitaoka |
120a6e |
TPointD p0, p1, p2;
|
|
Shinya Kitaoka |
120a6e |
p0 = TPointD((pv[i].x + pv[i + 1].x) / 2, (pv[i].y + pv[i + 1].y) / 2);
|
|
Shinya Kitaoka |
120a6e |
p1 = TPointD(pv[i + 1].x, pv[i + 1].y);
|
|
Shinya Kitaoka |
120a6e |
p2 = TPointD((pv[i + 1].x + pv[i + 2].x) / 2,
|
|
Shinya Kitaoka |
120a6e |
(pv[i + 1].y + pv[i + 2].y) / 2);
|
|
Shinya Kitaoka |
120a6e |
quadArray.push_back(new TQuadratic(p0, p1, p2));
|
|
Shinya Kitaoka |
120a6e |
toBeDeleted.push_back(quadArray.back());
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
TPointD p0, p1, p2;
|
|
Shinya Kitaoka |
120a6e |
p0 = TPointD((pv[nbPv - 2].x + pv[nbPv - 1].x) / 2,
|
|
Shinya Kitaoka |
120a6e |
(pv[nbPv - 2].y + pv[nbPv - 1].y) / 2);
|
|
Shinya Kitaoka |
120a6e |
p1 = TPointD(pv[nbPv - 1].x, pv[nbPv - 1].y);
|
|
Shinya Kitaoka |
120a6e |
p2 = TPointD((pv[0].x + pv[1].x) / 2, (pv[0].y + pv[1].y) / 2);
|
|
Shinya Kitaoka |
120a6e |
quadArray.push_back(new TQuadratic(p0, p1, p2));
|
|
Shinya Kitaoka |
120a6e |
toBeDeleted.push_back(quadArray.back());
|
|
Shinya Kitaoka |
120a6e |
} else {
|
|
Shinya Kitaoka |
120a6e |
for (int i = 0; i < (nbPv - 1); i++) {
|
|
Shinya Kitaoka |
120a6e |
TPointD p0, p1, p2;
|
|
Shinya Kitaoka |
120a6e |
p0 = TPointD(pv[i].x, pv[i].y);
|
|
Shinya Kitaoka |
120a6e |
p2 = TPointD(pv[i + 1].x, pv[i + 1].y);
|
|
Shinya Kitaoka |
120a6e |
p1 = TPointD((p0.x + p2.x) * 0.5, (p0.y + p2.y) * 0.5);
|
|
Shinya Kitaoka |
120a6e |
quadArray.push_back(new TQuadratic(p0, p1, p2));
|
|
Shinya Kitaoka |
120a6e |
toBeDeleted.push_back(quadArray.back());
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
TPointD p0, p1, p2;
|
|
Shinya Kitaoka |
120a6e |
p0 = TPointD(pv[nbPv - 1].x, pv[nbPv - 1].y);
|
|
Shinya Kitaoka |
120a6e |
p2 = TPointD(pv[0].x, pv[0].y);
|
|
Shinya Kitaoka |
120a6e |
p1 = TPointD((p0.x + p2.x) * 0.5, (p0.y + p2.y) * 0.5);
|
|
Shinya Kitaoka |
120a6e |
quadArray.push_back(new TQuadratic(p0, p1, p2));
|
|
Shinya Kitaoka |
120a6e |
toBeDeleted.push_back(quadArray.back());
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
void SFlashUtils::drawRegionOutline(TFlash &flash, const bool isRounded) const {
|
|
Shinya Kitaoka |
120a6e |
if (!m_r) return;
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
std::vector<std::vector<tquadratic *="">> quads;</std::vector<tquadratic>
|
|
Shinya Kitaoka |
120a6e |
std::vector<tquadratic *=""> toBeDeleted;</tquadratic>
|
|
Shinya Kitaoka |
120a6e |
std::vector<tquadratic *=""> quadArray;</tquadratic>
|
|
Shinya Kitaoka |
120a6e |
PointVector2QuadsArray(*(m_ro.m_exterior.begin()), quadArray, toBeDeleted,
|
|
Shinya Kitaoka |
120a6e |
isRounded);
|
|
Shinya Kitaoka |
120a6e |
quads.push_back(quadArray);
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
TRegionOutline::Boundary::const_iterator iinter = m_ro.m_interior.begin();
|
|
Shinya Kitaoka |
120a6e |
TRegionOutline::Boundary::const_iterator iinter_end = m_ro.m_interior.end();
|
|
Shinya Kitaoka |
120a6e |
for (; iinter != iinter_end; iinter++) {
|
|
Shinya Kitaoka |
120a6e |
PointVector2QuadsArray(*iinter, quadArray, toBeDeleted, isRounded);
|
|
Shinya Kitaoka |
120a6e |
quads.push_back(quadArray);
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
flash.drawPolygon(quads);
|
|
Shinya Kitaoka |
120a6e |
clearPointerContainer(toBeDeleted);
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
int SFlashUtils::nbDiffVerts(const std::vector<tpointd> &pv) const {</tpointd>
|
|
Shinya Kitaoka |
120a6e |
std::vector<tpointd> lpv;</tpointd>
|
|
Shinya Kitaoka |
120a6e |
bool isMissing[4] = {true, true, true, true};
|
|
Shinya Kitaoka |
120a6e |
if (pv.size() == 0) return 0;
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[0]);
|
|
Shinya Kitaoka |
120a6e |
isMissing[0] = false;
|
|
Shinya Kitaoka |
120a6e |
for (int i = 1; i < (int)pv.size(); i++) {
|
|
Shinya Kitaoka |
120a6e |
bool isDiff = true;
|
|
Shinya Kitaoka |
120a6e |
for (int j = 0; j < (int)lpv.size() && isDiff; j++)
|
|
Shinya Kitaoka |
120a6e |
isDiff = lpv[j] == pv[i] ? false : isDiff;
|
|
Shinya Kitaoka |
120a6e |
if (isDiff) {
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[i]);
|
|
Shinya Kitaoka |
120a6e |
isMissing[i] = false;
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
return lpv.size();
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
void SFlashUtils::Triangle2Quad(std::vector<tpointd> &p) const {</tpointd>
|
|
Shinya Kitaoka |
120a6e |
TPointD e;
|
|
Shinya Kitaoka |
120a6e |
int i, j;
|
|
Shinya Kitaoka |
120a6e |
i = j = -1;
|
|
Shinya Kitaoka |
120a6e |
if (p[0] == p[1]) {
|
|
Shinya Kitaoka |
120a6e |
i = 0;
|
|
Shinya Kitaoka |
120a6e |
j = 1;
|
|
Shinya Kitaoka |
120a6e |
e = p[2] - p[3];
|
|
Shinya Kitaoka |
120a6e |
} else if (p[0] == p[2]) {
|
|
Shinya Kitaoka |
120a6e |
} else if (p[0] == p[3]) {
|
|
Shinya Kitaoka |
120a6e |
i = 0;
|
|
Shinya Kitaoka |
120a6e |
j = 3;
|
|
Shinya Kitaoka |
120a6e |
e = p[2] - p[1];
|
|
Shinya Kitaoka |
120a6e |
} else if (p[1] == p[2]) {
|
|
Shinya Kitaoka |
120a6e |
i = 1;
|
|
Shinya Kitaoka |
120a6e |
j = 2;
|
|
Shinya Kitaoka |
120a6e |
e = p[3] - p[0];
|
|
Shinya Kitaoka |
120a6e |
} else if (p[1] == p[3]) {
|
|
Shinya Kitaoka |
120a6e |
} else if (p[2] == p[3]) {
|
|
Shinya Kitaoka |
120a6e |
i = 2;
|
|
Shinya Kitaoka |
120a6e |
j = 3;
|
|
Shinya Kitaoka |
120a6e |
e = p[0] - p[1];
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
e = normalize(e);
|
|
Shinya Kitaoka |
120a6e |
p[j] = p[i] + e * 0.001;
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Shinya Kitaoka |
120a6e |
void SFlashUtils::drawGradedPolyline(TFlash &flash, std::vector<tpointd> &pvv,</tpointd>
|
|
Shinya Kitaoka |
120a6e |
const TPixel32 &c1,
|
|
Shinya Kitaoka |
120a6e |
const TPixel32 &c2) const {
|
|
Shinya Kitaoka |
120a6e |
std::vector<tpointd> pv;</tpointd>
|
|
Shinya Kitaoka |
120a6e |
pv = pvv;
|
|
Shinya Kitaoka |
120a6e |
int nbDV = nbDiffVerts(pv);
|
|
Shinya Kitaoka |
120a6e |
if (nbDV < 3 || nbDV > 4) return;
|
|
Shinya Kitaoka |
120a6e |
if (nbDV == 3) Triangle2Quad(pv);
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
// Direction Of polyline
|
|
Shinya Kitaoka |
120a6e |
TPointD u = pv[0] - pv[1];
|
|
Shinya Kitaoka |
120a6e |
TPointD up = (pv[0] + pv[1]) * 0.5;
|
|
Shinya Kitaoka |
120a6e |
u = normalize(u);
|
|
Shinya Kitaoka |
120a6e |
u = rotate90(u);
|
|
Shinya Kitaoka |
120a6e |
TPointD up1 = up + u;
|
|
Shinya Kitaoka |
120a6e |
TPointD up2 = up - u;
|
|
Shinya Kitaoka |
120a6e |
double d1 = (tdistance(up1, pv[2]) + tdistance(up1, pv[3])) * 0.5;
|
|
Shinya Kitaoka |
120a6e |
double d2 = (tdistance(up2, pv[2]) + tdistance(up2, pv[3])) * 0.5;
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
std::vector<tpointd> lpv;</tpointd>
|
|
Shinya Kitaoka |
120a6e |
if (d1 > d2) {
|
|
Shinya Kitaoka |
120a6e |
lpv = pv;
|
|
Shinya Kitaoka |
120a6e |
} else {
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[1]);
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[0]);
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[3]);
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[2]);
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
// Transformation of gradient square
|
|
Shinya Kitaoka |
120a6e |
const double flashGrad = 16384.0; // size of gradient square
|
|
Shinya Kitaoka |
120a6e |
flash.setGradientFill(true, c1, c2, 0);
|
|
Shinya Kitaoka |
120a6e |
TPointD p0((lpv[0] + lpv[3]) * 0.5);
|
|
Shinya Kitaoka |
120a6e |
TPointD p1((lpv[1] + lpv[2]) * 0.5);
|
|
Shinya Kitaoka |
120a6e |
double lv = (tdistance(p0, p1));
|
|
Shinya Kitaoka |
120a6e |
double lh = 0.5 * (tdistance(lpv[0], lpv[3]) + tdistance(lpv[1], lpv[2]));
|
|
Shinya Kitaoka |
120a6e |
TPointD center =
|
|
Shinya Kitaoka |
120a6e |
0.25 * lpv[0] + 0.25 * lpv[1] + 0.25 * lpv[2] + 0.25 * lpv[3];
|
|
Shinya Kitaoka |
120a6e |
TPointD e(p0 - p1);
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
double angle = rad2degree(atan(e));
|
|
Shinya Kitaoka |
120a6e |
angle = angle <= 0 ? 270 + angle : angle - 90;
|
|
Shinya Kitaoka |
120a6e |
TRotation rM(angle);
|
|
Shinya Kitaoka |
120a6e |
TTranslation tM(center.x, center.y);
|
|
Shinya Kitaoka |
120a6e |
TScale sM(lh / (flashGrad), lv / (flashGrad));
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
flash.setFillStyleMatrix(tM * sM * rM);
|
|
Shinya Kitaoka |
120a6e |
flash.drawPolyline(pv);
|
|
Toshihiro Shimizu |
890ddd |
}
|
|
Toshihiro Shimizu |
890ddd |
|
|
Toshihiro Shimizu |
890ddd |
//------------------------------------------------------------
|
|
Toshihiro Shimizu |
890ddd |
|
|
Toshihiro Shimizu |
890ddd |
//------------------------------------------------------------
|
|
Shinya Kitaoka |
120a6e |
void SFlashUtils::drawGradedRegion(TFlash &flash, std::vector<tpointd> &pvv,</tpointd>
|
|
Shinya Kitaoka |
120a6e |
const TPixel32 &c1, const TPixel32 &c2,
|
|
Shinya Kitaoka |
120a6e |
const TRegion &r) const {
|
|
Shinya Kitaoka |
120a6e |
std::vector<tpointd> pv;</tpointd>
|
|
Shinya Kitaoka |
120a6e |
pv = pvv;
|
|
Shinya Kitaoka |
120a6e |
int nbDV = nbDiffVerts(pv);
|
|
Shinya Kitaoka |
120a6e |
if (nbDV < 3 || nbDV > 4) return;
|
|
Shinya Kitaoka |
120a6e |
if (nbDV == 3) Triangle2Quad(pv);
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
// Direction Of polyline
|
|
Shinya Kitaoka |
120a6e |
TPointD u = pv[0] - pv[1];
|
|
Shinya Kitaoka |
120a6e |
TPointD up = (pv[0] + pv[1]) * 0.5;
|
|
Shinya Kitaoka |
120a6e |
u = normalize(u);
|
|
Shinya Kitaoka |
120a6e |
u = rotate90(u);
|
|
Shinya Kitaoka |
120a6e |
TPointD up1 = up + u;
|
|
Shinya Kitaoka |
120a6e |
TPointD up2 = up - u;
|
|
Shinya Kitaoka |
120a6e |
double d1 = (tdistance(up1, pv[2]) + tdistance(up1, pv[3])) * 0.5;
|
|
Shinya Kitaoka |
120a6e |
double d2 = (tdistance(up2, pv[2]) + tdistance(up2, pv[3])) * 0.5;
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
std::vector<tpointd> lpv;</tpointd>
|
|
Shinya Kitaoka |
120a6e |
if (d1 > d2) {
|
|
Shinya Kitaoka |
120a6e |
lpv = pv;
|
|
Shinya Kitaoka |
120a6e |
} else {
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[1]);
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[0]);
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[3]);
|
|
Shinya Kitaoka |
120a6e |
lpv.push_back(pv[2]);
|
|
Shinya Kitaoka |
120a6e |
}
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
// Transformation of gradient square
|
|
Shinya Kitaoka |
120a6e |
const double flashGrad = 16384.0; // size of gradient square
|
|
Shinya Kitaoka |
120a6e |
flash.setGradientFill(true, c1, c2, 0);
|
|
Shinya Kitaoka |
120a6e |
TPointD p0((lpv[0] + lpv[3]) * 0.5);
|
|
Shinya Kitaoka |
120a6e |
TPointD p1((lpv[1] + lpv[2]) * 0.5);
|
|
Shinya Kitaoka |
120a6e |
double lv = (tdistance(p0, p1));
|
|
Shinya Kitaoka |
120a6e |
double lh = 0.5 * (tdistance(lpv[0], lpv[3]) + tdistance(lpv[1], lpv[2]));
|
|
Shinya Kitaoka |
120a6e |
TPointD center =
|
|
Shinya Kitaoka |
120a6e |
0.25 * lpv[0] + 0.25 * lpv[1] + 0.25 * lpv[2] + 0.25 * lpv[3];
|
|
Shinya Kitaoka |
120a6e |
TPointD e(p0 - p1);
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
double angle = rad2degree(atan(e));
|
|
Shinya Kitaoka |
120a6e |
angle = angle <= 0 ? 270 + angle : angle - 90;
|
|
Shinya Kitaoka |
120a6e |
TRotation rM(angle);
|
|
Shinya Kitaoka |
120a6e |
TTranslation tM(center.x, center.y);
|
|
Shinya Kitaoka |
120a6e |
TScale sM(lh / (flashGrad), lv / (flashGrad));
|
|
Shinya Kitaoka |
120a6e |
|
|
Shinya Kitaoka |
120a6e |
flash.setFillStyleMatrix(tM * sM * rM);
|
|
Shinya Kitaoka |
120a6e |
flash.drawRegion(r);
|
|
Toshihiro Shimizu |
890ddd |
}
|