PathCoverageTest.cpp File Reference

#include "include/core/SkPoint.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkSafe32.h"
#include "src/base/SkMathPriv.h"
#include "src/core/SkPointPriv.h"
#include "tests/Test.h"
#include <algorithm>
#include <array>
#include <cstdint>

Go to the source code of this file.

Macros
#define	MAX_COEFF_SHIFT   6

Functions
static int	cheap_distance (SkScalar dx, SkScalar dy)
static int	estimate_distance (const SkPoint points[])
static SkScalar	compute_distance (const SkPoint points[])
static uint32_t	estimate_pointCount (int distance)
static uint32_t	compute_pointCount (SkScalar d, SkScalar tol)
static uint32_t	quadraticPointCount_EE (const SkPoint points[])
static uint32_t	quadraticPointCount_EC (const SkPoint points[], SkScalar tol)
static uint32_t	quadraticPointCount_CE (const SkPoint points[])
static uint32_t	quadraticPointCount_CC (const SkPoint points[], SkScalar tol)
static bool	one_d_pe (const int *array, const unsigned int count, skiatest::Reporter *reporter)
static void	TestQuadPointCount (skiatest::Reporter *reporter)
	DEF_TEST (PathCoverage, reporter)

Variables
static const uint32_t	MAX_POINTS_PER_CURVE = 1 << MAX_COEFF_SHIFT
static const int	gXY []
static const int	gSawtooth []
static const int	gOvalish []
static const int	gSharpSawtooth []
static const int	gRibbon []

Macro Definition Documentation

MAX_COEFF_SHIFT

#define MAX_COEFF_SHIFT   6

Definition at line 27 of file PathCoverageTest.cpp.

Function Documentation

cheap_distance()

static int cheap_distance ( SkScalar  dx, SkScalar  dy  )

inlinestatic

Definition at line 35 of file PathCoverageTest.cpp.

                                                           {
    int idx = SkAbs32(SkScalarRoundToInt(dx));
    int idy = SkAbs32(SkScalarRoundToInt(dy));
    if (idx > idy) {
        idx += idy >> 1;
    } else {
        idx = idy + (idx >> 1);
    }
    return idx;
}

compute_distance()

static SkScalar compute_distance ( const SkPoint  points[] )

inlinestatic

Definition at line 51 of file PathCoverageTest.cpp.

                                                                {
    return SkPointPriv::DistanceToLineSegmentBetween(points[1], points[0], points[2]);
}

compute_pointCount()

static uint32_t compute_pointCount ( SkScalar  d, SkScalar  tol  )

inlinestatic

Definition at line 66 of file PathCoverageTest.cpp.

                                                                    {
    if (d < tol) {
       return 1;
    } else {
       int temp = SkScalarCeilToInt(SkScalarSqrt(d / tol));
       uint32_t count = std::min<uint32_t>(SkNextPow2(temp), MAX_POINTS_PER_CURVE);
       return count;
    }
}

DEF_TEST()

DEF_TEST	(	PathCoverage	,
		reporter
	)

Definition at line 165 of file PathCoverageTest.cpp.

                                 {
    TestQuadPointCount(reporter);
 
}

estimate_distance()

static int estimate_distance ( const SkPoint  points[] )

inlinestatic

Definition at line 46 of file PathCoverageTest.cpp.

                                                            {
    return cheap_distance(points[1].fX * 2 - points[2].fX - points[0].fX,
                          points[1].fY * 2 - points[2].fY - points[0].fY);
}

estimate_pointCount()

static uint32_t estimate_pointCount ( int  distance )

inlinestatic

Definition at line 55 of file PathCoverageTest.cpp.

                                                         {
    // Includes -2 bias because this estimator runs 4x high?
    int shift = 30 - SkCLZ(distance);
    // Clamp to zero if above subtraction went negative.
    shift &= ~(shift>>31);
    if (shift > MAX_COEFF_SHIFT) {
        shift = MAX_COEFF_SHIFT;
    }
    return 1 << shift;
}

one_d_pe()

static bool one_d_pe ( const int *  array, const unsigned int  count, skiatest::Reporter *  reporter  )

static

Definition at line 118 of file PathCoverageTest.cpp.

                                                 {
    SkPoint path [3];
    path[1] = SkPoint::Make(SkIntToScalar(array[0]), SkIntToScalar(array[1]));
    path[2] = SkPoint::Make(SkIntToScalar(array[2]), SkIntToScalar(array[3]));
    int numErrors = 0;
    for (unsigned i = 4; i < count; i += 2) {
        path[0] = path[1];
        path[1] = path[2];
        path[2] = SkPoint::Make(SkIntToScalar(array[i]),
                                SkIntToScalar(array[i+1]));
        uint32_t computedCount =
            quadraticPointCount_CC(path, SkIntToScalar(1));
        uint32_t estimatedCount =
            quadraticPointCount_EE(path);
 
        if ((false)) { // avoid bit rot, suppress warning
            computedCount = quadraticPointCount_EC(path, SkIntToScalar(1));
            estimatedCount = quadraticPointCount_CE(path);
        }
        // Allow estimated to be high by a factor of two, but no less than
        // the computed value.
        bool isAccurate = (estimatedCount >= computedCount) &&
            (estimatedCount <= 2 * computedCount);
 
        if (!isAccurate) {
            ERRORF(reporter, "Curve from %.2f %.2f through %.2f %.2f to "
                   "%.2f %.2f computes %u, estimates %u\n",
                   path[0].fX, path[0].fY, path[1].fX, path[1].fY,
                   path[2].fX, path[2].fY, computedCount, estimatedCount);
            numErrors++;
        }
    }
 
    return (numErrors == 0);
}

quadraticPointCount_CC()

static uint32_t quadraticPointCount_CC ( const SkPoint  points[], SkScalar  tol  )

static

Definition at line 91 of file PathCoverageTest.cpp.

                                                                             {
    SkScalar distance = compute_distance(points);
    return compute_pointCount(distance, tol);
}

quadraticPointCount_CE()

static uint32_t quadraticPointCount_CE ( const SkPoint  points[] )

static

Definition at line 86 of file PathCoverageTest.cpp.

                                                               {
    SkScalar distance = compute_distance(points);
    return estimate_pointCount(SkScalarRoundToInt(distance));
}

quadraticPointCount_EC()

static uint32_t quadraticPointCount_EC ( const SkPoint  points[], SkScalar  tol  )

static

Definition at line 81 of file PathCoverageTest.cpp.

                                                                             {
    int distance = estimate_distance(points);
    return compute_pointCount(SkIntToScalar(distance), tol);
}

quadraticPointCount_EE()

static uint32_t quadraticPointCount_EE ( const SkPoint  points[] )

static

Definition at line 76 of file PathCoverageTest.cpp.

                                                               {
    int distance = estimate_distance(points);
    return estimate_pointCount(distance);
}

TestQuadPointCount()

static void TestQuadPointCount ( skiatest::Reporter *  reporter )

static

Definition at line 157 of file PathCoverageTest.cpp.

                                                           {
    one_d_pe(gXY, std::size(gXY), reporter);
    one_d_pe(gSawtooth, std::size(gSawtooth), reporter);
    one_d_pe(gOvalish, std::size(gOvalish), reporter);
    one_d_pe(gSharpSawtooth, std::size(gSharpSawtooth), reporter);
    one_d_pe(gRibbon, std::size(gRibbon), reporter);
}

Variable Documentation

gOvalish

const int gOvalish[]

static

Initial value:

= {
    0, 0, 5, 15, 20, 20, 35, 15, 40, 0
}

Definition at line 105 of file PathCoverageTest.cpp.

                              {
    0, 0, 5, 15, 20, 20, 35, 15, 40, 0
};

gRibbon

const int gRibbon[]

static

Initial value:

= {
   -4, 0, 4, 20, 0, 25, -4, 20, 4, 0
}

Definition at line 114 of file PathCoverageTest.cpp.

                             {
   -4, 0, 4, 20, 0, 25, -4, 20, 4, 0
};

gSawtooth

const int gSawtooth[]

static

Initial value:

= {
    0, 0, 10, 10, 20, 20, 30, 10, 40, 0, 50, -10, 60, -20, 70, -10, 80, 0
}

Definition at line 101 of file PathCoverageTest.cpp.

                               {
    0, 0, 10, 10, 20, 20, 30, 10, 40, 0, 50, -10, 60, -20, 70, -10, 80, 0
};

gSharpSawtooth

const int gSharpSawtooth[]

static

Initial value:

= {
    0, 0, 1, 10, 2, 0, 3, -10, 4, 0
}

Definition at line 109 of file PathCoverageTest.cpp.

                                    {
    0, 0, 1, 10, 2, 0, 3, -10, 4, 0
};

gXY

const int gXY[]

static

Initial value:

= {
    4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
}

Definition at line 97 of file PathCoverageTest.cpp.

                         {
    4, 0, 0, -4, 8, -4, 12, 0, 8, 4, 0, 4
};

MAX_POINTS_PER_CURVE

const uint32_t MAX_POINTS_PER_CURVE = 1 << MAX_COEFF_SHIFT

static

Definition at line 28 of file PathCoverageTest.cpp.