/// <summary>
/// Applies a shear to the transform, either before or after this <see cref="AffineMatrix{T}"/>.
/// </summary>
/// <param name="shearVector">The vector used to compute the shear.</param>
/// <param name="order">The order to apply the transform in.</param>
public virtual void Shear(Vector shearVector, MatrixOperationOrder order)
{
Matrix shear = new Matrix(Format, RowCount, ColumnCount, new DoubleComponent(1));
MatrixProcessor.Shear(shear, shearVector);
Matrix result;
if (order == MatrixOperationOrder.Prepend)
{
if (Format == MatrixFormat.RowMajor)
{
result = MatrixProcessor.Multiply(shear, this);
}
else
{
result = MatrixProcessor.Multiply(this, shear);
}
}
else
{
if (Format == MatrixFormat.RowMajor)
{
result = MatrixProcessor.Multiply(this, shear);
}
else
{
result = MatrixProcessor.Multiply(shear, this);
}
}
MatrixProcessor.SetMatrix(result, this);
}
/// <summary>
/// Translates the affine transform by the given translation vector, in the order specified.
/// </summary>
/// <param name="translateVector">
/// A vector whose components will translate the
/// transform in the corresponding dimension.
/// </param>
/// <param name="order">The order to apply the transform in.</param>
public void Translate(Vector translateVector, MatrixOperationOrder order)
{
AffineMatrix translateMatrix = new AffineMatrix(Format, RowCount);
MatrixProcessor.Translate(translateMatrix, translateVector);
Matrix result;
if (Format == MatrixFormat.RowMajor)
{
if (order == MatrixOperationOrder.Append)
{
result = MatrixProcessor.Multiply(this, translateMatrix);
}
else
{
result = MatrixProcessor.Multiply(translateMatrix, this);
}
}
else
{
if (order == MatrixOperationOrder.Append)
{
result = MatrixProcessor.Multiply(translateMatrix, this);
}
else
{
result = MatrixProcessor.Multiply(this, translateMatrix);
}
}
MatrixProcessor.SetMatrix(result, this);
}
/// <summary>
/// Translates the affine transform by the given amount
/// in each dimension.
/// </summary>
/// <param name="amount">Amount to translate by.</param>
/// <param name="order">The order to apply the transform in.</param>
public void Translate(DoubleComponent amount, MatrixOperationOrder order)
{
Vector translateVector = new Vector(RowCount - 1);
for (Int32 i = 0; i < translateVector.ComponentCount; i++)
{
translateVector[i] = amount;
}
AffineMatrix translateMatrix = new AffineMatrix(Format, RowCount);
MatrixProcessor.Translate(translateMatrix, translateVector);
Matrix result;
if (order == MatrixOperationOrder.Append)
{
result = MatrixProcessor.Multiply(translateMatrix, this);
}
else
{
result = MatrixProcessor.Multiply(this, translateMatrix);
}
MatrixProcessor.SetMatrix(result, this);
}
/// <summary>
/// Creates an element-by-element copy of the matrix.
/// </summary>
public Matrix Clone()
{
Matrix clone = new Matrix(Format, RowCount, ColumnCount);
MatrixProcessor.SetMatrix(this, clone);
return(clone);
}
/// <summary>
/// Negates the values of a matrix.
/// </summary>
/// <param name="value">The matrix to negate.</param>
/// <returns>A negated matrix instance.</returns>
public static Matrix operator -(Matrix value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
return(MatrixProcessor.Negate(value));
}
/// <summary>
/// Scalar multiplication.
/// </summary>
public static Matrix operator *(Matrix lhs, DoubleComponent rhs)
{
if (lhs == null)
{
throw new ArgumentNullException("lhs");
}
return(MatrixProcessor.ScalarMultiply(lhs, rhs));
}
/// <summary>
/// Applies this transform to the given <paramref name="input"/> vector.
/// </summary>
/// <param name="input">Vector to transform.</param>
public void TransformVector(DoubleComponent[] input)
{
if (Format == MatrixFormat.RowMajor)
{
MatrixProcessor.Multiply(input, this);
}
else
{
MatrixProcessor.Multiply(this, input);
}
}
/// <summary>
/// Applies this transform to the given <paramref name="input"/> vectors.
/// </summary>
/// <param name="input">Set of vectors to transform.</param>
public IEnumerable <Vector> TransformVectors(IEnumerable <Vector> input)
{
if (Format == MatrixFormat.RowMajor)
{
return(MatrixProcessor.Multiply(input, this));
}
else
{
return(MatrixProcessor.Multiply(this, input));
}
}
/// <summary>
/// <see cref="Matrix"/> multiplication.
/// </summary>
public static Matrix operator *(Matrix lhs, Matrix rhs)
{
if (lhs == null)
{
throw new ArgumentNullException("lhs");
}
if (rhs == null)
{
throw new ArgumentNullException("rhs");
}
return(MatrixProcessor.Multiply(lhs, rhs));
}
///// <summary>
///// Applies this transform to the given <paramref name="input"/> matrix.
///// </summary>
///// <param name="input">Matrix to transform.</param>
///// <returns>The multiplication of this transform matrix with the input matrix,
///// with the transform on the left-hand side of the operation.</returns>
//public void TransformMatrix(DoubleComponent[][] input)
//{
// MatrixProcessor.Multiply(this, input);
//}
/// <summary>
/// Applies this transform to the given <paramref name="input"/> vector.
/// </summary>
/// <param name="input">Vector to transform.</param>
/// <returns>
/// The multiplication of this transform matrix with the input vector.
/// </returns>
public Vector TransformVector(Vector input)
{
DoubleComponent[] elements = new DoubleComponent[input.ComponentCount];
Array.Copy(input.Components, elements, input.ComponentCount);
if (Format == MatrixFormat.RowMajor)
{
MatrixProcessor.Multiply(elements, this);
}
else
{
MatrixProcessor.Multiply(this, elements);
}
return(new Vector(elements));
}
public AffineMatrix Multiply(AffineMatrix b)
{
return(new AffineMatrix(MatrixProcessor.Multiply(this, b)));
}
/// <summary>
/// Returns a transpose of the <see cref="Matrix"/>.
/// </summary>
/// <value>The rows-for-columns, columns-for-rows transpose of A.</value>
/// <returns>AT, the transpose of matrix A.</returns>
public Matrix Transpose()
{
return(MatrixProcessor.Transpose(this));
}
/// <summary>
/// Matrix multiplication.
/// </summary>
/// <param name="value">Matrix to multiply.</param>
/// <returns>For matrix A, (value)A.</returns>
public Matrix Multiply(Matrix value)
{
return(MatrixProcessor.Multiply(this, value));
}
/// <summary>
/// Scalar multiplication.
/// </summary>
/// <param name="value">Scalar to multiply.</param>
/// <returns>For matrix A, (value)A.</returns>
public Matrix Multiply(DoubleComponent value)
{
return(MatrixProcessor.ScalarMultiply(this, value));
}
/// <summary>
/// Returns a matrix which is the result of the instance minus the <paramref name="value"/>.
/// </summary>
/// <param name="value">The matrix to subtract.</param>
/// <returns>For matrix A, A - value.</returns>
public Matrix Subtract(Matrix value)
{
return(MatrixProcessor.Subtract(this, value));
}
/// <summary>
/// Returns a matrix which is the result of the instance plus the <paramref name="value"/>.
/// </summary>
/// <param name="value">The matrix to add.</param>
/// <returns>For matrix A, A + value.</returns>
public Matrix Add(Matrix value)
{
return(MatrixProcessor.Add(this, value));
}
/// <summary>
/// Rotates the affine transform around the given <paramref name="axis"/>.
/// </summary>
/// <param name="axis">The axis to rotate around.</param>
/// <param name="radians">Angle to rotate through.</param>
public virtual void RotateAlong(Vector axis, Double radians)
{
MatrixProcessor.Rotate(this, axis, radians);
}
public Vector Add(Vector b)
{
return(MatrixProcessor.Add(this, b));
}
public Vector Subtract(Vector b)
{
return(MatrixProcessor.Subtract(this, b));
}
/// <summary>
/// Returns a copy of the matrix with all the elements negated.
/// </summary>
/// <returns>For matrix A, -A.</returns>
public Matrix Negative()
{
return(MatrixProcessor.Negate(this));
}
