skdiff.h File Reference

#include "include/core/SkBitmap.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkString.h"
#include "include/private/base/SkTArray.h"

Go to the source code of this file.

Classes
struct	DiffResource
struct	DiffRecord
class	CompareDiffMetrics
class	CompareDiffWeighted
class	CompareDiffMeanMismatches
class	CompareDiffMaxMismatches

Macros
#define	PATH_DIV_STR   "/"
#define	PATH_DIV_CHAR   '/'
#define	MAX2(a, b)   (((b) < (a)) ? (a) : (b))
#define	MAX3(a, b, c)   (((b) < (a)) ? MAX2((a), (c)) : MAX2((b), (c)))

Typedefs
typedef skia_private::TArray< DiffRecord >	RecordArray
typedef SkPMColor(*	DiffMetricProc) (SkPMColor, SkPMColor)
	Parameterized routine to compute the color of a pixel in a difference image.

Functions
template<typename T >
int	compare (const void *untyped_lhs, const void *untyped_rhs)
static SkPMColor	compute_diff_pmcolor (SkPMColor c0, SkPMColor c1)
void	compute_diff (DiffRecord *dr, DiffMetricProc diffFunction, const int colorThreshold)

Macro Definition Documentation

MAX2

#define MAX2	(		a,
			b
	)		(((b) < (a)) ? (a) : (b))

Definition at line 25 of file skdiff.h.

MAX3

#define MAX3	(		a,
			b,
			c
	)		(((b) < (a)) ? MAX2((a), (c)) : MAX2((b), (c)))

Definition at line 26 of file skdiff.h.

PATH_DIV_CHAR

#define PATH_DIV_CHAR   '/'

Definition at line 22 of file skdiff.h.

PATH_DIV_STR

#define PATH_DIV_STR   "/"

Definition at line 21 of file skdiff.h.

Typedef Documentation

DiffMetricProc

typedef SkPMColor(* DiffMetricProc) (SkPMColor, SkPMColor)

Parameterized routine to compute the color of a pixel in a difference image.

Definition at line 255 of file skdiff.h.

RecordArray

typedef skia_private::TArray<DiffRecord> RecordArray

Definition at line 157 of file skdiff.h.

Function Documentation

compare()

template<typename T >

int compare	(	const void *	untyped_lhs,
		const void *	untyped_rhs
	)

A wrapper for any sortProc (comparison routine) which applies a first-order sort beforehand, and a tiebreaker if the sortProc returns 0.

Definition at line 161 of file skdiff.h.

                                                                                   {
    const DiffRecord* lhs = reinterpret_cast<DiffRecord const *>(untyped_lhs);
    const DiffRecord* rhs = reinterpret_cast<DiffRecord const *>(untyped_rhs);
 
    // First-order sort... these comparisons should be applied before comparing
    // pixel values, no matter what.
    if (lhs->fResult != rhs->fResult) {
        return (lhs->fResult < rhs->fResult) ? 1 : -1;
    }
 
    // Passed first-order sort, so call the pixel comparison routine.
    int result = T::comparePixels(lhs, rhs);
    if (result != 0) {
        return result;
    }
 
    // Tiebreaker... if we got to this point, we don't really care
    // which order they are sorted in, but let's at least be consistent.
    return strcmp(lhs->fBase.fFilename.c_str(), rhs->fBase.fFilename.c_str());
}

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;
}

compute_diff_pmcolor()

static SkPMColor compute_diff_pmcolor ( SkPMColor  c0, SkPMColor  c1  )

inlinestatic

Definition at line 258 of file skdiff.h.

                                                                         {
    int dr = SkGetPackedR32(c0) - SkGetPackedR32(c1);
    int dg = SkGetPackedG32(c0) - SkGetPackedG32(c1);
    int db = SkGetPackedB32(c0) - SkGetPackedB32(c1);
 
    return SkPackARGB32(0xFF, SkAbs32(dr), SkAbs32(dg), SkAbs32(db));
}