From 2a93c7f6eb042f87176b55ccbf2fdedb5093374a Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Sat, 28 Jun 2014 03:07:40 +0200 Subject: Add missing FloatUtil.invertMatrix(..) unit test, which impl. changed w/ commit ee774dce9e474e8ea961bd9b504d26e9321e1b15 --- .../jogl/math/TestFloatUtil03InversionNOUI.java | 262 +++++++++++++++++++++ 1 file changed, 262 insertions(+) create mode 100644 src/test/com/jogamp/opengl/test/junit/jogl/math/TestFloatUtil03InversionNOUI.java (limited to 'src/test/com/jogamp') 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 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()); + } +} -- cgit v1.2.3