Add missing FloatUtil.invertMatrix(..) unit test, which impl. changed w/ commit ee774dce9e474e8ea961bd9b504d26e9321e1b15

1 files changed, 262 insertions, 0 deletions

diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil03InversionNOUI.java b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil03InversionNOUI.java
new file mode 100644
index 000000000..e9558b251
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil03InversionNOUI.java
@@ -0,0 +1,262 @@
+/**

+ * Copyright 2014 JogAmp Community. All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without modification, are

+ * permitted provided that the following conditions are met:

+ *

+ *    1. Redistributions of source code must retain the above copyright notice, this list of

+ *       conditions and the following disclaimer.

+ *

+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list

+ *       of conditions and the following disclaimer in the documentation and/or other materials

+ *       provided with the distribution.

+ *

+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED

+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR

+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+ *

+ * The views and conclusions contained in the software and documentation are those of the

+ * authors and should not be interpreted as representing official policies, either expressed

+ * or implied, of JogAmp Community.

+ */

+

+package com.jogamp.opengl.test.junit.jogl.math;

+

+import org.junit.Assert;

+import org.junit.Test;
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;

+

+import com.jogamp.common.os.Platform;

+import com.jogamp.opengl.math.FloatUtil;

+

+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestFloatUtil03InversionNOUI {

+

+    @Test

+    public void test01Ident(){

+        final float[] res1 = new float[16];

+        final float[] res2 = new float[16];

+        final float[] temp = new float[16];

+

+        final float[] identity = new float[] { 1, 0, 0, 0,

+                                               0, 1, 0, 0,

+                                               0, 0, 1, 0,

+                                               0, 0, 0, 1 };

+

+        FloatUtil.invertMatrix(identity, 0, res1, 0);

+        System.err.println(FloatUtil.matrixToString(null, "inv-1: ", "%10.7f", res1, 0, 4, 4, false /* rowMajorOrder */));

+        invertMatrix(identity, 0, res2, 0, temp);

+        System.err.println(FloatUtil.matrixToString(null, "inv-2: ", "%10.7f", res2, 0, 4, 4, false /* rowMajorOrder */));

+

+        Assert.assertArrayEquals("I1/I2 failure", res1, res2, FloatUtil.INV_DEVIANCE);

+        Assert.assertArrayEquals("I2 failure", identity, res2, FloatUtil.INV_DEVIANCE);

+        Assert.assertArrayEquals("I1 failure", identity, res1, FloatUtil.INV_DEVIANCE);

+    }

+

+    private void testImpl(final float[] matrix) {

+        final float[] inv1_0 = new float[16];

+        final float[] inv1_1 = new float[16];

+        final float[] inv1_2 = new float[16];

+        final float[] inv2_0 = new float[16];

+        final float[] inv2_1 = new float[16];

+        final float[] inv2_2 = new float[16];

+        final float[] temp = new float[16];

+

+        System.err.println(FloatUtil.matrixToString(null, "orig  : ", "%10.7f", matrix, 0, 4, 4, false /* rowMajorOrder */));

+        invertMatrix(matrix, 0, inv1_0, 0, temp);

+        invertMatrix(inv1_0, 0, inv2_0, 0, temp);

+        System.err.println(FloatUtil.matrixToString(null, "inv1_0: ", "%10.7f", inv1_0, 0, 4, 4, false /* rowMajorOrder */));

+        System.err.println(FloatUtil.matrixToString(null, "inv2_0: ", "%10.7f", inv2_0, 0, 4, 4, false /* rowMajorOrder */));

+        FloatUtil.invertMatrix(matrix, 0, inv1_1, 0);

+        FloatUtil.invertMatrix(inv1_1, 0, inv2_1, 0);

+        System.err.println(FloatUtil.matrixToString(null, "inv1_1: ", "%10.7f", inv1_1, 0, 4, 4, false /* rowMajorOrder */));

+        System.err.println(FloatUtil.matrixToString(null, "inv2_1: ", "%10.7f", inv2_1, 0, 4, 4, false /* rowMajorOrder */));

+        FloatUtil.invertMatrix(matrix, inv1_2);

+        FloatUtil.invertMatrix(inv1_2, inv2_2);

+        System.err.println(FloatUtil.matrixToString(null, "inv1_2: ", "%10.7f", inv1_2, 0, 4, 4, false /* rowMajorOrder */));

+        System.err.println(FloatUtil.matrixToString(null, "inv2_2: ", "%10.7f", inv2_2, 0, 4, 4, false /* rowMajorOrder */));

+

+        Assert.assertArrayEquals("I1_1/I1_2 failure", inv1_1, inv1_2, FloatUtil.INV_DEVIANCE);

+        Assert.assertArrayEquals("I2_1/I2_2 failure", inv2_1, inv2_2, FloatUtil.INV_DEVIANCE);

+

+        Assert.assertArrayEquals("I1_0/I1_1 failure", inv1_0, inv1_2, FloatUtil.INV_DEVIANCE);

+        Assert.assertArrayEquals("I2_0/I2_1 failure", inv2_0, inv2_2, FloatUtil.INV_DEVIANCE);

+

+        Assert.assertArrayEquals("I1 failure", matrix, inv2_0, FloatUtil.INV_DEVIANCE);

+        Assert.assertArrayEquals("I2 failure", matrix, inv2_2, FloatUtil.INV_DEVIANCE);

+        Assert.assertArrayEquals("I2 failure", matrix, inv2_1, FloatUtil.INV_DEVIANCE);

+    }

+

+    @Test

+    public void test02(){

+        float[] p = new float[] { 2.3464675f, 0,          0,        0,

+                                  0,          2.4142134f, 0,        0,

+                                  0,          0,         -1.0002f, -1,

+                                  0,          0,        -20.002f,   0 };

+        testImpl(p);

+    }

+

+    @Test

+    public void test03(){

+        float[] mv = new float[] { 1, 0,    0, 0,

+                                   0, 1,    0, 0,

+                                   0, 0,    1, 0,

+                                   0, 0, -200, 1 } ;

+        testImpl(mv);

+    }

+

+    @Test

+    public void test04(){

+        float[] p = new float[] { 2.3464675f, 0,          0,        0,

+                                  0,          2.4142134f, 0,        0,

+                                  0,          0,         -1.0002f, -1,

+                                  0,          0,        -20.002f,   0 };

+

+        testImpl(p);

+    }

+

+    @Test

+    public void test05Perf(){

+        float[] p1 = new float[] { 2.3464675f, 0,          0,        0,

+                                   0,          2.4142134f, 0,        0,

+                                   0,          0,         -1.0002f, -1,

+                                   0,          0,        -20.002f,   0 };

+

+        float[] p2 = new float[]{   26,   59,  143,   71,

+                                    59,  174,  730,  386,

+                                   143,  730, 9770, 5370,

+                                    71,  386, 5370, 2954 };

+

+        final float[] res1 = new float[16];

+        final float[] res2 = new float[16];

+        final float[] temp = new float[16];

+

+        final int loops = 1000000;

+        long tI0 = 0;

+        long tI1 = 0;

+        long tI2 = 0;

+

+        // warm-up

+        for(int i=0; i<10; i++) {

+            invertMatrix(p1, 0, res2, 0, temp);

+            FloatUtil.invertMatrix(p1, 0, res1, 0);

+            FloatUtil.invertMatrix(p1, res1);

+

+            invertMatrix(p2, 0, res2, 0, temp);

+            FloatUtil.invertMatrix(p2, 0, res1, 0);

+            FloatUtil.invertMatrix(p2, res1);

+        }

+

+

+        for(int i=0; i<loops; i++) {

+

+            final long t_0 = Platform.currentTimeMillis();

+

+            invertMatrix(p1, 0, res2, 0, temp);

+            final long t_1 = Platform.currentTimeMillis();

+            tI0 += t_1 - t_0;

+

+            FloatUtil.invertMatrix(p1, 0, res1, 0);

+            final long t_2 = Platform.currentTimeMillis();

+            tI1 += t_2 - t_1;

+

+            FloatUtil.invertMatrix(p1, res1);

+            final long t_3 = Platform.currentTimeMillis();

+            tI2 += t_3 - t_2;

+

+            invertMatrix(p2, 0, res2, 0, temp);

+            final long t_4 = Platform.currentTimeMillis();

+            tI0 += t_4 - t_3;

+

+            FloatUtil.invertMatrix(p2, 0, res1, 0);

+            final long t_5 = Platform.currentTimeMillis();

+            tI1 += t_5 - t_4;

+

+            FloatUtil.invertMatrix(p2, res2);

+            final long t_6 = Platform.currentTimeMillis();

+            tI2 += t_6 - t_5;

+        }

+        System.err.printf("Summary loops %6d: I1 %6d ms total, %f ms/inv%n", loops, tI0, (double)tI0/loops);

+        System.err.printf("Summary loops %6d: I2 %6d ms total, %f ms/inv%n", loops, tI1, (double)tI1/loops);

+        System.err.printf("Summary loops %6d: I3 %6d ms total, %f ms/inv%n", loops, tI2, (double)tI2/loops);

+

+    }

+

+    public static float[] invertMatrix(final float[] msrc, final int msrc_offset, final float[] mres, final int mres_offset, final float[/*4*4*/] temp) {

+        int i, j, k, swap;

+        float t;

+        for (i = 0; i < 4; i++) {

+            final int i4 = i*4;

+            for (j = 0; j < 4; j++) {

+                temp[i4+j] = msrc[i4+j+msrc_offset];

+            }

+        }

+        FloatUtil.makeIdentity(mres, mres_offset);

+

+        for (i = 0; i < 4; i++) {

+            final int i4 = i*4;

+

+            //

+            // Look for largest element in column

+            //

+            swap = i;

+            for (j = i + 1; j < 4; j++) {

+                if (Math.abs(temp[j*4+i]) > Math.abs(temp[i4+i])) {

+                    swap = j;

+                }

+            }

+

+            if (swap != i) {

+                final int swap4 = swap*4;

+                //

+                // Swap rows.

+                //

+                for (k = 0; k < 4; k++) {

+                    t = temp[i4+k];

+                    temp[i4+k] = temp[swap4+k];

+                    temp[swap4+k] = t;

+

+                    t = mres[i4+k+mres_offset];

+                    mres[i4+k+mres_offset] = mres[swap4+k+mres_offset];

+                    mres[swap4+k+mres_offset] = t;

+                }

+            }

+

+            if (temp[i4+i] == 0) {

+                //

+                // No non-zero pivot. The matrix is singular, which shouldn't

+                // happen. This means the user gave us a bad matrix.

+                //

+                return null;

+            }

+

+            t = temp[i4+i];

+            for (k = 0; k < 4; k++) {

+                temp[i4+k] /= t;

+                mres[i4+k+mres_offset] /= t;

+            }

+            for (j = 0; j < 4; j++) {

+                if (j != i) {

+                    final int j4 = j*4;

+                    t = temp[j4+i];

+                    for (k = 0; k < 4; k++) {

+                        temp[j4+k] -= temp[i4+k] * t;

+                        mres[j4+k+mres_offset] -= mres[i4+k+mres_offset]*t;

+                    }

+                }

+            }

+        }

+        return mres;

+    }

+

+    public static void main(String args[]) {

+        org.junit.runner.JUnitCore.main(TestFloatUtil03InversionNOUI.class.getName());

+    }

+}