text: // Copyright 2018 Google LLC.
  // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
  
  // Jitter GMs
  //
  // Re-execute rendering tests with slight translational changes and see if
  // there is a significant change.  Print `1` if the named test has no
  // significant change, `0` otherwise
  
  #include "gm/gm.h"
  #include "include/core/SkBitmap.h"
  #include "include/core/SkCanvas.h"
  #include "include/core/SkColor.h"
  #include "include/core/SkExecutor.h"
  #include "include/core/SkGraphics.h"
  #include "include/core/SkPoint.h"
  #include "include/core/SkSize.h"
  #include "include/core/SkTypes.h"
  #include "include/private/SkSemaphore.h"
  #include "tools/Registry.h"
  #include "tools/skqp/src/skqp.h"
  #include "tools/skqp/src/skqp_model.h"
  
  #include <math.h>
  #include <algorithm>
  #include <cstdio>
  #include <fstream>
  #include <memory>
  #include <mutex>
  #include <string>
  #include <vector>
  
  // Error tolerance distance in 8888 color space with Manhattan metric on color channel.
  static constexpr uint8_t kSkiaSkqpGlobalErrorTolerance = 8;
  
  // Number of times to jitter the canvas.
  static constexpr int kNumberOfJitters = 7;
  
  // Distance to translate the canvas in each jitter (direction will be different each time).
  static constexpr float kJitterMagnitude = 0.03125f;
  
  // The `kNumberOfJitters` different runs will each go in a different direction.
  // this is the angle (in radians) for the first one.
  static constexpr float kPhase = 0.3f;
  
  static void do_gm(SkBitmap* bm, skiagm::GM* gm, SkPoint jitter) {
      SkASSERT(bm);
      SkASSERT(gm);
      SkASSERT(bm->dimensions() == gm->getISize());
      SkCanvas canvas(*bm);
      SkAutoCanvasRestore autoCanvasRestore(&canvas, true);
      canvas.clear(SK_ColorWHITE);
      canvas.translate(jitter.x(), jitter.y());
      gm->draw(&canvas);
      canvas.flush();
  }
  
  // Return true if passes jitter test.
  static bool test_jitter(skiagm::GM* gm) {
      SkASSERT(gm);
      SkISize size = gm->getISize();
      SkBitmap control, experimental;
      control.allocN32Pixels(size.width(), size.height());
      experimental.allocN32Pixels(size.width(), size.height());
      do_gm(&control, gm, {0, 0});
      for (int i = 0; i < kNumberOfJitters; ++i) {
          float angle = i * (6.2831853f / kNumberOfJitters) + kPhase;
          do_gm(&experimental, gm, SkPoint{kJitterMagnitude * cosf(angle),
                                           kJitterMagnitude * sinf(angle)});
          SkQP::RenderOutcome result = skqp::Check(
                  control.pixmap(), control.pixmap(), experimental.pixmap(),
                  kSkiaSkqpGlobalErrorTolerance, nullptr);
          if (result.fTotalError > 0) {
              return false;
          }
      }
      return true;
  }
  
  static bool do_this_test(const char* name,
                      const std::vector<std::string>& doNotRun,
                      const std::vector<std::string>& testOnlyThese) {
      for (const std::string& bad : doNotRun) {
          if (bad == name) {
              return false;
          }
      }
      for (const std::string& good : testOnlyThese) {
          if (good == name) {
              return true;
          }
      }
      return testOnlyThese.empty();
  }
  
  
  int main(int argc, char** argv) {
      std::vector<std::string> doNotRun;
      std::vector<std::string> testOnlyThese;
      if (argc > 1) {
          std::ifstream ifs(argv[1]);
          if (ifs.is_open()) {
              std::string str;
              while (std::getline(ifs, str)) {
                  doNotRun.push_back(str);
              }
          }
      }
      if (argc > 2) {
          for (int i = 2; i < argc; ++i) {
              testOnlyThese.emplace_back(argv[i]);
          }
      }
      SkGraphics::Init();
      std::mutex mutex;
      std::vector<std::string> goodResults;
      std::vector<std::string> badResults;
  
      int total = 0;
      SkSemaphore semaphore;
      auto executor = SkExecutor::MakeFIFOThreadPool();
      for (skiagm::GMFactory factory : skiagm::GMRegistry::Range()) {
          ++total;
          executor->add([factory, &mutex, &goodResults, &badResults,
                         &semaphore, &doNotRun, &testOnlyThese](){
              std::unique_ptr<skiagm::GM> gm(factory());
              const char* name = gm->getName();
              if (do_this_test(name, doNotRun, testOnlyThese)) {
                  bool success = test_jitter(gm.get());
                  std::lock_guard<std::mutex> lock(mutex);
                  if (success) {
                      goodResults.emplace_back(name);
                  } else {
                      badResults.emplace_back(name);
                  }
                  fputc('.', stderr);
                  fflush(stderr);
              }
              semaphore.signal();
          });
      }
      while (total-- > 0) { semaphore.wait(); }
      fputc('\n', stderr);
      fflush(stderr);
      std::sort(goodResults.begin(), goodResults.end());
      std::sort(badResults.begin(), badResults.end());
      std::ofstream good("good.txt");
      std::ofstream bad("bad.txt");
      for (const std::string& s : goodResults) { good << s << '\n'; }
      for (const std::string& s : badResults) { bad << s << '\n'; }
      fprintf(stderr, "good = %u\nbad = %u\n\n",
              (unsigned)goodResults.size(), (unsigned)badResults.size());
  }
  