From 53ec7dc7cb523f220a9f5cd713b241c706779c81 Mon Sep 17 00:00:00 2001
From: Herb Derby <herb@google.com>
Date: Fri, 3 Nov 2017 13:36:55 -0400
Subject: Gauss filter calculation

Change-Id: I921ef815d4f788c312aa729f353b6ea154140555
Reviewed-on: https://skia-review.googlesource.com/67723
Commit-Queue: Herb Derby <herb@google.com>
Reviewed-by: Robert Phillips <robertphillips@google.com>
---
 tests/SkGaussFilterTest.cpp | 88 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 tests/SkGaussFilterTest.cpp

(limited to 'tests/SkGaussFilterTest.cpp')

diff --git a/tests/SkGaussFilterTest.cpp b/tests/SkGaussFilterTest.cpp
new file mode 100644
index 0000000000..958e811ce5
--- /dev/null
+++ b/tests/SkGaussFilterTest.cpp
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkGaussFilter.h"
+
+#include <cmath>
+#include <tuple>
+#include <vector>
+#include "Test.h"
+
+// one part in a million
+static constexpr double kEpsilon = 0.000001;
+
+static double careful_add(int n, double* gauss) {
+    // Sum smallest to largest to retain precision.
+    double sum = 0;
+    for (int i = n - 1; i >= 1; i--) {
+        sum += 2.0 * gauss[i];
+    }
+    sum += gauss[0];
+    return sum;
+}
+
+DEF_TEST(SkGaussFilterCommon, r) {
+    using Test = std::tuple<double, SkGaussFilter::Type, std::vector<double>>;
+
+    auto golden_check = [&](const Test& test) {
+        double sigma; SkGaussFilter::Type type; std::vector<double> golden;
+        std::tie(sigma, type, golden) = test;
+        SkGaussFilter filter{sigma, type};
+        double result[5];
+        size_t n = filter.filterDouble(result);
+        REPORTER_ASSERT(r, n == golden.size());
+        double sum = careful_add(n, result);
+        REPORTER_ASSERT(r, sum == 1.0);
+        for (size_t i = 0; i < golden.size(); i++) {
+            REPORTER_ASSERT(r, std::abs(golden[i] - result[i]) < kEpsilon);
+        }
+    };
+
+    // The following two sigmas account for about 85% of all sigmas used for masks.
+    // Golden values generated using Mathematica.
+    auto tests = {
+        // 0.788675 - most common mask sigma.
+        // GaussianMatrix[{{Automatic}, {.788675}}, Method -> "Gaussian"]
+        Test{0.788675, SkGaussFilter::Type::Gaussian, {0.506205, 0.226579, 0.0203189}},
+
+        // GaussianMatrix[{{Automatic}, {.788675}}]
+        Test{0.788675, SkGaussFilter::Type::Bessel,   {0.593605, 0.176225, 0.0269721}},
+
+        // 1.07735 - second most common mask sigma.
+        // GaussianMatrix[{{Automatic}, {1.07735}}, Method -> "Gaussian"]
+        Test{1.07735, SkGaussFilter::Type::Gaussian,  {0.376362, 0.244636, 0.0671835}},
+
+        // GaussianMatrix[{{4}, {1.07735}}, Method -> "Bessel"]
+        Test{1.07735, SkGaussFilter::Type::Bessel,    {0.429537, 0.214955, 0.059143, 0.0111337}},
+    };
+
+    for (auto& test : tests) {
+        golden_check(test);
+    }
+}
+
+DEF_TEST(SkGaussFilterSweep, r) {
+    // The double just before 2.0.
+    const double maxSigma = nextafter(2.0, 0.0);
+    for (auto type : {SkGaussFilter::Type::Gaussian, SkGaussFilter::Type::Bessel}) {
+
+        auto check = [&](double sigma) {
+            SkGaussFilter filter{sigma, type};
+            double result[5];
+            int n = filter.filterDouble(result);
+            REPORTER_ASSERT(r, n <= 5);
+            double sum = careful_add(n, result);
+            REPORTER_ASSERT(r, sum == 1.0);
+        };
+
+        for (double sigma = 0.0; sigma < 2.0; sigma += 0.1) {
+            check(sigma);
+        }
+
+        check(maxSigma);
+    }
+}
-- 
cgit v1.2.3