1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program Tester Core 3 * ---------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Fuzzy image comparison. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "tcuFuzzyImageCompare.hpp" 25 #include "tcuTexture.hpp" 26 #include "tcuTextureUtil.hpp" 27 #include "deMath.h" 28 #include "deRandom.hpp" 29 30 #include <vector> 31 32 namespace tcu 33 { 34 35 enum 36 { 37 MIN_ERR_THRESHOLD = 4 // Magic to make small differences go away 38 }; 39 40 using std::vector; 41 42 template<int Channel> 43 static inline deUint8 getChannel (deUint32 color) 44 { 45 return (deUint8)((color >> (Channel*8)) & 0xff); 46 } 47 48 static inline deUint8 getChannel (deUint32 color, int channel) 49 { 50 return (deUint8)((color >> (channel*8)) & 0xff); 51 } 52 53 static inline deUint32 setChannel (deUint32 color, int channel, deUint8 val) 54 { 55 return (color & ~(0xffu << (8*channel))) | (val << (8*channel)); 56 } 57 58 static inline Vec4 toFloatVec (deUint32 color) 59 { 60 return Vec4((float)getChannel<0>(color), (float)getChannel<1>(color), (float)getChannel<2>(color), (float)getChannel<3>(color)); 61 } 62 63 static inline deUint8 roundToUint8Sat (float v) 64 { 65 return (deUint8)de::clamp((int)(v + 0.5f), 0, 255); 66 } 67 68 static inline deUint32 toColor (Vec4 v) 69 { 70 return roundToUint8Sat(v[0]) | (roundToUint8Sat(v[1]) << 8) | (roundToUint8Sat(v[2]) << 16) | (roundToUint8Sat(v[3]) << 24); 71 } 72 73 template<int NumChannels> 74 static inline deUint32 readUnorm8 (const tcu::ConstPixelBufferAccess& src, int x, int y) 75 { 76 const deUint8* ptr = (const deUint8*)src.getDataPtr() + src.getRowPitch()*y + x*NumChannels; 77 deUint32 v = 0; 78 79 for (int c = 0; c < NumChannels; c++) 80 v |= ptr[c] << (c*8); 81 82 if (NumChannels < 4) 83 v |= 0xffu << 24; 84 85 return v; 86 } 87 88 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 89 template<> 90 inline deUint32 readUnorm8<4> (const tcu::ConstPixelBufferAccess& src, int x, int y) 91 { 92 return *(const deUint32*)((const deUint8*)src.getDataPtr() + src.getRowPitch()*y + x*4); 93 } 94 #endif 95 96 template<int NumChannels> 97 static inline void writeUnorm8 (const tcu::PixelBufferAccess& dst, int x, int y, deUint32 val) 98 { 99 deUint8* ptr = (deUint8*)dst.getDataPtr() + dst.getRowPitch()*y + x*NumChannels; 100 101 for (int c = 0; c < NumChannels; c++) 102 ptr[c] = getChannel(val, c); 103 } 104 105 #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) 106 template<> 107 inline void writeUnorm8<4> (const tcu::PixelBufferAccess& dst, int x, int y, deUint32 val) 108 { 109 *(deUint32*)((deUint8*)dst.getDataPtr() + dst.getRowPitch()*y + x*4) = val; 110 } 111 #endif 112 113 static inline deUint32 colorDistSquared (deUint32 pa, deUint32 pb) 114 { 115 const int r = de::max<int>(de::abs((int)getChannel<0>(pa) - (int)getChannel<0>(pb)) - MIN_ERR_THRESHOLD, 0); 116 const int g = de::max<int>(de::abs((int)getChannel<1>(pa) - (int)getChannel<1>(pb)) - MIN_ERR_THRESHOLD, 0); 117 const int b = de::max<int>(de::abs((int)getChannel<2>(pa) - (int)getChannel<2>(pb)) - MIN_ERR_THRESHOLD, 0); 118 const int a = de::max<int>(de::abs((int)getChannel<3>(pa) - (int)getChannel<3>(pb)) - MIN_ERR_THRESHOLD, 0); 119 120 return deUint32(r*r + g*g + b*b + a*a); 121 } 122 123 template<int NumChannels> 124 inline deUint32 bilinearSample (const ConstPixelBufferAccess& src, float u, float v) 125 { 126 int w = src.getWidth(); 127 int h = src.getHeight(); 128 129 int x0 = deFloorFloatToInt32(u-0.5f); 130 int x1 = x0+1; 131 int y0 = deFloorFloatToInt32(v-0.5f); 132 int y1 = y0+1; 133 134 int i0 = de::clamp(x0, 0, w-1); 135 int i1 = de::clamp(x1, 0, w-1); 136 int j0 = de::clamp(y0, 0, h-1); 137 int j1 = de::clamp(y1, 0, h-1); 138 139 float a = deFloatFrac(u-0.5f); 140 float b = deFloatFrac(v-0.5f); 141 142 deUint32 p00 = readUnorm8<NumChannels>(src, i0, j0); 143 deUint32 p10 = readUnorm8<NumChannels>(src, i1, j0); 144 deUint32 p01 = readUnorm8<NumChannels>(src, i0, j1); 145 deUint32 p11 = readUnorm8<NumChannels>(src, i1, j1); 146 deUint32 dst = 0; 147 148 // Interpolate. 149 for (int c = 0; c < NumChannels; c++) 150 { 151 float f = (getChannel(p00, c)*(1.0f-a)*(1.0f-b)) + 152 (getChannel(p10, c)*( a)*(1.0f-b)) + 153 (getChannel(p01, c)*(1.0f-a)*( b)) + 154 (getChannel(p11, c)*( a)*( b)); 155 dst = setChannel(dst, c, roundToUint8Sat(f)); 156 } 157 158 return dst; 159 } 160 161 template<int DstChannels, int SrcChannels> 162 static void separableConvolve (const PixelBufferAccess& dst, const ConstPixelBufferAccess& src, int shiftX, int shiftY, const std::vector<float>& kernelX, const std::vector<float>& kernelY) 163 { 164 DE_ASSERT(dst.getWidth() == src.getWidth() && dst.getHeight() == src.getHeight()); 165 166 TextureLevel tmp (dst.getFormat(), dst.getHeight(), dst.getWidth()); 167 PixelBufferAccess tmpAccess = tmp.getAccess(); 168 169 int kw = (int)kernelX.size(); 170 int kh = (int)kernelY.size(); 171 172 // Horizontal pass 173 // \note Temporary surface is written in column-wise order 174 for (int j = 0; j < src.getHeight(); j++) 175 { 176 for (int i = 0; i < src.getWidth(); i++) 177 { 178 Vec4 sum(0); 179 180 for (int kx = 0; kx < kw; kx++) 181 { 182 float f = kernelX[kw-kx-1]; 183 deUint32 p = readUnorm8<SrcChannels>(src, de::clamp(i+kx-shiftX, 0, src.getWidth()-1), j); 184 185 sum += toFloatVec(p)*f; 186 } 187 188 writeUnorm8<DstChannels>(tmpAccess, j, i, toColor(sum)); 189 } 190 } 191 192 // Vertical pass 193 for (int j = 0; j < src.getHeight(); j++) 194 { 195 for (int i = 0; i < src.getWidth(); i++) 196 { 197 Vec4 sum(0.0f); 198 199 for (int ky = 0; ky < kh; ky++) 200 { 201 float f = kernelY[kh-ky-1]; 202 deUint32 p = readUnorm8<DstChannels>(tmpAccess, de::clamp(j+ky-shiftY, 0, tmp.getWidth()-1), i); 203 204 sum += toFloatVec(p)*f; 205 } 206 207 writeUnorm8<DstChannels>(dst, i, j, toColor(sum)); 208 } 209 } 210 } 211 212 template<int NumChannels> 213 static deUint32 distSquaredToNeighbor (de::Random& rnd, deUint32 pixel, const ConstPixelBufferAccess& surface, int x, int y) 214 { 215 // (x, y) + (0, 0) 216 deUint32 minDist = colorDistSquared(pixel, readUnorm8<NumChannels>(surface, x, y)); 217 218 if (minDist == 0) 219 return minDist; 220 221 // Area around (x, y) 222 static const int s_coords[][2] = 223 { 224 {-1, -1}, 225 { 0, -1}, 226 {+1, -1}, 227 {-1, 0}, 228 {+1, 0}, 229 {-1, +1}, 230 { 0, +1}, 231 {+1, +1} 232 }; 233 234 for (int d = 0; d < (int)DE_LENGTH_OF_ARRAY(s_coords); d++) 235 { 236 int dx = x + s_coords[d][0]; 237 int dy = y + s_coords[d][1]; 238 239 if (!deInBounds32(dx, 0, surface.getWidth()) || !deInBounds32(dy, 0, surface.getHeight())) 240 continue; 241 242 minDist = de::min(minDist, colorDistSquared(pixel, readUnorm8<NumChannels>(surface, dx, dy))); 243 if (minDist == 0) 244 return minDist; 245 } 246 247 // Random bilinear-interpolated samples around (x, y) 248 for (int s = 0; s < 32; s++) 249 { 250 float dx = (float)x + rnd.getFloat()*2.0f - 0.5f; 251 float dy = (float)y + rnd.getFloat()*2.0f - 0.5f; 252 253 deUint32 sample = bilinearSample<NumChannels>(surface, dx, dy); 254 255 minDist = de::min(minDist, colorDistSquared(pixel, sample)); 256 if (minDist == 0) 257 return minDist; 258 } 259 260 return minDist; 261 } 262 263 static inline float toGrayscale (const Vec4& c) 264 { 265 return 0.2126f*c[0] + 0.7152f*c[1] + 0.0722f*c[2]; 266 } 267 268 static bool isFormatSupported (const TextureFormat& format) 269 { 270 return format.type == TextureFormat::UNORM_INT8 && (format.order == TextureFormat::RGB || format.order == TextureFormat::RGBA); 271 } 272 273 float fuzzyCompare (const FuzzyCompareParams& params, const ConstPixelBufferAccess& ref, const ConstPixelBufferAccess& cmp, const PixelBufferAccess& errorMask) 274 { 275 DE_ASSERT(ref.getWidth() == cmp.getWidth() && ref.getHeight() == cmp.getHeight()); 276 DE_ASSERT(errorMask.getWidth() == ref.getWidth() && errorMask.getHeight() == ref.getHeight()); 277 278 if (!isFormatSupported(ref.getFormat()) || !isFormatSupported(cmp.getFormat())) 279 throw InternalError("Unsupported format in fuzzy comparison", DE_NULL, __FILE__, __LINE__); 280 281 int width = ref.getWidth(); 282 int height = ref.getHeight(); 283 de::Random rnd (667); 284 285 // Filtered 286 TextureLevel refFiltered(TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), width, height); 287 TextureLevel cmpFiltered(TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), width, height); 288 289 // Kernel = {0.1, 0.8, 0.1} 290 vector<float> kernel(3); 291 kernel[0] = kernel[2] = 0.1f; kernel[1]= 0.8f; 292 int shift = (int)(kernel.size() - 1) / 2; 293 294 switch (ref.getFormat().order) 295 { 296 case TextureFormat::RGBA: separableConvolve<4, 4>(refFiltered, ref, shift, shift, kernel, kernel); break; 297 case TextureFormat::RGB: separableConvolve<4, 3>(refFiltered, ref, shift, shift, kernel, kernel); break; 298 default: 299 DE_ASSERT(DE_FALSE); 300 } 301 302 switch (cmp.getFormat().order) 303 { 304 case TextureFormat::RGBA: separableConvolve<4, 4>(cmpFiltered, cmp, shift, shift, kernel, kernel); break; 305 case TextureFormat::RGB: separableConvolve<4, 3>(cmpFiltered, cmp, shift, shift, kernel, kernel); break; 306 default: 307 DE_ASSERT(DE_FALSE); 308 } 309 310 int numSamples = 0; 311 deUint64 distSum4 = 0ull; 312 313 // Clear error mask to green. 314 clear(errorMask, Vec4(0.0f, 1.0f, 0.0f, 1.0f)); 315 316 ConstPixelBufferAccess refAccess = refFiltered.getAccess(); 317 ConstPixelBufferAccess cmpAccess = cmpFiltered.getAccess(); 318 319 for (int y = 1; y < height-1; y++) 320 { 321 for (int x = 1; x < width-1; x += params.maxSampleSkip > 0 ? (int)rnd.getInt(0, params.maxSampleSkip) : 1) 322 { 323 const deUint32 minDist2RefToCmp = distSquaredToNeighbor<4>(rnd, readUnorm8<4>(refAccess, x, y), cmpAccess, x, y); 324 const deUint32 minDist2CmpToRef = distSquaredToNeighbor<4>(rnd, readUnorm8<4>(cmpAccess, x, y), refAccess, x, y); 325 const deUint32 minDist2 = de::min(minDist2RefToCmp, minDist2CmpToRef); 326 const deUint64 newSum4 = distSum4 + minDist2*minDist2; 327 328 distSum4 = (newSum4 >= distSum4) ? newSum4 : ~0ull; // In case of overflow 329 numSamples += 1; 330 331 // Build error image. 332 { 333 const int scale = 255-MIN_ERR_THRESHOLD; 334 const float err2 = float(minDist2) / float(scale*scale); 335 const float err4 = err2*err2; 336 const float red = err4 * 500.0f; 337 const float luma = toGrayscale(cmp.getPixel(x, y)); 338 const float rF = 0.7f + 0.3f*luma; 339 340 errorMask.setPixel(Vec4(red*rF, (1.0f-red)*rF, 0.0f, 1.0f), x, y); 341 } 342 } 343 } 344 345 { 346 // Scale error sum based on number of samples taken 347 const double pSamples = double((width-2) * (height-2)) / double(numSamples); 348 const deUint64 colScale = deUint64(255-MIN_ERR_THRESHOLD); 349 const deUint64 colScale4 = colScale*colScale*colScale*colScale; 350 351 return float(double(distSum4) / double(colScale4) * pSamples); 352 } 353 } 354 355 } // tcu 356
