callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

app/core/gimp-transform-utils.[ch]. switch from x1,y1,x2,y2 bounding boxes

Browse Source 
2004-10-27  Michael Natterer  <mitch@gimp.org>

	* app/core/gimp-transform-utils.[ch]. switch from x1,y1,x2,y2
	bounding boxes to x,y,width,height ones. Added
	gimp_transform_matrix_flip_free(). Renamed some parameters to be
	consistent with others. Some internal cleanup.

	* app/tools/gimpperspectivetool.c
	* app/tools/gimpscaletool.c
	* app/tools/gimpsheartool.c
	* tools/pdbgen/pdb/drawable_transform.pdb
	* tools/pdbgen/pdb/transform_tools.pdb: changed accordingly.

	* tools/pdbgen/pdb/drawable_transform.pdb
	* tools/pdbgen/pdb/transform_tools.pdb: guard all transform
	wrappers with if(gimp_drawable_mask_intersect(...)), also the
	ones which don't need the returned bounding box.

	* tools/pdbgen/pdb/drawable_transform.pdb: renamed some parameters
	and added gimp_drawable_transform_matrix() which takes the 9
	coefficients of a 3x3 matrix for ultimate flexibility ;)

	* app/pdb/drawable_transform_cmds.c
	* app/pdb/internal_procs.c
	* app/pdb/transform_tools_cmds.c
	* libgimp/gimpdrawabletransform_pdb.[ch]: regenerated.
This commit is contained in:
Michael Natterer
2004-10-27 17:56:02 +00:00
committed by Michael Natterer
parent 4349469e3c
commit d0ab9a7470
13 changed files with 1188 additions and 733 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
ChangeLog
View File

@ -1,3 +1,30 @@
2004-10-27 Michael Natterer <mitch@gimp.org>
* app/core/gimp-transform-utils.[ch]. switch from x1,y1,x2,y2
bounding boxes to x,y,width,height ones. Added
gimp_transform_matrix_flip_free(). Renamed some parameters to be
consistent with others. Some internal cleanup.
* app/tools/gimpperspectivetool.c
* app/tools/gimpscaletool.c
* app/tools/gimpsheartool.c
* tools/pdbgen/pdb/drawable_transform.pdb
* tools/pdbgen/pdb/transform_tools.pdb: changed accordingly.
* tools/pdbgen/pdb/drawable_transform.pdb
* tools/pdbgen/pdb/transform_tools.pdb: guard all transform
wrappers with if(gimp_drawable_mask_intersect(...)), also the
ones which don't need the returned bounding box.
* tools/pdbgen/pdb/drawable_transform.pdb: renamed some parameters
and added gimp_drawable_transform_matrix() which takes the 9
coefficients of a 3x3 matrix for ultimate flexibility ;)
* app/pdb/drawable_transform_cmds.c
* app/pdb/internal_procs.c
* app/pdb/transform_tools_cmds.c
* libgimp/gimpdrawabletransform_pdb.[ch]: regenerated.
2004-10-27 Sven Neumann <sven@gimp.org> 2004-10-27 Sven Neumann <sven@gimp.org>
* app/actions/dockable-actions.c (dockable_toggle_actions): changed * app/actions/dockable-actions.c (dockable_toggle_actions): changed

196
app/core/gimp-transform-utils.c
View File

@ -32,6 +32,8 @@ gimp_transform_matrix_flip (GimpOrientationType flip_type,
gdouble axis, gdouble axis,
GimpMatrix3 *result) GimpMatrix3 *result)
{ {
g_return_if_fail (result != NULL);
gimp_matrix3_identity (result); gimp_matrix3_identity (result);
switch (flip_type) switch (flip_type)
@ -54,127 +56,159 @@ gimp_transform_matrix_flip (GimpOrientationType flip_type,
} }
void void
gimp_transform_matrix_rotate (gint x1, gimp_transform_matrix_flip_free (gint x,
gint y1, gint y,
gint x2, gint width,
gint y2, gint height,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
GimpMatrix3 *result)
{
gdouble angle;
gdouble dx, dy;
g_return_if_fail (result != NULL);
angle = atan2 (y2 - y1, x2 - x1);
dx = x - x1;
dy = (x1 + ((y2 - y1) / (x2 - x1) ) * x) - y1;
gimp_matrix3_identity (result);
gimp_matrix3_translate (result, dx, dy);
gimp_matrix3_rotate (result, -angle);
gimp_matrix3_scale (result, 1.0, -1.0);
gimp_matrix3_rotate (result, angle);
gimp_matrix3_translate (result, -dx, -dy);
}
void
gimp_transform_matrix_rotate (gint x,
gint y,
gint width,
gint height,
gdouble angle, gdouble angle,
GimpMatrix3 *result) GimpMatrix3 *result)
{ {
gdouble cx; gdouble center_x;
gdouble cy; gdouble center_y;
cx = (gdouble) (x1 + x2) / 2.0; g_return_if_fail (result != NULL);
cy = (gdouble) (y1 + y2) / 2.0;
center_x = (gdouble) x + (gdouble) width / 2.0;
center_y = (gdouble) y + (gdouble) height / 2.0;
gimp_matrix3_identity (result); gimp_matrix3_identity (result);
gimp_matrix3_translate (result, -cx, -cy); gimp_matrix3_translate (result, -center_x, -center_y);
gimp_matrix3_rotate (result, angle); gimp_matrix3_rotate (result, angle);
gimp_matrix3_translate (result, +cx, +cy); gimp_matrix3_translate (result, +center_x, +center_y);
} }
void void
gimp_transform_matrix_rotate_center (gdouble cx, gimp_transform_matrix_rotate_center (gdouble center_x,
gdouble cy, gdouble center_y,
gdouble angle, gdouble angle,
GimpMatrix3 *result) GimpMatrix3 *result)
{ {
g_return_if_fail (result != NULL);
gimp_matrix3_identity (result); gimp_matrix3_identity (result);
gimp_matrix3_translate (result, -cx, -cy); gimp_matrix3_translate (result, -center_x, -center_y);
gimp_matrix3_rotate (result, angle); gimp_matrix3_rotate (result, angle);
gimp_matrix3_translate (result, +cx, +cy); gimp_matrix3_translate (result, +center_x, +center_y);
} }
void void
gimp_transform_matrix_scale (gint x1, gimp_transform_matrix_scale (gint x,
gint y1, gint y,
gint x2, gint width,
gint y2, gint height,
gdouble tx1, gdouble t_x,
gdouble ty1, gdouble t_y,
gdouble tx2, gdouble t_width,
gdouble ty2, gdouble t_height,
GimpMatrix3 *result) GimpMatrix3 *result)
{ {
gdouble scalex; gdouble scale_x = 1.0;
gdouble scaley; gdouble scale_y = 1.0;
scalex = scaley = 1.0; g_return_if_fail (result != NULL);
if ((x2 - x1) > 0) if (width > 0)
scalex = (tx2 - tx1) / (gdouble) (x2 - x1); scale_x = t_width / (gdouble) width;
if ((y2 - y1) > 0) if (height > 0)
scaley = (ty2 - ty1) / (gdouble) (y2 - y1); scale_y = t_height / (gdouble) height;
gimp_matrix3_identity (result); gimp_matrix3_identity (result);
gimp_matrix3_translate (result, -x1, -y1); gimp_matrix3_translate (result, -x, -y);
gimp_matrix3_scale (result, scalex, scaley); gimp_matrix3_scale (result, scale_x, scale_y);
gimp_matrix3_translate (result, tx1, ty1); gimp_matrix3_translate (result, t_x, t_y);
} }
void void
gimp_transform_matrix_shear (gint x1, gimp_transform_matrix_shear (gint x,
gint y1, gint y,
gint x2, gint width,
gint y2, gint height,
GimpOrientationType orientation, GimpOrientationType orientation,
gdouble amount, gdouble amount,
GimpMatrix3 *result) GimpMatrix3 *result)
{ {
gint width; gdouble center_x;
gint height; gdouble center_y;
gdouble cx;
gdouble cy;
width = x2 - x1; g_return_if_fail (result != NULL);
height = y2 - y1;
if (width == 0) if (width == 0)
width = 1; width = 1;
if (height == 0) if (height == 0)
height = 1; height = 1;
cx = (gdouble) (x1 + x2) / 2.0; center_x = (gdouble) x + (gdouble) width / 2.0;
cy = (gdouble) (y1 + y2) / 2.0; center_y = (gdouble) y + (gdouble) height / 2.0;
gimp_matrix3_identity (result); gimp_matrix3_identity (result);
gimp_matrix3_translate (result, -cx, -cy); gimp_matrix3_translate (result, -center_x, -center_y);
if (orientation == GIMP_ORIENTATION_HORIZONTAL) if (orientation == GIMP_ORIENTATION_HORIZONTAL)
gimp_matrix3_xshear (result, amount / height); gimp_matrix3_xshear (result, amount / height);
else else
gimp_matrix3_yshear (result, amount / width); gimp_matrix3_yshear (result, amount / width);
gimp_matrix3_translate (result, +cx, +cy); gimp_matrix3_translate (result, +center_x, +center_y);
} }
void void
gimp_transform_matrix_perspective (gint x1, gimp_transform_matrix_perspective (gint x,
gint y1, gint y,
gint x2, gint width,
gint y2, gint height,
gdouble tx1, gdouble t_x1,
gdouble ty1, gdouble t_y1,
gdouble tx2, gdouble t_x2,
gdouble ty2, gdouble t_y2,
gdouble tx3, gdouble t_x3,
gdouble ty3, gdouble t_y3,
gdouble tx4, gdouble t_x4,
gdouble ty4, gdouble t_y4,
GimpMatrix3 *result) GimpMatrix3 *result)
{ {
GimpMatrix3 matrix; GimpMatrix3 matrix;
gdouble scalex; gdouble scalex;
gdouble scaley; gdouble scaley;
g_return_if_fail (result != NULL);
scalex = scaley = 1.0; scalex = scaley = 1.0;
if ((x2 - x1) > 0) if (width > 0)
scalex = 1.0 / (gdouble) (x2 - x1); scalex = 1.0 / (gdouble) width;
if ((y2 - y1) > 0) if (height > 0)
scaley = 1.0 / (gdouble) (y2 - y1); scaley = 1.0 / (gdouble) height;
/* Determine the perspective transform that maps from /* Determine the perspective transform that maps from
* the unit cube to the transformed coordinates * the unit cube to the transformed coordinates
@ -182,23 +216,23 @@ gimp_transform_matrix_perspective (gint x1,
{ {
gdouble dx1, dx2, dx3, dy1, dy2, dy3; gdouble dx1, dx2, dx3, dy1, dy2, dy3;
dx1 = tx2 - tx4; dx1 = t_x2 - t_x4;
dx2 = tx3 - tx4; dx2 = t_x3 - t_x4;
dx3 = tx1 - tx2 + tx4 - tx3; dx3 = t_x1 - t_x2 + t_x4 - t_x3;
dy1 = ty2 - ty4; dy1 = t_y2 - t_y4;
dy2 = ty3 - ty4; dy2 = t_y3 - t_y4;
dy3 = ty1 - ty2 + ty4 - ty3; dy3 = t_y1 - t_y2 + t_y4 - t_y3;
/* Is the mapping affine? */ /* Is the mapping affine? */
if ((dx3 == 0.0) && (dy3 == 0.0)) if ((dx3 == 0.0) && (dy3 == 0.0))
{ {
matrix.coeff[0][0] = tx2 - tx1; matrix.coeff[0][0] = t_x2 - t_x1;
matrix.coeff[0][1] = tx4 - tx2; matrix.coeff[0][1] = t_x4 - t_x2;
matrix.coeff[0][2] = tx1; matrix.coeff[0][2] = t_x1;
matrix.coeff[1][0] = ty2 - ty1; matrix.coeff[1][0] = t_y2 - t_y1;
matrix.coeff[1][1] = ty4 - ty2; matrix.coeff[1][1] = t_y4 - t_y2;
matrix.coeff[1][2] = ty1; matrix.coeff[1][2] = t_y1;
matrix.coeff[2][0] = 0.0; matrix.coeff[2][0] = 0.0;
matrix.coeff[2][1] = 0.0; matrix.coeff[2][1] = 0.0;
} }
@ -221,20 +255,20 @@ gimp_transform_matrix_perspective (gint x1,
else else
matrix.coeff[2][1] = det1 / det2; matrix.coeff[2][1] = det1 / det2;
matrix.coeff[0][0] = tx2 - tx1 + matrix.coeff[2][0] * tx2; matrix.coeff[0][0] = t_x2 - t_x1 + matrix.coeff[2][0] * t_x2;
matrix.coeff[0][1] = tx3 - tx1 + matrix.coeff[2][1] * tx3; matrix.coeff[0][1] = t_x3 - t_x1 + matrix.coeff[2][1] * t_x3;
matrix.coeff[0][2] = tx1; matrix.coeff[0][2] = t_x1;
matrix.coeff[1][0] = ty2 - ty1 + matrix.coeff[2][0] * ty2; matrix.coeff[1][0] = t_y2 - t_y1 + matrix.coeff[2][0] * t_y2;
matrix.coeff[1][1] = ty3 - ty1 + matrix.coeff[2][1] * ty3; matrix.coeff[1][1] = t_y3 - t_y1 + matrix.coeff[2][1] * t_y3;
matrix.coeff[1][2] = ty1; matrix.coeff[1][2] = t_y1;
} }
matrix.coeff[2][2] = 1.0; matrix.coeff[2][2] = 1.0;
} }
gimp_matrix3_identity (result); gimp_matrix3_identity (result);
gimp_matrix3_translate (result, -x1, -y1); gimp_matrix3_translate (result, -x, -y);
gimp_matrix3_scale (result, scalex, scaley); gimp_matrix3_scale (result, scalex, scaley);
gimp_matrix3_mult (&matrix, result); gimp_matrix3_mult (&matrix, result);
} }

89
app/core/gimp-transform-utils.h
View File

@ -21,47 +21,56 @@
void gimp_transform_matrix_flip (GimpOrientationType flip_type, void gimp_transform_matrix_flip (GimpOrientationType flip_type,
gdouble axis, gdouble axis,
GimpMatrix3 *result); GimpMatrix3 *result);
void gimp_transform_matrix_rotate (gint x1, void gimp_transform_matrix_flip_free (gint x,
gint y1, gint y,
gint x2, gint width,
gint y2, gint height,
gdouble angle, gdouble x1,
GimpMatrix3 *result); gdouble y1,
void gimp_transform_matrix_rotate_center (gdouble cx, gdouble x2,
gdouble cy, gdouble y2,
gdouble angle, GimpMatrix3 *result);
GimpMatrix3 *result); void gimp_transform_matrix_rotate (gint x,
void gimp_transform_matrix_scale (gint x1, gint y,
gint y1, gint width,
gint x2, gint height,
gint y2, gdouble angle,
gdouble tx1, GimpMatrix3 *result);
gdouble ty1, void gimp_transform_matrix_rotate_center (gdouble center_x,
gdouble tx2, gdouble center_y,
gdouble ty2, gdouble angle,
GimpMatrix3 *result); GimpMatrix3 *result);
void gimp_transform_matrix_shear (gint x1, void gimp_transform_matrix_scale (gint x,
gint y1, gint y,
gint x2, gint width,
gint y2, gint height,
gdouble t_x,
gdouble t_y,
gdouble t_width,
gdouble t_height,
GimpMatrix3 *result);
void gimp_transform_matrix_shear (gint x,
gint y,
gint width,
gint height,
GimpOrientationType orientation, GimpOrientationType orientation,
gdouble amount, gdouble amount,
GimpMatrix3 *result); GimpMatrix3 *result);
void gimp_transform_matrix_perspective (gint x1, void gimp_transform_matrix_perspective (gint x,
gint y1, gint y,
gint x2, gint width,
gint y2, gint height,
gdouble tx1, gdouble t_x1,
gdouble ty1, gdouble t_y1,
gdouble tx2, gdouble t_x2,
gdouble ty2, gdouble t_y2,
gdouble tx3, gdouble t_x3,
gdouble ty3, gdouble t_y3,
gdouble tx4, gdouble t_x4,
gdouble ty5, gdouble t_y4,
GimpMatrix3 *result); GimpMatrix3 *result);
#endif /* __GIMP_TRANSFORM_UTILS_H__ */ #endif /* __GIMP_TRANSFORM_UTILS_H__ */

486
app/pdb/drawable_transform_cmds.c
View File

@ -44,6 +44,7 @@ static ProcRecord drawable_transform_rotate_proc;
static ProcRecord drawable_transform_scale_proc; static ProcRecord drawable_transform_scale_proc;
static ProcRecord drawable_transform_shear_proc; static ProcRecord drawable_transform_shear_proc;
static ProcRecord drawable_transform_2d_proc; static ProcRecord drawable_transform_2d_proc;
static ProcRecord drawable_transform_matrix_proc;
void void
register_drawable_transform_procs (Gimp *gimp) register_drawable_transform_procs (Gimp *gimp)
@ -55,6 +56,7 @@ register_drawable_transform_procs (Gimp *gimp)
procedural_db_register (gimp, &drawable_transform_scale_proc); procedural_db_register (gimp, &drawable_transform_scale_proc);
procedural_db_register (gimp, &drawable_transform_shear_proc); procedural_db_register (gimp, &drawable_transform_shear_proc);
procedural_db_register (gimp, &drawable_transform_2d_proc); procedural_db_register (gimp, &drawable_transform_2d_proc);
procedural_db_register (gimp, &drawable_transform_matrix_proc);
} }
static Argument * static Argument *
@ -105,14 +107,19 @@ drawable_transform_flip_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
success = gimp_drawable_transform_flip (drawable, gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
context, {
transform_direction, success = gimp_drawable_transform_flip (drawable,
center, axis, context,
clip_result); transform_direction,
center, axis,
clip_result);
}
} }
return_args = procedural_db_return_args (&drawable_transform_flip_proc, success); return_args = procedural_db_return_args (&drawable_transform_flip_proc, success);
@ -185,7 +192,7 @@ static ProcRecord drawable_transform_flip_proc =
{ {
"gimp_drawable_transform_flip", "gimp_drawable_transform_flip",
"Flip the specified drawable either vertically or horizontally.", "Flip the specified drawable either vertically or horizontally.",
"This tool flips the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then flipped. If center is set to true, the flip is around the image center. Otherwise, the coordinate of the axis needs to be specified. The return value is the ID of the flipped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and flipped drawable.", "This procedure flips the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then flipped. If center is set to true, the flip is around the image center. Otherwise, the coordinate of the axis needs to be specified. The return value is the ID of the flipped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and flipped drawable.",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"2004", "2004",
@ -207,10 +214,10 @@ drawable_transform_flip_free_invoker (Gimp *gimp,
gboolean success = TRUE; gboolean success = TRUE;
Argument *return_args; Argument *return_args;
GimpDrawable *drawable; GimpDrawable *drawable;
gdouble x0;
gdouble y0;
gdouble x1; gdouble x1;
gdouble y1; gdouble y1;
gdouble x2;
gdouble y2;
gint32 transform_direction; gint32 transform_direction;
gint32 interpolation; gint32 interpolation;
gboolean supersample; gboolean supersample;
@ -221,13 +228,13 @@ drawable_transform_flip_free_invoker (Gimp *gimp,
if (! (GIMP_IS_DRAWABLE (drawable) && ! gimp_item_is_removed (GIMP_ITEM (drawable)))) if (! (GIMP_IS_DRAWABLE (drawable) && ! gimp_item_is_removed (GIMP_ITEM (drawable))))
success = FALSE; success = FALSE;
x1 = args[1].value.pdb_float; x0 = args[1].value.pdb_float;
y1 = args[2].value.pdb_float; y0 = args[2].value.pdb_float;
x2 = args[3].value.pdb_float; x1 = args[3].value.pdb_float;
y2 = args[4].value.pdb_float; y1 = args[4].value.pdb_float;
transform_direction = args[5].value.pdb_int; transform_direction = args[5].value.pdb_int;
if (transform_direction < GIMP_TRANSFORM_FORWARD || transform_direction > GIMP_TRANSFORM_BACKWARD) if (transform_direction < GIMP_TRANSFORM_FORWARD || transform_direction > GIMP_TRANSFORM_BACKWARD)
@ -247,44 +254,34 @@ drawable_transform_flip_free_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_flip_free (x, y, width, height,
gdouble angle; x0, y0, x1, y1,
gdouble dx, dy; &matrix);
GimpMatrix3 matrix;
angle = atan2 ((y2 - y1), (x2 - x1)); if (progress)
dx = x - x1; gimp_progress_start (progress, _("Flip..."), FALSE);
dy = (x1 + ( (gdouble) (y2 - y1) / (x2 - x1) ) * x ) - y1;
gimp_matrix3_identity (&matrix); /* Transform the selection */
gimp_matrix3_translate (&matrix, dx, dy); success = gimp_drawable_transform_affine (drawable, context,
gimp_matrix3_rotate (&matrix, -angle); &matrix,
gimp_matrix3_scale (&matrix, 1.0, -1.0); transform_direction,
gimp_matrix3_rotate (&matrix, angle); interpolation,
gimp_matrix3_translate (&matrix, -dx, -dy); supersample,
recursion_level,
if (progress) clip_result,
gimp_progress_start (progress, _("Flip..."), FALSE); progress);
if (progress)
/* Transform the selection */ gimp_progress_end (progress);
success = gimp_drawable_transform_affine (drawable, context,
&matrix,
transform_direction,
interpolation,
supersample,
recursion_level,
clip_result,
progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
@ -305,22 +302,22 @@ static ProcArg drawable_transform_flip_free_inargs[] =
}, },
{ {
GIMP_PDB_FLOAT, GIMP_PDB_FLOAT,
"x1", "x0",
"horz. coord. of one end of axis" "horz. coord. of one end of axis"
}, },
{ {
GIMP_PDB_FLOAT, GIMP_PDB_FLOAT,
"y1", "y0",
"vert. coord. of one end of axis" "vert. coord. of one end of axis"
}, },
{ {
GIMP_PDB_FLOAT, GIMP_PDB_FLOAT,
"x2", "x1",
"horz. coord. of other end of axis" "horz. coord. of other end of axis"
}, },
{ {
GIMP_PDB_FLOAT, GIMP_PDB_FLOAT,
"y2", "y1",
"vert. coord. of other end of axis" "vert. coord. of other end of axis"
}, },
{ {
@ -363,7 +360,7 @@ static ProcRecord drawable_transform_flip_free_proc =
{ {
"gimp_drawable_transform_flip_free", "gimp_drawable_transform_flip_free",
"Flip the specified drawable around a given line.", "Flip the specified drawable around a given line.",
"This tool flips the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then flipped. The axis to flip around is specified by specifying two points from that line. The return value is the ID of the flipped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and flipped drawable. The clip results parameter specifies wheter current selection will affect the transform.", "This procedure flips the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then flipped. The axis to flip around is specified by specifying two points from that line. The return value is the ID of the flipped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and flipped drawable. The clip results parameter specifies wheter current selection will affect the transform.",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"2004", "2004",
@ -430,39 +427,37 @@ drawable_transform_perspective_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_perspective (x, y, width, height,
GimpMatrix3 matrix; trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
trans_info[X2], trans_info[Y2],
trans_info[X3], trans_info[Y3],
&matrix);
/* Assemble the transformation matrix */ if (progress)
gimp_transform_matrix_perspective (x, y, x + width, y + height, gimp_progress_start (progress, _("Perspective..."), FALSE);
trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
trans_info[X2], trans_info[Y2],
trans_info[X3], trans_info[Y3],
&matrix);
if (progress) /* Perspective the selection */
gimp_progress_start (progress, _("Perspective..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result,
progress);
/* Perspective the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result,
progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
@ -561,7 +556,7 @@ static ProcRecord drawable_transform_perspective_proc =
{ {
"gimp_drawable_transform_perspective", "gimp_drawable_transform_perspective",
"Perform a possibly non-affine transformation on the specified drawable, with extra parameters.", "Perform a possibly non-affine transformation on the specified drawable, with extra parameters.",
"This tool performs a possibly non-affine transformation on the specified drawable by allowing the corners of the original bounding box to be arbitrarily remapped to any values. The specified drawable is remapped if no selection exists. However, if a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then remapped as specified. The return value is the ID of the remapped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and remapped drawable. The 4 coordinates specify the new locations of each corner of the original bounding box. By specifying these values, any affine transformation (rotation, scaling, translation) can be affected. Additionally, these values can be specified such that the resulting transformed drawable will appear to have been projected via a perspective transform.", "This procedure performs a possibly non-affine transformation on the specified drawable by allowing the corners of the original bounding box to be arbitrarily remapped to any values. The specified drawable is remapped if no selection exists. However, if a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then remapped as specified. The return value is the ID of the remapped drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and remapped drawable. The 4 coordinates specify the new locations of each corner of the original bounding box. By specifying these values, any affine transformation (rotation, scaling, translation) can be affected. Additionally, these values can be specified such that the resulting transformed drawable will appear to have been projected via a perspective transform.",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"2004", "2004",
@ -584,8 +579,8 @@ drawable_transform_rotate_invoker (Gimp *gimp,
Argument *return_args; Argument *return_args;
GimpDrawable *drawable; GimpDrawable *drawable;
gdouble angle; gdouble angle;
gint32 cx; gint32 center_x;
gint32 cy; gint32 center_y;
gint32 transform_direction; gint32 transform_direction;
gint32 interpolation; gint32 interpolation;
gboolean supersample; gboolean supersample;
@ -598,9 +593,9 @@ drawable_transform_rotate_invoker (Gimp *gimp,
angle = args[1].value.pdb_float; angle = args[1].value.pdb_float;
cx = args[2].value.pdb_int; center_x = args[2].value.pdb_int;
cy = args[3].value.pdb_int; center_y = args[3].value.pdb_int;
transform_direction = args[4].value.pdb_int; transform_direction = args[4].value.pdb_int;
if (transform_direction < GIMP_TRANSFORM_FORWARD || transform_direction > GIMP_TRANSFORM_BACKWARD) if (transform_direction < GIMP_TRANSFORM_FORWARD || transform_direction > GIMP_TRANSFORM_BACKWARD)
@ -620,14 +615,18 @@ drawable_transform_rotate_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
GimpMatrix3 matrix; GimpMatrix3 matrix;
/* Assemble the transformation matrix */ /* Assemble the transformation matrix */
gimp_transform_matrix_rotate_center (cx, cy, angle, &matrix); gimp_transform_matrix_rotate_center (center_x, center_y, angle,
&matrix);
if (progress) if (progress)
gimp_progress_start (progress, _("Rotating..."), FALSE); gimp_progress_start (progress, _("Rotating..."), FALSE);
@ -666,12 +665,12 @@ static ProcArg drawable_transform_rotate_inargs[] =
}, },
{ {
GIMP_PDB_INT32, GIMP_PDB_INT32,
"cx", "center_x",
"The hor. coordinate of the center of rotation" "The hor. coordinate of the center of rotation"
}, },
{ {
GIMP_PDB_INT32, GIMP_PDB_INT32,
"cy", "center_y",
"The vert. coordinate of the center of rotation" "The vert. coordinate of the center of rotation"
}, },
{ {
@ -714,7 +713,7 @@ static ProcRecord drawable_transform_rotate_proc =
{ {
"gimp_drawable_transform_rotate", "gimp_drawable_transform_rotate",
"Rotate the specified drawable about given coordinates through the specified angle.", "Rotate the specified drawable about given coordinates through the specified angle.",
"This tool rotates the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then rotated by the specified amount. The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and rotated drawable.", "This function rotates the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then rotated by the specified amount. The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and rotated drawable.",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"2004", "2004",
@ -773,38 +772,38 @@ drawable_transform_scale_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = (gimp_item_is_attached (GIMP_ITEM (drawable)) && success = (gimp_item_is_attached (GIMP_ITEM (drawable)) &&
trans_info[X0] < trans_info[X1] && trans_info[X0] < trans_info[X1] &&
trans_info[Y0] < trans_info[X1]); trans_info[Y0] < trans_info[X1]);
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_scale (x, y, width, height,
GimpMatrix3 matrix; trans_info[X0],
trans_info[Y0],
trans_info[X1] - trans_info[X0],
trans_info[Y1] - trans_info[Y0],
&matrix);
/* Assemble the transformation matrix */ if (progress)
gimp_transform_matrix_scale (x, y, x + width, y + height, gimp_progress_start (progress, _("Scaling..."), FALSE);
trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
&matrix);
if (progress) /* Scale the selection */
gimp_progress_start (progress, _("Scaling..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result, progress);
/* Scale the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
@ -883,7 +882,7 @@ static ProcRecord drawable_transform_scale_proc =
{ {
"gimp_drawable_transform_scale", "gimp_drawable_transform_scale",
"Scale the specified drawable with extra parameters", "Scale the specified drawable with extra parameters",
"This tool scales the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then scaled by the specified amount. The return value is the ID of the scaled drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and scaled drawable.", "This procedure scales the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then scaled by the specified amount. The return value is the ID of the scaled drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and scaled drawable.",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"2004", "2004",
@ -941,35 +940,33 @@ drawable_transform_shear_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_shear (x, y, width, height,
GimpMatrix3 matrix; shear_type, magnitude,
&matrix);
/* Assemble the transformation matrix */ if (progress)
gimp_transform_matrix_shear (x, y, x + width, y + height, gimp_progress_start (progress, _("Shearing..."), FALSE);
shear_type, magnitude,
&matrix);
if (progress) /* Shear the selection */
gimp_progress_start (progress, _("Shearing..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result, progress);
/* Shear the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
@ -1038,7 +1035,7 @@ static ProcRecord drawable_transform_shear_proc =
{ {
"gimp_drawable_transform_shear", "gimp_drawable_transform_shear",
"Shear the specified drawable about its center by the specified magnitude, with extra parameters.", "Shear the specified drawable about its center by the specified magnitude, with extra parameters.",
"This tool shears the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then sheard by the specified amount. The return value is the ID of the sheard drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and sheard drawable. The shear type parameter indicates whether the shear will be applied horizontally or vertically. The magnitude can be either positive or negative and indicates the extent (in pixels) to shear by.", "This procedure shears the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then sheard by the specified amount. The return value is the ID of the sheard drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and sheard drawable. The shear type parameter indicates whether the shear will be applied horizontally or vertically. The magnitude can be either positive or negative and indicates the extent (in pixels) to shear by.",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"2004", "2004",
@ -1109,11 +1106,14 @@ drawable_transform_2d_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
GimpMatrix3 matrix; GimpMatrix3 matrix;
/* Assemble the transformation matrix */ /* Assemble the transformation matrix */
gimp_matrix3_identity (&matrix); gimp_matrix3_identity (&matrix);
@ -1227,7 +1227,7 @@ static ProcRecord drawable_transform_2d_proc =
{ {
"gimp_drawable_transform_2d", "gimp_drawable_transform_2d",
"Transform the specified drawable in 2d, with extra parameters.", "Transform the specified drawable in 2d, with extra parameters.",
"This tool transforms the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then transformed. The transformation is done by scaling the image by the x and y scale factors about the point (source_x, source_y), then rotating around the same point, then translating that point to the new position (dest_x, dest_y). The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and transformed drawable.", "This procedure transforms the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then transformed. The transformation is done by scaling the image by the x and y scale factors about the point (source_x, source_y), then rotating around the same point, then translating that point to the new position (dest_x, dest_y). The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and transformed drawable.",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"João S. O. Bueno Calligaris", "João S. O. Bueno Calligaris",
"2004", "2004",
@ -1239,3 +1239,215 @@ static ProcRecord drawable_transform_2d_proc =
drawable_transform_2d_outargs, drawable_transform_2d_outargs,
{ { drawable_transform_2d_invoker } } { { drawable_transform_2d_invoker } }
}; };
static Argument *
drawable_transform_matrix_invoker (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
{
gboolean success = TRUE;
Argument *return_args;
GimpDrawable *drawable;
gdouble coeff_0_0;
gdouble coeff_0_1;
gdouble coeff_0_2;
gdouble coeff_1_0;
gdouble coeff_1_1;
gdouble coeff_1_2;
gdouble coeff_2_0;
gdouble coeff_2_1;
gdouble coeff_2_2;
gint32 transform_direction;
gint32 interpolation;
gboolean supersample;
gint32 recursion_level;
gboolean clip_result;
drawable = (GimpDrawable *) gimp_item_get_by_ID (gimp, args[0].value.pdb_int);
if (! (GIMP_IS_DRAWABLE (drawable) && ! gimp_item_is_removed (GIMP_ITEM (drawable))))
success = FALSE;
coeff_0_0 = args[1].value.pdb_float;
coeff_0_1 = args[2].value.pdb_float;
coeff_0_2 = args[3].value.pdb_float;
coeff_1_0 = args[4].value.pdb_float;
coeff_1_1 = args[5].value.pdb_float;
coeff_1_2 = args[6].value.pdb_float;
coeff_2_0 = args[7].value.pdb_float;
coeff_2_1 = args[8].value.pdb_float;
coeff_2_2 = args[9].value.pdb_float;
transform_direction = args[10].value.pdb_int;
if (transform_direction < GIMP_TRANSFORM_FORWARD || transform_direction > GIMP_TRANSFORM_BACKWARD)
success = FALSE;
interpolation = args[11].value.pdb_int;
if (interpolation < GIMP_INTERPOLATION_NONE || interpolation > GIMP_INTERPOLATION_CUBIC)
success = FALSE;
supersample = args[12].value.pdb_int ? TRUE : FALSE;
recursion_level = args[13].value.pdb_int;
if (recursion_level <= 0)
success = FALSE;
clip_result = args[14].value.pdb_int ? TRUE : FALSE;
if (success)
{
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{
GimpMatrix3 matrix;
/* Assemble the transformation matrix */
matrix.coeff[0][0] = coeff_0_0;
matrix.coeff[0][1] = coeff_0_1;
matrix.coeff[0][2] = coeff_0_2;
matrix.coeff[1][0] = coeff_1_0;
matrix.coeff[1][1] = coeff_1_1;
matrix.coeff[1][2] = coeff_1_2;
matrix.coeff[2][0] = coeff_2_0;
matrix.coeff[2][1] = coeff_2_1;
matrix.coeff[2][2] = coeff_2_2;
if (progress)
gimp_progress_start (progress, _("2D Transform..."), FALSE);
/* Transform the selection */
success = gimp_drawable_transform_affine (drawable, context,
&matrix, transform_direction,
interpolation, supersample,
recursion_level,
clip_result, progress);
if (progress)
gimp_progress_end (progress);
}
}
return_args = procedural_db_return_args (&drawable_transform_matrix_proc, success);
if (success)
return_args[1].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable));
return return_args;
}
static ProcArg drawable_transform_matrix_inargs[] =
{
{
GIMP_PDB_DRAWABLE,
"drawable",
"The affected drawable"
},
{
GIMP_PDB_FLOAT,
"coeff_0_0",
"coefficient (0,0) of the transformation matrix"
},
{
GIMP_PDB_FLOAT,
"coeff_0_1",
"coefficient (0,1) of the transformation matrix"
},
{
GIMP_PDB_FLOAT,
"coeff_0_2",
"coefficient (0,2) of the transformation matrix"
},
{
GIMP_PDB_FLOAT,
"coeff_1_0",
"coefficient (1,0) of the transformation matrix"
},
{
GIMP_PDB_FLOAT,
"coeff_1_1",
"coefficient (1,1) of the transformation matrix"
},
{
GIMP_PDB_FLOAT,
"coeff_1_2",
"coefficient (1,2) of the transformation matrix"
},
{
GIMP_PDB_FLOAT,
"coeff_2_0",
"coefficient (2,0) of the transformation matrix"
},
{
GIMP_PDB_FLOAT,
"coeff_2_1",
"coefficient (2,1) of the transformation matrix"
},
{
GIMP_PDB_FLOAT,
"coeff_2_2",
"coefficient (2,2) of the transformation matrix"
},
{
GIMP_PDB_INT32,
"transform_direction",
"Direction of Transformation: { GIMP_TRANSFORM_FORWARD (0), GIMP_TRANSFORM_BACKWARD (1) }"
},
{
GIMP_PDB_INT32,
"interpolation",
"Type of interpolation: { GIMP_INTERPOLATION_NONE (0), GIMP_INTERPOLATION_LINEAR (1), GIMP_INTERPOLATION_CUBIC (2) }"
},
{
GIMP_PDB_INT32,
"supersample",
"Whether to perform supersample"
},
{
GIMP_PDB_INT32,
"recursion_level",
"Level of recursion (3 is a nice default)"
},
{
GIMP_PDB_INT32,
"clip_result",
"Whether to clip results"
}
};
static ProcArg drawable_transform_matrix_outargs[] =
{
{
GIMP_PDB_DRAWABLE,
"drawable",
"The transformed drawable"
}
};
static ProcRecord drawable_transform_matrix_proc =
{
"gimp_drawable_transform_matrix",
"Transform the specified drawable in 2d, with extra parameters.",
"This procedure transforms the specified drawable if no selection exists. If a selection exists, the portion of the drawable which lies under the selection is cut from the drawable and made into a floating selection which is then transformed. The transformation is done by assembling a 3x3 matrix from the coefficients passed. The return value is the ID of the rotated drawable. If there was no selection, this will be equal to the drawable ID supplied as input. Otherwise, this will be the newly created and transformed drawable.",
"João S. O. Bueno Calligaris",
"João S. O. Bueno Calligaris",
"2004",
NULL,
GIMP_INTERNAL,
15,
drawable_transform_matrix_inargs,
1,
drawable_transform_matrix_outargs,
{ { drawable_transform_matrix_invoker } }
};

50
app/pdb/internal_procs.c
View File

@ -74,7 +74,7 @@ void register_transform_tools_procs (Gimp *gimp);
void register_undo_procs (Gimp *gimp); void register_undo_procs (Gimp *gimp);
void register_unit_procs (Gimp *gimp); void register_unit_procs (Gimp *gimp);
/* 420 procedures registered total */ /* 421 procedures registered total */
void void
internal_procs_init (Gimp *gimp, internal_procs_init (Gimp *gimp,
@ -101,67 +101,67 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Context"), 0.095); (* status_callback) (NULL, _("Context"), 0.095);
register_context_procs (gimp); register_context_procs (gimp);
(* status_callback) (NULL, _("Convert"), 0.148); (* status_callback) (NULL, _("Convert"), 0.147);
register_convert_procs (gimp); register_convert_procs (gimp);
(* status_callback) (NULL, _("Display procedures"), 0.155); (* status_callback) (NULL, _("Display procedures"), 0.154);
register_display_procs (gimp); register_display_procs (gimp);
(* status_callback) (NULL, _("Drawable procedures"), 0.164); (* status_callback) (NULL, _("Drawable procedures"), 0.164);
register_drawable_procs (gimp); register_drawable_procs (gimp);
(* status_callback) (NULL, _("Transformation procedures"), 0.243); (* status_callback) (NULL, _("Transformation procedures"), 0.242);
register_drawable_transform_procs (gimp); register_drawable_transform_procs (gimp);
(* status_callback) (NULL, _("Edit procedures"), 0.26); (* status_callback) (NULL, _("Edit procedures"), 0.261);
register_edit_procs (gimp); register_edit_procs (gimp);
(* status_callback) (NULL, _("File Operations"), 0.279); (* status_callback) (NULL, _("File Operations"), 0.28);
register_fileops_procs (gimp); register_fileops_procs (gimp);
(* status_callback) (NULL, _("Floating selections"), 0.3); (* status_callback) (NULL, _("Floating selections"), 0.302);
register_floating_sel_procs (gimp); register_floating_sel_procs (gimp);
(* status_callback) (NULL, _("Font UI"), 0.314); (* status_callback) (NULL, _("Font UI"), 0.316);
register_font_select_procs (gimp); register_font_select_procs (gimp);
(* status_callback) (NULL, _("Fonts"), 0.321); (* status_callback) (NULL, _("Fonts"), 0.323);
register_fonts_procs (gimp); register_fonts_procs (gimp);
(* status_callback) (NULL, _("Gimprc procedures"), 0.326); (* status_callback) (NULL, _("Gimprc procedures"), 0.328);
register_gimprc_procs (gimp); register_gimprc_procs (gimp);
(* status_callback) (NULL, _("Gradient"), 0.34); (* status_callback) (NULL, _("Gradient"), 0.342);
register_gradient_procs (gimp); register_gradient_procs (gimp);
(* status_callback) (NULL, _("Gradient UI"), 0.41); (* status_callback) (NULL, _("Gradient UI"), 0.411);
register_gradient_select_procs (gimp); register_gradient_select_procs (gimp);
(* status_callback) (NULL, _("Gradients"), 0.417); (* status_callback) (NULL, _("Gradients"), 0.418);
register_gradients_procs (gimp); register_gradients_procs (gimp);
(* status_callback) (NULL, _("Guide procedures"), 0.429); (* status_callback) (NULL, _("Guide procedures"), 0.43);
register_guides_procs (gimp); register_guides_procs (gimp);
(* status_callback) (NULL, _("Help procedures"), 0.443); (* status_callback) (NULL, _("Help procedures"), 0.444);
register_help_procs (gimp); register_help_procs (gimp);
(* status_callback) (NULL, _("Image"), 0.445); (* status_callback) (NULL, _("Image"), 0.447);
register_image_procs (gimp); register_image_procs (gimp);
(* status_callback) (NULL, _("Layer"), 0.593); (* status_callback) (NULL, _("Layer"), 0.594);
register_layer_procs (gimp); register_layer_procs (gimp);
(* status_callback) (NULL, _("Message procedures"), 0.655); (* status_callback) (NULL, _("Message procedures"), 0.656);
register_message_procs (gimp); register_message_procs (gimp);
(* status_callback) (NULL, _("Miscellaneous"), 0.662); (* status_callback) (NULL, _("Miscellaneous"), 0.663);
register_misc_procs (gimp); register_misc_procs (gimp);
(* status_callback) (NULL, _("Paint Tool procedures"), 0.667); (* status_callback) (NULL, _("Paint Tool procedures"), 0.667);
register_paint_tools_procs (gimp); register_paint_tools_procs (gimp);
(* status_callback) (NULL, _("Palette"), 0.702); (* status_callback) (NULL, _("Palette"), 0.703);
register_palette_procs (gimp); register_palette_procs (gimp);
(* status_callback) (NULL, _("Palette UI"), 0.729); (* status_callback) (NULL, _("Palette UI"), 0.729);
@ -170,7 +170,7 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Palettes"), 0.736); (* status_callback) (NULL, _("Palettes"), 0.736);
register_palettes_procs (gimp); register_palettes_procs (gimp);
(* status_callback) (NULL, _("Parasite procedures"), 0.745); (* status_callback) (NULL, _("Parasite procedures"), 0.746);
register_parasite_procs (gimp); register_parasite_procs (gimp);
(* status_callback) (NULL, _("Paths"), 0.774); (* status_callback) (NULL, _("Paths"), 0.774);
@ -179,10 +179,10 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Pattern"), 0.81); (* status_callback) (NULL, _("Pattern"), 0.81);
register_pattern_procs (gimp); register_pattern_procs (gimp);
(* status_callback) (NULL, _("Pattern UI"), 0.814); (* status_callback) (NULL, _("Pattern UI"), 0.815);
register_pattern_select_procs (gimp); register_pattern_select_procs (gimp);
(* status_callback) (NULL, _("Patterns"), 0.821); (* status_callback) (NULL, _("Patterns"), 0.822);
register_patterns_procs (gimp); register_patterns_procs (gimp);
(* status_callback) (NULL, _("Plug-in"), 0.831); (* status_callback) (NULL, _("Plug-in"), 0.831);
@ -191,7 +191,7 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Procedural database"), 0.843); (* status_callback) (NULL, _("Procedural database"), 0.843);
register_procedural_db_procs (gimp); register_procedural_db_procs (gimp);
(* status_callback) (NULL, _("Progress"), 0.864); (* status_callback) (NULL, _("Progress"), 0.865);
register_progress_procs (gimp); register_progress_procs (gimp);
(* status_callback) (NULL, _("Image mask"), 0.876); (* status_callback) (NULL, _("Image mask"), 0.876);
@ -203,7 +203,7 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Text procedures"), 0.931); (* status_callback) (NULL, _("Text procedures"), 0.931);
register_text_tool_procs (gimp); register_text_tool_procs (gimp);
(* status_callback) (NULL, _("Transform Tool procedures"), 0.94); (* status_callback) (NULL, _("Transform Tool procedures"), 0.941);
register_transform_tools_procs (gimp); register_transform_tools_procs (gimp);
(* status_callback) (NULL, _("Undo"), 0.955); (* status_callback) (NULL, _("Undo"), 0.955);

220
app/pdb/transform_tools_cmds.c
View File

@ -76,11 +76,16 @@ flip_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
success = gimp_drawable_transform_flip (drawable, context, gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
flip_type, TRUE, 0.0, FALSE); {
success = gimp_drawable_transform_flip (drawable, context,
flip_type, TRUE, 0.0, FALSE);
}
} }
return_args = procedural_db_return_args (&flip_proc, success); return_args = procedural_db_return_args (&flip_proc, success);
@ -167,43 +172,39 @@ perspective_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_perspective (x, y, width, height,
GimpMatrix3 matrix; trans_info[X0], trans_info[Y0],
GimpInterpolationType interpolation_type; trans_info[X1], trans_info[Y1],
trans_info[X2], trans_info[Y2],
trans_info[X3], trans_info[Y3],
&matrix);
/* Assemble the transformation matrix */ if (interpolation)
gimp_transform_matrix_perspective (x, y, x + width, y + height, interpolation_type = gimp->config->interpolation_type;
trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
trans_info[X2], trans_info[Y2],
trans_info[X3], trans_info[Y3],
&matrix);
if (interpolation) if (progress)
interpolation_type = gimp->config->interpolation_type; gimp_progress_start (progress, _("Perspective..."), FALSE);
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) /* Perspective the selection */
gimp_progress_start (progress, _("Perspective..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, TRUE, 3,
FALSE, progress);
/* Perspective the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, TRUE, 3,
FALSE, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
@ -318,39 +319,35 @@ rotate_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_rotate (x, y, width, height,
GimpMatrix3 matrix; angle, &matrix);
GimpInterpolationType interpolation_type;
/* Assemble the transformation matrix */ if (interpolation)
gimp_transform_matrix_rotate (x, y, x + width, y + height, interpolation_type = gimp->config->interpolation_type;
angle, &matrix);
if (interpolation) if (progress)
interpolation_type = gimp->config->interpolation_type; gimp_progress_start (progress, _("Rotating..."), FALSE);
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) /* Rotate the selection */
gimp_progress_start (progress, _("Rotating..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, FALSE, 3,
FALSE, progress);
/* Rotate the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, FALSE, 3,
FALSE, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
@ -435,43 +432,41 @@ scale_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = (gimp_item_is_attached (GIMP_ITEM (drawable)) && success = (gimp_item_is_attached (GIMP_ITEM (drawable)) &&
trans_info[X0] < trans_info[X1] && trans_info[X0] < trans_info[X1] &&
trans_info[Y0] < trans_info[X1]); trans_info[Y0] < trans_info[X1]);
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_scale (x, y, width, height,
GimpMatrix3 matrix; trans_info[X0],
GimpInterpolationType interpolation_type; trans_info[Y0],
trans_info[X1] - trans_info[X0],
trans_info[Y1] - trans_info[Y0],
&matrix);
/* Assemble the transformation matrix */ if (interpolation)
gimp_transform_matrix_scale (x, y, x + width, y + height, interpolation_type = gimp->config->interpolation_type;
trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
&matrix);
if (interpolation) if (progress)
interpolation_type = gimp->config->interpolation_type; gimp_progress_start (progress, _("Scaling..."), FALSE);
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) /* Scale the selection */
gimp_progress_start (progress, _("Scaling..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, TRUE, 3,
FALSE, progress);
/* Scale the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, TRUE, 3,
FALSE, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
@ -570,40 +565,36 @@ shear_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_shear (x, y, width, height,
GimpMatrix3 matrix; shear_type, magnitude,
GimpInterpolationType interpolation_type; &matrix);
/* Assemble the transformation matrix */ if (interpolation)
gimp_transform_matrix_shear (x, y, x + width, y + height, interpolation_type = gimp->config->interpolation_type;
shear_type, magnitude,
&matrix);
if (interpolation) if (progress)
interpolation_type = gimp->config->interpolation_type; gimp_progress_start (progress, _("Shearing..."), FALSE);
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) /* Shear the selection */
gimp_progress_start (progress, _("Shearing..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, FALSE, 3,
FALSE, progress);
/* Shear the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, FALSE, 3,
FALSE, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
@ -705,12 +696,15 @@ transform_2d_invoker (Gimp *gimp,
if (success) if (success)
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
GimpMatrix3 matrix; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type; GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
/* Assemble the transformation matrix */ /* Assemble the transformation matrix */
gimp_matrix3_identity (&matrix); gimp_matrix3_identity (&matrix);
@ -721,8 +715,6 @@ transform_2d_invoker (Gimp *gimp,
if (interpolation) if (interpolation)
interpolation_type = gimp->config->interpolation_type; interpolation_type = gimp->config->interpolation_type;
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) if (progress)
gimp_progress_start (progress, _("2D Transform..."), FALSE); gimp_progress_start (progress, _("2D Transform..."), FALSE);

4
app/tools/gimpperspectivetool.c
View File

@ -239,8 +239,8 @@ gimp_perspective_tool_recalc (GimpTransformTool *tr_tool,
{ {
gimp_transform_matrix_perspective (tr_tool->x1, gimp_transform_matrix_perspective (tr_tool->x1,
tr_tool->y1, tr_tool->y1,
tr_tool->x2, tr_tool->x2 - tr_tool->x1,
tr_tool->y2, tr_tool->y2 - tr_tool->y1,
tr_tool->trans_info[X0], tr_tool->trans_info[X0],
tr_tool->trans_info[Y0], tr_tool->trans_info[Y0],
tr_tool->trans_info[X1], tr_tool->trans_info[X1],

8
app/tools/gimpscaletool.c
View File

@ -477,12 +477,12 @@ gimp_scale_tool_recalc (GimpTransformTool *tr_tool,
{ {
gimp_transform_matrix_scale (tr_tool->x1, gimp_transform_matrix_scale (tr_tool->x1,
tr_tool->y1, tr_tool->y1,
tr_tool->x2, tr_tool->x2 - tr_tool->x1,
tr_tool->y2, tr_tool->y2 - tr_tool->y1,
tr_tool->trans_info[X0], tr_tool->trans_info[X0],
tr_tool->trans_info[Y0], tr_tool->trans_info[Y0],
tr_tool->trans_info[X1], tr_tool->trans_info[X1] - tr_tool->trans_info[X0],
tr_tool->trans_info[Y1], tr_tool->trans_info[Y1] - tr_tool->trans_info[Y0],
&tr_tool->transform); &tr_tool->transform);
} }

4
app/tools/gimpsheartool.c
View File

@ -294,8 +294,8 @@ gimp_shear_tool_recalc (GimpTransformTool *tr_tool,
gimp_transform_matrix_shear (tr_tool->x1, gimp_transform_matrix_shear (tr_tool->x1,
tr_tool->y1, tr_tool->y1,
tr_tool->x2, tr_tool->x2 - tr_tool->x1,
tr_tool->y2, tr_tool->y2 - tr_tool->y1,
tr_tool->trans_info[HORZ_OR_VERT], tr_tool->trans_info[HORZ_OR_VERT],
amount, amount,
&tr_tool->transform); &tr_tool->transform);

157
libgimp/gimpdrawabletransform_pdb.c
View File

@ -39,9 +39,9 @@
* *
* Flip the specified drawable either vertically or horizontally. * Flip the specified drawable either vertically or horizontally.
* *
* This tool flips the specified drawable if no selection exists. If a * This procedure flips the specified drawable if no selection exists.
* selection exists, the portion of the drawable which lies under the * If a selection exists, the portion of the drawable which lies under
* selection is cut from the drawable and made into a floating * the selection is cut from the drawable and made into a floating
* selection which is then flipped. If center is set to true, the flip * selection which is then flipped. If center is set to true, the flip
* is around the image center. Otherwise, the coordinate of the axis * is around the image center. Otherwise, the coordinate of the axis
* needs to be specified. The return value is the ID of the flipped * needs to be specified. The return value is the ID of the flipped
@ -92,10 +92,10 @@ gimp_drawable_transform_flip (gint32 drawable_ID,
/** /**
* gimp_drawable_transform_flip_free: * gimp_drawable_transform_flip_free:
* @drawable_ID: The affected drawable. * @drawable_ID: The affected drawable.
* @x1: horz. coord. of one end of axis. * @x0: horz. coord. of one end of axis.
* @y1: vert. coord. of one end of axis. * @y0: vert. coord. of one end of axis.
* @x2: horz. coord. of other end of axis. * @x1: horz. coord. of other end of axis.
* @y2: vert. coord. of other end of axis. * @y1: vert. coord. of other end of axis.
* @transform_direction: Direction of Transformation. * @transform_direction: Direction of Transformation.
* @interpolation: Type of interpolation. * @interpolation: Type of interpolation.
* @supersample: Whether to perform supersample. * @supersample: Whether to perform supersample.
@ -104,9 +104,9 @@ gimp_drawable_transform_flip (gint32 drawable_ID,
* *
* Flip the specified drawable around a given line. * Flip the specified drawable around a given line.
* *
* This tool flips the specified drawable if no selection exists. If a * This procedure flips the specified drawable if no selection exists.
* selection exists, the portion of the drawable which lies under the * If a selection exists, the portion of the drawable which lies under
* selection is cut from the drawable and made into a floating * the selection is cut from the drawable and made into a floating
* selection which is then flipped. The axis to flip around is * selection which is then flipped. The axis to flip around is
* specified by specifying two points from that line. The return value * specified by specifying two points from that line. The return value
* is the ID of the flipped drawable. If there was no selection, this * is the ID of the flipped drawable. If there was no selection, this
@ -121,10 +121,10 @@ gimp_drawable_transform_flip (gint32 drawable_ID,
*/ */
gint32 gint32
gimp_drawable_transform_flip_free (gint32 drawable_ID, gimp_drawable_transform_flip_free (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1, gdouble x1,
gdouble y1, gdouble y1,
gdouble x2,
gdouble y2,
GimpTransformDirection transform_direction, GimpTransformDirection transform_direction,
GimpInterpolationType interpolation, GimpInterpolationType interpolation,
gboolean supersample, gboolean supersample,
@ -138,10 +138,10 @@ gimp_drawable_transform_flip_free (gint32 drawable_ID,
return_vals = gimp_run_procedure ("gimp_drawable_transform_flip_free", return_vals = gimp_run_procedure ("gimp_drawable_transform_flip_free",
&nreturn_vals, &nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, x0,
GIMP_PDB_FLOAT, y0,
GIMP_PDB_FLOAT, x1, GIMP_PDB_FLOAT, x1,
GIMP_PDB_FLOAT, y1, GIMP_PDB_FLOAT, y1,
GIMP_PDB_FLOAT, x2,
GIMP_PDB_FLOAT, y2,
GIMP_PDB_INT32, transform_direction, GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation, GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample, GIMP_PDB_INT32, supersample,
@ -177,7 +177,7 @@ gimp_drawable_transform_flip_free (gint32 drawable_ID,
* Perform a possibly non-affine transformation on the specified * Perform a possibly non-affine transformation on the specified
* drawable, with extra parameters. * drawable, with extra parameters.
* *
* This tool performs a possibly non-affine transformation on the * This procedure performs a possibly non-affine transformation on the
* specified drawable by allowing the corners of the original bounding * specified drawable by allowing the corners of the original bounding
* box to be arbitrarily remapped to any values. The specified drawable * box to be arbitrarily remapped to any values. The specified drawable
* is remapped if no selection exists. However, if a selection exists, * is remapped if no selection exists. However, if a selection exists,
@ -247,8 +247,8 @@ gimp_drawable_transform_perspective (gint32 drawable_ID,
* gimp_drawable_transform_rotate: * gimp_drawable_transform_rotate:
* @drawable_ID: The affected drawable. * @drawable_ID: The affected drawable.
* @angle: The angle of rotation (radians). * @angle: The angle of rotation (radians).
* @cx: The hor. coordinate of the center of rotation. * @center_x: The hor. coordinate of the center of rotation.
* @cy: The vert. coordinate of the center of rotation. * @center_y: The vert. coordinate of the center of rotation.
* @transform_direction: Direction of Transformation. * @transform_direction: Direction of Transformation.
* @interpolation: Type of interpolation. * @interpolation: Type of interpolation.
* @supersample: Whether to perform supersample. * @supersample: Whether to perform supersample.
@ -258,9 +258,9 @@ gimp_drawable_transform_perspective (gint32 drawable_ID,
* Rotate the specified drawable about given coordinates through the * Rotate the specified drawable about given coordinates through the
* specified angle. * specified angle.
* *
* This tool rotates the specified drawable if no selection exists. If * This function rotates the specified drawable if no selection exists.
* a selection exists, the portion of the drawable which lies under the * If a selection exists, the portion of the drawable which lies under
* selection is cut from the drawable and made into a floating * the selection is cut from the drawable and made into a floating
* selection which is then rotated by the specified amount. The return * selection which is then rotated by the specified amount. The return
* value is the ID of the rotated drawable. If there was no selection, * value is the ID of the rotated drawable. If there was no selection,
* this will be equal to the drawable ID supplied as input. Otherwise, * this will be equal to the drawable ID supplied as input. Otherwise,
@ -273,8 +273,8 @@ gimp_drawable_transform_perspective (gint32 drawable_ID,
gint32 gint32
gimp_drawable_transform_rotate (gint32 drawable_ID, gimp_drawable_transform_rotate (gint32 drawable_ID,
gdouble angle, gdouble angle,
gint cx, gint center_x,
gint cy, gint center_y,
GimpTransformDirection transform_direction, GimpTransformDirection transform_direction,
GimpInterpolationType interpolation, GimpInterpolationType interpolation,
gboolean supersample, gboolean supersample,
@ -289,8 +289,8 @@ gimp_drawable_transform_rotate (gint32 drawable_ID,
&nreturn_vals, &nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID, GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, angle, GIMP_PDB_FLOAT, angle,
GIMP_PDB_INT32, cx, GIMP_PDB_INT32, center_x,
GIMP_PDB_INT32, cy, GIMP_PDB_INT32, center_y,
GIMP_PDB_INT32, transform_direction, GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation, GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample, GIMP_PDB_INT32, supersample,
@ -321,9 +321,9 @@ gimp_drawable_transform_rotate (gint32 drawable_ID,
* *
* Scale the specified drawable with extra parameters * Scale the specified drawable with extra parameters
* *
* This tool scales the specified drawable if no selection exists. If a * This procedure scales the specified drawable if no selection exists.
* selection exists, the portion of the drawable which lies under the * If a selection exists, the portion of the drawable which lies under
* selection is cut from the drawable and made into a floating * the selection is cut from the drawable and made into a floating
* selection which is then scaled by the specified amount. The return * selection which is then scaled by the specified amount. The return
* value is the ID of the scaled drawable. If there was no selection, * value is the ID of the scaled drawable. If there was no selection,
* this will be equal to the drawable ID supplied as input. Otherwise, * this will be equal to the drawable ID supplied as input. Otherwise,
@ -385,9 +385,9 @@ gimp_drawable_transform_scale (gint32 drawable_ID,
* Shear the specified drawable about its center by the specified * Shear the specified drawable about its center by the specified
* magnitude, with extra parameters. * magnitude, with extra parameters.
* *
* This tool shears the specified drawable if no selection exists. If a * This procedure shears the specified drawable if no selection exists.
* selection exists, the portion of the drawable which lies under the * If a selection exists, the portion of the drawable which lies under
* selection is cut from the drawable and made into a floating * the selection is cut from the drawable and made into a floating
* selection which is then sheard by the specified amount. The return * selection which is then sheard by the specified amount. The return
* value is the ID of the sheard drawable. If there was no selection, * value is the ID of the sheard drawable. If there was no selection,
* this will be equal to the drawable ID supplied as input. Otherwise, * this will be equal to the drawable ID supplied as input. Otherwise,
@ -452,14 +452,14 @@ gimp_drawable_transform_shear (gint32 drawable_ID,
* *
* Transform the specified drawable in 2d, with extra parameters. * Transform the specified drawable in 2d, with extra parameters.
* *
* This tool transforms the specified drawable if no selection exists. * This procedure transforms the specified drawable if no selection
* If a selection exists, the portion of the drawable which lies under * exists. If a selection exists, the portion of the drawable which
* the selection is cut from the drawable and made into a floating * lies under the selection is cut from the drawable and made into a
* selection which is then transformed. The transformation is done by * floating selection which is then transformed. The transformation is
* scaling the image by the x and y scale factors about the point * done by scaling the image by the x and y scale factors about the
* (source_x, source_y), then rotating around the same point, then * point (source_x, source_y), then rotating around the same point,
* translating that point to the new position (dest_x, dest_y). The * then translating that point to the new position (dest_x, dest_y).
* return value is the ID of the rotated drawable. If there was no * The return value is the ID of the rotated drawable. If there was no
* selection, this will be equal to the drawable ID supplied as input. * selection, this will be equal to the drawable ID supplied as input.
* Otherwise, this will be the newly created and transformed drawable. * Otherwise, this will be the newly created and transformed drawable.
* *
@ -510,3 +510,84 @@ gimp_drawable_transform_2d (gint32 drawable_ID,
return ret_drawable_ID; return ret_drawable_ID;
} }
/**
* gimp_drawable_transform_matrix:
* @drawable_ID: The affected drawable.
* @coeff_0_0: coefficient (0,0) of the transformation matrix.
* @coeff_0_1: coefficient (0,1) of the transformation matrix.
* @coeff_0_2: coefficient (0,2) of the transformation matrix.
* @coeff_1_0: coefficient (1,0) of the transformation matrix.
* @coeff_1_1: coefficient (1,1) of the transformation matrix.
* @coeff_1_2: coefficient (1,2) of the transformation matrix.
* @coeff_2_0: coefficient (2,0) of the transformation matrix.
* @coeff_2_1: coefficient (2,1) of the transformation matrix.
* @coeff_2_2: coefficient (2,2) of the transformation matrix.
* @transform_direction: Direction of Transformation.
* @interpolation: Type of interpolation.
* @supersample: Whether to perform supersample.
* @recursion_level: Level of recursion (3 is a nice default).
* @clip_result: Whether to clip results.
*
* Transform the specified drawable in 2d, with extra parameters.
*
* This procedure transforms the specified drawable if no selection
* exists. If a selection exists, the portion of the drawable which
* lies under the selection is cut from the drawable and made into a
* floating selection which is then transformed. The transformation is
* done by assembling a 3x3 matrix from the coefficients passed. The
* return value is the ID of the rotated drawable. If there was no
* selection, this will be equal to the drawable ID supplied as input.
* Otherwise, this will be the newly created and transformed drawable.
*
* Returns: The transformed drawable.
*
* Since: GIMP 2.2
*/
gint32
gimp_drawable_transform_matrix (gint32 drawable_ID,
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result)
{
GimpParam *return_vals;
gint nreturn_vals;
gint32 ret_drawable_ID = -1;
return_vals = gimp_run_procedure ("gimp_drawable_transform_matrix",
&nreturn_vals,
GIMP_PDB_DRAWABLE, drawable_ID,
GIMP_PDB_FLOAT, coeff_0_0,
GIMP_PDB_FLOAT, coeff_0_1,
GIMP_PDB_FLOAT, coeff_0_2,
GIMP_PDB_FLOAT, coeff_1_0,
GIMP_PDB_FLOAT, coeff_1_1,
GIMP_PDB_FLOAT, coeff_1_2,
GIMP_PDB_FLOAT, coeff_2_0,
GIMP_PDB_FLOAT, coeff_2_1,
GIMP_PDB_FLOAT, coeff_2_2,
GIMP_PDB_INT32, transform_direction,
GIMP_PDB_INT32, interpolation,
GIMP_PDB_INT32, supersample,
GIMP_PDB_INT32, recursion_level,
GIMP_PDB_INT32, clip_result,
GIMP_PDB_END);
if (return_vals[0].data.d_status == GIMP_PDB_SUCCESS)
ret_drawable_ID = return_vals[1].data.d_drawable;
gimp_destroy_params (return_vals, nreturn_vals);
return ret_drawable_ID;
}

23
libgimp/gimpdrawabletransform_pdb.h
View File

@ -39,10 +39,10 @@ gint32 gimp_drawable_transform_flip (gint32 drawable_ID,
gint recursion_level, gint recursion_level,
gboolean clip_result); gboolean clip_result);
gint32 gimp_drawable_transform_flip_free (gint32 drawable_ID, gint32 gimp_drawable_transform_flip_free (gint32 drawable_ID,
gdouble x0,
gdouble y0,
gdouble x1, gdouble x1,
gdouble y1, gdouble y1,
gdouble x2,
gdouble y2,
GimpTransformDirection transform_direction, GimpTransformDirection transform_direction,
GimpInterpolationType interpolation, GimpInterpolationType interpolation,
gboolean supersample, gboolean supersample,
@ -64,8 +64,8 @@ gint32 gimp_drawable_transform_perspective (gint32 drawable_ID,
gboolean clip_result); gboolean clip_result);
gint32 gimp_drawable_transform_rotate (gint32 drawable_ID, gint32 gimp_drawable_transform_rotate (gint32 drawable_ID,
gdouble angle, gdouble angle,
gint cx, gint center_x,
gint cy, gint center_y,
GimpTransformDirection transform_direction, GimpTransformDirection transform_direction,
GimpInterpolationType interpolation, GimpInterpolationType interpolation,
gboolean supersample, gboolean supersample,
@ -102,6 +102,21 @@ gint32 gimp_drawable_transform_2d (gint32 drawable_ID,
gboolean supersample, gboolean supersample,
gint recursion_level, gint recursion_level,
gboolean clip_result); gboolean clip_result);
gint32 gimp_drawable_transform_matrix (gint32 drawable_ID,
gdouble coeff_0_0,
gdouble coeff_0_1,
gdouble coeff_0_2,
gdouble coeff_1_0,
gdouble coeff_1_1,
gdouble coeff_1_2,
gdouble coeff_2_0,
gdouble coeff_2_1,
gdouble coeff_2_2,
GimpTransformDirection transform_direction,
GimpInterpolationType interpolation,
gboolean supersample,
gint recursion_level,
gboolean clip_result);
G_END_DECLS G_END_DECLS

437
tools/pdbgen/pdb/drawable_transform.pdb
View File

@ -78,11 +78,12 @@ Flip the specified drawable either vertically or horizontally.
BLURB BLURB
$help = <<'HELP'; $help = <<'HELP';
This tool flips the specified drawable if no selection exists. If a selection This procedure flips the specified drawable if no selection exists. If
exists, the portion of the drawable which lies under the selection is cut from a selection exists, the portion of the drawable which lies under the
the drawable and made into a floating selection which is then flipped. selection is cut from the drawable and made into a floating selection
If center is set to true, the flip is around the image center. Otherwise, which is then flipped. If center is set to true, the flip is around
the coordinate of the axis needs to be specified. the image center. Otherwise, the coordinate of the axis needs to be
specified.
The return value is the ID of the flipped drawable. If there was no The return value is the ID of the flipped drawable. If there was no
selection, this will be equal to the drawable ID supplied as input. selection, this will be equal to the drawable ID supplied as input.
@ -109,14 +110,19 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
success = gimp_drawable_transform_flip (drawable, gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
context, {
transform_direction, success = gimp_drawable_transform_flip (drawable,
center, axis, context,
clip_result); transform_direction,
center, axis,
clip_result);
}
} }
CODE CODE
); );
@ -129,10 +135,11 @@ Flip the specified drawable around a given line.
BLURB BLURB
$help = <<'HELP'; $help = <<'HELP';
This tool flips the specified drawable if no selection exists. If a selection This procedure flips the specified drawable if no selection exists. If
exists, the portion of the drawable which lies under the selection is cut from a selection exists, the portion of the drawable which lies under the
the drawable and made into a floating selection which is then flipped. The selection is cut from the drawable and made into a floating selection
axis to flip around is specified by specifying two points from that line. which is then flipped. The axis to flip around is specified by
specifying two points from that line.
The return value is the ID of the flipped drawable. If there was no The return value is the ID of the flipped drawable. If there was no
selection, this will be equal to the drawable ID supplied as input. selection, this will be equal to the drawable ID supplied as input.
@ -144,13 +151,13 @@ HELP
@inargs = ( @inargs = (
&drawable_arg, &drawable_arg,
{ name => 'x1', type => 'float', { name => 'x0', type => 'float',
desc => 'horz. coord. of one end of axis' }, desc => 'horz. coord. of one end of axis' },
{ name => 'y1', type => 'float', { name => 'y0', type => 'float',
desc => 'vert. coord. of one end of axis' }, desc => 'vert. coord. of one end of axis' },
{ name => 'x2', type => 'float', { name => 'x1', type => 'float',
desc => 'horz. coord. of other end of axis' }, desc => 'horz. coord. of other end of axis' },
{ name => 'y2', type => 'float', { name => 'y1', type => 'float',
desc => 'vert. coord. of other end of axis' }, desc => 'vert. coord. of other end of axis' },
&transform_options_args, &transform_options_args,
@ -162,44 +169,34 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_flip_free (x, y, width, height,
gdouble angle; x0, y0, x1, y1,
gdouble dx, dy; &matrix);
GimpMatrix3 matrix;
angle = atan2 ((y2 - y1), (x2 - x1)); if (progress)
dx = x - x1; gimp_progress_start (progress, _("Flip..."), FALSE);
dy = (x1 + ( (gdouble) (y2 - y1) / (x2 - x1) ) * x ) - y1;
gimp_matrix3_identity (&matrix); /* Transform the selection */
gimp_matrix3_translate (&matrix, dx, dy); success = gimp_drawable_transform_affine (drawable, context,
gimp_matrix3_rotate (&matrix, -angle); &matrix,
gimp_matrix3_scale (&matrix, 1.0, -1.0); transform_direction,
gimp_matrix3_rotate (&matrix, angle); interpolation,
gimp_matrix3_translate (&matrix, -dx, -dy); supersample,
recursion_level,
if (progress) clip_result,
gimp_progress_start (progress, _("Flip..."), FALSE); progress);
if (progress)
/* Transform the selection */ gimp_progress_end (progress);
success = gimp_drawable_transform_affine (drawable, context,
&matrix,
transform_direction,
interpolation,
supersample,
recursion_level,
clip_result,
progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
CODE CODE
@ -213,19 +210,21 @@ Perform a possibly non-affine transformation on the specified drawable, with ext
BLURB BLURB
$help = <<'HELP'; $help = <<'HELP';
This tool performs a possibly non-affine transformation on the specified This procedure performs a possibly non-affine transformation on the
drawable by allowing the corners of the original bounding box to be arbitrarily specified drawable by allowing the corners of the original bounding
remapped to any values. The specified drawable is remapped if no selection box to be arbitrarily remapped to any values. The specified drawable
exists. However, if a selection exists, the portion of the drawable which lies is remapped if no selection exists. However, if a selection exists,
under the selection is cut from the drawable and made into a floating selection the portion of the drawable which lies under the selection is cut from
which is then remapped as specified. The return value is the ID of the the drawable and made into a floating selection which is then remapped
remapped drawable. If there was no selection, this will be equal to the as specified. The return value is the ID of the remapped drawable. If
drawable ID supplied as input. Otherwise, this will be the newly created and there was no selection, this will be equal to the drawable ID supplied
remapped drawable. The 4 coordinates specify the new locations of each corner as input. Otherwise, this will be the newly created and remapped
drawable. The 4 coordinates specify the new locations of each corner
of the original bounding box. By specifying these values, any affine of the original bounding box. By specifying these values, any affine
transformation (rotation, scaling, translation) can be affected. Additionally, transformation (rotation, scaling, translation) can be
these values can be specified such that the resulting transformed drawable will affected. Additionally, these values can be specified such that the
appear to have been projected via a perspective transform. resulting transformed drawable will appear to have been projected via
a perspective transform.
HELP HELP
&pdb_misc; &pdb_misc;
@ -256,39 +255,37 @@ HELP
vars => [ 'gdouble trans_info[8]' ], vars => [ 'gdouble trans_info[8]' ],
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_perspective (x, y, width, height,
GimpMatrix3 matrix; trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
trans_info[X2], trans_info[Y2],
trans_info[X3], trans_info[Y3],
&matrix);
/* Assemble the transformation matrix */ if (progress)
gimp_transform_matrix_perspective (x, y, x + width, y + height, gimp_progress_start (progress, _("Perspective..."), FALSE);
trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
trans_info[X2], trans_info[Y2],
trans_info[X3], trans_info[Y3],
&matrix);
if (progress) /* Perspective the selection */
gimp_progress_start (progress, _("Perspective..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result,
progress);
/* Perspective the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result,
progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
CODE CODE
@ -301,12 +298,13 @@ Rotate the specified drawable about given coordinates through the specified angl
BLURB BLURB
$help = <<'HELP'; $help = <<'HELP';
This tool rotates the specified drawable if no selection exists. If a selection This function rotates the specified drawable if no selection
exists, the portion of the drawable which lies under the selection is cut from exists. If a selection exists, the portion of the drawable which lies
the drawable and made into a floating selection which is then rotated by the under the selection is cut from the drawable and made into a floating
specified amount. The return value is the ID of the rotated drawable. selection which is then rotated by the specified amount. The return
If there was no selection, this will be equal to the drawable ID supplied as value is the ID of the rotated drawable. If there was no selection,
input. Otherwise, this will be the newly created and rotated drawable. this will be equal to the drawable ID supplied as input. Otherwise,
this will be the newly created and rotated drawable.
HELP HELP
&pdb_misc; &pdb_misc;
@ -315,9 +313,9 @@ HELP
&drawable_arg, &drawable_arg,
{ name => 'angle', type => 'float', { name => 'angle', type => 'float',
desc => 'The angle of rotation (radians)' }, desc => 'The angle of rotation (radians)' },
{ name => 'cx', type => 'int32', { name => 'center_x', type => 'int32',
desc => 'The hor. coordinate of the center of rotation' }, desc => 'The hor. coordinate of the center of rotation' },
{ name => 'cy', type => 'int32', { name => 'center_y', type => 'int32',
desc => 'The vert. coordinate of the center of rotation' }, desc => 'The vert. coordinate of the center of rotation' },
&transform_options_args, &transform_options_args,
&clip_result_arg &clip_result_arg
@ -328,14 +326,18 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
GimpMatrix3 matrix; GimpMatrix3 matrix;
/* Assemble the transformation matrix */ /* Assemble the transformation matrix */
gimp_transform_matrix_rotate_center (cx, cy, angle, &matrix); gimp_transform_matrix_rotate_center (center_x, center_y, angle,
&matrix);
if (progress) if (progress)
gimp_progress_start (progress, _("Rotating..."), FALSE); gimp_progress_start (progress, _("Rotating..."), FALSE);
@ -359,12 +361,13 @@ sub drawable_transform_scale {
$blurb = 'Scale the specified drawable with extra parameters'; $blurb = 'Scale the specified drawable with extra parameters';
$help = <<'HELP'; $help = <<'HELP';
This tool scales the specified drawable if no selection exists. If a selection This procedure scales the specified drawable if no selection
exists, the portion of the drawable which lies under the selection is cut from exists. If a selection exists, the portion of the drawable which lies
the drawable and made into a floating selection which is then scaled by the under the selection is cut from the drawable and made into a floating
specified amount. The return value is the ID of the scaled drawable. selection which is then scaled by the specified amount. The return
If there was no selection, this will be equal to the drawable ID supplied as value is the ID of the scaled drawable. If there was no selection,
input. Otherwise, this will be the newly created and scaled drawable. this will be equal to the drawable ID supplied as input. Otherwise,
this will be the newly created and scaled drawable.
HELP HELP
&pdb_misc; &pdb_misc;
@ -396,38 +399,38 @@ HELP
vars => [ 'gdouble trans_info[4]' ], vars => [ 'gdouble trans_info[4]' ],
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = (gimp_item_is_attached (GIMP_ITEM (drawable)) && success = (gimp_item_is_attached (GIMP_ITEM (drawable)) &&
trans_info[X0] < trans_info[X1] && trans_info[X0] < trans_info[X1] &&
trans_info[Y0] < trans_info[X1]); trans_info[Y0] < trans_info[X1]);
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_scale (x, y, width, height,
GimpMatrix3 matrix; trans_info[X0],
trans_info[Y0],
trans_info[X1] - trans_info[X0],
trans_info[Y1] - trans_info[Y0],
&matrix);
/* Assemble the transformation matrix */ if (progress)
gimp_transform_matrix_scale (x, y, x + width, y + height, gimp_progress_start (progress, _("Scaling..."), FALSE);
trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
&matrix);
if (progress) /* Scale the selection */
gimp_progress_start (progress, _("Scaling..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result, progress);
/* Scale the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
transform_direction,
interpolation, supersample,
recursion_level,
clip_result, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
CODE CODE
@ -440,15 +443,16 @@ Shear the specified drawable about its center by the specified magnitude, with e
BLURB BLURB
$help = <<'HELP'; $help = <<'HELP';
This tool shears the specified drawable if no selection exists. If a selection This procedure shears the specified drawable if no selection
exists, the portion of the drawable which lies under the selection is cut from exists. If a selection exists, the portion of the drawable which lies
the drawable and made into a floating selection which is then sheard by the under the selection is cut from the drawable and made into a floating
specified amount. The return value is the ID of the sheard drawable. selection which is then sheard by the specified amount. The return
If there was no selection, this will be equal to the drawable ID supplied as value is the ID of the sheard drawable. If there was no selection,
input. Otherwise, this will be the newly created and sheard drawable. The shear this will be equal to the drawable ID supplied as input. Otherwise,
type parameter indicates whether the shear will be applied horizontally or this will be the newly created and sheard drawable. The shear type
vertically. The magnitude can be either positive or negative and indicates the parameter indicates whether the shear will be applied horizontally or
extent (in pixels) to shear by. vertically. The magnitude can be either positive or negative and
indicates the extent (in pixels) to shear by.
HELP HELP
&pdb_misc; &pdb_misc;
@ -468,35 +472,33 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{
GimpMatrix3 matrix;
/* Assemble the transformation matrix */ /* Assemble the transformation matrix */
gimp_transform_matrix_shear (x, y, x + width, y + height, gimp_transform_matrix_shear (x, y, width, height,
shear_type, magnitude, shear_type, magnitude,
&matrix); &matrix);
if (progress) if (progress)
gimp_progress_start (progress, _("Shearing..."), FALSE); gimp_progress_start (progress, _("Shearing..."), FALSE);
/* Shear the selection */ /* Shear the selection */
success = gimp_drawable_transform_affine (drawable, context, success = gimp_drawable_transform_affine (drawable, context,
&matrix, &matrix,
transform_direction, transform_direction,
interpolation, supersample, interpolation, supersample,
recursion_level, recursion_level,
clip_result, progress); clip_result, progress);
if (progress) if (progress)
gimp_progress_end (progress); gimp_progress_end (progress);
}
} }
} }
CODE CODE
@ -510,15 +512,17 @@ Transform the specified drawable in 2d, with extra parameters.
BLURB BLURB
$help = <<'HELP'; $help = <<'HELP';
This tool transforms the specified drawable if no selection exists. If a This procedure transforms the specified drawable if no selection
selection exists, the portion of the drawable which lies under the exists. If a selection exists, the portion of the drawable which lies
selection is cut from the drawable and made into a floating selection which under the selection is cut from the drawable and made into a floating
is then transformed. The transformation is done by scaling the image by selection which is then transformed. The transformation is done by
the x and y scale factors about the point (source_x, source_y), then rotating scaling the image by the x and y scale factors about the point
around the same point, then translating that point to the new position (source_x, source_y), then rotating around the same point, then
(dest_x, dest_y). The return value is the ID of the rotated drawable. If translating that point to the new position (dest_x, dest_y). The
there was no selection, this will be equal to the drawable ID supplied as return value is the ID of the rotated drawable. If there was no
input. Otherwise, this will be the newly created and transformed drawable. selection, this will be equal to the drawable ID supplied as
input. Otherwise, this will be the newly created and transformed
drawable.
HELP HELP
&pdb_misc; &pdb_misc;
@ -548,11 +552,14 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
GimpMatrix3 matrix; GimpMatrix3 matrix;
/* Assemble the transformation matrix */ /* Assemble the transformation matrix */
gimp_matrix3_identity (&matrix); gimp_matrix3_identity (&matrix);
@ -579,6 +586,91 @@ CODE
); );
} }
sub drawable_transform_matrix {
$blurb = <<'BLURB';
Transform the specified drawable in 2d, with extra parameters.
BLURB
$help = <<'HELP';
This procedure transforms the specified drawable if no selection
exists. If a selection exists, the portion of the drawable which lies
under the selection is cut from the drawable and made into a floating
selection which is then transformed. The transformation is done by
assembling a 3x3 matrix from the coefficients passed. The return
value is the ID of the rotated drawable. If there was no selection,
this will be equal to the drawable ID supplied as input. Otherwise,
this will be the newly created and transformed drawable.
HELP
&pdb_misc;
@inargs = (
&drawable_arg,
{ name => 'coeff_0_0', type => 'float',
desc => 'coefficient (0,0) of the transformation matrix' },
{ name => 'coeff_0_1', type => 'float',
desc => 'coefficient (0,1) of the transformation matrix' },
{ name => 'coeff_0_2', type => 'float',
desc => 'coefficient (0,2) of the transformation matrix' },
{ name => 'coeff_1_0', type => 'float',
desc => 'coefficient (1,0) of the transformation matrix' },
{ name => 'coeff_1_1', type => 'float',
desc => 'coefficient (1,1) of the transformation matrix' },
{ name => 'coeff_1_2', type => 'float',
desc => 'coefficient (1,2) of the transformation matrix' },
{ name => 'coeff_2_0', type => 'float',
desc => 'coefficient (2,0) of the transformation matrix' },
{ name => 'coeff_2_1', type => 'float',
desc => 'coefficient (2,1) of the transformation matrix' },
{ name => 'coeff_2_2', type => 'float',
desc => 'coefficient (2,2) of the transformation matrix' },
&transform_options_args,
&clip_result_arg
);
@outargs = ( &drawable_out_arg('transformed') );
%invoke = (
code => <<'CODE'
{
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{
GimpMatrix3 matrix;
/* Assemble the transformation matrix */
matrix.coeff[0][0] = coeff_0_0;
matrix.coeff[0][1] = coeff_0_1;
matrix.coeff[0][2] = coeff_0_2;
matrix.coeff[1][0] = coeff_1_0;
matrix.coeff[1][1] = coeff_1_1;
matrix.coeff[1][2] = coeff_1_2;
matrix.coeff[2][0] = coeff_2_0;
matrix.coeff[2][1] = coeff_2_1;
matrix.coeff[2][2] = coeff_2_2;
if (progress)
gimp_progress_start (progress, _("2D Transform..."), FALSE);
/* Transform the selection */
success = gimp_drawable_transform_affine (drawable, context,
&matrix, transform_direction,
interpolation, supersample,
recursion_level,
clip_result, progress);
if (progress)
gimp_progress_end (progress);
}
}
CODE
);
}
@headers = qw("libgimpmath/gimpmath.h" "config/gimpcoreconfig.h" @headers = qw("libgimpmath/gimpmath.h" "config/gimpcoreconfig.h"
"core/gimp.h" "core/gimp-transform-utils.h" "core/gimpimage.h" "core/gimp.h" "core/gimp-transform-utils.h" "core/gimpimage.h"
"core/gimpdrawable.h" "core/gimpdrawable-transform.h" "core/gimpdrawable.h" "core/gimpdrawable-transform.h"
@ -588,7 +680,8 @@ CODE
@procs = qw(drawable_transform_flip drawable_transform_flip_free @procs = qw(drawable_transform_flip drawable_transform_flip_free
drawable_transform_perspective drawable_transform_perspective
drawable_transform_rotate drawable_transform_scale drawable_transform_rotate drawable_transform_scale
drawable_transform_shear drawable_transform_2d); drawable_transform_shear drawable_transform_2d
drawable_transform_matrix);
%exports = (app => [@procs], lib => [@procs]); %exports = (app => [@procs], lib => [@procs]);

220
tools/pdbgen/pdb/transform_tools.pdb
View File

@ -68,11 +68,16 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
success = gimp_drawable_transform_flip (drawable, context, gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
flip_type, TRUE, 0.0, FALSE); {
success = gimp_drawable_transform_flip (drawable, context,
flip_type, TRUE, 0.0, FALSE);
}
} }
CODE CODE
); );
@ -127,43 +132,39 @@ HELP
vars => [ 'gdouble trans_info[8]' ], vars => [ 'gdouble trans_info[8]' ],
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_perspective (x, y, width, height,
GimpMatrix3 matrix; trans_info[X0], trans_info[Y0],
GimpInterpolationType interpolation_type; trans_info[X1], trans_info[Y1],
trans_info[X2], trans_info[Y2],
trans_info[X3], trans_info[Y3],
&matrix);
/* Assemble the transformation matrix */ if (interpolation)
gimp_transform_matrix_perspective (x, y, x + width, y + height, interpolation_type = gimp->config->interpolation_type;
trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
trans_info[X2], trans_info[Y2],
trans_info[X3], trans_info[Y3],
&matrix);
if (interpolation) if (progress)
interpolation_type = gimp->config->interpolation_type; gimp_progress_start (progress, _("Perspective..."), FALSE);
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) /* Perspective the selection */
gimp_progress_start (progress, _("Perspective..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, TRUE, 3,
FALSE, progress);
/* Perspective the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, TRUE, 3,
FALSE, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
CODE CODE
@ -201,39 +202,35 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_rotate (x, y, width, height,
GimpMatrix3 matrix; angle, &matrix);
GimpInterpolationType interpolation_type;
/* Assemble the transformation matrix */ if (interpolation)
gimp_transform_matrix_rotate (x, y, x + width, y + height, interpolation_type = gimp->config->interpolation_type;
angle, &matrix);
if (interpolation) if (progress)
interpolation_type = gimp->config->interpolation_type; gimp_progress_start (progress, _("Rotating..."), FALSE);
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) /* Rotate the selection */
gimp_progress_start (progress, _("Rotating..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, FALSE, 3,
FALSE, progress);
/* Rotate the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, FALSE, 3,
FALSE, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
CODE CODE
@ -280,43 +277,41 @@ HELP
vars => [ 'gdouble trans_info[4]' ], vars => [ 'gdouble trans_info[4]' ],
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = (gimp_item_is_attached (GIMP_ITEM (drawable)) && success = (gimp_item_is_attached (GIMP_ITEM (drawable)) &&
trans_info[X0] < trans_info[X1] && trans_info[X0] < trans_info[X1] &&
trans_info[Y0] < trans_info[X1]); trans_info[Y0] < trans_info[X1]);
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_scale (x, y, width, height,
GimpMatrix3 matrix; trans_info[X0],
GimpInterpolationType interpolation_type; trans_info[Y0],
trans_info[X1] - trans_info[X0],
trans_info[Y1] - trans_info[Y0],
&matrix);
/* Assemble the transformation matrix */ if (interpolation)
gimp_transform_matrix_scale (x, y, x + width, y + height, interpolation_type = gimp->config->interpolation_type;
trans_info[X0], trans_info[Y0],
trans_info[X1], trans_info[Y1],
&matrix);
if (interpolation) if (progress)
interpolation_type = gimp->config->interpolation_type; gimp_progress_start (progress, _("Scaling..."), FALSE);
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) /* Scale the selection */
gimp_progress_start (progress, _("Scaling..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, TRUE, 3,
FALSE, progress);
/* Scale the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, TRUE, 3,
FALSE, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
CODE CODE
@ -359,40 +354,36 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
gint x, y, width, height; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
if (gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height)) /* Assemble the transformation matrix */
{ gimp_transform_matrix_shear (x, y, width, height,
GimpMatrix3 matrix; shear_type, magnitude,
GimpInterpolationType interpolation_type; &matrix);
/* Assemble the transformation matrix */ if (interpolation)
gimp_transform_matrix_shear (x, y, x + width, y + height, interpolation_type = gimp->config->interpolation_type;
shear_type, magnitude,
&matrix);
if (interpolation) if (progress)
interpolation_type = gimp->config->interpolation_type; gimp_progress_start (progress, _("Shearing..."), FALSE);
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) /* Shear the selection */
gimp_progress_start (progress, _("Shearing..."), FALSE); success = gimp_drawable_transform_affine (drawable, context,
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, FALSE, 3,
FALSE, progress);
/* Shear the selection */ if (progress)
success = gimp_drawable_transform_affine (drawable, context, gimp_progress_end (progress);
&matrix,
GIMP_TRANSFORM_FORWARD,
interpolation_type, FALSE, 3,
FALSE, progress);
if (progress)
gimp_progress_end (progress);
}
} }
} }
CODE CODE
@ -445,12 +436,15 @@ HELP
%invoke = ( %invoke = (
code => <<'CODE' code => <<'CODE'
{ {
gint x, y, width, height;
success = gimp_item_is_attached (GIMP_ITEM (drawable)); success = gimp_item_is_attached (GIMP_ITEM (drawable));
if (success) if (success &&
gimp_drawable_mask_intersect (drawable, &x, &y, &width, &height))
{ {
GimpMatrix3 matrix; GimpMatrix3 matrix;
GimpInterpolationType interpolation_type; GimpInterpolationType interpolation_type = GIMP_INTERPOLATION_NONE;
/* Assemble the transformation matrix */ /* Assemble the transformation matrix */
gimp_matrix3_identity (&matrix); gimp_matrix3_identity (&matrix);
@ -461,8 +455,6 @@ HELP
if (interpolation) if (interpolation)
interpolation_type = gimp->config->interpolation_type; interpolation_type = gimp->config->interpolation_type;
else
interpolation_type = GIMP_INTERPOLATION_NONE;
if (progress) if (progress)
gimp_progress_start (progress, _("2D Transform..."), FALSE); gimp_progress_start (progress, _("2D Transform..."), FALSE);