static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_STRING, "url", "URL of the webpage to screenshot" },
{ GIMP_PDB_INT32, "width", "The width of the screenshot (in pixels)" },
{ GIMP_PDB_INT32, "font-size", "The font size to use in the page (in pt)" }
};
static const GimpParamDef return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Create an image of a webpage"),
"The plug-in allows you to take a screenshot "
"of a webpage.",
"Mukund Sivaraman <*****@*****.**>",
"2011",
"2011",
N_("From _Webpage..."),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (args),
G_N_ELEMENTS (return_vals),
args, return_vals);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/File/Create/Acquire");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "percent", "Percent sharpening (default = 10)" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Make image sharper "
"(less powerful than Unsharp Mask)"),
"This plug-in selectively performs a convolution "
"filter on an image.",
"Michael Sweet <*****@*****.**>",
"Copyright 1997-1998 by Michael Sweet",
PLUG_IN_VERSION,
N_("_Sharpen..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Enhance");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "horizontal", "Sobel in horizontal direction" },
{ GIMP_PDB_INT32, "vertical", "Sobel in vertical direction" },
{ GIMP_PDB_INT32, "keep-sign", "Keep sign of result (one direction only)" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Specialized direction-dependent edge detection"),
"This plugin calculates the gradient with a sobel "
"operator. The user can specify which direction to "
"use. When both directions are used, the result is "
"the RMS of the two gradients; if only one direction "
"is used, the result either the absolut value of the "
"gradient, or 127 + gradient (if the 'keep sign' "
"switch is on). This way, information about the "
"direction of the gradient is preserved. Resulting "
"images are not autoscaled.",
"Thorsten Schnier",
"Thorsten Schnier",
"1997",
N_("_Sobel..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Edge-Detect");
}
static void
query (void)
{
// Build the description of the parameters that the function expects.
// Each parameter has a type, a name, and a description
// All plug-ins must take a run-mode. Plug-ins associated with an
// image
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Run mode" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input layer or other drawable" }
}; // args
// Tell the GIMP about our plugin.
gimp_install_procedure (
"munge-image", // Name
"Have fun with the image", // Blurb
"I don't really care what this does. It's just a test of tile-stream",
// Help
"Samuel A. Rebelsky", // Author
"Copyright (c) Samuel A. Rebelsky. All rights reserved.",
// Copyright
"2013", // Year
"<Image>/MediaScript/Munge", // Path
"RGB", // Image types
GIMP_PLUGIN, // Type
3, // Number of params
0, // Number of return vals
args, // Param descriptions
NULL // Return descriptions
);
} // query
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "angle", "Angle { 90 (1), 180 (2), 270 (3) } degrees" },
{ GIMP_PDB_INT32, "everything", "Rotate the whole image { TRUE, FALSE }" }
};
gimp_install_procedure (PLUG_IN_PROC,
"Rotates a layer or the whole image by 90, 180 or 270 degrees",
"This plug-in does rotate the active layer or the "
"whole image clockwise by multiples of 90 degrees. "
"When the whole image is choosen, the image is "
"resized if necessary.",
PLUG_IN_AUTHOR,
PLUG_IN_COPYRIGHT,
PLUG_IN_VERSION,
NULL,
PLUG_IN_IMAGE_TYPES,
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_COLOR, "color", "Color to remove" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Convert a specified color to transparency"),
"This replaces as much of a given color as possible "
"in each pixel with a corresponding amount of alpha, "
"then readjusts the color accordingly.",
"Seth Burgess",
"Seth Burgess <*****@*****.**>",
"7th Aug 1999",
N_("Color to _Alpha..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC,
"<Image>/Colors/Modify");
gimp_plugin_menu_register (PLUG_IN_PROC,
"<Image>/Layer/Transparency/Modify");
}
static void
query (void)
{
static const GimpParamDef load_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_STRING, "raw-filename", "The name of the file to load" }
};
static const GimpParamDef load_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Output image" }
};
gimp_install_procedure (LOAD_PROC,
"loads files of the tiff file format",
"FIXME: write help for tiff_load",
"Spencer Kimball, Peter Mattis & Nick Lamb",
"Nick Lamb <*****@*****.**>",
"1995-1996,1998-2003",
N_("TIFF image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (load_args),
G_N_ELEMENTS (load_return_vals),
load_args, load_return_vals);
gimp_register_file_handler_mime (LOAD_PROC, "image/tiff");
gimp_register_magic_load_handler (LOAD_PROC,
"tif,tiff",
"",
"0,string,II*\\0,0,string,MM\\0*");
}
static void
query (void)
{
static const GimpParamDef save_args[] =
{
{GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }"},
{GIMP_PDB_IMAGE, "image", "Input image"},
{GIMP_PDB_DRAWABLE, "drawable", "Drawable to save"},
{GIMP_PDB_STRING, "filename", "The name of the file to save the image in"},
{GIMP_PDB_STRING, "raw-filename", "The name entered"},
{GIMP_PDB_STRING, "file-type", "File type to use"}
};
gimp_install_procedure (SAVE_PROC,
"Saves grayscale image in various text formats",
"This plug-in uses aalib to save grayscale image "
"as ascii art into a variety of text formats",
"Tim Newsome <*****@*****.**>",
"Tim Newsome <*****@*****.**>",
"1997",
N_("ASCII art"),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "text/plain");
gimp_register_save_handler (SAVE_PROC, "txt,ansi,text", "");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Stretch brightness values to cover the full range"),
"This plugin performs almost the same operation as "
"the 'contrast autostretch' plugin, except that it "
"won't allow the color channels to normalize "
"independently. This is actually what most people "
"probably want instead of contrast-autostretch; use "
"c-a only if you wish to remove an undesirable "
"color-tint from a source image which is supposed to "
"contain pure-white and pure-black.",
"Adam D. Moss, Federico Mena Quintero",
"Adam D. Moss, Federico Mena Quintero",
"1997",
N_("_Normalize"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
}
static void
query (void)
{
static const GimpParamDef args [] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }"},
{ GIMP_PDB_IMAGE, "image", "Input image"},
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable (not used)"},
{ GIMP_PDB_INT32, "link-after-alignment", "Link the visible layers after alignment { TRUE, FALSE }"},
{ GIMP_PDB_INT32, "use-bottom", "use the bottom layer as the base of alignment { TRUE, FALSE }"}
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Align all visible layers of the image"),
"Align visible layers",
"Shuji Narazaki <*****@*****.**>",
"Shuji Narazaki",
"1997",
N_("Align Visi_ble Layers..."),
"RGB*,GRAY*,INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Image/Arrange");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "amount", "Edge detection amount" },
{ GIMP_PDB_INT32, "wrapmode", "Edge detection behavior: { WRAP (0), SMEAR (1), BLACK (2) }" },
{ GIMP_PDB_INT32, "edgemode", "Edge detection algorithm: { SOBEL (0), PREWITT (1), GRADIENT (2), ROBERTS (3), DIFFERENTIAL (4), LAPLACE (5) }" }
};
const gchar *help_string =
"Perform edge detection on the contents of the specified drawable."
"AMOUNT is an arbitrary constant, WRAPMODE is like displace plug-in "
"(useful for tilable image). EDGEMODE sets the kind of matrix "
"transform applied to the pixels, SOBEL was the method used in older "
"versions.";
gimp_install_procedure (PLUG_IN_PROC,
N_("Several simple methods for detecting edges"),
help_string,
"Peter Mattis & (ported to 1.0 by) Eiichi Takamori",
"Peter Mattis",
"1996",
N_("_Edge..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Edge-Detect");
}
static void
query ()
{
static GParamDef args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (unused)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_INT32, "horizontal", "Sobel in horizontal direction" },
{ PARAM_INT32, "vertical", "Sobel in vertical direction" },
{ PARAM_INT32, "keep_sign", "Keep sign of result (one direction only)" },
};
static GParamDef *return_vals = NULL;
static int nargs = sizeof (args) / sizeof (args[0]);
static int nreturn_vals = 0;
gimp_install_procedure ("plug_in_sobel",
"Edge Detection with Sobel Operation",
"This plugin calculates the gradient with a sobel operator. The user can specify which direction to use. When both directions are used, the result is the RMS of the two gradients; if only one direction is used, the result either the absolut value of the gradient, or 127 + gradient (if the 'keep sign' switch is on). This way, information about the direction of the gradient is preserved. Resulting images are not autoscaled.",
"Thorsten Schnier",
"Thorsten Schnier",
"1997",
"<Image>/Filters/Edge-Detect/Sobel",
"RGB*, GRAY*, U16_RGB*, U16_GRAY*, FLOAT_RGB*, FLOAT_GRAY*, FLOAT16_RGB*, FLOAT16_GRAY*",
PROC_PLUG_IN,
nargs, nreturn_vals,
args, return_vals);
_("Edge-Detect");
_("Sobel");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "The Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "The Drawable" },
{ GIMP_PDB_INT32, "mode", "Mode { NTSC (0), PAL (1) }" },
{ GIMP_PDB_INT32, "action", "The action to perform" },
{ GIMP_PDB_INT32, "new-layer", "Create a new layer { TRUE, FALSE }" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Find and fix pixels that may be unsafely bright"),
"hot scans an image for pixels that will give unsave "
"values of chrominance or composite signale "
"amplitude when encoded into an NTSC or PAL signal. "
"Three actions can be performed on these ``hot'' "
"pixels. (0) reduce luminance, (1) reduce "
"saturation, or (2) Blacken.",
"Eric L. Hernes, Alan Wm Paeth",
"Eric L. Hernes",
"1997",
N_("_Hot..."),
"RGB",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Colors/Modify");
}
static void query(void)
{
static const GimpParamDef args[] = {
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_DRAWABLE, "marked", "Marking drawable" },
{ GIMP_PDB_INT32, "use_mask", "Enable to mask unselected areas" },
{ GIMP_PDB_FLOAT, "thresh", "Alpha threshold for markings" },
{ GIMP_PDB_INT32, "mio", "Marked image includes the pixels from the original image" },
{ GIMP_PDB_INT32, "white_mask", "Enable to mask pure white areas" },
{ GIMP_PDB_INT32, "use_chroma", "Use chroma in addition to luminance" },
{ GIMP_PDB_INT32, "entire_image", "Use the entire image, even when the selected area is smaller" },
};
gimp_install_procedure(
"plug_in_colorize",
"Re-color images using optimization techniques.",
"This plug-in uses the algorithm described by Anat Levin, "
"Dani Lischinski, and Yair Weiss. Full information is "
"available at http://www.cs.huji.ac.il/~yweiss/Colorization/ "
"or http://www.cs.huji.ac.il/~yweiss/Colorization/colorization-siggraph04.pdf",
"Christopher Lais",
"Christopher Lais",
PLUG_IN_VERSION,
"Colorization...",
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS(args), 0,
args, NULL
);
gimp_plugin_menu_register("plug_in_colorize", "<Image>/Colors");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "monochrome", "Monochrome { TRUE, FALSE }" },
{ GIMP_PDB_FLOAT, "rr-gain", "Set the red gain for the red channel" },
{ GIMP_PDB_FLOAT, "rg-gain", "Set the green gain for the red channel" },
{ GIMP_PDB_FLOAT, "rb-gain", "Set the blue gain for the red channel" },
{ GIMP_PDB_FLOAT, "gr-gain", "Set the red gain for the green channel" },
{ GIMP_PDB_FLOAT, "gg-gain", "Set the green gain for the green channel" },
{ GIMP_PDB_FLOAT, "gb-gain", "Set the blue gain for the green channel" },
{ GIMP_PDB_FLOAT, "br-gain", "Set the red gain for the blue channel" },
{ GIMP_PDB_FLOAT, "bg-gain", "Set the green gain for the blue channel" },
{ GIMP_PDB_FLOAT, "bb-gain", "Set the blue gain for the blue channel" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Alter colors by mixing RGB Channels"),
"This plug-in mixes the RGB channels.",
"Martin Guldahl <*****@*****.**>",
"Martin Guldahl <*****@*****.**>",
"2002",
N_("Channel Mi_xer..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Colors/Components");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "num-domain-names", "" },
{ GIMP_PDB_STRINGARRAY, "domain-names", "" },
{ GIMP_PDB_INT32, "num-domain-uris", "" },
{ GIMP_PDB_STRINGARRAY, "domain-uris", "" }
};
gimp_install_procedure (GIMP_HELP_EXT_PROC,
"", /* FIXME */
"", /* FIXME */
"Sven Neumann <*****@*****.**>, "
"Michael Natterer <*****@*****.**>, "
"Henrik Brix Andersen <*****@*****.**>",
"Sven Neumann, Michael Natterer & Henrik Brix Andersen",
"1999-2008",
NULL,
"",
GIMP_EXTENSION,
G_N_ELEMENTS (args), 0,
args, NULL);
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "scale", "Biggest scale value" },
{ GIMP_PDB_INT32, "nscales", "Number of scales" },
{ GIMP_PDB_INT32, "scales-mode", "Retinex distribution through scales" },
{ GIMP_PDB_FLOAT, "cvar", "Variance value" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Enhance contrast using the Retinex method"),
"The Retinex Image Enhancement Algorithm is an "
"automatic image enhancement method that enhances "
"a digital image in terms of dynamic range "
"compression, color independence from the spectral "
"distribution of the scene illuminant, and "
"color/lightness rendition.",
"Fabien Pelisson",
"Fabien Pelisson",
"2003",
N_("Retine_x..."),
"RGB*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Colors/Modify");
}
static void
query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
gimp_plugin_domain_register (GETTEXT_PACKAGE, LOCALEDIR);
gimp_install_procedure (PLUG_IN_PROC,
N_("Optimize & export image for web"),
"Optimize image for web.",
"Aurimas Juška",
"Aurimas Juška",
"0.25",
N_("Export for We_b..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/File/Export");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "refraction", "Lens refraction index" },
{ GIMP_PDB_INT32, "keep-surroundings", "Keep lens surroundings { TRUE, FALSE }" },
{ GIMP_PDB_INT32, "set-background", "Set lens surroundings to BG value { TRUE, FALSE }" },
{ GIMP_PDB_INT32, "set-transparent", "Set lens surroundings transparent { TRUE, FALSE }" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Simulate an elliptical lens over the image"),
"This plug-in uses Snell's law to draw "
"an ellipsoid lens over the image",
"Morten Eriksen",
"Morten Eriksen",
"1997",
N_("Apply _Lens..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC,
"<Image>/Filters/Distorts");
}
static void
query (void)
{
static const GimpParamDef save_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
{ GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
{ GIMP_PDB_STRING, "raw-filename", "The name of the file to save the image in" }
};
gimp_install_procedure (SAVE_PROC,
"GIMP Table Magic",
"Allows you to draw an HTML table in GIMP. See help for more info.",
"Daniel Dunbar",
"Daniel Dunbar",
"1998",
_("HTML table"),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (save_args), 0,
save_args, NULL);
gimp_register_file_handler_mime (SAVE_PROC, "text/html");
gimp_register_save_handler (SAVE_PROC, "html,htm", "");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "shift-amount", "shift amount (0 <= shift_amount_x <= 200)" },
{ GIMP_PDB_INT32, "orientation", "vertical, horizontal orientation" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Shift each row of pixels by a random amount"),
"Shifts the pixels of the specified drawable. "
"Each row will be displaced a random value of pixels.",
"Spencer Kimball and Peter Mattis, ported by Brian "
"Degenhardt and Federico Mena Quintero",
"Brian Degenhardt",
"1997",
N_("_Shift..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Distorts");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "The Image" },
{ GIMP_PDB_DRAWABLE, "drawable", "The Drawable" },
{ GIMP_PDB_FLOAT, "amplitude", "The Amplitude of the Waves" },
{ GIMP_PDB_FLOAT, "phase", "The Phase of the Waves" },
{ GIMP_PDB_FLOAT, "wavelength", "The Wavelength of the Waves" },
{ GIMP_PDB_INT32, "type", "Type of waves, black/smeared" },
{ GIMP_PDB_INT32, "reflective", "Use Reflection" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Distort the image with waves"),
"none yet",
"Eric L. Hernes, Stephen Norris",
"Stephen Norris",
"1997",
N_("_Waves..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Distorts");
}
/* Register plugin to Procedural DataBase */
static void
query()
{
/* resynth_paramdefs defined in resynth-parameters.h */
GimpParamDef *return_vals = NULL;
gint nargs = sizeof(resynth_paramdefs)/sizeof(resynth_paramdefs[0]);
gint nreturn_vals = 0;
gimp_plugin_domain_register (RESYNTH_DOMAIN_NAME, LOCALEDIR);
gimp_install_procedure(
RESYNTH_CONTROLS_PDB_NAME,
N_("Make tiles, apply themes, render texture, remove features, etc."),
"The resynthesizer control panel.",
"Paul Francis Harrison, Lloyd Konneker",
"2000 Paul Francis Harrison, 2010 Lloyd Konneker",
"2010",
N_("_Resynthesize..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
nargs, nreturn_vals,
resynth_paramdefs, return_vals);
gimp_plugin_menu_register(RESYNTH_CONTROLS_PDB_NAME, "<Image>/Filters/Map");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "period", "Period: number of pixels for one wave to complete" },
{ GIMP_PDB_INT32, "amplitude", "Amplitude: maximum displacement of wave" },
{ GIMP_PDB_INT32, "orientation", "Orientation { ORIENTATION-HORIZONTAL (0), ORIENTATION-VERTICAL (1) }" },
{ GIMP_PDB_INT32, "edges", "Edges { SMEAR (0), WRAP (1), BLANK (2) }" },
{ GIMP_PDB_INT32, "waveform", "Waveform { SAWTOOTH (0), SINE (1) }" },
{ GIMP_PDB_INT32, "antialias", "Antialias { TRUE, FALSE }" },
{ GIMP_PDB_INT32, "tile", "Tileable { TRUE, FALSE }" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Displace pixels in a ripple pattern"),
"Ripples the pixels of the specified drawable. "
"Each row or column will be displaced a certain "
"number of pixels coinciding with the given wave form",
"Brian Degenhardt <*****@*****.**>",
"Brian Degenhardt",
"1997",
N_("_Ripple..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
}
static void
query (void)
{
static const GimpParamDef print_args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0) }" },
{ GIMP_PDB_IMAGE, "image", "Image to print" }
};
gimp_install_procedure (PRINT_PROC_NAME,
N_("Print the image"),
"Print the image using the GTK+ Print API.",
"Bill Skaggs, Sven Neumann, Stefan Röllin",
"Bill Skaggs <*****@*****.**>",
"2006 - 2008",
N_("_Print..."),
"*",
GIMP_PLUGIN,
G_N_ELEMENTS (print_args), 0,
print_args, NULL);
gimp_plugin_menu_register (PRINT_PROC_NAME, "<Image>/File/Send");
gimp_plugin_icon_register (PRINT_PROC_NAME, GIMP_ICON_TYPE_STOCK_ID,
(const guint8 *) GTK_STOCK_PRINT);
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "radius", "Filter box radius (default = 3)" },
{ GIMP_PDB_INT32, "type", "Filter type { MEDIAN (0), ADAPTIVE (1), RECURSIVE-MEDIAN (2), RECURSIVE-ADAPTIVE (3) }" },
{ GIMP_PDB_INT32, "black", "Black level (-1 to 255)" },
{ GIMP_PDB_INT32, "white", "White level (0 to 256)" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Remove speckle noise from the image"),
"This plug-in selectively performs a median or "
"adaptive box filter on an image.",
"Michael Sweet <*****@*****.**>",
"Copyright 1997-1998 by Michael Sweet",
PLUG_IN_VERSION,
N_("Des_peckle..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Enhance");
}
/* tell GIMP who we are */
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }
};
static const GimpParamDef return_vals[] =
{
{ GIMP_PDB_INT32, "num-colors", "Number of colors in the image" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Analyze the set of colors in the image"),
"Analyze colorcube and print some information about "
"the current image (also displays a color-histogram)",
"*****@*****.**",
"*****@*****.**",
"June 20th, 1997",
N_("Colorcube A_nalysis..."),
"RGB*, GRAY*, INDEXED*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), G_N_ELEMENTS (return_vals),
args, return_vals);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Colors/Info");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "circle", "Circle depth in %" },
{ GIMP_PDB_FLOAT, "angle", "Offset angle" },
{ GIMP_PDB_INT32, "backwards", "Map backwards { TRUE, FALSE }" },
{ GIMP_PDB_INT32, "inverse", "Map from top { TRUE, FALSE }" },
{ GIMP_PDB_INT32, "polrec", "Polar to rectangular { TRUE, FALSE }" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Convert image to or from polar coordinates"),
"Remaps and image from rectangular coordinates "
"to polar coordinates "
"or vice versa",
"Daniel Dunbar and Federico Mena Quintero",
"Daniel Dunbar and Federico Mena Quintero",
PLUG_IN_VERSION,
N_("P_olar Coordinates..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Distorts");
}
static void
query (void)
{
static const GimpParamDef args[]=
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_INT32, "xcenter", "X coordinates of the center of supernova" },
{ GIMP_PDB_INT32, "ycenter", "Y coordinates of the center of supernova" },
{ GIMP_PDB_COLOR, "color", "Color of supernova" },
{ GIMP_PDB_INT32, "radius", "Radius of supernova" },
{ GIMP_PDB_INT32, "nspoke", "Number of spokes" },
{ GIMP_PDB_INT32, "randomhue", "Random hue" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Add a starburst to the image"),
"This plug-in produces an effect like a supernova "
"burst. The amount of the light effect is "
"approximately in proportion to 1/r, where r is the "
"distance from the center of the star. It works with "
"RGB*, GRAY* image.",
"Eiichi Takamori",
"Eiichi Takamori",
"May 2000",
N_("Super_nova..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC,
"<Image>/Filters/Light and Shadow/Light");
}
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_FLOAT, "inner", "Radius of inner gaussian blur (in pixels, > 0.0)" },
{ GIMP_PDB_FLOAT, "outer", "Radius of outer gaussian blur (in pixels, > 0.0)" },
{ GIMP_PDB_INT32, "normalize", "Normalize { TRUE, FALSE }" },
{ GIMP_PDB_INT32, "invert", "Invert { TRUE, FALSE }" }
};
gimp_install_procedure (PLUG_IN_PROC,
N_("Edge detection with control of edge thickness"),
"Applies two Gaussian blurs to the drawable, and "
"subtracts the results. This is robust and widely "
"used method for detecting edges.",
"Spencer Kimball, Peter Mattis, Sven Neumann, William Skaggs",
"Spencer Kimball, Peter Mattis, Sven Neumann, William Skaggs",
"1995-2004",
N_("_Difference of Gaussians..."),
"RGB*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Edge-Detect");
}
