| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/test/pixel_comparator.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include "base/logging.h" | |
| 10 #include "ui/gfx/geometry/rect.h" | |
| 11 | |
| 12 namespace cc { | |
| 13 | |
| 14 ExactPixelComparator::ExactPixelComparator(const bool discard_alpha) | |
| 15 : discard_alpha_(discard_alpha) { | |
| 16 } | |
| 17 | |
| 18 bool ExactPixelComparator::Compare(const SkBitmap& actual_bmp, | |
| 19 const SkBitmap& expected_bmp) const { | |
| 20 // Number of pixels with an error | |
| 21 int error_pixels_count = 0; | |
| 22 | |
| 23 gfx::Rect error_bounding_rect = gfx::Rect(); | |
| 24 | |
| 25 // Check that bitmaps have identical dimensions. | |
| 26 DCHECK(actual_bmp.width() == expected_bmp.width() && | |
| 27 actual_bmp.height() == expected_bmp.height()); | |
| 28 | |
| 29 SkAutoLockPixels lock_actual_bmp(actual_bmp); | |
| 30 SkAutoLockPixels lock_expected_bmp(expected_bmp); | |
| 31 | |
| 32 for (int x = 0; x < actual_bmp.width(); ++x) { | |
| 33 for (int y = 0; y < actual_bmp.height(); ++y) { | |
| 34 SkColor actual_color = actual_bmp.getColor(x, y); | |
| 35 SkColor expected_color = expected_bmp.getColor(x, y); | |
| 36 if (discard_alpha_) { | |
| 37 actual_color = SkColorSetA(actual_color, 0); | |
| 38 expected_color = SkColorSetA(expected_color, 0); | |
| 39 } | |
| 40 if (actual_color != expected_color) { | |
| 41 ++error_pixels_count; | |
| 42 error_bounding_rect.Union(gfx::Rect(x, y, 1, 1)); | |
| 43 } | |
| 44 } | |
| 45 } | |
| 46 | |
| 47 if (error_pixels_count != 0) { | |
| 48 LOG(ERROR) << "Number of pixel with an error: " << error_pixels_count; | |
| 49 LOG(ERROR) << "Error Bounding Box : " << error_bounding_rect.ToString(); | |
| 50 return false; | |
| 51 } | |
| 52 | |
| 53 return true; | |
| 54 } | |
| 55 | |
| 56 FuzzyPixelComparator::FuzzyPixelComparator( | |
| 57 const bool discard_alpha, | |
| 58 const float error_pixels_percentage_limit, | |
| 59 const float small_error_pixels_percentage_limit, | |
| 60 const float avg_abs_error_limit, | |
| 61 const int max_abs_error_limit, | |
| 62 const int small_error_threshold) | |
| 63 : discard_alpha_(discard_alpha), | |
| 64 error_pixels_percentage_limit_(error_pixels_percentage_limit), | |
| 65 small_error_pixels_percentage_limit_(small_error_pixels_percentage_limit), | |
| 66 avg_abs_error_limit_(avg_abs_error_limit), | |
| 67 max_abs_error_limit_(max_abs_error_limit), | |
| 68 small_error_threshold_(small_error_threshold) { | |
| 69 } | |
| 70 | |
| 71 bool FuzzyPixelComparator::Compare(const SkBitmap& actual_bmp, | |
| 72 const SkBitmap& expected_bmp) const { | |
| 73 // Number of pixels with an error | |
| 74 int error_pixels_count = 0; | |
| 75 // Number of pixels with a small error | |
| 76 int small_error_pixels_count = 0; | |
| 77 // The per channel sums of absolute errors over all pixels. | |
| 78 int64 sum_abs_error_r = 0; | |
| 79 int64 sum_abs_error_g = 0; | |
| 80 int64 sum_abs_error_b = 0; | |
| 81 int64 sum_abs_error_a = 0; | |
| 82 // The per channel maximum absolute errors over all pixels. | |
| 83 int max_abs_error_r = 0; | |
| 84 int max_abs_error_g = 0; | |
| 85 int max_abs_error_b = 0; | |
| 86 int max_abs_error_a = 0; | |
| 87 | |
| 88 gfx::Rect error_bounding_rect = gfx::Rect(); | |
| 89 | |
| 90 // Check that bitmaps have identical dimensions. | |
| 91 DCHECK(actual_bmp.width() == expected_bmp.width() && | |
| 92 actual_bmp.height() == expected_bmp.height()); | |
| 93 | |
| 94 // Check that bitmaps are not empty. | |
| 95 DCHECK(actual_bmp.width() > 0 && actual_bmp.height() > 0); | |
| 96 | |
| 97 SkAutoLockPixels lock_actual_bmp(actual_bmp); | |
| 98 SkAutoLockPixels lock_expected_bmp(expected_bmp); | |
| 99 | |
| 100 for (int x = 0; x < actual_bmp.width(); ++x) { | |
| 101 for (int y = 0; y < actual_bmp.height(); ++y) { | |
| 102 SkColor actual_color = actual_bmp.getColor(x, y); | |
| 103 SkColor expected_color = expected_bmp.getColor(x, y); | |
| 104 if (discard_alpha_) { | |
| 105 actual_color = SkColorSetA(actual_color, 0); | |
| 106 expected_color = SkColorSetA(expected_color, 0); | |
| 107 } | |
| 108 | |
| 109 if (actual_color != expected_color) { | |
| 110 ++error_pixels_count; | |
| 111 | |
| 112 // Compute per channel errors | |
| 113 int error_r = SkColorGetR(actual_color) - SkColorGetR(expected_color); | |
| 114 int error_g = SkColorGetG(actual_color) - SkColorGetG(expected_color); | |
| 115 int error_b = SkColorGetB(actual_color) - SkColorGetB(expected_color); | |
| 116 int error_a = SkColorGetA(actual_color) - SkColorGetA(expected_color); | |
| 117 int abs_error_r = std::abs(error_r); | |
| 118 int abs_error_g = std::abs(error_g); | |
| 119 int abs_error_b = std::abs(error_b); | |
| 120 int abs_error_a = std::abs(error_a); | |
| 121 | |
| 122 // Increment small error counter if error is below threshold | |
| 123 if (abs_error_r <= small_error_threshold_ && | |
| 124 abs_error_g <= small_error_threshold_ && | |
| 125 abs_error_b <= small_error_threshold_ && | |
| 126 abs_error_a <= small_error_threshold_) | |
| 127 ++small_error_pixels_count; | |
| 128 | |
| 129 // Update per channel maximum absolute errors | |
| 130 max_abs_error_r = std::max(max_abs_error_r, abs_error_r); | |
| 131 max_abs_error_g = std::max(max_abs_error_g, abs_error_g); | |
| 132 max_abs_error_b = std::max(max_abs_error_b, abs_error_b); | |
| 133 max_abs_error_a = std::max(max_abs_error_a, abs_error_a); | |
| 134 | |
| 135 // Update per channel absolute error sums | |
| 136 sum_abs_error_r += abs_error_r; | |
| 137 sum_abs_error_g += abs_error_g; | |
| 138 sum_abs_error_b += abs_error_b; | |
| 139 sum_abs_error_a += abs_error_a; | |
| 140 } | |
| 141 } | |
| 142 } | |
| 143 | |
| 144 // Compute error metrics from collected data | |
| 145 int pixels_count = actual_bmp.width() * actual_bmp.height(); | |
| 146 float error_pixels_percentage = 0.0f; | |
| 147 float small_error_pixels_percentage = 0.0f; | |
| 148 if (pixels_count > 0) { | |
| 149 error_pixels_percentage = static_cast<float>(error_pixels_count) / | |
| 150 pixels_count * 100.0f; | |
| 151 small_error_pixels_percentage = | |
| 152 static_cast<float>(small_error_pixels_count) / pixels_count * 100.0f; | |
| 153 } | |
| 154 float avg_abs_error_r = 0.0f; | |
| 155 float avg_abs_error_g = 0.0f; | |
| 156 float avg_abs_error_b = 0.0f; | |
| 157 float avg_abs_error_a = 0.0f; | |
| 158 if (error_pixels_count > 0) { | |
| 159 avg_abs_error_r = static_cast<float>(sum_abs_error_r) / error_pixels_count; | |
| 160 avg_abs_error_g = static_cast<float>(sum_abs_error_g) / error_pixels_count; | |
| 161 avg_abs_error_b = static_cast<float>(sum_abs_error_b) / error_pixels_count; | |
| 162 avg_abs_error_a = static_cast<float>(sum_abs_error_a) / error_pixels_count; | |
| 163 } | |
| 164 | |
| 165 if (error_pixels_percentage > error_pixels_percentage_limit_ || | |
| 166 small_error_pixels_percentage > small_error_pixels_percentage_limit_ || | |
| 167 avg_abs_error_r > avg_abs_error_limit_ || | |
| 168 avg_abs_error_g > avg_abs_error_limit_ || | |
| 169 avg_abs_error_b > avg_abs_error_limit_ || | |
| 170 avg_abs_error_a > avg_abs_error_limit_ || | |
| 171 max_abs_error_r > max_abs_error_limit_ || | |
| 172 max_abs_error_g > max_abs_error_limit_ || | |
| 173 max_abs_error_b > max_abs_error_limit_ || | |
| 174 max_abs_error_a > max_abs_error_limit_) { | |
| 175 LOG(ERROR) << "Percentage of pixels with an error: " | |
| 176 << error_pixels_percentage; | |
| 177 LOG(ERROR) << "Percentage of pixels with errors not greater than " | |
| 178 << small_error_threshold_ << ": " | |
| 179 << small_error_pixels_percentage; | |
| 180 LOG(ERROR) << "Average absolute error (excluding identical pixels): " | |
| 181 << "R=" << avg_abs_error_r << " " | |
| 182 << "G=" << avg_abs_error_g << " " | |
| 183 << "B=" << avg_abs_error_b << " " | |
| 184 << "A=" << avg_abs_error_a; | |
| 185 LOG(ERROR) << "Largest absolute error: " | |
| 186 << "R=" << max_abs_error_r << " " | |
| 187 << "G=" << max_abs_error_g << " " | |
| 188 << "B=" << max_abs_error_b << " " | |
| 189 << "A=" << max_abs_error_a; | |
| 190 | |
| 191 for (int x = 0; x < actual_bmp.width(); ++x) { | |
| 192 for (int y = 0; y < actual_bmp.height(); ++y) { | |
| 193 SkColor actual_color = actual_bmp.getColor(x, y); | |
| 194 SkColor expected_color = expected_bmp.getColor(x, y); | |
| 195 if (discard_alpha_) { | |
| 196 actual_color = SkColorSetA(actual_color, 0); | |
| 197 expected_color = SkColorSetA(expected_color, 0); | |
| 198 } | |
| 199 if (actual_color != expected_color) | |
| 200 error_bounding_rect.Union(gfx::Rect(x, y, 1, 1)); | |
| 201 } | |
| 202 } | |
| 203 LOG(ERROR) << "Error Bounding Box : " << error_bounding_rect.ToString(); | |
| 204 return false; | |
| 205 } else { | |
| 206 return true; | |
| 207 } | |
| 208 } | |
| 209 | |
| 210 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
