path_stroke_with_zero_length.cpp File Reference

#include "gm/gm.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GrDirectContext.h"
#include "include/utils/SkParsePath.h"
#include "src/core/SkAutoPixmapStorage.h"

Go to the source code of this file.

Functions
static void	draw_path_cell (SkCanvas *canvas, SkSurface *surface, int expectedCaps)
static skiagm::DrawResult	draw_zero_length_capped_paths (SkCanvas *canvas, bool aa, SkString *errorMsg)
	DEF_SIMPLE_GM_BG_CAN_FAIL (zero_length_paths_aa, canvas, errorMsg, kTotalWidth, kTotalHeight, SK_ColorBLACK)
	DEF_SIMPLE_GM_BG_CAN_FAIL (zero_length_paths_bw, canvas, errorMsg, kTotalWidth, kTotalHeight, SK_ColorBLACK)
static skiagm::DrawResult	draw_zero_length_capped_paths_dbl_contour (SkCanvas *canvas, bool aa, SkString *errorMsg)
	DEF_SIMPLE_GM_BG_CAN_FAIL (zero_length_paths_dbl_aa, canvas, errorMsg, kDblContourTotalWidth, kTotalHeight, SK_ColorBLACK)
	DEF_SIMPLE_GM_BG_CAN_FAIL (zero_length_paths_dbl_bw, canvas, errorMsg, kDblContourTotalWidth, kTotalHeight, SK_ColorBLACK)

Variables
static const SkPaint::Cap	kCaps []
static const SkScalar	kWidths [] = { 0.0f, 0.9f, 1.0f, 1.1f, 15.0f, 25.0f }
static const char *	kAllVerbs []
static const char *	kSomeVerbs []
static const int	kCellWidth = 50
static const int	kCellHeight = 20
static const int	kCellPad = 2
static const int	kNumRows = std::size(kCaps) * std::size(kWidths)
static const int	kNumColumns = std::size(kAllVerbs)
static const int	kTotalWidth = kNumColumns * (kCellWidth + kCellPad) + kCellPad
static const int	kTotalHeight = kNumRows * (kCellHeight + kCellPad) + kCellPad
static const int	kDblContourNumColums = std::size(kSomeVerbs) * std::size(kSomeVerbs)
static const int	kDblContourTotalWidth = kDblContourNumColums * (kCellWidth + kCellPad) + kCellPad

Function Documentation

DEF_SIMPLE_GM_BG_CAN_FAIL() [1/4]

DEF_SIMPLE_GM_BG_CAN_FAIL	(	zero_length_paths_aa	,
		canvas	,
		errorMsg	,
		kTotalWidth	,
		kTotalHeight	,
		SK_ColorBLACK
	)

Definition at line 180 of file path_stroke_with_zero_length.cpp.

                                                                    {
    return draw_zero_length_capped_paths(canvas, true, errorMsg);
}

DEF_SIMPLE_GM_BG_CAN_FAIL() [2/4]

DEF_SIMPLE_GM_BG_CAN_FAIL	(	zero_length_paths_bw	,
		canvas	,
		errorMsg	,
		kTotalWidth	,
		kTotalHeight	,
		SK_ColorBLACK
	)

Definition at line 185 of file path_stroke_with_zero_length.cpp.

                                                                    {
    return draw_zero_length_capped_paths(canvas, false, errorMsg);
}

DEF_SIMPLE_GM_BG_CAN_FAIL() [3/4]

DEF_SIMPLE_GM_BG_CAN_FAIL	(	zero_length_paths_dbl_aa	,
		canvas	,
		errorMsg	,
		kDblContourTotalWidth	,
		kTotalHeight	,
		SK_ColorBLACK
	)

Definition at line 256 of file path_stroke_with_zero_length.cpp.

                                                                              {
    return draw_zero_length_capped_paths_dbl_contour(canvas, true, errorMsg);
}

DEF_SIMPLE_GM_BG_CAN_FAIL() [4/4]

DEF_SIMPLE_GM_BG_CAN_FAIL	(	zero_length_paths_dbl_bw	,
		canvas	,
		errorMsg	,
		kDblContourTotalWidth	,
		kTotalHeight	,
		SK_ColorBLACK
	)

Definition at line 261 of file path_stroke_with_zero_length.cpp.

                                                                              {
    return draw_zero_length_capped_paths_dbl_contour(canvas, false, errorMsg);
}

draw_path_cell()

static void draw_path_cell ( SkCanvas *  canvas, SkSurface *  surface, int  expectedCaps  )

static

Definition at line 38 of file path_stroke_with_zero_length.cpp.

                                             {
    static const SkColor kFailureRed = 0x7F7F0000;
    static const SkColor kFailureYellow = 0x7F7F7F00;
    static const SkColor kSuccessGreen = 0x7F007f00;
 
    int w = surface->width(), h = surface->height();
 
    // Read the pixels back
    SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
    SkAutoPixmapStorage pmap;
    pmap.alloc(info);
    if (!surface->readPixels(pmap, 0, 0)) {
        return;
    }
 
    // To account for rasterization differences, we scan the middle two rows [y, y+1] of the image
    SkASSERT(h % 2 == 0);
    int y = (h - 1) / 2;
 
    bool inBlob = false;
    int numBlobs = 0;
    for (int x = 0; x < w; ++x) {
        // We drew white-on-black. We can look for any non-zero value. Just check red.
        // And we care if either row is non-zero, so just add them to simplify everything.
        uint32_t v = SkGetPackedR32(*pmap.addr32(x, y)) + SkGetPackedR32(*pmap.addr32(x, y + 1));
 
        if (!inBlob && v) {
            ++numBlobs;
        }
        inBlob = SkToBool(v);
    }
 
    SkPaint result;
 
    if (numBlobs == expectedCaps) {
        result.setColor(kSuccessGreen); // Green
    } else if (numBlobs > expectedCaps) {
        result.setColor(kFailureYellow); // Yellow -- more geometry than expected
    } else {
        result.setColor(kFailureRed); // Red -- missing some geometry
    }
 
    auto img = surface->makeImageSnapshot();
    canvas->drawImage(img, 0, 0);
    canvas->drawRect(SkRect::MakeWH(w, h), result);
}

draw_zero_length_capped_paths()

static skiagm::DrawResult draw_zero_length_capped_paths ( SkCanvas *  canvas, bool  aa, SkString *  errorMsg  )

static

Definition at line 131 of file path_stroke_with_zero_length.cpp.

                                                                            {
    canvas->translate(kCellPad, kCellPad);
 
    SkImageInfo info = canvas->imageInfo().makeWH(kCellWidth, kCellHeight);
    auto surface = canvas->makeSurface(info);
    if (!surface) {
        surface = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(kCellWidth, kCellHeight));
    }
 
    SkPaint paint;
    paint.setColor(SK_ColorWHITE);
    paint.setAntiAlias(aa);
    paint.setStyle(SkPaint::kStroke_Style);
 
    for (auto cap : kCaps) {
        for (auto width : kWidths) {
            paint.setStrokeCap(cap);
            paint.setStrokeWidth(width);
            canvas->save();
 
            for (auto verb : kAllVerbs) {
                SkString pathStr;
                pathStr.appendf("M %f %f ", (kCellWidth - 1) * 0.5f, (kCellHeight - 1) * 0.5f);
                if (verb) {
                    pathStr.append(verb);
                }
 
                SkPath path;
                SkParsePath::FromSVGString(pathStr.c_str(), &path);
 
                surface->getCanvas()->clear(SK_ColorTRANSPARENT);
                surface->getCanvas()->drawPath(path, paint);
 
                // All cases should draw one cap, except for butt capped, and dangling moves
                // (without a verb or close), which shouldn't draw anything.
                int expectedCaps = ((SkPaint::kButt_Cap == cap) || !verb) ? 0 : 1;
 
                draw_path_cell(canvas, surface.get(), expectedCaps);
                canvas->translate(kCellWidth + kCellPad, 0);
            }
            canvas->restore();
            canvas->translate(0, kCellHeight + kCellPad);
        }
    }
 
    return skiagm::DrawResult::kOk;
}

draw_zero_length_capped_paths_dbl_contour()

static skiagm::DrawResult draw_zero_length_capped_paths_dbl_contour ( SkCanvas *  canvas, bool  aa, SkString *  errorMsg  )

static

Definition at line 190 of file path_stroke_with_zero_length.cpp.

                                                                                        {
    auto rContext = canvas->recordingContext();
    auto dContext = GrAsDirectContext(rContext);
 
    if (!dContext && rContext) {
        *errorMsg = "Not supported in DDL mode";
        return skiagm::DrawResult::kSkip;
    }
    canvas->translate(kCellPad, kCellPad);
 
    SkImageInfo info = canvas->imageInfo().makeWH(kCellWidth, kCellHeight);
    auto surface = canvas->makeSurface(info);
    if (!surface) {
        surface = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(kCellWidth, kCellHeight));
    }
 
    SkPaint paint;
    paint.setColor(SK_ColorWHITE);
    paint.setAntiAlias(aa);
    paint.setStyle(SkPaint::kStroke_Style);
 
    for (auto cap : kCaps) {
        for (auto width : kWidths) {
            paint.setStrokeCap(cap);
            paint.setStrokeWidth(width);
            canvas->save();
 
            for (auto firstVerb : kSomeVerbs) {
                for (auto secondVerb : kSomeVerbs) {
                    int expectedCaps = 0;
 
                    SkString pathStr;
                    pathStr.append("M 9.5 9.5 ");
                    if (firstVerb) {
                        pathStr.append(firstVerb);
                        ++expectedCaps;
                    }
                    pathStr.append("M 40.5 9.5 ");
                    if (secondVerb) {
                        pathStr.append(secondVerb);
                        ++expectedCaps;
                    }
 
                    SkPath path;
                    SkParsePath::FromSVGString(pathStr.c_str(), &path);
 
                    surface->getCanvas()->clear(SK_ColorTRANSPARENT);
                    surface->getCanvas()->drawPath(path, paint);
 
                    if (SkPaint::kButt_Cap == cap) {
                        expectedCaps = 0;
                    }
 
                    draw_path_cell(canvas, surface.get(), expectedCaps);
                    canvas->translate(kCellWidth + kCellPad, 0);
                }
            }
            canvas->restore();
            canvas->translate(0, kCellHeight + kCellPad);
        }
    }
 
    return skiagm::DrawResult::kOk;
}

Variable Documentation

kAllVerbs

const char* kAllVerbs[]

static

Initial value:

= {
    nullptr,
    "z ",
    "l 0 0 ",
    "l 0 0 z ",
    "q 0 0 0 0 ",
    "q 0 0 0 0 z ",
    "c 0 0 0 0 0 0 ",
    "c 0 0 0 0 0 0 z ",
    "a 0 0 0 0 0 0 0 ",
    "a 0 0 0 0 0 0 0 z "
}

Definition at line 96 of file path_stroke_with_zero_length.cpp.

kCaps

const SkPaint::Cap kCaps[]

static

Initial value:

= {
    SkPaint::kButt_Cap,
    SkPaint::kRound_Cap,
    SkPaint::kSquare_Cap
}

Definition at line 87 of file path_stroke_with_zero_length.cpp.

kCellHeight

const int kCellHeight = 20

static

Definition at line 120 of file path_stroke_with_zero_length.cpp.

kCellPad

const int kCellPad = 2

static

Definition at line 121 of file path_stroke_with_zero_length.cpp.

kCellWidth

const int kCellWidth = 50

static

Definition at line 119 of file path_stroke_with_zero_length.cpp.

kDblContourNumColums

const int kDblContourNumColums = std::size(kSomeVerbs) * std::size(kSomeVerbs)

static

Definition at line 128 of file path_stroke_with_zero_length.cpp.

kDblContourTotalWidth

const int kDblContourTotalWidth = kDblContourNumColums * (kCellWidth + kCellPad) + kCellPad

static

Definition at line 129 of file path_stroke_with_zero_length.cpp.

kNumColumns

const int kNumColumns = std::size(kAllVerbs)

static

Definition at line 124 of file path_stroke_with_zero_length.cpp.

kNumRows

const int kNumRows = std::size(kCaps) * std::size(kWidths)

static

Definition at line 123 of file path_stroke_with_zero_length.cpp.

kSomeVerbs

const char* kSomeVerbs[]

static

Initial value:

= {
    nullptr,
    "z ",
    "l 0 0 ",
    "l 0 0 z ",
    "q 0 0 0 0 ",
    "q 0 0 0 0 z ",
}

Definition at line 110 of file path_stroke_with_zero_length.cpp.

kTotalHeight

const int kTotalHeight = kNumRows * (kCellHeight + kCellPad) + kCellPad

static

Definition at line 126 of file path_stroke_with_zero_length.cpp.

kTotalWidth

const int kTotalWidth = kNumColumns * (kCellWidth + kCellPad) + kCellPad

static

Definition at line 125 of file path_stroke_with_zero_length.cpp.

kWidths

const SkScalar kWidths[] = { 0.0f, 0.9f, 1.0f, 1.1f, 15.0f, 25.0f }

static

Definition at line 93 of file path_stroke_with_zero_length.cpp.