PathOpsAngleTest.cpp File Reference

#include "include/core/SkPoint.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkTemplates.h"
#include "src/base/SkArenaAlloc.h"
#include "src/base/SkFloatBits.h"
#include "src/base/SkRandom.h"
#include "src/pathops/SkIntersections.h"
#include "src/pathops/SkOpAngle.h"
#include "src/pathops/SkOpContour.h"
#include "src/pathops/SkOpSegment.h"
#include "src/pathops/SkPathOpsLine.h"
#include "src/pathops/SkPathOpsPoint.h"
#include "src/pathops/SkPathOpsQuad.h"
#include "src/pathops/SkPathOpsTypes.h"
#include "tests/PathOpsTestCommon.h"
#include "tests/Test.h"
#include <array>
#include <cfloat>
#include <cmath>

Go to the source code of this file.

Classes
class	PathOpsAngleTester
class	PathOpsSegmentTester
struct	CircleData
struct	IntersectData
struct	FourPoints

Macros
#define	I(x)   intersectDataSet##x
#define	I(x)   (int) std::size(intersectDataSet##x)

Functions
static float	next (float f)
static float	prev (float f)
	DEF_TEST (PathOpsAngleFindCrossEpsilon, reporter)
	DEF_TEST (PathOpsAngleFindQuadEpsilon, reporter)
static int	find_slop (double x, double y, double rx, double ry)
static double	diamond_angle (double y, double x)
	DEF_TEST (PathOpsAngleFindSlop, reporter)
	DEF_TEST (PathOpsAngleCircle, reporter)
	DEF_TEST (PathOpsAngleAfter, reporter)
	DEF_TEST (PathOpsAngleAllOnOneSide, reporter)

Variables
static bool	gDisableAngleTests = true
static const double	slopTests [][4]
static CircleData	circleDataSet []
static const int	circleDataSetSize = (int) std::size(circleDataSet)
static IntersectData	intersectDataSet1 []
static IntersectData	intersectDataSet2 []
static IntersectData	intersectDataSet3 []
static IntersectData	intersectDataSet4 []
static IntersectData	intersectDataSet5 []
static IntersectData	intersectDataSet6 []
static IntersectData	intersectDataSet7 []
static IntersectData	intersectDataSet8 []
static IntersectData	intersectDataSet9 []
static IntersectData	intersectDataSet10 []
static IntersectData	intersectDataSet11 []
static IntersectData	intersectDataSet12 []
static IntersectData	intersectDataSet13 []
static IntersectData	intersectDataSet14 []
static IntersectData	intersectDataSet15 []
static IntersectData	intersectDataSet16 []
static IntersectData	intersectDataSet17 []
static IntersectData	intersectDataSet18 []
static IntersectData	intersectDataSet19 []
static IntersectData *	intersectDataSets []
static const int	intersectDataSetSizes []
static const int	intersectDataSetsSize = (int) std::size(intersectDataSetSizes)

Macro Definition Documentation

I [1/2]

#define I

(

x

)

intersectDataSet##x

Definition at line 433 of file PathOpsAngleTest.cpp.

I [2/2]

#define I

(

x

)

(int) std::size(intersectDataSet##x)

Definition at line 433 of file PathOpsAngleTest.cpp.

Function Documentation

DEF_TEST() [1/6]

DEF_TEST	(	PathOpsAngleAfter	,
		reporter
	)

Definition at line 448 of file PathOpsAngleTest.cpp.

                                      {
    for (int index = intersectDataSetsSize - 1; index >= 0; --index) {
        IntersectData* dataArray = intersectDataSets[index];
        const int dataSize = intersectDataSetSizes[index];
        for (int index2 = 0; index2 < dataSize - 2; ++index2) {
            SkSTArenaAlloc<4096> alloc;
            SkOpContourHead contour;
            SkOpGlobalState state(&contour, &alloc  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
            contour.init(&state, false, false);
            for (int index3 = 0; index3 < 3; ++index3) {
                IntersectData& data = dataArray[index2 + index3];
                SkPoint* temp = (SkPoint*) alloc.make<FourPoints>();
                for (int idx2 = 0; idx2 < data.fPtCount; ++idx2) {
                    temp[idx2] = data.fPts.fPts[idx2].asSkPoint();
                }
                switch (data.fPtCount) {
                    case 2: {
                        contour.addLine(temp);
                        } break;
                    case 3: {
                        contour.addQuad(temp);
                        } break;
                    case 4: {
                        contour.addCubic(temp);
                        } break;
                }
            }
            SkOpSegment* seg1 = contour.first();
            seg1->debugAddAngle(dataArray[index2 + 0].fTStart, dataArray[index2 + 0].fTEnd);
            SkOpSegment* seg2 = seg1->next();
            seg2->debugAddAngle(dataArray[index2 + 1].fTStart, dataArray[index2 + 1].fTEnd);
            SkOpSegment* seg3 = seg2->next();
            seg3->debugAddAngle(dataArray[index2 + 2].fTStart, dataArray[index2 + 2].fTEnd);
            SkOpAngle& angle1 = *seg1->debugLastAngle();
            SkOpAngle& angle2 = *seg2->debugLastAngle();
            SkOpAngle& angle3 = *seg3->debugLastAngle();
            PathOpsAngleTester::SetNext(angle1, angle3);
       // These data sets are seeded when the set itself fails, so likely the dataset does not
       // match the expected result. The tests above return 1 when first added, but
       // return 0 after the bug is fixed.
            SkDEBUGCODE(int result =) PathOpsAngleTester::After(angle2, angle1);
            SkASSERT(result == 0 || result == 1);
        }
    }
}

DEF_TEST() [2/6]

DEF_TEST	(	PathOpsAngleAllOnOneSide	,
		reporter
	)

Definition at line 494 of file PathOpsAngleTest.cpp.

                                             {
    SkSTArenaAlloc<4096> allocator;
    SkOpContourHead contour;
    SkOpGlobalState state(&contour, &allocator  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
    contour.init(&state, false, false);
    SkPoint conicPts[3] = {{494.37100219726562f, 224.66200256347656f},
        {494.37360910682298f, 224.6729026561527f},
        {494.37600708007813f, 224.68400573730469f}};
    SkPoint linePts[2] = {{494.371002f, 224.662003f}, {494.375000f, 224.675995f}};
    for (int i = 10; i >= 0; --i) {
        SkPoint modLinePts[2] = { linePts[0], linePts[1] };
        modLinePts[1].fX += i * .1f;
        contour.addLine(modLinePts);
        contour.addQuad(conicPts);
   //     contour.addConic(conicPts, 0.999935746f, &allocator);
        SkOpSegment* first = contour.first();
        first->debugAddAngle(0, 1);
        SkOpSegment* next = first->next();
        next->debugAddAngle(0, 1);
        /* int result = */
            PathOpsAngleTester::AllOnOneSide(*first->debugLastAngle(), *next->debugLastAngle());
  //      SkDebugf("i=%d result=%d\n", i , result);
    }
}

DEF_TEST() [3/6]

DEF_TEST	(	PathOpsAngleCircle	,
		reporter
	)

Definition at line 256 of file PathOpsAngleTest.cpp.

                                       {
    SkSTArenaAlloc<4096> allocator;
    SkOpContourHead contour;
    SkOpGlobalState state(&contour, &allocator  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
    contour.init(&state, false, false);
    for (int index = 0; index < circleDataSetSize; ++index) {
        CircleData& data = circleDataSet[index];
        for (int idx2 = 0; idx2 < data.fPtCount; ++idx2) {
            data.fShortPts[idx2] = data.fPts.fPts[idx2].asSkPoint();
        }
        switch (data.fPtCount) {
            case 2:
                contour.addLine(data.fShortPts);
                break;
            case 3:
                contour.addQuad(data.fShortPts);
                break;
            case 4:
                contour.addCubic(data.fShortPts);
                break;
        }
    }
    SkOpSegment* first = contour.first();
    first->debugAddAngle(0, 1);
    SkOpSegment* next = first->next();
    next->debugAddAngle(0, 1);
    PathOpsAngleTester::Orderable(*first->debugLastAngle(), *next->debugLastAngle());
}

DEF_TEST() [4/6]

DEF_TEST	(	PathOpsAngleFindCrossEpsilon	,
		reporter
	)

Definition at line 48 of file PathOpsAngleTest.cpp.

                                                 {
    if (gDisableAngleTests) {
        return;
    }
    SkRandom ran;
    int maxEpsilon = 0;
    for (int index = 0; index < 10000000; ++index) {
        SkDLine line = {{{0, 0}, {ran.nextRangeF(0.0001f, 1000), ran.nextRangeF(0.0001f, 1000)}}};
        for (int inner = 0; inner < 10; ++inner) {
            float t = ran.nextRangeF(0.0001f, 1);
            SkDPoint dPt = line.ptAtT(t);
            SkPoint pt = dPt.asSkPoint();
            float xs[3] = { prev(pt.fX), pt.fX, next(pt.fX) };
            float ys[3] = { prev(pt.fY), pt.fY, next(pt.fY) };
            for (int xIdx = 0; xIdx < 3; ++xIdx) {
                for (int yIdx = 0; yIdx < 3; ++yIdx) {
                    SkPoint test = { xs[xIdx], ys[yIdx] };
                    float p1 = SkDoubleToScalar(line[1].fX * test.fY);
                    float p2 = SkDoubleToScalar(line[1].fY * test.fX);
                    int p1Bits = SkFloatAs2sCompliment(p1);
                    int p2Bits = SkFloatAs2sCompliment(p2);
                    int epsilon = SkTAbs(p1Bits - p2Bits);
                    if (maxEpsilon < epsilon) {
                        SkDebugf("line={{0, 0}, {%1.7g, %1.7g}} t=%1.7g pt={%1.7g, %1.7g}"
                            " epsilon=%d\n",
                            line[1].fX, line[1].fY, t, test.fX, test.fY, epsilon);
                        maxEpsilon = epsilon;
                    }
                }
            }
        }
    }
}

DEF_TEST() [5/6]

DEF_TEST	(	PathOpsAngleFindQuadEpsilon	,
		reporter
	)

Definition at line 82 of file PathOpsAngleTest.cpp.

                                                {
    if (gDisableAngleTests) {
        return;
    }
    SkRandom ran;
    int maxEpsilon = 0;
    double maxAngle = 0;
    for (int index = 0; index < 100000; ++index) {
        SkDLine line = {{{0, 0}, {ran.nextRangeF(0.0001f, 1000), ran.nextRangeF(0.0001f, 1000)}}};
        float t = ran.nextRangeF(0.0001f, 1);
        SkDPoint dPt = line.ptAtT(t);
        float t2 = ran.nextRangeF(0.0001f, 1);
        SkDPoint qPt = line.ptAtT(t2);
        float t3 = ran.nextRangeF(0.0001f, 1);
        SkDPoint qPt2 = line.ptAtT(t3);
        qPt.fX += qPt2.fY;
        qPt.fY -= qPt2.fX;
        QuadPts q = {{line[0], dPt, qPt}};
        SkDQuad quad;
        quad.debugSet(q.fPts);
        // binary search for maximum movement of quad[1] towards test that still has 1 intersection
        double moveT = 0.5f;
        double deltaT = moveT / 2;
        SkDPoint last;
        do {
            last = quad[1];
            quad[1].fX = dPt.fX - line[1].fY * moveT;
            quad[1].fY = dPt.fY + line[1].fX * moveT;
            SkIntersections i;
            i.intersect(quad, line);
            REPORTER_ASSERT(reporter, i.used() > 0);
            if (i.used() == 1) {
                moveT += deltaT;
            } else {
                moveT -= deltaT;
            }
            deltaT /= 2;
        } while (last.asSkPoint() != quad[1].asSkPoint());
        float p1 = SkDoubleToScalar(line[1].fX * last.fY);
        float p2 = SkDoubleToScalar(line[1].fY * last.fX);
        int p1Bits = SkFloatAs2sCompliment(p1);
        int p2Bits = SkFloatAs2sCompliment(p2);
        int epsilon = SkTAbs(p1Bits - p2Bits);
        if (maxEpsilon < epsilon) {
            SkDebugf("line={{0, 0}, {%1.7g, %1.7g}} t=%1.7g/%1.7g/%1.7g moveT=%1.7g"
                    " pt={%1.7g, %1.7g} epsilon=%d\n",
                    line[1].fX, line[1].fY, t, t2, t3, moveT, last.fX, last.fY, epsilon);
            maxEpsilon = epsilon;
        }
        double a1 = atan2(line[1].fY, line[1].fX);
        double a2 = atan2(last.fY, last.fX);
        double angle = fabs(a1 - a2);
        if (maxAngle < angle) {
            SkDebugf("line={{0, 0}, {%1.7g, %1.7g}} t=%1.7g/%1.7g/%1.7g moveT=%1.7g"
                    " pt={%1.7g, %1.7g} angle=%1.7g\n",
                    line[1].fX, line[1].fY, t, t2, t3, moveT, last.fX, last.fY, angle);
            maxAngle = angle;
        }
    }
}

DEF_TEST() [6/6]

DEF_TEST	(	PathOpsAngleFindSlop	,
		reporter
	)

Definition at line 188 of file PathOpsAngleTest.cpp.

                                         {
    if (gDisableAngleTests) {
        return;
    }
    for (int index = 0; index < (int) std::size(slopTests); ++index) {
        const double* slopTest = slopTests[index];
        double x = slopTest[0];
        double y = slopTest[1];
        double rx = slopTest[2];
        double ry = slopTest[3];
        SkDebugf("%s  xy %d=%d\n", __FUNCTION__, index, find_slop(x, y, rx, ry));
        SkDebugf("%s rxy %d=%d\n", __FUNCTION__, index, find_slop(rx, ry, x, y));
        double angle = diamond_angle(y, x);
        double rAngle = diamond_angle(ry, rx);
        double diff = fabs(angle - rAngle);
        SkDebugf("%s diamond xy=%1.9g rxy=%1.9g diff=%1.9g factor=%d\n", __FUNCTION__,
                angle, rAngle, diff, (int) (diff / FLT_EPSILON));
    }
}

diamond_angle()

static double diamond_angle ( double  y, double  x  )

static

Definition at line 173 of file PathOpsAngleTest.cpp.

{
    if (y >= 0)
        return (x >= 0 ? y/(x+y) : 1-x/(-x+y));
    else
        return (x < 0 ? 2-y/(-x-y) : 3+x/(x-y));
}

find_slop()

static int find_slop ( double  x, double  y, double  rx, double  ry  )

static

Definition at line 143 of file PathOpsAngleTest.cpp.

                                                               {
    int slopBits = 0;
    bool less1, less2;
    double absX = fabs(x);
    double absY = fabs(y);
    double length = absX < absY ? absX / 2 + absY : absX + absY / 2;
    int exponent;
    (void) frexp(length, &exponent);
    double epsilon = ldexp(FLT_EPSILON, exponent);
    do {
        // get the length as the larger plus half the smaller (both same signs)
        // find the ulps of the length
        // compute the offsets from there
        double xSlop = epsilon * slopBits;
        double ySlop = x * y < 0 ? -xSlop : xSlop; // OPTIMIZATION: use copysign / _copysign ?
        double x1 = x - xSlop;
        double y1 = y + ySlop;
        double x_ry1 = x1 * ry;
        double rx_y1 = rx * y1;
        less1 = x_ry1 < rx_y1;
        double x2 = x + xSlop;
        double y2 = y - ySlop;
        double x_ry2 = x2 * ry;
        double rx_y2 = rx * y2;
        less2 = x_ry2 < rx_y2;
    } while (less1 == less2 && ++slopBits);
    return slopBits;
}

next()

static float next ( float  f )

static

Definition at line 32 of file PathOpsAngleTest.cpp.

{
    int fBits = SkFloatAs2sCompliment(f);
    ++fBits;
    float fNext = Sk2sComplimentAsFloat(fBits);
    return fNext;
}

prev()

static float prev ( float  f )

static

Definition at line 40 of file PathOpsAngleTest.cpp.

{
    int fBits = SkFloatAs2sCompliment(f);
    --fBits;
    float fNext = Sk2sComplimentAsFloat(fBits);
    return fNext;
}

Variable Documentation

circleDataSet

CircleData circleDataSet[]

static

Initial value:

= {
    { {{{313.0155029296875, 207.90290832519531}, {320.05078125, 227.58743286132812}}}, 2, {} },
    { {{{313.0155029296875, 207.90290832519531}, {313.98246891063195, 219.33615203830394},
            {320.05078125, 227.58743286132812}}}, 3, {} },
}

Definition at line 248 of file PathOpsAngleTest.cpp.

circleDataSetSize

const int circleDataSetSize = (int) std::size(circleDataSet)

static

Definition at line 254 of file PathOpsAngleTest.cpp.

gDisableAngleTests

bool gDisableAngleTests = true

static

Definition at line 30 of file PathOpsAngleTest.cpp.

intersectDataSet1

IntersectData intersectDataSet1[]

static

Initial value:

= {
    { {{{322.935669,231.030273}, {312.832214,220.393295}, {312.832214,203.454178}}}, 3,
            0.865309956, 0.154740299, {} },
    { {{{322.12738,233.397751}, {295.718353,159.505829}}}, 2,
            0.345028807, 0.0786326511, {} },
    { {{{322.935669,231.030273}, {312.832214,220.393295}, {312.832214,203.454178}}}, 3,
            0.865309956, 1, {} },
    { {{{322.12738,233.397751}, {295.718353,159.505829}}}, 2,
            0.345028807, 1, {} },
}

Definition at line 293 of file PathOpsAngleTest.cpp.

intersectDataSet10

IntersectData intersectDataSet10[]

static

Initial value:

= { 
    { {{{0.000,1.000}, {1.000,6.000}, {1.000,0.000}, {1.000,0.000}}}, 4, 0.788195121, 0.726275769, {} }, 
    { {{{0.000,1.000}, {0.000,1.000}, {1.000,0.000}, {6.000,1.000}}}, 4, 0.473378977, 1, {} }, 
    { {{{0.000,1.000}, {1.000,6.000}, {1.000,0.000}, {1.000,0.000}}}, 4, 0.788195121, 1, {} }, 
}

Definition at line 355 of file PathOpsAngleTest.cpp.

intersectDataSet11

IntersectData intersectDataSet11[]

static

Initial value:

= { 
    { {{{979.305,561.000}, {1036.695,291.000}}}, 2, 0.888888874, 0.11111108, {} }, 
    { {{{1006.695,291.000}, {1023.264,291.000}, {1033.840,304.431}, {1030.318,321.000}}}, 4, 1, 0, {} }, 
    { {{{979.305,561.000}, {1036.695,291.000}}}, 2, 0.888888874, 1, {} }, 
}

Definition at line 361 of file PathOpsAngleTest.cpp.

intersectDataSet12

IntersectData intersectDataSet12[]

static

Initial value:

= { 
    { {{{67.000,912.000}, {67.000,913.000}}}, 2, 1, 0, {} }, 
    { {{{67.000,913.000}, {67.000,917.389}, {67.224,921.726}, {67.662,926.000}}}, 4, 0, 1, {} }, 
    { {{{194.000,1041.000}, {123.860,1041.000}, {67.000,983.692}, {67.000,913.000}}}, 4, 1, 0, {} }, 
}

Definition at line 367 of file PathOpsAngleTest.cpp.

intersectDataSet13

IntersectData intersectDataSet13[]

static

Initial value:

= { 
    { {{{6.000,0.000}, {0.000,4.000}}}, 2, 0.625, 0.25, {} }, 
    { {{{0.000,1.000}, {0.000,6.000}, {4.000,0.000}, {6.000,1.000}}}, 4, 0.5, 0.833333333, {} }, 
    { {{{0.000,1.000}, {0.000,6.000}, {4.000,0.000}, {6.000,1.000}}}, 4, 0.5, 0.379043969, {} }, 
}

Definition at line 373 of file PathOpsAngleTest.cpp.

intersectDataSet14

IntersectData intersectDataSet14[]

static

Initial value:

= { 
    { {{{0.000,1.000}, {4.000,6.000}, {2.000,1.000}, {2.000,0.000}}}, 4, 0.0756502183, 0.0594570973, {} }, 
    { {{{1.000,2.000}, {0.000,2.000}, {1.000,0.000}, {6.000,4.000}}}, 4, 0.0756502184, 0, {} }, 
    { {{{0.000,1.000}, {4.000,6.000}, {2.000,1.000}, {2.000,0.000}}}, 4, 0.0756502183, 0.531917258, {} }, 
}

Definition at line 379 of file PathOpsAngleTest.cpp.

intersectDataSet15

IntersectData intersectDataSet15[]

static

Initial value:

= { 
    { {{{490.435,879.407}, {405.593,909.436}}}, 2, 0.500554405, 1, {} }, 
    { {{{447.967,894.438}, {448.007,894.424}, {448.014,894.422}}}, 3, 0, 1, {} }, 
    { {{{490.435,879.407}, {405.593,909.436}}}, 2, 0.500554405, 0.500000273, {} }, 
}

Definition at line 385 of file PathOpsAngleTest.cpp.

intersectDataSet16

IntersectData intersectDataSet16[]

static

Initial value:

= { 
    { {{{1.000,4.000}, {4.000,5.000}, {3.000,2.000}, {6.000,3.000}}}, 4, 0.5, 0, {} }, 
    { {{{2.000,3.000}, {3.000,6.000}, {4.000,1.000}, {5.000,4.000}}}, 4, 0.5, 0.112701665, {} }, 
    { {{{5.000,4.000}, {2.000,3.000}}}, 2, 0.5, 0, {} }, 
}

Definition at line 391 of file PathOpsAngleTest.cpp.

intersectDataSet17

IntersectData intersectDataSet17[]

static

Initial value:

= {
    {  {{{270.974121f, 770.025879f}, {234.948273f, 734}, {184, 734}}}
        , 3, 0.74590454, 0.547660352, {} },
    {  {{{185, 734}, {252.93103f, 734}, {308, 789.06897f}, {308, 857}}}
        , 4, 0.12052623, 0, {} },
    {  {{{270.974121f, 770.025879f}, {234.948273f, 734}, {184, 734}}}
        , 3, 0.74590454, 1, {} },
}

Definition at line 398 of file PathOpsAngleTest.cpp.

intersectDataSet18

IntersectData intersectDataSet18[]

static

Initial value:

= {
    {  {{{270.974121f, 770.025879f}, {234.948273f, 734}, {184, 734}}}
        , 3, 0.74590454, 1, {} },
    {  {{{185, 734}, {252.93103f, 734}, {308, 789.06897f}, {308, 857}}}
        , 4, 0.12052623, 0.217351928, {} },
    {  {{{270.974121f, 770.025879f}, {234.948273f, 734}, {184, 734}}}
        , 3, 0.74590454, 0.547660352, {} },
}

Definition at line 407 of file PathOpsAngleTest.cpp.

intersectDataSet19

IntersectData intersectDataSet19[]

static

Initial value:

= {
    {  {{{0, 1}, {3, 5}, {2, 1}, {3, 1}}}
        , 4, 0.135148995, 0.134791946, {} },
    {  {{{1, 2}, {1, 2.15061641f}, {1, 2.21049166f}, {1.01366711f, 2.21379328f}}}
        , 4, 0.956740456, 0.894913214, {} },
    {  {{{0, 1}, {3, 5}, {2, 1}, {3, 1}}}
        , 4, 0.135148995, 0.551812363, {} },
}

Definition at line 416 of file PathOpsAngleTest.cpp.

intersectDataSet2

IntersectData intersectDataSet2[]

static

Initial value:

= {
    { {{{364.390686,157.898193}, {375.281769,136.674606}, {396.039917,136.674606}}}, 3,
            0.578520747, 1, {} },
    { {{{364.390686,157.898193}, {375.281769,136.674606}, {396.039917,136.674606}}}, 3,
            0.578520747, 0.536512973, {} },
    { {{{366.608826,151.196014}, {378.803101,136.674606}, {398.164948,136.674606}}}, 3,
            0.490456543, 1, {} },
}

Definition at line 304 of file PathOpsAngleTest.cpp.

intersectDataSet3

IntersectData intersectDataSet3[]

static

Initial value:

= {
    { {{{2.000000,0.000000}, {1.33333333,0.66666667}}}, 2, 1, 0, {} },
    { {{{1.33333333,0.66666667}, {0.000000,2.000000}}}, 2, 0, 0.25, {} },
    { {{{2.000000,2.000000}, {1.33333333,0.66666667}}}, 2, 1, 0, {} },
}

Definition at line 313 of file PathOpsAngleTest.cpp.

intersectDataSet4

IntersectData intersectDataSet4[]

static

Initial value:

= {
    { {{{1.3333333,0.6666667}, {0.000,2.000}}}, 2, 0.250000006, 0, {} },
    { {{{1.000,0.000}, {1.000,1.000}}}, 2, 1, 0, {} },
    { {{{1.000,1.000}, {0.000,0.000}}}, 2, 0, 1, {} },
}

Definition at line 319 of file PathOpsAngleTest.cpp.

intersectDataSet5

IntersectData intersectDataSet5[]

static

Initial value:

= {
    { {{{0.000,0.000}, {1.000,0.000}, {1.000,1.000}}}, 3, 1, 0.666666667, {} },
    { {{{0.000,0.000}, {2.000,1.000}, {0.000,2.000}}}, 3, 0.5, 1, {} },
    { {{{0.000,0.000}, {2.000,1.000}, {0.000,2.000}}}, 3, 0.5, 0, {} },
}

Definition at line 325 of file PathOpsAngleTest.cpp.

intersectDataSet6

IntersectData intersectDataSet6[]

static

Initial value:

= { 
    { {{{0.000,1.000}, {3.000,4.000}, {1.000,0.000}, {3.000,0.000}}}, 4, 0.0925339054, 0, {} }, 
    { {{{0.000,1.000}, {0.000,3.000}, {1.000,0.000}, {4.000,3.000}}}, 4, 0.453872386, 0, {} }, 
    { {{{0.000,1.000}, {3.000,4.000}, {1.000,0.000}, {3.000,0.000}}}, 4, 0.0925339054, 0.417096368, {} }, 
}

Definition at line 331 of file PathOpsAngleTest.cpp.

intersectDataSet7

IntersectData intersectDataSet7[]

static

Initial value:

= { 
    { {{{2.000,1.000}, {0.000,1.000}}}, 2, 0.5, 0, {} }, 
    { {{{2.000,0.000}, {0.000,2.000}}}, 2, 0.5, 1, {} }, 
    { {{{0.000,1.000}, {0.000,2.000}, {2.000,0.000}, {2.000,1.000}}}, 4, 0.5, 1, {} }, 
}

Definition at line 337 of file PathOpsAngleTest.cpp.

intersectDataSet8

IntersectData intersectDataSet8[]

static

Initial value:

= { 
    { {{{0.000,1.000}, {2.000,3.000}, {5.000,1.000}, {4.000,3.000}}}, 4, 0.311007457, 0.285714286, {} }, 
    { {{{1.000,5.000}, {3.000,4.000}, {1.000,0.000}, {3.000,2.000}}}, 4, 0.589885081, 0.999982974, {} }, 
    { {{{1.000,5.000}, {3.000,4.000}, {1.000,0.000}, {3.000,2.000}}}, 4, 0.589885081, 0.576935809, {} }, 
}

Definition at line 343 of file PathOpsAngleTest.cpp.

intersectDataSet9

IntersectData intersectDataSet9[]

static

Initial value:

= { 
    { {{{0.000,1.000}, {2.000,3.000}, {5.000,1.000}, {4.000,3.000}}}, 4, 0.476627072, 0.311007457, {} }, 
    { {{{1.000,5.000}, {3.000,4.000}, {1.000,0.000}, {3.000,2.000}}}, 4, 0.999982974, 1, {} }, 
    { {{{0.000,1.000}, {2.000,3.000}, {5.000,1.000}, {4.000,3.000}}}, 4, 0.476627072, 1, {} }, 
}

Definition at line 349 of file PathOpsAngleTest.cpp.

intersectDataSets

IntersectData* intersectDataSets[]

static

Initial value:

= {
    I(1), I(2), I(3), I(4), I(5), I(6), I(7), I(8), I(9), I(10),
    I(11), I(12), I(13), I(14), I(15), I(16), I(17), I(18), I(19),
}

Definition at line 427 of file PathOpsAngleTest.cpp.

intersectDataSetSizes

const int intersectDataSetSizes[]

static

Initial value:

= {
    I(1), I(2), I(3), I(4), I(5), I(6), I(7), I(8), I(9), I(10),
    I(11), I(12), I(13), I(14), I(15), I(16), I(17), I(18), I(19),
}

Definition at line 435 of file PathOpsAngleTest.cpp.

intersectDataSetsSize

const int intersectDataSetsSize = (int) std::size(intersectDataSetSizes)

static

Definition at line 442 of file PathOpsAngleTest.cpp.

slopTests

const double slopTests[][4]

static

Initial value:

= {
   
    {-0.058554756452593892, -0.18804585843827226, -0.018568569646021160, -0.059615294434479438},
    {-0.0013717412948608398, 0.0041152238845825195, -0.00045837944195925573, 0.0013753175735478074},
    {-2.1033774145221198, -1.4046019261273715e-008, -0.70062688352066704, -1.2706324683777995e-008},
}

Definition at line 181 of file PathOpsAngleTest.cpp.