| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "include/core/SkPath.h" |
| #include "include/core/SkPoint.h" |
| #include "include/core/SkScalar.h" |
| #include "include/core/SkStream.h" |
| #include "include/core/SkString.h" |
| #include "include/core/SkTypes.h" |
| #include "include/utils/SkParse.h" |
| #include "include/utils/SkParsePath.h" |
| #include "src/core/SkGeometry.h" |
| |
| #include <cstdio> |
| |
| enum class SkPathDirection; |
| |
| static inline bool is_between(int c, int min, int max) { |
| return (unsigned)(c - min) <= (unsigned)(max - min); |
| } |
| |
| static inline bool is_ws(int c) { |
| return is_between(c, 1, 32); |
| } |
| |
| static inline bool is_digit(int c) { |
| return is_between(c, '0', '9'); |
| } |
| |
| static inline bool is_sep(int c) { |
| return is_ws(c) || c == ','; |
| } |
| |
| static inline bool is_lower(int c) { |
| return is_between(c, 'a', 'z'); |
| } |
| |
| static inline int to_upper(int c) { |
| return c - 'a' + 'A'; |
| } |
| |
| static const char* skip_ws(const char str[]) { |
| SkASSERT(str); |
| while (is_ws(*str)) |
| str++; |
| return str; |
| } |
| |
| static const char* skip_sep(const char str[]) { |
| if (!str) { |
| return nullptr; |
| } |
| while (is_sep(*str)) |
| str++; |
| return str; |
| } |
| |
| // If unable to read count points from str into value, this will return nullptr |
| // to signal the failure. Otherwise, it will return the next offset to read from. |
| static const char* find_points(const char str[], SkPoint value[], int count, |
| bool isRelative, SkPoint* relative) { |
| str = SkParse::FindScalars(str, &value[0].fX, count * 2); |
| if (isRelative) { |
| for (int index = 0; index < count; index++) { |
| value[index].fX += relative->fX; |
| value[index].fY += relative->fY; |
| } |
| } |
| return str; |
| } |
| |
| // If unable to read a scalar from str into value, this will return nullptr |
| // to signal the failure. Otherwise, it will return the next offset to read from. |
| static const char* find_scalar(const char str[], SkScalar* value, |
| bool isRelative, SkScalar relative) { |
| str = SkParse::FindScalar(str, value); |
| if (!str) { |
| return nullptr; |
| } |
| if (isRelative) { |
| *value += relative; |
| } |
| str = skip_sep(str); |
| return str; |
| } |
| |
| // https://www.w3.org/TR/SVG11/paths.html#PathDataBNF |
| // |
| // flag: |
| // "0" | "1" |
| static const char* find_flag(const char str[], bool* value) { |
| if (!str) { |
| return nullptr; |
| } |
| if (str[0] != '1' && str[0] != '0') { |
| return nullptr; |
| } |
| *value = str[0] != '0'; |
| str = skip_sep(str + 1); |
| return str; |
| } |
| |
| bool SkParsePath::FromSVGString(const char data[], SkPath* result) { |
| // We will write all data to this local path and only write it |
| // to result if the whole parsing succeeds. |
| SkPath path; |
| SkPoint first = {0, 0}; |
| SkPoint c = {0, 0}; |
| SkPoint lastc = {0, 0}; |
| // We will use find_points and find_scalar to read into these. |
| // There might not be enough data to fill them, so to avoid |
| // MSAN warnings about using uninitialized bytes, we initialize |
| // them there. |
| SkPoint points[3] = {}; |
| SkScalar scratch = 0; |
| char op = '\0'; |
| char previousOp = '\0'; |
| bool relative = false; |
| for (;;) { |
| if (!data) { |
| // Truncated data |
| return false; |
| } |
| data = skip_ws(data); |
| if (data[0] == '\0') { |
| break; |
| } |
| char ch = data[0]; |
| if (is_digit(ch) || ch == '-' || ch == '+' || ch == '.') { |
| if (op == '\0' || op == 'Z') { |
| return false; |
| } |
| } else if (is_sep(ch)) { |
| data = skip_sep(data); |
| } else { |
| op = ch; |
| relative = false; |
| if (is_lower(op)) { |
| op = (char) to_upper(op); |
| relative = true; |
| } |
| data++; |
| data = skip_sep(data); |
| } |
| switch (op) { |
| case 'M': // Move |
| data = find_points(data, points, 1, relative, &c); |
| // find_points might have failed, so this might be the |
| // previous point. However, data will be set to nullptr |
| // if it failed, so we will check this at the top of the loop. |
| path.moveTo(points[0]); |
| previousOp = '\0'; |
| op = 'L'; |
| c = points[0]; |
| break; |
| case 'L': // Line |
| data = find_points(data, points, 1, relative, &c); |
| path.lineTo(points[0]); |
| c = points[0]; |
| break; |
| case 'H': // Horizontal Line |
| data = find_scalar(data, &scratch, relative, c.fX); |
| // Similarly, if there wasn't a scalar to read, data will |
| // be set to nullptr and this lineTo is bogus but will |
| // be ultimately ignored when the next time through the loop |
| // detects that and bails out. |
| path.lineTo(scratch, c.fY); |
| c.fX = scratch; |
| break; |
| case 'V': // Vertical Line |
| data = find_scalar(data, &scratch, relative, c.fY); |
| path.lineTo(c.fX, scratch); |
| c.fY = scratch; |
| break; |
| case 'C': // Cubic Bezier Curve |
| data = find_points(data, points, 3, relative, &c); |
| goto cubicCommon; |
| case 'S': // Continued "Smooth" Cubic Bezier Curve |
| data = find_points(data, &points[1], 2, relative, &c); |
| points[0] = c; |
| if (previousOp == 'C' || previousOp == 'S') { |
| points[0].fX -= lastc.fX - c.fX; |
| points[0].fY -= lastc.fY - c.fY; |
| } |
| cubicCommon: |
| path.cubicTo(points[0], points[1], points[2]); |
| lastc = points[1]; |
| c = points[2]; |
| break; |
| case 'Q': // Quadratic Bezier Curve |
| data = find_points(data, points, 2, relative, &c); |
| goto quadraticCommon; |
| case 'T': // Continued Quadratic Bezier Curve |
| data = find_points(data, &points[1], 1, relative, &c); |
| points[0] = c; |
| if (previousOp == 'Q' || previousOp == 'T') { |
| points[0].fX -= lastc.fX - c.fX; |
| points[0].fY -= lastc.fY - c.fY; |
| } |
| quadraticCommon: |
| path.quadTo(points[0], points[1]); |
| lastc = points[0]; |
| c = points[1]; |
| break; |
| case 'A': { // Arc (Elliptical) |
| SkPoint radii; |
| SkScalar angle; |
| bool largeArc, sweep; |
| if ((data = find_points(data, &radii, 1, false, nullptr)) |
| && (data = skip_sep(data)) |
| && (data = find_scalar(data, &angle, false, 0)) |
| && (data = skip_sep(data)) |
| && (data = find_flag(data, &largeArc)) |
| && (data = skip_sep(data)) |
| && (data = find_flag(data, &sweep)) |
| && (data = skip_sep(data)) |
| && (data = find_points(data, &points[0], 1, relative, &c))) { |
| path.arcTo(radii, angle, (SkPath::ArcSize) largeArc, |
| (SkPathDirection) !sweep, points[0]); |
| path.getLastPt(&c); |
| } |
| } break; |
| case 'Z': // Close Path |
| path.close(); |
| c = first; |
| break; |
| default: |
| return false; |
| } |
| if (previousOp == 0) { |
| first = c; |
| } |
| previousOp = op; |
| } |
| // we're good, go ahead and swap in the result |
| result->swap(path); |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| SkString SkParsePath::ToSVGString(const SkPath& path, PathEncoding encoding) { |
| SkDynamicMemoryWStream stream; |
| |
| SkPoint current_point{0,0}; |
| const auto rel_selector = encoding == PathEncoding::Relative; |
| |
| const auto append_command = [&](char cmd, const SkPoint pts[], size_t count) { |
| // Use lower case cmds for relative encoding. |
| cmd += 32 * rel_selector; |
| stream.write(&cmd, 1); |
| |
| for (size_t i = 0; i < count; ++i) { |
| const auto pt = pts[i] - current_point; |
| if (i > 0) { |
| stream.write(" ", 1); |
| } |
| stream.writeScalarAsText(pt.fX); |
| stream.write(" ", 1); |
| stream.writeScalarAsText(pt.fY); |
| } |
| |
| SkASSERT(count > 0); |
| // For relative encoding, track the current point (otherwise == origin). |
| current_point = pts[count - 1] * rel_selector; |
| }; |
| |
| SkPath::Iter iter(path, false); |
| SkPoint pts[4]; |
| |
| for (;;) { |
| switch (iter.next(pts)) { |
| case SkPath::kConic_Verb: { |
| const SkScalar tol = SK_Scalar1 / 1024; // how close to a quad |
| SkAutoConicToQuads quadder; |
| const SkPoint* quadPts = quadder.computeQuads(pts, iter.conicWeight(), tol); |
| for (int i = 0; i < quadder.countQuads(); ++i) { |
| append_command('Q', &quadPts[i*2 + 1], 2); |
| } |
| } break; |
| case SkPath::kMove_Verb: |
| append_command('M', &pts[0], 1); |
| break; |
| case SkPath::kLine_Verb: |
| append_command('L', &pts[1], 1); |
| break; |
| case SkPath::kQuad_Verb: |
| append_command('Q', &pts[1], 2); |
| break; |
| case SkPath::kCubic_Verb: |
| append_command('C', &pts[1], 3); |
| break; |
| case SkPath::kClose_Verb: |
| stream.write("Z", 1); |
| break; |
| case SkPath::kDone_Verb: { |
| SkString str; |
| str.resize(stream.bytesWritten()); |
| stream.copyTo(str.data()); |
| return str; |
| } |
| } |
| } |
| } |
