Add a map homogenous points to SkMatrix

tests/MatrixTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 #include "SkMath.h"
 #include "SkMatrix.h"
@@ skipping 574 matching lines @@
     REPORTER_ASSERT(reporter, !SkDecomposeUpper2x2(mat, &rotation0, &scaleX, &scaleY, &rotation1));
     mat.reset();
     // linearly dependent entries
     mat[SkMatrix::kMScaleX] = 1.f;
     mat[SkMatrix::kMSkewX] = 2.f;
     mat[SkMatrix::kMSkewY] = 4.f;
     mat[SkMatrix::kMScaleY] = 8.f;
     REPORTER_ASSERT(reporter, !SkDecomposeUpper2x2(mat, &rotation0, &scaleX, &scaleY, &rotation1));
 }
 
+// For test_matrix_homogeneous, below.
+static bool scalar_array_nearly_equal_relative(const SkScalar a[], const SkScalar b[], int count) {
+    for (int i = 0; i < count; ++i) {
+        if (!scalar_nearly_equal_relative(a[i], b[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// For test_matrix_homogeneous, below.
+// Maps a single triple in src using m and compares results to those in dst
+static bool naive_homogeneous_mapping(const SkMatrix& m, const SkScalar src[3],
+                                      const SkScalar dst[3]) {
+    SkScalar res[3];
+    res[0] = src[0] * m[0] + src[1] * m[1] + src[2] * m[2];
+    res[1] = src[0] * m[3] + src[1] * m[4] + src[2] * m[5];
+    res[2] = src[0] * m[6] + src[1] * m[7] + src[2] * m[8];
+    return scalar_array_nearly_equal_relative(res, dst, 3);
+}
+
+static void test_matrix_homogeneous(skiatest::Reporter* reporter) {
+    SkMatrix mat;
+
+    const float kRotation0 = 15.5f;
+    const float kRotation1 = -50.f;
+    const float kScale0 = 5000.f;
+
+    const int kTripleCount = 1000;
+    const int kMatrixCount = 1000;
+    SkRandom rand;
+
+    SkScalar randTriples[3*kTripleCount];
+    for (int i = 0; i < 3*kTripleCount; ++i) {
+        randTriples[i] = rand.nextRangeF(-3000.f, 3000.f);
+    }
+
+    SkMatrix mats[kMatrixCount];
+    for (int i = 0; i < kMatrixCount; ++i) {
+        for (int j = 0; j < 9; ++j) {
+            mats[i].set(j, rand.nextRangeF(-3000.f, 3000.f));
+        }
+    }
+
+    // identity
+    {
+    mat.reset();
+    SkScalar dst[3*kTripleCount];
+    mat.mapHomogeneousPoints(dst, randTriples, kTripleCount);
+    REPORTER_ASSERT(reporter, scalar_array_nearly_equal_relative(randTriples, dst, kTripleCount*3));
+    }
+
+    // zero matrix
+    {
+    mat.setAll(0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f);
+    SkScalar dst[3*kTripleCount];
+    mat.mapHomogeneousPoints(dst, randTriples, kTripleCount);
+    SkScalar zeros[3] = {0.f, 0.f, 0.f};
+    for (int i = 0; i < kTripleCount; ++i) {
+        REPORTER_ASSERT(reporter, scalar_array_nearly_equal_relative(&dst[i*3], zeros, 3));
+    }
+    }
+
+    // zero point
+    {
+    SkScalar zeros[3] = {0.f, 0.f, 0.f};
+    for (int i = 0; i < kMatrixCount; ++i) {
+        SkScalar dst[3];
+        mats[i].mapHomogeneousPoints(dst, zeros, 1);
+        REPORTER_ASSERT(reporter, scalar_array_nearly_equal_relative(dst, zeros, 3));
+    }
+    }
+
+    // doesn't crash with null dst, src, count <= 0
+    {
+    mats[0].mapHomogeneousPoints(NULL, NULL, 0);
+    mats[0].mapHomogeneousPoints(NULL, NULL, -1);

[bsalomon, 2013/08/09 13:53:25]

This doesn't trigger an assert?

[egdaniel, 2013/08/09 13:58:24]

So from what Mike was telling me, the tests are not really meant to check
"failures" but more check "successes", since the tests are not run in debug
mode. Basically this is here to just show that if for some reason it was passed
in with bad values the function won't crash. At least that's what I took
thought.
 
On 2013/08/09 13:53:25, bsalomon wrote:

[bsalomon, 2013/08/09 14:04:59]

The tests *are* run in debug builds :) So if -1 is illegal input that we assert
on (which seems totally reasonable) then we can't pass it here. We have the
asserts in the debug build so that we will crash, notice, and fix the call site.
In general, if our contract says passing negative values is illegal then it's OK
if the function crashes (even though it won't in this case). If it's legal to
pass negative then we have to change the assert.

+    }
+
+    // uniform scale of point
+    {
+    mat.setScale(kScale0, kScale0);
+    SkScalar dst[3];
+    SkScalar src[3] = {randTriples[0], randTriples[1], 1.f};
+    SkPoint pnt;
+    pnt.set(src[0], src[1]);
+    mat.mapHomogeneousPoints(dst, src, 1);
+    mat.mapPoints(&pnt, &pnt, 1);
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[0], pnt.fX));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[1], pnt.fY));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[2], SK_Scalar1));
+    }
+
+    // rotation of point
+    {
+    mat.setRotate(kRotation0);
+    SkScalar dst[3];
+    SkScalar src[3] = {randTriples[0], randTriples[1], 1.f};
+    SkPoint pnt;
+    pnt.set(src[0], src[1]);
+    mat.mapHomogeneousPoints(dst, src, 1);
+    mat.mapPoints(&pnt, &pnt, 1);
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[0], pnt.fX));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[1], pnt.fY));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[2], SK_Scalar1));
+    }
+
+    // rotation, scale, rotation of point
+    {
+    mat.setRotate(kRotation1);
+    mat.postScale(kScale0, kScale0);
+    mat.postRotate(kRotation0);
+    SkScalar dst[3];
+    SkScalar src[3] = {randTriples[0], randTriples[1], 1.f};
+    SkPoint pnt;
+    pnt.set(src[0], src[1]);
+    mat.mapHomogeneousPoints(dst, src, 1);
+    mat.mapPoints(&pnt, &pnt, 1);
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[0], pnt.fX));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[1], pnt.fY));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[2], SK_Scalar1));
+    }
+
+    // compare with naive approach
+    {
+    for (int i = 0; i < kMatrixCount; ++i) {
+        for (int j = 0; j < kTripleCount; ++j) {
+            SkScalar dst[3];
+            mats[i].mapHomogeneousPoints(dst, &randTriples[j*3], 1);
+            REPORTER_ASSERT(reporter, naive_homogeneous_mapping(mats[i], &randTriples[j*3], dst));
+        }
+    }
+    }
+
+}
+
 static void TestMatrix(skiatest::Reporter* reporter) {
     SkMatrix    mat, inverse, iden1, iden2;
 
     mat.reset();
     mat.setTranslate(SK_Scalar1, SK_Scalar1);
     REPORTER_ASSERT(reporter, mat.invert(&inverse));
     iden1.setConcat(mat, inverse);
     REPORTER_ASSERT(reporter, is_identity(iden1));
 
     mat.setScale(SkIntToScalar(2), SkIntToScalar(4));
@@ skipping 101 matching lines @@
 #ifdef SK_SCALAR_IS_FIXED
     REPORTER_ASSERT(reporter, are_equal(reporter, mat, mat2));
 #else
     REPORTER_ASSERT(reporter, !are_equal(reporter, mat, mat2));
 #endif
 
     test_matrix_max_stretch(reporter);
     test_matrix_is_similarity(reporter);
     test_matrix_recttorect(reporter);
     test_matrix_decomposition(reporter);
+    test_matrix_homogeneous(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Matrix", MatrixTestClass, TestMatrix)