PathOpsConicIntersectionTest.cpp File Reference

#include "include/core/SkPoint.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "src/core/SkGeometry.h"
#include "src/pathops/SkIntersections.h"
#include "src/pathops/SkPathOpsConic.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>

Go to the source code of this file.

Macros
#define	DEBUG_VISUALIZE_CONICS   0

Functions
static void	chopCompare (const SkConic chopped[2], const SkDConic dChopped[2])
static void	chopBothWays (const SkDConic &dConic, double t, const char *name)
static void	oneOff (skiatest::Reporter *reporter, const ConicPts &conic1, const ConicPts &conic2, bool coin)
static void	oneOff (skiatest::Reporter *reporter, int outer, int inner)
static void	oneOffTests (skiatest::Reporter *reporter)
	DEF_TEST (PathOpsConicIntersectionOneOff, reporter)
	DEF_TEST (PathOpsConicIntersection, reporter)

Variables
static const ConicPts	testSet []
const int	testSetCount = (int) std::size(testSet)

Macro Definition Documentation

DEBUG_VISUALIZE_CONICS

#define DEBUG_VISUALIZE_CONICS   0

Definition at line 72 of file PathOpsConicIntersectionTest.cpp.

Function Documentation

chopBothWays()

static void chopBothWays ( const SkDConic &  dConic, double  t, const char *  name  )

static

Definition at line 166 of file PathOpsConicIntersectionTest.cpp.

                                                                             {
    SkConic conic;
    for (int index = 0; index < 3; ++index) {
        conic.fPts[index] = dConic.fPts[index].asSkPoint();
    }
    conic.fW = dConic.fWeight;
    SkConic chopped[2];
    SkDConic dChopped[2];
    if (!conic.chopAt(SkDoubleToScalar(t), chopped)) {
        return;
    }
    dChopped[0] = dConic.subDivide(0, t);
    dChopped[1] = dConic.subDivide(t, 1);
#if DEBUG_VISUALIZE_CONICS
    dConic.dump();
#endif
    chopCompare(chopped, dChopped);
#if DEBUG_VISUALIZE_CONICS
    writePng(conic, chopped, name);
#endif
}

chopCompare()

static void chopCompare ( const SkConic  chopped[2], const SkDConic  dChopped[2]  )

static

Definition at line 56 of file PathOpsConicIntersectionTest.cpp.

                                                                              {
    SkASSERT(roughly_equal(chopped[0].fW, dChopped[0].fWeight));
    SkASSERT(roughly_equal(chopped[1].fW, dChopped[1].fWeight));
    for (int cIndex = 0; cIndex < 2; ++cIndex) {
        for (int pIndex = 0; pIndex < 3; ++pIndex) {
            SkDPoint up;
            up.set(chopped[cIndex].fPts[pIndex]);
            SkASSERT(dChopped[cIndex].fPts[pIndex].approximatelyEqual(up));
        }
    }
#if DEBUG_VISUALIZE_CONICS
    dChopped[0].dump();
    dChopped[1].dump();
#endif
}

DEF_TEST() [1/2]

DEF_TEST	(	PathOpsConicIntersection	,
		reporter
	)

Definition at line 356 of file PathOpsConicIntersectionTest.cpp.

                                             {
    oneOffTests(reporter);
}

DEF_TEST() [2/2]

DEF_TEST	(	PathOpsConicIntersectionOneOff	,
		reporter
	)

Definition at line 352 of file PathOpsConicIntersectionTest.cpp.

                                                   {
    oneOff(reporter, 0, 1);
}

oneOff() [1/2]

static void oneOff ( skiatest::Reporter *  reporter, const ConicPts &  conic1, const ConicPts &  conic2, bool  coin  )

static

Definition at line 304 of file PathOpsConicIntersectionTest.cpp.

                   {
#if DEBUG_VISUALIZE_CONICS
    writeFrames();
#endif
    SkDConic c1, c2;
    c1.debugSet(conic1.fPts.fPts, conic1.fWeight);
    c2.debugSet(conic2.fPts.fPts, conic2.fWeight);
    chopBothWays(c1, 0.5, "c1");
    chopBothWays(c2, 0.5, "c2");
#if DEBUG_VISUALIZE_CONICS
    writeDPng(c1, "d1");
    writeDPng(c2, "d2");
#endif
    SkASSERT(ValidConic(c1));
    SkASSERT(ValidConic(c2));
    SkIntersections intersections;
    intersections.intersect(c1, c2);
    REPORTER_ASSERT(reporter, !coin || intersections.used() == 2);
    double tt1, tt2;
    SkDPoint xy1, xy2;
    for (int pt3 = 0; pt3 < intersections.used(); ++pt3) {
        tt1 = intersections[0][pt3];
        xy1 = c1.ptAtT(tt1);
        tt2 = intersections[1][pt3];
        xy2 = c2.ptAtT(tt2);
        const SkDPoint& iPt = intersections.pt(pt3);
        REPORTER_ASSERT(reporter, xy1.approximatelyEqual(iPt));
        REPORTER_ASSERT(reporter, xy2.approximatelyEqual(iPt));
        REPORTER_ASSERT(reporter, xy1.approximatelyEqual(xy2));
    }
    reporter->bumpTestCount();
}

oneOff() [2/2]

static void oneOff ( skiatest::Reporter *  reporter, int  outer, int  inner  )

static

Definition at line 338 of file PathOpsConicIntersectionTest.cpp.

                                                                     {
    const ConicPts& c1 = testSet[outer];
    const ConicPts& c2 = testSet[inner];
    oneOff(reporter, c1, c2, false);
}

oneOffTests()

static void oneOffTests ( skiatest::Reporter *  reporter )

static

Definition at line 344 of file PathOpsConicIntersectionTest.cpp.

                                                    {
    for (int outer = 0; outer < testSetCount - 1; ++outer) {
        for (int inner = outer + 1; inner < testSetCount; ++inner) {
            oneOff(reporter, outer, inner);
        }
    }
}

Variable Documentation

testSet

const ConicPts testSet[]

static

Initial value:

= {
    {{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
    {{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
 
    {{{{5.1114602088928223, 628.77813720703125},
        {10.834027290344238, 988.964111328125},
        {163.40835571289062, 988.964111328125}}}, 0.72944212f},
    {{{{163.40835571289062, 988.964111328125},
        {5, 988.964111328125},
        {5, 614.7423095703125}}}, 0.707106769f},
 
    {{{{11.17222976684570312, -8.103978157043457031},
        {22.91432571411132812, -10.37866020202636719},
        {23.7764129638671875, -7.725424289703369141}}}, 1.00862849f},
    {{{{-1.545085430145263672, -4.755282402038574219},
        {22.23132705688476562, -12.48070907592773438},
        {23.7764129638671875, -7.725427150726318359}}}, 0.707106769f},
 
    {{{{-4,1}, {-4,5}, {0,5}}}, 0.707106769f},
    {{{{-3,4}, {-3,1}, {0,1}}}, 0.707106769f},
 
    {{{{0, 0}, {0, 1}, {1, 1}}}, 0.5f},
    {{{{1, 0}, {0, 0}, {0, 1}}}, 0.5f},
 
}

Definition at line 28 of file PathOpsConicIntersectionTest.cpp.

testSetCount

const int testSetCount = (int) std::size(testSet)

Definition at line 54 of file PathOpsConicIntersectionTest.cpp.