PathMeasureTest.cpp 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308
  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/core/SkPathMeasure.h"
  8. #include "tests/Test.h"
  9. static void test_small_segment3() {
  10. SkPath path;
  11. const SkPoint pts[] = {
  12. { 0, 0 },
  13. { 100000000000.0f, 100000000000.0f }, { 0, 0 }, { 10, 10 },
  14. { 10, 10 }, { 0, 0 }, { 10, 10 }
  15. };
  16. path.moveTo(pts[0]);
  17. for (size_t i = 1; i < SK_ARRAY_COUNT(pts); i += 3) {
  18. path.cubicTo(pts[i], pts[i + 1], pts[i + 2]);
  19. }
  20. SkPathMeasure meas(path, false);
  21. meas.getLength();
  22. }
  23. static void test_small_segment2() {
  24. SkPath path;
  25. const SkPoint pts[] = {
  26. { 0, 0 },
  27. { 100000000000.0f, 100000000000.0f }, { 0, 0 },
  28. { 10, 10 }, { 0, 0 },
  29. };
  30. path.moveTo(pts[0]);
  31. for (size_t i = 1; i < SK_ARRAY_COUNT(pts); i += 2) {
  32. path.quadTo(pts[i], pts[i + 1]);
  33. }
  34. SkPathMeasure meas(path, false);
  35. meas.getLength();
  36. }
  37. static void test_small_segment() {
  38. SkPath path;
  39. const SkPoint pts[] = {
  40. { 100000, 100000},
  41. // big jump between these points, makes a big segment
  42. { 1.0005f, 0.9999f },
  43. // tiny (non-zero) jump between these points
  44. { SK_Scalar1, SK_Scalar1 },
  45. };
  46. path.moveTo(pts[0]);
  47. for (size_t i = 1; i < SK_ARRAY_COUNT(pts); ++i) {
  48. path.lineTo(pts[i]);
  49. }
  50. SkPathMeasure meas(path, false);
  51. /* this would assert (before a fix) because we added a segment with
  52. the same length as the prev segment, due to the follow (bad) pattern
  53. d = distance(pts[0], pts[1]);
  54. distance += d;
  55. seg->fDistance = distance;
  56. SkASSERT(d > 0); // TRUE
  57. SkASSERT(seg->fDistance > prevSeg->fDistance); // FALSE
  58. This 2nd assert failes because (distance += d) didn't affect distance
  59. because distance >>> d.
  60. */
  61. meas.getLength();
  62. }
  63. DEF_TEST(PathMeasure, reporter) {
  64. SkPath path;
  65. path.moveTo(0, 0);
  66. path.lineTo(SK_Scalar1, 0);
  67. path.lineTo(SK_Scalar1, SK_Scalar1);
  68. path.lineTo(0, SK_Scalar1);
  69. SkPathMeasure meas(path, true);
  70. SkScalar length = meas.getLength();
  71. SkASSERT(length == SK_Scalar1*4);
  72. path.reset();
  73. path.moveTo(0, 0);
  74. path.lineTo(SK_Scalar1*3, SK_Scalar1*4);
  75. meas.setPath(&path, false);
  76. length = meas.getLength();
  77. REPORTER_ASSERT(reporter, length == SK_Scalar1*5);
  78. path.reset();
  79. path.addCircle(0, 0, SK_Scalar1);
  80. meas.setPath(&path, true);
  81. length = meas.getLength();
  82. // SkDebugf("circle arc-length = %g\n", length);
  83. // Test the behavior following a close not followed by a move.
  84. path.reset();
  85. path.lineTo(SK_Scalar1, 0);
  86. path.lineTo(SK_Scalar1, SK_Scalar1);
  87. path.lineTo(0, SK_Scalar1);
  88. path.close();
  89. path.lineTo(-SK_Scalar1, 0);
  90. meas.setPath(&path, false);
  91. length = meas.getLength();
  92. REPORTER_ASSERT(reporter, length == SK_Scalar1 * 4);
  93. meas.nextContour();
  94. length = meas.getLength();
  95. REPORTER_ASSERT(reporter, length == SK_Scalar1);
  96. SkPoint position;
  97. SkVector tangent;
  98. REPORTER_ASSERT(reporter, meas.getPosTan(SK_ScalarHalf, &position, &tangent));
  99. REPORTER_ASSERT(reporter,
  100. SkScalarNearlyEqual(position.fX,
  101. -SK_ScalarHalf,
  102. 0.0001f));
  103. REPORTER_ASSERT(reporter, position.fY == 0);
  104. REPORTER_ASSERT(reporter, tangent.fX == -SK_Scalar1);
  105. REPORTER_ASSERT(reporter, tangent.fY == 0);
  106. // Test degenerate paths
  107. path.reset();
  108. path.moveTo(0, 0);
  109. path.lineTo(0, 0);
  110. path.lineTo(SK_Scalar1, 0);
  111. path.quadTo(SK_Scalar1, 0, SK_Scalar1, 0);
  112. path.quadTo(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1 * 2);
  113. path.cubicTo(SK_Scalar1, SK_Scalar1 * 2,
  114. SK_Scalar1, SK_Scalar1 * 2,
  115. SK_Scalar1, SK_Scalar1 * 2);
  116. path.cubicTo(SK_Scalar1*2, SK_Scalar1 * 2,
  117. SK_Scalar1*3, SK_Scalar1 * 2,
  118. SK_Scalar1*4, SK_Scalar1 * 2);
  119. meas.setPath(&path, false);
  120. length = meas.getLength();
  121. REPORTER_ASSERT(reporter, length == SK_Scalar1 * 6);
  122. REPORTER_ASSERT(reporter, meas.getPosTan(SK_ScalarHalf, &position, &tangent));
  123. REPORTER_ASSERT(reporter,
  124. SkScalarNearlyEqual(position.fX,
  125. SK_ScalarHalf,
  126. 0.0001f));
  127. REPORTER_ASSERT(reporter, position.fY == 0);
  128. REPORTER_ASSERT(reporter, tangent.fX == SK_Scalar1);
  129. REPORTER_ASSERT(reporter, tangent.fY == 0);
  130. REPORTER_ASSERT(reporter, meas.getPosTan(2.5f, &position, &tangent));
  131. REPORTER_ASSERT(reporter,
  132. SkScalarNearlyEqual(position.fX, SK_Scalar1, 0.0001f));
  133. REPORTER_ASSERT(reporter,
  134. SkScalarNearlyEqual(position.fY, 1.5f));
  135. REPORTER_ASSERT(reporter, tangent.fX == 0);
  136. REPORTER_ASSERT(reporter, tangent.fY == SK_Scalar1);
  137. REPORTER_ASSERT(reporter, meas.getPosTan(4.5f, &position, &tangent));
  138. REPORTER_ASSERT(reporter,
  139. SkScalarNearlyEqual(position.fX,
  140. 2.5f,
  141. 0.0001f));
  142. REPORTER_ASSERT(reporter,
  143. SkScalarNearlyEqual(position.fY,
  144. 2.0f,
  145. 0.0001f));
  146. REPORTER_ASSERT(reporter, tangent.fX == SK_Scalar1);
  147. REPORTER_ASSERT(reporter, tangent.fY == 0);
  148. path.reset();
  149. path.moveTo(0, 0);
  150. path.lineTo(SK_Scalar1, 0);
  151. path.moveTo(SK_Scalar1, SK_Scalar1);
  152. path.moveTo(SK_Scalar1 * 2, SK_Scalar1 * 2);
  153. path.lineTo(SK_Scalar1, SK_Scalar1 * 2);
  154. meas.setPath(&path, false);
  155. length = meas.getLength();
  156. REPORTER_ASSERT(reporter, length == SK_Scalar1);
  157. REPORTER_ASSERT(reporter, meas.getPosTan(SK_ScalarHalf, &position, &tangent));
  158. REPORTER_ASSERT(reporter,
  159. SkScalarNearlyEqual(position.fX,
  160. SK_ScalarHalf,
  161. 0.0001f));
  162. REPORTER_ASSERT(reporter, position.fY == 0);
  163. REPORTER_ASSERT(reporter, tangent.fX == SK_Scalar1);
  164. REPORTER_ASSERT(reporter, tangent.fY == 0);
  165. meas.nextContour();
  166. length = meas.getLength();
  167. REPORTER_ASSERT(reporter, length == SK_Scalar1);
  168. REPORTER_ASSERT(reporter, meas.getPosTan(SK_ScalarHalf, &position, &tangent));
  169. REPORTER_ASSERT(reporter,
  170. SkScalarNearlyEqual(position.fX,
  171. 1.5f,
  172. 0.0001f));
  173. REPORTER_ASSERT(reporter,
  174. SkScalarNearlyEqual(position.fY,
  175. 2.0f,
  176. 0.0001f));
  177. REPORTER_ASSERT(reporter, tangent.fX == -SK_Scalar1);
  178. REPORTER_ASSERT(reporter, tangent.fY == 0);
  179. test_small_segment();
  180. test_small_segment2();
  181. test_small_segment3();
  182. }
  183. DEF_TEST(PathMeasureConic, reporter) {
  184. SkPoint stdP, hiP, pts[] = {{0,0}, {100,0}, {100,0}};
  185. SkPath p;
  186. p.moveTo(0, 0);
  187. p.conicTo(pts[1], pts[2], 1);
  188. SkPathMeasure stdm(p, false);
  189. REPORTER_ASSERT(reporter, stdm.getPosTan(20, &stdP, nullptr));
  190. p.reset();
  191. p.moveTo(0, 0);
  192. p.conicTo(pts[1], pts[2], 10);
  193. stdm.setPath(&p, false);
  194. REPORTER_ASSERT(reporter, stdm.getPosTan(20, &hiP, nullptr));
  195. REPORTER_ASSERT(reporter, 19.5f < stdP.fX && stdP.fX < 20.5f);
  196. REPORTER_ASSERT(reporter, 19.5f < hiP.fX && hiP.fX < 20.5f);
  197. }
  198. // Regression test for b/26425223
  199. DEF_TEST(PathMeasure_nextctr, reporter) {
  200. SkPath path;
  201. path.moveTo(0, 0); path.lineTo(100, 0);
  202. SkPathMeasure meas(path, false);
  203. // only expect 1 contour, even if we didn't explicitly call getLength() ourselves
  204. REPORTER_ASSERT(reporter, !meas.nextContour());
  205. }
  206. #include "include/core/SkContourMeasure.h"
  207. static void test_90_degrees(sk_sp<SkContourMeasure> cm, SkScalar radius,
  208. skiatest::Reporter* reporter) {
  209. SkPoint pos;
  210. SkVector tan;
  211. SkScalar distance = cm->length() / 4;
  212. bool success = cm->getPosTan(distance, &pos, &tan);
  213. REPORTER_ASSERT(reporter, success);
  214. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pos.fX, 0));
  215. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pos.fY, radius));
  216. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(tan.fX, -1));
  217. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(tan.fY, 0));
  218. }
  219. static void test_empty_contours(skiatest::Reporter* reporter) {
  220. SkPath path;
  221. path.moveTo(0, 0).lineTo(100, 100).lineTo(200, 100);
  222. path.moveTo(2, 2).moveTo(3, 3); // zero-length(s)
  223. path.moveTo(4, 4).close().close().close(); // zero-length
  224. path.moveTo(5, 5).lineTo(5, 5); // zero-length
  225. path.moveTo(5, 5).lineTo(5, 5).close(); // zero-length
  226. path.moveTo(5, 5).lineTo(5, 5).close().close(); // zero-length
  227. path.moveTo(6, 6).lineTo(7, 7);
  228. path.moveTo(10, 10); // zero-length
  229. SkContourMeasureIter fact(path, false);
  230. // given the above construction, we expect only 2 contours (the rest are "empty")
  231. REPORTER_ASSERT(reporter, fact.next());
  232. REPORTER_ASSERT(reporter, fact.next());
  233. REPORTER_ASSERT(reporter, !fact.next());
  234. }
  235. static void test_MLM_contours(skiatest::Reporter* reporter) {
  236. SkPath path;
  237. // This odd sequence (with a trailing moveTo) used to return a 2nd contour, which is
  238. // wrong, since the contract for a measure is to only return non-zero length contours.
  239. path.moveTo(10, 10).lineTo(20, 20).moveTo(30, 30);
  240. for (bool forceClosed : {false, true}) {
  241. SkContourMeasureIter fact(path, forceClosed);
  242. REPORTER_ASSERT(reporter, fact.next());
  243. REPORTER_ASSERT(reporter, !fact.next());
  244. }
  245. }
  246. DEF_TEST(contour_measure, reporter) {
  247. SkPath path;
  248. path.addCircle(0, 0, 100);
  249. path.addCircle(0, 0, 10);
  250. SkContourMeasureIter fact(path, false);
  251. path.reset(); // we should not need the path avert we created the factory
  252. auto cm0 = fact.next();
  253. auto cm1 = fact.next();
  254. REPORTER_ASSERT(reporter, cm0->isClosed());
  255. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(cm0->length(), 200 * SK_ScalarPI, 1.5f));
  256. test_90_degrees(cm0, 100, reporter);
  257. REPORTER_ASSERT(reporter, cm1->isClosed());
  258. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(cm1->length(), 20 * SK_ScalarPI, 0.5f));
  259. test_90_degrees(cm1, 10, reporter);
  260. auto cm2 = fact.next();
  261. REPORTER_ASSERT(reporter, !cm2);
  262. test_empty_contours(reporter);
  263. test_MLM_contours(reporter);
  264. }