Beispiel #1
0
        /// <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);
        }
Beispiel #2
0
        /// <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);
        }
Beispiel #3
0
        /// <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);
        }
Beispiel #4
0
 /// <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);
     }
 }
Beispiel #5
0
 /// <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));
     }
 }
Beispiel #6
0
        /// <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));
        }
Beispiel #7
0
        ///// <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));
        }
Beispiel #8
0
 /// <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));
 }
Beispiel #9
0
 public AffineMatrix Multiply(AffineMatrix b)
 {
     return(new AffineMatrix(MatrixProcessor.Multiply(this, b)));
 }