/// <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>
/// 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));
}
/// <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));
}
public AffineMatrix Multiply(AffineMatrix b)
{
return(new AffineMatrix(MatrixProcessor.Multiply(this, b)));
}