421 lines
11 KiB
C#
421 lines
11 KiB
C#
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
// Copyright (c) 2007 Novell, Inc. (http://www.novell.com)
|
|
//
|
|
// Authors:
|
|
// Chris Toshok (toshok@ximian.com)
|
|
//
|
|
|
|
using System;
|
|
using System.Windows;
|
|
using System.Windows.Media;
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.System.Windows.Media {
|
|
|
|
[TestFixture]
|
|
public class MatrixTest {
|
|
const double DELTA = 0.000000001d;
|
|
|
|
void CheckMatrix (Matrix expected, Matrix actual)
|
|
{
|
|
Assert.AreEqual (expected.M11, actual.M11, DELTA);
|
|
Assert.AreEqual (expected.M12, actual.M12, DELTA);
|
|
Assert.AreEqual (expected.M21, actual.M21, DELTA);
|
|
Assert.AreEqual (expected.M22, actual.M22, DELTA);
|
|
Assert.AreEqual (expected.OffsetX, actual.OffsetX, DELTA);
|
|
Assert.AreEqual (expected.OffsetY, actual.OffsetY, DELTA);
|
|
}
|
|
|
|
[Test]
|
|
public void TestAccessors ()
|
|
{
|
|
Matrix m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
Assert.AreEqual (1, m.M11);
|
|
Assert.AreEqual (2, m.M12);
|
|
Assert.AreEqual (3, m.M21);
|
|
Assert.AreEqual (4, m.M22);
|
|
Assert.AreEqual (5, m.OffsetX);
|
|
Assert.AreEqual (6, m.OffsetY);
|
|
}
|
|
|
|
[Test]
|
|
public void Append ()
|
|
{
|
|
Matrix m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
m.Append (m);
|
|
CheckMatrix (new Matrix (7, 10, 15, 22, 28, 40), m);
|
|
}
|
|
|
|
[Test]
|
|
public void Equals ()
|
|
{
|
|
Matrix m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
Assert.IsTrue (m.Equals (new Matrix (1, 2, 3, 4, 5, 6)));
|
|
Assert.IsFalse (m.Equals (new Matrix (0, 2, 3, 4, 5, 6)));
|
|
Assert.IsFalse (m.Equals (new Matrix (1, 0, 3, 4, 5, 6)));
|
|
Assert.IsFalse (m.Equals (new Matrix (1, 2, 0, 4, 5, 6)));
|
|
Assert.IsFalse (m.Equals (new Matrix (1, 2, 3, 0, 5, 6)));
|
|
Assert.IsFalse (m.Equals (new Matrix (1, 2, 3, 4, 0, 6)));
|
|
Assert.IsFalse (m.Equals (new Matrix (1, 2, 3, 4, 5, 0)));
|
|
|
|
Assert.IsFalse (m.Equals (0));
|
|
Assert.IsTrue (m.Equals ((object)m));
|
|
}
|
|
|
|
[Test]
|
|
public void Determinant ()
|
|
{
|
|
Assert.AreEqual (0, (new Matrix (2, 2, 2, 2, 0, 0)).Determinant);
|
|
Assert.AreEqual (-6, (new Matrix (1, 4, 2, 2, 0, 0)).Determinant);
|
|
Assert.AreEqual (1, (new Matrix (1, 0, 0, 1, 0, 0)).Determinant);
|
|
Assert.AreEqual (1, (new Matrix (1, 0, 0, 1, 5, 5)).Determinant);
|
|
Assert.AreEqual (-1, (new Matrix (0, 1, 1, 0, 5, 5)).Determinant);
|
|
}
|
|
|
|
[Test]
|
|
public void HasInverse ()
|
|
{
|
|
/* same matrices as in Determinant() */
|
|
Assert.IsFalse ((new Matrix (2, 2, 2, 2, 0, 0)).HasInverse);
|
|
Assert.IsTrue ((new Matrix (1, 4, 2, 2, 0, 0)).HasInverse);
|
|
Assert.IsTrue ((new Matrix (1, 0, 0, 1, 0, 0)).HasInverse);
|
|
Assert.IsTrue ((new Matrix (1, 0, 0, 1, 5, 5)).HasInverse);
|
|
Assert.IsTrue ((new Matrix (0, 1, 1, 0, 5, 5)).HasInverse);
|
|
}
|
|
|
|
[Test]
|
|
public void IsIdentity ()
|
|
{
|
|
Assert.IsTrue (Matrix.Identity.IsIdentity);;
|
|
Assert.IsFalse ((new Matrix (1, 0, 0, 1, 5, 5)).IsIdentity);
|
|
Assert.IsFalse ((new Matrix (5, 5, 5, 5, 5, 5)).IsIdentity);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))] // "Transform is not invertible."
|
|
public void InvertException1 ()
|
|
{
|
|
Matrix m = new Matrix (2, 2, 2, 2, 0, 0);
|
|
m.Invert ();
|
|
}
|
|
|
|
[Test]
|
|
public void Invert ()
|
|
{
|
|
Matrix m;
|
|
|
|
m = new Matrix (1, 0, 0, 1, 0, 0);
|
|
m.Invert ();
|
|
CheckMatrix (new Matrix (1, 0, 0, 1, 0, 0), m);
|
|
|
|
m = new Matrix (1, 0, 0, 1, 5, 5);
|
|
m.Invert ();
|
|
CheckMatrix (new Matrix (1, 0, 0, 1, -5, -5), m);
|
|
|
|
m = new Matrix (1, 0, 0, 2, 5, 5);
|
|
m.Invert ();
|
|
CheckMatrix (new Matrix (1, 0, 0, 0.5, -5, -2.5), m);
|
|
|
|
m = new Matrix (0, 2, 4, 0, 5, 5);
|
|
m.Invert ();
|
|
CheckMatrix (new Matrix (0, 0.25, 0.5, 0, -2.5, -1.25), m);
|
|
}
|
|
|
|
[Test]
|
|
public void Identity ()
|
|
{
|
|
CheckMatrix (new Matrix (1, 0, 0, 1, 0, 0), Matrix.Identity);
|
|
}
|
|
|
|
[Test]
|
|
public void Multiply ()
|
|
{
|
|
CheckMatrix (new Matrix (5, 0, 0, 5, 10, 10),
|
|
Matrix.Multiply (new Matrix (1, 0, 0, 1, 2, 2),
|
|
new Matrix (5, 0, 0, 5, 0, 0)));
|
|
|
|
CheckMatrix (new Matrix (0, 0, 0, 0, 10, 10),
|
|
Matrix.Multiply (new Matrix (1, 0, 0, 1, 0, 0),
|
|
new Matrix (0, 0, 0, 0, 10, 10)));
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")]
|
|
public void Parse ()
|
|
{
|
|
CheckMatrix (Matrix.Identity, Matrix.Parse ("Identity"));
|
|
CheckMatrix (new Matrix (1, 0, 0, 1, 0, 0), Matrix.Parse ("1, 0, 0, 1, 0, 0"));
|
|
CheckMatrix (new Matrix (0.1, 0.2, 0.3, 0.4, 0.5, 0.6), Matrix.Parse ("0.1,0.2,0.3,0.4,0.5,0.6"));
|
|
// XXX what about locales where . and , are switched?
|
|
}
|
|
|
|
[Test]
|
|
public void Prepend ()
|
|
{
|
|
Matrix m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
m.Prepend (new Matrix (2, 4, 6, 8, 10, 12));
|
|
|
|
CheckMatrix (new Matrix (14, 20, 30, 44, 51, 74), m);
|
|
}
|
|
|
|
[Test]
|
|
public void Rotate ()
|
|
{
|
|
Matrix m = Matrix.Identity;
|
|
m.Rotate (45);
|
|
CheckMatrix (new Matrix (0.707106781186548,
|
|
0.707106781186547,
|
|
-0.707106781186547,
|
|
0.707106781186548, 0, 0), m);
|
|
|
|
m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
m.Rotate (33);
|
|
CheckMatrix (new Matrix (-0.25060750208463,
|
|
2.22198017090588,
|
|
0.337455563776164,
|
|
4.98859937682678,
|
|
0.925518629636958,
|
|
7.75521858274768), m);
|
|
}
|
|
|
|
[Test]
|
|
public void RotateAt ()
|
|
{
|
|
Matrix m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
m.RotateAt (33, 5, 5);
|
|
|
|
CheckMatrix (new Matrix (-0.25060750208463,
|
|
2.22198017090588,
|
|
0.337455563776164,
|
|
4.98859937682678,
|
|
4.45536096498497,
|
|
5.83867056794542), m);
|
|
}
|
|
|
|
[Test]
|
|
public void RotateAtPrepend ()
|
|
{
|
|
Matrix m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
m.RotateAtPrepend (33, 5, 5);
|
|
|
|
CheckMatrix (new Matrix (2.47258767299051,
|
|
3.85589727595096,
|
|
1.97137266882125,
|
|
2.26540420175164,
|
|
2.78019829094125,
|
|
5.39349261148701), m);
|
|
}
|
|
|
|
[Test]
|
|
public void RotatePrepend ()
|
|
{
|
|
Matrix m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
m.RotatePrepend (33);
|
|
|
|
CheckMatrix (new Matrix (2.47258767299051,
|
|
3.85589727595096,
|
|
1.97137266882125,
|
|
2.26540420175164,
|
|
5, 6), m);
|
|
}
|
|
|
|
[Test]
|
|
public void Scale ()
|
|
{
|
|
Matrix m = Matrix.Identity;
|
|
|
|
m.Scale (5, 6);
|
|
CheckMatrix (new Matrix (5, 0, 0, 6, 0, 0), m);
|
|
|
|
m = new Matrix (1, 2, 2, 1, 3, 3);
|
|
m.Scale (5, 5);
|
|
CheckMatrix (new Matrix (5, 10, 10, 5, 15, 15), m);
|
|
}
|
|
|
|
[Test]
|
|
public void ScaleAt ()
|
|
{
|
|
Matrix m = new Matrix (1, 0, 0, 1, 2, 2);
|
|
m.ScaleAt (2, 2, 0, 0);
|
|
CheckMatrix (new Matrix (2, 0, 0, 2, 4, 4), m);
|
|
|
|
m = new Matrix (1, 0, 0, 1, 2, 2);
|
|
m.ScaleAt (2, 2, 4, 4);
|
|
CheckMatrix (new Matrix (2, 0, 0, 2, 0, 0), m);
|
|
|
|
m = new Matrix (1, 0, 0, 1, 2, 2);
|
|
m.ScaleAt (2, 2, 2, 2);
|
|
CheckMatrix (new Matrix (2, 0, 0, 2, 2, 2), m);
|
|
}
|
|
|
|
[Test]
|
|
public void ScaleAtPrepend ()
|
|
{
|
|
Matrix m = new Matrix (1, 0, 0, 1, 2, 2);
|
|
m.ScaleAtPrepend (2, 2, 0, 0);
|
|
CheckMatrix (new Matrix (2, 0, 0, 2, 2, 2), m);
|
|
|
|
m = new Matrix (1, 0, 0, 1, 2, 2);
|
|
m.ScaleAtPrepend (2, 2, 4, 4);
|
|
CheckMatrix (new Matrix (2, 0, 0, 2, -2, -2), m);
|
|
|
|
m = new Matrix (1, 0, 0, 1, 2, 2);
|
|
m.ScaleAtPrepend (2, 2, 2, 2);
|
|
CheckMatrix (new Matrix (2, 0, 0, 2, 0, 0), m);
|
|
}
|
|
|
|
[Test]
|
|
public void ScalePrepend ()
|
|
{
|
|
Matrix m = Matrix.Identity;
|
|
|
|
m.ScalePrepend (5, 6);
|
|
CheckMatrix (new Matrix (5, 0, 0, 6, 0, 0), m);
|
|
|
|
m = new Matrix (1, 2, 2, 1, 3, 3);
|
|
m.ScalePrepend (5, 5);
|
|
CheckMatrix (new Matrix (5, 10, 10, 5, 3, 3), m);
|
|
}
|
|
|
|
[Test]
|
|
public void SetIdentity ()
|
|
{
|
|
Matrix m = new Matrix (5, 5, 5, 5, 5, 5);
|
|
m.SetIdentity ();
|
|
CheckMatrix (Matrix.Identity, m);
|
|
}
|
|
|
|
[Test]
|
|
public void Skew ()
|
|
{
|
|
Matrix m = Matrix.Identity;
|
|
|
|
m.Skew (10, 15);
|
|
CheckMatrix (new Matrix (1,
|
|
0.267949192431123,
|
|
0.176326980708465,
|
|
1, 0, 0), m);
|
|
|
|
m = new Matrix (1, 2, 2, 1, 3, 3);
|
|
m.Skew (10, 15);
|
|
CheckMatrix (new Matrix (1.35265396141693,
|
|
2.26794919243112,
|
|
2.17632698070847,
|
|
1.53589838486225,
|
|
3.52898094212539,
|
|
3.80384757729337), m);
|
|
}
|
|
|
|
[Test]
|
|
public void SkewPrepend ()
|
|
{
|
|
Matrix m = Matrix.Identity;
|
|
|
|
m.SkewPrepend (10, 15);
|
|
CheckMatrix (new Matrix (1,
|
|
0.267949192431123,
|
|
0.176326980708465,
|
|
1, 0, 0), m);
|
|
|
|
m = new Matrix (1, 2, 2, 1, 3, 3);
|
|
m.SkewPrepend (10, 15);
|
|
CheckMatrix (new Matrix (1.53589838486225,
|
|
2.26794919243112,
|
|
2.17632698070847,
|
|
1.35265396141693,
|
|
3, 3), m);
|
|
}
|
|
|
|
[Test]
|
|
public void ToStringTest ()
|
|
{
|
|
Matrix m = new Matrix (1, 2, 3, 4, 5, 6);
|
|
Assert.AreEqual ("1,2,3,4,5,6", m.ToString());
|
|
m = Matrix.Identity;
|
|
Assert.AreEqual ("Identity", m.ToString());
|
|
}
|
|
|
|
[Test]
|
|
public void PointTransform ()
|
|
{
|
|
Matrix m = new Matrix (2, 0, 0, 2, 4, 4);
|
|
|
|
Point p = new Point (5, 6);
|
|
|
|
Assert.AreEqual (new Point (14, 16), m.Transform (p));
|
|
|
|
Point[] ps = new Point[10];
|
|
for (int i = 0; i < ps.Length; i ++)
|
|
ps[i] = new Point (3 * i, 2 * i);
|
|
|
|
m.Transform (ps);
|
|
|
|
for (int i = 0; i < ps.Length; i ++)
|
|
Assert.AreEqual (m.Transform (new Point (3 * i, 2 * i)), ps[i]);
|
|
}
|
|
|
|
[Test]
|
|
public void VectorTransform ()
|
|
{
|
|
Matrix m = new Matrix (2, 0, 0, 2, 4, 4);
|
|
|
|
Vector p = new Vector (5, 6);
|
|
|
|
Assert.AreEqual (new Vector (10, 12), m.Transform (p));
|
|
|
|
Vector[] ps = new Vector[10];
|
|
for (int i = 0; i < ps.Length; i ++)
|
|
ps[i] = new Vector (3 * i, 2 * i);
|
|
|
|
m.Transform (ps);
|
|
|
|
for (int i = 0; i < ps.Length; i ++)
|
|
Assert.AreEqual (m.Transform (new Vector (3 * i, 2 * i)), ps[i]);
|
|
}
|
|
|
|
[Test]
|
|
public void Translate ()
|
|
{
|
|
Matrix m = new Matrix (1, 0, 0, 1, 0, 0);
|
|
m.Translate (5, 5);
|
|
CheckMatrix (new Matrix (1, 0, 0, 1, 5, 5), m);
|
|
|
|
m = new Matrix (2, 0, 0, 2, 0, 0);
|
|
m.Translate (5, 5);
|
|
CheckMatrix (new Matrix (2, 0, 0, 2, 5, 5), m);
|
|
}
|
|
|
|
[Test]
|
|
public void TranslatePrepend ()
|
|
{
|
|
Matrix m = new Matrix (1, 0, 0, 1, 0, 0);
|
|
m.TranslatePrepend (5, 5);
|
|
CheckMatrix (new Matrix (1, 0, 0, 1, 5, 5), m);
|
|
|
|
m = new Matrix (2, 0, 0, 2, 0, 0);
|
|
m.TranslatePrepend (5, 5);
|
|
CheckMatrix (new Matrix (2, 0, 0, 2, 10, 10), m);
|
|
}
|
|
|
|
}
|
|
}
|
|
|