968 lines
36 KiB
C++
968 lines
36 KiB
C++
//
|
|
// Created by natty on 15.7.23.
|
|
//
|
|
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <format>
|
|
#include <iostream>
|
|
#include "svgpathextractor.h"
|
|
#include "renderwindow.h"
|
|
|
|
template<typename T>
|
|
std::pair<T, std::string_view::const_iterator> map(std::pair<std::string_view, std::string_view::const_iterator> in);
|
|
|
|
template<>
|
|
std::pair<double, std::string_view::const_iterator> map(std::pair<std::string_view, std::string_view::const_iterator> in) {
|
|
return { std::stod(std::string(in.first)), in.second };
|
|
}
|
|
|
|
template<>
|
|
std::pair<bool, std::string_view::const_iterator> map(std::pair<std::string_view, std::string_view::const_iterator> in) {
|
|
if (in.first == "0") {
|
|
return { false, in.second };
|
|
} else if (in.first == "1") {
|
|
return { true, in.second };
|
|
} else {
|
|
throw std::runtime_error(std::format("Flag parse error: {}", in.first));
|
|
}
|
|
}
|
|
|
|
std::string_view::const_iterator skipWhitespace(std::string_view::const_iterator path, std::string_view::const_iterator end) {
|
|
auto it = path;
|
|
while (it != end && (*it == ' ' || *it == '\t' || *it == '\xA' || *it == '\xC' || *it == '\xD')) {
|
|
++it;
|
|
}
|
|
return it;
|
|
}
|
|
|
|
std::string_view::const_iterator skipComma(std::string_view::const_iterator path, std::string_view::const_iterator end) {
|
|
auto it = path;
|
|
while (it != end && (*it == ',')) {
|
|
++it;
|
|
}
|
|
return it;
|
|
}
|
|
|
|
std::string_view::const_iterator skipSeparators(std::string_view::const_iterator path, std::string_view::const_iterator end) {
|
|
return skipWhitespace(skipComma(skipWhitespace(path, end), end), end);
|
|
}
|
|
|
|
std::pair<std::string_view, std::string_view::const_iterator> throwIfEmpty(std::pair<std::string_view, std::string_view::const_iterator> in) {
|
|
if (in.first.empty()) {
|
|
throw std::runtime_error("Unexpect end of input");
|
|
}
|
|
|
|
return in;
|
|
}
|
|
|
|
std::pair<std::string_view, std::string_view::const_iterator> nomDouble(std::string_view::const_iterator path, std::string_view::const_iterator end) {
|
|
auto it = path;
|
|
while (it != end && (*it == '-' && it == path || *it == '.' || (*it >= '0' && *it <= '9'))) {
|
|
++it;
|
|
}
|
|
return {{ &*path, static_cast<size_t>(it - path) }, it};
|
|
}
|
|
|
|
std::pair<std::string_view, std::string_view::const_iterator> nomFlag(std::string_view::const_iterator path, std::string_view::const_iterator end) {
|
|
auto it = path;
|
|
while (it != end && ((*it == '0' || *it == '1'))) {
|
|
++it;
|
|
}
|
|
return {{ &*path, static_cast<size_t>(it - path) }, it};
|
|
}
|
|
|
|
enum class CommandType {
|
|
Move,
|
|
Line,
|
|
HorLine,
|
|
VerLine,
|
|
Curve,
|
|
SmoothCurve,
|
|
Quadratic,
|
|
SmoothQuadratic,
|
|
EllipticalArc,
|
|
ClosePath
|
|
};
|
|
|
|
std::ostream& operator<< (std::ostream& stream, const CommandType& type) {
|
|
switch (type)
|
|
{
|
|
case CommandType::Move:
|
|
stream << "Move";
|
|
break;
|
|
case CommandType::Line:
|
|
stream << "Line";
|
|
break;
|
|
case CommandType::HorLine:
|
|
stream << "HorLine";
|
|
break;
|
|
case CommandType::VerLine:
|
|
stream << "VerLine";
|
|
break;
|
|
case CommandType::Curve:
|
|
stream << "Curve";
|
|
break;
|
|
case CommandType::SmoothCurve:
|
|
stream << "SmoothCurve";
|
|
break;
|
|
case CommandType::Quadratic:
|
|
stream << "Quadratic";
|
|
break;
|
|
case CommandType::SmoothQuadratic:
|
|
stream << "SmoothQuadratic";
|
|
break;
|
|
case CommandType::EllipticalArc:
|
|
stream << "EllipticalArc";
|
|
break;
|
|
case CommandType::ClosePath:
|
|
stream << "ClosePath";
|
|
break;
|
|
}
|
|
|
|
return stream;
|
|
}
|
|
|
|
struct Command {
|
|
CommandType type;
|
|
bool relative;
|
|
};
|
|
|
|
std::ostream& operator<< (std::ostream& stream, const Command& command) {
|
|
stream << command.type;
|
|
if (command.relative) {
|
|
stream << "Relative";
|
|
}
|
|
return stream;
|
|
}
|
|
|
|
struct Token {
|
|
enum class Type {
|
|
Command,
|
|
Number,
|
|
End,
|
|
Unknown
|
|
} type;
|
|
union TokenData {
|
|
double value;
|
|
Command command;
|
|
} data;
|
|
};
|
|
|
|
std::ostream& operator<< (std::ostream& stream, const Token& token) {
|
|
switch (token.type) {
|
|
case Token::Type::Command:
|
|
stream << token.data.command;
|
|
break;
|
|
case Token::Type::Number:
|
|
stream << token.data.value;
|
|
break;
|
|
case Token::Type::End:
|
|
stream << "End";
|
|
break;
|
|
case Token::Type::Unknown:
|
|
stream << "Unknown";
|
|
break;
|
|
}
|
|
return stream;
|
|
}
|
|
|
|
std::pair<Token, std::string_view::const_iterator> nomToken(bool skipSeparator, std::string_view::const_iterator it, std::string_view::const_iterator end)
|
|
{
|
|
if (skipSeparator)
|
|
it = skipSeparators(it, end);
|
|
else
|
|
it = skipWhitespace(it, end);
|
|
|
|
if (it == end) {
|
|
return {{ .type = Token::Type::End }, it};
|
|
}
|
|
|
|
std::optional<CommandType> commandType;
|
|
switch (std::tolower(*it)) {
|
|
case 'm':
|
|
commandType = CommandType::Move;
|
|
break;
|
|
case 'z':
|
|
commandType = CommandType::ClosePath;
|
|
break;
|
|
case 'l':
|
|
commandType = CommandType::Line;
|
|
break;
|
|
case 'h':
|
|
commandType = CommandType::HorLine;
|
|
break;
|
|
case 'v':
|
|
commandType = CommandType::VerLine;
|
|
break;
|
|
case 'c':
|
|
commandType = CommandType::Curve;
|
|
break;
|
|
case 's':
|
|
commandType = CommandType::SmoothCurve;
|
|
break;
|
|
case 'q':
|
|
commandType = CommandType::Quadratic;
|
|
break;
|
|
case 't':
|
|
commandType = CommandType::SmoothQuadratic;
|
|
break;
|
|
case 'a':
|
|
commandType = CommandType::EllipticalArc;
|
|
break;
|
|
}
|
|
|
|
if (commandType) {
|
|
return {{
|
|
.type = Token::Type::Command,
|
|
.data = {
|
|
.command = {
|
|
.type = *commandType,
|
|
.relative = !static_cast<bool>(isupper(*it))
|
|
}
|
|
}
|
|
}, it + 1};
|
|
}
|
|
|
|
if (*it == '-' || *it == '.' || (*it >= '0' && *it <= '9')) {
|
|
auto [value, it2] = map<double>(nomDouble(it, end));
|
|
return {{
|
|
.type = Token::Type::Number,
|
|
.data = {
|
|
.value = value
|
|
}
|
|
}, it2};
|
|
}
|
|
|
|
return {{
|
|
.type = Token::Type::Unknown
|
|
}, it};
|
|
}
|
|
|
|
void interpolateCubic(std::vector<Vertex>& output, size_t segments, double sx, double sy, double x1, double y1, double x2, double y2, double x, double y) {
|
|
auto segmentsScaled = static_cast<size_t>(std::round(std::hypot(x - sx, y - sy) / 50.0 * static_cast<double>(segments)));
|
|
|
|
for (size_t i = 1; i < segmentsScaled; ++i) {
|
|
const double t = static_cast<double>(i) / static_cast<double>(segmentsScaled);
|
|
const double t2 = t * t;
|
|
const double t3 = t2 * t;
|
|
const double inv_t = 1.0 - t;
|
|
const double inv_t2 = inv_t * inv_t;
|
|
const double inv_t3 = inv_t2 * inv_t;
|
|
|
|
const double px = inv_t3 * sx + 3 * inv_t2 * t * x1 + 3 * inv_t * t2 * x2 + t3 * x;
|
|
const double py = inv_t3 * sy + 3 * inv_t2 * t * y1 + 3 * inv_t * t2 * y2 + t3 * y;
|
|
|
|
output.emplace_back(px, py);
|
|
}
|
|
}
|
|
|
|
void interpolateQuadratic(std::vector<Vertex>& output, size_t segments, double sx, double sy, double x1, double y1, double x, double y) {
|
|
auto segmentsScaled = static_cast<size_t>(std::round(std::hypot(x - sx, y - sy) / 50.0 * static_cast<double>(segments)));
|
|
|
|
for (size_t i = 1; i < segmentsScaled; ++i) {
|
|
const double t = static_cast<double>(i) / static_cast<double>(segmentsScaled);
|
|
const double t2 = t * t;
|
|
const double inv_t = 1.0 - t;
|
|
const double inv_t2 = inv_t * inv_t;
|
|
|
|
const double px = inv_t2 * sx + 2 * inv_t * t * x1 + t2 * x;
|
|
const double py = inv_t2 * sy + 2 * inv_t * t * y1 + t2 * y;
|
|
|
|
output.emplace_back(px, py);
|
|
}
|
|
}
|
|
|
|
void interpolateLine(std::vector<Vertex>& output, size_t segments, double sx, double sy, double x, double y) {
|
|
auto segmentsScaled = static_cast<size_t>(std::round(std::hypot(x - sx, y - sy) / 50.0 * static_cast<double>(segments)));
|
|
|
|
for (size_t i = 1; i < segmentsScaled; ++i) {
|
|
const double t = static_cast<double>(i) / static_cast<double>(segmentsScaled);
|
|
const double inv_t = 1.0 - t;
|
|
|
|
const double px = inv_t * sx + t * x;
|
|
const double py = inv_t * sy + t * y;
|
|
|
|
output.emplace_back(px, py);
|
|
}
|
|
}
|
|
|
|
|
|
double vecAngle(double ux, double uy, double vx, double vy) {
|
|
double sign = ux * vy - uy * vx < 0.0 ? -1.0 : 1.0;
|
|
double dot = ux * vx + uy * vy;
|
|
double uLen = std::hypot(ux, uy);
|
|
double vLen = std::hypot(vx, vy);
|
|
return sign * std::acos(dot / (uLen * vLen));
|
|
}
|
|
|
|
void interpolateArc(std::vector<Vertex>& output, const size_t segments, double rx, double ry, double rot,
|
|
bool largeArcFlag, bool sweepFlag, double x1, double y1, double x2, double y2)
|
|
{
|
|
constexpr double PI = 3.14159;
|
|
constexpr double PI2 = 2.0 * PI;
|
|
|
|
double phi = rot * PI / 180.0;
|
|
|
|
double dx = x1 - x2;
|
|
double dy = y1 - y2;
|
|
|
|
double dxHalf = dx / 2.0;
|
|
double dyHalf = dy / 2.0;
|
|
double xAvg = (x1 + x2) / 2.0;
|
|
double yAvg = (y1 + y2) / 2.0;
|
|
|
|
double sinPhi = std::sin(phi);
|
|
double cosPhi = std::cos(phi);
|
|
|
|
double x1p = cosPhi * dxHalf + sinPhi * dyHalf;
|
|
double y1p = -sinPhi * dxHalf + cosPhi * dyHalf;
|
|
|
|
double x1p2 = x1p * x1p;
|
|
double y1p2 = y1p * y1p;
|
|
|
|
double rx2 = rx * rx;
|
|
double ry2 = ry * ry;
|
|
|
|
double lambda = std::sqrt(x1p2 / rx2 + y1p2 / ry2);
|
|
if (lambda > 1) {
|
|
rx *= lambda;
|
|
ry *= lambda;
|
|
}
|
|
|
|
double sig = largeArcFlag == sweepFlag ? -1.0 : 1.0;
|
|
double aNum = rx2 * ry2 - rx2 * y1p2 - ry2 * x1p2;
|
|
double aDenom = rx2 * y1p2 + ry2 * x1p2;
|
|
double a = sig * std::sqrt(std::abs(aNum / aDenom));
|
|
|
|
double cxp = a * (rx * y1p / ry);
|
|
double cyp = a * -(ry * x1p / rx);
|
|
|
|
double cx = cosPhi * cxp - sinPhi * cyp + xAvg;
|
|
double cy = sinPhi * cxp + cosPhi * cyp + yAvg;
|
|
|
|
double svx = (x1p - cxp) / rx;
|
|
double svy = (y1p - cyp) / ry;
|
|
double theta = vecAngle(1.0, 0.0, svx, svy);
|
|
double deltaThetaUnbound = vecAngle(svx, svy, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
|
|
double deltaTheta = std::fmod(deltaThetaUnbound, PI2);
|
|
if (deltaTheta > 0.0 && !sweepFlag)
|
|
deltaTheta -= PI2;
|
|
if (deltaTheta < 0.0 && sweepFlag)
|
|
deltaTheta += PI2;
|
|
|
|
auto segmentsScaled = static_cast<size_t>(std::round(std::hypot(rx, ry) / 50.0 * static_cast<double>(segments)));
|
|
|
|
for (size_t i = 0; i < segmentsScaled; ++i)
|
|
{
|
|
const double t = static_cast<double>(i) / static_cast<double>(segmentsScaled - 1);
|
|
double px = rx * std::cos(theta + deltaTheta * t);
|
|
double py = ry * std::sin(theta + deltaTheta * t);
|
|
double x = cx + px * cosPhi - py * sinPhi;
|
|
double y = cy + px * sinPhi + py * cosPhi;
|
|
|
|
output.emplace_back(x, y);
|
|
}
|
|
}
|
|
|
|
static constexpr size_t SEGMENTS = 20;
|
|
|
|
std::vector<Vertex> extractVertices(std::string_view path) {
|
|
|
|
std::vector<Vertex> vertices;
|
|
std::optional<Command> lastCommand{};
|
|
bool repeatLastCommand = false;
|
|
Vertex pos{};
|
|
Vertex lastControlPoint{};
|
|
Vertex subpathStart{};
|
|
|
|
auto it = path.cbegin();
|
|
while (it != path.end()) {
|
|
auto lastCommandType = lastCommand ? lastCommand->type : CommandType::ClosePath;
|
|
auto [token, itNext] = nomToken(lastCommandType != CommandType::ClosePath, it, path.end());
|
|
it = itNext;
|
|
|
|
switch (token.type) {
|
|
case Token::Type::End:
|
|
break;
|
|
|
|
case Token::Type::Number:
|
|
switch (lastCommandType) {
|
|
case CommandType::Move:
|
|
{
|
|
if (!repeatLastCommand) {
|
|
vertices.push_back(pos);
|
|
}
|
|
|
|
auto x = token.data.value;
|
|
it = skipSeparators(it, path.end());
|
|
auto [y, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
|
|
double xAbs = lastCommand->relative ? pos.x + x : x;
|
|
double yAbs = lastCommand->relative ? pos.y + y : y;
|
|
|
|
interpolateLine(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
pos = { xAbs, yAbs };
|
|
lastControlPoint = pos;
|
|
|
|
vertices.push_back(pos);
|
|
break;
|
|
}
|
|
case CommandType::Line:
|
|
{
|
|
auto x = token.data.value;
|
|
it = skipSeparators(it, path.end());
|
|
auto [y, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
|
|
double xAbs = lastCommand->relative ? pos.x + x : x;
|
|
double yAbs = lastCommand->relative ? pos.y + y : y;
|
|
|
|
interpolateLine(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
pos = { xAbs, yAbs };
|
|
lastControlPoint = pos;
|
|
|
|
vertices.push_back(pos);
|
|
break;
|
|
}
|
|
case CommandType::HorLine:
|
|
{
|
|
auto x = token.data.value;
|
|
|
|
double xAbs = lastCommand->relative ? pos.x + x : x;
|
|
|
|
interpolateLine(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
xAbs, pos.y
|
|
);
|
|
|
|
pos = { xAbs, pos.y };
|
|
lastControlPoint = pos;
|
|
|
|
vertices.push_back(pos);
|
|
break;
|
|
}
|
|
case CommandType::VerLine:
|
|
{
|
|
auto y = token.data.value;
|
|
|
|
double yAbs = lastCommand->relative ? pos.y + y : y;
|
|
|
|
interpolateLine(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
pos.x, yAbs
|
|
);
|
|
|
|
pos = { pos.x, yAbs };
|
|
lastControlPoint = pos;
|
|
|
|
vertices.push_back(pos);
|
|
break;
|
|
}
|
|
case CommandType::Curve:
|
|
{
|
|
auto x1 = token.data.value;
|
|
it = skipSeparators(it, path.end());
|
|
auto [y1, it3] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it3 = skipSeparators(it3, path.end());
|
|
auto [x2, it4] = map<double>(throwIfEmpty(nomDouble(it3, path.end())));
|
|
it4 = skipSeparators(it4, path.end());
|
|
auto [y2, it5] = map<double>(throwIfEmpty(nomDouble(it4, path.end())));
|
|
it5 = skipSeparators(it5, path.end());
|
|
auto [x, it6] = map<double>(throwIfEmpty(nomDouble(it5, path.end())));
|
|
it6 = skipSeparators(it6, path.end());
|
|
auto [y, it7] = map<double>(throwIfEmpty(nomDouble(it6, path.end())));
|
|
it = it7;
|
|
|
|
double x2abs = lastCommand->relative ? pos.x + x2 : x2;
|
|
double y2abs = lastCommand->relative ? pos.y + y2 : y2;
|
|
double xAbs = lastCommand->relative ? pos.x + x : x;
|
|
double yAbs = lastCommand->relative ? pos.y + y : y;
|
|
|
|
interpolateCubic(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
lastCommand->relative ? pos.x + x1 : x1, lastCommand->relative ? pos.y + y1 : y1,
|
|
x2abs, y2abs,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
lastControlPoint = { x2abs, y2abs };
|
|
pos = { xAbs, yAbs };
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::SmoothCurve:
|
|
{
|
|
auto x2 = token.data.value;
|
|
it = skipSeparators(it, path.end());
|
|
auto [y2, it5] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it5 = skipSeparators(it5, path.end());
|
|
auto [x, it6] = map<double>(throwIfEmpty(nomDouble(it5, path.end())));
|
|
it6 = skipSeparators(it6, path.end());
|
|
auto [y, it7] = map<double>(throwIfEmpty(nomDouble(it6, path.end())));
|
|
it = it7;
|
|
|
|
double x1abs = 2.0 * pos.x - lastControlPoint.x;
|
|
double y1abs = 2.0 * pos.y - lastControlPoint.y;
|
|
|
|
double x2abs = lastCommand->relative ? pos.x + x2 : x2;
|
|
double y2abs = lastCommand->relative ? pos.y + y2 : y2;
|
|
double xAbs = lastCommand->relative ? pos.x + x : x;
|
|
double yAbs = lastCommand->relative ? pos.y + y : y;
|
|
|
|
interpolateCubic(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
x1abs, y1abs,
|
|
x2abs, y2abs,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
lastControlPoint = { x2abs, y2abs };
|
|
pos = { xAbs, yAbs };
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
|
|
case CommandType::Quadratic:
|
|
{
|
|
auto x1 = token.data.value;
|
|
it = skipSeparators(it, path.end());
|
|
auto [y1, it3] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it3 = skipSeparators(it3, path.end());
|
|
auto [x, it4] = map<double>(throwIfEmpty(nomDouble(it3, path.end())));
|
|
it4 = skipSeparators(it4, path.end());
|
|
auto [y, it5] = map<double>(throwIfEmpty(nomDouble(it4, path.end())));
|
|
it = it5;
|
|
|
|
double x1abs = lastCommand->relative ? pos.x + x1 : x1;
|
|
double y1abs = lastCommand->relative ? pos.y + y1 : y1;
|
|
|
|
double xAbs = lastCommand->relative ? pos.x + x : x;
|
|
double yAbs = lastCommand->relative ? pos.y + y : y;
|
|
|
|
interpolateQuadratic(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
x1abs, y1abs,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
lastControlPoint = { x1abs, y1abs };
|
|
pos = { xAbs, yAbs };
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::SmoothQuadratic:
|
|
{
|
|
auto x = token.data.value;
|
|
it = skipSeparators(it, path.end());
|
|
auto [y, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it = it2;
|
|
|
|
double x1abs = 2.0 * pos.x - lastControlPoint.x;
|
|
double y1abs = 2.0 * pos.y - lastControlPoint.y;
|
|
|
|
double xAbs = lastCommand->relative ? pos.x + x : x;
|
|
double yAbs = lastCommand->relative ? pos.y + y : y;
|
|
|
|
interpolateQuadratic(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
x1abs, y1abs,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
lastControlPoint = { x1abs, y1abs };
|
|
pos = { xAbs, yAbs };
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::EllipticalArc:
|
|
{
|
|
it = skipSeparators(it, path.end());
|
|
auto rx = token.data.value;
|
|
auto [ry, it3] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it3 = skipSeparators(it3, path.end());
|
|
auto [rot, it4] = map<double>(throwIfEmpty(nomDouble(it3, path.end())));
|
|
it4 = skipSeparators(it4, path.end());
|
|
auto [largeArcFlag, it5] = map<bool>(throwIfEmpty(nomFlag(it4, path.end())));
|
|
it5 = skipSeparators(it5, path.end());
|
|
auto [sweepFlag, it6] = map<bool>(throwIfEmpty(nomFlag(it5, path.end())));
|
|
it6 = skipSeparators(it6, path.end());
|
|
auto [x, it7] = map<double>(throwIfEmpty(nomDouble(it6, path.end())));
|
|
it7 = skipSeparators(it6, path.end());
|
|
auto [y, it8] = map<double>(throwIfEmpty(nomDouble(it7, path.end())));
|
|
it = it8;
|
|
|
|
rx = abs(rx);
|
|
ry = abs(ry);
|
|
|
|
double xAbs = lastCommand->relative ? pos.x + x : x;
|
|
double yAbs = lastCommand->relative ? pos.y + y : y;
|
|
|
|
interpolateArc(vertices, SEGMENTS, rx, ry, rot, largeArcFlag, sweepFlag, pos.x, pos.y, xAbs, yAbs);
|
|
pos = { xAbs, yAbs };
|
|
|
|
lastControlPoint = pos;
|
|
|
|
break;
|
|
}
|
|
case CommandType::ClosePath:
|
|
throw std::runtime_error("Unexpected number");
|
|
}
|
|
|
|
if (!repeatLastCommand) {
|
|
repeatLastCommand = true;
|
|
}
|
|
|
|
break;
|
|
|
|
case Token::Type::Command:
|
|
switch (token.data.command.type) {
|
|
case CommandType::Move:
|
|
{
|
|
it = skipWhitespace(it, path.end());
|
|
auto [x, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it2 = skipSeparators(it2, path.end());
|
|
auto [y, it3] = map<double>(throwIfEmpty(nomDouble(it2, path.end())));
|
|
it = it3;
|
|
|
|
if (token.data.command.relative) {
|
|
pos.x += x;
|
|
pos.y += y;
|
|
} else {
|
|
pos = { x, y };
|
|
}
|
|
|
|
subpathStart = pos;
|
|
lastControlPoint = pos;
|
|
|
|
break;
|
|
}
|
|
case CommandType::Line:
|
|
{
|
|
if (!repeatLastCommand && (lastCommand && lastCommand->type == CommandType::Move)) {
|
|
vertices.push_back(pos);
|
|
}
|
|
|
|
it = skipWhitespace(it, path.end());
|
|
auto [x, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it2 = skipSeparators(it2, path.end());
|
|
auto [y, it3] = map<double>(throwIfEmpty(nomDouble(it2, path.end())));
|
|
it = it3;
|
|
|
|
double xAbs = token.data.command.relative ? pos.x + x : x;
|
|
double yAbs = token.data.command.relative ? pos.y + y : y;
|
|
|
|
interpolateLine(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
pos = { xAbs, yAbs };
|
|
lastControlPoint = pos;
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::HorLine:
|
|
{
|
|
if (!repeatLastCommand && (lastCommand && lastCommand->type == CommandType::Move)) {
|
|
vertices.push_back(pos);
|
|
}
|
|
|
|
it = skipWhitespace(it, path.end());
|
|
auto [x, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it = it2;
|
|
|
|
double xAbs = token.data.command.relative ? pos.x + x : x;
|
|
|
|
interpolateLine(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
xAbs, pos.y
|
|
);
|
|
|
|
pos = { xAbs, pos.y };
|
|
|
|
lastControlPoint = pos;
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
|
|
}
|
|
case CommandType::VerLine:
|
|
{
|
|
if (!repeatLastCommand && (lastCommand && lastCommand->type == CommandType::Move)) {
|
|
vertices.push_back(pos);
|
|
}
|
|
|
|
it = skipWhitespace(it, path.end());
|
|
auto [y, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it = it2;
|
|
|
|
double yAbs = token.data.command.relative ? pos.y + y : y;
|
|
|
|
interpolateLine(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
pos.x, yAbs
|
|
);
|
|
|
|
pos = { pos.x, yAbs };
|
|
lastControlPoint = pos;
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::Curve:
|
|
{
|
|
if (!repeatLastCommand && (lastCommand && lastCommand->type == CommandType::Move)) {
|
|
vertices.push_back(pos);
|
|
}
|
|
|
|
it = skipWhitespace(it, path.end());
|
|
auto [x1, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it2 = skipSeparators(it2, path.end());
|
|
auto [y1, it3] = map<double>(throwIfEmpty(nomDouble(it2, path.end())));
|
|
it3 = skipSeparators(it3, path.end());
|
|
auto [x2, it4] = map<double>(throwIfEmpty(nomDouble(it3, path.end())));
|
|
it4 = skipSeparators(it4, path.end());
|
|
auto [y2, it5] = map<double>(throwIfEmpty(nomDouble(it4, path.end())));
|
|
it5 = skipSeparators(it5, path.end());
|
|
auto [x, it6] = map<double>(throwIfEmpty(nomDouble(it5, path.end())));
|
|
it6 = skipSeparators(it6, path.end());
|
|
auto [y, it7] = map<double>(throwIfEmpty(nomDouble(it6, path.end())));
|
|
it = it7;
|
|
|
|
double x2abs = token.data.command.relative ? pos.x + x2 : x2;
|
|
double y2abs = token.data.command.relative ? pos.y + y2 : y2;
|
|
double xAbs = token.data.command.relative ? pos.x + x : x;
|
|
double yAbs = token.data.command.relative ? pos.y + y : y;
|
|
|
|
interpolateCubic(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
token.data.command.relative ? pos.x + x1 : x1, token.data.command.relative ? pos.y + y1 : y1,
|
|
x2abs, y2abs,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
lastControlPoint = { x2abs, y2abs };
|
|
pos = { xAbs, yAbs };
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::SmoothCurve:
|
|
{
|
|
if (!repeatLastCommand && (lastCommand && lastCommand->type == CommandType::Move)) {
|
|
vertices.push_back(pos);
|
|
}
|
|
|
|
it = skipWhitespace(it, path.end());
|
|
auto [x2, it4] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it4 = skipSeparators(it4, path.end());
|
|
auto [y2, it5] = map<double>(throwIfEmpty(nomDouble(it4, path.end())));
|
|
it5 = skipSeparators(it5, path.end());
|
|
auto [x, it6] = map<double>(throwIfEmpty(nomDouble(it5, path.end())));
|
|
it6 = skipSeparators(it6, path.end());
|
|
auto [y, it7] = map<double>(throwIfEmpty(nomDouble(it6, path.end())));
|
|
it = it7;
|
|
|
|
double x1abs, y1abs;
|
|
if (!lastCommand || (lastCommand->type != CommandType::Curve && lastCommand->type != CommandType::SmoothCurve)) {
|
|
x1abs = pos.x;
|
|
y1abs = pos.y;
|
|
} else {
|
|
x1abs = 2.0 * pos.x - lastControlPoint.x;
|
|
y1abs = 2.0 * pos.y - lastControlPoint.y;
|
|
}
|
|
|
|
double x2abs = token.data.command.relative ? pos.x + x2 : x2;
|
|
double y2abs = token.data.command.relative ? pos.y + y2 : y2;
|
|
double xAbs = token.data.command.relative ? pos.x + x : x;
|
|
double yAbs = token.data.command.relative ? pos.y + y : y;
|
|
|
|
interpolateCubic(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
x1abs, y1abs,
|
|
x2abs, y2abs,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
lastControlPoint = { x2abs, y2abs };
|
|
pos = { xAbs, yAbs };
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::Quadratic:
|
|
{
|
|
if (!repeatLastCommand && (lastCommand && lastCommand->type == CommandType::Move)) {
|
|
vertices.push_back(pos);
|
|
}
|
|
|
|
it = skipWhitespace(it, path.end());
|
|
auto [x1, it4] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it4 = skipSeparators(it4, path.end());
|
|
auto [y1, it5] = map<double>(throwIfEmpty(nomDouble(it4, path.end())));
|
|
it5 = skipSeparators(it5, path.end());
|
|
auto [x, it6] = map<double>(throwIfEmpty(nomDouble(it5, path.end())));
|
|
it6 = skipSeparators(it6, path.end());
|
|
auto [y, it7] = map<double>(throwIfEmpty(nomDouble(it6, path.end())));
|
|
it = it7;
|
|
|
|
double x1abs = token.data.command.relative ? pos.x + x1 : x1;
|
|
double y1abs = token.data.command.relative ? pos.y + y1 : y1;
|
|
double xAbs = token.data.command.relative ? pos.x + x : x;
|
|
double yAbs = token.data.command.relative ? pos.y + y : y;
|
|
|
|
interpolateQuadratic(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
x1abs, y1abs,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
pos = { xAbs, yAbs };
|
|
lastControlPoint = { x1abs, y1abs };
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::SmoothQuadratic:
|
|
{
|
|
if (!repeatLastCommand && (lastCommand && lastCommand->type == CommandType::Move)) {
|
|
vertices.push_back(pos);
|
|
}
|
|
|
|
it = skipWhitespace(it, path.end());
|
|
auto [x, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it2 = skipSeparators(it2, path.end());
|
|
auto [y, it3] = map<double>(throwIfEmpty(nomDouble(it2, path.end())));
|
|
it = it3;
|
|
|
|
double x1abs, y1abs;
|
|
if (!lastCommand || (lastCommand->type != CommandType::Quadratic && lastCommand->type != CommandType::SmoothQuadratic)) {
|
|
x1abs = pos.x;
|
|
y1abs = pos.y;
|
|
} else {
|
|
x1abs = 2.0 * pos.x - lastControlPoint.x;
|
|
y1abs = 2.0 * pos.y - lastControlPoint.y;
|
|
}
|
|
|
|
double xAbs = token.data.command.relative ? pos.x + x : x;
|
|
double yAbs = token.data.command.relative ? pos.y + y : y;
|
|
|
|
interpolateQuadratic(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
x1abs, y1abs,
|
|
xAbs, yAbs
|
|
);
|
|
|
|
lastControlPoint = { x1abs, y1abs };
|
|
pos = { xAbs, yAbs };
|
|
|
|
vertices.push_back(pos);
|
|
|
|
break;
|
|
}
|
|
case CommandType::EllipticalArc:
|
|
{
|
|
it = skipWhitespace(it, path.end());
|
|
auto [rx, it2] = map<double>(throwIfEmpty(nomDouble(it, path.end())));
|
|
it2 = skipSeparators(it2, path.end());
|
|
auto [ry, it3] = map<double>(throwIfEmpty(nomDouble(it2, path.end())));
|
|
it3 = skipSeparators(it3, path.end());
|
|
auto [rot, it4] = map<double>(throwIfEmpty(nomDouble(it3, path.end())));
|
|
it4 = skipSeparators(it4, path.end());
|
|
auto [largeArcFlag, it5] = map<bool>(throwIfEmpty(nomFlag(it4, path.end())));
|
|
it5 = skipSeparators(it5, path.end());
|
|
auto [sweepFlag, it6] = map<bool>(throwIfEmpty(nomFlag(it5, path.end())));
|
|
it6 = skipSeparators(it6, path.end());
|
|
auto [x, it7] = map<double>(throwIfEmpty(nomDouble(it6, path.end())));
|
|
it7 = skipSeparators(it7, path.end());
|
|
auto [y, it8] = map<double>(throwIfEmpty(nomDouble(it7, path.end())));
|
|
it = it8;
|
|
|
|
rx = abs(rx);
|
|
ry = abs(ry);
|
|
|
|
double xAbs = token.data.command.relative ? pos.x + x : x;
|
|
double yAbs = token.data.command.relative ? pos.y + y : y;
|
|
|
|
interpolateArc(vertices, SEGMENTS, rx, ry, rot, largeArcFlag, sweepFlag, pos.x, pos.y, xAbs, yAbs);
|
|
pos = { xAbs, yAbs };
|
|
|
|
lastControlPoint = pos;
|
|
|
|
break;
|
|
}
|
|
case CommandType::ClosePath:
|
|
{
|
|
interpolateLine(
|
|
vertices,
|
|
SEGMENTS,
|
|
pos.x, pos.y,
|
|
subpathStart.x, subpathStart.y
|
|
);
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
lastCommand = token.data.command;
|
|
repeatLastCommand = false;
|
|
break;
|
|
case Token::Type::Unknown:
|
|
throw std::runtime_error("Unknown token");
|
|
}
|
|
}
|
|
|
|
return vertices;
|
|
} |