1/*
2 * Copyright 2013 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/SkCanvas.h"
8#include "include/utils/SkRandom.h"
9#include "tests/PathOpsExtendedTest.h"
10#include "tests/PathOpsThreadedCommon.h"
11#include "tests/Test.h"
12
13static void testTightBoundsLines(PathOpsThreadState* data) {
14    SkRandom ran;
15    for (int index = 0; index < 1000; ++index) {
16        SkPath path;
17        int contourCount = ran.nextRangeU(1, 10);
18        for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
19            int lineCount = ran.nextRangeU(1, 10);
20            path.moveTo(ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000));
21            for (int lIndex = 0; lIndex < lineCount; ++lIndex) {
22                path.lineTo(ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000));
23            }
24            if (ran.nextBool()) {
25                path.close();
26            }
27        }
28        SkRect classicBounds = path.getBounds();
29        SkRect tightBounds;
30        REPORTER_ASSERT(data->fReporter, TightBounds(path, &tightBounds));
31        REPORTER_ASSERT(data->fReporter, classicBounds == tightBounds);
32    }
33}
34
35DEF_TEST(PathOpsTightBoundsLines, reporter) {
36    initializeTests(reporter, "tightBoundsLines");
37    PathOpsThreadedTestRunner testRunner(reporter);
38    int outerCount = reporter->allowExtendedTest() ? 100 : 1;
39    for (int index = 0; index < outerCount; ++index) {
40        for (int idx2 = 0; idx2 < 10; ++idx2) {
41            *testRunner.fRunnables.append() =
42                    new PathOpsThreadedRunnable(&testTightBoundsLines, 0, 0, 0, 0, &testRunner);
43        }
44    }
45    testRunner.render();
46}
47
48static void testTightBoundsQuads(PathOpsThreadState* data) {
49    SkRandom ran;
50    const int bitWidth = 32;
51    const int bitHeight = 32;
52    const float pathMin = 1;
53    const float pathMax = (float) (bitHeight - 2);
54    SkBitmap& bits = *data->fBitmap;
55    if (bits.width() == 0) {
56        bits.allocN32Pixels(bitWidth, bitHeight);
57    }
58    SkCanvas canvas(bits);
59    SkPaint paint;
60    for (int index = 0; index < 100; ++index) {
61        SkPath path;
62        int contourCount = ran.nextRangeU(1, 10);
63        for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
64            int lineCount = ran.nextRangeU(1, 10);
65            path.moveTo(ran.nextRangeF(1, pathMax), ran.nextRangeF(pathMin, pathMax));
66            for (int lIndex = 0; lIndex < lineCount; ++lIndex) {
67                if (ran.nextBool()) {
68                    path.lineTo(ran.nextRangeF(pathMin, pathMax), ran.nextRangeF(pathMin, pathMax));
69                } else {
70                    path.quadTo(ran.nextRangeF(pathMin, pathMax), ran.nextRangeF(pathMin, pathMax),
71                            ran.nextRangeF(pathMin, pathMax), ran.nextRangeF(pathMin, pathMax));
72                }
73            }
74            if (ran.nextBool()) {
75                path.close();
76            }
77        }
78        SkRect classicBounds = path.getBounds();
79        SkRect tightBounds;
80        REPORTER_ASSERT(data->fReporter, TightBounds(path, &tightBounds));
81        REPORTER_ASSERT(data->fReporter, classicBounds.contains(tightBounds));
82        canvas.drawColor(SK_ColorWHITE);
83        canvas.drawPath(path, paint);
84        SkIRect bitsWritten = {31, 31, 0, 0};
85        for (int y = 0; y < bitHeight; ++y) {
86            uint32_t* addr1 = data->fBitmap->getAddr32(0, y);
87            bool lineWritten = false;
88            for (int x = 0; x < bitWidth; ++x) {
89                if (addr1[x] == (uint32_t) -1) {
90                    continue;
91                }
92                lineWritten = true;
93                bitsWritten.fLeft = std::min(bitsWritten.fLeft, x);
94                bitsWritten.fRight = std::max(bitsWritten.fRight, x);
95            }
96            if (!lineWritten) {
97                continue;
98            }
99            bitsWritten.fTop = std::min(bitsWritten.fTop, y);
100            bitsWritten.fBottom = std::max(bitsWritten.fBottom, y);
101        }
102        if (!bitsWritten.isEmpty()) {
103            SkIRect tightOut;
104            tightBounds.roundOut(&tightOut);
105            REPORTER_ASSERT(data->fReporter, tightOut.contains(bitsWritten));
106        }
107    }
108}
109
110DEF_TEST(PathOpsTightBoundsQuads, reporter) {
111    initializeTests(reporter, "tightBoundsQuads");
112    PathOpsThreadedTestRunner testRunner(reporter);
113    int outerCount = reporter->allowExtendedTest() ? 100 : 1;
114    for (int index = 0; index < outerCount; ++index) {
115        for (int idx2 = 0; idx2 < 10; ++idx2) {
116            *testRunner.fRunnables.append() =
117                    new PathOpsThreadedRunnable(&testTightBoundsQuads, 0, 0, 0, 0, &testRunner);
118        }
119    }
120    testRunner.render();
121}
122
123DEF_TEST(PathOpsTightBoundsMove, reporter) {
124    SkPath path;
125    path.moveTo(10, 10);
126    path.close();
127    path.moveTo(20, 20);
128    path.lineTo(20, 20);
129    path.close();
130    path.moveTo(15, 15);
131    path.lineTo(15, 15);
132    path.close();
133    const SkRect& bounds = path.getBounds();
134    SkRect tight;
135    REPORTER_ASSERT(reporter, TightBounds(path, &tight));
136    REPORTER_ASSERT(reporter, bounds == tight);
137}
138
139DEF_TEST(PathOpsTightBoundsMoveOne, reporter) {
140    SkPath path;
141    path.moveTo(20, 20);
142    const SkRect& bounds = path.getBounds();
143    SkRect tight;
144    REPORTER_ASSERT(reporter, TightBounds(path, &tight));
145    REPORTER_ASSERT(reporter, bounds == tight);
146}
147
148DEF_TEST(PathOpsTightBoundsMoveTwo, reporter) {
149    SkPath path;
150    path.moveTo(20, 20);
151    path.moveTo(40, 40);
152    const SkRect& bounds = path.getBounds();
153    SkRect tight;
154    REPORTER_ASSERT(reporter, TightBounds(path, &tight));
155    REPORTER_ASSERT(reporter, bounds == tight);
156}
157
158DEF_TEST(PathOpsTightBoundsTiny, reporter) {
159    SkPath path;
160    path.moveTo(1, 1);
161    path.quadTo(1.000001f, 1, 1, 1);
162    const SkRect& bounds = path.getBounds();
163    SkRect tight;
164    REPORTER_ASSERT(reporter, TightBounds(path, &tight));
165    SkRect moveBounds = {1, 1, 1, 1};
166    REPORTER_ASSERT(reporter, bounds != tight);
167    REPORTER_ASSERT(reporter, moveBounds == tight);
168}
169
170DEF_TEST(PathOpsTightBoundsWellBehaved, reporter) {
171    SkPath path;
172    path.moveTo(1, 1);
173    path.quadTo(2, 3, 4, 5);
174    const SkRect& bounds = path.getBounds();
175    SkRect tight;
176    REPORTER_ASSERT(reporter, TightBounds(path, &tight));
177    REPORTER_ASSERT(reporter, bounds == tight);
178}
179
180DEF_TEST(PathOpsTightBoundsIllBehaved, reporter) {
181    SkPath path;
182    path.moveTo(1, 1);
183    path.quadTo(4, 3, 2, 2);
184    const SkRect& bounds = path.getBounds();
185    SkRect tight;
186    REPORTER_ASSERT(reporter, TightBounds(path, &tight));
187    REPORTER_ASSERT(reporter, bounds != tight);
188}
189
190DEF_TEST(PathOpsTightBoundsIllBehavedScaled, reporter) {
191    SkPath path;
192    path.moveTo(0, 0);
193    path.quadTo(1048578, 1048577, 1048576, 1048576);
194    const SkRect& bounds = path.getBounds();
195    SkRect tight;
196    REPORTER_ASSERT(reporter, TightBounds(path, &tight));
197    REPORTER_ASSERT(reporter, bounds != tight);
198    REPORTER_ASSERT(reporter, tight.right() == 1048576);
199    REPORTER_ASSERT(reporter, tight.bottom() == 1048576);
200}
201