From 7512a83ab9b953ec01a00987f35ce1e9c213aac8 Mon Sep 17 00:00:00 2001 From: Sven Neumann Date: Sun, 6 Feb 2000 22:45:55 +0000 Subject: [PATCH] documented gimpmatrix --Sven --- ChangeLog | 5 + devel-docs/ChangeLog | 8 + devel-docs/libgimp/libgimp-decl.txt | 36 +- devel-docs/libgimp/tmpl/gimpcolorspace.sgml | 38 --- devel-docs/libgimp/tmpl/gimpmatrix.sgml | 60 ++-- devel-docs/libgimp/tmpl/gimpmenu.sgml | 6 - libgimp/gimpmatrix.c | 352 ++++++++++++++------ libgimp/gimpmatrix.h | 44 ++- 8 files changed, 343 insertions(+), 206 deletions(-) diff --git a/ChangeLog b/ChangeLog index 4f47ac831c..35e14556d5 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +Sun Feb 6 23:45:09 CET 2000 Sven Neumann + + * libgimp/gimpmatrix.[ch]: use g* types and name the parameters + in the header. + Sun Feb 6 22:18:24 CET 2000 Sven Neumann * libgimp/gimpexport.[ch]: use an enum instead of defines diff --git a/devel-docs/ChangeLog b/devel-docs/ChangeLog index 765e53c09d..b3fdbd8a18 100644 --- a/devel-docs/ChangeLog +++ b/devel-docs/ChangeLog @@ -1,3 +1,11 @@ +Sun Feb 6 23:44:17 CET 2000 Sven Neumann + + * devel-docs/libgimp/libgimp-decl.txt + * devel-docs/libgimp/tmpl/gimpmatrix.sgml: documented gimpmatrix + + * devel-docs/libgimp/tmpl/gimpcolorspace.sgml + * devel-docs/libgimp/tmpl/gimpmenu.sgml: cleanup + Sun Feb 6 22:15:20 CET 2000 Sven Neumann * libgimp/.cvsignore diff --git a/devel-docs/libgimp/libgimp-decl.txt b/devel-docs/libgimp/libgimp-decl.txt index 21f94cdc7f..78bf5801e1 100644 --- a/devel-docs/libgimp/libgimp-decl.txt +++ b/devel-docs/libgimp/libgimp-decl.txt @@ -2549,72 +2549,72 @@ typedef double GimpMatrix[3][3]; gimp_matrix_transform_point void -GimpMatrix, double, double,double *, double * +GimpMatrix matrix,gdouble x,gdouble y,gdouble *newx,gdouble *newy gimp_matrix_mult void -GimpMatrix, GimpMatrix +GimpMatrix matrix1,GimpMatrix matrix2 gimp_matrix_identity void -GimpMatrix +GimpMatrix matrix gimp_matrix_translate void -GimpMatrix, double, double +GimpMatrix matrix,gdouble x,gdouble y gimp_matrix_scale void -GimpMatrix, double, double +GimpMatrix matrix,gdouble x,gdouble y gimp_matrix_rotate void -GimpMatrix, double +GimpMatrix matrix,gdouble theta gimp_matrix_xshear void -GimpMatrix, double +GimpMatrix matrix,gdouble amount gimp_matrix_yshear void -GimpMatrix, double +GimpMatrix matrix,gdouble amount gimp_matrix_determinant -double -GimpMatrix +gdouble +GimpMatrix matrix gimp_matrix_invert void -GimpMatrix m, GimpMatrix m_inv +GimpMatrix matrix,GimpMatrix matrix_inv gimp_matrix_duplicate void -GimpMatrix src, GimpMatrix target +GimpMatrix src,GimpMatrix target gimp_matrix_is_diagonal -int -GimpMatrix m +gboolean +GimpMatrix matrix gimp_matrix_is_identity -int -GimpMatrix m +gboolean +GimpMatrix matrix gimp_matrix_is_simple -int -GimpMatrix m +gboolean +GimpMatrix matrix PARASITE_PERSISTENT diff --git a/devel-docs/libgimp/tmpl/gimpcolorspace.sgml b/devel-docs/libgimp/tmpl/gimpcolorspace.sgml index e82d837001..d01eb8eb7e 100644 --- a/devel-docs/libgimp/tmpl/gimpcolorspace.sgml +++ b/devel-docs/libgimp/tmpl/gimpcolorspace.sgml @@ -22,10 +22,6 @@ gimpcolorspace @red: @green: @blue: - -@Param1: -@Param2: -@Param3: @@ -36,10 +32,6 @@ gimpcolorspace @hue: @saturation: @value: - -@Param1: -@Param2: -@Param3: @@ -50,10 +42,6 @@ gimpcolorspace @red: @green: @blue: - -@Param1: -@Param2: -@Param3: @@ -65,10 +53,6 @@ gimpcolorspace @green: @blue: @Returns: - -@Varargs: -@Varargs: -@Varargs: @@ -79,10 +63,6 @@ gimpcolorspace @hue: @lightness: @saturation: - -@Param1: -@Param2: -@Param3: @@ -93,10 +73,6 @@ gimpcolorspace @red: @green: @blue: - -@Param1: -@Param2: -@Param3: @@ -107,10 +83,6 @@ gimpcolorspace @hue: @saturation: @value: - -@Param1: -@Param2: -@Param3: @@ -122,11 +94,6 @@ gimpcolorspace @red: @green: @blue: - -@Param1: -@Param2: -@Param3: -@Param4: @@ -138,11 +105,6 @@ gimpcolorspace @hue: @saturation: @value: - -@Param1: -@Param2: -@Param3: -@Param4: diff --git a/devel-docs/libgimp/tmpl/gimpmatrix.sgml b/devel-docs/libgimp/tmpl/gimpmatrix.sgml index 83cb2cae42..a4155766b7 100644 --- a/devel-docs/libgimp/tmpl/gimpmatrix.sgml +++ b/devel-docs/libgimp/tmpl/gimpmatrix.sgml @@ -2,11 +2,15 @@ gimpmatrix - +Utilities to set up and manipulate 3x3 transformation matrices. - +When doing image manipulation you will often need 3x3 transformation +matrices that define translation, rotation, scaling, shearing and +arbitrary perspective transformations using a 3x3 matrix. Here you'll +find a set of utility functions to set up those matrices and to perform +basic matrix manipulations and tests. @@ -25,11 +29,11 @@ gimpmatrix -@Param1: -@Param2: -@Param3: -@Param4: -@Param5: +@matrix: +@x: +@y: +@newx: +@newy: @@ -37,8 +41,8 @@ gimpmatrix -@Param1: -@Param2: +@matrix1: +@matrix2: @@ -46,7 +50,7 @@ gimpmatrix -@Param1: +@matrix: @@ -54,9 +58,9 @@ gimpmatrix -@Param1: -@Param2: -@Param3: +@matrix: +@x: +@y: @@ -64,9 +68,9 @@ gimpmatrix -@Param1: -@Param2: -@Param3: +@matrix: +@x: +@y: @@ -74,8 +78,8 @@ gimpmatrix -@Param1: -@Param2: +@matrix: +@theta: @@ -83,8 +87,8 @@ gimpmatrix -@Param1: -@Param2: +@matrix: +@amount: @@ -92,8 +96,8 @@ gimpmatrix -@Param1: -@Param2: +@matrix: +@amount: @@ -101,7 +105,7 @@ gimpmatrix -@Param1: +@matrix: @Returns: @@ -110,8 +114,8 @@ gimpmatrix -@m: -@m_inv: +@matrix: +@matrix_inv: @@ -128,7 +132,7 @@ gimpmatrix -@m: +@matrix: @Returns: @@ -137,7 +141,7 @@ gimpmatrix -@m: +@matrix: @Returns: @@ -146,7 +150,7 @@ gimpmatrix -@m: +@matrix: @Returns: diff --git a/devel-docs/libgimp/tmpl/gimpmenu.sgml b/devel-docs/libgimp/tmpl/gimpmenu.sgml index 989f6f1608..5fd86f451d 100644 --- a/devel-docs/libgimp/tmpl/gimpmenu.sgml +++ b/devel-docs/libgimp/tmpl/gimpmenu.sgml @@ -48,8 +48,6 @@ gimpmenu @mask_data: @dialog_closing: @user_data: - -@Param1: @@ -64,8 +62,6 @@ gimpmenu @mask_data: @dialog_closing: @user_data: - -@Param1: @@ -78,8 +74,6 @@ gimpmenu @grad_data: @dialog_closing: @user_data: - -@Param1: diff --git a/libgimp/gimpmatrix.c b/libgimp/gimpmatrix.c index be09c42d49..d0b814dfca 100644 --- a/libgimp/gimpmatrix.c +++ b/libgimp/gimpmatrix.c @@ -24,159 +24,281 @@ #define EPSILON 1e-6 + +/** + * gimp_matrix_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_matrix_transform_point (GimpMatrix m, double x, double y, - double *newx, double *newy) +gimp_matrix_transform_point (GimpMatrix matrix, + gdouble x, + gdouble y, + gdouble *newx, + gdouble *newy) { - double w; - w = m[2][0]*x + m[2][1]*y + m[2][2]; + 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 = (m[0][0]*x + m[0][1]*y + m[0][2])*w; - *newy = (m[1][0]*x + m[1][1]*y + m[1][2])*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_matrix_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_matrix_mult (GimpMatrix m1, GimpMatrix m2) +gimp_matrix_mult (GimpMatrix matrix1, + GimpMatrix matrix2) { - int i, j; + gint i, j; GimpMatrix tmp; - double t1, t2, t3; + gdouble t1, t2, t3; for (i = 0; i < 3; i++) - { - t1 = m1[i][0]; - t2 = m1[i][1]; - t3 = m1[i][2]; - for (j = 0; j < 3; j++) { - tmp[i][j] = t1 * m2[0][j]; - tmp[i][j] += t2 * m2[1][j]; - tmp[i][j] += t3 * m2[2][j]; + 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 m2 */ - memcpy(&m2[0][0], &tmp[0][0], sizeof(GimpMatrix)); + + /* put the results in matrix2 */ + memcpy (&matrix2[0][0], &tmp[0][0], sizeof(GimpMatrix)); } +/** + * gimp_matrix_identity: + * @matrix: A matrix. + * + * Sets the matrix to the identity matrix. + */ void -gimp_matrix_identity (GimpMatrix m) +gimp_matrix_identity (GimpMatrix matrix) { static GimpMatrix identity = { {1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0} }; - memcpy(&m[0][0], &identity[0][0], sizeof(GimpMatrix)); + memcpy (&matrix[0][0], &identity[0][0], sizeof(GimpMatrix)); } +/** + * gimp_matrix_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_matrix_translate (GimpMatrix m, double x, double y) +gimp_matrix_translate (GimpMatrix matrix, + gdouble x, + gdouble y) { - double g, h, i; - g = m[2][0]; - h = m[2][1]; - i = m[2][2]; - m[0][0] += x*g; - m[0][1] += x*h; - m[0][2] += x*i; - m[1][0] += y*g; - m[1][1] += y*h; - m[1][2] += y*i; + 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_matrix_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_matrix_scale (GimpMatrix m, double x, double y) +gimp_matrix_scale (GimpMatrix matrix, + gdouble x, + gdouble y) { - m[0][0] *= x; - m[0][1] *= x; - m[0][2] *= x; + matrix[0][0] *= x; + matrix[0][1] *= x; + matrix[0][2] *= x; - m[1][0] *= y; - m[1][1] *= y; - m[1][2] *= y; + matrix[1][0] *= y; + matrix[1][1] *= y; + matrix[1][2] *= y; } +/** + * gimp_matrix_rotate: + * @matrix: The matrix that is to be rotated. + * @theta: The angle of rotation (in radians). + * + * Rotates the matrix by theta degrees. + */ void -gimp_matrix_rotate (GimpMatrix m, double theta) +gimp_matrix_rotate (GimpMatrix matrix, + gdouble theta) { - double t1, t2; - double cost, sint; + gdouble t1, t2; + gdouble cost, sint; cost = cos(theta); sint = sin(theta); - t1 = m[0][0]; - t2 = m[1][0]; - m[0][0] = cost*t1 - sint*t2; - m[1][0] = sint*t1 + cost*t2; + t1 = matrix[0][0]; + t2 = matrix[1][0]; + matrix[0][0] = cost*t1 - sint*t2; + matrix[1][0] = sint*t1 + cost*t2; - t1 = m[0][1]; - t2 = m[1][1]; - m[0][1] = cost*t1 - sint*t2; - m[1][1] = 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 = m[0][2]; - t2 = m[1][2]; - m[0][2] = cost*t1 - sint*t2; - m[1][2] = 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_matrix_xshear: + * @matrix: The matrix that is to be sheared. + * @amount: X shear amount. + * + * Shears the matrix in the X direction. + */ void -gimp_matrix_xshear (GimpMatrix m, double amnt) +gimp_matrix_xshear (GimpMatrix matrix, + gdouble amount) { - m[0][0] += amnt * m[1][0]; - m[0][1] += amnt * m[1][1]; - m[0][2] += amnt * m[1][2]; + matrix[0][0] += amount * matrix[1][0]; + matrix[0][1] += amount * matrix[1][1]; + matrix[0][2] += amount * matrix[1][2]; } +/** + * gimp_matrix_yshear: + * @matrix: The matrix that is to be sheared. + * @amount: Y shear amount. + * + * Shears the matrix in the Y direction. + */ void -gimp_matrix_yshear (GimpMatrix m, double amnt) +gimp_matrix_yshear (GimpMatrix matrix, + gdouble amount) { - m[1][0] += amnt * m[0][0]; - m[1][1] += amnt * m[0][1]; - m[1][2] += amnt * m[0][2]; + matrix[1][0] += amount * matrix[0][0]; + matrix[1][1] += amount * matrix[0][1]; + matrix[1][2] += amount * matrix[0][2]; } - -double -gimp_matrix_determinant (GimpMatrix m) +/** + * gimp_matrix_determinant: + * @matrix: The input matrix. + * + * Calculates the determinant of the given matrix. + * + * Returns: The determinant. + */ +gdouble +gimp_matrix_determinant (GimpMatrix matrix) { - double determinant; + gdouble determinant; - determinant = m[0][0] * (m[1][1]*m[2][2] - m[1][2]*m[2][1]); - determinant -= m[1][0] * (m[0][1]*m[2][2] - m[0][2]*m[2][1]); - determinant += m[2][0] * (m[0][1]*m[1][2] - m[0][2]*m[1][1]); + 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_matrix_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_matrix_invert (GimpMatrix m, GimpMatrix m_inv) +gimp_matrix_invert (GimpMatrix matrix, + GimpMatrix matrix_inv) { - double det_1; + gdouble det_1; + + det_1 = gimp_matrix_determinant (matrix); - det_1 = gimp_matrix_determinant (m); if (det_1 == 0.0) return; + det_1 = 1.0 / det_1; - m_inv[0][0] = ( m[1][1] * m[2][2] - m[1][2] * m[2][1] ) * det_1; - m_inv[1][0] = - ( m[1][0] * m[2][2] - m[1][2] * m[2][0] ) * det_1; - m_inv[2][0] = ( m[1][0] * m[2][1] - m[1][1] * m[2][0] ) * det_1; - m_inv[0][1] = - ( m[0][1] * m[2][2] - m[0][2] * m[2][1] ) * det_1; - m_inv[1][1] = ( m[0][0] * m[2][2] - m[0][2] * m[2][0] ) * det_1; - m_inv[2][1] = - ( m[0][0] * m[2][1] - m[0][1] * m[2][0] ) * det_1; - m_inv[0][2] = ( m[0][1] * m[1][2] - m[0][2] * m[1][1] ) * det_1; - m_inv[1][2] = - ( m[0][0] * m[1][2] - m[0][2] * m[1][0] ) * det_1; - m_inv[2][2] = ( m[0][0] * m[1][1] - m[0][1] * m[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_matrix_duplicate: + * @src: The source matrix. + * @target: The destination matrix. + * + * Copies the source matrix to the destination matrix. + */ void -gimp_matrix_duplicate (GimpMatrix src, GimpMatrix target) +gimp_matrix_duplicate (GimpMatrix src, + GimpMatrix target) { memcpy (&target[0][0], &src[0][0], sizeof(GimpMatrix)); } @@ -184,26 +306,44 @@ gimp_matrix_duplicate (GimpMatrix src, GimpMatrix target) /* functions to test for matrix properties */ -int -gimp_matrix_is_diagonal (GimpMatrix m) + +/** + * gimp_matrix_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_matrix_is_diagonal (GimpMatrix matrix) { - int i,j; + gint i, j; for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { - if (i != j && fabs (m[i][j]) > EPSILON) + if (i != j && fabs (matrix[i][j]) > EPSILON) return FALSE; } } + return TRUE; } -int -gimp_matrix_is_identity (GimpMatrix m) +/** + * gimp_matrix_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_matrix_is_identity (GimpMatrix matrix) { - int i,j; + gint i,j; for (i = 0; i < 3; i++) { @@ -211,16 +351,17 @@ gimp_matrix_is_identity (GimpMatrix m) { if (i == j) { - if (fabs (m[i][j] - 1.0) > EPSILON) + if (fabs (matrix[i][j] - 1.0) > EPSILON) return FALSE; } else { - if (fabs (m[i][j]) > EPSILON) + if (fabs (matrix[i][j]) > EPSILON) return FALSE; } } } + return TRUE; } @@ -228,24 +369,33 @@ gimp_matrix_is_identity (GimpMatrix m) This function returns TRUE if all entries of the upper left 2x2 matrix are either 0 or 1 */ -int -gimp_matrix_is_simple (GimpMatrix m) + + +/** + * gimp_matrix_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_matrix_is_simple (GimpMatrix matrix) { - double absm; - int i,j; + gdouble absm; + gint i, j; for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) { - absm = fabs (m[i][j]); + absm = fabs (matrix[i][j]); if (absm > EPSILON && fabs (absm - 1.0) > EPSILON) return FALSE; } } + return TRUE; } - - - - diff --git a/libgimp/gimpmatrix.h b/libgimp/gimpmatrix.h index 8612f05941..058ea67223 100644 --- a/libgimp/gimpmatrix.h +++ b/libgimp/gimpmatrix.h @@ -26,21 +26,35 @@ extern "C" { typedef double GimpMatrix[3][3]; -void gimp_matrix_transform_point (GimpMatrix, double, double, - double *, double *); -void gimp_matrix_mult (GimpMatrix, GimpMatrix); -void gimp_matrix_identity (GimpMatrix); -void gimp_matrix_translate (GimpMatrix, double, double); -void gimp_matrix_scale (GimpMatrix, double, double); -void gimp_matrix_rotate (GimpMatrix, double); -void gimp_matrix_xshear (GimpMatrix, double); -void gimp_matrix_yshear (GimpMatrix, double); -double gimp_matrix_determinant (GimpMatrix); -void gimp_matrix_invert (GimpMatrix m, GimpMatrix m_inv); -void gimp_matrix_duplicate (GimpMatrix src, GimpMatrix target); -int gimp_matrix_is_diagonal (GimpMatrix m); -int gimp_matrix_is_identity (GimpMatrix m); -int gimp_matrix_is_simple (GimpMatrix m); +void gimp_matrix_transform_point (GimpMatrix matrix, + gdouble x, + gdouble y, + gdouble *newx, + gdouble *newy); +void gimp_matrix_mult (GimpMatrix matrix1, + GimpMatrix matrix2); +void gimp_matrix_identity (GimpMatrix matrix); +void gimp_matrix_translate (GimpMatrix matrix, + gdouble x, + gdouble y); +void gimp_matrix_scale (GimpMatrix matrix, + gdouble x, + gdouble y); +void gimp_matrix_rotate (GimpMatrix matrix, + gdouble theta); +void gimp_matrix_xshear (GimpMatrix matrix, + gdouble amount); +void gimp_matrix_yshear (GimpMatrix matrix, + gdouble amount); +gdouble gimp_matrix_determinant (GimpMatrix matrix); +void gimp_matrix_invert (GimpMatrix matrix, + GimpMatrix matrix_inv); +void gimp_matrix_duplicate (GimpMatrix src, + GimpMatrix target); + +gboolean gimp_matrix_is_diagonal (GimpMatrix matrix); +gboolean gimp_matrix_is_identity (GimpMatrix matrix); +gboolean gimp_matrix_is_simple (GimpMatrix matrix); #ifdef __cplusplus }