--- devel-docs/libgimpmath/html/api-index-full.html | 438 ++++ devel-docs/libgimpmath/html/home.png | Bin 0 -> 256 bytes devel-docs/libgimpmath/html/index.html | 47 + devel-docs/libgimpmath/html/left-insensitive.png | Bin 0 -> 395 bytes devel-docs/libgimpmath/html/left.png | Bin 0 -> 262 bytes .../libgimpmath/html/libgimpmath-GimpMD5.html | 102 + .../libgimpmath/html/libgimpmath-GimpMath.html | 340 +++ .../libgimpmath/html/libgimpmath-GimpMatrix.html | 1373 ++++++++++++ .../libgimpmath/html/libgimpmath-GimpVector.html | 2219 ++++++++++++++++++++ devel-docs/libgimpmath/html/libgimpmath.devhelp2 | 127 ++ devel-docs/libgimpmath/html/pt01.html | 47 + devel-docs/libgimpmath/html/right-insensitive.png | Bin 0 -> 373 bytes devel-docs/libgimpmath/html/right.png | Bin 0 -> 261 bytes devel-docs/libgimpmath/html/style.css | 530 +++++ devel-docs/libgimpmath/html/up-insensitive.png | Bin 0 -> 374 bytes devel-docs/libgimpmath/html/up.png | Bin 0 -> 260 bytes 16 files changed, 5223 insertions(+) create mode 100644 devel-docs/libgimpmath/html/api-index-full.html create mode 100644 devel-docs/libgimpmath/html/home.png create mode 100644 devel-docs/libgimpmath/html/index.html create mode 100644 devel-docs/libgimpmath/html/left-insensitive.png create mode 100644 devel-docs/libgimpmath/html/left.png create mode 100644 devel-docs/libgimpmath/html/libgimpmath-GimpMD5.html create mode 100644 devel-docs/libgimpmath/html/libgimpmath-GimpMath.html create mode 100644 devel-docs/libgimpmath/html/libgimpmath-GimpMatrix.html create mode 100644 devel-docs/libgimpmath/html/libgimpmath-GimpVector.html create mode 100644 devel-docs/libgimpmath/html/libgimpmath.devhelp2 create mode 100644 devel-docs/libgimpmath/html/pt01.html create mode 100644 devel-docs/libgimpmath/html/right-insensitive.png create mode 100644 devel-docs/libgimpmath/html/right.png create mode 100644 devel-docs/libgimpmath/html/style.css create mode 100644 devel-docs/libgimpmath/html/up-insensitive.png create mode 100644 devel-docs/libgimpmath/html/up.png (limited to 'devel-docs/libgimpmath/html') diff --git a/devel-docs/libgimpmath/html/api-index-full.html b/devel-docs/libgimpmath/html/api-index-full.html new file mode 100644 index 0000000..6c1298d --- /dev/null +++ b/devel-docs/libgimpmath/html/api-index-full.html @@ -0,0 +1,438 @@ + + + + +Index: GIMP Math Library Reference Manual + + + + + + + + + + + + + + + + +

+Index

+MAX255, macro in GimpMath +

+gimp_md5_get_digest, function in GimpMD5 +

P

+gimp_param_spec_matrix2, function in GimpMatrix +

+gimp_param_spec_matrix3, function in GimpMatrix +

R

+gimp_rad_to_deg, macro in GimpMath +

+RINT, macro in GimpMath +

+ROUND, macro in GimpMath +

S

+SAFE_CLAMP, macro in GimpMath +

+SIGNED_ROUND, macro in GimpMath +

+SQR, macro in GimpMath +

T

+GIMP_TYPE_MATRIX2, macro in GimpMatrix +

+GIMP_TYPE_MATRIX3, macro in GimpMatrix +

+GIMP_TYPE_PARAM_MATRIX2, macro in GimpMatrix +

+GIMP_TYPE_PARAM_MATRIX3, macro in GimpMatrix +

V

+GIMP_VALUE_HOLDS_MATRIX2, macro in GimpMatrix +

+GIMP_VALUE_HOLDS_MATRIX3, macro in GimpMatrix +

+GimpVector2, struct in GimpVector +

+gimp_vector2_add, function in GimpVector +

+gimp_vector2_add_val, function in GimpVector +

+gimp_vector2_cross_product, function in GimpVector +

+gimp_vector2_cross_product_val, function in GimpVector +

+gimp_vector2_inner_product, function in GimpVector +

+gimp_vector2_inner_product_val, function in GimpVector +

+gimp_vector2_length, function in GimpVector +

+gimp_vector2_length_val, function in GimpVector +

+gimp_vector2_mul, function in GimpVector +

+gimp_vector2_mul_val, function in GimpVector +

+gimp_vector2_neg, function in GimpVector +

+gimp_vector2_neg_val, function in GimpVector +

+gimp_vector2_new, function in GimpVector +

+gimp_vector2_normal, function in GimpVector +

+gimp_vector2_normalize, function in GimpVector +

+gimp_vector2_normalize_val, function in GimpVector +

+gimp_vector2_normal_val, function in GimpVector +

+gimp_vector2_rotate, function in GimpVector +

+gimp_vector2_rotate_val, function in GimpVector +

+gimp_vector2_set, function in GimpVector +

+gimp_vector2_sub, function in GimpVector +

+gimp_vector2_sub_val, function in GimpVector +

+GimpVector3, struct in GimpVector +

+gimp_vector3_add, function in GimpVector +

+gimp_vector3_add_val, function in GimpVector +

+gimp_vector3_cross_product, function in GimpVector +

+gimp_vector3_cross_product_val, function in GimpVector +

+gimp_vector3_inner_product, function in GimpVector +

+gimp_vector3_inner_product_val, function in GimpVector +

+gimp_vector3_length, function in GimpVector +

+gimp_vector3_length_val, function in GimpVector +

+gimp_vector3_mul, function in GimpVector +

+gimp_vector3_mul_val, function in GimpVector +

+gimp_vector3_neg, function in GimpVector +

+gimp_vector3_neg_val, function in GimpVector +

+gimp_vector3_new, function in GimpVector +

+gimp_vector3_normalize, function in GimpVector +

+gimp_vector3_normalize_val, function in GimpVector +

+gimp_vector3_rotate, function in GimpVector +

+gimp_vector3_rotate_val, function in GimpVector +

+gimp_vector3_set, function in GimpVector +

+gimp_vector3_sub, function in GimpVector +

+gimp_vector3_sub_val, function in GimpVector +

+GimpVector4, struct in GimpVector +

+gimp_vector_2d_to_3d, function in GimpVector +

+gimp_vector_2d_to_3d_val, function in GimpVector +

+gimp_vector_3d_to_2d, function in GimpVector +

+ + + \ No newline at end of file diff --git a/devel-docs/libgimpmath/html/home.png b/devel-docs/libgimpmath/html/home.png new file mode 100644 index 0000000..3966a91 Binary files /dev/null and b/devel-docs/libgimpmath/html/home.png differ diff --git a/devel-docs/libgimpmath/html/index.html b/devel-docs/libgimpmath/html/index.html new file mode 100644 index 0000000..7ac8074 --- /dev/null +++ b/devel-docs/libgimpmath/html/index.html @@ -0,0 +1,47 @@ + + + + +GIMP Math Library Reference Manual: GIMP Math Library Reference Manual + + + + + + + +

+ for GIMP 2.10.36 + +

I. GIMP Math Library

+GimpMath — Mathematical definitions and macros. +
+GimpMatrix — Utilities to set up and manipulate 3x3 +transformation matrices. +
+GimpVector — Utilities to set up and manipulate vectors. +
+GimpMD5 — The MD5 message-digest algorithm +

Index

+ + + \ No newline at end of file diff --git a/devel-docs/libgimpmath/html/left-insensitive.png b/devel-docs/libgimpmath/html/left-insensitive.png new file mode 100644 index 0000000..2cd8c16 Binary files /dev/null and b/devel-docs/libgimpmath/html/left-insensitive.png differ diff --git a/devel-docs/libgimpmath/html/left.png b/devel-docs/libgimpmath/html/left.png new file mode 100644 index 0000000..1ca1664 Binary files /dev/null and b/devel-docs/libgimpmath/html/left.png differ diff --git a/devel-docs/libgimpmath/html/libgimpmath-GimpMD5.html b/devel-docs/libgimpmath/html/libgimpmath-GimpMD5.html new file mode 100644 index 0000000..7465cd4 --- /dev/null +++ b/devel-docs/libgimpmath/html/libgimpmath-GimpMD5.html @@ -0,0 +1,102 @@ + + + + +GimpMD5: GIMP Math Library Reference Manual + + + + + + + + + + + + + + + + +

+ + +

GimpMD5

GimpMD5 — The MD5 message-digest algorithm

Functions

++++ + + + + +

+void +

+gimp_md5_get_digest () +

Description

The MD5 message-digest algorithm

Functions

gimp_md5_get_digest ()

void
+gimp_md5_get_digest (const gchar *buffer,
+                     gint buffer_size,
+                     guchar digest[16]);

gimp_md5_get_digest is deprecated and should not be used in newly-written code.

This function is deprecated! Use GChecksum from GLib instead.

Get the md5 hash of a buffer. The result is put in the 16 bytes +buffer digest +. For more information see RFC 1321.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

buffer	byte buffer
buffer_size	buffer size (in bytes) or -1 if `buffer` +is nul-terminated.
digest	16 bytes buffer receiving the hash code.

+ + + \ No newline at end of file diff --git a/devel-docs/libgimpmath/html/libgimpmath-GimpMath.html b/devel-docs/libgimpmath/html/libgimpmath-GimpMath.html new file mode 100644 index 0000000..399351b --- /dev/null +++ b/devel-docs/libgimpmath/html/libgimpmath-GimpMath.html @@ -0,0 +1,340 @@ + + + + +GimpMath: GIMP Math Library Reference Manual + + + + + + + + + + + + + + + + +

+ + +

GimpMath

GimpMath — Mathematical definitions and macros.

Functions

++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

#define	+RINT() +
#define	+ROUND() +
#define	+SIGNED_ROUND() +
#define	+SQR() +
#define	+MAX255() +
#define	+CLAMP0255() +
#define	+SAFE_CLAMP() +
#define	+gimp_deg_to_rad() +
#define	+gimp_rad_to_deg() +

Description

Mathematical definitions and macros for use both by the GIMP +application and plug-ins. These macros should be used rather than +the ones from <math.h> for enhanced portability.

Functions

RINT()

#define RINT(x) rint(x)
+

This macro rounds its argument x + to an integer value in floating +point format. Use RINT() instead of rint().

Parameters

+++++ + + + + + +

the value to be rounded

ROUND()

#define ROUND(x) ((int) ((x) + 0.5))
+

This macro rounds its positive argument x + to the nearest integer.

Parameters

+++++ + + + + + +

the value to be rounded.

SIGNED_ROUND()

#define SIGNED_ROUND(x) ((int) RINT (x))
+

This macro rounds its argument x + to the nearest integer.

Parameters

+++++ + + + + + +

the value to be rounded.

SQR()

#define SQR(x) ((x) * (x))
+

This macro squares its argument x +.

Parameters

+++++ + + + + + +

the value to be squared.

MAX255()

#define MAX255(a)  ((a) | (((a) & 256) - (((a) & 256) >> 8)))
+

This macro limits it argument a +, an (0-511) int, to 255.

Parameters

+++++ + + + + + +

the value to be limited.

CLAMP0255()

#define CLAMP0255(a)  CLAMP(a,0,255)
+

This macro clamps its argument a +, an int32-range int, between 0 +and 255 inclusive.

Parameters

+++++ + + + + + +

the value to be clamped.

SAFE_CLAMP()

#define SAFE_CLAMP(x, low, high)  ((x) > (low) ? (x) < (high) ? (x) : (high) : (low))
+

Ensures that x + is between the limits set by low + and high +, +even if x + is NaN. If low + is greater than high +, or if either +of them is NaN, the result is undefined.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

x	the value to be limited.
low	the lower limit.
high	the upper limit.

Since: 2.10

gimp_deg_to_rad()

#define gimp_deg_to_rad(angle) ((angle) * (2.0 * G_PI) / 360.0)
+

This macro converts its argument angle + from degree to radian.

Parameters

+++++ + + + + + +

angle

the angle to be converted.

gimp_rad_to_deg()

#define gimp_rad_to_deg(angle) ((angle) * 360.0 / (2.0 * G_PI))
+

This macro converts its argument angle + from radian to degree.

Parameters

+++++ + + + + + +

angle

the angle to be converted.

+ + + \ No newline at end of file diff --git a/devel-docs/libgimpmath/html/libgimpmath-GimpMatrix.html b/devel-docs/libgimpmath/html/libgimpmath-GimpMatrix.html new file mode 100644 index 0000000..e9a56b8 --- /dev/null +++ b/devel-docs/libgimpmath/html/libgimpmath-GimpMatrix.html @@ -0,0 +1,1373 @@ + + + + +GimpMatrix: GIMP Math Library Reference Manual + + + + + + + + + + + + + + + + +

+ + +

GimpMatrix

GimpMatrix — Utilities to set up and manipulate 3x3 +transformation matrices.

Functions

++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+void +	+gimp_matrix2_identity () +
+void +	+gimp_matrix2_mult () +
+gdouble +	+gimp_matrix2_determinant () +
+void +	+gimp_matrix2_invert () +
+void +	+gimp_matrix2_transform_point () +
+void +	+gimp_matrix3_identity () +
+void +	+gimp_matrix3_mult () +
+void +	+gimp_matrix3_translate () +
+void +	+gimp_matrix3_scale () +
+void +	+gimp_matrix3_rotate () +
+void +	+gimp_matrix3_xshear () +
+void +	+gimp_matrix3_yshear () +
+void +	+gimp_matrix3_affine () +
+void +	+gimp_matrix3_transform_point () +
+gdouble +	+gimp_matrix3_determinant () +
+void +	+gimp_matrix3_invert () +
+gboolean +	+gimp_matrix3_is_identity () +
+gboolean +	+gimp_matrix3_is_diagonal () +
+gboolean +	+gimp_matrix3_is_affine () +
+gboolean +	+gimp_matrix3_is_simple () +
+gboolean +	+gimp_matrix3_equal () +
+void +	+gimp_matrix4_identity () +
+void +	+gimp_matrix4_mult () +
+void +	+gimp_matrix4_to_deg () +
+gdouble +	+gimp_matrix4_transform_point () +
#define	+GIMP_IS_PARAM_SPEC_MATRIX2() +
+GParamSpec * +	+gimp_param_spec_matrix2 () +
#define	+GIMP_VALUE_HOLDS_MATRIX2() +
#define	+GIMP_IS_PARAM_SPEC_MATRIX3() +
+GParamSpec * +	+gimp_param_spec_matrix3 () +
#define	+GIMP_VALUE_HOLDS_MATRIX3() +

Types and Values

++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

struct	GimpMatrix2
struct	GimpMatrix3
struct	GimpMatrix4
#define	GIMP_TYPE_MATRIX2
#define	GIMP_TYPE_PARAM_MATRIX2
#define	GIMP_TYPE_MATRIX3
#define	GIMP_TYPE_PARAM_MATRIX3

Description

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.

Each matrix class has a 2 dimensional gdouble coeff member. The +element for row r and column c of the matrix is coeffr.

Functions

gimp_matrix2_identity ()

void
+gimp_matrix2_identity (GimpMatrix2 *matrix);

Sets the matrix to the identity matrix.

Parameters

+++++ + + + + + +

matrix

A matrix.

gimp_matrix2_mult ()

void
+gimp_matrix2_mult (const GimpMatrix2 *matrix1,
+                   GimpMatrix2 *matrix2);

Multiplies two matrices and puts the result into the second one.

Parameters

+++++ + + + + + + + + + + + + +

matrix1	The first input matrix.
matrix2	The second input matrix which will be overwritten by the result.

gimp_matrix2_determinant ()

gdouble
+gimp_matrix2_determinant (const GimpMatrix2 *matrix);

Calculates the determinant of the given matrix.

Parameters

+++++ + + + + + +

matrix

The input matrix.

Returns

The determinant.

Since: 2.10.16

gimp_matrix2_invert ()

void
+gimp_matrix2_invert (GimpMatrix2 *matrix);

Inverts the given matrix.

Parameters

+++++ + + + + + +

matrix

The matrix that is to be inverted.

Since: 2.10.16

gimp_matrix2_transform_point ()

void
+gimp_matrix2_transform_point (const GimpMatrix2 *matrix,
+                              gdouble x,
+                              gdouble y,
+                              gdouble *newx,
+                              gdouble *newy);

Transforms a point in 2D as specified by the transformation matrix.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

matrix	The transformation matrix.
x	The source X coordinate.
y	The source Y coordinate.
newx	The transformed X coordinate.
newy	The transformed Y coordinate.

Since: 2.10.16

gimp_matrix3_identity ()

void
+gimp_matrix3_identity (GimpMatrix3 *matrix);

Sets the matrix to the identity matrix.

Parameters

+++++ + + + + + +

matrix

A matrix.

gimp_matrix3_mult ()

void
+gimp_matrix3_mult (const GimpMatrix3 *matrix1,
+                   GimpMatrix3 *matrix2);

Multiplies two matrices and puts the result into the second one.

Parameters

+++++ + + + + + + + + + + + + +

matrix1	The first input matrix.
matrix2	The second input matrix which will be overwritten by the result.

gimp_matrix3_translate ()

void
+gimp_matrix3_translate (GimpMatrix3 *matrix,
+                        gdouble x,
+                        gdouble y);

Translates the matrix by x and y.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

matrix	The matrix that is to be translated.
x	Translation in X direction.
y	Translation in Y direction.

gimp_matrix3_scale ()

void
+gimp_matrix3_scale (GimpMatrix3 *matrix,
+                    gdouble x,
+                    gdouble y);

Scales the matrix by x and y

Parameters

+++++ + + + + + + + + + + + + + + + + + +

matrix	The matrix that is to be scaled.
x	X scale factor.
y	Y scale factor.

gimp_matrix3_rotate ()

void
+gimp_matrix3_rotate (GimpMatrix3 *matrix,
+                     gdouble theta);

Rotates the matrix by theta degrees.

Parameters

+++++ + + + + + + + + + + + + +

matrix	The matrix that is to be rotated.
theta	The angle of rotation (in radians).

gimp_matrix3_xshear ()

void
+gimp_matrix3_xshear (GimpMatrix3 *matrix,
+                     gdouble amount);

Shears the matrix in the X direction.

Parameters

+++++ + + + + + + + + + + + + +

matrix	The matrix that is to be sheared.
amount	X shear amount.

gimp_matrix3_yshear ()

void
+gimp_matrix3_yshear (GimpMatrix3 *matrix,
+                     gdouble amount);

Shears the matrix in the Y direction.

Parameters

+++++ + + + + + + + + + + + + +

matrix	The matrix that is to be sheared.
amount	Y shear amount.

gimp_matrix3_affine ()

void
+gimp_matrix3_affine (GimpMatrix3 *matrix,
+                     gdouble a,
+                     gdouble b,
+                     gdouble c,
+                     gdouble d,
+                     gdouble e,
+                     gdouble f);

Applies the affine transformation given by six values to matrix +. +The six values form define an affine transformation matrix as +illustrated below:

( a c e ) + ( b d f ) + ( 0 0 1 )

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

matrix	The input matrix.
a	the 'a' coefficient
b	the 'b' coefficient
c	the 'c' coefficient
d	the 'd' coefficient
e	the 'e' coefficient
f	the 'f' coefficient

gimp_matrix3_transform_point ()

void
+gimp_matrix3_transform_point (const GimpMatrix3 *matrix,
+                              gdouble x,
+                              gdouble y,
+                              gdouble *newx,
+                              gdouble *newy);

Transforms a point in 2D as specified by the transformation matrix.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

matrix	The transformation matrix.
x	The source X coordinate.
y	The source Y coordinate.
newx	The transformed X coordinate.
newy	The transformed Y coordinate.

gimp_matrix3_determinant ()

gdouble
+gimp_matrix3_determinant (const GimpMatrix3 *matrix);

Calculates the determinant of the given matrix.

Parameters

+++++ + + + + + +

matrix

The input matrix.

Returns

The determinant.

gimp_matrix3_invert ()

void
+gimp_matrix3_invert (GimpMatrix3 *matrix);

Inverts the given matrix.

Parameters

+++++ + + + + + +

matrix

The matrix that is to be inverted.

gimp_matrix3_is_identity ()

gboolean
+gimp_matrix3_is_identity (const GimpMatrix3 *matrix);

Checks if the given matrix is the identity matrix.

Parameters

+++++ + + + + + +

matrix

The matrix that is to be tested.

Returns

TRUE if the matrix is the identity matrix, FALSE otherwise

gimp_matrix3_is_diagonal ()

gboolean
+gimp_matrix3_is_diagonal (const GimpMatrix3 *matrix);

Checks if the given matrix is diagonal.

Parameters

+++++ + + + + + +

matrix

The matrix that is to be tested.

Returns

TRUE if the matrix is diagonal, FALSE otherwise

gimp_matrix3_is_affine ()

gboolean
+gimp_matrix3_is_affine (const GimpMatrix3 *matrix);

Checks if the given matrix defines an affine transformation.

Parameters

+++++ + + + + + +

matrix

The matrix that is to be tested.

Returns

TRUE if the matrix defines an affine transformation, +FALSE otherwise

Since: 2.4

gimp_matrix3_is_simple ()

gboolean
+gimp_matrix3_is_simple (const GimpMatrix3 *matrix);

Checks if we'll need to interpolate when applying this matrix as +a transformation.

Parameters

+++++ + + + + + +

matrix

The matrix that is to be tested.

Returns

TRUE if all entries of the upper left 2x2 matrix are +either 0 or 1, FALSE otherwise

gimp_matrix3_equal ()

gboolean
+gimp_matrix3_equal (const GimpMatrix3 *matrix1,
+                    const GimpMatrix3 *matrix2);

Checks if two matrices are equal.

Parameters

+++++ + + + + + + + + + + + + +

matrix1	The first matrix
matrix2	The second matrix

Returns

TRUE the matrices are equal, FALSE otherwise

Since: 2.10.16

gimp_matrix4_identity ()

void
+gimp_matrix4_identity (GimpMatrix4 *matrix);

Sets the matrix to the identity matrix.

Parameters

+++++ + + + + + +

matrix

A matrix.

Since: 2.10.16

gimp_matrix4_mult ()

void
+gimp_matrix4_mult (const GimpMatrix4 *matrix1,
+                   GimpMatrix4 *matrix2);

Multiplies two matrices and puts the result into the second one.

Parameters

+++++ + + + + + + + + + + + + +

matrix1	The first input matrix.
matrix2	The second input matrix which will be overwritten by the result.

Since: 2.10.16

gimp_matrix4_to_deg ()

void
+gimp_matrix4_to_deg (const GimpMatrix4 *matrix,
+                     gdouble *a,
+                     gdouble *b,
+                     gdouble *c);

gimp_matrix4_transform_point ()

gdouble
+gimp_matrix4_transform_point (const GimpMatrix4 *matrix,
+                              gdouble x,
+                              gdouble y,
+                              gdouble z,
+                              gdouble *newx,
+                              gdouble *newy,
+                              gdouble *newz);

Transforms a point in 3D as specified by the transformation matrix.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

matrix	The transformation matrix.
x	The source X coordinate.
y	The source Y coordinate.
z	The source Z coordinate.
newx	The transformed X coordinate.
newy	The transformed Y coordinate.
newz	The transformed Z coordinate.

Returns

The transformed W coordinate.

Since: 2.10.16

GIMP_IS_PARAM_SPEC_MATRIX2()

#define GIMP_IS_PARAM_SPEC_MATRIX2(pspec)  (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_MATRIX2))
+

gimp_param_spec_matrix2 ()

GParamSpec *
+gimp_param_spec_matrix2 (const gchar *name,
+                         const gchar *nick,
+                         const gchar *blurb,
+                         const GimpMatrix2 *default_value,
+                         GParamFlags flags);

Creates a param spec to hold a GimpMatrix2 value. +See g_param_spec_internal() for more information.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

name	Canonical name of the param
nick	Nickname of the param
blurb	Brief description of param.
default_value	Value to use if none is assigned.
flags	a combination of GParamFlags

Returns

a newly allocated GParamSpec instance

Since: 2.4

GIMP_VALUE_HOLDS_MATRIX2()

#define GIMP_VALUE_HOLDS_MATRIX2(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_MATRIX2))
+

GIMP_IS_PARAM_SPEC_MATRIX3()

#define GIMP_IS_PARAM_SPEC_MATRIX3(pspec)  (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), GIMP_TYPE_PARAM_MATRIX3))
+

gimp_param_spec_matrix3 ()

GParamSpec *
+gimp_param_spec_matrix3 (const gchar *name,
+                         const gchar *nick,
+                         const gchar *blurb,
+                         const GimpMatrix3 *default_value,
+                         GParamFlags flags);

Creates a param spec to hold a GimpMatrix3 value. +See g_param_spec_internal() for more information.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

name	Canonical name of the param
nick	Nickname of the param
blurb	Brief description of param.
default_value	Value to use if none is assigned.
flags	a combination of GParamFlags

Returns

a newly allocated GParamSpec instance

Since: 2.8

GIMP_VALUE_HOLDS_MATRIX3()

#define GIMP_VALUE_HOLDS_MATRIX3(value) (G_TYPE_CHECK_VALUE_TYPE ((value), GIMP_TYPE_MATRIX3))
+

Types and Values

struct GimpMatrix2

struct GimpMatrix2 {
+  gdouble coeff[2][2];
+};
+

A two by two matrix.

Members

+++++ + + + + + +

gdouble coeff[2][2];

the coefficients

struct GimpMatrix3

struct GimpMatrix3 {
+  gdouble coeff[3][3];
+};
+

A three by three matrix.

Members

+++++ + + + + + +

gdouble coeff[3][3];

the coefficients

struct GimpMatrix4

struct GimpMatrix4 {
+  gdouble coeff[4][4];
+};
+

A four by four matrix.

Members

+++++ + + + + + +

gdouble coeff[4][4];

the coefficients

GIMP_TYPE_MATRIX2

#define GIMP_TYPE_MATRIX2               (gimp_matrix2_get_type ())
+

GIMP_TYPE_PARAM_MATRIX2

#define GIMP_TYPE_PARAM_MATRIX2            (gimp_param_matrix2_get_type ())
+

GIMP_TYPE_MATRIX3

#define GIMP_TYPE_MATRIX3               (gimp_matrix3_get_type ())
+

GIMP_TYPE_PARAM_MATRIX3

#define GIMP_TYPE_PARAM_MATRIX3            (gimp_param_matrix3_get_type ())
+

GimpVector

GimpVector — Utilities to set up and manipulate vectors.

Functions

++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+GimpVector2 +	+gimp_vector2_new () +
+void +	+gimp_vector2_set () +
+gdouble +	+gimp_vector2_length () +
+gdouble +	+gimp_vector2_length_val () +
+void +	+gimp_vector2_mul () +
+GimpVector2 +	+gimp_vector2_mul_val () +
+GimpVector2 +	+gimp_vector2_normal () +
+GimpVector2 +	+gimp_vector2_normal_val () +
+void +	+gimp_vector2_normalize () +
+GimpVector2 +	+gimp_vector2_normalize_val () +
+void +	+gimp_vector2_neg () +
+GimpVector2 +	+gimp_vector2_neg_val () +
+void +	+gimp_vector2_add () +
+GimpVector2 +	+gimp_vector2_add_val () +
+void +	+gimp_vector2_sub () +
+GimpVector2 +	+gimp_vector2_sub_val () +
+gdouble +	+gimp_vector2_inner_product () +
+gdouble +	+gimp_vector2_inner_product_val () +
+GimpVector2 +	+gimp_vector2_cross_product () +
+GimpVector2 +	+gimp_vector2_cross_product_val () +
+void +	+gimp_vector2_rotate () +
+GimpVector2 +	+gimp_vector2_rotate_val () +
+GimpVector3 +	+gimp_vector3_new () +
+void +	+gimp_vector3_set () +
+gdouble +	+gimp_vector3_length () +
+gdouble +	+gimp_vector3_length_val () +
+void +	+gimp_vector3_mul () +
+GimpVector3 +	+gimp_vector3_mul_val () +
+void +	+gimp_vector3_normalize () +
+GimpVector3 +	+gimp_vector3_normalize_val () +
+void +	+gimp_vector3_neg () +
+GimpVector3 +	+gimp_vector3_neg_val () +
+void +	+gimp_vector3_add () +
+GimpVector3 +	+gimp_vector3_add_val () +
+void +	+gimp_vector3_sub () +
+GimpVector3 +	+gimp_vector3_sub_val () +
+gdouble +	+gimp_vector3_inner_product () +
+gdouble +	+gimp_vector3_inner_product_val () +
+GimpVector3 +	+gimp_vector3_cross_product () +
+GimpVector3 +	+gimp_vector3_cross_product_val () +
+void +	+gimp_vector3_rotate () +
+GimpVector3 +	+gimp_vector3_rotate_val () +
+void +	+gimp_vector_2d_to_3d () +
+GimpVector3 +	+gimp_vector_2d_to_3d_val () +
+void +	+gimp_vector_3d_to_2d () +

Types and Values

++++ + + + + + + + + + + + + + + +

struct	GimpVector2
struct	GimpVector3
struct	GimpVector4

Description

Utilities to set up and manipulate vectors.

Functions

gimp_vector2_new ()

GimpVector2
+gimp_vector2_new (gdouble x,
+                  gdouble y);

Creates a GimpVector2 of coordinates x + and y +.

Parameters

+++++ + + + + + + + + + + + + +

x	the X coordinate.
y	the Y coordinate.

Returns

the resulting GimpVector2.

gimp_vector2_set ()

void
+gimp_vector2_set (GimpVector2 *vector,
+                  gdouble x,
+                  gdouble y);

Sets the X and Y coordinates of vector + to x + and y +.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

vector	a pointer to a GimpVector2.
x	the X coordinate.
y	the Y coordinate.

gimp_vector2_length ()

gdouble
+gimp_vector2_length (const GimpVector2 *vector);

Computes the length of a 2D vector.

Parameters

+++++ + + + + + +

vector

a pointer to a GimpVector2.

Returns

the length of vector +(a positive gdouble).

gimp_vector2_length_val ()

gdouble
+gimp_vector2_length_val (GimpVector2 vector);

This function is identical to gimp_vector2_length() but the +vector is passed by value rather than by reference.

Parameters

+++++ + + + + + +

vector

a GimpVector2.

Returns

the length of vector +(a positive gdouble).

gimp_vector2_mul ()

void
+gimp_vector2_mul (GimpVector2 *vector,
+                  gdouble factor);

Multiplies each component of the vector + by factor +. Note that this +is equivalent to multiplying the vectors length by factor +.

Parameters

+++++ + + + + + + + + + + + + +

vector	a pointer to a GimpVector2.
factor	a scalar.

gimp_vector2_mul_val ()

GimpVector2
+gimp_vector2_mul_val (GimpVector2 vector,
+                      gdouble factor);

This function is identical to gimp_vector2_mul() but the vector is +passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector	a GimpVector2.
factor	a scalar.

Returns

the resulting GimpVector2.

gimp_vector2_normal ()

GimpVector2
+gimp_vector2_normal (GimpVector2 *vector);

Compute a normalized perpendicular vector to vector +

Parameters

+++++ + + + + + +

vector

a pointer to a GimpVector2.

Returns

a GimpVector2 perpendicular to vector +, with a length of 1.0.

Since: 2.8

gimp_vector2_normal_val ()

GimpVector2
+gimp_vector2_normal_val (GimpVector2 vector);

This function is identical to gimp_vector2_normal() but the vector +is passed by value rather than by reference.

Parameters

+++++ + + + + + +

vector

a GimpVector2.

Returns

a GimpVector2 perpendicular to vector +, with a length of 1.0.

Since: 2.8

gimp_vector2_normalize ()

void
+gimp_vector2_normalize (GimpVector2 *vector);

Normalizes the vector + so the length of the vector + is 1.0. The nul +vector will not be changed.

Parameters

+++++ + + + + + +

vector

a pointer to a GimpVector2.

gimp_vector2_normalize_val ()

GimpVector2
+gimp_vector2_normalize_val (GimpVector2 vector);

This function is identical to gimp_vector2_normalize() but the +vector is passed by value rather than by reference.

Parameters

+++++ + + + + + +

vector

a GimpVector2.

Returns

a GimpVector2 parallel to vector +, pointing in the same +direction but with a length of 1.0.

gimp_vector2_neg ()

void
+gimp_vector2_neg (GimpVector2 *vector);

Negates the vector + (i.e. negate all its coordinates).

Parameters

+++++ + + + + + +

vector

a pointer to a GimpVector2.

gimp_vector2_neg_val ()

GimpVector2
+gimp_vector2_neg_val (GimpVector2 vector);

This function is identical to gimp_vector2_neg() but the vector +is passed by value rather than by reference.

Parameters

+++++ + + + + + +

vector

a GimpVector2.

Returns

the negated GimpVector2.

gimp_vector2_add ()

void
+gimp_vector2_add (GimpVector2 *result,
+                  const GimpVector2 *vector1,
+                  const GimpVector2 *vector2);

Computes the sum of two 2D vectors. The resulting GimpVector2 is +stored in result +.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

result	destination for the resulting GimpVector2.
vector1	a pointer to the first GimpVector2.
vector2	a pointer to the second GimpVector2.

gimp_vector2_add_val ()

GimpVector2
+gimp_vector2_add_val (GimpVector2 vector1,
+                      GimpVector2 vector2);

This function is identical to gimp_vector2_add() but the vectors +are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector1	the first GimpVector2.
vector2	the second GimpVector2.

Returns

the resulting GimpVector2.

gimp_vector2_sub ()

void
+gimp_vector2_sub (GimpVector2 *result,
+                  const GimpVector2 *vector1,
+                  const GimpVector2 *vector2);

Computes the difference of two 2D vectors (vector1 + minus vector2 +). +The resulting GimpVector2 is stored in result +.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

result	the destination for the resulting GimpVector2.
vector1	a pointer to the first GimpVector2.
vector2	a pointer to the second GimpVector2.

gimp_vector2_sub_val ()

GimpVector2
+gimp_vector2_sub_val (GimpVector2 vector1,
+                      GimpVector2 vector2);

This function is identical to gimp_vector2_sub() but the vectors +are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector1	the first GimpVector2.
vector2	the second GimpVector2.

Returns

the resulting GimpVector2.

gimp_vector2_inner_product ()

gdouble
+gimp_vector2_inner_product (const GimpVector2 *vector1,
+                            const GimpVector2 *vector2);

Computes the inner (dot) product of two 2D vectors. +This product is zero if and only if the two vectors are orthogonal.

Parameters

+++++ + + + + + + + + + + + + +

vector1	a pointer to the first GimpVector2.
vector2	a pointer to the second GimpVector2.

Returns

The inner product.

gimp_vector2_inner_product_val ()

gdouble
+gimp_vector2_inner_product_val (GimpVector2 vector1,
+                                GimpVector2 vector2);

This function is identical to gimp_vector2_inner_product() but the +vectors are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector1	the first GimpVector2.
vector2	the second GimpVector2.

Returns

The inner product.

gimp_vector2_cross_product ()

GimpVector2
+gimp_vector2_cross_product (const GimpVector2 *vector1,
+                            const GimpVector2 *vector2);

Compute the cross product of two vectors. The result is a +GimpVector2 which is orthogonal to both vector1 + and vector2 +. If +vector1 + and vector2 + are parallel, the result will be the nul +vector.

Note that in 2D, this function is useful to test if two vectors are +parallel or not, or to compute the area spawned by two vectors.

Parameters

+++++ + + + + + + + + + + + + +

vector1	a pointer to the first GimpVector2.
vector2	a pointer to the second GimpVector2.

Returns

The cross product.

gimp_vector2_cross_product_val ()

GimpVector2
+gimp_vector2_cross_product_val (GimpVector2 vector1,
+                                GimpVector2 vector2);

This function is identical to gimp_vector2_cross_product() but the +vectors are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector1	the first GimpVector2.
vector2	the second GimpVector2.

Returns

The cross product.

gimp_vector2_rotate ()

void
+gimp_vector2_rotate (GimpVector2 *vector,
+                     gdouble alpha);

Rotates the vector + counterclockwise by alpha + radians.

Parameters

+++++ + + + + + + + + + + + + +

vector	a pointer to a GimpVector2.
alpha	an angle (in radians).

gimp_vector2_rotate_val ()

GimpVector2
+gimp_vector2_rotate_val (GimpVector2 vector,
+                         gdouble alpha);

This function is identical to gimp_vector2_rotate() but the vector +is passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector	a GimpVector2.
alpha	an angle (in radians).

Returns

a GimpVector2 representing vector +rotated by alpha +radians.

gimp_vector3_new ()

GimpVector3
+gimp_vector3_new (gdouble x,
+                  gdouble y,
+                  gdouble z);

Creates a GimpVector3 of coordinate x +, y + and z +.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

x	the X coordinate.
y	the Y coordinate.
z	the Z coordinate.

Returns

the resulting GimpVector3.

gimp_vector3_set ()

void
+gimp_vector3_set (GimpVector3 *vector,
+                  gdouble x,
+                  gdouble y,
+                  gdouble z);

Sets the X, Y and Z coordinates of vector + to x +, y + and z +.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + +

vector	a pointer to a GimpVector3.
x	the X coordinate.
y	the Y coordinate.
z	the Z coordinate.

gimp_vector3_length ()

gdouble
+gimp_vector3_length (const GimpVector3 *vector);

Computes the length of a 3D vector.

Parameters

+++++ + + + + + +

vector

a pointer to a GimpVector3.

Returns

the length of vector +(a positive gdouble).

gimp_vector3_length_val ()

gdouble
+gimp_vector3_length_val (GimpVector3 vector);

This function is identical to gimp_vector3_length() but the vector +is passed by value rather than by reference.

Parameters

+++++ + + + + + +

vector

a GimpVector3.

Returns

the length of vector +(a positive gdouble).

gimp_vector3_mul ()

void
+gimp_vector3_mul (GimpVector3 *vector,
+                  gdouble factor);

Multiplies each component of the vector + by factor +. Note that +this is equivalent to multiplying the vectors length by factor +.

Parameters

+++++ + + + + + + + + + + + + +

vector	a pointer to a GimpVector3.
factor	a scalar.

gimp_vector3_mul_val ()

GimpVector3
+gimp_vector3_mul_val (GimpVector3 vector,
+                      gdouble factor);

This function is identical to gimp_vector3_mul() but the vector is +passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector	a GimpVector3.
factor	a scalar.

Returns

the resulting GimpVector3.

gimp_vector3_normalize ()

void
+gimp_vector3_normalize (GimpVector3 *vector);

Normalizes the vector + so the length of the vector + is 1.0. The nul +vector will not be changed.

Parameters

+++++ + + + + + +

vector

a pointer to a GimpVector3.

gimp_vector3_normalize_val ()

GimpVector3
+gimp_vector3_normalize_val (GimpVector3 vector);

This function is identical to gimp_vector3_normalize() but the +vector is passed by value rather than by reference.

Parameters

+++++ + + + + + +

vector

a GimpVector3.

Returns

a GimpVector3 parallel to vector +, pointing in the same +direction but with a length of 1.0.

gimp_vector3_neg ()

void
+gimp_vector3_neg (GimpVector3 *vector);

Negates the vector + (i.e. negate all its coordinates).

Parameters

+++++ + + + + + +

vector

a pointer to a GimpVector3.

gimp_vector3_neg_val ()

GimpVector3
+gimp_vector3_neg_val (GimpVector3 vector);

This function is identical to gimp_vector3_neg() but the vector +is passed by value rather than by reference.

Parameters

+++++ + + + + + +

vector

a GimpVector3.

Returns

the negated GimpVector3.

gimp_vector3_add ()

void
+gimp_vector3_add (GimpVector3 *result,
+                  const GimpVector3 *vector1,
+                  const GimpVector3 *vector2);

Computes the sum of two 3D vectors. The resulting GimpVector3 is +stored in result +.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

result	destination for the resulting GimpVector3.
vector1	a pointer to the first GimpVector3.
vector2	a pointer to the second GimpVector3.

gimp_vector3_add_val ()

GimpVector3
+gimp_vector3_add_val (GimpVector3 vector1,
+                      GimpVector3 vector2);

This function is identical to gimp_vector3_add() but the vectors +are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector1	a GimpVector3.
vector2	a GimpVector3.

Returns

the resulting GimpVector3.

gimp_vector3_sub ()

void
+gimp_vector3_sub (GimpVector3 *result,
+                  const GimpVector3 *vector1,
+                  const GimpVector3 *vector2);

Computes the difference of two 3D vectors (vector1 + minus vector2 +). +The resulting GimpVector3 is stored in result +.

Parameters

+++++ + + + + + + + + + + + + + + + + + +

result	the destination for the resulting GimpVector3.
vector1	a pointer to the first GimpVector3.
vector2	a pointer to the second GimpVector3.

gimp_vector3_sub_val ()

GimpVector3
+gimp_vector3_sub_val (GimpVector3 vector1,
+                      GimpVector3 vector2);

This function is identical to gimp_vector3_sub() but the vectors +are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector1	a GimpVector3.
vector2	a GimpVector3.

Returns

the resulting GimpVector3.

gimp_vector3_inner_product ()

gdouble
+gimp_vector3_inner_product (const GimpVector3 *vector1,
+                            const GimpVector3 *vector2);

Computes the inner (dot) product of two 3D vectors. This product +is zero if and only if the two vectors are orthogonal.

Parameters

+++++ + + + + + + + + + + + + +

vector1	a pointer to the first GimpVector3.
vector2	a pointer to the second GimpVector3.

Returns

The inner product.

gimp_vector3_inner_product_val ()

gdouble
+gimp_vector3_inner_product_val (GimpVector3 vector1,
+                                GimpVector3 vector2);

This function is identical to gimp_vector3_inner_product() but the +vectors are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector1	the first GimpVector3.
vector2	the second GimpVector3.

Returns

The inner product.

gimp_vector3_cross_product ()

GimpVector3
+gimp_vector3_cross_product (const GimpVector3 *vector1,
+                            const GimpVector3 *vector2);

Compute the cross product of two vectors. The result is a +GimpVector3 which is orthogonal to both vector1 + and vector2 +. If +vector1 + and vector2 + and parallel, the result will be the nul +vector.

This function can be used to compute the normal of the plane +defined by vector1 + and vector2 +.

Parameters

+++++ + + + + + + + + + + + + +

vector1	a pointer to the first GimpVector3.
vector2	a pointer to the second GimpVector3.

Returns

The cross product.

gimp_vector3_cross_product_val ()

GimpVector3
+gimp_vector3_cross_product_val (GimpVector3 vector1,
+                                GimpVector3 vector2);

This function is identical to gimp_vector3_cross_product() but the +vectors are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + +

vector1	the first GimpVector3.
vector2	the second GimpVector3.

Returns

The cross product.

gimp_vector3_rotate ()

void
+gimp_vector3_rotate (GimpVector3 *vector,
+                     gdouble alpha,
+                     gdouble beta,
+                     gdouble gamma);

Rotates the vector + around the three axis (Z, Y, and X) by alpha +, +beta + and gamma +, respectively.

Note that the order of the rotation is very important. If you +expect a vector to be rotated around X, and then around Y, you will +have to call this function twice. Also, it is often wise to call +this function with only one of alpha +, beta + and gamma + non-zero.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + +

vector	a pointer to a GimpVector3.
alpha	the angle (in radian) of rotation around the Z axis.
beta	the angle (in radian) of rotation around the Y axis.
gamma	the angle (in radian) of rotation around the X axis.

gimp_vector3_rotate_val ()

GimpVector3
+gimp_vector3_rotate_val (GimpVector3 vector,
+                         gdouble alpha,
+                         gdouble beta,
+                         gdouble gamma);

This function is identical to gimp_vector3_rotate() but the vectors +are passed by value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + +

vector	a GimpVector3.
alpha	the angle (in radian) of rotation around the Z axis.
beta	the angle (in radian) of rotation around the Y axis.
gamma	the angle (in radian) of rotation around the X axis.

Returns

the rotated vector.

gimp_vector_2d_to_3d ()

void
+gimp_vector_2d_to_3d (gint sx,
+                      gint sy,
+                      gint w,
+                      gint h,
+                      gint x,
+                      gint y,
+                      const GimpVector3 *vp,
+                      GimpVector3 *p);

\"Compute screen (sx, sy) - (sx + w, sy + h) to 3D unit square +mapping. The plane to map to is given in the z field of p. The +observer is located at position vp (vp->z != 0.0).\"

In other words, this computes the projection of the point (x +, y +) +to the plane z = p->z + (parallel to XY), from the vp + point of view +through the screen (sx +, sy +)->(sx + + w +, sy + + h +)

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

sx	the abscissa of the upper-left screen rectangle.
sy	the ordinate of the upper-left screen rectangle.
w	the width of the screen rectangle.
h	the height of the screen rectangle.
x	the abscissa of the point in the screen rectangle to map.
y	the ordinate of the point in the screen rectangle to map.
vp	the position of the observer.
p	the resulting point.

gimp_vector_2d_to_3d_val ()

GimpVector3
+gimp_vector_2d_to_3d_val (gint sx,
+                          gint sy,
+                          gint w,
+                          gint h,
+                          gint x,
+                          gint y,
+                          GimpVector3 vp,
+                          GimpVector3 p);

This function is identical to gimp_vector_2d_to_3d() but the +position of the observer + and the resulting point p + are passed by +value rather than by reference.

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

sx	the abscissa of the upper-left screen rectangle.
sy	the ordinate of the upper-left screen rectangle.
w	the width of the screen rectangle.
h	the height of the screen rectangle.
x	the abscissa of the point in the screen rectangle to map.
y	the ordinate of the point in the screen rectangle to map.
vp	position of the observer.
p	the resulting point.

Returns

the computed GimpVector3 point.

gimp_vector_3d_to_2d ()

void
+gimp_vector_3d_to_2d (gint sx,
+                      gint sy,
+                      gint w,
+                      gint h,
+                      gdouble *x,
+                      gdouble *y,
+                      const GimpVector3 *vp,
+                      const GimpVector3 *p);

Convert the given 3D point to 2D (project it onto the viewing +plane, (sx, sy, 0) - (sx + w, sy + h, 0). The input is assumed to +be in the unit square (0, 0, z) - (1, 1, z). The viewpoint of the +observer is passed in vp.

This is basically the opposite of gimp_vector_2d_to_3d().

Parameters

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

sx	the abscissa of the upper-left screen rectangle.
sy	the ordinate of the upper-left screen rectangle.
w	the width of the screen rectangle.
h	the height of the screen rectangle.
x	the abscissa of the point in the screen rectangle to map (return value).
y	the ordinate of the point in the screen rectangle to map (return value).
vp	position of the observer.
p	the 3D point to project to the plane.

Types and Values

struct GimpVector2

struct GimpVector2 {
+  gdouble x, y;
+};
+

A two dimensional vector.

Members

+++++ + + + + + + + + + + + + +

gdouble `x`;	the x axis
gdouble `y`;	the y axis

struct GimpVector3

struct GimpVector3 {
+  gdouble x, y, z;
+};
+

A three dimensional vector.

Members

+++++ + + + + + + + + + + + + + + + + + +

gdouble `x`;	the x axis
gdouble `y`;	the y axis
gdouble `z`;	the z axis

struct GimpVector4

struct GimpVector4 {
+  gdouble x, y, z, w;
+};
+

A four dimensional vector.

Members

+++++ + + + + + + + + + + + + + + + + + + + + + + +

gdouble `x`;	the x axis
gdouble `y`;	the y axis
gdouble `z`;	the z axis
gdouble `w`;	the w axis

+Part I. GIMP Math Library

Table of Contents

+GimpMath — Mathematical definitions and macros. +
+GimpMatrix — Utilities to set up and manipulate 3x3 +transformation matrices. +
+GimpVector — Utilities to set up and manipulate vectors. +
+GimpMD5 — The MD5 message-digest algorithm +

+ + + \ No newline at end of file diff --git a/devel-docs/libgimpmath/html/right-insensitive.png b/devel-docs/libgimpmath/html/right-insensitive.png new file mode 100644 index 0000000..763208d Binary files /dev/null and b/devel-docs/libgimpmath/html/right-insensitive.png differ diff --git a/devel-docs/libgimpmath/html/right.png b/devel-docs/libgimpmath/html/right.png new file mode 100644 index 0000000..eb90dd4 Binary files /dev/null and b/devel-docs/libgimpmath/html/right.png differ diff --git a/devel-docs/libgimpmath/html/style.css b/devel-docs/libgimpmath/html/style.css new file mode 100644 index 0000000..41781ba --- /dev/null +++ b/devel-docs/libgimpmath/html/style.css @@ -0,0 +1,530 @@ +body +{ + font-family: cantarell, sans-serif; +} +.synopsis, .classsynopsis +{ + /* tango:aluminium 1/2 */ + background: #eeeeec; + background: rgba(238, 238, 236, 0.5); + border: solid 1px rgb(238, 238, 236); + padding: 0.5em; +} +.programlisting +{ + /* tango:sky blue 0/1 */ + /* fallback for no rgba support */ + background: #e6f3ff; + border: solid 1px #729fcf; + background: rgba(114, 159, 207, 0.1); + border: solid 1px rgba(114, 159, 207, 0.2); + padding: 0.5em; +} +.variablelist +{ + padding: 4px; + margin-left: 3em; +} +.variablelist td:first-child +{ + vertical-align: top; +} + +span.nowrap { + white-space: nowrap; +} + +div.gallery-float +{ + float: left; + padding: 10px; +} +div.gallery-float img +{ + border-style: none; +} +div.gallery-spacer +{ + clear: both; +} + +a, a:visited +{ + text-decoration: none; + /* tango:sky blue 2 */ + color: #3465a4; +} +a:hover +{ + text-decoration: underline; + /* tango:sky blue 1 */ + color: #729fcf; +} + +.function_type, +.variable_type, +.property_type, +.signal_type, +.parameter_name, +.struct_member_name, +.union_member_name, +.define_keyword, +.datatype_keyword, +.typedef_keyword +{ + text-align: right; +} + +/* dim non-primary columns */ +.c_punctuation, +.function_type, +.variable_type, +.property_type, +.signal_type, +.define_keyword, +.datatype_keyword, +.typedef_keyword, +.property_flags, +.signal_flags, +.parameter_annotations, +.enum_member_annotations, +.struct_member_annotations, +.union_member_annotations +{ + color: #888a85; +} + +.function_type a, +.function_type a:visited, +.function_type a:hover, +.property_type a, +.property_type a:visited, +.property_type a:hover, +.signal_type a, +.signal_type a:visited, +.signal_type a:hover, +.signal_flags a, +.signal_flags a:visited, +.signal_flags a:hover +{ + color: #729fcf; +} + +td p +{ + margin: 0.25em; +} + +div.informaltable table[border="1"], +div.table table +{ + border-collapse: collapse; + border-spacing: 0px; + /* tango:aluminium 3 */ + border: solid 1px #babdb6; +} + +div.informaltable table[border="1"] td, +div.informaltable table th, +div.table table td, div.table table th +{ + /* tango:aluminium 3 */ + border: solid 1px #babdb6; + padding: 3px; + vertical-align: top; +} + +div.informaltable table[border="1"] th, +div.table table th +{ + /* tango:aluminium 2 */ + background-color: #d3d7cf; +} + +h4 +{ + color: #555753; + margin-top: 1em; + margin-bottom: 1em; +} + +hr +{ + /* tango:aluminium 1 */ + color: #d3d7cf; + background: #d3d7cf; + border: none 0px; + height: 1px; + clear: both; + margin: 2.0em 0em 2.0em 0em; +} + +dl.toc dt +{ + padding-bottom: 0.25em; +} + +dl.toc > dt +{ + padding-top: 0.25em; + padding-bottom: 0.25em; + font-weight: bold; +} + +dl.toc > dl +{ + padding-bottom: 0.5em; +} + +.parameter +{ + font-style: normal; +} + +.footer +{ + padding-top: 3.5em; + /* tango:aluminium 3 */ + color: #babdb6; + text-align: center; + font-size: 80%; +} + +.informalfigure, +.figure +{ + margin: 1em; +} + +.informalexample, +.example +{ + margin-top: 1em; + margin-bottom: 1em; +} + +.warning +{ + /* tango:orange 0/1 */ + background: #ffeed9; + background: rgba(252, 175, 62, 0.1); + border-color: #ffb04f; + border-color: rgba(252, 175, 62, 0.2); +} +.note +{ + /* tango:chameleon 0/0.5 */ + background: #d8ffb2; + background: rgba(138, 226, 52, 0.1); + border-color: #abf562; + border-color: rgba(138, 226, 52, 0.2); +} +div.blockquote +{ + border-color: #eeeeec; +} +.note, .warning, div.blockquote +{ + padding: 0.5em; + border-width: 1px; + border-style: solid; + margin: 2em; +} +.note p, .warning p +{ + margin: 0; +} + +div.warning h3.title, +div.note h3.title +{ + display: none; +} + +p + div.section +{ + margin-top: 1em; +} + +div.refnamediv, +div.refsynopsisdiv, +div.refsect1, +div.refsect2, +div.toc, +div.section +{ + margin-bottom: 1em; +} + +/* blob links */ +h2 .extralinks, h3 .extralinks +{ + float: right; + /* tango:aluminium 3 */ + color: #babdb6; + font-size: 80%; + font-weight: normal; +} + +.lineart +{ + color: #d3d7cf; + font-weight: normal; +} + +.annotation +{ + /* tango:aluminium 5 */ + color: #555753; + font-weight: normal; +} + +.structfield +{ + font-style: normal; + font-weight: normal; +} + +acronym,abbr +{ + border-bottom: 1px dotted gray; +} + +.listing_frame { + /* tango:sky blue 1 */ + border: solid 1px #729fcf; + border: solid 1px rgba(114, 159, 207, 0.2); + padding: 0px; +} + +.listing_lines, .listing_code { + margin-top: 0px; + margin-bottom: 0px; + padding: 0.5em; +} +.listing_lines { + /* tango:sky blue 0.5 */ + background: #a6c5e3; + background: rgba(114, 159, 207, 0.2); + /* tango:aluminium 6 */ + color: #2e3436; +} +.listing_code { + /* tango:sky blue 0 */ + background: #e6f3ff; + background: rgba(114, 159, 207, 0.1); +} +.listing_code .programlisting { + /* override from previous */ + border: none 0px; + padding: 0px; + background: none; +} +.listing_lines pre, .listing_code pre { + margin: 0px; +} + +@media screen { + /* these have a ^{as a first child, but since there are no parent selectors
+ * we can't use that. */
+ a.footnote
+ {
+ position: relative;
+ top: 0em ! important;
+ }
+ /* this is needed so that the local anchors are displayed below the naviagtion */
+ div.footnote a[name], div.refnamediv a[name], div.refsect1 a[name], div.refsect2 a[name], div.index a[name], div.glossary a[name], div.sect1 a[name]
+ {
+ display: inline-block;
+ position: relative;
+ top:-5em;
+ }
+ /* this seems to be a bug in the xsl style sheets when generating indexes */
+ div.index div.index
+ {
+ top: 0em;
+ }
+ /* make space for the fixed navigation bar and add space at the bottom so that
+ * link targets appear somewhat close to top
+ */
+ body
+ {
+ padding-top: 2.5em;
+ padding-bottom: 500px;
+ max-width: 60em;
+ }
+ p
+ {
+ max-width: 60em;
+ }
+ /* style and size the navigation bar */
+ table.navigation#top
+ {
+ position: fixed;
+ background: #e2e2e2;
+ border-bottom: solid 1px #babdb6;
+ border-spacing: 5px;
+ margin-top: 0;
+ margin-bottom: 0;
+ top: 0;
+ left: 0;
+ z-index: 10;
+ }
+ table.navigation#top td
+ {
+ padding-left: 6px;
+ padding-right: 6px;
+ }
+ .navigation a, .navigation a:visited
+ {
+ /* tango:sky blue 3 */
+ color: #204a87;
+ }
+ .navigation a:hover
+ {
+ /* tango:sky blue 2 */
+ color: #3465a4;
+ }
+ td.shortcuts
+ {
+ /* tango:sky blue 2 */
+ color: #3465a4;
+ font-size: 80%;
+ white-space: nowrap;
+ }
+ td.shortcuts .dim
+ {
+ color: #babdb6;
+ }
+ .navigation .title
+ {
+ font-size: 80%;
+ max-width: none;
+ margin: 0px;
+ font-weight: normal;
+ }
+}
+@media screen and (min-width: 60em) {
+ /* screen larger than 60em */
+ body { margin: auto; }
+}
+@media screen and (max-width: 60em) {
+ /* screen less than 60em */
+ #nav_hierarchy { display: none; }
+ #nav_interfaces { display: none; }
+ #nav_prerequisites { display: none; }
+ #nav_derived_interfaces { display: none; }
+ #nav_implementations { display: none; }
+ #nav_child_properties { display: none; }
+ #nav_style_properties { display: none; }
+ #nav_index { display: none; }
+ #nav_glossary { display: none; }
+ .gallery_image { display: none; }
+ .property_flags { display: none; }
+ .signal_flags { display: none; }
+ .parameter_annotations { display: none; }
+ .enum_member_annotations { display: none; }
+ .struct_member_annotations { display: none; }
+ .union_member_annotations { display: none; }
+ /* now that a column is hidden, optimize space */
+ col.parameters_name { width: auto; }
+ col.parameters_description { width: auto; }
+ col.struct_members_name { width: auto; }
+ col.struct_members_description { width: auto; }
+ col.enum_members_name { width: auto; }
+ col.enum_members_description { width: auto; }
+ col.union_members_name { width: auto; }
+ col.union_members_description { width: auto; }
+ .listing_lines { display: none; }
+}
+@media print {
+ table.navigation {
+ visibility: collapse;
+ display: none;
+ }
+ div.titlepage table.navigation {
+ visibility: visible;
+ display: table;
+ background: #e2e2e2;
+ border: solid 1px #babdb6;
+ margin-top: 0;
+ margin-bottom: 0;
+ top: 0;
+ left: 0;
+ height: 3em;
+ }
+}
+
+pre { line-height: 125%; margin: 0; }
+td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
+span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
+td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
+span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
+.hll { background-color: #ffffcc }
+.c { color: #408080; font-style: italic } /* Comment */
+.err { border: 1px solid #FF0000 } /* Error */
+.k { color: #008000; font-weight: bold } /* Keyword */
+.o { color: #666666 } /* Operator */
+.ch { color: #408080; font-style: italic } /* Comment.Hashbang */
+.cm { color: #408080; font-style: italic } /* Comment.Multiline */
+.cp { color: #BC7A00 } /* Comment.Preproc */
+.cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */
+.c1 { color: #408080; font-style: italic } /* Comment.Single */
+.cs { color: #408080; font-style: italic } /* Comment.Special */
+.gd { color: #A00000 } /* Generic.Deleted */
+.ge { font-style: italic } /* Generic.Emph */
+.gr { color: #FF0000 } /* Generic.Error */
+.gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.gi { color: #00A000 } /* Generic.Inserted */
+.go { color: #888888 } /* Generic.Output */
+.gp { color: #000080; font-weight: bold } /* Generic.Prompt */
+.gs { font-weight: bold } /* Generic.Strong */
+.gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.gt { color: #0044DD } /* Generic.Traceback */
+.kc { color: #008000; font-weight: bold } /* Keyword.Constant */
+.kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
+.kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
+.kp { color: #008000 } /* Keyword.Pseudo */
+.kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
+.kt { color: #B00040 } /* Keyword.Type */
+.m { color: #666666 } /* Literal.Number */
+.s { color: #BA2121 } /* Literal.String */
+.na { color: #7D9029 } /* Name.Attribute */
+.nb { color: #008000 } /* Name.Builtin */
+.nc { color: #0000FF; font-weight: bold } /* Name.Class */
+.no { color: #880000 } /* Name.Constant */
+.nd { color: #AA22FF } /* Name.Decorator */
+.ni { color: #999999; font-weight: bold } /* Name.Entity */
+.ne { color: #D2413A; font-weight: bold } /* Name.Exception */
+.nf { color: #0000FF } /* Name.Function */
+.nl { color: #A0A000 } /* Name.Label */
+.nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
+.nt { color: #008000; font-weight: bold } /* Name.Tag */
+.nv { color: #19177C } /* Name.Variable */
+.ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
+.w { color: #bbbbbb } /* Text.Whitespace */
+.mb { color: #666666 } /* Literal.Number.Bin */
+.mf { color: #666666 } /* Literal.Number.Float */
+.mh { color: #666666 } /* Literal.Number.Hex */
+.mi { color: #666666 } /* Literal.Number.Integer */
+.mo { color: #666666 } /* Literal.Number.Oct */
+.sa { color: #BA2121 } /* Literal.String.Affix */
+.sb { color: #BA2121 } /* Literal.String.Backtick */
+.sc { color: #BA2121 } /* Literal.String.Char */
+.dl { color: #BA2121 } /* Literal.String.Delimiter */
+.sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
+.s2 { color: #BA2121 } /* Literal.String.Double */
+.se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
+.sh { color: #BA2121 } /* Literal.String.Heredoc */
+.si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
+.sx { color: #008000 } /* Literal.String.Other */
+.sr { color: #BB6688 } /* Literal.String.Regex */
+.s1 { color: #BA2121 } /* Literal.String.Single */
+.ss { color: #19177C } /* Literal.String.Symbol */
+.bp { color: #008000 } /* Name.Builtin.Pseudo */
+.fm { color: #0000FF } /* Name.Function.Magic */
+.vc { color: #19177C } /* Name.Variable.Class */
+.vg { color: #19177C } /* Name.Variable.Global */
+.vi { color: #19177C } /* Name.Variable.Instance */
+.vm { color: #19177C } /* Name.Variable.Magic */
+.il { color: #666666 } /* Literal.Number.Integer.Long */
\ No newline at end of file
diff --git a/devel-docs/libgimpmath/html/up-insensitive.png b/devel-docs/libgimpmath/html/up-insensitive.png
new file mode 100644
index 0000000..478700c
Binary files /dev/null and b/devel-docs/libgimpmath/html/up-insensitive.png differ
diff --git a/devel-docs/libgimpmath/html/up.png b/devel-docs/libgimpmath/html/up.png
new file mode 100644
index 0000000..636d50d
Binary files /dev/null and b/devel-docs/libgimpmath/html/up.png differ
--
cgit v1.2.3}