| OLD | NEW |
| (Empty) |
| 1 /* | |
| 2 * Copyright 2013 Google Inc. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license that can be | |
| 5 * found in the LICENSE file. | |
| 6 */ | |
| 7 | |
| 8 #include "SkBitmap.h" | |
| 9 #include "SkImageDecoder.h" | |
| 10 #include "SkOSFile.h" | |
| 11 #include "SkStream.h" | |
| 12 #include "SkTDict.h" | |
| 13 | |
| 14 #include "SkDiffContext.h" | |
| 15 #include "SkImageDiffer.h" | |
| 16 #include "skpdiff_util.h" | |
| 17 | |
| 18 SkDiffContext::SkDiffContext() { | |
| 19 fRecords = NULL; | |
| 20 fDiffers = NULL; | |
| 21 fDifferCount = 0; | |
| 22 } | |
| 23 | |
| 24 SkDiffContext::~SkDiffContext() { | |
| 25 // Delete the record linked list | |
| 26 DiffRecord* currentRecord = fRecords; | |
| 27 while (NULL != currentRecord) { | |
| 28 DiffRecord* nextRecord = currentRecord->fNext; | |
| 29 SkDELETE(currentRecord); | |
| 30 currentRecord = nextRecord; | |
| 31 } | |
| 32 | |
| 33 if (NULL != fDiffers) { | |
| 34 SkDELETE_ARRAY(fDiffers); | |
| 35 } | |
| 36 } | |
| 37 | |
| 38 void SkDiffContext::setDiffers(const SkTDArray<SkImageDiffer*>& differs) { | |
| 39 // Delete whatever the last array of differs was | |
| 40 if (NULL != fDiffers) { | |
| 41 SkDELETE_ARRAY(fDiffers); | |
| 42 fDiffers = NULL; | |
| 43 fDifferCount = 0; | |
| 44 } | |
| 45 | |
| 46 // Copy over the new differs | |
| 47 fDifferCount = differs.count(); | |
| 48 fDiffers = SkNEW_ARRAY(SkImageDiffer*, fDifferCount); | |
| 49 differs.copy(fDiffers); | |
| 50 } | |
| 51 | |
| 52 void SkDiffContext::addDiff(const char* baselinePath, const char* testPath) { | |
| 53 // Load the images at the paths | |
| 54 SkBitmap baselineBitmap; | |
| 55 SkBitmap testBitmap; | |
| 56 if (!SkImageDecoder::DecodeFile(baselinePath, &baselineBitmap)) { | |
| 57 SkDebugf("Failed to load bitmap \"%s\"\n", baselinePath); | |
| 58 return; | |
| 59 } | |
| 60 if (!SkImageDecoder::DecodeFile(testPath, &testBitmap)) { | |
| 61 SkDebugf("Failed to load bitmap \"%s\"\n", testPath); | |
| 62 return; | |
| 63 } | |
| 64 | |
| 65 // Setup a record for this diff | |
| 66 DiffRecord* newRecord = SkNEW(DiffRecord); | |
| 67 newRecord->fBaselinePath = baselinePath; | |
| 68 newRecord->fTestPath = testPath; | |
| 69 newRecord->fNext = fRecords; | |
| 70 fRecords = newRecord; | |
| 71 | |
| 72 // Perform each diff | |
| 73 for (int differIndex = 0; differIndex < fDifferCount; differIndex++) { | |
| 74 SkImageDiffer* differ = fDiffers[differIndex]; | |
| 75 int diffID = differ->queueDiff(&baselineBitmap, &testBitmap); | |
| 76 if (diffID >= 0) { | |
| 77 | |
| 78 // Copy the results into data for this record | |
| 79 DiffData& diffData = newRecord->fDiffs.push_back(); | |
| 80 | |
| 81 diffData.fDiffName = differ->getName(); | |
| 82 diffData.fResult = differ->getResult(diffID); | |
| 83 | |
| 84 int poiCount = differ->getPointsOfInterestCount(diffID); | |
| 85 SkIPoint* poi = differ->getPointsOfInterest(diffID); | |
| 86 diffData.fPointsOfInterest.append(poiCount, poi); | |
| 87 | |
| 88 // Because we are doing everything synchronously for now, we are don
e with the diff | |
| 89 // after reading it. | |
| 90 differ->deleteDiff(diffID); | |
| 91 } | |
| 92 } | |
| 93 } | |
| 94 | |
| 95 | |
| 96 void SkDiffContext::diffDirectories(const char baselinePath[], const char testPa
th[]) { | |
| 97 // Get the files in the baseline, we will then look for those inside the tes
t path | |
| 98 SkTArray<SkString> baselineEntries; | |
| 99 if (!get_directory(baselinePath, &baselineEntries)) { | |
| 100 SkDebugf("Unable to open path \"%s\"\n", baselinePath); | |
| 101 return; | |
| 102 } | |
| 103 | |
| 104 for (int baselineIndex = 0; baselineIndex < baselineEntries.count(); baselin
eIndex++) { | |
| 105 SkDebugf("[%i/%i] ", baselineIndex, baselineEntries.count()); | |
| 106 const char* baseFilename = baselineEntries[baselineIndex].c_str(); | |
| 107 | |
| 108 // Find the real location of each file to compare | |
| 109 SkString baselineFile = SkOSPath::SkPathJoin(baselinePath, baseFilename)
; | |
| 110 SkString testFile = SkOSPath::SkPathJoin(testPath, baseFilename); | |
| 111 | |
| 112 // Check that the test file exists and is a file | |
| 113 if (sk_exists(testFile.c_str()) && !sk_isdir(testFile.c_str())) { | |
| 114 // Queue up the comparison with the differ | |
| 115 this->addDiff(baselineFile.c_str(), testFile.c_str()); | |
| 116 } else { | |
| 117 SkDebugf("Baseline file \"%s\" has no corresponding test file\n", ba
selineFile.c_str()); | |
| 118 } | |
| 119 } | |
| 120 } | |
| 121 | |
| 122 | |
| 123 void SkDiffContext::diffPatterns(const char baselinePattern[], const char testPa
ttern[]) { | |
| 124 // Get the files in the baseline and test patterns. Because they are in sort
ed order, it's easy | |
| 125 // to find corresponding images by matching entry indices. | |
| 126 | |
| 127 SkTArray<SkString> baselineEntries; | |
| 128 if (!glob_files(baselinePattern, &baselineEntries)) { | |
| 129 SkDebugf("Unable to get pattern \"%s\"\n", baselinePattern); | |
| 130 return; | |
| 131 } | |
| 132 | |
| 133 SkTArray<SkString> testEntries; | |
| 134 if (!glob_files(testPattern, &testEntries)) { | |
| 135 SkDebugf("Unable to get pattern \"%s\"\n", testPattern); | |
| 136 return; | |
| 137 } | |
| 138 | |
| 139 if (baselineEntries.count() != testEntries.count()) { | |
| 140 SkDebugf("Baseline and test patterns do not yield corresponding number o
f files\n"); | |
| 141 return; | |
| 142 } | |
| 143 | |
| 144 for (int entryIndex = 0; entryIndex < baselineEntries.count(); entryIndex++)
{ | |
| 145 SkDebugf("[%i/%i] ", entryIndex, baselineEntries.count()); | |
| 146 const char* baselineFilename = baselineEntries[entryIndex].c_str(); | |
| 147 const char* testFilename = testEntries [entryIndex].c_str(); | |
| 148 | |
| 149 this->addDiff(baselineFilename, testFilename); | |
| 150 } | |
| 151 } | |
| 152 | |
| 153 void SkDiffContext::outputRecords(SkWStream& stream, bool useJSONP) { | |
| 154 DiffRecord* currentRecord = fRecords; | |
| 155 if (useJSONP) { | |
| 156 stream.writeText("var SkPDiffRecords = {\n"); | |
| 157 } | |
| 158 else | |
| 159 { | |
| 160 stream.writeText("{\n"); | |
| 161 } | |
| 162 stream.writeText(" \"records\": [\n"); | |
| 163 while (NULL != currentRecord) { | |
| 164 stream.writeText(" {\n"); | |
| 165 | |
| 166 stream.writeText(" \"baselinePath\": \""); | |
| 167 stream.writeText(currentRecord->fBaselinePath.c_str()); | |
| 168 stream.writeText("\",\n"); | |
| 169 | |
| 170 stream.writeText(" \"testPath\": \""); | |
| 171 stream.writeText(currentRecord->fTestPath.c_str()); | |
| 172 stream.writeText("\",\n"); | |
| 173 | |
| 174 stream.writeText(" \"diffs\": [\n"); | |
| 175 for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); d
iffIndex++) { | |
| 176 DiffData& data = currentRecord->fDiffs[diffIndex]; | |
| 177 stream.writeText(" {\n"); | |
| 178 | |
| 179 stream.writeText(" \"differName\": \""); | |
| 180 stream.writeText(data.fDiffName); | |
| 181 stream.writeText("\",\n"); | |
| 182 | |
| 183 stream.writeText(" \"result\": "); | |
| 184 stream.writeScalarAsText((SkScalar)data.fResult); | |
| 185 stream.writeText(",\n"); | |
| 186 | |
| 187 stream.writeText(" \"pointsOfInterest\":
[\n"); | |
| 188 for (int poiIndex = 0; poiIndex < data.fPointsOfInterest.cou
nt(); poiIndex++) { | |
| 189 SkIPoint poi = data.fPointsOfInterest[poiIndex]; | |
| 190 stream.writeText(" ["); | |
| 191 stream.writeDecAsText(poi.x()); | |
| 192 stream.writeText(","); | |
| 193 stream.writeDecAsText(poi.y()); | |
| 194 stream.writeText("]"); | |
| 195 | |
| 196 // JSON does not allow trailing commas | |
| 197 if (poiIndex + 1 < data.fPointsOfInterest.count()) | |
| 198 { | |
| 199 stream.writeText(","); | |
| 200 } | |
| 201 stream.writeText("\n"); | |
| 202 } | |
| 203 stream.writeText(" ]\n"); | |
| 204 stream.writeText(" }"); | |
| 205 | |
| 206 // JSON does not allow trailing commas | |
| 207 if (diffIndex + 1 < currentRecord->fDiffs.count()) | |
| 208 { | |
| 209 stream.writeText(","); | |
| 210 } | |
| 211 stream.writeText(" \n"); | |
| 212 } | |
| 213 stream.writeText(" ]\n"); | |
| 214 | |
| 215 stream.writeText(" }"); | |
| 216 | |
| 217 // JSON does not allow trailing commas | |
| 218 if (NULL != currentRecord->fNext) | |
| 219 { | |
| 220 stream.writeText(","); | |
| 221 } | |
| 222 stream.writeText("\n"); | |
| 223 currentRecord = currentRecord->fNext; | |
| 224 } | |
| 225 stream.writeText(" ]\n"); | |
| 226 if (useJSONP) { | |
| 227 stream.writeText("};\n"); | |
| 228 } | |
| 229 else | |
| 230 { | |
| 231 stream.writeText("}\n"); | |
| 232 } | |
| 233 } | |
| 234 | |
| 235 void SkDiffContext::outputCsv(SkWStream& stream) { | |
| 236 SkTDict<int> columns(2); | |
| 237 int cntColumns = 0; | |
| 238 | |
| 239 stream.writeText("key"); | |
| 240 | |
| 241 DiffRecord* currentRecord = fRecords; | |
| 242 | |
| 243 // Write CSV header and create a dictionary of all columns. | |
| 244 while (NULL != currentRecord) { | |
| 245 for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); diffI
ndex++) { | |
| 246 DiffData& data = currentRecord->fDiffs[diffIndex]; | |
| 247 if (!columns.find(data.fDiffName)) { | |
| 248 columns.set(data.fDiffName, cntColumns); | |
| 249 stream.writeText(", "); | |
| 250 stream.writeText(data.fDiffName); | |
| 251 cntColumns++; | |
| 252 } | |
| 253 } | |
| 254 currentRecord = currentRecord->fNext; | |
| 255 } | |
| 256 stream.writeText("\n"); | |
| 257 | |
| 258 double values[100]; | |
| 259 SkASSERT(cntColumns < 100); // Make the array larger, if we ever have so ma
ny diff types. | |
| 260 | |
| 261 currentRecord = fRecords; | |
| 262 while (NULL != currentRecord) { | |
| 263 for (int i = 0; i < cntColumns; i++) { | |
| 264 values[i] = -1; | |
| 265 } | |
| 266 | |
| 267 for (int diffIndex = 0; diffIndex < currentRecord->fDiffs.count(); diffI
ndex++) { | |
| 268 DiffData& data = currentRecord->fDiffs[diffIndex]; | |
| 269 int index = -1; | |
| 270 SkAssertResult(columns.find(data.fDiffName, &index)); | |
| 271 SkASSERT(index >= 0 && index < cntColumns); | |
| 272 values[index] = data.fResult; | |
| 273 } | |
| 274 | |
| 275 const char* filename = currentRecord->fBaselinePath.c_str() + | |
| 276 strlen(currentRecord->fBaselinePath.c_str()) - 1; | |
| 277 while (filename > currentRecord->fBaselinePath.c_str() && *(filename - 1
) != '/') { | |
| 278 filename--; | |
| 279 } | |
| 280 | |
| 281 stream.writeText(filename); | |
| 282 | |
| 283 for (int i = 0; i < cntColumns; i++) { | |
| 284 SkString str; | |
| 285 str.printf(", %f", values[i]); | |
| 286 stream.writeText(str.c_str()); | |
| 287 } | |
| 288 stream.writeText("\n"); | |
| 289 | |
| 290 currentRecord = currentRecord->fNext; | |
| 291 } | |
| 292 } | |
| OLD | NEW |