skiagm::FontationsFtCompareGM Class Reference

Inheritance diagram for skiagm::FontationsFtCompareGM:

Public Member Functions
	FontationsFtCompareGM (std::string testName, std::string fontNameFilterRegexp, std::string langFilterRegexp)
Public Member Functions inherited from skiagm::GM
	GM (SkColor backgroundColor=SK_ColorWHITE)
virtual	~GM ()
void	setMode (Mode mode)
Mode	getMode () const
DrawResult	gpuSetup (SkCanvas *, SkString *errorMsg, GraphiteTestContext *=nullptr)
void	gpuTeardown ()
void	onceBeforeDraw ()
DrawResult	draw (SkCanvas *canvas)
DrawResult	draw (SkCanvas *, SkString *errorMsg)
void	drawBackground (SkCanvas *)
DrawResult	drawContent (SkCanvas *canvas)
DrawResult	drawContent (SkCanvas *, SkString *errorMsg)
virtual bool	runAsBench () const
SkScalar	width ()
SkScalar	height ()
SkColor	getBGColor () const
void	setBGColor (SkColor)
void	drawSizeBounds (SkCanvas *, SkColor)
bool	animate (double)
virtual bool	onChar (SkUnichar)
bool	getControls (SkMetaData *controls)
void	setControls (const SkMetaData &controls)
virtual void	modifyGrContextOptions (GrContextOptions *)
virtual void	modifyGraphiteContextOptions (skgpu::graphite::ContextOptions *) const
virtual bool	isBazelOnly () const
virtual std::map< std::string, std::string >	getGoldKeys () const

Protected Member Functions
SkString	getName () const override
SkISize	getISize () override
DrawResult	onDraw (SkCanvas *canvas, SkString *errorMsg) override
Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas *, SkString *, GraphiteTestContext *)
virtual void	onGpuTeardown ()
virtual void	onOnceBeforeDraw ()
virtual void	onDraw (SkCanvas *)
virtual bool	onAnimate (double)
virtual bool	onGetControls (SkMetaData *)
virtual void	onSetControls (const SkMetaData &)
GraphiteTestContext *	graphiteTestContext () const

Additional Inherited Members
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }
using	DrawResult = skiagm::DrawResult
using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext
Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Definition at line 70 of file fontations_ft_compare.cpp.

Constructor & Destructor Documentation

FontationsFtCompareGM()

skiagm::FontationsFtCompareGM::FontationsFtCompareGM ( std::string  testName, std::string  fontNameFilterRegexp, std::string  langFilterRegexp  )

inline

Definition at line 72 of file fontations_ft_compare.cpp.

            : fTestDataIterator(fontNameFilterRegexp, langFilterRegexp)
            , fTestName(testName.c_str()) {
        this->setBGColor(SK_ColorWHITE);
    }

Member Function Documentation

getISize()

SkISize skiagm::FontationsFtCompareGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 85 of file fontations_ft_compare.cpp.

                                {
        TestFontDataProvider::TestSet testSet;
        fTestDataIterator.rewind();
        fTestDataIterator.next(&testSet);
 
        return SkISize::Make(kGmWidth,
                             testSet.langSamples.size() * kFontSize * kLangYIncrementScale + 100);
    }

getName()

SkString skiagm::FontationsFtCompareGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 81 of file fontations_ft_compare.cpp.

                                      {
        return SkStringPrintf("fontations_compare_ft_%s", fTestName.c_str());
    }

onDraw()

DrawResult skiagm::FontationsFtCompareGM::onDraw ( SkCanvas *  canvas, SkString *  errorMsg  )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 94 of file fontations_ft_compare.cpp.

                                                                     {
        SkPaint paint;
        paint.setColor(SK_ColorBLACK);
 
        fTestDataIterator.rewind();
        TestFontDataProvider::TestSet testSet;
 
        while (fTestDataIterator.next(&testSet)) {
            sk_sp<SkTypeface> testTypeface = SkTypeface_Make_Fontations(
                    SkStream::MakeFromFile(testSet.fontFilename.c_str()), SkFontArguments());
            sk_sp<SkTypeface> ftTypeface = SkTypeface_FreeType::MakeFromStream(
                    SkStream::MakeFromFile(testSet.fontFilename.c_str()), SkFontArguments());
 
            if (!testTypeface || !ftTypeface) {
                *errorMsg = "Unable to initialize typeface.";
                return DrawResult::kSkip;
            }
 
            auto configureFont = [](SkFont& font) {
                font.setSize(kFontSize);
                font.setEdging(SkFont::Edging::kSubpixelAntiAlias);
                font.setSubpixel(true);
                font.setHinting(SkFontHinting::kNone);
            };
 
            SkFont font(testTypeface);
            configureFont(font);
 
            SkFont ftFont(ftTypeface);
            configureFont(ftFont);
            enum class DrawPhase { Fontations, FreeType, Comparison };
 
            SkRect maxBounds = SkRect::MakeEmpty();
            for (auto phase : {DrawPhase::Fontations, DrawPhase::FreeType, DrawPhase::Comparison}) {
                SkScalar yCoord = kFontSize * 1.5f;
 
                for (auto& langEntry : testSet.langSamples) {
                    auto shapeAndDrawToCanvas = [canvas, paint, langEntry](const SkFont& font,
                                                                           SkPoint coord) {
                        std::string testString(langEntry.sampleShort.c_str(),
                                               langEntry.sampleShort.size());
                        SkTextBlobBuilderRunHandler textBlobBuilder(testString.c_str(), {0, 0});
                        std::unique_ptr<SkShaper> shaper = SkShaper::Make();
                        shaper->shape(testString.c_str(),
                                      testString.size(),
                                      font,
                                      true,
                                      999999, /* Don't linebreak. */
                                      &textBlobBuilder);
                        sk_sp<const SkTextBlob> blob = textBlobBuilder.makeBlob();
                        canvas->drawTextBlob(blob.get(), coord.x(), coord.y(), paint);
                        return blob->bounds();
                    };
 
                    auto roundToDevicePixels = [canvas](SkPoint& point) {
                        SkMatrix ctm = canvas->getLocalToDeviceAs3x3();
                        SkPoint mapped = ctm.mapPoint(point);
                        SkPoint mappedRounded =
                                SkPoint::Make(roundf(mapped.x()), roundf(mapped.y()));
                        SkMatrix inverse;
                        bool inverseExists = ctm.invert(&inverse);
                        SkASSERT(inverseExists);
                        if (inverseExists) {
                            point = inverse.mapPoint(mappedRounded);
                        }
                    };
 
                    auto fontationsCoord = [yCoord, roundToDevicePixels]() {
                        SkPoint fontationsCoord = SkPoint::Make(kMargin, yCoord);
                        roundToDevicePixels(fontationsCoord);
                        return fontationsCoord;
                    };
 
                    auto freetypeCoord = [yCoord, maxBounds, roundToDevicePixels]() {
                        SkPoint freetypeCoord = SkPoint::Make(
                                2 * kMargin + maxBounds.left() + maxBounds.width(), yCoord);
                        roundToDevicePixels(freetypeCoord);
                        return freetypeCoord;
                    };
 
                    switch (phase) {
                        case DrawPhase::Fontations: {
                            SkRect boundsFontations = shapeAndDrawToCanvas(font, fontationsCoord());
                            /* Determine maximum of column width across all language samples. */
                            boundsFontations.roundOut();
                            maxBounds.join(boundsFontations);
                            break;
                        }
                        case DrawPhase::FreeType: {
                            shapeAndDrawToCanvas(ftFont, freetypeCoord());
                            break;
                        }
                        case DrawPhase::Comparison: {
                            /* Read back pixels from equally sized rectangles from the space in
                             * SkCanvas where Fontations and FreeType sample texts were drawn,
                             * compare them using pixel comparisons similar to SkDiff, draw a
                             * comparison as faint pixel differences, and as an amplified
                             * visualization in which each differing pixel is drawn as white. */
                            SkPoint copyBoxFontationsCoord = fontationsCoord();
                            SkPoint copyBoxFreetypeCoord = freetypeCoord();
                            SkRect copyBoxFontations(maxBounds);
                            copyBoxFontations.roundOut(&copyBoxFontations);
                            SkRect copyBoxFreetype(copyBoxFontations);
                            copyBoxFontations.offset(copyBoxFontationsCoord.x(),
                                                     copyBoxFontationsCoord.y());
                            copyBoxFreetype.offset(copyBoxFreetypeCoord.x(),
                                                   copyBoxFreetypeCoord.y());
 
                            SkMatrix ctm = canvas->getLocalToDeviceAs3x3();
                            ctm.mapRect(&copyBoxFontations, copyBoxFontations);
                            ctm.mapRect(&copyBoxFreetype, copyBoxFreetype);
 
                            SkISize pixelDimensions(copyBoxFontations.roundOut().size());
                            SkImageInfo canvasImageInfo = canvas->imageInfo();
                            SkImageInfo copyImageInfo =
                                    SkImageInfo::Make(pixelDimensions,
                                                      canvasImageInfo.colorType(),
                                                      canvasImageInfo.alphaType());
 
                            SkBitmap fontationsBitmap, freetypeBitmap, diffBitmap,
                                    highlightDiffBitmap;
                            fontationsBitmap.allocPixels(copyImageInfo, 0);
                            freetypeBitmap.allocPixels(copyImageInfo, 0);
                            diffBitmap.allocPixels(copyImageInfo, 0);
                            highlightDiffBitmap.allocPixels(copyImageInfo, 0);
 
                            canvas->readPixels(
                                    fontationsBitmap, copyBoxFontations.x(), copyBoxFontations.y());
                            canvas->readPixels(
                                    freetypeBitmap, copyBoxFreetype.x(), copyBoxFreetype.y());
 
                            comparePixels(fontationsBitmap,
                                          freetypeBitmap,
                                          &diffBitmap,
                                          &highlightDiffBitmap);
 
                            /* Place comparison results as two extra columns, shift up to account
                               for placement of rectangles vs. SkTextBlobs (baseline shift). */
                            SkPoint comparisonCoord = ctm.mapPoint(SkPoint::Make(
                                    3 * kMargin + maxBounds.width() * 2, yCoord + maxBounds.top()));
                            SkPoint whiteCoord = ctm.mapPoint(SkPoint::Make(
                                    4 * kMargin + maxBounds.width() * 3, yCoord + maxBounds.top()));
 
                            canvas->writePixels(
                                    diffBitmap, comparisonCoord.x(), comparisonCoord.y());
                            canvas->writePixels(
                                    highlightDiffBitmap, whiteCoord.x(), whiteCoord.y());
                            break;
                        }
                    }
 
                    yCoord += font.getSize() * kLangYIncrementScale;
                }
            }
        }
 
        return DrawResult::kOk;
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/gm/fontations_ft_compare.cpp