private Matrix <double> GetAMatrix(double[] arguments)
{
Matrix <double> A;
double[] s = new double[5]; // 0..2m
MatrixDouble[][] m = new MatrixDouble[3][];
for (int i = 0; i < 3; i++)
{
m[i] = new MatrixDouble[3];
}
for (int i = 0; i < 5; i++)
{
double sum = 0.0;
for (int j = 0; j < arguments.Length; j++)
{
sum += IntPow(arguments[j], i);
}
s[i] = sum;
}
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
m[i][j] = new MatrixDouble(s[i + j]);
}
}
A = new Matrix <double>(m);
return(A);
}
public void MatrixDouble_ToString()
{
MatrixDouble m = CreateRandomMatrix(3, 3);
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Assert.DoesNotThrow(() => m.ToString());
}
/// <summary>
/// Calculates the ViewPortTransfrom for the Current Heading and ViewPortCenter.
/// Invalidates the ViewPort to schedule a redraw.
/// </summary>
protected virtual void UpdateViewPortTransform()
{
if (ViewPortTransform == null)
{
return;
}
double scaleFactor = ViewPortProjection.GetZoomFactor(ZoomLevel);
double w2 = ActualWidth / 2d;
double h2 = ActualHeight / 2d;
MatrixDouble vpCenterTranslation = MatrixDouble.CreateTranslation(w2, h2);
MatrixDouble scale = MatrixDouble.CreateScale(scaleFactor);
MatrixDouble mapCenterTranslation = MatrixDouble.CreateTranslation(-ViewPortCenter.X, -ViewPortCenter.Y);
double heading = Heading * Math.PI / 180.0;
Point center = new Point(ViewPortCenter.X, ViewPortCenter.Y);
MatrixDouble mapRotation = MatrixDouble.CreateRotation(heading, center);
MatrixDouble objectRotation = MatrixDouble.CreateRotation(heading);
ViewPortTransform.Matrix = (mapRotation * mapCenterTranslation * scale * vpCenterTranslation).ToXamlMatrix();
ScaleRotateTransform.Matrix = (objectRotation * scale).ToXamlMatrix();
ScaleTransform.Matrix = scale.ToXamlMatrix();
RotateTransform.Matrix = objectRotation.ToXamlMatrix();
TranslationTransform.Matrix = (mapCenterTranslation * vpCenterTranslation).ToXamlMatrix();
InvalidateArrange();
OnViewPortChangedEvent();
}
public virtual void MatrixDouble_Set()
{
MatrixDouble m = CreateRandomMatrix(2, 3);
MatrixDouble z = new MatrixDouble(2, 3);
m.Set(z);
for (uint c = 0; c < 2; c++)
{
for (uint r = 0; r < 2; r++)
{
Assert.AreEqual(0.0, m[c, r]);
}
}
m = CreateRandomMatrix(2, 3);
m.Set((IMatrix)z);
for (uint c = 0; c < 2; c++)
{
for (uint r = 0; r < 2; r++)
{
Assert.AreEqual(0.0, m[c, r]);
}
}
}
public void DoubleMatrix()
{
double[,] _m = new double[, ] {
{ 17, 21, 5, 8, 18, 5, 20, 19, 11, 7, 31, 7, 36, 15, 15, 27, 31, 3, 15, 2, 11, 30, 7, 34, 42 },
{ 36, 28, 0, 12, 31, 12, 29, 13, 31, 26, 27, 38, 7, 19, 0, 38, 15, 15, 16, 28, 37, 6, 34, 25, 42 },
{ 33, 22, 4, 10, 39, 31, 29, 27, 13, 11, 12, 30, 4, 8, 27, 39, 18, 18, 16, 10, 28, 16, 19, 11, 42 },
{ 3, 17, 27, 35, 14, 19, 36, 29, 33, 14, 18, 9, 7, 18, 13, 39, 36, 0, 24, 36, 7, 9, 33, 6, 42 },
{ 28, 16, 10, 19, 30, 24, 37, 16, 2, 32, 7, 22, 4, 34, 12, 34, 15, 22, 37, 29, 30, 18, 32, 39, 42 },
{ 4, 17, 13, 27, 32, 23, 4, 33, 23, 20, 7, 37, 9, 16, 39, 8, 17, 1, 6, 14, 11, 30, 35, 2, 42 },
{ 27, 30, 20, 24, 12, 3, 16, 9, 24, 10, 15, 12, 11, 9, 24, 19, 28, 14, 39, 24, 27, 15, 24, 38, 42 },
{ 23, 29, 12, 28, 12, 17, 28, 13, 21, 11, 0, 1, 2, 20, 20, 19, 3, 37, 12, 39, 1, 26, 36, 7, 42 },
{ 16, 27, 25, 36, 31, 11, 14, 12, 5, 22, 1, 23, 31, 28, 36, 6, 22, 1, 31, 39, 9, 22, 16, 8, 42 },
{ 33, 19, 20, 29, 2, 25, 37, 36, 32, 4, 11, 25, 32, 31, 21, 10, 36, 27, 36, 20, 19, 37, 28, 15, 42 },
{ 0, 5, 17, 39, 35, 37, 38, 34, 10, 17, 3, 12, 30, 25, 9, 20, 24, 4, 31, 26, 16, 11, 14, 30, 42 },
{ 19, 20, 2, 21, 26, 36, 29, 35, 30, 5, 28, 36, 8, 38, 1, 34, 6, 17, 14, 14, 27, 9, 20, 11, 42 },
{ 17, 15, 36, 14, 6, 2, 39, 29, 31, 26, 19, 15, 34, 17, 7, 14, 28, 8, 21, 25, 36, 13, 11, 25, 42 },
{ 2, 36, 19, 38, 37, 39, 2, 10, 39, 31, 3, 10, 39, 14, 28, 28, 5, 39, 5, 21, 18, 26, 0, 29, 42 },
{ 9, 0, 26, 19, 28, 35, 15, 4, 3, 10, 11, 10, 22, 0, 31, 31, 24, 9, 15, 3, 13, 37, 14, 13, 42 },
{ 19, 32, 19, 36, 8, 30, 7, 16, 36, 29, 28, 36, 13, 22, 21, 4, 16, 38, 6, 29, 2, 18, 5, 5, 42 },
{ 7, 13, 37, 9, 10, 36, 15, 12, 25, 12, 0, 36, 16, 18, 36, 13, 3, 35, 14, 32, 12, 35, 18, 1, 42 },
{ 27, 10, 27, 15, 30, 24, 11, 0, 26, 13, 29, 34, 32, 37, 5, 39, 14, 15, 10, 0, 21, 25, 28, 37, 42 },
{ 2, 33, 26, 7, 4, 12, 33, 12, 35, 36, 21, 0, 9, 0, 22, 1, 1, 0, 9, 2, 28, 2, 21, 5, 42 },
{ 29, 14, 18, 36, 24, 17, 19, 2, 21, 29, 13, 37, 38, 3, 35, 13, 20, 16, 38, 36, 15, 5, 30, 13, 42 },
{ 33, 9, 38, 21, 15, 26, 9, 39, 11, 20, 18, 30, 34, 36, 28, 17, 16, 18, 18, 19, 27, 25, 2, 38, 42 }
};
MatrixDouble dM = new MatrixDouble(_m);
dM.GaussElim();
}
public void MatrixDouble_Constructor5_Exceptions()
{
// ReSharper disable once NotAccessedVariable
MatrixDouble m;
Assert.Throws <ArgumentNullException>(() => m = new MatrixDouble((IMatrix)null));
}
public void MatrixDouble_Constructor1_Exceptions()
{
// ReSharper disable once NotAccessedVariable
MatrixDouble m;
Assert.Throws <ArgumentException>(() => m = new MatrixDouble(0, 2));
Assert.Throws <ArgumentException>(() => m = new MatrixDouble(2, 0));
}
public void MatrixDouble_Constructor3()
{
MatrixDouble m = CreateRandomMatrix(3, 3);
AssertComplement(m, 0, 0);
AssertComplement(m, 1, 2);
AssertComplement(m, 2, 1);
}
public void MatrixDouble_Transpose()
{
MatrixDouble m = CreateRandomMatrix(2, 3);
MatrixDouble t = m.Transpose();
Assert.AreEqual(m.Width, t.Height);
Assert.AreEqual(m.Height, t.Width);
}
public void MatrixDouble_Clone()
{
MatrixDouble m = CreateRandomMatrix(2, 2);
MatrixDouble c = null;
Assert.DoesNotThrow(() => c = m.Clone());
Assert.AreNotSame(m, c);
Assert.AreEqual(m.GetType(), c.GetType(), "Clone() mast return the same matrix type");
}
public void MatrixDouble_EqualsObject()
{
MatrixDouble m = CreateRandomMatrix(3, 3);
Assert.IsTrue(m.Equals((object)m));
Assert.IsFalse(m.Equals((object)null));
// ReSharper disable once SuspiciousTypeConversion.Global
Assert.IsFalse(m.Equals(1.0f));
}
public void Matrix_SetIdentity()
{
MatrixDouble m = CreateRandomMatrix(3, 3);
Assert.IsFalse(m.IsIdentity());
m.SetIdentity();
Assert.IsTrue(m.IsIdentity());
}
public void SizeConstructor()
{
const int sizeRows = 10, sizeColumns = 5;
var matrix = new MatrixDouble(sizeRows, sizeColumns);
Assert.AreEqual(sizeRows, matrix.Rows);
Assert.AreEqual(sizeColumns, matrix.Columns);
}
public void MatrixDouble_OperatorAdd_Exceptions()
{
// ReSharper disable once NotAccessedVariable
MatrixDouble m = CreateRandomMatrix(2, 2), r;
Assert.Throws <ArgumentNullException>(() => r = m + null);
Assert.Throws <ArgumentNullException>(() => r = null + m);
Assert.Throws <ArgumentException>(() => r = m + new MatrixDouble(1, 2));
Assert.Throws <ArgumentException>(() => r = m + new MatrixDouble(2, 1));
}
public void MatrixDouble_Constructor3_Exceptions()
{
// ReSharper disable once NotAccessedVariable
MatrixDouble m;
Assert.Throws <ArgumentNullException>(() => m = new MatrixDouble(null, 0, 0));
Assert.Throws <ArgumentException>(() => m = new MatrixDouble(new MatrixDouble(1, 1), 0, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => m = new MatrixDouble(new MatrixDouble(2, 2), 2, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => m = new MatrixDouble(new MatrixDouble(2, 2), 0, 2));
}
public void MatrixDouble_Accessor_Exceptions()
{
MatrixDouble m = CreateRandomMatrix(2, 2);
// ReSharper disable once NotAccessedVariable
double c;
Assert.Throws <ArgumentException>(() => c = m[2, 0]);
Assert.Throws <ArgumentException>(() => c = m[0, 2]);
Assert.Throws <ArgumentException>(() => m[2, 0] = double.NaN);
Assert.Throws <ArgumentException>(() => m[0, 2] = double.NaN);
}
public void MatrixDouble_GetHashCode()
{
MatrixDouble m = CreateRandomMatrix(3, 3);
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Assert.DoesNotThrow(() => m.GetHashCode());
MatrixDouble c = m.Clone();
Assert.AreNotEqual(m.GetHashCode(), c.GetHashCode());
}
public void MatrixDouble_Constructor2_Exceptions()
{
// ReSharper disable once NotAccessedVariable
MatrixDouble m;
Assert.Throws <ArgumentException>(() => m = new MatrixDouble(0, 2, null));
Assert.Throws <ArgumentException>(() => m = new MatrixDouble(2, 0, null));
Assert.Throws <ArgumentNullException>(() => m = new MatrixDouble(2, 2, null));
Assert.Throws <ArgumentException>(() => m = new MatrixDouble(2, 2, 1.0f, 2.0f, 3.0f));
Assert.DoesNotThrow(() => m = new MatrixDouble(2, 2, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f));
}
public CartesianPoint GetCartesianFromPoint(Point point)
{
double zoomFactor = 1 / ViewPortProjection.GetZoomFactor(ZoomLevel);
double x = (point.X - RenderSize.Width / 2d) * zoomFactor + ViewPortCenter.X;
double y = (point.Y - RenderSize.Height / 2d) * zoomFactor + ViewPortCenter.Y;
MatrixDouble reverseRotationMatrix = MatrixDouble.CreateRotation(-TransformHelper.DegToRad(Heading), ViewPortCenter.ToPoint());
return(new CartesianPoint(reverseRotationMatrix.Transform(new Point(x, y))));
}
public void MatrixDouble_ToArray(uint w, uint h)
{
MatrixDouble m = CreateRandomMatrix(w, h);
double[] mArray = m.ToArray();
Assert.IsNotNull(mArray);
Assert.AreEqual(w * h, (uint)mArray.Length);
Assert.AreNotSame(m.ToArray(), mArray);
CollectionAssert.AreEqual(m.Buffer, mArray);
}
public void Matrix_GetInverseMatrix(uint size)
{
MatrixDouble m = CreateRandomMatrix(size, size);
MatrixDouble i = m.GetInverseMatrix();
Assert.AreEqual(m.Width, i.Width);
Assert.AreEqual(m.Height, i.Height);
MatrixDouble r = m * i;
Assert.IsTrue(r.IsIdentity(1e-4));
}
private void OnManipulationStarted(object sender, ManipulationStartedRoutedEventArgs e)
{
_headingBeforeManipulation = _map.Heading;
_zoomFactorBeforeManipulation = _map.ViewPortProjection.GetZoomFactor(_map.ZoomLevel);
_viewPortCenterBeforeManipulation = _map.ViewPortCenter.ToPoint();
_reverseRotationMatrix = MatrixDouble.CreateRotation(-TransformHelper.DegToRad(_headingBeforeManipulation), _viewPortCenterBeforeManipulation);
_manipulationStartPoint = _map.GetCartesianFromPoint(e.Position).ToPoint();
e.Handled = true;
}
protected virtual void UpdateZoomOnlyManipulation(double zoomDelta, Point position)
{
Point zoomCenter = _map.GetCartesianFromPoint(position).ToPoint();
double oldZoomLevel = _map.ZoomLevel;
double newZoomLevel = oldZoomLevel + zoomDelta;
double scaleFactor = 1 / (_map.ViewPortProjection.GetZoomFactor(newZoomLevel) / _map.ViewPortProjection.GetZoomFactor(oldZoomLevel));
MatrixDouble scale = MatrixDouble.CreateScale(scaleFactor, zoomCenter);
_map.ViewPortCenter = new CartesianPoint(scale.Transform(_map.ViewPortCenter.ToPoint()));
_map.ZoomLevel = newZoomLevel;
}
public virtual void MatrixDouble_Set_Exceptions()
{
MatrixDouble m = CreateRandomMatrix(2, 3);
Assert.Throws <ArgumentNullException>(() => m.Set(null));
Assert.Throws <ArgumentNullException>(() => m.Set((IMatrix)null));
Assert.Throws <ArgumentException>(() => m.Set(new MatrixDouble(3, 3)));
Assert.Throws <ArgumentException>(() => m.Set((IMatrix) new MatrixDouble(3, 3)));
Assert.Throws <ArgumentException>(() => m.Set(new MatrixDouble(2, 2)));
Assert.Throws <ArgumentException>(() => m.Set((IMatrix) new MatrixDouble(2, 2)));
}
protected virtual void UpdateManipulation(ManipulationDelta delta)
{
double newHeading = _headingBeforeManipulation;
double newZoomFact = _zoomFactorBeforeManipulation * delta.Scale;
MatrixDouble m = MatrixDouble.Identity;
if (TranslationEnabled)
{
m = MatrixDouble.CreateTranslation(-(delta.Translation.X / _zoomFactorBeforeManipulation), -(delta.Translation.Y / _zoomFactorBeforeManipulation));
m = m * _reverseRotationMatrix;
}
if (ZoomEnabled)
{
double scaleFactor = _zoomFactorBeforeManipulation / newZoomFact;
m = m * MatrixDouble.CreateScale(scaleFactor, _manipulationStartPoint);
}
if ((delta.Rotation != 0.0) && RotationEnabled)
{
//Add the Rotation from the Manipulation
MatrixDouble rotation = MatrixDouble.CreateRotation(-TransformHelper.DegToRad(delta.Rotation), _manipulationStartPoint);
m = m * rotation;
newHeading = (_headingBeforeManipulation + delta.Rotation) % 360;
if (newHeading < 0)
{
newHeading += 360;
}
}
double zoomLevel = _map.ViewPortProjection.GetZoomLevel(newZoomFact);
CartesianPoint viewPortCenter = new CartesianPoint(m.Transform(_viewPortCenterBeforeManipulation));
if (Update != null)
{
TouchMapEventArgs eventArgs = new TouchMapEventArgs();
eventArgs.Heading = newHeading;
eventArgs.ZoomLevel = zoomLevel;
eventArgs.ViewPortCenter = viewPortCenter;
OnUpdate(eventArgs);
}
if (AutoUpdateMap)
{
_map.Heading = newHeading;
_map.ZoomLevel = zoomLevel;
_map.ViewPortCenter = viewPortCenter;
}
}
public void MatrixDouble_GetRow()
{
MatrixDouble m = CreateRandomMatrix(2, 2);
double[] c;
c = m.GetRow(0);
Assert.IsNotNull(c);
Assert.AreEqual(2, c.Length);
c = m.GetRow(1);
Assert.IsNotNull(c);
Assert.AreEqual(2, c.Length);
}
public virtual void MatrixDouble_SetVoid()
{
MatrixDouble m = CreateRandomMatrix(2, 3);
m.SetVoid();
for (uint c = 0; c < 2; c++)
{
for (uint r = 0; r < 2; r++)
{
Assert.AreEqual(0.0f, m[c, r]);
}
}
}
public void MatrixDouble_OperatorAdd()
{
MatrixDouble m = new MatrixDouble(2, 2, +1.0, -0.5, +2.0, -1.5);
MatrixDouble n = new MatrixDouble(2, 2, -1.0, +0.5, -2.0, +1.5);
MatrixDouble o = m + n;
for (uint c = 0; c < m.Width; c++)
{
for (uint r = 0; r < m.Height; r++)
{
Assert.AreEqual(0.0f, o[c, r]);
}
}
}
public void MatrixDouble_Constructor4(uint w, uint h)
{
MatrixDouble m = CreateRandomMatrix(w, h);
MatrixDouble cm = new MatrixDouble(m);
Assert.AreEqual(m.Width, cm.Width);
Assert.AreEqual(m.Height, cm.Height);
for (uint c = 0; c < w; c++)
{
for (uint r = 0; r < h; r++)
{
Assert.AreEqual(m[c, r], cm[c, r]);
}
}
}
public void MatrixDouble_Constructor1(uint w, uint h)
{
MatrixDouble m = new MatrixDouble(w, h);
Assert.AreEqual(w, m.Width);
Assert.AreEqual(h, m.Height);
for (uint c = 0; c < w; c++)
{
for (uint r = 0; r < h; r++)
{
Assert.AreEqual(0.0, m[c, r]);
}
}
}
/// <summary>
/// Set uniform state variable (mat3 variable).
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> used for operations.
/// </param>
/// <param name="uniformName">
/// A <see cref="String"/> that specify the variable name in the shader source.
/// </param>
/// <param name="m">
/// A <see cref="MatrixDouble"/> holding the uniform variabile data.
/// </param>
public void SetUniform(GraphicsContext ctx, string uniformName, MatrixDouble m)
{
if (ctx == null)
throw new ArgumentNullException("ctx");
if (m == null)
throw new ArgumentNullException("m");
UniformBinding uniform = GetUniform(uniformName);
CheckProgramBinding();
switch (uniform.UniformType) {
case ShaderUniformType.Mat2x2:
if ((m.Width != 2) || (m.Height != 2))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix2(uniform.Location, 1, false, m.MatrixBuffer);
break;
case ShaderUniformType.Mat2x3:
if ((m.Width != 2) || (m.Height != 3))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix2x3(uniform.Location, 1, false, m.MatrixBuffer);
break;
case ShaderUniformType.Mat2x4:
if ((m.Width != 2) || (m.Height != 4))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix2x4(uniform.Location, 1, false, m.MatrixBuffer);
break;
case ShaderUniformType.Mat3x2:
if ((m.Width != 3) || (m.Height != 2))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix3x2(uniform.Location, 1, false, m.MatrixBuffer);
break;
case ShaderUniformType.Mat3x3:
if ((m.Width != 3) || (m.Height != 3))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix3(uniform.Location, 1, false, m.MatrixBuffer);
break;
case ShaderUniformType.Mat3x4:
if ((m.Width != 3) || (m.Height != 4))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix3x4(uniform.Location, 1, false, m.MatrixBuffer);
break;
case ShaderUniformType.Mat4x2:
if ((m.Width != 4) || (m.Height != 2))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix4x2(uniform.Location, 1, false, m.MatrixBuffer);
break;
case ShaderUniformType.Mat4x3:
if ((m.Width != 4) || (m.Height != 3))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix4x3(uniform.Location, 1, false, m.MatrixBuffer);
break;
case ShaderUniformType.Mat4x4:
if ((m.Width != 4) || (m.Height != 4))
throw new ArgumentException("matrix size mismatch");
Gl.UniformMatrix4(uniform.Location, 1, false, m.MatrixBuffer);
break;
default:
throw new NotSupportedException(String.Format("uniform type {0} not assignable from Matrix{1}x{2}", uniform.UniformType, m.Width, m.Height));
}
}