| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES Utilities |
| * ------------------------------------------------ |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| 'use strict'; |
| goog.provide('framework.common.tcuFuzzyImageCompare'); |
| goog.require('framework.common.tcuTexture'); |
| goog.require('framework.common.tcuTextureUtil'); |
| goog.require('framework.delibs.debase.deMath'); |
| goog.require('framework.delibs.debase.deRandom'); |
| |
| goog.scope(function() { |
| |
| var tcuFuzzyImageCompare = framework.common.tcuFuzzyImageCompare; |
| var deMath = framework.delibs.debase.deMath; |
| var deRandom = framework.delibs.debase.deRandom; |
| var tcuTexture = framework.common.tcuTexture; |
| var tcuTextureUtil = framework.common.tcuTextureUtil; |
| |
| var DE_ASSERT = function(x) { |
| if (!x) |
| throw new Error('Assert failed'); |
| }; |
| |
| /** |
| * tcuFuzzyImageCompare.FuzzyCompareParams struct |
| * @constructor |
| * @param {number=} maxSampleSkip_ |
| * @param {number=} minErrThreshold_ |
| * @param {number=} errExp_ |
| */ |
| tcuFuzzyImageCompare.FuzzyCompareParams = function(maxSampleSkip_, minErrThreshold_, errExp_) { |
| /** @type {number} */ this.maxSampleSkip = maxSampleSkip_ === undefined ? 8 : maxSampleSkip_; |
| /** @type {number} */ this.minErrThreshold = minErrThreshold_ === undefined ? 4 : minErrThreshold_; |
| /** @type {number} */ this.errExp = errExp_ === undefined ? 4.0 : errExp_; |
| }; |
| |
| /** |
| * @param {Array<number>} v |
| * @return {Array<number>} |
| */ |
| tcuFuzzyImageCompare.roundArray4ToUint8Sat = function(v) { |
| return [ |
| deMath.clamp(Math.trunc(v[0] + 0.5), 0, 255), |
| deMath.clamp(Math.trunc(v[1] + 0.5), 0, 255), |
| deMath.clamp(Math.trunc(v[2] + 0.5), 0, 255), |
| deMath.clamp(Math.trunc(v[3] + 0.5), 0, 255) |
| ]; |
| }; |
| |
| /** |
| * @param {Array<number>} pa |
| * @param {Array<number>} pb |
| * @param {number} minErrThreshold |
| * @return {number} |
| */ |
| tcuFuzzyImageCompare.compareColors = function(pa, pb, minErrThreshold) { |
| /** @type {number}*/ var r = Math.max(Math.abs(pa[0] - pb[0]) - minErrThreshold, 0); |
| /** @type {number}*/ var g = Math.max(Math.abs(pa[1] - pb[1]) - minErrThreshold, 0); |
| /** @type {number}*/ var b = Math.max(Math.abs(pa[2] - pb[2]) - minErrThreshold, 0); |
| /** @type {number}*/ var a = Math.max(Math.abs(pa[3] - pb[3]) - minErrThreshold, 0); |
| |
| /** @type {number}*/ var scale = 1.0 / (255 - minErrThreshold); |
| /** @type {number}*/ var sqSum = (r * r + g * g + b * b + a * a) * (scale * scale); |
| |
| return Math.sqrt(sqSum); |
| }; |
| |
| /** |
| * @param {tcuTexture.RGBA8View} src |
| * @param {number} u |
| * @param {number} v |
| * @param {number} NumChannels |
| * @return {Array<number>} |
| */ |
| tcuFuzzyImageCompare.bilinearSample = function(src, u, v, NumChannels) { |
| /** @type {number}*/ var w = src.width; |
| /** @type {number}*/ var h = src.height; |
| |
| /** @type {number}*/ var x0 = Math.floor(u - 0.5); |
| /** @type {number}*/ var x1 = x0 + 1; |
| /** @type {number}*/ var y0 = Math.floor(v - 0.5); |
| /** @type {number}*/ var y1 = y0 + 1; |
| |
| /** @type {number}*/ var i0 = deMath.clamp(x0, 0, w - 1); |
| /** @type {number}*/ var i1 = deMath.clamp(x1, 0, w - 1); |
| /** @type {number}*/ var j0 = deMath.clamp(y0, 0, h - 1); |
| /** @type {number}*/ var j1 = deMath.clamp(y1, 0, h - 1); |
| |
| /** @type {number}*/ var a = (u - 0.5) - Math.floor(u - 0.5); |
| /** @type {number}*/ var b = (v - 0.5) - Math.floor(v - 0.5); |
| |
| /** @type {Array<number>} */ var p00 = src.read(i0, j0, NumChannels); |
| /** @type {Array<number>} */ var p10 = src.read(i1, j0, NumChannels); |
| /** @type {Array<number>} */ var p01 = src.read(i0, j1, NumChannels); |
| /** @type {Array<number>} */ var p11 = src.read(i1, j1, NumChannels); |
| /** @type {number} */ var dst = 0; |
| |
| // Interpolate. |
| /** @type {Array<number>}*/ var f = []; |
| for (var c = 0; c < NumChannels; c++) { |
| f[c] = p00[c] * (1.0 - a) * (1.0 - b) + |
| (p10[c] * a * (1.0 - b)) + |
| (p01[c] * (1.0 - a) * b) + |
| (p11[c] * a * b); |
| } |
| |
| return tcuFuzzyImageCompare.roundArray4ToUint8Sat(f); |
| }; |
| |
| /** |
| * @param {tcuTexture.RGBA8View} dst |
| * @param {tcuTexture.RGBA8View} src |
| * @param {number} shiftX |
| * @param {number} shiftY |
| * @param {Array<number>} kernelX |
| * @param {Array<number>} kernelY |
| * @param {number} DstChannels |
| * @param {number} SrcChannels |
| */ |
| tcuFuzzyImageCompare.separableConvolve = function(dst, src, shiftX, shiftY, kernelX, kernelY, DstChannels, SrcChannels) { |
| DE_ASSERT(dst.width == src.width && dst.height == src.height); |
| |
| /** @type {tcuTexture.TextureLevel} */ var tmp = new tcuTexture.TextureLevel(dst.getFormat(), dst.height, dst.width); |
| var tmpView = new tcuTexture.RGBA8View(tmp.getAccess()); |
| |
| /** @type {number} */ var kw = kernelX.length; |
| /** @type {number} */ var kh = kernelY.length; |
| |
| /** @type {Array<number>} */ var sum = []; |
| /** @type {number} */ var f; |
| /** @type {Array<number>} */ var p; |
| |
| // Horizontal pass |
| // \note Temporary surface is written in column-wise order |
| for (var j = 0; j < src.height; j++) { |
| for (var i = 0; i < src.width; i++) { |
| sum[0] = sum[1] = sum[2] = sum[3] = 0; |
| for (var kx = 0; kx < kw; kx++) { |
| f = kernelX[kw - kx - 1]; |
| p = src.read(deMath.clamp(i + kx - shiftX, 0, src.width - 1), j, SrcChannels); |
| sum = deMath.add(sum, deMath.scale(p, f)); |
| } |
| |
| sum = tcuFuzzyImageCompare.roundArray4ToUint8Sat(sum); |
| tmpView.write(j, i, sum, DstChannels); |
| } |
| } |
| |
| // Vertical pass |
| for (var j = 0; j < src.height; j++) { |
| for (var i = 0; i < src.width; i++) { |
| sum[0] = sum[1] = sum[2] = sum[3] = 0; |
| for (var ky = 0; ky < kh; ky++) { |
| f = kernelY[kh - ky - 1]; |
| p = tmpView.read(deMath.clamp(j + ky - shiftY, 0, tmpView.width - 1), i, DstChannels); |
| sum = deMath.add(sum, deMath.scale(p, f)); |
| } |
| |
| sum = tcuFuzzyImageCompare.roundArray4ToUint8Sat(sum); |
| dst.write(i, j, sum, DstChannels); |
| } |
| } |
| }; |
| |
| /** |
| * @param {tcuFuzzyImageCompare.FuzzyCompareParams} params |
| * @param {deRandom.Random} rnd |
| * @param {Array<number>} pixel |
| * @param {tcuTexture.RGBA8View} surface |
| * @param {number} x |
| * @param {number} y |
| * @param {number} NumChannels |
| * @return {number} |
| */ |
| tcuFuzzyImageCompare.compareToNeighbor = function(params, rnd, pixel, surface, x, y, NumChannels) { |
| /** @type {number} */ var minErr = 100; |
| |
| // (x, y) + (0, 0) |
| minErr = Math.min(minErr, tcuFuzzyImageCompare.compareColors(pixel, surface.read(x, y, NumChannels), params.minErrThreshold)); |
| if (minErr == 0.0) |
| return minErr; |
| |
| // Area around (x, y) |
| /** @type {Array<Array.<number>>} */ var s_coords = |
| [ |
| [-1, -1], |
| [0, -1], |
| [1, -1], |
| [-1, 0], |
| [1, 0], |
| [-1, 1], |
| [0, 1], |
| [1, 1] |
| ]; |
| |
| /** @type {number} */ var dx; |
| /** @type {number} */ var dy; |
| |
| for (var d = 0; d < s_coords.length; d++) { |
| dx = x + s_coords[d][0]; |
| dy = y + s_coords[d][1]; |
| |
| if (!deMath.deInBounds32(dx, 0, surface.width) || !deMath.deInBounds32(dy, 0, surface.height)) |
| continue; |
| |
| minErr = Math.min(minErr, tcuFuzzyImageCompare.compareColors(pixel, surface.read(dx, dy, NumChannels), params.minErrThreshold)); |
| if (minErr == 0.0) |
| return minErr; |
| } |
| |
| // Random bilinear-interpolated samples around (x, y) |
| for (var s = 0; s < 32; s++) { |
| dx = x + rnd.getFloat() * 2.0 - 0.5; |
| dy = y + rnd.getFloat() * 2.0 - 0.5; |
| |
| /** @type {Array<number>} */ var sample = tcuFuzzyImageCompare.bilinearSample(surface, dx, dy, NumChannels); |
| |
| minErr = Math.min(minErr, tcuFuzzyImageCompare.compareColors(pixel, sample, params.minErrThreshold)); |
| if (minErr == 0.0) |
| return minErr; |
| } |
| |
| return minErr; |
| }; |
| |
| /** |
| * @param {Array<number>} c |
| * @return {number} |
| */ |
| tcuFuzzyImageCompare.toGrayscale = function(c) { |
| return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]; |
| }; |
| |
| /** |
| * @param {tcuTexture.TextureFormat} format |
| * @return {boolean} |
| */ |
| tcuFuzzyImageCompare.isFormatSupported = function(format) { |
| return format.type == tcuTexture.ChannelType.UNORM_INT8 && (format.order == tcuTexture.ChannelOrder.RGB || format.order == tcuTexture.ChannelOrder.RGBA); |
| }; |
| |
| /** |
| * @param {tcuFuzzyImageCompare.FuzzyCompareParams} params |
| * @param {tcuTexture.ConstPixelBufferAccess} ref |
| * @param {tcuTexture.ConstPixelBufferAccess} cmp |
| * @param {tcuTexture.PixelBufferAccess} errorMask |
| * @return {number} |
| */ |
| tcuFuzzyImageCompare.fuzzyCompare = function(params, ref, cmp, errorMask) { |
| assertMsgOptions(ref.getWidth() == cmp.getWidth() && ref.getHeight() == cmp.getHeight(), |
| 'Reference and result images have different dimensions', false, true); |
| |
| assertMsgOptions(ref.getWidth() == errorMask.getWidth() && ref.getHeight() == errorMask.getHeight(), |
| 'Reference and error mask images have different dimensions', false, true); |
| |
| if (!tcuFuzzyImageCompare.isFormatSupported(ref.getFormat()) || !tcuFuzzyImageCompare.isFormatSupported(cmp.getFormat())) |
| throw new Error('Unsupported format in fuzzy comparison'); |
| |
| /** @type {number} */ var width = ref.getWidth(); |
| /** @type {number} */ var height = ref.getHeight(); |
| /** @type {deRandom.Random} */ var rnd = new deRandom.Random(667); |
| |
| // Filtered |
| /** @type {tcuTexture.TextureLevel} */ var refFiltered = new tcuTexture.TextureLevel(new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGBA, tcuTexture.ChannelType.UNORM_INT8), width, height); |
| /** @type {tcuTexture.TextureLevel} */ var cmpFiltered = new tcuTexture.TextureLevel(new tcuTexture.TextureFormat(tcuTexture.ChannelOrder.RGBA, tcuTexture.ChannelType.UNORM_INT8), width, height); |
| |
| var refView = new tcuTexture.RGBA8View(ref); |
| var cmpView = new tcuTexture.RGBA8View(cmp); |
| var refFilteredView = new tcuTexture.RGBA8View(tcuTexture.PixelBufferAccess.newFromTextureLevel(refFiltered)); |
| var cmpFilteredView = new tcuTexture.RGBA8View(tcuTexture.PixelBufferAccess.newFromTextureLevel(cmpFiltered)); |
| |
| // Kernel = {0.15, 0.7, 0.15} |
| /** @type {Array<number>} */ var kernel = [0.1, 0.8, 0.1]; |
| /** @type {number} */ var shift = Math.floor((kernel.length - 1) / 2); |
| |
| switch (ref.getFormat().order) { |
| case tcuTexture.ChannelOrder.RGBA: tcuFuzzyImageCompare.separableConvolve(refFilteredView, refView, shift, shift, kernel, kernel, 4, 4); break; |
| case tcuTexture.ChannelOrder.RGB: tcuFuzzyImageCompare.separableConvolve(refFilteredView, refView, shift, shift, kernel, kernel, 4, 3); break; |
| default: |
| throw new Error('tcuFuzzyImageCompare.fuzzyCompare - Invalid ChannelOrder'); |
| } |
| |
| switch (cmp.getFormat().order) { |
| case tcuTexture.ChannelOrder.RGBA: tcuFuzzyImageCompare.separableConvolve(cmpFilteredView, cmpView, shift, shift, kernel, kernel, 4, 4); break; |
| case tcuTexture.ChannelOrder.RGB: tcuFuzzyImageCompare.separableConvolve(cmpFilteredView, cmpView, shift, shift, kernel, kernel, 4, 3); break; |
| default: |
| throw new Error('tcuFuzzyImageCompare.fuzzyCompare - Invalid ChannelOrder'); |
| } |
| |
| /** @type {number} */ var numSamples = 0; |
| /** @type {number} */ var errSum = 0.0; |
| |
| // Clear error mask to green. |
| errorMask.clear([0.0, 1.0, 0.0, 1.0]); |
| |
| for (var y = 1; y < height - 1; y++) { |
| for (var x = 1; x < width - 1; x += params.maxSampleSkip > 0 ? rnd.getInt(0, params.maxSampleSkip) : 1) { |
| /** @type {number} */ var err = Math.min(tcuFuzzyImageCompare.compareToNeighbor(params, rnd, refFilteredView.read(x, y, 4), cmpFilteredView, x, y, 4), |
| tcuFuzzyImageCompare.compareToNeighbor(params, rnd, cmpFilteredView.read(x, y, 4), refFilteredView, x, y, 4)); |
| |
| err = Math.pow(err, params.errExp); |
| |
| errSum += err; |
| numSamples += 1; |
| |
| // Build error image. |
| /** @type {number} */ var red = err * 500.0; |
| /** @type {number} */ var luma = tcuFuzzyImageCompare.toGrayscale(cmp.getPixel(x, y)); |
| /** @type {number} */ var rF = 0.7 + 0.3 * luma; |
| errorMask.setPixel([red * rF, (1.0 - red) * rF, 0.0, 1.0], x, y); |
| |
| } |
| } |
| |
| // Scale error sum based on number of samples taken |
| errSum *= ((width - 2) * (height - 2)) / numSamples; |
| |
| return errSum; |
| }; |
| |
| }); |