skdiff.cpp File Reference

#include "include/core/SkBitmap.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkTypes.h"
#include "tools/skdiff/skdiff.h"

Go to the source code of this file.

Functions
static bool	colors_match_thresholded (SkPMColor c0, SkPMColor c1, const int threshold)
void	compute_diff (DiffRecord *dr, DiffMetricProc diffFunction, const int colorThreshold)

Variables
static char const *const	ResultDescriptions [DiffRecord::kResultCount]
static char const *const	StatusDescriptions [DiffResource::kStatusCount]
const SkPMColor	PMCOLOR_WHITE = SkPreMultiplyColor(SK_ColorWHITE)
const SkPMColor	PMCOLOR_BLACK = SkPreMultiplyColor(SK_ColorBLACK)

Function Documentation

colors_match_thresholded()

static bool colors_match_thresholded ( SkPMColor  c0, SkPMColor  c1, const int  threshold  )

inlinestatic

Definition at line 143 of file skdiff.cpp.

                                                                                             {
    int da = SkGetPackedA32(c0) - SkGetPackedA32(c1);
    int dr = SkGetPackedR32(c0) - SkGetPackedR32(c1);
    int dg = SkGetPackedG32(c0) - SkGetPackedG32(c1);
    int db = SkGetPackedB32(c0) - SkGetPackedB32(c1);
 
    return ((SkAbs32(da) <= threshold) &&
            (SkAbs32(dr) <= threshold) &&
            (SkAbs32(dg) <= threshold) &&
            (SkAbs32(db) <= threshold));
}

compute_diff()

void compute_diff	(	DiffRecord *	dr,
		DiffMetricProc	diffFunction,
		const int	colorThreshold
	)

When finished, dr->fResult should have some value other than kUnknown_Result. Expects dr->fWhite.fBitmap and dr->fDifference.fBitmap to have the same bounds as dr->fBase.fBitmap and have a valid pixelref.

Definition at line 158 of file skdiff.cpp.

                                                                                         {
    const int w = dr->fComparison.fBitmap.width();
    const int h = dr->fComparison.fBitmap.height();
    if (w != dr->fBase.fBitmap.width() || h != dr->fBase.fBitmap.height()) {
        dr->fResult = DiffRecord::kDifferentSizes_Result;
        return;
    }
 
    int mismatchedPixels = 0;
    int totalMismatchA = 0;
    int totalMismatchR = 0;
    int totalMismatchG = 0;
    int totalMismatchB = 0;
 
    // Accumulate fractionally different pixels, then divide out
    // # of pixels at the end.
    dr->fWeightedFraction = 0;
    for (int y = 0; y < h; y++) {
        for (int x = 0; x < w; x++) {
            SkPMColor c0 = *dr->fBase.fBitmap.getAddr32(x, y);
            SkPMColor c1 = *dr->fComparison.fBitmap.getAddr32(x, y);
            SkPMColor outputDifference = diffFunction(c0, c1);
            uint32_t thisA = SkAbs32(SkGetPackedA32(c0) - SkGetPackedA32(c1));
            uint32_t thisR = SkAbs32(SkGetPackedR32(c0) - SkGetPackedR32(c1));
            uint32_t thisG = SkAbs32(SkGetPackedG32(c0) - SkGetPackedG32(c1));
            uint32_t thisB = SkAbs32(SkGetPackedB32(c0) - SkGetPackedB32(c1));
            totalMismatchA += thisA;
            totalMismatchR += thisR;
            totalMismatchG += thisG;
            totalMismatchB += thisB;
            // In HSV, value is defined as max RGB component.
            int value = MAX3(thisR, thisG, thisB);
            dr->fWeightedFraction += ((float) value) / 255;
            if (thisA > dr->fMaxMismatchA) {
                dr->fMaxMismatchA = thisA;
            }
            if (thisR > dr->fMaxMismatchR) {
                dr->fMaxMismatchR = thisR;
            }
            if (thisG > dr->fMaxMismatchG) {
                dr->fMaxMismatchG = thisG;
            }
            if (thisB > dr->fMaxMismatchB) {
                dr->fMaxMismatchB = thisB;
            }
            if (!colors_match_thresholded(c0, c1, colorThreshold)) {
                mismatchedPixels++;
                *dr->fDifference.fBitmap.getAddr32(x, y) = outputDifference;
                *dr->fWhite.fBitmap.getAddr32(x, y) = PMCOLOR_WHITE;
            } else {
                *dr->fDifference.fBitmap.getAddr32(x, y) = 0;
                *dr->fWhite.fBitmap.getAddr32(x, y) = PMCOLOR_BLACK;
            }
        }
    }
    if (0 == mismatchedPixels) {
        dr->fResult = DiffRecord::kEqualPixels_Result;
        return;
    }
    dr->fResult = DiffRecord::kDifferentPixels_Result;
    int pixelCount = w * h;
    dr->fFractionDifference = ((float) mismatchedPixels) / pixelCount;
    dr->fWeightedFraction /= pixelCount;
    dr->fTotalMismatchA = totalMismatchA;
    dr->fAverageMismatchA = ((float) totalMismatchA) / pixelCount;
    dr->fAverageMismatchR = ((float) totalMismatchR) / pixelCount;
    dr->fAverageMismatchG = ((float) totalMismatchG) / pixelCount;
    dr->fAverageMismatchB = ((float) totalMismatchB) / pixelCount;
}

Variable Documentation

PMCOLOR_BLACK

const SkPMColor PMCOLOR_BLACK = SkPreMultiplyColor(SK_ColorBLACK)

Definition at line 156 of file skdiff.cpp.

PMCOLOR_WHITE

const SkPMColor PMCOLOR_WHITE = SkPreMultiplyColor(SK_ColorWHITE)

Definition at line 155 of file skdiff.cpp.

ResultDescriptions

char const* const ResultDescriptions[DiffRecord::kResultCount]

static

Initial value:

= {
    "contain exactly the same bits",
    "contain the same pixel values, but not the same bits",
    "have identical dimensions but some differing pixels",
    "have differing dimensions",
    "could not be compared",
    "not compared yet",
}

Definition at line 32 of file skdiff.cpp.

                                                                       {
    "contain exactly the same bits",
    "contain the same pixel values, but not the same bits",
    "have identical dimensions but some differing pixels",
    "have differing dimensions",
    "could not be compared",
    "not compared yet",
};

StatusDescriptions

char const* const StatusDescriptions[DiffResource::kStatusCount]

static

Initial value:

= {
    "decoded",
    "could not be decoded",
 
    "read",
    "could not be read",
 
    "found",
    "not found",
 
    "specified",
    "unspecified",
 
    "unknown",
}

Definition at line 70 of file skdiff.cpp.

                                                                         {
    "decoded",
    "could not be decoded",
 
    "read",
    "could not be read",
 
    "found",
    "not found",
 
    "specified",
    "unspecified",
 
    "unknown",
};