277c3f8765
enable conics in SkPath git-svn-id: http://skia.googlecode.com/svn/trunk@9370 2bbb7eff-a529-9590-31e7-b0007b416f81
237 lines
7.3 KiB
C++
237 lines
7.3 KiB
C++
/*
|
|
* Copyright 2013 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
#include "SkOpSegment.h"
|
|
#include "Test.h"
|
|
|
|
static const SkPoint cubics[][4] = {
|
|
/* 0 */ {{0, 1}, {2, 6}, {4, 2}, {5, 3}},
|
|
/* 1 */ {{10, 234}, {10, 229.581726f}, {13.5817204f, 226}, {18, 226}},
|
|
/* 2 */ {{132, 11419}, {130.89543151855469f, 11419}, {130, 11418.1044921875f}, {130, 11417}},
|
|
/* 3 */ {{130.04275512695312f, 11417.4130859375f}, {130.23307800292969f, 11418.3193359375f},
|
|
{131.03709411621094f, 11419}, {132, 11419}},
|
|
/* 4 */ {{0,1}, {0,5}, {4,1}, {6,4}},
|
|
/* 5 */ {{1,5}, {4,6}, {1,0}, {4,0}},
|
|
/* 6 */ {{0,1}, {0,4}, {5,1}, {6,4}},
|
|
/* 7 */ {{0,1}, {1,2}, {1,0}, {6,1}},
|
|
/* 8 */ {{0,3}, {0,1}, {2,0}, {1,0}},
|
|
/* 9 */ {{189,7}, {189,5.3431458473205566f}, {190.3431396484375f,4}, {192,4}},
|
|
/* 10 */ {{0,1}, {1,3}, {1,0}, {6,4}},
|
|
/* 11 */ {{0,1}, {2,3}, {2,1}, {4,3}},
|
|
/* 12 */ {{1,2}, {3,4}, {1,0}, {3,2}},
|
|
};
|
|
|
|
static const SkPoint quads[][3] = {
|
|
/* 0 */ {{12.3423996f, 228.342407f}, {10, 230.686295f}, {10, 234}},
|
|
/* 1 */ {{304.24319458007812f,591.75677490234375f}, {306,593.51470947265625f}, {306,596}},
|
|
};
|
|
|
|
static const SkPoint lines[][2] = {
|
|
/* 0 */ {{6, 2}, {2, 4}},
|
|
/* 1 */ {{306,617}, {306,590}},
|
|
/* 2 */ {{306,596}, {306,617}},
|
|
/* 3 */ {{6,4}, {0,1}},
|
|
/* 4 */ {{6,1}, {0,1}},
|
|
/* 5 */ {{1,0}, {0,3}},
|
|
/* 6 */ {{246,4}, {189,4}},
|
|
/* 7 */ {{192,4}, {243,4}},
|
|
/* 8 */ {{4,3}, {0,1}},
|
|
/* 9 */ {{3,2}, {1,2}},
|
|
};
|
|
|
|
struct SortSet {
|
|
const SkPoint* ptData;
|
|
int ptCount;
|
|
double tStart;
|
|
double tEnd;
|
|
};
|
|
|
|
static const SortSet set1[] = {
|
|
{cubics[0], 4, 0.66666987081928919, 0.875},
|
|
{lines[0], 2, 0.574070336, 0.388888889},
|
|
{cubics[0], 4, 0.66666987081928919, 0.4050371120499307 },
|
|
{lines[0], 2, 0.574070336, 0.9140625},
|
|
};
|
|
|
|
static const SortSet set2[] = {
|
|
{cubics[0], 4, 0.666666667, 0.875},
|
|
{lines[0], 2, 0.574074074, 0.388888889},
|
|
{cubics[0], 4, 0.666666667, 0.405037112},
|
|
{lines[0], 2, 0.574074074, 0.9140625},
|
|
};
|
|
|
|
static const SortSet set3[] = {
|
|
{cubics[1], 4, 0, 1},
|
|
{quads[0], 3, 1, 0},
|
|
};
|
|
|
|
static const SortSet set4[] = {
|
|
{cubics[2], 4, 0.812114222, 1},
|
|
{cubics[3], 4, 0.0684734759, 0},
|
|
};
|
|
|
|
static const SortSet set5[] = {
|
|
{lines[1], 2, 0.777777778, 1},
|
|
{quads[1], 3, 1, 4.34137342e-06},
|
|
{lines[2], 2, 0, 1},
|
|
};
|
|
|
|
static const SortSet set6[] = {
|
|
{lines[3], 2, 0.407407407, 0.554627832},
|
|
{cubics[4], 4, 0.666666667, 0.548022446},
|
|
{lines[3], 2, 0.407407407, 0},
|
|
{cubics[4], 4, 0.666666667, 1},
|
|
};
|
|
|
|
static const SortSet set7[] = {
|
|
{cubics[5], 4, 0.545233342, 0.545454545},
|
|
{cubics[6], 4, 0.484938134, 0.484805744},
|
|
{cubics[5], 4, 0.545233342, 0},
|
|
{cubics[6], 4, 0.484938134, 0.545454545},
|
|
};
|
|
|
|
static const SortSet set8[] = {
|
|
{cubics[7], 4, 0.5, 0.522986744 },
|
|
{lines[4], 2, 0.75, 1},
|
|
{cubics[7], 4, 0.5, 0},
|
|
{lines[4], 2, 0.75, 0.737654321},
|
|
};
|
|
|
|
static const SortSet set9[] = {
|
|
{cubics[8], 4, 0.4, 1},
|
|
{lines[5], 2, 0.36, 0},
|
|
{cubics[8], 4, 0.4, 0.394675838},
|
|
{lines[5], 2, 0.36, 0.363999782},
|
|
};
|
|
|
|
static const SortSet set10[] = {
|
|
{lines[6], 2, 0.947368421, 1},
|
|
{cubics[9], 4, 1, 0.500000357},
|
|
{lines[7], 2, 0, 1},
|
|
};
|
|
|
|
static const SortSet set11[] = {
|
|
{lines[3], 2, 0.75, 1},
|
|
{cubics[10], 4, 0.5, 0.228744269},
|
|
{lines[3], 2, 0.75, 0.627112191},
|
|
{cubics[10], 4, 0.5, 0.6339746},
|
|
};
|
|
|
|
static const SortSet set12[] = {
|
|
{cubics[12], 4, 0.5, 1},
|
|
{lines[8], 2, 0.5, 1},
|
|
{cubics[11], 4, 0.5, 0},
|
|
{lines[9], 2, 0.5, 1},
|
|
{cubics[12], 4, 0.5, 0},
|
|
{lines[8], 2, 0.5, 0},
|
|
{cubics[11], 4, 0.5, 1},
|
|
{lines[9], 2, 0.5, 0},
|
|
};
|
|
|
|
struct SortSetTests {
|
|
const SortSet* set;
|
|
size_t count;
|
|
};
|
|
|
|
static const SortSetTests tests[] = {
|
|
{ set12, SK_ARRAY_COUNT(set12) },
|
|
{ set11, SK_ARRAY_COUNT(set11) },
|
|
{ set10, SK_ARRAY_COUNT(set10) },
|
|
{ set9, SK_ARRAY_COUNT(set9) },
|
|
{ set8, SK_ARRAY_COUNT(set8) },
|
|
{ set7, SK_ARRAY_COUNT(set7) },
|
|
{ set6, SK_ARRAY_COUNT(set6) },
|
|
{ set2, SK_ARRAY_COUNT(set2) },
|
|
{ set5, SK_ARRAY_COUNT(set5) },
|
|
{ set4, SK_ARRAY_COUNT(set4) },
|
|
{ set3, SK_ARRAY_COUNT(set3) },
|
|
{ set1, SK_ARRAY_COUNT(set1) },
|
|
};
|
|
|
|
static void setup(const SortSet* set, const size_t idx, SkPoint const ** data,
|
|
SkOpSegment* seg, int* ts) {
|
|
SkPoint start, end;
|
|
*data = set[idx].ptData;
|
|
switch(set[idx].ptCount) {
|
|
case 2: {
|
|
seg->addLine(*data, false, false);
|
|
SkDLine dLine;
|
|
dLine.set(set[idx].ptData);
|
|
start = dLine.xyAtT(set[idx].tStart).asSkPoint();
|
|
end = dLine.xyAtT(set[idx].tEnd).asSkPoint();
|
|
} break;
|
|
case 3: {
|
|
seg->addQuad(*data, false, false);
|
|
SkDQuad dQuad;
|
|
dQuad.set(set[idx].ptData);
|
|
start = dQuad.xyAtT(set[idx].tStart).asSkPoint();
|
|
end = dQuad.xyAtT(set[idx].tEnd).asSkPoint();
|
|
} break;
|
|
case 4: {
|
|
seg->addCubic(*data, false, false);
|
|
SkDCubic dCubic;
|
|
dCubic.set(set[idx].ptData);
|
|
start = dCubic.xyAtT(set[idx].tStart).asSkPoint();
|
|
end = dCubic.xyAtT(set[idx].tEnd).asSkPoint();
|
|
} break;
|
|
}
|
|
double tStart = set[idx].tStart;
|
|
double tEnd = set[idx].tEnd;
|
|
seg->addT(NULL, start, tStart);
|
|
seg->addT(NULL, end, tEnd);
|
|
double tLeft = tStart < tEnd ? 0 : 1;
|
|
if (tStart != tLeft && tEnd != tLeft) {
|
|
seg->addT(NULL, set[idx].ptData[0], tLeft);
|
|
}
|
|
double tRight = tStart < tEnd ? 1 : 0;
|
|
if (tStart != tRight && tEnd != tRight) {
|
|
seg->addT(NULL, set[idx].ptData[set[idx].ptCount - 1], tRight);
|
|
}
|
|
int tIndex = 0;
|
|
do {
|
|
if (seg->t(tIndex) == set[idx].tStart) {
|
|
ts[0] = tIndex;
|
|
}
|
|
if (seg->t(tIndex) == set[idx].tEnd) {
|
|
ts[1] = tIndex;
|
|
}
|
|
if (seg->t(tIndex) >= 1) {
|
|
break;
|
|
}
|
|
} while (++tIndex);
|
|
}
|
|
|
|
static void PathOpsAngleTest(skiatest::Reporter* reporter) {
|
|
for (size_t index = 0; index < SK_ARRAY_COUNT(tests); ++index) {
|
|
const SortSetTests& test = tests[index];
|
|
for (size_t idxL = 0; idxL < test.count - 1; ++idxL) {
|
|
SkOpSegment lesser, greater;
|
|
int lesserTs[2], greaterTs[2];
|
|
const SkPoint* lesserData, * greaterData;
|
|
const SortSet* set = test.set;
|
|
setup(set, idxL, &lesserData, &lesser, lesserTs);
|
|
size_t idxG = idxL + 1;
|
|
setup(set, idxG, &greaterData, &greater, greaterTs);
|
|
SkOpAngle first, second;
|
|
first.set(lesserData, SkPathOpsPointsToVerb(set[idxL].ptCount - 1), &lesser,
|
|
lesserTs[0], lesserTs[1], lesser.spans());
|
|
second.set(greaterData, SkPathOpsPointsToVerb(set[idxG].ptCount - 1), &greater,
|
|
greaterTs[0], greaterTs[1], greater.spans());
|
|
bool compare = first < second;
|
|
if (!compare) {
|
|
SkDebugf("%s test[%d]: lesser[%d] > greater[%d]\n", __FUNCTION__,
|
|
index, idxL, idxG);
|
|
compare = first < second;
|
|
}
|
|
REPORTER_ASSERT(reporter, compare);
|
|
reporter->bumpTestCount();
|
|
}
|
|
}
|
|
}
|
|
|
|
#include "TestClassDef.h"
|
|
DEFINE_TESTCLASS_SHORT(PathOpsAngleTest)
|