// reduce to a quadratic or smaller
// look for identical points
// look for all four points in a line
// note that three points in a line doesn't simplify a cubic
// look for approximation with single quadratic
// save approximation with multiple quadratics for later
int reduceOrder(const Cubic& cubic, Cubic& reduction, ReduceOrder_Quadratics allowQuadratics,
ReduceOrder_Styles reduceStyle) {
int index, minX, maxX, minY, maxY;
int minXSet, minYSet;
minX = maxX = minY = maxY = 0;
minXSet = minYSet = 0;
for (index = 1; index < 4; ++index) {
if (cubic[minX].x > cubic[index].x) {
minX = index;
}
if (cubic[minY].y > cubic[index].y) {
minY = index;
}
if (cubic[maxX].x < cubic[index].x) {
maxX = index;
}
if (cubic[maxY].y < cubic[index].y) {
maxY = index;
}
}
for (index = 0; index < 4; ++index) {
double cx = cubic[index].x;
double cy = cubic[index].y;
double denom = SkTMax(fabs(cx), SkTMax(fabs(cy),
SkTMax(fabs(cubic[minX].x), fabs(cubic[minY].y))));
if (denom == 0) {
minXSet |= 1 << index;
minYSet |= 1 << index;
continue;
}
double inv = 1 / denom;
if (approximately_equal_half(cx * inv, cubic[minX].x * inv)) {
minXSet |= 1 << index;
}
if (approximately_equal_half(cy * inv, cubic[minY].y * inv)) {
minYSet |= 1 << index;
}
}
if (minXSet == 0xF) { // test for vertical line
if (minYSet == 0xF) { // return 1 if all four are coincident
return coincident_line(cubic, reduction);
}
return vertical_line(cubic, reduceStyle, reduction);
}
if (minYSet == 0xF) { // test for horizontal line
return horizontal_line(cubic, reduceStyle, reduction);
}
int result = check_linear(cubic, reduceStyle, minX, maxX, minY, maxY, reduction);
if (result) {
return result;
}
if (allowQuadratics == kReduceOrder_QuadraticsAllowed
&& (result = check_quadratic(cubic, reduction))) {
return result;
}
memcpy(reduction, cubic, sizeof(Cubic));
return 4;
}
// reduce to a quadratic or smaller
// look for identical points
// look for all four points in a line
// note that three points in a line doesn't simplify a cubic
// look for approximation with single quadratic
// save approximation with multiple quadratics for later
int SkReduceOrder::reduce(const SkDCubic& cubic, Quadratics allowQuadratics) {
int index, minX, maxX, minY, maxY;
int minXSet, minYSet;
minX = maxX = minY = maxY = 0;
minXSet = minYSet = 0;
for (index = 1; index < 4; ++index) {
if (cubic[minX].fX > cubic[index].fX) {
minX = index;
}
if (cubic[minY].fY > cubic[index].fY) {
minY = index;
}
if (cubic[maxX].fX < cubic[index].fX) {
maxX = index;
}
if (cubic[maxY].fY < cubic[index].fY) {
maxY = index;
}
}
for (index = 0; index < 4; ++index) {
double cx = cubic[index].fX;
double cy = cubic[index].fY;
double denom = SkTMax(fabs(cx), SkTMax(fabs(cy),
SkTMax(fabs(cubic[minX].fX), fabs(cubic[minY].fY))));
if (denom == 0) {
minXSet |= 1 << index;
minYSet |= 1 << index;
continue;
}
double inv = 1 / denom;
if (approximately_equal_half(cx * inv, cubic[minX].fX * inv)) {
minXSet |= 1 << index;
}
if (approximately_equal_half(cy * inv, cubic[minY].fY * inv)) {
minYSet |= 1 << index;
}
}
if (minXSet == 0xF) { // test for vertical line
if (minYSet == 0xF) { // return 1 if all four are coincident
return coincident_line(cubic, fCubic);
}
return vertical_line(cubic, fCubic);
}
if (minYSet == 0xF) { // test for horizontal line
return horizontal_line(cubic, fCubic);
}
int result = check_linear(cubic, minX, maxX, minY, maxY, fCubic);
if (result) {
return result;
}
if (allowQuadratics == SkReduceOrder::kAllow_Quadratics
&& (result = check_quadratic(cubic, fCubic))) {
return result;
}
fCubic = cubic;
return 4;
}
int
main(int argc, char **argv)
{
krb5_context context;
krb5_error_code ret;
setprogname(argv[0]);
ret = krb5_init_context(&context);
if (ret)
errx(1, "krb5_init_context");
check_linear(context, "KTH1.SE", "KTH1.SE", NULL);
check_linear(context, "KTH1.SE", "KTH2.SE", NULL);
check_linear(context, "KTH1.SE", "KTH3.SE", "KTH2.SE", NULL);
check_linear(context, "KTH1.SE", "KTH4.SE", "KTH3.SE", "KTH2.SE", NULL);
check_linear(context, "KTH1.SE", "KTH5.SE", "KTH4.SE", "KTH3.SE", "KTH2.SE", NULL);
return 0;
}
// reduce to a quadratic or smaller
// look for identical points
// look for all four points in a line
// note that three points in a line doesn't simplify a cubic
// look for approximation with single quadratic
// save approximation with multiple quadratics for later
int reduceOrder(const Cubic& cubic, Cubic& reduction, ReduceOrder_Flags allowQuadratics) {
int index, minX, maxX, minY, maxY;
int minXSet, minYSet;
minX = maxX = minY = maxY = 0;
minXSet = minYSet = 0;
for (index = 1; index < 4; ++index) {
if (cubic[minX].x > cubic[index].x) {
minX = index;
}
if (cubic[minY].y > cubic[index].y) {
minY = index;
}
if (cubic[maxX].x < cubic[index].x) {
maxX = index;
}
if (cubic[maxY].y < cubic[index].y) {
maxY = index;
}
}
for (index = 0; index < 4; ++index) {
if (approximately_equal(cubic[index].x, cubic[minX].x)) {
minXSet |= 1 << index;
}
if (approximately_equal(cubic[index].y, cubic[minY].y)) {
minYSet |= 1 << index;
}
}
if (minXSet == 0xF) { // test for vertical line
if (minYSet == 0xF) { // return 1 if all four are coincident
return coincident_line(cubic, reduction);
}
return vertical_line(cubic, reduction);
}
if (minYSet == 0xF) { // test for horizontal line
return horizontal_line(cubic, reduction);
}
int result = check_linear(cubic, reduction, minX, maxX, minY, maxY);
if (result) {
return result;
}
if (allowQuadratics && (result = check_quadratic(cubic, reduction))) {
return result;
}
memcpy(reduction, cubic, sizeof(Cubic));
return 4;
}
// reduce to a quadratic or smaller
// look for identical points
// look for all four points in a line
// note that three points in a line doesn't simplify a cubic
// look for approximation with single quadratic
// save approximation with multiple quadratics for later
int SkReduceOrder::reduce(const SkDQuad& quad) {
int index, minX, maxX, minY, maxY;
int minXSet, minYSet;
minX = maxX = minY = maxY = 0;
minXSet = minYSet = 0;
for (index = 1; index < 3; ++index) {
if (quad[minX].fX > quad[index].fX) {
minX = index;
}
if (quad[minY].fY > quad[index].fY) {
minY = index;
}
if (quad[maxX].fX < quad[index].fX) {
maxX = index;
}
if (quad[maxY].fY < quad[index].fY) {
maxY = index;
}
}
for (index = 0; index < 3; ++index) {
if (AlmostEqualUlps(quad[index].fX, quad[minX].fX)) {
minXSet |= 1 << index;
}
if (AlmostEqualUlps(quad[index].fY, quad[minY].fY)) {
minYSet |= 1 << index;
}
}
if ((minXSet & 0x05) == 0x5 && (minYSet & 0x05) == 0x5) { // test for degenerate
// this quad starts and ends at the same place, so never contributes
// to the fill
return coincident_line(quad, fQuad);
}
if (minXSet == 0x7) { // test for vertical line
return vertical_line(quad, fQuad);
}
if (minYSet == 0x7) { // test for horizontal line
return horizontal_line(quad, fQuad);
}
int result = check_linear(quad, minX, maxX, minY, maxY, fQuad);
if (result) {
return result;
}
fQuad = quad;
return 3;
}
// reduce to a quadratic or smaller
// look for identical points
// look for all four points in a line
// note that three points in a line doesn't simplify a cubic
// look for approximation with single quadratic
// save approximation with multiple quadratics for later
int SkReduceOrder::reduce(const SkDQuad& quad) {
int index, minX, maxX, minY, maxY;
int minXSet, minYSet;
minX = maxX = minY = maxY = 0;
minXSet = minYSet = 0;
for (index = 1; index < 3; ++index) {
if (quad[minX].fX > quad[index].fX) {
minX = index;
}
if (quad[minY].fY > quad[index].fY) {
minY = index;
}
if (quad[maxX].fX < quad[index].fX) {
maxX = index;
}
if (quad[maxY].fY < quad[index].fY) {
maxY = index;
}
}
for (index = 0; index < 3; ++index) {
if (AlmostEqualUlps(quad[index].fX, quad[minX].fX)) {
minXSet |= 1 << index;
}
if (AlmostEqualUlps(quad[index].fY, quad[minY].fY)) {
minYSet |= 1 << index;
}
}
if (minXSet == 0x7) { // test for vertical line
if (minYSet == 0x7) { // return 1 if all four are coincident
return coincident_line(quad, fQuad);
}
return vertical_line(quad, fQuad);
}
if (minYSet == 0xF) { // test for horizontal line
return horizontal_line(quad, fQuad);
}
int result = check_linear(quad, minX, maxX, minY, maxY, fQuad);
if (result) {
return result;
}
fQuad = quad;
return 3;
}
// reduce to a quadratic or smaller
// look for identical points
// look for all four points in a line
// note that three points in a line doesn't simplify a cubic
// look for approximation with single quadratic
// save approximation with multiple quadratics for later
int reduceOrder(const Quadratic& quad, Quadratic& reduction) {
int index, minX, maxX, minY, maxY;
int minXSet, minYSet;
minX = maxX = minY = maxY = 0;
minXSet = minYSet = 0;
for (index = 1; index < 3; ++index) {
if (quad[minX].x > quad[index].x) {
minX = index;
}
if (quad[minY].y > quad[index].y) {
minY = index;
}
if (quad[maxX].x < quad[index].x) {
maxX = index;
}
if (quad[maxY].y < quad[index].y) {
maxY = index;
}
}
for (index = 0; index < 3; ++index) {
if (AlmostEqualUlps(quad[index].x, quad[minX].x)) {
minXSet |= 1 << index;
}
if (AlmostEqualUlps(quad[index].y, quad[minY].y)) {
minYSet |= 1 << index;
}
}
if (minXSet == 0x7) { // test for vertical line
if (minYSet == 0x7) { // return 1 if all four are coincident
return coincident_line(quad, reduction);
}
return vertical_line(quad, reduction);
}
if (minYSet == 0xF) { // test for horizontal line
return horizontal_line(quad, reduction);
}
int result = check_linear(quad, reduction, minX, maxX, minY, maxY);
if (result) {
return result;
}
memcpy(reduction, quad, sizeof(Quadratic));
return 3;
}
