gimp/libgimpmath/gimpmatrix.c

418 lines
8.9 KiB
C

/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
*
* gimpmatrix.c
* Copyright (C) 1998 Jay Cox <jaycox@earthlink.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <string.h> /* memcmp */
#include <glib.h>
#include "gimpmath.h"
#define EPSILON 1e-6
/**
* gimp_matrix3_transform_point:
* @matrix: The transformation matrix.
* @x: The source X coordinate.
* @y: The source Y coordinate.
* @newx: The transformed X coordinate.
* @newy: The transformed Y coordinate.
*
* Transforms a point in 2D as specified by the transformation matrix.
*/
void
gimp_matrix3_transform_point (GimpMatrix3 matrix,
gdouble x,
gdouble y,
gdouble *newx,
gdouble *newy)
{
gdouble w;
w = matrix[2][0]*x + matrix[2][1]*y + matrix[2][2];
if (w == 0.0)
w = 1.0;
else
w = 1.0/w;
*newx = (matrix[0][0]*x + matrix[0][1]*y + matrix[0][2])*w;
*newy = (matrix[1][0]*x + matrix[1][1]*y + matrix[1][2])*w;
}
/**
* gimp_matrix3_mult:
* @matrix1: The first input matrix.
* @matrix2: The second input matrix which will be oeverwritten ba the result.
*
* Multiplies two matrices and puts the result into the second one.
*/
void
gimp_matrix3_mult (GimpMatrix3 matrix1,
GimpMatrix3 matrix2)
{
gint i, j;
GimpMatrix3 tmp;
gdouble t1, t2, t3;
for (i = 0; i < 3; i++)
{
t1 = matrix1[i][0];
t2 = matrix1[i][1];
t3 = matrix1[i][2];
for (j = 0; j < 3; j++)
{
tmp[i][j] = t1 * matrix2[0][j];
tmp[i][j] += t2 * matrix2[1][j];
tmp[i][j] += t3 * matrix2[2][j];
}
}
/* put the results in matrix2 */
memcpy (&matrix2[0][0], &tmp[0][0], sizeof (GimpMatrix3));
}
/**
* gimp_matrix3_identity:
* @matrix: A matrix.
*
* Sets the matrix to the identity matrix.
*/
void
gimp_matrix3_identity (GimpMatrix3 matrix)
{
static GimpMatrix3 identity = { { 1.0, 0.0, 0.0 },
{ 0.0, 1.0, 0.0 },
{ 0.0, 0.0, 1.0 } };
memcpy (&matrix[0][0], &identity[0][0], sizeof (GimpMatrix3));
}
/**
* gimp_matrix3_translate:
* @matrix: The matrix that is to be translated.
* @x: Translation in X direction.
* @y: Translation in Y direction.
*
* Translates the matrix by x and y.
*/
void
gimp_matrix3_translate (GimpMatrix3 matrix,
gdouble x,
gdouble y)
{
gdouble g, h, i;
g = matrix[2][0];
h = matrix[2][1];
i = matrix[2][2];
matrix[0][0] += x * g;
matrix[0][1] += x * h;
matrix[0][2] += x * i;
matrix[1][0] += y * g;
matrix[1][1] += y * h;
matrix[1][2] += y * i;
}
/**
* gimp_matrix3_scale:
* @matrix: The matrix that is to be scaled.
* @x: X scale factor.
* @y: Y scale factor.
*
* Scales the matrix by x and y
*/
void
gimp_matrix3_scale (GimpMatrix3 matrix,
gdouble x,
gdouble y)
{
matrix[0][0] *= x;
matrix[0][1] *= x;
matrix[0][2] *= x;
matrix[1][0] *= y;
matrix[1][1] *= y;
matrix[1][2] *= y;
}
/**
* gimp_matrix3_rotate:
* @matrix: The matrix that is to be rotated.
* @theta: The angle of rotation (in radians).
*
* Rotates the matrix by theta degrees.
*/
void
gimp_matrix3_rotate (GimpMatrix3 matrix,
gdouble theta)
{
gdouble t1, t2;
gdouble cost, sint;
cost = cos (theta);
sint = sin (theta);
t1 = matrix[0][0];
t2 = matrix[1][0];
matrix[0][0] = cost * t1 - sint * t2;
matrix[1][0] = sint * t1 + cost * t2;
t1 = matrix[0][1];
t2 = matrix[1][1];
matrix[0][1] = cost * t1 - sint * t2;
matrix[1][1] = sint*t1 + cost*t2;
t1 = matrix[0][2];
t2 = matrix[1][2];
matrix[0][2] = cost*t1 - sint*t2;
matrix[1][2] = sint*t1 + cost*t2;
}
/**
* gimp_matrix3_xshear:
* @matrix: The matrix that is to be sheared.
* @amount: X shear amount.
*
* Shears the matrix in the X direction.
*/
void
gimp_matrix3_xshear (GimpMatrix3 matrix,
gdouble amount)
{
matrix[0][0] += amount * matrix[1][0];
matrix[0][1] += amount * matrix[1][1];
matrix[0][2] += amount * matrix[1][2];
}
/**
* gimp_matrix3_yshear:
* @matrix: The matrix that is to be sheared.
* @amount: Y shear amount.
*
* Shears the matrix in the Y direction.
*/
void
gimp_matrix3_yshear (GimpMatrix3 matrix,
gdouble amount)
{
matrix[1][0] += amount * matrix[0][0];
matrix[1][1] += amount * matrix[0][1];
matrix[1][2] += amount * matrix[0][2];
}
/**
* gimp_matrix3_determinant:
* @matrix: The input matrix.
*
* Calculates the determinant of the given matrix.
*
* Returns: The determinant.
*/
gdouble
gimp_matrix3_determinant (GimpMatrix3 matrix)
{
gdouble determinant;
determinant =
matrix[0][0] * (matrix[1][1]*matrix[2][2] - matrix[1][2]*matrix[2][1]);
determinant -=
matrix[1][0] * (matrix[0][1]*matrix[2][2] - matrix[0][2]*matrix[2][1]);
determinant +=
matrix[2][0] * (matrix[0][1]*matrix[1][2] - matrix[0][2]*matrix[1][1]);
return determinant;
}
/**
* gimp_matrix3_invert:
* @matrix: The matrix that is to be inverted.
* @matrix_inv: A matrix the inverted matrix should be written into.
*
* Inverts the given matrix.
*/
void
gimp_matrix3_invert (GimpMatrix3 matrix,
GimpMatrix3 matrix_inv)
{
gdouble det_1;
det_1 = gimp_matrix3_determinant (matrix);
if (det_1 == 0.0)
return;
det_1 = 1.0 / det_1;
matrix_inv[0][0] =
(matrix[1][1] * matrix[2][2] - matrix[1][2] * matrix[2][1]) * det_1;
matrix_inv[1][0] =
- (matrix[1][0] * matrix[2][2] - matrix[1][2] * matrix[2][0]) * det_1;
matrix_inv[2][0] =
(matrix[1][0] * matrix[2][1] - matrix[1][1] * matrix[2][0]) * det_1;
matrix_inv[0][1] =
- (matrix[0][1] * matrix[2][2] - matrix[0][2] * matrix[2][1] ) * det_1;
matrix_inv[1][1] =
(matrix[0][0] * matrix[2][2] - matrix[0][2] * matrix[2][0]) * det_1;
matrix_inv[2][1] =
- (matrix[0][0] * matrix[2][1] - matrix[0][1] * matrix[2][0]) * det_1;
matrix_inv[0][2] =
(matrix[0][1] * matrix[1][2] - matrix[0][2] * matrix[1][1]) * det_1;
matrix_inv[1][2] =
- (matrix[0][0] * matrix[1][2] - matrix[0][2] * matrix[1][0]) * det_1;
matrix_inv[2][2] =
(matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]) * det_1;
}
/**
* gimp_matrix3_duplicate:
* @src: The source matrix.
* @target: The destination matrix.
*
* Copies the source matrix to the destination matrix.
*/
void
gimp_matrix3_duplicate (GimpMatrix3 src,
GimpMatrix3 target)
{
memcpy (&target[0][0], &src[0][0], sizeof (GimpMatrix3));
}
/* functions to test for matrix properties */
/**
* gimp_matrix3_is_diagonal:
* @matrix: The matrix that is to be tested.
*
* Checks if the given matrix is diagonal.
*
* Returns: TRUE if the matrix is diagonal.
*/
gboolean
gimp_matrix3_is_diagonal (GimpMatrix3 matrix)
{
gint i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
if (i != j && fabs (matrix[i][j]) > EPSILON)
return FALSE;
}
}
return TRUE;
}
/**
* gimp_matrix3_is_identity:
* @matrix: The matrix that is to be tested.
*
* Checks if the given matrix is the identity matrix.
*
* Returns: TRUE if the matrix is the identity matrix.
*/
gboolean
gimp_matrix3_is_identity (GimpMatrix3 matrix)
{
gint i,j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
if (i == j)
{
if (fabs (matrix[i][j] - 1.0) > EPSILON)
return FALSE;
}
else
{
if (fabs (matrix[i][j]) > EPSILON)
return FALSE;
}
}
}
return TRUE;
}
/* Check if we'll need to interpolate when applying this matrix.
This function returns TRUE if all entries of the upper left
2x2 matrix are either 0 or 1
*/
/**
* gimp_matrix3_is_simple:
* @matrix: The matrix that is to be tested.
*
* Checks if we'll need to interpolate when applying this matrix as
* a transformation.
*
* Returns: TRUE if all entries of the upper left 2x2 matrix are either
* 0 or 1
*/
gboolean
gimp_matrix3_is_simple (GimpMatrix3 matrix)
{
gdouble absm;
gint i, j;
for (i = 0; i < 2; i++)
{
for (j = 0; j < 2; j++)
{
absm = fabs (matrix[i][j]);
if (absm > EPSILON && fabs (absm - 1.0) > EPSILON)
return FALSE;
}
}
return TRUE;
}
void
gimp_matrix4_to_deg (GimpMatrix4 matrix,
gdouble *a,
gdouble *b,
gdouble *c)
{
*a = 180 * (asin (matrix[1][0]) / G_PI_2);
*b = 180 * (asin (matrix[2][0]) / G_PI_2);
*c = 180 * (asin (matrix[2][1]) / G_PI_2);
}