SkParsePath.cpp 8.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269
  1. /*
  2. * Copyright 2011 Google Inc.
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #include "include/utils/SkParse.h"
  8. #include "include/utils/SkParsePath.h"
  9. static inline bool is_between(int c, int min, int max) {
  10. return (unsigned)(c - min) <= (unsigned)(max - min);
  11. }
  12. static inline bool is_ws(int c) {
  13. return is_between(c, 1, 32);
  14. }
  15. static inline bool is_digit(int c) {
  16. return is_between(c, '0', '9');
  17. }
  18. static inline bool is_sep(int c) {
  19. return is_ws(c) || c == ',';
  20. }
  21. static inline bool is_lower(int c) {
  22. return is_between(c, 'a', 'z');
  23. }
  24. static inline int to_upper(int c) {
  25. return c - 'a' + 'A';
  26. }
  27. static const char* skip_ws(const char str[]) {
  28. SkASSERT(str);
  29. while (is_ws(*str))
  30. str++;
  31. return str;
  32. }
  33. static const char* skip_sep(const char str[]) {
  34. if (!str) {
  35. return nullptr;
  36. }
  37. while (is_sep(*str))
  38. str++;
  39. return str;
  40. }
  41. static const char* find_points(const char str[], SkPoint value[], int count,
  42. bool isRelative, SkPoint* relative) {
  43. str = SkParse::FindScalars(str, &value[0].fX, count * 2);
  44. if (isRelative) {
  45. for (int index = 0; index < count; index++) {
  46. value[index].fX += relative->fX;
  47. value[index].fY += relative->fY;
  48. }
  49. }
  50. return str;
  51. }
  52. static const char* find_scalar(const char str[], SkScalar* value,
  53. bool isRelative, SkScalar relative) {
  54. str = SkParse::FindScalar(str, value);
  55. if (!str) {
  56. return nullptr;
  57. }
  58. if (isRelative) {
  59. *value += relative;
  60. }
  61. str = skip_sep(str);
  62. return str;
  63. }
  64. bool SkParsePath::FromSVGString(const char data[], SkPath* result) {
  65. SkPath path;
  66. SkPoint first = {0, 0};
  67. SkPoint c = {0, 0};
  68. SkPoint lastc = {0, 0};
  69. SkPoint points[3];
  70. char op = '\0';
  71. char previousOp = '\0';
  72. bool relative = false;
  73. for (;;) {
  74. if (!data) {
  75. // Truncated data
  76. return false;
  77. }
  78. data = skip_ws(data);
  79. if (data[0] == '\0') {
  80. break;
  81. }
  82. char ch = data[0];
  83. if (is_digit(ch) || ch == '-' || ch == '+' || ch == '.') {
  84. if (op == '\0') {
  85. return false;
  86. }
  87. } else if (is_sep(ch)) {
  88. data = skip_sep(data);
  89. } else {
  90. op = ch;
  91. relative = false;
  92. if (is_lower(op)) {
  93. op = (char) to_upper(op);
  94. relative = true;
  95. }
  96. data++;
  97. data = skip_sep(data);
  98. }
  99. switch (op) {
  100. case 'M':
  101. data = find_points(data, points, 1, relative, &c);
  102. path.moveTo(points[0]);
  103. previousOp = '\0';
  104. op = 'L';
  105. c = points[0];
  106. break;
  107. case 'L':
  108. data = find_points(data, points, 1, relative, &c);
  109. path.lineTo(points[0]);
  110. c = points[0];
  111. break;
  112. case 'H': {
  113. SkScalar x;
  114. data = find_scalar(data, &x, relative, c.fX);
  115. path.lineTo(x, c.fY);
  116. c.fX = x;
  117. } break;
  118. case 'V': {
  119. SkScalar y;
  120. data = find_scalar(data, &y, relative, c.fY);
  121. path.lineTo(c.fX, y);
  122. c.fY = y;
  123. } break;
  124. case 'C':
  125. data = find_points(data, points, 3, relative, &c);
  126. goto cubicCommon;
  127. case 'S':
  128. data = find_points(data, &points[1], 2, relative, &c);
  129. points[0] = c;
  130. if (previousOp == 'C' || previousOp == 'S') {
  131. points[0].fX -= lastc.fX - c.fX;
  132. points[0].fY -= lastc.fY - c.fY;
  133. }
  134. cubicCommon:
  135. path.cubicTo(points[0], points[1], points[2]);
  136. lastc = points[1];
  137. c = points[2];
  138. break;
  139. case 'Q': // Quadratic Bezier Curve
  140. data = find_points(data, points, 2, relative, &c);
  141. goto quadraticCommon;
  142. case 'T':
  143. data = find_points(data, &points[1], 1, relative, &c);
  144. points[0] = c;
  145. if (previousOp == 'Q' || previousOp == 'T') {
  146. points[0].fX -= lastc.fX - c.fX;
  147. points[0].fY -= lastc.fY - c.fY;
  148. }
  149. quadraticCommon:
  150. path.quadTo(points[0], points[1]);
  151. lastc = points[0];
  152. c = points[1];
  153. break;
  154. case 'A': {
  155. SkPoint radii;
  156. SkScalar angle, largeArc, sweep;
  157. if ((data = find_points(data, &radii, 1, false, nullptr))
  158. && (data = skip_sep(data))
  159. && (data = find_scalar(data, &angle, false, 0))
  160. && (data = skip_sep(data))
  161. && (data = find_scalar(data, &largeArc, false, 0))
  162. && (data = skip_sep(data))
  163. && (data = find_scalar(data, &sweep, false, 0))
  164. && (data = skip_sep(data))
  165. && (data = find_points(data, &points[0], 1, relative, &c))) {
  166. path.arcTo(radii, angle, (SkPath::ArcSize) SkToBool(largeArc),
  167. (SkPath::Direction) !SkToBool(sweep), points[0]);
  168. path.getLastPt(&c);
  169. }
  170. } break;
  171. case 'Z':
  172. path.close();
  173. c = first;
  174. break;
  175. case '~': {
  176. SkPoint args[2];
  177. data = find_points(data, args, 2, false, nullptr);
  178. path.moveTo(args[0].fX, args[0].fY);
  179. path.lineTo(args[1].fX, args[1].fY);
  180. } break;
  181. default:
  182. return false;
  183. }
  184. if (previousOp == 0) {
  185. first = c;
  186. }
  187. previousOp = op;
  188. }
  189. // we're good, go ahead and swap in the result
  190. result->swap(path);
  191. return true;
  192. }
  193. ///////////////////////////////////////////////////////////////////////////////
  194. #include "include/core/SkStream.h"
  195. #include "include/core/SkString.h"
  196. #include "src/core/SkGeometry.h"
  197. static void write_scalar(SkWStream* stream, SkScalar value) {
  198. char buffer[64];
  199. #ifdef SK_BUILD_FOR_WIN
  200. int len = _snprintf(buffer, sizeof(buffer), "%g", value);
  201. #else
  202. int len = snprintf(buffer, sizeof(buffer), "%g", value);
  203. #endif
  204. char* stop = buffer + len;
  205. stream->write(buffer, stop - buffer);
  206. }
  207. static void append_scalars(SkWStream* stream, char verb, const SkScalar data[],
  208. int count) {
  209. stream->write(&verb, 1);
  210. write_scalar(stream, data[0]);
  211. for (int i = 1; i < count; i++) {
  212. stream->write(" ", 1);
  213. write_scalar(stream, data[i]);
  214. }
  215. }
  216. void SkParsePath::ToSVGString(const SkPath& path, SkString* str) {
  217. SkDynamicMemoryWStream stream;
  218. SkPath::Iter iter(path, false);
  219. SkPoint pts[4];
  220. for (;;) {
  221. switch (iter.next(pts, false)) {
  222. case SkPath::kConic_Verb: {
  223. const SkScalar tol = SK_Scalar1 / 1024; // how close to a quad
  224. SkAutoConicToQuads quadder;
  225. const SkPoint* quadPts = quadder.computeQuads(pts, iter.conicWeight(), tol);
  226. for (int i = 0; i < quadder.countQuads(); ++i) {
  227. append_scalars(&stream, 'Q', &quadPts[i*2 + 1].fX, 4);
  228. }
  229. } break;
  230. case SkPath::kMove_Verb:
  231. append_scalars(&stream, 'M', &pts[0].fX, 2);
  232. break;
  233. case SkPath::kLine_Verb:
  234. append_scalars(&stream, 'L', &pts[1].fX, 2);
  235. break;
  236. case SkPath::kQuad_Verb:
  237. append_scalars(&stream, 'Q', &pts[1].fX, 4);
  238. break;
  239. case SkPath::kCubic_Verb:
  240. append_scalars(&stream, 'C', &pts[1].fX, 6);
  241. break;
  242. case SkPath::kClose_Verb:
  243. stream.write("Z", 1);
  244. break;
  245. case SkPath::kDone_Verb:
  246. str->resize(stream.bytesWritten());
  247. stream.copyTo(str->writable_str());
  248. return;
  249. }
  250. }
  251. }