| G'MIC(1) | General Commands Manual | G'MIC(1) |
NAME¶
gmic - Perform generic image processing operations, through the G'MIC language interpreter.
HELP¶
gmic: GREYC's Magic for Image Computing.
Version 1.7.9, Copyright (c) 2008-2016, David Tschumperle.
(http://gmic.eu)
1. Usage
-----
gmic [-command1 [arg1_1,arg1_2,..]] .. [-commandN
[argN_1,argN_2,..]]
'gmic' is the open-source interpreter of the G'MIC language, a script-based
programming
language dedicated to the design of possibly complex image processing
pipelines.
It can be used to convert, manipulate, filter and visualize image datasets
made of one
or several 1d/2d or 3d multi-spectral images.
This reference documentation describes the rules and technical aspects of the
G'MIC language.
You may be also interested by our detailed tutorial pages, at:
http://gmic.eu/tutorial/
2. Overall context
---------------
- At any time, G'MIC manages one list of numbered (and optionally named)
pixel-based images,
entirely stored (not compressed) in computer memory.
- The first image of the list has indice '0' and is denoted by '[0]'.
The second image of the
list is denoted by '[1]', the third by '[2]' and so on.
- Negative indices are treated in a periodic way: '[-1]' refers to the
last image of the list,
'[-2]' to the penultimate one, etc. Thus, if the list has 4 images,
'[1]' and '[-3]' both
designate the second image of the list.
- A named image may be also indicated by '[name]', if 'name' uses the
character set [a-zA-Z0-9_]
and does not start with a number. Image names can be set or reassigned at any
moment during
the processing pipeline (see commands '-name' and '-input' for
this purpose).
- G'MIC defines a set of various commands and substitution mechanisms to
allow the design of
complex pipelines managing this list of images, in a very flexible way:
You can insert or remove images in the list, rearrange image indices, process
images
(individually or grouped), merge image data together, display and output
image files, etc.
- Such a pipeline can be written itself as a custom G'MIC command storable in
a user
command file, and can be re-used afterwards in another pipeline if
necessary.
3. Image definition and terminology
--------------------------------
- In G'MIC, each image is modeled as a 1d, 2d, 3d or 4d array of scalar
values, uniformly
discretized on a rectangular/parallelepipedic domain.
- The four dimensions of this array are respectively denoted by:
. 'width', the number of image columns (size along the 'x'-axis).
. 'height', the number of image rows (size along the 'y'-axis).
. 'depth', the number of image slices (size along the 'z'-axis).
(the depth is equal to 1 for usual color or grayscale 2d images).
. 'spectrum', the number of image channels (size along the 'c'-axis).
(the spectrum is respectively equal to 3 and 4 for usual RGB and RGBA color
images).
- There are no hard limitations on the size the image along each dimension.
For instance,
the number of image slices or channels can be of arbitrary size within the
limits of
the available memory.
- The width, height and depth of an image are considered as spatial
dimensions, while the
spectrum has a multi-spectral meaning. Thus, a 4d image in G'MIC should be
most often
regarded as a 3d dataset of multi-spectral voxels. Most of the G'MIC commands
will stick with
this idea (e.g. command '-blur' blurs images only along the spatial
'xyz'-axes).
- G'MIC stores all the image data as buffers of 'float' values (32 bits,
value range
[-3.4E38,+3.4E38]). It performs all its image processing operations with
floating point
numbers. Each image pixel takes then 32bits/channel (except if
double-precision buffers have
been enabled during the compilation of the software, in which case
64bits/channel is the
default).
- Considering 'float'-valued pixels ensure to keep the numerical precision
when executing
image processing pipelines. For image input/output operations, you may want
to prescribe the
image datatype to be different than 'float' (like 'bool', 'char', 'int',
etc...).
This is possible by specifying it as a file option when using I/O commands.
(see section 'Input/output properties' to learn more about file
options).
4. Items of a processing pipeline
------------------------------
- In G'MIC, an image processing pipeline is described as a sequence of items
separated by the
space character ' '. Such items are interpreted and executed from the left to
the right.
For instance, the expression:
filename.jpg -blur 3,0 -sharpen 10 -resize 200%,200% -output
output.jpg
defines a valid pipeline composed of nine G'MIC items.
- Each G'MIC item is a string that is either a command, a list of command
arguments,
a filename, or a special input string.
- Escape characters '\' and double quotes '"' can be used to define
items containing spaces or
other special characters. For instance, the two strings 'single\ item'
and '"single item"'
both define the same single item, with a space in it.
5. Input data items
----------------
- If a specified G'MIC item appears to be an existing filename, the
corresponding image data
are loaded and inserted at the end of the image list (which is equivalent to
the use of
'-input filename').
- Special filenames '-' and '-.ext' stand for the standard
input/output streams, optionally
forced to be in a specific 'ext' file format (e.g. '-.jpg' or
'-.png').
- The following special input strings may be used as G'MIC items to create
and insert new
images with prescribed values, at the end of the image list:
. '[selection]' or '[selection]xN': Insert 1 or N copies of
already existing images.
'selection' may represent one or several images
(see section 'Command items and selections' to learn more about
selections).
. 'width[%],_height[%],_depth[%],_spectrum[%],_values': Insert a new
image with specified
size and values (adding '%' to a dimension means 'percentage of the size
along the same
axis, taken from the last image '[-1]''). Any specified dimension can be also
written as
'[image]', and is then set to the size (along the same axis) of the
existing specified image
[image]. 'values' can be either a sequence of numbers separated by commas
',', or a
mathematical expression, as e.g. in input item
'256,256,1,3,if(c==0,x,if(c==1,y,0))' which
creates a 256x256 RGB color image with a spatial shading on the red and green
channels.
(see section 'Mathematical expressions' to learn more about
mathematical expressions).
. '(v1,v2,..)': Insert a new image from specified prescribed values.
Value separator inside
parentheses can be ',' (column separator), ';' (row separator), '/' (slice
separator) or
'^' (channel separator). For instance, expression
'(1,2,3;4,5,6;7,8,9)' creates a 3x3 matrix
(scalar image), with values running from 1 to 9.
. '0': Insert a new 'empty' image, containing no pixel data. Empty
images are used only in rare
occasions.
- Input item 'name=value' declares a new local or global variable
'name', or assign a new value
to an existing variable. Variable names must use the character set
[a-zA-Z0-9_] and cannot
start with a number.
- A variable definition is always local to the current command except when it
starts by the
underscore character '_'. In that case, it becomes also accessible by any
command invoked
outside the current command scope (global variable).
- If a variable name starts with two underscores '__', the global variable is
also shared among
different threads and can be read/set by commands running in parallel (see
command '-parallel'
for this purpose). Otherwise, it remains local to the thread that defined
it.
- Numerical variables can be updated with the use of these special operators:
'+=' (addition), '-=' (subtraction), '*=' (multiplication), '/=' (division),
'%=' (modulo),
'&=' (bitwise and), '|=' (bitwise or), '^=' (power), '<<=' and
'>>=' (bitwise left and right
shifts). As in pipeline: 'foo=1 foo+=3'.
6. Command items and selections
----------------------------
- A G'MIC item starting by a hyphen '-' designates a command, most of the
time. Generally,
commands perform image processing operations on one or several available
images of the list.
- Reccurent commands have two equivalent names (regular and short). For
instance, command names
'-resize' and '-r' refer to the same image resizing action.
- A G'MIC command may have mandatory or optional arguments. Command arguments
must be specified
in the next item on the command line. Commas ',' are used to separate
multiple arguments of a
single command, when required.
- The execution of a G'MIC command may be restricted only to a subset of the
image list, by
appending '[selection]' to the command name. Examples of valid
syntaxes for 'selection' are:
. '-command[-2]': Apply command only on the penultimate image [-2] of
the list.
. '-command[0,1,3]': Apply command only on images [0],[1] and [3].
. '-command[3-6]': Apply command only on images [3] to [6] (i.e,
[3],[4],[5] and [6]).
. '-command[50%-100%]': Apply command only on the second half of the
image list.
. '-command[0,-4--1]': Apply command only on the first image and the
last four images.
. '-command[0-9:3]': Apply command only on images [0] to [9], with a
step of 3
(i.e. on images [0], [3], [6] and [9]).
. '-command[0--1:2]': Apply command only on images of the list with
even indices.
. '-command[0,2-4,50%--1]': Apply command on images [0],[2],[3],[4]
and on the second half of
the image list.
. '-command[^0,1]': Apply command on all images except the two first.
. '-command[name1,name2]': Apply command on named images 'name1' and
'name2'.
- Indices in selections are always sorted in increasing order, and duplicate
indices are
discarded. For instance, selections '[3-1,1-3]' and
'[1,1,1,3,2]' are both equivalent to
'[1-3]'. If you want to repeat a single command multiple times on an
image, use a
'-repeat..-done' loop instead. Inverting the order of images for a
command is achieved by
explicitly inverting the order of the images in the list, with command
'-reverse[selection]'.
- Command selections '[-1]','[-2]' and '[-3]' are so
often used that they have their own
shortcuts, respectively '.', '..' and '...'. For
instance, command '-blur..' is equivalent to
'-blur[-2]'. These shortcuts work also when specifying command
arguments.
- G'MIC commands invoked without '[selection]' are applied on all
images of the list, i.e. the
default selection is '[0--1]' (except for command '-input'
whose default selection is '[-1]').
- A G'MIC command starting with a double hyphen '--' (instead of a single
hyphen '-') does not
act 'in-place' but inserts its result as one or several new images at the end
of the image
list.
- There are two different types of commands that can be run by the G'MIC
interpreter:
. Native commands, are the hard-coded functionalities in the interpreter
core. They are thus
compiled as binary code and run fast, most of the time. Omitting an argument
when invoking a
native command is not permitted, except if all following arguments are also
omitted.
For instance, invoking '-plasma 10,,5' is invalid but '-plasma
10' is correct.
. Custom commands, are defined as G'MIC pipelines of native or custom
commands. They are
interpreted by the G'MIC interpreter, and thus run a bit slower than native
commands.
Omitting arguments when invoking a custom command is permitted. For instance,
expressions
'-flower ,,,100,,2' or '-flower ,' are correct.
- Most of the existing commands in G'MIC are actually defined as custom
commands.
- A user can easily add its own custom commands to the G'MIC interpreter (see
section
'Adding custom commands' for more details). New native commands cannot
be added
(unless you modify the G'MIC interpreter source code and recompile it).
7. Input/output properties
-----------------------
- G'MIC is able to read/write most of the classical image file formats,
including:
. 2d grayscale/color files: .png, .jpeg, .gif, .pnm, .tif, .bmp, ...
. 3d volumetric files: .dcm, .hdr, .nii, .pan, .inr, .pnk, ...
. video files: .mpeg, .avi, .mov, .ogg, .flv, ...
. Generic ascii or binary data files: .gmz, .cimg, .cimgz, .dlm, .asc,
.pfm, .raw, .txt, .h.
. 3d object files: .off.
- When dealing with color images, G'MIC generally reads, writes and displays
data using the usual
sRGB color space.
- G'MIC is able to manage 3d objects that may be read from files or generated
by G'MIC commands.
A 3d object is stored as a one-column scalar image containing the object
data, in the
following order: { magic_number; sizes; vertices; primitives; colors;
opacities }.
These 3d representations can be then processed as regular images.
(see command '-split3d' for accessing each of these 3d object data
separately).
- Be aware that usual file formats may be sometimes not adapted to store all
the available image
data, since G'MIC uses float-valued image buffers. For instance, saving an
image that was
initially loaded as a 16bits/channel image, as a .jpg file will result
in a loss of
information. Use the G'MIC-specific file extensions .cimgz or
.gmz to ensure that all data
precision are preserved when saving images.
- Sometimes, file options may/must be set for file formats:
. Video files: Only sub-frames of an image sequence may be loaded, using the
input expression
'filename.ext,[first_frame[,last_frame[,step]]]'. Set 'last_frame==-1'
to tell it must be
the last frame of the video. Set 'step' to 0 to force an opened video file to
be
opened/closed. Output framerate and codec can be also set by using the output
expression
'filename.avi,_fps,_codec,_keep_open={ 0 | 1 }'. 'codec' is a 4-char
string
(see http://www.fourcc.org/codecs.php) or '0' for the default codec.
'keep_open' tells if
the output video file must be kept open for appending new frames
afterwards.
. .cimg[z] files: Only crops and sub-images of .cimg files can be loaded,
using the input
expressions 'filename.cimg,N0,N1', 'filename.cimg,N0,N1,x0,x1',
'filename.cimg,N0,N1,x0,y0,x1,y1',
'filename.cimg,N0,N1,x0,y0,z0,x1,y1,z1' or
'filename.cimg,N0,N1,x0,y0,z0,c0,x1,y1,z1,c1'.
Specifying '-1' for one coordinates stands for the maximum possible value.
Output expression
'filename.cimg[z][,datatype]' can be used to force the output pixel
type. 'datatype' can be
{ uchar | char | ushort | short | uint | int | uint64 | int64 | float |
double }.
. .raw binary files: Image dimensions and input pixel type may be specified
when loading .raw
files with input expresssion
'filename.raw[,datatype][,width][,height[,depth[,dim[,offset]]]]]'. If
no dimensions are
specified, the resulting image is a one-column vector with maximum possible
height. Pixel
type can also be specified with the output expression
'filename.raw[,datatype]'.
'datatype' can be the same as for .cimg[z] files.
. .yuv files: Image dimensions must be specified, and only sub-frames of an
image sequence may
be loaded, using the input expression
'filename.yuv,width,height[,first_frame[,last_frame[,step]]]'.
. .tiff files: Only sub-images of multi-pages tiff files can be loaded, using
the input
expression 'filename.tif,_first_frame,_last_frame,_step'.
Output expression
'filename.tiff,_datatype,_compression,_force_multipage,_use_bigtiff'
can
be used to specify the output pixel type, as well as the compression method.
'datatype' can be the same as for .cimg[z] files. 'compression' can be
{ none (default) | lzw | jpeg }. 'force_multipage can be { 0=no (default) |
1=yes }.
'use_bigtiff can be { 0=no | 1=yes (default) }.
. .gif files: Animated gif files can be saved, using the input expression
'filename.gif,fps>0,nb_loops'. Specify 'nb_loops=0' to get an
infinite number of animation
loops (this is the default behavior).
. .jpeg files: The output quality may be specified (in %), using the output
expression
'filename.jpg,30' (here, to get a 30% quality output). '100' is the
default.
. .mnc files: The output header can set from another file, using the output
expression
'filename.mnc,header_template.mnc'.
. .pan, .cpp, .hpp, .c and .h files: The output datatype can be selected with
output expression
'filename[,datatype]'. 'datatype' can be the same as for .cimg[z]
files.
. .gmic files: These filenames are assumed to be G'MIC custom commands files.
Loading such a
file will add the commands it defines to the interpreter. Debug information
can be
enabled/disabled by the input expression 'filename.gmic[,add_debug_info={
0 | 1 }]'.
. Inserting 'ext:' on the beginning of a filename (e.g.
'jpg:filename') forces G'MIC to
read/write the file as it would have been done if it had the specified
extension '.ext'.
- Some input/output formats and options may not be supported, depending on
the configuration
flags that have been set during the build of the G'MIC software.
8. Substitution rules
------------------
- G'MIC items containing '$' or '{}' are substituted before being
interpreted. Use these
substituting expressions to access various data from the interpreter
environment.
- '$name' and '${name}' are both substituted by the value of
the specified named variable
(set previously by the item 'name=value'). If this variable has not
been already set, the
expression is substituted by the highest positive indice of the named image
'[name]'. If no
image has this name, the expression is substituted by the value of the OS
environment variable
with same name (it may be thus an empty string).
The following reserved variables are predefined by the G'MIC interpreter:
. '$!': The current number of images in the list.
. '$>' and '$<': The increasing/decreasing indice of the
latest (currently running)
'repeat...done' loop.
. '$/': The current call stack. Stack items are separated by slashes
'/'.
. '$|': The current value (expressed in seconds) of a millisecond
precision timer.
. '$^': The current verbosity level.
. '$_cpus': The number of computation cores available on your machine.
. '$_pid': The current process identifier, as an integer.
. '$_prerelease': For pre-releases only, the date of the pre-release
as 'mmddyy'.
For stable releases, this variable is not defined.
. '$_version': A 3-digits number telling about the current version of
the G'MIC interpreter
(currently '179').
. '$_vt100': Set to 1 (default value) if colored text output is
allowed on the console.
. '$_path_rc': The path to the G'MIC folder used to store resources
and configuration files
(its value is OS-dependent).
. '$_path_user': The path to the G'MIC user file .gmic or user.gmic
(its value is
OS-dependent).
- '${"command line"}' is substituted by the status value set
by the execution of the specified
command line (see command '-status' to learn more about status).
Expression '${}' thus stands
for the current status value.
- '{``string}' (starting with two backquotes) is substituted by a
double-quoted version of the
specified string.
- '{/string}' is substituted by the escaped version of the specified
string.
- '{'string'}' (between single quotes) is substituted by the sequence
of ascii codes that compose
the specified string, separated by commas ','. For instance, item
'{'foo'}' is substituted
by '102,111,111'.
- '{image,feature}' is substituted by a specific feature of the image
[image]. 'image' can be
either an image number or an image name. It can be also eluded, in which
case, the last image
'[-1]' of the list is considered for the requested feature.
Specified 'feature' can be one of:
. 'b': The image basename (i.e. filename without the folder path nor
extension).
. 'f': The image folder name.
. 'n': The image name or filename (if the image has been read from a
file).
. 't': The text string from the image values regarded as ascii codes.
. 'x': The image extension (i.e last characters after the last '.' in
the image name).
. '^ : The sequence of all image values, separated by commas ','.
. '@subset': The sequence of image values corresponding to the
specified subset, and
separated by commas ','.
. Any other 'feature' is considered as a mathematical expression
associated to the image
[image] and is substituted by the result of its evaluation (float
value). For instance,
expression '{0,w+h}' is substituted by the sum of the width and height
of the first image
(see section 'Mathematical expressions' for more details). If a
mathematical expression
starts with an underscore '_', the resulting value is truncated to a readable
format.
For instance, item '{_pi}' is substituted by '3.14159' (while
'{pi}' is substituted by
'3.141592653589793').
. A 'feature' delimited by backquotes is replaced by a string whose
ascii codes correspond
to the list of values resulting from the evaluation of the specified
mathematical
expression. For instance, item '{`[102,111,111]`}' is substituted by
'foo' and item
'{`vector8(65)`}' by 'AAAAAAAA'.
- '{*}' is substituted by the visibility state of the instant display
window [0] (can be
{ 0=closed | 1=visible }).
- '{*,feature}' or '{*indice,feature}' is substituted by a
specific feature of the instant
display window #0 (or #indice, if specified). Requested
'feature' can be:
. 'w': display width (i.e. width of the display area managed by the
window).
. 'h': display height (i.e. height of the display area managed by the
window).
. 'wh': display width x display height.
. 'd': window width (i.e. width of the window widget).
. 'e': window height (i.e. height of the window widget).
. 'de': window width x window height.
. 'u': screen width (actually independent on the window size).
.' v': screen height (actually independent on the window size).
. 'uv': screen width x screen height.
. 'n': current normalization type of the instant display.
. 't': window title of the instant display.
. 'x': X-coordinate of the mouse position (or -1, if outside the
display area).
. 'y': Y-coordinate of the mouse position (or -1, if outside the
display area).
. 'b': state of the mouse buttons { 1=left-but. | 2=right-but. |
4=middle-but. }.
. 'o': state of the mouse wheel.
. 'k': decimal code of the pressed key if any, 0 otherwise.
. 'c': boolean (0 or 1) telling if the instant display has been closed
recently.
. 'r': boolean telling if the instant display has been resized
recently.
. 'm': boolean telling if the instant display has been moved recently.
. Any other 'feature' stands for a keycode name (in capital letters),
and is substituted by
a boolean describing the current key state { 0=pressed | 1=released }.
. You can also prepend a hyphen '-' to a 'feature' (that supports it)
to flush the
corresponding event immediately after reading its state (works for keys,
mouse and
window events).
- Item substitution is never performed in items between double quotes. One
must break the quotes
to enable substitution if needed, as in "3+8 kg = "{3+8}"
kg". Using double quotes is then
a convenient way to disable the substitutions mechanism in items, when
necessary.
- One can also disable the substitution mechanism on items outside double
quotes, by escaping the
'{','}' or '$' characters, as in '\{3+4\}\ doesn't\ evaluate'.
9. Mathematical expressions
------------------------
- G'MIC has an embedded mathematical parser. It is used to evaluate
expressions inside braces
'{}', or formulas in commands that may take one as an argument (e.g.
'-fill').
- When the context allows it, a formula is evaluated for each pixel of the
selected images
(e.g. '-fill').
- A math expression may return a scalar or vector-valued result (with a fixed
number of
components).
- The mathematical parser understands the following set of functions,
operators and variables:
_ Usual operators: || (logical or), && (logical and),
| (bitwise or), & (bitwise and),
!=, ==, <=, >=, <, >, << (left bitwise shift),
>> (right bitwise shift), -, +, *, /,
% (modulo), ^ (power), ! (logical not), ~
(bitwise not),
++, --, +=, -=, *=, /=, %=,
&=, |=, ^=, >>=, <<=
(in-place operators).
_ Usual math functions: abs(), acos(), arg(), argmax(), argmin(), asin(),
atan(), atan2(),
cbrt(), cos(), cosh(), cut(), exp(), fact(), fibo(), gauss(), int(),
isval(), isnan(),
isinf(), isint(), isbool(), isfile(), isdir(), isin(), kth(), log(),
log2(), log10(),
max(), mean(), med(), min(), narg(), prod(), rol() (left bit
rotation),
ror() (right bit rotation), round(), sign(), sin(), sinc(), sinh(),
sqrt(), std(),
sum(), tan(), tanh(), variance(), xor().
. 'atan2(x,y)' is the version of 'atan()' with two arguments
'y' and 'x' (as in C/C++).
. 'permut(k,n,with_order)' computes the number of permutations of k
objects from a set of
n objects.
. 'gauss(x,_sigma)' returns 'exp(-x^2/(2*s^2))/sqrt(2*pi*sigma^2)'.
. 'cut(value,min,max)' returns value if it is in range [min,max], or
min or max otherwise.
. 'narg(a_1,...,a_N)' returns the number of specified arguments (here,
N).
. 'arg(i,a_1,..,a_N)' returns the ith argument a_i.
. 'isval()', 'isnan()', 'isinf()', 'isint()',
'isbool()' test the type of the given
number or expression, and return 0 (false) or 1 (true).
. 'isfile()' (resp. 'isdir()') returns 0 (false) or 1 (true)
whether its argument is a
path to an existing file (resp. to a directory) or not.
. 'isin(v,a_1,...,a_n)' returns 0 (false) or 1 (true) whether the
first value 'v' appears
in the set of other values 'a_i'.
. 'argmin()', 'argmax()', 'kth()', 'max()',
'mean()', 'med()', 'min()', 'std()',
'sum()'
and 'variance()' can be called with an arbitrary number of
scalar/vector arguments.
. 'round(value,rounding_value,direction)' returns a rounded value.
'direction' can be
{ -1=to-lowest | 0=to-nearest | 1=to-highest }.
_ Variable names below are pre-defined. They can be overrided.
. 'l': length of the associated list of images, if any (0 otherwise).
. 'w': width of the associated image, if any (0 otherwise).
. 'h': height of the associated image, if any (0 otherwise).
. 'd': depth of the associated image, if any (0 otherwise).
. 's': spectrum of the associated image, if any (0 otherwise).
. 'r': shared state of the associated image, if any (0 otherwise).
. 'wh': shortcut for width x height.
. 'whd': shortcut for width x height x depth.
. 'whds': shortcut for width x height x depth x spectrum (i.e. number
of scalar values).
. 'i': current processed pixel value (i.e. value located at (x,y,z,c))
in the associated
image, if any (0 otherwise).
. 'iN': Nth channel value of current processed pixel (i.e. value
located at (x,y,z,N)) in
the associated image, if any (0 otherwise). 'N' must be an integer in range
[0,9].
. 'R','G','B' and 'A' are equivalent to
'i0', 'i1', 'i2' and 'i3' respectively.
.
'im','iM','ia','iv','is','ip','ic':
Respectively the minimum, maximum, average values,
variance, sum, product and median value of the associated image, if any (0
otherwise).
. 'xm','ym','zm','cm': The pixel coordinates of
the minimum value in the associated
image, if any (0 otherwise).
. 'xM','yM','zM','cM': The pixel coordinates of
the maximum value in the associated
image, if any (0 otherwise).
. 'I': current vector-valued processed pixel in the associated image,
if any (0 otherwise).
The number of vector components is equal to the number of image channels
(e.g. I = [ R,G,B ] for a RGB image).
. You may add '#ind' to any of the variable name above to retrieve the
information for any
numbered image [ind] of the list (when this makes sense). For instance
'ia#0' denotes the
average value of the first image of the list).
. 'x': current processed column of the associated image, if any (0
otherwise).
. 'y': current processed row of the associated image, if any (0
otherwise).
. 'z': current processed slice of the associated image, if any (0
otherwise).
. 'c': current processed channel of the associated image, if any (0
otherwise).
. 't': thread id when an expression is evaluated with multiple threads
(0 means
'master thread').
. 'e': value of e, i.e. 2.71828...
. 'pi': value of pi, i.e. 3.1415926...
. 'u': a random value between [0,1], following a uniform distribution.
. 'g': a random value, following a gaussian distribution of variance 1
(roughly in [-6,6]).
. 'interpolation': value of the default interpolation mode used when
reading pixel values
with the pixel access operators (i.e. when the interpolation argument is not
explicitly
specified, see below for more details on pixel access operators). Its initial
default
value is 0.
. 'boundary': value of the default boundary conditions used when
reading pixel values with
the pixel access operators (i.e. when the boundary condition argument is not
explicitly
specified, see below for more details on pixel access operators). Its initial
default
value is 0.
_ Vector calculus: Most operators are also able to work with vector-valued
elements.
. '[ a0,a1,...,aN ]' defines a (N+1)-dimensional vector with scalar
coefficients ak.
. 'vectorN(a0,a1,,...,)' does the same, with the ak being repeated
periodically if only a
few are specified.
. In both previous expressions, the ak can be vectors themselves, to be
concatenated into a
single vector.
. The scalar element ak of a vector X is retrieved by 'X[k]'.
. The sub-vector [ X[p]...X[p+q-1] ] (of size q) of a vector X is retrieved
by 'X[p,q]'.
. Equality/inequality comparisons between two vectors is done with operators
'==' and '!='.
. Some vector-specific functions can be used on vector values:
'cross(X,Y)' (cross product), 'dot(X,Y)' (dot product),
'size(X)' (vector dimension),
'sort(X,_is_increasing,_chunk_size)' (sorting values),
'reverse(A)' (reverse order of
components) and 'same(A,B,_nb_vals,_is_case_sensitive)' (vector
equality test).
. Function 'resize(A,size,_interpolation,_boundary_conditions)'
returns a resized version of
a vector 'A' with specified interpolation mode. 'interpolation' can be {
-1=none
(memory content) | 0=none | 1=nearest | 2=average | 3=linear | 4=grid |
5=bicubic |
6=lanczos }, and 'boundary_conditions' can be { 0=dirichlet | 1=neumann |
2=periodic }.
. Function 'find(A,B,_is_forward,_starting_indice)' returns the index
where sub-vector B
appears in vector A, (or -1 if B is not found in A). Argument A can be also
replaced by
an image indice #ind.
. A 2-dimensional vector may be seen as a complex number and used in those
particular
functions/operators:
'**' (complex multiplication), '//' (complex division),
'^^' (complex exponentiation),
'**=' (complex self-multiplication), '//=' (complex
self-division), '^^=' (complex
self-exponentiation), 'cabs()' (complex modulus), 'carg()'
(complex argument), 'cconj()'
(complex conjugate), 'cexp()' (complex exponential) and
'clog()' (complex logarithm).
. A MN-dimensional vector may be seen as a M x N matrix and used in those
particular
functions/operators:
'**' (matrix-vector multiplication), 'det(A)' (determinant),
'diag(V)' (diagonal matrix
from a vector), 'eig(A)' (eigenvalues/eigenvectors), 'eye(n)'
(n x n identity matrix),
'inv(A)' (matrix inverse), 'mul(A,B,_nb_colsB)' (matrix-matrix
multiplication),
'pseudoinv(A,_nb_colsA)', 'rot(x,y,z,angle)' (3d rotation
matrix), 'rot(angle)' (2d
rotation matrix), 'solve(A,B,_nb_colsB)' (least-square solver of
linear system A.X = B),
'svd(A,_nb_colsA)' (singular value decomposition), 'trace(A)'
(matrix trace) and
'transp(A,nb_colsA)' (matrix transpose). Argument 'nb_colsB'
may be omitted if it is
equal to 1.
. Specifying a vector-valued math expression as an argument of a command that
operates on
image values (e.g. '-fill') modifies the whole spectrum range of the
processed image(s),
for each spatial coordinates (x,y,z). The command does not loop over the
C-axis in this
case.
_ String manipulation: Character strings are defined and managed as vectors
objects.
Dedicated functions and initializers to manage strings are
. [ 'string' ] and 'string' define a vector whose values are
the ascii codes of the
specified character string (e.g. 'foo' is equal to [ 102,111,111 ]).
. _'character' returns the (scalar) ascii code of the specified
character (e.g. _'A' is
equal to 65).
. A special case happens for empty strings: Values of both expressions [
'' ] and '' are 0.
. Functions 'lowercase()' and 'uppercase()' return string with
all string characters
lowercased or uppercased.
. Function 'stod(str,is_strict)' parses specified string 'str'
and returns the value
contained in it.
_ Special operators can be used:
. ';': expression separator. The returned value is always the last
encountered expression.
For instance expression '1;2;pi' is evaluated as 'pi'.
. '=': variable assignment. Variables in mathematical parser can only
refer to numerical
values (vectors or scalars). Variable names are case-sensitive. Use this
operator in
conjunction with ';' to define more complex evaluable expressions,
such as
't=cos(x);3*t^2+2*t+1'.
These variables remain local to the mathematical parser and cannot be
accessed outside
the evaluated expression.
. Variables defined in math parser may have a constant property, by
specifying keyword const
before the variable name (e.g. const foo = pi/4;). The value set to
such a variable must
be indeed a constant scalar. Constant variables allows certain types
of optimizations in
the math JIT compiler.
_ The following specific functions are also defined:
. 'normP(u1,...,un)' computes the LP-norm of the specified vector
(P being an unsigned integer constant or 'inf'). If P is
omitted, the L2 norm is used.
. 'u(max)' or 'u(min,max)': return a random value between
[0,max] or [min,max], following
a uniform distribution.
. 'i(_a,_b,_c,_d,_interpolation_type,_boundary_conditions)': return
the value of the pixel
located at position (a,b,c,d) in the associated image, if any (0 otherwise).
'interpolation_type' can be { 0=nearest neighbor | other=linear }.
'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic }.
Omitted coordinates are replaced by their default values which are
respectively
x, y, z, c, interpolation and boundary.
For instance command '-fill 0.5*(i(x+1)-i(x-1))' will estimate the
X-derivative of an
image with a classical finite difference scheme.
. 'j(_dx,_dy,_dz,_dc,_interpolation_type,_boundary_conditions)' does
the same for the pixel
located at position (x+dx,y+dy,z+dz,c+dc) (pixel access relative to the
current
coordinates).
. 'i[offset,_boundary_conditions]' returns the value of the pixel
located at specified
'offset' in the associated image buffer (or 0 if offset is out-of-bounds).
. 'j[offset,_boundary_conditions]' does the same for an offset
relative to the current pixel
coordinates (x,y,z,c).
. 'i(#ind,_x,_y,_z,_c,_interpolation,_boundary)',
'j(#ind,_dx,_dy,_dz,_dc,_interpolation,_boundary)',
'i[#ind,offset,_boundary]' and 'i[offset,_boundary]' are
similar expressions used to
access pixel values for any numbered image [ind] of the list.
. 'I/J[offset,_boundary_conditions]' and
'I/J(#ind,_x,_y,_z,_interpolation,_boundary)' do
the same as 'i/j[offset,_boundary_conditions]' and
'i/j(#ind,_x,_y,_z,_c,_interpolation,_boundary)' but return a vector
instead of a scalar
(e.g. a vector [ R,G,B ] for a pixel at (a,b,c) in a color image).
. 'crop(_#ind,_x,_y,_z,_c,_dx,_dy,_dz,_dc,_boundary)' returns a vector
whose values come
from the cropped region of image [ind] (or from default image selected if
'ind' is not
specified). Cropped region starts from point (x,y,z,c) and has a size of
dx x dy x dz x dc. Arguments for coordinates and sizes can be omitted if they
are not
ambiguous (e.g. 'crop(#ind,x,y,dx,dy)' is a valid invokation of this
function).
. 'draw(_#ind,S,x,y,z,c,dx,_dy,_dz,_dc,_opacity,_M,_max_M)' draws a
sprite S in image [ind]
(or in default image selected if 'ind' is not specified) at
coordinates (x,y,z,c).
The size of the sprite dx x dy x dz x dc must be specified. You can also
specify a
corresponding opacity mask M if its size matches S.
. 'if(condition,expr_then,_expr_else)': return value of
'expr_then' or 'expr_else',
depending on the value of 'condition' (0=false, other=true).
'expr_else' can be omitted
in which case 0 is returned if the condition does not hold. Using the ternary
operator
'condition?expr_then[:expr_else]' gives an equivalent expression.
For instance, G'MIC commands '-fill if(x%10==0,255,i)' and '-fill
x%10?i:255' both draw
blank vertical lines on every 10th column of an image.
. 'dowhile(expression,_condition)' repeats the evaluation of
'expression' until 'condition'
vanishes (or until 'expression' vanishes if no 'condition' is
specified). For instance,
the expression:
'if(N<2,N,n=N-1;F0=0;F1=1;dowhile(F2=F0+F1;F0=F1;F1=F2,n=n-1))'
returns
the Nth value of the Fibonacci sequence, for N>=0 (e.g., 46368 for N=24).
'dowhile(expression,condition)' always evaluates the specified
expression at least once,
then check for the loop condition. When done, it returns the last value of
'expression'.
. 'for(init,condition,_procedure,body)' first evaluates the expression
'init', then
iteratively evaluates 'body' (followed by 'procedure' if
specified) while 'condition'
is verified (i.e. not zero). It may happen that no iteration is done, in
which case the
function returns nan. Otherwise, it returns the last value of 'body'.
For instance, the expression:
'if(N<2,N,for(n=N;F0=0;F1=1,n=n-1,F2=F0+F1;F0=F1;F1=F2))'
returns the Nth value of the Fibonacci sequence, for N>=0 (e.g., 46368 for
N=24).
. 'whiledo(condition,expression)' is exactly the same as
'for(init,condition,expression)'
without the specification of an initializing expression.
. 'break()' and 'continue()' respectively breaks and continues
the current running bloc
(loop, init or main environment).
. 'date(attr,path)' returns the date attribute for the given 'path'
(file or directory),
with 'attr' being { 0=year | 1=month | 2=day | 3=day of week | 4=hour |
5=minute |
6=second }.
. 'date(_attr) returns the specified attribute for the current
(locale) date.
. 'print(expr1,expr2,...) prints the value of the specified
expressions on the console
(and returns the value of the last expression).
. 'debug(expression) prints detailed debug information about the
sequence of operations done
by the math parser to evaluate the expression (and returns its value).
. 'display(_X) prints and displays the contents of the specified
vector 'X', and wait for
user events. if no arguments are provided, a memory snapshot of the math
parser
environment is displayed instead.
. 'init(expression) evaluates the specified expression only once, even
when multiple
evaluations are required (e.g. in '-fill init(foo=0);++foo').
. 'copy(dest,src,_nb_elts,_inc_d,_inc_s,_opacity) copies an entire
memory block of 'nb_elts'
elements starting from a source value 'src' to a specified destination
'dest', with
increments defined by 'inc_d' and 'inc_s' respectively for the
destination and source
pointers.
. 'unref(a,b,...) destroys references to the named variable given as
arguments.
. 'breakpoint() inserts a computation breakpoint (not supported by the
cli interface).
- User-defined macros:
. Custom macro functions can be defined in a math expression, using the
assignment operator
'=', e.g. 'foo(x,y) = cos(x + y); result = foo(1,2) +
foo(2,3)'.
. Trying to override a built-in function (e.g. 'abs()') has no effect.
. Overloading macros with different number of arguments is possible.
Re-defining a
previously defined macro with the same number of arguments discards its
previous
definition.
. Macro functions are indeed processed as macros by the mathematical
evaluator. You should
avoid invoking them with arguments that are themselves results of assignments
or
self-operations. For instance, 'foo(x) = x + x; z = 0; foo(++z)'
returns '4' rather
than expected value '2'.
. When substituted, macro arguments are placed inside parentheses, except if
a number sign
'#' is located just before or after the argument name. For instance,
expression
'foo(x,y) = x*y; foo(1+2,3)' returns '9' (being substituted as
'(1+2)*(3)'), while
expression 'foo(x,y) = x#*y#; foo(1+2,3)' returns '7' (being
substituted as '1+2*3').
. Number signs appearing between macro arguments function actually count for
'empty'
separators. They may be used to force the substitution of macro arguments in
unusual
places, e.g. as in 'str(N) = ['I like N#'];'.
- Multi-threaded and in-place evaluation:
. If your image data are large enough and you have several CPUs available, it
is likely that
the math expression passed to a '-fill' or '-input' command is
evaluated in parallel,
using multiple computation threads.
. Starting an expression with ':' or '*' forces the evaluations
required for an image to be
run in parallel, even if the amount of data to process is small (beware, it
may be slower
to evaluate in this case!). Specify ':' (instead of '*') to
avoid possible image copy
done before evaluating the expression (this saves memory, but do this only if
you are
sure this step is not required!)
. If the specified expression starts with '>' or '<', the
pixel access operators
'i(), i[], j()' and 'j[]' return values of the image being
currently modified,
in forward ('>') or backward ('<') order. The
multi-threading evaluation of the
expression is also disabled in this case.
. Function '(operands)' forces the execution of the given operands in a
single thread at a
time.
_ Expressions 'i(_#ind,x,_y,_z,_c)=value',
'j(_#ind,x,_y,_z,_c)=value', 'i[_#ind,offset]=value'
and 'j[_#ind,offset]=value' set a pixel value at a different location
than the running one
in the image [ind] (or in the associated image if argument '#ind' is
omitted), either with
global coordinates/offsets (with 'i(...)' and 'i[...]'), or
relatively to the current
position (x,y,z,c) (with 'j(...)' and 'j[...]'). These
expressions always return 'value'.
- The last image of the list is always associated to the evaluations of
'{expressions}',
e.g. G'MIC sequence '256,128 -f {w}' will create a 256x128 image
filled with value 256.
10. Image and data viewers
----------------------
- G'MIC has some very handy embedded visualization modules, for 1d signals
(command '-plot'),
1d/2d/3d images (command '-display') and 3d objects (command
'-display3d'). It manages
interactive views of the selected image data.
- The following keyboard shortcuts are available in the interactive
viewers:
. (mousewheel): Zoom in/out.
. CTRL+D: Increase window size.
. CTRL+C: Decrease window size.
. CTRL+R: Reset window size.
. CTRL+W: Close window.
. CTRL+F: Toggle fullscreen mode.
. CTRL+S: Save current window snapshot as numbered file 'gmic_xxxx.bmp'.
. CTRL+O: Save current instance of the viewed data, as numbered file
'gmic_xxxx.cimgz'.
- Shortcuts specific to the 1d/2d/3d image viewer (command '-display')
are:
. CTRL+A: Switch cursor mode.
. CTRL+P: Play z-stack of frames as a movie (for volumetric 3d images).
. CTRL+V: Show/hide 3D view (for volumetric 3d images).
. CTRL+(mousewheel): Go up/down.
. SHIFT+(mousewheel): Go left/right.
. Numeric PAD: Zoom in/out (+/-) and move through zoomed image (digits).
. BACKSPACE: Reset zoom scale.
- Shortcuts specific to the 3d object viewer (command '-display3d')
are:
. (mouse)+(left mouse button): Rotate 3d object.
. (mouse)+(right mouse button): Zoom 3d object.
. (mouse)+(middle mouse button): Shift 3d object.
. CTRL+F1 ... CTRL+F6: Toggle between different 3d rendering modes.
. CTRL+Z: Enable/disable z-buffered rendering.
. CTRL+A: Show/hide 3d axes.
. CTRL+G: Save 3d object, as numbered file 'gmic_xxxx.off'.
. CTRL+T: Switch between single/double-sided 3d modes.
11. Adding custom commands
----------------------
- New custom commands can be added by the user, through the use of G'MIC
custom commands files.
- A command file is a simple ascii text file, where each line starts either
by
'command_name: command_definition' or 'command_definition
(continuation)'.
- At startup, G'MIC automatically includes user's command file $HOME/.gmic
(on Unix) or
%APPDATA%/user.gmic (on Windows). The CLI tool 'gmic' automatically runs the
command
'-cli_start' if defined.
- Custom command names must use character set [a-zA-Z0-9_] and cannot start
with a number.
- Any ' # comment' expression found in a custom commands file is
discarded by the G'MIC parser,
wherever it is located in a line.
- In a custom command, the following $-expressions are recognized and
substituted:
. '$*' is substituted by a copy of the specified string of arguments.
. '$"*"' is substituted by a copy of the specified string of
arguments, each being
double-quoted.
. '$#' is substituted by the maximum indice of known arguments (either
specified by the user
or set to a default value in the custom command).
. '$?' is substituted by a string telling about the command subset
restriction (only useful
when custom commands need to output descriptive messages).
. '$i' and '${i}' are both substituted by the i^th specified
argument. Negative indices such as
'${-j}' are allowed and refer to the j^th latest argument. '$0'
is substituted by the
custom command name.
. '${i=default}' is substituted by the value of $i (if defined)
or by its new value set to
'default' otherwise ('default' may be a $-expression as well).
. '${subset}' is substituted by the argument values (separated by
commas ',') of a specified
argument subset. For instance expression '${2--2}' is substitued by
all specified command
arguments except the first and the last one. Expression '${^0}' is
then substituted by all
arguments of the invoked command (eq. to '$*' if all specified
arguments have indeed a
value).
. '$=var' is substituted by the set of instructions that will assign
each argument $i to the
named variable 'var$i' (for i in [0...$#]). This is particularly
useful when a custom
command want to manage variable numbers of arguments. Variables names must
use character set
[a-zA-Z0-9_] and cannot start with a number.
- These particular $-expressions for custom commands are always substituted,
even in
double-quoted items or when the dollar sign '$' is escaped with a backslash
'\'. To avoid
substitution, place an empty double quoted string just after the '$' (as in
'$""1').
- Specifying arguments may be skipped when invoking a custom command, by
replacing them by commas
',' as in expression '-flower ,,3'. Omitted arguments are set to their
default values, which
must be thus explicitly defined in the code of the corresponding custom
command (using
default argument expressions as '${1=default}').
- If one numbered argument required by a custom command misses a value, an
error is thrown by the
G'MIC interpreter.
12. List of commands
----------------
All available G'MIC commands are listed below, classified by themes. When
several choices of
command arguments are possible, they appear separated by '|'. An argument
specified inside '[]'
or starting by '_' is optional except when standing for an existing image
[image], where 'image'
can be either an indice number or an image name. In this case, the '[]'
characters are mandatory
when writing the item. A command marked with '(+)' is one of the native
commands. Note also that
all images that serve as illustrations in this reference documentation are
normalized in [0,255]
before being displayed. You may need to do this explicitly (command
'-normalize 0,255') if you
want to save and view images with the same aspect than those illustrated in
the example codes.
** Global options:
-debug (+):
Activate debug mode.
When activated, the G'MIC interpreter becomes very verbose and outputs
additionnal log
messages about its internal state on the standard output (stdout).
This option is useful for developers or to report possible bugs of the
interpreter.
-help:
command |
(no arg)
Display help (optionally for specified command only) and exit.
(eq. to '-h').
-version:
Display current version number on stdout.
** Input/output:
-camera (+):
_camera_index>=0,_nb_frames>0,_skip_frames>=0,_capture_width>=0,
_capture_height>=0
Insert one or several frames from specified camera.
When 'nb_frames==0', the camera stream is released instead of capturing new
images.
Default values: 'camera_index=0' (default camera), 'nb_frames=1',
'skip_frames=0' and
'capture_width=capture_height=0' (default size).
-clut:
"clut_name",_resolution>0
Insert one of the pre-defined CLUT at the end of the image list.
-command (+):
_add_debug_info={ 0 | 1 },{ filename | http[s]://URL | "string"
}
Import G'MIC custom commands from specified file, URL or string.
(eq. to '-m').
Imported commands are available directly after the '-command' invocation.
Default value: 'add_debug_info=1'.
-cursor (+):
_mode = { 0=hide | 1=show }
Show or hide mouse cursor for selected instant display windows.
Command selection (if any) stands for instant display window indices instead
of image indices.
Default value: 'mode=1'.
-display (+):
_X>=0,_Y>=0,_Z>=0,_exit_on_anykey={ 0 | 1 }
Display selected images in an interactive viewer (use the instant display
window [0] if opened).
(eq. to '-d').
Arguments 'X','Y','Z' determine the initial selection view, for 3d volumetric
images.
Default value: 'X=Y=Z=0' and 'exit_on_anykey=0'.
-display0:
Display selected images without value normalization.
(eq. to '-d0').
-display3d (+):
_[background_image],_exit_on_anykey={ 0 | 1 } |
_exit_on_anykey={ 0 | 1 }
Display selected 3d objects in an interactive viewer (use the instant display
window [0] if
opened).
(eq. to '-d3d').
Default values: '[background_image]=(default)' and 'exit_on_anykey=0'.
-display_array:
_width>0,_height>0
Display images in interactive windows where pixel neighborhoods can be
explored.
Default values: 'width=13' and 'height=width'.
-display_fft:
Display fourier transform of selected images, with centered log-module and
argument.
(eq. to '-dfft').
-display_graph:
_width>32,_height>32,_plot_type,_vertex_type,_xmin,_xmax,_ymin,_ymax,_xlabel,
_ylabel
Render graph plot from selected image data.
'plot_type' can be { 0=none | 1=lines | 2=splines | 3=bar }.
'vertex_type' can be { 0=none | 1=points | 2,3=crosses | 4,5=circles |
6,7=squares }.
'xmin','xmax','ymin','ymax' set the coordinates of the displayed xy-axes.
Default values: 'width=640', 'height=480', 'plot_type=1', 'vertex_type=1',
'xmin=xmax=ymin=ymax=0 (auto)', 'xlabel="x-axis"' and
'ylabel="y-axis"'.
-display_histogram:
_width>0,_height>0,_clusters>0,_min_value[%],_max_value[%],_show_axes={
0 | 1 },
_expression.
Render a channel-by-channel histogram.
If selected image has several slices, the rendering is performed for all
input slices.
'expression' is a mathematical expression used to transform the histogram
data for
visualization purpose.
(eq. to '-dh').
Default values: 'width=512', 'height=300', 'clusters=256', 'min_value=0%',
'max_value=100%',
'show_axes=1' and 'expression=i'.
-display_parametric:
_width>0,_height>0,_outline_opacity,_vertex_radius>=0,_is_antialiased={
0 | 1 },
_is_decorated={ 0 | 1 },_xlabel,_ylabel
Render 2d or 3d parametric curve or point clouds from selected image data.
Curve points are defined as pixels of a 2 or 3-channel image.
If the point image contains more than 3 channels, additional channels define
the (R,G,B) color
for each vertex.
If 'outline_opacity>1', the outline is colored according to the specified
vertex colors and
'outline_opacity-1' is used
as the actual drawing opacity.
Default values: 'width=512', 'height=width', 'outline_opacity=3',
'vertex_radius=0',
'is_antialiased=1', 'is_decorated=1', 'xlabel="x-axis"' and
'ylabel="y-axis"'.
-display_polar:
_width>32,_height>32,_outline_type,_fill_R,_fill_G,_fill_B,_theta_start,
_theta_end,_xlabel,_ylabel
Render polar curve from selected image data.
(eq. to '-dp').
'outline_type' can be { r<0=dots with radius -r | 0=no outline |
r>0=lines+dots with radius r }.
'fill_color' can be { -1=no fill | R,G,B=fill with specified color }.
Default values: 'width=500', 'height=width', 'outline_type=1',
'fill_R=fill_G=fill_B=200',
'theta_start=0', 'theta_end=360', 'xlabel="x-axis"' and
'ylabel="y-axis"'.
-display_quiver:
_size_factor>0,_arrow_size>=0,_color_mode={ 0=monochrome | 1=grayscale
|
2=color }
Render selected image of 2d vectors as a field of 2d arrows.
(eq. to '-dq').
Default values: 'size_factor=16', 'arrow_size=1.5' and 'color_mode=1'.
-display_rgba:
Render selected RGBA images over a checkerboard background.
(eq. to '-drgba').
-display_tensors:
_size_factor>0,_ellipse_size>=0,_color_mode={ 0=monochrome |
1=grayscale |
2=color },_outline>=0
Render selected image of tensors as a field of 2d ellipses.
(eq. to '-dt').
Default values: 'size_factor=16', 'ellipse_size=1.5', 'color_mode=2' and
'outline=2'.
-display_warp:
_cell_size>0
Render selected 2d warping fields.
(eq. to '-dw').
Default value: 'cell_size=15'.
-document_gmic:
_format={ ascii | bash | html | images | latex },_image_path,_write_wrapper={
0
| 1 }
Create documentation of .gmic command files (loaded as raw 'uchar' images),
in specified format.
Default values: 'format=ascii', 'image_path=""' and
'write_wrapper=1'.
Example(s) : raw:filename.gmic,char -document_gmic html,img
-echo (+):
message
Output specified message on the error output.
(eq. to '-e').
Command selection (if any) stands for displayed call stack subset instead of
image indices.
-echo_file:
filename,message
Output specified message, appending it to specified output file.
(similar to '-echo' for specified output file stream).
-echo_stdout:
message
Output specified message, on the standard output (stdout).
(similar to '-echo' for output on standard output instead of standard
error).
-function1d:
0<=smoothness<=1,x0>=0,y0,x1>=0,y1,...,xn>=0,yn
Insert continuous 1d function from specified list of keypoints (xk,yk)
in range [0,max(xk)] (xk are positive integers).
Default values: 'smoothness=1' and 'x0=y0=0'.
-gmicky:
Insert new image of the G'MIC mascot 'Gmicky'.
-gmicky_deevad:
Insert new image of the G'MIC mascot 'Gmicky', by David Revoy.
-gmicky_mahvin:
Insert new image of the G'MIC mascot 'Gmicky', by Mahvin.
-gmicky_wilber:
Insert new image of the G'MIC mascot 'Gmicky' together with GIMP mascot
'Wilber', by Mahvin.
-input (+):
[type:]filename |
[type:]http://URL |
[selection]x_nb_copies>0 |
{ width>0[%] | [image_w] },{ _height>0[%] | [image_h] },{
_depth>0[%] |
[image_d] },{ _spectrum>0[%] | [image_s] },_{ value1,_value2,... |
'formula' } |
(value1{,|;|/|^}value2{,|;|/|^}...) |
0
Insert a new image taken from a filename or from a copy of an existing image
['indice'],"
or insert new image with specified dimensions and values. Single quotes may
be omitted in
'formula'. Specifying argument '0' inserts an 'empty' image.
(eq. to '-i' | (no arg)).
Default values: 'nb_copies=1', 'height=depth=spectrum=1' and 'value1=0'.
-input_cube:
"filename",_convert_1d_cluts_to_3d={ 0 | 1 }.
Insert CLUT data from a .cube filename (Adobe CLUT format).
Default value: 'convert_1d_cluts_to_3d=0'.
-input_glob:
pattern
Insert new images from several filenames that match the specified glob
pattern.
-input_gpl:
filename
Input specified filename as a GIMP palette data file.
-output (+):
[type:]filename,_format_options
Output selected images as one or several numbered file(s).
(eq. to '-o').
Default value: 'format_options'=(undefined).
-output_cube:
filename
Output selected CLUTs as a .cube file (Adobe CLUT format).
-output_ggr:
filename,_gradient_name
Output selected images as GIMP gradient files.
If no gradient name is specified, it is deduced from the filename.
-outputn:
filename
Output selected images as automatically numbered filenames in repeat...done
loops.
(eq. to '-on').
-outputp:
prefix
Output selected images as prefixed versions of their original filenames.
(eq. to '-op').
Default value: 'prefix=_'.
-outputw:
Output selected images by overwritting their original location.
(eq. to '-ow').
-outputx:
extension1,_extension2,_...,_extensionN,_output_at_same_location={ 0 | 1
}
Output selected images with same base filenames but for N different
extensions.
(eq. to '-ox').
Default value: 'output_at_same_location=0'.
-pass (+):
_shared_state={ 0=non-shared (copy) | 1=shared | 2=adaptive }
Insert images from parent context of a custom command or a local environment.
Command selection (if any) stands for a selection of images in the parent
context.
By default (adaptive shared state), selected images are inserted in a shared
state if they do
not belong to the context (selection) of the current custom command or local
environment as
well.
Typical use of command '-pass' concerns the design of custom commands that
take images as
arguments.
Default value: 'shared_state=2'.
-plot (+):
_plot_type,_vertex_type,_xmin,_xmax,_ymin,_ymax,_exit_on_anykey={ 0 | 1 } |
'formula',_resolution>=0,_plot_type,_vertex_type,_xmin,xmax,_ymin,_ymax,
_exit_on_anykey={ 0 | 1 }
Display selected image or formula in an interactive viewer (use the instant
display window [0]
if opened).
'plot_type' can be { 0=none | 1=lines | 2=splines | 3=bar }.
'vertex_type' can be { 0=none | 1=points | 2,3=crosses | 4,5=circles |
6,7=squares }.
'xmin','xmax','ymin','ymax' set the coordinates of the displayed xy-axes.
Default values: 'plot_type=1', 'vertex_type=1', 'xmin=xmax=ymin=ymax=0
(auto)' and
'exit_on_anykey=0'.
-print (+):
Output information on selected images, on the standard error (stderr).
(eq. to '-p').
-rainbow_lut:
Input a 256-entries RGB colormap of rainbow colors.
-roddy:
Input a new image of the G'MIC Rodilius mascot 'Roddy'.
-screen (+):
_x0[%],_y0[%],_x1[%],_y1[%]
Take screenshot, optionally grabbed with specified coordinates, and insert it
at the end of the image list.
-select (+):
feature_type,_X,_Y,_Z,_exit_on_anykey={ 0 | 1 }
Interactively select a feature from selected images (use the instant display
window [0] if
opened).
'feature_type' can be { 0=point | 1=segment | 2=rectangle | 3=ellipse }.
Arguments 'X','Y','Z' determine the initial selection view, for 3d volumetric
images.
The retrieved feature is returned as a 3d vector (if 'feature_type==0') or as
a 6d vector
(if 'feature_type!=0') containing the feature coordinates.
The coordinates of the last selected features are also returned as the status
value.
Default values: 'X=Y=Z=(undefined)' and 'exit_on_anykey=0'.
-serialize (+):
_datatype,_is_compressed={ 0 | 1 },_store_names={ 0 | 1 }
Serialize selected list of images into a single image, optionnally in a
compressed form.
'datatype' can be { uchar | char | ushort | short | uint | int | uint64 |
int64 | float |
double }.
Specify 'datatype' if all selected images have a range of values constrained
to a particular
datatype, in order to minimize the memory footprint.
The resulting image has only integers values in [0,255] and can then be saved
as a raw image of
unsigned chars (doing so will output a valid .cimg[z] or .gmz file).
If 'store_names' is set to '1', serialization uses the .gmz format to store
data in memory
(otherwise the .cimg[z] format).
Default values: 'datatype=float', 'is_compressed=1' and 'store_names=1'.
-shape_heart:
_size>=0
Input a 2d heart binary shape with specified size.
Default value: 'size=512'.
-shape_circle:
_size>=0
Input a 2d circle binary shape with specified size.
Default value: 'size=512'.
-shape_cupid:
_size>=0
Input a 2d cupid binary shape with specified size.
Default value: 'size=512'.
-shape_diamond:
_size>=0
Input a 2d diamond binary shape with specified size.
Default value: 'size=512'.
-shape_fern:
_size>=0,_density[%]>=0,_angle,0<=_opacity<=1,_type={ 0=Asplenium
adiantum-nigrum | 1=Thelypteridaceae }
Input a 2d Barnsley fern with specified size.
Default value: 'size=512', 'density=50%', 'angle=30', 'opacity=0.3' and
'type=0'.
-shape_polygon:
_size>=0,_nb_vertices>=3,_angle
Input a 2d polygonal binary shape with specified geometry.
Default value: 'size=512', 'nb_vertices=5' and 'angle=0'.
-shape_snowflake:
size>=0,0<=_nb_recursions<=6
Input a 2d snowflake binary shape with specified size.
Default values: 'size=512' and 'nb_recursions=5'.
-shape_star:
_size>=0,_nb_branches>0,0<=_thickness<=1
Input a 2d star binary shape with specified size.
Default values: 'size=512', 'nb_branches=5' and 'thickness=0.38'.
-shared (+):
x0[%],x1[%],y[%],z[%],v[%] |
y0[%],y1[%],z[%],v[%] |
z0[%],z1[%],v[%] |
v0[%],v1[%] |
v0[%] |
(no arg)
Insert shared buffers from (opt. points/rows/planes/channels of) selected
images.
Shared buffers cannot be returned by a command, nor a local environment.
(eq. to '-sh').
-sample:
_name={ ? | apples | barbara | boats | bottles | butterfly | cameraman | cat
|
cliff | duck | eagle | elephant | earth | flower | fruits | greece | gummy |
house | inside | landscape | leaf | lena | lion | mandrill | monkey | parrots
|
pencils | peppers | rooster | rose | square | teddy | tiger | wall |
waterfall |
zelda },_width={ >=0 | 0 (auto) },_height = { >=0 | 0 (auto) } |
(no arg)
Input a new sample RGB image (opt. with specified size).
(eq. to '-sp').
Argument 'name' can be replaced by an integer which serves as a sample
index.
-srand (+):
value |
(no arg)
Set random generator seed.
If no argument is specified, a random value is used as the random generator
seed.
-string:
"string"
Insert new image containing the ascii codes of specified string.
-testimage2d:
_width>0,_height>0,_spectrum>0
Input a 2d synthetic image.
Default values: 'width=512', 'height=width' and 'spectrum=3'.
-uncommand (+):
command_name[,_command_name2,...] |
*
Discard last definition of specified custom commands.
Set argument to '*' for discarding all existing custom commands.
-uniform_distribution:
nb_levels>=1,spectrum>=1
Input set of uniformly distributed N-d points in [0,1]^N.
-unserialize (+):
Recreate lists of images from serialized image buffers, obtained with command
'-serialize'.
-update:
Update commands from the latest definition file on the G'MIC server.
This requires an active Internet connection and an access to the external
tools 'curl' or 'wget'.
Once the update has been downloaded, running 'gmic' makes it use
automatically.
(eq. to '-up').
-verbose (+):
level |
{ + | - }
Set or increment/decrement the verbosity level. Default level is 0.
(eq. to '-v').
When 'level'>=0, G'MIC log messages are displayed on the standard error
(stderr).
Default value: 'level=0'.
-wait (+):
delay |
(no arg)
Wait for a given delay (in ms), optionally since the last call to '-wait'.
or wait for a user event occuring on the selected instant display windows.
'delay' can be { <0=delay+flush events | 0=event | >0=delay }.
Command selection (if any) stands for instant display window indices instead
of image indices.
If no window indices are specified and if 'delay' is positive, the command
results
in a 'hard' sleep during specified delay.
Default value: 'delay=0'.
-warn (+):
_force_visible={ 0 | 1 },_message
Print specified warning message, on the standard error (stderr).
Command selection (if any) stands for displayed call stack subset instead of
image indices.
-window (+):
_width[%]>=-1,_height[%]>=-1,_normalization,_fullscreen,_pos_x[%],_pos_y[%],
_title
Display selected images into an instant display window with specified size,
normalization type,
fullscreen mode and title.
(eq. to '-w').
If 'width' or 'height' is set to -1, the corresponding dimension is adjusted
to the window
or image size.
When arguments 'pos_x' and 'pos_y' are both different than -1, the window is
moved to
the specified coordinates.
'width'=0 or 'height'=0 closes the instant display window.
'normalization' can be { -1=keep same | 0=none | 1=always | 2=1st-time |
3=auto }.
'fullscreen' can be { -1=keep same | 0=no | 1=yes }.
You can manage up to 10 different instant display windows by using the
numbered variants
'-w0' (default, eq. to '-w'),'-w1',...,'-w9' of the command '-w'.
Invoke '-window' with no selection to make the window visible, if is has been
closed by the
user.
Default values: 'width=height=normalization=fullscreen=-1' and
'title=(undefined)'.
** List manipulation:
-keep (+):
Keep only selected images.
(eq. to '-k').
-move (+):
position[%]
Move selected images at specified position.
(eq. to '-mv').
-name (+):
"name"
Set name of selected images.
(eq. to '-nm').
-names:
name1,name2,...,nameN
Set each name of (multiple) selected images from the sequence of the provided
arguments.
(eq. to '-nms').
-remove (+):
Remove selected images.
(eq. to '-rm').
-remove_duplicates:
Remove duplicates images in the selected images list.
-remove_empty:
Remove empty images in the selected image list.
-reverse (+):
Reverse positions of selected images.
(eq. to '-rv').
-sort_list:
_ordering={ + | - },_criterion
Sort list of selected images according to the specified image criterion.
Default values: 'ordering=+', 'criterion=i'.
-sort_str:
Sort selected images (viewed as a list of strings) in lexicographic
order.
** Mathematical operators:
-abs (+):
Compute the pointwise absolute values of selected images.
-acos (+):
Compute the pointwise arc-cosine of selected images.
-add (+):
value[%] |
[image] |
'formula' |
(no arg)
Add specified value, image or mathematical expression to selected images,
or compute the pointwise sum of selected images.
(eq. to '-+').
-and (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the bitwise AND of selected images with specified value, image or
mathematical
expression, or compute the pointwise sequential bitwise AND of selected
images.
(eq. to '-&').
-asin (+):
Compute the pointwise arc-sine of selected images.
-atan (+):
Compute the pointwise arc-tangent of selected images.
-atan2 (+):
[x_argument]
Compute the pointwise oriented arc-tangent of selected images.
Each selected image is regarded as the y-argument of the arc-tangent
function, while the
specified image gives the corresponding x-argument.
-bsl (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the bitwise left shift of selected images with specified value, image
or
mathematical expression, or compute the pointwise sequential bitwise left
shift of
selected images.
(eq. to '-<<').
-bsr (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the bitwise right shift of selected images with specified value,
image or"
mathematical expression, or compute the pointwise sequential bitwise right
shift of
selected images.
(eq. to '->>').
-cos (+):
Compute the pointwise cosine of selected images.
-cosh (+):
Compute the pointwise hyperbolic cosine of selected images.
-div (+):
value[%] |
[image] |
'formula' |
(no arg)
Divide selected image by specified value, image or mathematical expression,
or compute the pointwise quotient of selected images.
(eq. to '-/').
-div_complex:
[divider_real,divider_imag],_epsilon>=0
Perform division of the selected complex pairs (real1,imag1,...,realN,imagN)
of images by
specified complex pair of images (divider_real,divider_imag).
In complex pairs, the real image must be always located before the imaginary
image in the image
list.
Default value: 'epsilon=1e-8'.
-eq (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the boolean equality of selected images with specified value, image
or
mathematical expression, or compute the boolean equality of selected images.
(eq. to '-==').
-exp (+):
Compute the pointwise exponential of selected images.
-ge (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the boolean 'greater or equal than' of selected images with specified
value, image
or mathematical expression, or compute the boolean 'greater or equal than' of
selected images.
(eq. to '->=').
-gt (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the boolean 'greater than' of selected images with specified value,
image or
mathematical expression, or compute the boolean 'greater than' of selected
images.
(eq. to '->').
-le (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the boolean 'less or equal than' of selected images with specified
value, image or
mathematical expression, or compute the boolean 'less or equal than' of
selected images.
(eq. to '-<=').
-lt (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the boolean 'less than' of selected images with specified value,
image or
mathematical expression, or compute the boolean 'less than' of selected
images.
(eq. to '-<').
-log (+):
Compute the pointwise base-e logarithm of selected images.
-log10 (+):
Compute the pointwise base-10 logarithm of selected images.
-log2 (+):
Compute the pointwise base-2 logarithm of selected images
-max (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the maximum between selected images and specified value, image or
mathematical expression, or compute the pointwise maxima between selected
images.
-mdiv (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the matrix division of selected matrices/vectors by specified value,
image or
mathematical expression, or compute the matrix division of selected images.
(eq. to '-//').
-min (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the minimum between selected images and specified value, image or
mathematical expression, or compute the pointwise minima between selected
images.
-mod (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the modulo of selected images with specified value, image or
mathematical
expression, or compute the pointwise sequential modulo of selected images.
(eq. to '-%').
-mmul (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the matrix right multiplication of selected matrices/vectors by
specified value, image
or
mathematical expression, or compute the matrix right multiplication of
selected images.
(eq. to '-**').
-mul (+):
value[%] |
[image] |
'formula' |
(no arg)
Multiply selected images by specified value, image or mathematical
expression,
or compute the pointwise product of selected images.
(eq. to '-*').
-mul_channels:
value1,_value2,...,_valueN
Multiply channels of selected images by specified sequence of values.
-mul_complex:
[multiplier_real,multiplier_imag]
Perform multiplication of the selected complex pairs
(real1,imag1,...,realN,imagN) of images by
specified complex pair of images (multiplier_real,multiplier_imag).
In complex pairs, the real image must be always located before the imaginary
image in the image
list.
-neq (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the boolean inequality of selected images with specified value, image
or
mathematical expression, or compute the boolean inequality of selected
images.
(eq. to '-!=').
-or (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the bitwise OR of selected images with specified value, image or
mathematical
expression, or compute the pointwise sequential bitwise OR of selected
images.
(eq. to '-|').
-pow (+):
value[%] |
[image] |
'formula' |
(no arg)
Raise selected image to the power of specified value, image or mathematical
expression, or compute the pointwise sequential powers of selected images.
(eq. to '-^').
-rol (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the bitwise left rotation of selected images with specified value,
image or
mathematical expression, or compute the pointwise sequential bitwise left
rotation of
selected images.
-ror (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the bitwise right rotation of selected images with specified value,
image or
mathematical expression, or compute the pointwise sequential bitwise right
rotation of
selected images.
-sign (+):
Compute the pointwise sign of selected images.
-sin (+):
Compute the pointwise sine of selected images.
-sinc (+):
Compute the pointwise sinc function of selected images.
-sinh (+):
Compute the pointwise hyperbolic sine of selected images.
-sqr (+):
Compute the pointwise square function of selected images.
-sqrt (+):
Compute the pointwise square root of selected images.
-sub (+):
value[%] |
[image] |
'formula' |
(no arg)
Subtract specified value, image or mathematical expression to selected
images,
or compute the pointwise difference of selected images.
(eq. to '--').
-tan (+):
Compute the pointwise tangent of selected images.
-tanh (+):
Compute the pointwise hyperbolic tangent of selected images.
-xor (+):
value[%] |
[image] |
'formula' |
(no arg)
Compute the bitwise XOR of selected images with specified value, image or
mathematical
expression, or compute the pointwise sequential bitwise XOR of selected
images.
** Values manipulation:
-apply_curve:
0<=smoothness<=1,x0,y0,x1,y1,x2,y2,...,xN,yN
Apply curve transformation to image values.
Default values: 'smoothness=1', 'x0=0', 'y0=100'.
-apply_gamma:
gamma>=0
Apply gamma correction to selected images.
-balance_gamma:
_ref_color1,...
Compute gamma-corrected color balance of selected image, with respect to
specified reference
color.
Default value: 'ref_color1=128'.
-complex2polar:
Compute complex to polar transforms of selected images.
-compress_clut:
_max_nbpoints>=1,_max_error>=0,_avg_error>=0
Compress selected color LUTs as sequences of colored keypoints.
Default values: 'max_nb_points=2048', 'max_error=17.5' and
'avg_error=1.75'.
-compress_rle:
_is_binary_data={ 0 | 1 },_maximum_sequence_length>=0
Compress selected images as 2xN data matrices, using RLE algorithm.
Set 'maximum_sequence_length=0' to disable maximum length constraint.
Default values: 'is_binary_data=0' and 'maximum_sequence_length=0'.
-cumulate (+):
{ x | y | z | c }...{ x | y | z | c } |
(no arg)
Compute the cumulative function of specified image data, optionally along the
specified axes.
-cut (+):
{ value0[%] | [image0] },{ value1[%] | [image1] } |
[image] |
(no arg)
Cut values of selected images in specified range.
(eq. to '-c').
(no arg) runs interactive mode (uses the instant display window [0] if
opened).
In this case, the chosen cut values are returned in the status.
-decompress_clut:
_width>0,_height>0,_depth>0
Decompress color LUT expressed as a list of colored keypoints.
Default value: 'width=height=depth=64'.
-decompress_rle:
Decompress selected 2xN data matrices, using RLE algorithm.
-discard (+):
_value1,_value2,... |
{ x | y | z | c}...{ x | y | z | c},_value1,_value2,... |
(no arg)
Discard specified values in selected images or discard neighboring duplicate
values,
optionally only for the values along the first of a specified axis.
If no values are specified, neighboring duplicate values are discarded.
If all pixels of a selected image are discarded, an empty image is
returned.
-eigen2tensor:
Recompose selected pairs of eigenvalues/eigenvectors as 2x2 or 3x3 tensor
fields.
-endian (+):
_datatype
Reverse data endianness of selected images, eventually considering the pixel
being of the
specified datatype.
'datatype' can be { uchar | char | ushort | short | uint | int | uint64 |
int64 | float |
double }.
-equalize (+):
_nb_levels>0[%],_value_min[%],_value_max[%]
Equalize histograms of selected images.
If value range is specified, the equalization is done only for pixels in the
specified
value range.
Default values: 'nb_levels=256', 'value_min=0%' and 'value_max=100%'.
-fill (+):
value1,_value2,... |
[image] |
'formula'
Fill selected images with values read from the specified value list, existing
image
or mathematical expression. Single quotes may be omitted in 'formula'.
(eq. to '-f').
-float2int8:
Convert selected float-valued images to 8bits integer representations.
-int82float:
Convert selected 8bits integer representations to float-valued images.
-index (+):
{ [palette] | predefined_palette },0<=_dithering<=1,_map_palette={ 0 |
1 }
Index selected vector-valued images by specified vector-valued palette.
'predefined_palette' can be { 0=default | 1=HSV | 2=lines | 3=hot | 4=cool |
5=jet | 6=flag |
7=cube }.
Default values: 'dithering=0' and 'map_palette=0'.
-inrange:
min[%],max[%]
Detect pixels whose values are in specified range [min,max], in selected
images.
(eq. to '-ir').
-map (+):
[palette],_boundary |
predefined_palette,_boundary
Map specified vector-valued palette to selected indexed scalar images.
'predefined_palette' can be { 0=default | 1=HSV | 2=lines | 3=hot | 4=cool |
5=jet | 6=flag |
7=cube }.
'boundary' can be { 0=dirichlet | 1=neumann | 2=periodic }.
Default value: 'boundary=0'.
-map_clut:
[clut]
Map specified RGB color LUT to selected images.
-mix_channels:
(a00,...,aMN)
Apply specified matrix to channels of selected images.
-negate:
base_value |
(no arg)
Negate image values.
Default value: 'base_value=(undefined)'.
-noise (+):
std_variation>=0[%],_noise_type
Add random noise to selected images.
'noise_type' can be { 0=gaussian | 1=uniform | 2=salt&pepper | 3=poisson
| 4=rice }.
Default value: 'noise_type=0'.
-normlp:
p>=0
Compute the pointwise Lp-norm norm of vector-valued pixels in selected
images.
Default value: 'p=2'.
-norm:
Compute the pointwise euclidean norm of vector-valued pixels in selected
images.
-normalize (+):
{ value0[%] | [image0] },{ value1[%] | [image1] } |
[image]
Linearly normalize values of selected images in specified range.
(eq. to '-n').
-normalize_sum:
Normalize selected images with a unitary sum.
-not:
Apply boolean not operation on selected images.
-orientation:
Compute the pointwise orientation of vector-valued pixels in selected
images.
-oneminus:
For each selected image, compute one minus image.
-otsu:
_nb_levels>0
Hard-threshold selected images using Otsu's method.
The computed thresholds are returned as a list of values in the status.
Default value: 'nb_levels=256'.
-polar2complex:
Compute polar to complex transforms of selected images.
-quantize:
nb_levels>=1,_keep_values={ 0 | 1 },_is_uniform={ 0 | 1 }
Quantize selected images.
Default value: 'keep_values=1' and 'is_uniform=0'.
-rand (+):
{ value0[%] | [image0] },_{ value1[%] | [image1] } |
[image]
Fill selected images with random values uniformly distributed in the
specified range.
-replace:
value_src,value_dest
Replace pixel values in selected images.
-replace_inf:
_expression
Replace all infinite values in selected images by specified expression.
-replace_nan:
_expression
Replace all NaN values in selected images by specified expression.
-replace_seq:
"search_seq","replace_seq"
Search and replace a sequence of values in selected images.
-replace_str:
"search_str","replace_str"
Search and replace a string in selected images (viewed as strings, i.e.
sequences of ascii
codes).
-round (+):
rounding_value>=0,_rounding_type |
(no arg)
Round values of selected images.
'rounding_type' can be { -1=backward | 0=nearest | 1=forward }.
Default value: 'rounding_type=0'.
-roundify:
gamma>=0
Apply roundify transformation on float-valued data, with specified gamma.
Default value: 'gamma=0'.
-set (+):
value,_x[%],_y[%],_z[%],_c[%]
Set pixel value in selected images, at specified coordinates.
(eq. to '-=').
If specified coordinates are outside the image bounds, no action is
performed.
Default values: 'x=y=z=c=0'.
-threshold (+):
value[%],_is_soft={ 0 | 1 } |
(no arg)
Threshold values of selected images.
'soft' can be { 0=hard-thresholding | 1=soft-thresholding }.
(no arg) runs interactive mode (uses the instant display window [0] if
opened).
In this case, the chosen threshold value is returned in the status.
Default value: 'is_soft=0'.
-unrepeat:
Remove repetition of adjacent values in selected images.
-vector2tensor:
Convert selected vector fields to corresponding tensor fields.
** Colors manipulation:
-adjust_colors:
-100<=_brightness<=100,-100<=_contrast<=100,-100<=_gamma<=100,
-100<=_hue_shift<=100,-100<=_saturation<=100,_value_min,_value_max
Perform a global adjustment of colors on selected images.
Range of correct image values are considered to be in [value_min,value_max]
(e.g. [0,255]).
If 'value_min==value_max==0', value range is estimated from min/max values of
selected images.
Processed images have pixel values constrained in [value_min,value_max].
Default values: 'brightness=0', 'contrast=0', 'gamma=0', 'hue_shift=0',
'saturation=0',
'value_min=value_max=0'.
-apply_channels:
"command",channels,_value_action={ 0=none | 1=cut | 2=normalize
}
Apply specified command on the chosen color channel(s) of each selected
images.
(eq. to '-ac').
Argument 'channels' refers to a colorspace, and can be basically one of { all
| rgba | rgb |
lrgb | ycbcr | lab | lch | hsv | hsi | hsl | cmy | cmyk | yiq }.
You can also focus the processing on one particular channel of this
colorspace, by setting
'channels' as 'colorspace_channel' (e.g. 'hsv_h' for the hue).
All channel values are considered to be in the [0,255] range.
Default value: 'value_action=0'.
-autoindex:
nb_colors>0,0<=_dithering<=1,_method={ 0=median-cut | 1=k-means
}
Index selected vector-valued images by adapted colormaps.
Default values: 'dithering=0' and 'method=1'.
-bayer2rgb:
_GM_smoothness,_RB_smoothness1,_RB_smoothness2
Transform selected RGB-Bayer sampled images to color images.
Default values: 'GM_smoothness=RB_smoothness=1' and 'RB_smoothness2=0.5'.
-cmy2rgb:
Convert selected images from CMY to RGB colorbases.
-cmyk2rgb:
Convert selected images from CMYK to RGB colorbases.
-colorblind:
type={ 0=protanopia | 1=protanomaly | 2=deuteranopia | 3=deuteranomaly |
4=tritanopia | 5=tritanomaly | 6=achromatopsia | 7=achromatomaly }
Simulate color blindness vision.
-colormap:
nb_levels>=0,_method={ 0=median-cut | 1=k-means },_sort_vectors={ 0 | 1
}
Estimate best-fitting colormap with 'nb_colors' entries, to index selected
images.
Set 'nb_levels==0' to extract all existing colors of an image.
Default value: 'method=1' and 'sort_vectors=1'.
-compose_channels:
Compose all channels of each selected image, using specified arithmetic
operator (+,-,or,min,...
).
Default value: '1=+'.
-direction2rgb:
Compute RGB representation of selected 2d direction fields.
-ditheredbw:
Create dithered B&W version of selected images.
-fill_color:
col1,...,colN
Fill selected images with specified color.
(eq. to '-fc').
-gradient2rgb:
_is_orientation={ 0 | 1 }
Compute RGB representation of 2d gradient of selected images.
Default value: 'is_orientation=0'.
-hsi2rgb (+):
Convert selected images from HSI to RGB colorbases.
-hsi82rgb:
Convert selected images from HSI8 to RGB color bases.
-hsl2rgb (+):
Convert selected images from HSL to RGB colorbases.
-hsl82rgb:
Convert selected images from HSL8 to RGB color bases.
-hsv2rgb (+):
Convert selected images from HSV to RGB colorbases.
-hsv82rgb:
Convert selected images from HSV8 to RGB color bases.
-int2rgb:
Convert selected images from INT24 scalars to RGB.
-lab2lch:
Convert selected images from Lab to Lch color bases.
-lab2rgb (+):
illuminant={ 0=D50 | 1=D65 } |
(no arg)
Convert selected images from Lab to RGB colorbases.
-lab82rgb:
illuminant={ 0=D50 | 1=D65 } |
(no arg)
Convert selected images from Lab8 to RGB color bases.
-lch2lab:
Convert selected images from Lch to Lab color bases.
-lch2rgb:
Convert selected images from Lch to RGB color bases.
-lch82rgb:
Convert selected images from Lch8 to RGB color bases.
-luminance:
Compute luminance of selected sRGB images.
-mix_rgb:
a11,a12,a13,a21,a22,a23,a31,a32,a33
Apply 3x3 specified matrix to RGB colors of selected images.
Default values: 'a11=1', 'a12=a13=a21=0', 'a22=1', 'a23=a31=a32=0' and
'a33=1'.
-pseudogray:
_max_increment>=0,_JND_threshold>=0,_bits_depth>0
Generate pseudogray colormap with specified increment and perceptual
threshold.
If 'JND_threshold' is 0, no perceptual constraints are applied.
Default values: 'max_increment=5', 'JND_threshold=2.3' and
'bits_depth=8'.
-replace_color:
tolerance[%]>=0,smoothness[%]>=0,src1,src2,...,dest1,dest2,...
Replace pixels from/to specified colors in selected images.
-retinex:
_value_offset>0,_colorspace={ hsi | hsv | lab | lrgb | rgb | ycbcr },
0<=_min_cut<=100,0<=_max_cut<=100,_sigma_low>0,_sigma_mid>0,_sigma_high>0
Apply multi-scale retinex algorithm on selected image to improve color
consistency.
(as described in the page http://www.ipol.im/pub/art/2014/107/).
Default values: 'offset=1', 'colorspace=hsv', 'min_cut=1', 'max_cut=1',
'sigma_low=15',
'sigma_mid=80' and 'sigma_high=250'.
-rgb2bayer:
_start_pattern=0,_color_grid=0
Transform selected color images to RGB-Bayer sampled images.
Default values: 'start_pattern=0' and 'color_grid=0'.
-rgb2cmy:
Convert selected images from RGB to CMY colorbases.
-rgb2cmyk:
Convert selected images from RGB to CMYK colorbases.
-rgb2hsi (+):
Convert selected images from RGB to HSI colorbases.
-rgb2hsi8:
Convert selected images from RGB to HSI8 color bases.
-rgb2hsl (+):
Convert selected images from RGB to HSL colorbases.
-rgb2hsl8:
Convert selected images from RGB to HSL8 color bases.
-rgb2hsv (+):
Convert selected images from RGB to HSV colorbases.
-rgb2hsv8:
Convert selected images from RGB to HSV8 color bases.
-rgb2lab (+):
illuminant={ 0=D50 | 1=D65 } |
(no arg)
Convert selected images from RGB to Lab colorbases.
-rgb2lab8:
illuminant={ 0=D50 | 1=D65 } |
(no arg)
Convert selected images from RGB to Lab8 color bases.
-rgb2lch:
Convert selected images from RGB to Lch color bases.
-rgb2lch8:
Convert selected images from RGB to Lch8 color bases.
-rgb2luv:
Convert selected images from RGB to LUV color bases.
-rgb2int:
Convert selected images from RGB to INT24 scalars.
-rgb2srgb (+):
Convert selected images from RGB to sRGB colorbases.
-rgb2xyz:
illuminant={ 0=D50 | 1=D65 } |
(no arg)
Convert selected images from RGB to XYZ colorbases.
Default value: 'illuminant=0'.
-rgb2xyz8:
illuminant={ 0=D50 | 1=D65 } |
(no arg)
Convert selected images from RGB to XYZ8 color bases.
-rgb2yiq:
Convert selected images from RGB to YIQ colorbases.
-rgb2yiq8:
Convert selected images from RGB to YIQ8 colorbases.
-rgb2ycbcr:
Convert selected images from RGB to YCbCr colorbases.
-rgb2yuv:
Convert selected images from RGB to YUV colorbases.
-rgb2yuv8:
Convert selected images from RGB to YUV8 color bases.
-remove_opacity:
Remove opacity channel of selected images.
-select_color:
tolerance[%]>=0,col1,...,colN
Select pixels with specified color in selected images.
-sepia:
Apply sepia tones effect on selected images.
-solarize:
Solarize selected images.
-split_colors:
_tolerance>=0,_max_nb_outputs>0,_min_area>0
Split selected images as several image containing a single color.
One selected image can be split as at most 'max_nb_outputs' images.
Output images are sorted by decreasing area of extracted color regions and
have an additional
alpha-channel.
Default values: 'tolerance=0', 'max_nb_outputs=256' and 'min_area=8'.
-split_opacity:
Split color and opacity parts of selected images.
-srgb2rgb (+):
Convert selected images from sRGB to RGB colorbases.
-to_a:
Force selected images to have an alpha channel.
-to_color:
Force selected images to be in color mode (RGB or RGBA).
-to_colormode:
mode={ 0=adaptive | 1=G | 2=GA | 3=RGB | 4=RGBA }
Force selected images to be in a given color mode.
Default value: 'mode=0'.
-to_gray:
Force selected images to be in GRAY mode.
-to_graya:
Force selected images to be in GRAYA mode.
-to_pseudogray:
_max_step>=0,_is_perceptual_constraint={ 0 | 1 },_bits_depth>0
Convert selected scalar images ([0-255]-valued) to pseudo-gray color images.
Default parameters : 'max_step=5', 'is_perceptual_constraint=1' and
'bits_depth=8'.
The original pseudo-gray technique has been introduced by Rich Franzen
[http://r0k.us/graphics/
pseudoGrey.html].
Extension of this technique to arbitrary increments for more tones, has been
done by David
Tschumperle.
-to_rgb:
Force selected images to be in RGB mode.
-to_rgba:
Force selected images to be in RGBA mode.
-transfer_colors:
[reference_image],_transfer_brightness={ 0 | 1 }
Transfer colors of the specified reference image to selected images.
Default value: 'transfer_brightness=0'.
-transfer_rgb:
[target],_gamma>=0,_regularization>=0,_luminosity_constraints>=0,
_rgb_resolution>=0,_is_constraints={ 0 | 1 }
Transfer colors from selected source images to selected reference image
(given as argument).
'gamma' determines the importance of color occurences in the matching process
(0=none to
1=huge).
'regularization' determines the number of guided filter iterations to remove
quantization
effects.
'luminosity_constraints' tells if luminosity constraints must be applied on
non-confident
matched colors.
'is_constraints' tells if additional hard color constraints must be set
(opens an interactive
window).
Default values: 'gamma=0.3','regularization=8', 'luminosity_constraints=0.1',
'rgb_resolution=64' and 'is_constraints=0'.
-xyz2rgb:
illuminant={ 0=D50 | 1=D65 } |
(no arg)
Convert selected images from XYZ to RGB colorbases.
Default value: 'illuminant=0'.
-xyz82rgb:
illuminant={ 0=D50 | 1=D65 } |
(no arg)
Convert selected images from XYZ8 to RGB color bases.
-ycbcr2rgb:
Convert selected images from YCbCr to RGB colorbases.
-yiq2rgb:
Convert selected images from YIQ to RGB colorbases.
-yiq82rgb:
Convert selected images from YIQ8 to RGB colorbases.
-yuv2rgb:
Convert selected images from YUV to RGB colorbases.
-yuv82rgb:
Convert selected images from YUV8 to RGB color bases.
** Geometry manipulation:
-append (+):
[image],axis,_centering |
axis,_centering
Append specified image to selected images, or all selected images together,
along specified
axis.
(eq. to '-a').
'axis' can be { x | y | z | c }.
Usual 'centering' values are { 0=left-justified | 0.5=centered |
1=right-justified }.
Default value: 'centering=0'.
-append_tiles:
_M>=0,_N>=0,0<=_centering_x<=1,0<=_centering_y<=1
Append MxN selected tiles as new images.
If 'N' is set to 0, number of rows is estimated automatically.
If 'M' is set to 0, number of columns is estimated automatically.
If 'M' and 'N' are both set to '0', auto-mode is used.
If 'M' or 'N' is set to 0, only a single image is produced.
'centering_x' and 'centering_y' tells about the centering of tiles when they
have different
sizes.
Default values: 'M=0', 'N=0', 'centering_x=centering_y=0.5'.
-apply_scales:
"command",number_of_scales>0,_min_scale[%]>=0,_max_scale[%]>=0,_scale_gamma>0,
_interpolation
Apply specified command on different scales of selected images.
'interpolation' can be { 0=none | 1=nearest | 2=average | 3=linear | 4=grid |
5=bicubic |
6=lanczos }.
Default value: 'min_scale=25%', 'max_scale=100%' and 'interpolation=3'.
-autocrop (+):
value1,value2,... |
(no arg)
Autocrop selected images by specified vector-valued intensity.
If no arguments are provided, cropping value is guessed.
-autocrop_components:
_threshold[%],_min_area[%]>=0,_is_high_connectivity={ 0 | 1
},_output_type={
0=crop | 1=segmentation | 2=coordinates }
Autocrop and extract connected components in selected images, according to a
mask given as the
last channel of
each of the selected image (e.g. alpha-channel).
Default values: 'threshold=0%', 'min_area=0.1%', 'is_high_connectivity=0' and
'output_type=1'.
-autocrop_seq:
value1,value2,... | auto
Autocrop selected images using the crop geometry of the last one by specified
vector-valued
intensity,
or by automatic guessing the cropping value.
Default value: auto mode.
-channels (+):
{ [image0] | c0[%] },_{ [image1] | c1[%] }
Keep only specified channels of selected images.
Dirichlet boundary is used when specified channels are out of range.
-columns (+):
{ [image0] | x0[%] },_{ [image1] | x1[%] }
Keep only specified columns of selected images.
Dirichlet boundary is used when specified columns are out of range.
-crop (+):
x0[%],x1[%],_boundary |
x0[%],y0[%],x1[%],y1[%],_boundary |
x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],_boundary |
x0[%],y0[%],z0[%],c0[%],x1[%],y1[%],z1[%],c1[%],_boundary |
(no arg)
Crop selected images with specified region coordinates.
(eq. to '-z').
'boundary' can be { 0=dirichlet | 1=neumann }.
(no arg) runs interactive mode (uses the instant display window [0] if
opened).
Default value: 'boundary=0'.
-diagonal:
Transform selected vectors as diagonal matrices.
-elevate:
_depth,_is_plain={ 0 | 1 },_is_colored={ 0 | 1 }
Elevate selected 2d images into 3d volumes.
Default values: 'depth=64', 'is_plain=1' and 'is_colored=1'.
-expand_x:
size_x>=0,_boundary={ 0=dirichlet | 1=neumann | 2=periodic }
Expand selected images along the x-axis.
Default value: 'border=1'.
-expand_xy:
size>=0,_boundary={ 0=dirichlet | 1=neumann | 2=periodic }
Expand selected images along the xy-axes.
Default value: 'border=1'.
-expand_xyz:
size>=0,_boundary={ 0=dirichlet | 1=neumann | 2=periodic }
Expand selected images along the xyz-axes.
Default value: 'border=1'.
-expand_y:
size_y>=0,_boundary={ 0=dirichlet | 1=neumann | 2=periodic }
Expand selected images along the y-axis.
Default value: 'border=1'.
-expand_z:
size_z>=0,_boundary={ 0=dirichlet | 1=neumann | 2=periodic }
Expand selected images along the z-axis.
Default value: 'border=1'.
-montage:
"_layout_code",_montage_mode={ 0<=centering<=1 |
2<=scale+2<=3 },_output_mode={
0=single layer | 1=multiple layers },"_processing_command"
Create a single image montage from selected images, according to specified
layout code :
- 'X' to assemble all images using an automatically estimated layout.
- 'H' to assemble all images horizontally.
- 'V' to assemble all images vertically.
- 'A' to assemble all images as an horizontal array.
- 'B' to assemble all images as a vertical array.
- 'Ha:b' to assemble two blocks 'a' and 'b' horizontally.
- 'Va:b' to assemble two blocks 'a' and 'b' vertically.
- 'Ra' to rotate a block 'a' by 90 deg. ('RRa' for 180 deg. and 'RRRa' for
270 deg.).
- 'Ma' to mirror a block 'a' along the X-axis ('MRRa' for the Y-axis).
A block 'a' can be an image indice (treated periodically) or a nested layout
expression 'Hb:c',
'Vb:c','Rb' or 'Mb' itself.
For example, layout code 'H0:V1:2' creates an image where image [0] is on the
left, and images
[1] and [2] vertically packed on the right.
Default values: 'layout_code=X', 'montage_mode=2', output_mode='0' and
'processing_command=""'.
-mirror (+):
{ x | y | z }...{ x | y | z }
Mirror selected images along specified axes.
-permute (+):
permutation_string
Permute selected image axes by specified permutation.
'permutation' is a combination of the character set {x|y|z|c},
e.g. 'xycz', 'cxyz', ...
-resize (+):
[image],_interpolation,_boundary,_ax,_ay,_az,_ac |
{[image_w] | width>0[%]},_{[image_h] | height>0[%]},_{[image_d] |
depth>0[%]},
_{[image_s] | spectrum>0[%]},_interpolation,_boundary,_ax,_ay,_az,_ac |
(no arg)
Resize selected images with specified geometry.
(eq. to '-r').
'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
'boundary' has different meanings, according to the chosen 'interpolation'
mode :
. When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary' is meaningless.
. When 'interpolation==0', 'boundary' can be { 0=dirichlet | 1=neumann |
2=periodic }.
. When 'interpolation=={ 3 | 5 | 6 }', 'boundary' can be { 0=none | 1=neumann
}.
'ax,ay,az,ac' set the centering along each axis when 'interpolation=0 or 4'
(set to '0' by default, must be defined in range [0,1]).
(no arg) runs interactive mode (uses the instant display window [0] if
opened).
Default values: 'interpolation=1', 'boundary=0' and 'ax=ay=az=ac=0'.
-resize_pow2:
_interpolation,_boundary,_ax,_ay,_az,_ac
Resize selected images so that each dimension is a power of 2.
'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
'boundary' has different meanings, according to the chosen 'interpolation'
mode :
. When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary' is meaningless.
. When 'interpolation==0', 'boundary' can be { 0=dirichlet | 1=neumann |
2=periodic }.
. When 'interpolation=={ 3 | 5 | 6 }', 'boundary' can be { 0=none | 1=neumann
}.
'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
(set to '0' by default, must be defined in range [0,1]).
Default values: 'interpolation=0', 'boundary=0' and 'ax=ay=az=ac=0'.
-resize_ratio2d:
width>0,height>0,_mode={ 0=inside | 1=outside | 2=padded
},0=<_interpolation<=6
Resize selected images while preserving their aspect ratio.
(eq. to '-rr2d').
Default values: 'mode=0' and 'interpolation=6'.
-resize2dx:
width[%]>0,_interpolation,_boundary,_ax,_ay,_az,_ac
Resize selected images along the x-axis, preserving 2d ratio.
(eq. to '-r2dx').
'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
'boundary' has different meanings, according to the chosen 'interpolation'
mode :
. When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary' is meaningless.
. When 'interpolation==0', 'boundary' can be { 0=dirichlet | 1=neumann |
2=periodic }.
. When 'interpolation=={ 3 | 5 | 6 }', 'boundary' can be { 0=none | 1=neumann
}.
'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
(set to '0' by default, must be defined in range [0,1]).
Default values: 'interpolation=3', 'boundary=0' and 'ax=ay=az=ac=0'.
-resize2dy:
height[%]>=0,_interpolation,_boundary,_ax,_ay,_az,_ac
Resize selected images along the y-axis, preserving 2d ratio.
(eq. to '-r2dy').
'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
'boundary' has different meanings, according to the chosen 'interpolation'
mode :
. When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary' is meaningless.
. When 'interpolation==0', 'boundary' can be { 0=dirichlet | 1=neumann |
2=periodic }.
. When 'interpolation=={ 3 | 5 | 6 }', 'boundary' can be { 0=none | 1=neumann
}.
'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
(set to '0' by default, must be defined in range [0,1]).
Default values: 'interpolation=3', 'boundary=0' and 'ax=ay=az=ac=0'.
-resize3dx:
width[%]>0,_interpolation,_boundary,_ax,_ay,_az,_ac
Resize selected images along the x-axis, preserving 3d ratio.
(eq. to '-r3dx').
'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
'boundary' has different meanings, according to the chosen 'interpolation'
mode :
. When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary' is meaningless.
. When 'interpolation==0', 'boundary' can be { 0=dirichlet | 1=neumann |
2=periodic }.
. When 'interpolation=={ 3 | 5 | 6 }', 'boundary' can be { 0=none | 1=neumann
}.
'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
(set to '0' by default, must be defined in range [0,1]).
Default values: 'interpolation=3', 'boundary=0' and 'ax=ay=az=ac=0'.
-resize3dy:
height[%]>0,_interpolation,_boundary,_ax,_ay,_az,_ac
Resize selected images along the y-axis, preserving 3d ratio.
(eq. to '-r3dy').
'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
'boundary' has different meanings, according to the chosen 'interpolation'
mode :
. When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary' is meaningless.
. When 'interpolation==0', 'boundary' can be { 0=dirichlet | 1=neumann |
2=periodic }.
. When 'interpolation=={ 3 | 5 | 6 }', 'boundary' can be { 0=none | 1=neumann
}.
'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
(set to '0' by default, must be defined in range [0,1]).
Default values: 'interpolation=3', 'boundary=0' and 'ax=ay=az=ac=0'.
-resize3dz:
depth[%]>0,_interpolation,_boundary,_ax,_ay,_az,_ac
Resize selected images along the z-axis, preserving 3d ratio.
(eq. to '-r3dz').
'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest |
2=average | 3=linear |
4=grid | 5=bicubic | 6=lanczos }.
'boundary' has different meanings, according to the chosen 'interpolation'
mode :
. When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary' is meaningless.
. When 'interpolation==0', 'boundary' can be { 0=dirichlet | 1=neumann |
2=periodic }.
. When 'interpolation=={ 3 | 5 | 6 }', 'boundary' can be { 0=none | 1=neumann
}.
'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
(set to '0' by default, must be defined in range [0,1]).
Default values: 'interpolation=3', 'boundary=0' and 'ax=ay=az=ac=0'.
-rotate (+):
angle,_interpolation,_boundary,_center_x[%],_center_y[%] |
u,v,w,angle,interpolation,boundary,_center_x[%],_center_y[%],_center_z[%]
Rotate selected images with specified angle (in deg.), and optionally 3d axis
(u,v,w).
'interpolation' can be { 0=none | 1=linear | 2=bicubic }.
'boundary' can be { 0=dirichlet | 1=neumann | 2=periodic }.
When a rotation center (cx,cy,_cz) is specified, the size of the image is
preserved.
Default values: 'interpolation=1', 'boundary=0' and
'center_x=center_y=(undefined)'.
-rotate_tileable:
angle,_max_size_factor>=0
Rotate selected images by specified angle and make them tileable.
If resulting size of an image is too big, the image is replaced by a 1x1
image.
Default values: 'max_size_factor=8'.
-rows (+):
{ [image0] | y0[%] },_{ [image1] | y1[%] }
Keep only specified rows of selected images.
Dirichlet boundary is used when specified rows are out of range.
-scale2x:
Resize selected images using the Scale2x algorithm.
-scale3x:
Resize selected images using the Scale3x algorithm.
-scale_dcci2x:
_edge_threshold>=0,_exponent>0,_extend_1px={ 0=false | 1=true }
Double image size using directional cubic convolution interpolation,
as described in
https://en.wikipedia.org/wiki/Directional_Cubic_Convolution_Interpolation.
Default values: 'edge_threshold=1.15', 'exponent=5' and 'extend_1px=0'.
-seamcarve:
_width[%]>=0,_height[%]>=0,_is_priority_channel={ 0 | 1
},_is_antialiasing={ 0 |
1 },_maximum_seams[%]>=0
Resize selected images with specified 2d geometry, using the seam-carving
algorithm.
Default values: 'height=100%', 'is_priority_channel=0', 'is_antialiasing=1'
and
'maximum_seams=25%'.
-shift (+):
vx[%],_vy[%],_vz[%],_vc[%],_boundary
Shift selected images by specified displacement vector.
Displacement vector can be non-integer in which case linear interpolation of
the shift is
computed.
'boundary' can be { 0=dirichlet | 1=neumann | 2=periodic }.
Default value: 'boundary=0'.
-shrink_x:
size_x>=0
Shrink selected images along the x-axis.
-shrink_xy:
size>=0
Shrink selected images along the xy-axes.
-shrink_xyz:
size>=0
Shrink selected images along the xyz-axes.
-shrink_y:
size_y>=0
Shrink selected images along the y-axis.
-shrink_z:
size_z>=0
Shrink selected images along the z-axis.
-slices (+):
{ [image0] | z0[%] },_{ [image1] | z1[%] }
Keep only specified slices of selected images.
Dirichlet boundary is used when specified slices are out of range.
-sort (+):
_ordering={ + | - },_axis={ x | y | z | c }
Sort pixel values of selected images.
If 'axis' is specified, the sorting is done according to the data of the
first column/row/slice/
channel
of selected images.
Default values: 'ordering=+' and 'axis=(undefined)'.
-split (+):
{ x | y | z | c }...{ x | y | z | c },_split_mode |
keep_splitting_values={ + | - },_{ x | y | z | c }...{ x | y | z | c
},value1,
_value2,... |
(no arg)
Split selected images along specified axes, or regarding to a sequence of
scalar values
(optionally along specified axes too).
(eq. to '-s').
'split_mode' can be { 0=split according to constant values | >0=split in N
parts | <0=split in
parts of size -N }.
Default value: 'split_mode=-1'.
-split_tiles:
M!=0,_N!=0,_is_homogeneous={ 0 | 1 }
Split selected images as a MxN array of tiles.
If M or N is negative, it stands for the tile size instead.
Default values: 'N=M' and 'is_homogeneous=0'.
-unroll (+):
_axis={ x | y | z | c }
Unroll selected images along specified axis.
(eq. to '-y').
Default value: 'axis=y'.
-upscale_smart:
width[%],_height[%],_depth,_smoothness>=0,_anisotropy=[0,1],sharpening>=0
Upscale selected images with an edge-preserving algorithm.
Default values: 'height=100%', 'depth=100%', 'smoothness=2', 'anisotropy=0.4'
and
'sharpening=10'.
-warp (+):
[warping_field],_mode,_interpolation,_boundary,_nb_frames>0
Warp selected image with specified displacement field.
'mode' can be { 0=backward-absolute | 1=backward-relative |
2=forward-absolute |
3=forward-relative }.
'interpolation' can be { 0=nearest-neighbor | 1=linear | 2=cubic }.
'boundary' can be { 0=dirichlet | 1=neumann | 2=periodic }.
Default values: 'mode=0', 'interpolation=1', 'boundary=1' and
'nb_frames=1'.
** Filtering:
-bandpass:
_min_freq[%],_max_freq[%]
Apply bandpass filter to selected images.
Default values: 'min_freq=0' and 'max_freq=20%'.
-bilateral (+):
[guide],std_variation_s[%]>=0,std_variation_r[%]>=0,_sampling_s>=0,
_sampling_r>=0 |
std_variation_s[%]>=0,std_variation_r[%]>=0,_sampling_s>=0,_sampling_r>=0
Blur selected images by anisotropic (eventually joint/cross) bilateral
filtering.
If a guide image is provided, it is used for drive the smoothing filter.
A guide image must be of the same xyz-size as the selected images.
Set 'sampling' arguments to '0' for automatic adjustment.
-blur (+):
std_variation>=0[%],_boundary,_kernel |
axes,std_variation>=0[%],_boundary,_kernel
Blur selected images by a quasi-gaussian or gaussian filter (recursive
implementation).
(eq. to '-b').
'boundary' can be { 0=dirichlet | 1=neumann } and 'kernel' can be {
0=quasi-gaussian (faster) |
1=gaussian }.
When specified, argument 'axes' is a sequence of { x | y | z | c }.
Specifying one axis multiple times apply also the blur multiple times.
Default values: 'boundary=1' and 'kernel=0'.
-blur_angular:
amplitude[%],_center_x[%],_center_y[%]
Apply angular blur on selected images.
Default values: 'center_x=center_y=50%'.
-blur_linear:
amplitude1[%],_amplitude2[%],_angle,_boundary={ 0=dirichlet | 1=neumann }
Apply linear blur on selected images, with specified angle and amplitudes.
Default values: 'amplitude2=0', 'angle=0' and 'boundary=1'.
-blur_radial:
amplitude[%],_center_x[%],_center_y[%]
Apply radial blur on selected images.
Default values: 'center_x=center_y=50%'.
-blur_selective:
sigma>=0,_edges>0,_nb_scales>0
Blur selected images using selective gaussian scales.
Default values: 'sigma=5', 'edges=0.5' and 'nb_scales=5'.
-blur_x:
amplitude[%]>=0,_boundary={ 0=dirichlet | 1=neumann }
Blur selected images along the x-axis.
Default value: 'boundary=1'.
-blur_xy:
amplitude_x[%],amplitude_y[%],_boundary={ 0=dirichlet | 1=neumann }
Blur selected images along the X and Y axes.
Default value: 'boundary=1'.
-blur_xyz:
amplitude_x[%],amplitude_y[%],amplitude_z,_boundary={ 0=dirichlet | 1=neumann
}
Blur selected images along the X, Y and Z axes.
Default value: 'boundary=1'.
-blur_y:
amplitude[%]>=0,_boundary={ 0=dirichlet | 1=neumann }
Blur selected images along the y-axis.
Default value: 'boundary=1'.
-blur_z:
amplitude[%]>=0,_boundary={ 0=dirichlet | 1=neumann }
Blur selected images along the z-axis.
Default value: 'boundary=1'.
-boxfilter (+):
size>=0[%],_order,_boundary |
axes,size>=0[%],_order,_boundary
Blur selected images by a box filter of specified size (recursive
implementation).
'order' can be { 0=smooth | 1=1st-derivative | 2=2nd-derivative }.
'boundary' can be { 0=dirichlet | 1=neumann } and 'kernel' can be {
0=quasi-gaussian (faster) |
1=gaussian }.
When specified, argument 'axes' is a sequence of { x | y | z | c }.
Specifying one axis multiple times apply also the blur multiple times.
Default values: 'order=0' and 'boundary=1'.
-compose_freq:
Compose selected low and high frequency parts into new images.
-convolve (+):
[mask],_boundary,_is_normalized={ 0 | 1 }
Convolve selected images by specified mask.
'boundary' can be { 0=dirichlet | 1=neumann }.
Default values: 'boundary=1' and 'is_normalized=0'.
-convolve_fft:
[mask]
Convolve selected images with specified mask, in the fourier domain.
-correlate (+):
[mask],_boundary,_is_normalized={ 0 | 1 }
Correlate selected images by specified mask.
'boundary' can be { 0=dirichlet | 1=neumann }.
Default values: 'boundary=1' and 'is_normalized=0'.
-cross_correlation:
[mask]
Compute cross-correlation of selected images with specified mask.
-curvature:
Compute isophote curvatures on selected images.
-dct:
_{ x | y | z }...{ x | y | z } |
(no arg)
Compute the discrete cosine transform of selected images,
optionally along the specified axes only.
Default values: (no arg)
-deblur:
amplitude[%]>=0,_nb_iter>=0,_dt>=0,_regul>=0,_regul_type={
0=Tikhonov |
1=meancurv. | 2=TV }
Deblur image using a regularized Jansson-Van Cittert algorithm.
Default values: 'nb_iter=10', 'dt=20', 'regul=0.7' and 'regul_type=1'.
-deblur_goldmeinel:
sigma>=0, _nb_iter>=0, _acceleration>=0, _kernel_type={
0=quasi-gaussian
(faster) | 1=gaussian }.
Deblur selected images using Gold-Meinel algorithm
Default values: 'nb_iter=8', 'acceleration=1' and 'kernel_type=1'.
-deblur_richardsonlucy:
sigma>=0, nb_iter>=0, _kernel_type={ 0=quasi-gaussian (faster) |
1=gaussian }.
Deblur selected images using Richardson-Lucy algorithm.
Default values: 'nb_iter=50' and 'kernel_type=1'.
-deconvolve_fft:
[kernel],_regularization>=0
Deconvolve selected images by specified mask in the fourier space.
Default value: 'regularization>=0'.
-deinterlace:
_method={ 0 | 1 }
Deinterlace selected images ('method' can be { 0=standard or
1=motion-compensated }).
Default value: 'method=0'.
-denoise (+):
std_variation_s>=0,_std_variation_p>=0,_patch_size>0,_lookup_size>0,_smoothness,
_fast_approx={ 0 | 1 }
Denoise selected images by non-local patch averaging.
Default values: 'std_variation_p=10', 'patch_size=5', 'lookup_size=6' and
'smoothness=1'.
-denoise_haar:
_threshold>=0,_nb_scales>=0,_cycle_spinning>0
Denoise selected image using haar-wavelet thresholding with cycle spinning.
Set 'nb_scales==0' to automatically determine the optimal number of scales.
Default values: 'threshold=1.4', 'nb_scale=0' and 'cycle_spinning=10'.
-denoise_patchpca:
_strength>=0,_patch_size>0,_lookup_size>0,_spatial_sampling>0
Denoise selected images using the patch-pca algorithm.
Default values: 'patch_size=7', 'lookup_size=11', 'details=1.8' and
'spatial_sampling=5'.
-deriche (+):
std_variation>=0[%],order={ 0 | 1 | 2 },axis={ x | y | z | c
},_boundary
Apply Deriche recursive filter on selected images, along specified axis and
with
specified standard deviation, order and boundary conditions.
'boundary' can be { 0=dirichlet | 1=neumann }.
Default value: 'boundary=1'.
-dilate (+):
size>=0 |
size_x>=0,size_y>=0,size_z>=0 |
[kernel],_boundary,_is_real={ 0=binary-mode | 1=real-mode }
Dilate selected images by a rectangular or the specified structuring element.
'boundary' can be { 0=dirichlet | 1=neumann }.
Default values: 'size_z=1', 'boundary=1' and 'is_real=0'.
-dilate_circ:
_size>=0,_boundary,_is_normalized={ 0 | 1 }
Apply circular dilation of selected image by specified size.
Default values: 'boundary=1' and 'is_normalized=0'.
-dilate_oct:
_size>=0,_boundary,_is_normalized={ 0 | 1 }
Apply octagonal dilation of selected image by specified size.
Default values: 'boundary=1' and 'is_normalized=0'.
-dilate_threshold:
size_x>=1,size_y>=1,size_z>=1,_threshold>=0,_boundary
Dilate selected images in the (X,Y,Z,I) space.
'boundary' can be { 0=dirichlet | 1=neumann }.
Default values: 'size_y=size_x', 'size_z=1', 'threshold=255' and
'boundary=1'.
-divergence:
Compute divergence of selected vector fields.
-dog:
_sigma1>=0[%],_sigma2>=0[%]
Compute difference of gaussian on selected images.
Default values: 'sigma1=2%' and 'sigma2=3%'.
-diffusiontensors:
_sharpness>=0,0<=_anisotropy<=1,_alpha[%],_sigma[%],is_sqrt={ 0 | 1
}
Compute the diffusion tensors of selected images for edge-preserving
smoothing algorithms.
Default values: 'sharpness=0.7', 'anisotropy=0.3', 'alpha=0.6', 'sigma=1.1'
and 'is_sqrt=0'.
-edges:
_threshold[%]>=0
Estimate contours of selected images.
Default value: 'edges=15%'
-erode (+):
size>=0 |
size_x>=0,size_y>=0,_size_z>=0 |
[kernel],_boundary,_is_real={ 0=binary-mode | 1=real-mode }
Erode selected images by a rectangular or the specified structuring element.
'boundary' can be { 0=dirichlet | 1=neumann }.
Default values: 'size_z=1', 'boundary=1' and 'is_real=0'.
-erode_circ:
_size>=0,_boundary,_is_normalized={ 0 | 1 }
Apply circular erosion of selected images by specified size.
Default values: 'boundary=1' and 'is_normalized=0'.
-erode_oct:
_size>=0,_boundary,_is_normalized={ 0 | 1 }
Apply octagonal erosion of selected images by specified size.
Default values: 'boundary=1' and 'is_normalized=0'.
-erode_threshold:
size_x>=1,size_y>=1,size_z>=1,_threshold>=0,_boundary
Erode selected images in the (X,Y,Z,I) space.
'boundary' can be { 0=dirichlet | 1=neumann }.
Default values: 'size_y=size_x', 'size_z=1', 'threshold=255' and
'boundary=1'.
-fft (+):
_{ x | y | z }...{ x | y | z }
Compute the direct fourier transform (real and imaginary parts) of selected
images,
optionally along the specified axes only.
-gradient (+):
{ x | y | z }...{ x | y | z },_scheme |
(no arg)
Compute the gradient components (first derivatives) of selected images.
(eq. to '-g').
'scheme' can be { -1=backward | 0=centered | 1=forward | 2=sobel |
3=rotation-invariant
(default) | 4=deriche | 5=vanvliet }.
(no arg) compute all significant 2d/3d components.
Default value: 'scheme=3'.
-gradient_norm:
Compute gradient norm of selected images.
-gradient_orientation:
_dimension={1,2,3}
Compute N-d gradient orientation of selected images.
Default value: 'dimension=3'.
-guided (+):
[guide],radius[%]>=0,regularization[%]>=0 |
radius[%]>=0,regularization[%]>=0
Blur selected images by guided image filtering.
If a guide image is provided, it is used to drive the smoothing process.
A guide image must be of the same xyz-size as the selected images.
This command implements the filtering algorithm described in:
He, Kaiming; Sun, Jian; Tang, Xiaoou, "Guided Image Filtering,"
Pattern Analysis and Machine
Intelligence,
IEEE Transactions on , vol.35, no.6, pp.1397,1409, June 2013
-haar:
scale>0
Compute the direct haar multiscale wavelet transform of selected images.
-heat_flow:
_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }
Apply iterations of the heat flow on selected images.
Default values: 'nb_iter=10', 'dt=30' and 'keep_sequence=0'.
-hessian (+):
{ xx | xy | xz | yy | yz | zz }...{ xx | xy | xz | yy | yz | zz } |
(no arg)
Compute the hessian components (second derivatives) of selected images.
(no arg) compute all significant components.
-idct:
_{ x | y | z }...{ x | y | z } |
(no arg)
Compute the inverse discrete cosine transform of selected images,
optionally along the specified axes only.
Default values: (no arg)
-iee:
Compute gradient-orthogonal-directed 2nd derivative of image(s).
-ifft (+):
_{ x | y | z }...{ x | y | z }
Compute the inverse fourier transform (real and imaginary parts) of selected
images.
optionally along the specified axes only.
-ihaar:
scale>0
Compute the inverse haar multiscale wavelet transform of selected images.
-inn:
Compute gradient-directed 2nd derivative of image(s).
-inpaint (+):
[mask] |
[mask],0,_fast_method |
[mask],_patch_size>=1,_lookup_size>=1,_lookup_factor>=0,_lookup_increment!=0,
_blend_size>=0,0<=_blend_threshold<=1,_blend_decay>=0,_blend_scales>=1,
_is_blend_outer={ 0 | 1 }
Inpaint selected images by specified mask.
If no patch size (or 0) is specified, inpainting is done using a fast average
or median
algorithm.
Otherwise, it used a patch-based reconstruction method, that can be very time
consuming.
'fast_method' can be { 0=low-connectivity average | 1=high-connectivity
average |
2=low-connectivity median | 3=high-connectivity median }.
Default values: 'patch_size=0', 'fast_method=1', 'lookup_size=22',
'lookup_factor=0.5',
'lookup_increment=1', 'blend_size=0', 'blend_threshold=0',
'blend_decay=0.05',
'blend_scales=10' and 'is_blend_outer=1'.
-inpaint_flow:
[mask],_nb_global_iter>=0,_nb_local_iter>=0,_dt>0,_alpha>=0,_sigma>=0
Apply iteration of the inpainting flow on selected images.
Default values: 'nb_global_iter=4', 'nb_global_iter=15', 'dt=10', 'alpha=1'
and 'sigma=3'.
-inpaint_holes:
maximal_area[%]>=0,_tolerance>=0,_is_high_connectivity={ 0 | 1 }
Inpaint all connected regions having an area less than specified value.
Default values: 'maximal_area=4', 'tolerance=0' and
'is_high_connectivity=0'.
-inpaint_morpho:
[mask]
Inpaint selected images by specified mask using morphological operators.
-inpaint_patchmatch:
[mask],_nb_scales={ 0=auto | >0
},_patch_size>0,_nb_iterations_per_scale>0,
_blend_size>=0,_allow_outer_blending={ 0 | 1 },_is_already_initialized={ 0
| 1 }
Inpaint selected images by specified binary mask, using a multi-scale
patchmatch algorithm.
Default values: 'nb_scales=0', 'patch_size=9', 'nb_iterations_per_scale=10',
'blend_size=5',
'allow_outer_blending=1' and 'is_already_initialized=0'.
-inpaint_diffusion:
[mask],_nb_scales[%]>=0,_diffusion_type={ 0=isotropic |
1=delaunay-oriented |
2=edge-oriented },_diffusion_iter>=0
Inpaint selected images by specified mask using a multiscale
transport-diffusion algorithm.
Default values: 'nb_scales=75%', 'diffusion_type=1' and
'diffusion_iter=20'.
-kuwahara:
size>0
Apply Kuwahara filter of specified size on selected images.
-laplacian:
Compute Laplacian of selected images.
-lic:
_amplitude>0,_channels>0
Render LIC representation of selected vector fields.
Default values: 'amplitude=30' and 'channels=1'.
-map_tones:
_threshold>=0,_gamma>=0,_smoothness>=0,nb_iter>=0
Apply tone mapping operator on selected images, based on Poisson equation.
Default values: 'threshold=0.1', 'gamma=0.8', 'smoothness=0.5' and
'nb_iter=30'.
-map_tones_fast:
_radius[%]>=0,_power>=0
Apply fast tone mapping operator on selected images.
Default values: 'radius=3%' and 'power=0.3'.
-meancurvature_flow:
_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }
Apply iterations of the mean curvature flow on selected images.
Default values: 'nb_iter=10', 'dt=30' and 'keep_sequence=0'.
-median (+):
size>=0,_threshold>0
Apply (opt. thresholded) median filter on selected images with structuring
element size x size.
-nlmeans:
[guide],_patch_radius>0,_spatial_bandwidth>0,_tonal_bandwidth>0,
_patch_measure_command |
_patch_radius>0,_spatial_bandwidth>0,_tonal_bandwidth>0,_patch_measure_command
Apply non local means denoising of Buades et al, 2005. on selected images.
The patch is a gaussian function of 'std _patch_radius'.
The spatial kernel is a rectangle of radius 'spatial_bandwidth'.
The tonal kernel is exponential (exp(-d^2/_tonal_bandwidth^2))
with d the euclidiean distance between image patches.
Default values: 'patch_radius=4', 'spatial_bandwidth=4', 'tonal_bandwidth=10'
and
'patch_measure_command=-norm'.
-nlmeans_core:
_reference_image,_scaling_map,_patch_radius>0,_spatial_bandwidth>0
Apply non local means denoising using a image for weigth and a map for
scaling
-normalize_local:
_amplitude>=0,_radius>0,_n_smooth>=0[%],_a_smooth>=0[%],_is_cut={
0 | 1 },
_min=0,_max=255
Normalize selected images locally.
Default values: 'amplitude=3', 'radius=16', 'n_smooth=4%', 'a_smooth=2%',
'is_cut=1', 'min=0'
and 'max=255'.
-normalized_cross_correlation:
[mask]
Compute normalized cross-correlation of selected images with specified
mask.
-peronamalik_flow:
K_factor>0,_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }
Apply iterations of the Perona-Malik flow on selected images.
Default values: 'K_factor=20', 'nb_iter=5', 'dt=5' and 'keep_sequence=0'.
-phase_correlation:
[destination]
Estimate translation vector between selected source images and specified
destination.
-pde_flow:
_nb_iter>=0,_dt,_velocity_command,_keep_sequence={ 0 | 1 }
Apply iterations of a generic PDE flow on selected images.
Default values: 'nb_iter=10', 'dt=30', 'velocity_command=laplacian' and
'keep_sequence=0'.
-periodize_poisson:
Periodize selected images using a Poisson solver in Fourier space.
-red_eye:
0<=_threshold<=100,_smoothness>=0,0<=attenuation<=1
Attenuate red-eye effect in selected images.
Default values: 'threshold=75', 'smoothness=3.5' and 'attenuation=0.1'.
-remove_hotpixels:
_mask_size>0, _threshold[%]>0
Remove hot pixels in selected images.
Default values: 'mask_size=3' and 'threshold=10%'.
-remove_pixels:
number_of_pixels[%]>=0
Remove specified number of pixels (i.e. set them to 0) from the set of
non-zero pixels in
selected images.
-rolling_guidance:
std_variation_s[%]>=0,std_variation_r[%]>=0,_precision>=0
Apply the rolling guidance filter on selected image.
Rolling guidance filter is a fast image abstraction filter, described in:
"Rolling Guidance Filter", Qi Zhang Xiaoyong, Shen Li, Xu Jiaya
Jia, ECCV'2014.
Default values: 'std_variation_s=4', 'std_variation_r=10' and
'precision=0.5'.
-sharpen (+):
amplitude>=0 |
amplitude>=0,edge>=0,_alpha,_sigma
Sharpen selected images by inverse diffusion or shock filters methods.
'edge' must be specified to enable shock-filter method.
Default values: 'alpha=0' and 'sigma=0'.
-smooth (+):
amplitude>=0,_sharpness>=0,_anisotropy,_alpha,_sigma,_dl>0,_da>0,_precision>0,
interpolation,_fast_approx={ 0 | 1 } |
nb_iterations>=0,_sharpness>=0,_anisotropy,_alpha,_sigma,_dt>0,0 |
[tensor_field],_amplitude>=0,_dl>0,_da>0,_precision>0,_interpolation,
_fast_approx={ 0 | 1 } |
[tensor_field],_nb_iters>=0,_dt>0,0
Smooth selected images anisotropically using diffusion PDE's, with specified
field of
diffusion tensors.
'anisotropy' must be in [0,1].
'interpolation' can be { 0=nearest | 1=linear | 2=runge-kutta }.
Default values: 'sharpness=0.7', 'anisotropy=0.3', 'alpha=0.6', 'sigma=1.1',
'dl=0.8', 'da=30',
'precision=2', 'interpolation=0' and 'fast_approx=1'.
-split_freq:
smoothness>0[%]
Split selected images into low and high frequency parts.
-solve_poisson:
"laplacian_command",_nb_iterations>=0,_time_step>0,_nb_scales>=0
Solve Poisson equation so that applying '-laplacian[n]' is close to the
result of
'-laplacian_command[n]'.
Solving is performed using a multi-scale gradient descent algorithm.
If 'nb_scales=0', the number of scales is automatically determined.
Default values: 'nb_iterations=60', 'dt=5' and 'nb_scales=0'.
-split_details:
_nb_scales>0,_base_scale[%]>=0,_detail_scale[%]>=0
Split selected images into 'nb_scales' detail scales.
If 'base_scale'=='detail_scale'==0, the image decomposition is done with 'a
trous' wavelets.
Otherwise, it uses laplacian pyramids with linear standard deviations.
Default values: 'nb_scales=4', 'base_scale=0' and 'detail_scale=0'.
-structuretensors (+):
_scheme={ 0=centered | 1=forward/backward }
Compute the structure tensor field of selected images.
Default value: 'scheme=1'.
-solidify:
_smoothness[%]>=0,_diffusion_type={ 0=isotropic | 1=delaunay-oriented |
2=edge-oriented },_diffusion_iter>=0
Solidify selected transparent images.
Default values: 'smoothness=75%', 'diffusion_type=1' and
'diffusion_iter=20'.
-syntexturize:
_width[%]>0,_height[%]>0
Resynthetize 'width'x'height' versions of selected micro-textures by phase
randomization.
The texture synthesis algorithm is a straightforward implementation of the
method described in :
http://www.ipol.im/pub/art/2011/ggm_rpn/
Default values: 'width=height=100%'.
-syntexturize_patchmatch:
_width[%]>0,_height[%]>0,_nb_scales>=0,_patch_size>0,_blending_size>=0,
_precision>=0
Resynthetize 'width'x'height' versions of selected micro-textures using a
patch-matching
algorithm.
If 'nbscales==0', the number of scales used is estimated from the image size.
Default values: 'width=height=100%', 'nb_scales=0', 'patch_size=7',
'blending_size=5' and
'precision=1'.
-tv_flow:
_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }
Apply iterations of the total variation flow on selected images.
Default values: 'nb_iter=10', 'dt=30' and 'keep_sequence=0'.
-unsharp:
radius[%]>=0,_amount>=0,_threshold[%]>=0
Apply unsharp mask on selected images.
Default values: 'amount=2' and 'threshold=0'.
-unsharp_octave:
_nb_scales>0,_radius[%]>=0,_amount>=0,threshold[%]>=0
Apply octave sharpening on selected images.
Default values: 'nb_scales=4', 'radius=1', 'amount=2' and 'threshold=0'.
-vanvliet (+):
std_variation>=0[%],order={ 0 | 1 | 2 | 3 },axis={ x | y | z | c
},_boundary
Apply Vanvliet recursive filter on selected images, along specified axis and
with
specified standard deviation, order and boundary conditions.
'boundary' can be { 0=dirichlet | 1=neumann }.
Default value: 'boundary=1'.
-watermark_fourier:
text,_size>0
Add a textual watermark in the frequency domain of selected images.
Default value: 'size=33'.
-watershed (+):
[priority_image],_is_high_connectivity={ 0 | 1 }
Compute the watershed transform of selected images.
Default value: 'is_high_connectivity=1'.
** Features extraction:
-area:
tolerance>=0,is_high_connectivity={ 0 | 1 }
Compute area of connected components in selected images.
Default values: 'is_high_connectivity=0'.
-area_fg:
tolerance>=0,is_high_connectivity={ 0 | 1 }
Compute area of connected components for non-zero values in selected images.
Similar to '-area' except that 0-valued pixels are not considered.
Default values: 'is_high_connectivity=0'.
-at_line:
x0[%],y0[%],z0[%],x1[%],y1[%],z1[%]
Retrieve pixels of the selected images belonging to the specified line
(x0,y0,z0)-(x1,y1,z1).
-barycenter:
Compute the barycenter vector of pixel values.
-detect_skin:
0<=tolerance<=1,_skin_x,_skin_y,_skin_radius>=0
Detect skin in selected color images and output an appartenance probability
map.
Detection is performed using CbCr chromaticity data of skin pixels.
If arguments 'skin_x', 'skin_y' and 'skin_radius' are provided, skin pixels
are learnt
from the sample pixels inside the circle located at ('skin_x','skin_y') with
radius
'skin_radius'.
Default value: 'tolerance=0.5' and 'skin_x=skiny=radius=-1'.
-displacement (+):
[source_image],_smoothness,_precision>=0,_nb_scales>=0,_iteration_max>=0,
is_backward={ 0 | 1 },_[guide]
Estimate displacement field between specified source and selected target
images.
If 'smoothness>=0', regularization type is set to isotropic, else to
anisotropic.
If 'nbscales==0', the number of scales used is estimated from the image size.
Default values: 'smoothness=0.1', 'precision=5', 'nb_scales=0',
'iteration_max=10000',
'is_backward=1' and '[guide]=(unused)'.
-distance (+):
isovalue[%],_metric |
isovalue[%],[metric],_method
Compute the unsigned distance function to specified isovalue, opt. according
to a custom metric.
'metric' can be { 0=chebyshev | 1=manhattan | 2=euclidean |
3=squared-euclidean }.
'method' can be { 0=fast-marching | 1=low-connectivity dijkstra |
2=high-connectivity dijkstra |
3=1+return path | 4=2+return path }.
Default value: 'metric=2' and 'method=0'.
-float2fft8:
Convert selected float-valued images to 8bits fourier representations.
-fft82float:
Convert selected 8bits fourier representations to float-valued images.
-fftpolar:
Compute fourier transform of selected images, as centered magnitude/phase
images.
-histogram (+):
_nb_levels>0[%],_value0[%],_value1[%]
Compute the histogram of selected images.
If value range is set, the histogram is estimated only for pixels in the
specified
value range. Argument 'value1' must be specified if 'value0' is set.
Default values: 'nb_levels=256', 'value0=0%' and 'value1=100%'.
-histogram_nd:
nb_levels>0[%],_value0[%],_value1[%]
Compute the 1d,2d or 3d histogram of selected multi-channels images (having
1,2 or 3 channels).
If value range is set, the histogram is estimated only for pixels in the
specified
value range.
Default values: 'value0=0%' and 'value1=100%'.
-histogram_cumul:
_nb_levels>0,_is_normalized={ 0 | 1 },_val0[%],_val1[%]
Compute cumulative histogram of selected images.
Default values: 'nb_levels=256', 'is_normalized=0' and 'val0=val1=0'.
-histogram_pointwise:
nb_levels>0[%],_value0[%],_value1[%]
Compute the histogram of each vector-valued point of selected images.
If value range is set, the histogram is estimated only for values in the
specified
value range.
Default values: 'value0=0%' and 'value1=100%'.
-hough:
_width>0,_height>0,gradient_norm_voting={ 0 | 1 }
Compute hough transform (theta,rho) of selected images.
Default values: 'width=512', 'height=width' and 'gradient_norm_voting=1'.
-ifftpolar:
Compute inverse fourier transform of selected images, from centered
magnitude/phase images.
-isophotes:
_nb_levels>0
Render isophotes of selected images on a transparent background.
Default value: 'nb_levels=64'
-label (+):
_tolerance>=0,is_high_connectivity={ 0 | 1 }
Label connected components in selected images.
Default values: 'tolerance=0' and 'is_high_connectivity=0'.
-label_fg:
tolerance>=0,is_high_connectivity={ 0 | 1 }
Label connected components for non-zero values (foreground) in selected
images.
Similar to '-label' except that 0-valued pixels are not labeled.
Default value: 'is_high_connectivity=0'.
-max_patch:
_patch_size>=1
Return locations of maximal values in local patch-based neighborhood of given
size for selected
images.
Default value: 'patch_size=16'.
-min_patch:
_patch_size>=1
Return locations of minimal values in local patch-based neighborhood of given
size for selected
images.
Default value: 'patch_size=16'.
-minimal_path:
x0[%]>=0,y0[%]>=0,z0[%]>=0,x1[%]>=0,y1[%]>=0,z1[%]>=0,_is_high_connectivity={
0
| 1 }
Compute minimal path between two points on selected potential maps.
Default value: 'is_high_connectivity=0'.
-mse (+):
Compute MSE (Mean-Squared Error) matrix between selected images.
-patches:
patch_width>0,patch_height>0,patch_depth>0,x0,y0,z0,_x1,_y1,_z1,...,_xN,_yN,_zN
Extract N+1 patches from selected images, centered at specified
locations.
-patchmatch (+):
[patch_image],patch_width>=1,_patch_height>=1,_patch_depth>=1,_nb_iterations>=0,
_nb_randoms>=0,_output_score={ 0 | 1 },_[guide]
Estimate correspondence map between selected images and specified patch
image, using
the patchmatch algorithm, as described in the paper :
"PatchMatch: A Randomized Correspondence Algorithm for Structural Image
Editing", by
Connelly Barnes, Eli Shechtman, Adam Finkelstein, Dan B Goldman(2009).
Each pixel of the returned correspondence map gives the location (p,q) of the
closest patch in
the specified patch image. If 'output_score=1', the third channel gives the
corresponding
matching score for each patch as well.
Default values: 'patch_height=patch_width', 'patch_depth=1',
'nb_iterations=5', 'nb_randoms=5',
'output_score=0' and 'guide=(undefined)'.
-plot2value:
Retrieve values from selected 2d graph plots.
-pointcloud:
_type = { -X=-X-opacity | 0=binary | 1=cumulative | 2=label
},_width,_height>0,
_depth>0
Convert a Nx1, Nx2, Nx3 or NxM image as a point cloud in a 1d/2d or 3d binary
image.
If 'M'>3, the 3-to-M lines sets the (M-3)-dimensional color at each point.
Parameters 'width','height' and 'depth' are related to the size of the final
image :
- If set to 0, the size is automatically set along the specified axis.
- If set to N>0, the size along the specified axis is N.
- If set to N<0, the size along the specified axis is at most N.
Points with coordinates that are negative or higher than specified
('width','height','depth')
are not plotted.
Default values: 'type=0' and 'max_width=max_height=max_depth=0'.
-psnr:
_max_value
Compute PSNR (Peak Signal-to-Noise Ratio) matrix between selected images.
Default value: 'max_value=255'.
-segment_watershed:
_threshold>=0
Apply watershed segmentation on selected images.
Default values: 'threshold=2'.
-skeleton:
_smoothness[%]>=0
Compute skeleton of binary shapes using distance transform.
Default value: 'smoothness=0'.
-ssd_patch:
[patch],_use_fourier={ 0 | 1 },_boundary_conditions={ 0=dirichlet | 1=neumann
}
Compute fields of SSD between selected images and specified patch.
Argument 'boundary_conditions' is valid only when 'use_fourier=0'.
Default value: 'use_fourier=0' and 'boundary_conditions=0'.
-thinning:
Compute skeleton of binary shapes using morphological thinning
(This is a quite slow iterative proces)
-tones:
N>0
Get N tones masks from selected images.
-topographic_map:
_nb_levels>0,_smoothness
Render selected images as topographic maps.
Default values: 'nb_levels=16' and 'smoothness=2'.
-variance_patch:
_patch_size>=1
Compute variance of each images patch centered at (x,y), in selected images.
Default value: 'patch_size=16'
** Image drawing:
-arrow:
x0[%],y0[%],x1[%],y1[%],_thickness[%]>=0,_head_length[%]>=0,
_head_thickness[%]>=0,_opacity,_pattern,_color1,...
Draw specified arrow on selected images.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified. If a pattern is specified, the arrow is
drawn outlined instead of filled.
Default values: 'thickness=1%', 'head_length=10%', 'head_thickness=3%',
'opacity=1',
'pattern=(undefined)' and 'color1=0'.
-axes:
x0,x1,y0,y1,_font_height>=0,_opacity,_pattern,_color1,...
Draw xy-axes on selected images.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified.
To draw only one x-axis at row Y, set both 'y0' and 'y1' to Y.
To draw only one y-axis at column X, set both 'x0' and 'x1' to X.
Default values: 'font_height=14', 'opacity=1', 'pattern=(undefined)' and
'color1=0'.
-ball:
_size>0,
_R,_G,_B,0<=_specular_light<=8,0<=_specular_size<=8,_shadow>=0
Input a 2d RGBA colored ball sprite.
Default values: 'size=64', 'R=255', 'G=R', 'B=R', 'specular_light=0.8',
'specular_size=1' and
'shading=1.5'.
-chessboard:
size1>0,_size2>0,_offset1,_offset2,_angle,_opacity,_color1,...,_color2,...
Draw chessboard on selected images.
Default values: 'size2=size1', 'offset1=offset2=0', 'angle=0', 'opacity=1',
'color1=0' and
'color2=255'.
-cie1931:
Draw CIE-1931 chromaticity diagram on selected images.
-circle:
x[%],y[%],R[%],_opacity,_pattern,_color1,...
Draw specified colored circle on selected images.
A radius of '100%' stands for 'sqrt(width^2+height^2)'.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified. If a pattern is specified, the circle is
drawn outlined instead of filled.
Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.
-ellipse (+):
x[%],y[%],R[%],r[%],_angle,_opacity,_pattern,_color1,...
Draw specified colored ellipse on selected images.
A radius of '100%' stands for 'sqrt(width^2+height^2)'.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified. If a pattern is specified, the ellipse is
drawn outlined instead of filled.
Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.
-flood (+):
x[%],_y[%],_z[%],_tolerance>=0,_is_high_connectivity={ 0 | 1
},_opacity,_color1,
...
Flood-fill selected images using specified value and tolerance.
Default values: 'y=z=0', 'tolerance=0', 'is_high_connectivity=0', 'opacity=1'
and 'color1=0'.
-gaussian:
_sigma1[%],_sigma2[%],_angle
Draw a centered gaussian on selected images, with specified standard
deviations and orientation.
Default values: 'sigma1=3', 'sigma2=sigma1' and 'angle=0'.
-graph (+):
[function_image],_plot_type,_vertex_type,_ymin,_ymax,_opacity,_pattern,_color1,.
.. |
'formula',_resolution>=0,_plot_type,_vertex_type,_xmin,xmax,_ymin,_ymax,
_opacity,_pattern,_color1,...
Draw specified function graph on selected images.
'plot_type' can be { 0=none | 1=lines | 2=splines | 3=bar }.
'vertex_type' can be { 0=none | 1=points | 2,3=crosses | 4,5=circles |
6,7=squares }.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified.
Default values: 'plot_type=1', 'vertex_type=1', 'ymin=ymax=0 (auto)',
'opacity=1',
'pattern=(undefined)'
and 'color1=0'.
-grid:
size_x[%]>=0,size_y[%]>=0,_offset_x[%],_offset_y[%],_opacity,_pattern,_color1,..
.
Draw xy-grid on selected images.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified.
Default values: 'offset_x=offset_y=0', 'opacity=1', 'pattern=(undefined)' and
'color1=0'.
-image (+):
[sprite],_x[%],_y[%],_z[%],_c[%],_opacity,_[sprite_mask],_max_opacity_mask
Draw specified sprite image on selected images.
(eq. to '-j').
Default values: 'x=y=z=c=0', 'opacity=1', 'sprite_mask=(undefined)' and
'max_opacity_mask=1'.
-line (+):
x0[%],y0[%],x1[%],y1[%],_opacity,_pattern,_color1,...
Draw specified colored line on selected images.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified.
Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.
-mandelbrot (+):
z0r,z0i,z1r,z1i,_iteration_max>=0,_is_julia={ 0 | 1
},_c0r,_c0i,_opacity
Draw mandelbrot/julia fractal on selected images.
Default values: 'iteration_max=100', 'is_julia=0', 'c0r=c0i=0' and
'opacity=1'.
-marble:
_image_weight,_pattern_weight,_angle,_amplitude,_sharpness>=0,_anisotropy>=0,
_alpha,_sigma,_cut_low>=0,_cut_high>=0
Render marble like pattern on selected images.
Default values: 'image_weight=0.2', 'pattern_weight=0.1', 'angle=45',
'amplitude=0',
'sharpness=0.4', 'anisotropy=0.8',
'alpha=0.6', 'sigma=1.1' and 'cut_low=cut_high=0'.
-maze:
_width>0,_height>0,_cell_size>0
Input maze with specified size.
-maze_mask:
_cellsize>0
Input maze according to size and shape of selected mask images.
Mask may contain disconnected shapes.
-object3d (+):
[object3d],_x[%],_y[%],_z,_opacity,_rendering_mode,_is_double_sided={ 0 | 1
},
_is_zbuffer={ 0 | 1 },_focale,_light_x,_light_y,_light_z,_specular_lightness,
_specular_shininess
Draw specified 3d object on selected images.
(eq. to '-j3d').
'rendering_mode' can be { 0=dots | 1=wireframe | 2=flat | 3=flat-shaded |
4=gouraud-shaded |
5=phong-shaded }.
Default values: 'x=y=z=0', 'opacity=1' and 'is_zbuffer=1'. All other
arguments take their
default values from the 3d environment variables.
-pack_sprites:
_nb_scales>=0,0<=_min_scale<=100,_allow_rotation={ 0=0 deg. | 1=180
deg. | 2=90
deg. | 3=any },_spacing,_precision>=0,max_iterations>=0
Try to randomly pack as many sprites as possible onto the 'empty' areas of an
image.
Sprites can be eventually rotated and scaled during the packing process.
First selected image is the canvas that will be filled with the sprites.
Its last channel must be a binary mask whose zero values represent potential
locations for
drawing the sprites.
All other selected images represent the sprites considered for packing.
Their last channel must be a binary mask that represents the sprite shape
(i.e. a 8-connected
component).
The order of sprite packing follows the order of specified sprites in the
image list.
Sprite packing is done on random locations and iteratively with decreasing
scales.
'nb_scales' sets the number of decreasing scales considered for all specified
sprites to be
packed.
'min_scale' (in %) sets the minimal size considered for packing (specified as
a percentage of
the original sprite size).
'spacing' can be positive or negative.
'precision' tells about the desired number of failed trials before ending the
filling process.
Default values: 'nb_scales=5', 'min_scale=25', 'allow_rotation=3',
'spacing=1', 'precision=7'
and 'max_iterations=256'.
-piechart:
label_height>=0,label_R,label_G,label_B,"label1",value1,R1,G1,B1,...,"labelN",
valueN,RN,GN,BN
Draw pie chart on selected (RGB) images.
-plasma (+):
_alpha,_beta,_scale>=0
Draw a random colored plasma fractal on selected images.
This command implements the so-called 'Diamond-Square' algorithm.
Default values: 'alpha=1', 'beta=1' and 'scale=8'.
-point (+):
x[%],y[%],_z[%],_opacity,_color1,...
Set specified colored pixel on selected images.
Default values: 'z=0', 'opacity=1' and 'color1=0'.
-polka_dots:
diameter>=0,_density,_offset1,_offset2,_angle,_aliasing,_shading,_opacity,
_color,...
Draw dots pattern on selected images.
Default values: 'density=20', 'offset1=offset2=50', 'angle=0', 'aliasing=10',
'shading=1',
'opacity=1' and 'color=255'.
-polygon (+):
N>=1,x1[%],y1[%],...,xN[%],yN[%],_opacity,_pattern,_color1,...
Draw specified colored N-vertices polygon on selected images.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified. If a pattern is specified, the polygon is
drawn outlined instead of filled.
Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.
-quiver:
[function_image],_sampling[%]>0,_factor>=0,_is_arrow={ 0 | 1
},_opacity,_color1,
...
Draw specified 2d vector/orientation field on selected images.
Default values: 'sampling=5%', 'factor=1', 'is_arrow=1', 'opacity=1',
'pattern=(undefined)'
and 'color1=0'.
-rectangle:
x0[%],y0[%],x1[%],y1[%],_opacity,_pattern,_color1,...
Draw specified colored rectangle on selected images.
'pattern' is an hexadecimal number starting with '0x' which can be omitted
even if a color is specified. If a pattern is specified, the rectangle is
drawn outlined instead of filled.
Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.
-rorschach:
'smoothness[%]>=0','mirroring={ 0=none | 1=x | 2=y | 3=xy }
Render rorschach-like inkblots on selected images.
Default values: 'smoothness=5%' and 'mirroring=1'.
-sierpinski:
recursion_level>=0
Draw Sierpinski triangle on selected images.
Default value: 'recursion_level=7'.
-spiralbw:
Draw (squared) spiral on selected images.
-spline:
x0[%],y0[%],u0[%],v0[%],x1[%],y1[%],u1[%],v1[%],_nb_vertices>=2,_opacity,
_color1,...
Draw specified colored spline curve on selected images (cubic hermite
spline).
Default values: 'nb_vertices=256', 'opacity=1' and 'color1=0'.
-tetraedron_shade:
x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3,R0,G0,B0,...,R1,G1,B1,...,R2,G2,B2,...,R3,
G3,B3,...
Draw tetraedron with interpolated colors on selected (volumetric) images.
-text (+):
text,_x[%],_y[%],_font_height[%]>=0,_opacity,_color1,...
Draw specified colored text string on selected images.
(eq. to '-t').
Exact pre-defined sizes are '13','23','53' and '103'. Using these sizes
ensures you draw binary
letters without anti-aliasing.
Any other font size is interpolated from an exact size (the upper when
possible).
Specifying an empty target image resizes it to new dimensions such that the
image contains
the entire text string.
Default values: 'opacity=1' and 'color1=0'.
-text_outline:
text,_x[%],_y[%],_font_height>0,_outline>=0,_opacity,_color1,...
Draw specified colored and outlined text string on selected images.
Default values: 'x=y=2', 'font_height=13', 'outline=2', 'opacity=1' and
'color1=255'.
-triangle_shade:
x0,y0,x1,y1,x2,y2,R0,G0,B0,...,R1,G1,B1,...,R2,G2,B2,...
Draw triangle with interpolated colors on selected images.
-truchet:
_scale>0,_radius>=0,_pattern_type={ 0=straight | 1=curved }
Fill selected images with random truchet patterns.
Default values: 'scale=32', 'radius=5' and 'pattern_type=1'.
-turbulence:
_radius>0,_octaves={1,2,3...,12},_alpha>0,_difference={-10,10},_mode={0,1,2,3}
Render fractal noise or turbulence on selected images.
Default values: 'radius=32', 'octaves=6', 'alpha=3', 'difference=0' and
'mode=0'.
-yinyang:
Draw a yin-yang symbol on selected images.
** Matrix computation:
-dijkstra (+):
starting_node>=0,ending_node>=0
Compute minimal distances and pathes from specified adjacency matrices by the
Dijkstra
algorithm.
-eigen (+):
Compute the eigenvalues and eigenvectors of selected symmetric matrices or
matrix fields.
If one selected image has 3 or 6 channels, it is regarded as a field of 2x2
or 3x3 symmetric
matrices,
whose eigen elements are computed at each point of the field.
-invert (+):
Compute the inverse of the selected matrices.
-solve (+):
[image]
Solve linear system AX = B for selected B-matrices and specified A-matrix.
If the system is under- or over-determined, the least square solution is
returned.
-svd (+):
Compute SVD decomposition of selected matrices.
-transpose:
Transpose selected matrices.
-trisolve (+):
[image]
Solve tridiagonal system AX = B for selected B-vectors and specified
tridiagonal A-matrix.
Tridiagonal matrix must be stored as a 3 column vector, where 2nd column
contains the
diagonal coefficients, while 1st and 3rd columns contain the left and right
coefficients.
** 3d rendering:
-add3d (+):
tx,_ty,_tz |
[object3d] |
(no arg)
Shift selected 3d objects with specified displacement vector, or merge them
with specified
3d object, or merge all selected 3d objects together.
(eq. to '-+3d').
Default values: 'ty=tz=0'.
-animate3d:
_width>0,_height>0,_angle_dx,_angle_dy,_angle_dz,_zoom_factor>=0,_filename
Animate selected 3d objects in a window.
If argument 'filename' is provided, each frame of the animation is saved as a
numbered filename.
Default values: 'width=640', 'height=480', 'angle_dx=0', 'angle_dy=1',
'angle_dz=0',
'zoom_factor=1' and 'filename=(undefined)'.
-apply_camera3d:
pos_x,pos_y,pos_z,target_x,target_y,target_z,up_x,up_y,up_z
Apply 3d camera matrix to selected 3d objects.
Default values: 'target_x=0', 'target_y=0', 'target_z=0', 'up_x=0', 'up_y=-1'
and 'up_z=0'.
-array3d:
size_x>=1,_size_y>=1,_size_z>=1,_offset_x[%],_offset_y[%],_offset_y[%]
Duplicate a 3d object along the X,Y and Z axes.
Default values: 'size_y=1', 'size_z=1' and
'offset_x=offset_y=offset_z=100%'.
-arrow3d:
x0,y0,z0,x1,y1,z1,_radius[%]>=0,_head_length[%]>=0,_head_radius[%]>=0
Input 3d arrow with specified starting and ending 3d points.
Default values: 'radius=5%', 'head_length=25%' and 'head_radius=15%'.
-axes3d:
_size_x,_size_y,_size_z,_font_size>0,_label_x,_label_y,_label_z
Input 3d axes with specified sizes along the x,y and z orientations.
Default values: 'size_x=size_y=size_z=1', 'font_size=23', 'label_x=X',
'label_y=Y' and
'label_z=Z'.
-box3d:
_size_x,_size_y,_size_z
Input 3d box at (0,0,0), with specified geometry.
Default values: 'size_x=1' and 'size_z=size_y=size_x'.
-center3d:
Center selected 3d objects at (0,0,0).
(eq. to '-c3d').
-circle3d:
_x0,_y0,_z0,_radius>=0
Input 3d circle at specified coordinates.
Default values: 'x0=y0=z0=0' and 'radius=1'.
-circles3d:
_radius>=0,_is_filled={ 0 | 1 }
Convert specified 3d objects to sets of 3d circles with specified radius.
Default values: 'radius=1' and 'is_filled=1'.
-color3d (+):
R,_G,_B,_opacity
Set color and opacity of selected 3d objects.
(eq. to '-col3d').
Default value: 'B=G=R' and 'opacity=(undefined)'.
-colorcube3d:
Input 3d color cube.
-cone3d:
_radius,_height,_nb_subdivisions>0
Input 3d cone at (0,0,0), with specified geometry.
Default value: 'radius=1','height=1' and 'nb_subdivisions=24'.
-cubes3d:
_size>=0
Convert specified 3d objects to sets of 3d cubes with specified size.
Default value: 'size=1'.
-cup3d:
_resolution>0
Input 3d cup object.
-cylinder3d:
_radius,_height,_nb_subdivisions>0
Input 3d cylinder at (0,0,0), with specified geometry.
Default value: 'radius=1','height=1' and 'nb_subdivisions=24'.
-delaunay3d:
Generate 3d delaunay triangulations from selected images.
One assumes that the selected input images are binary images containing the
set of points to
mesh.
The output 3d object is a mesh composed of non-oriented triangles.
-distribution3d:
Get 3d color distribution of selected images.
-div3d (+):
factor |
factor_x,factor_y,_factor_z
Scale selected 3d objects isotropically or anisotropically, with the inverse
of specified
factors.
(eq. to '-/3d').
Default value: 'factor_z=0'.
-double3d (+):
_is_double_sided={ 0 | 1 }
Enable/disable double-sided mode for 3d rendering.
(eq. to '-db3d').
Default value: 'is_double_sided=1'.
-elevation3d (+):
z-factor |
[elevation_map] |
'formula' |
(no arg)
Build 3d elevation of selected images, with a specified elevation map.
When invoked with (no arg) or 'z-factor', the elevation map is computed as
the pointwise L2
norm of the
pixel values. Otherwise, the elevation map is taken from the specified image
or formula.
-empty3d:
Input empty 3d object.
-extrude3d:
_depth>0,_resolution>0,_smoothness[%]>=0
Generate extruded 3d object from selected binary XY-profiles.
Default values: 'depth=16', 'resolution=1024' and 'smoothness=0.5%'.
-focale3d (+):
focale
Set 3d focale.
(eq. to '-f3d').
Set 'focale' to 0 to enable parallel projection (instead of perspective).
Set negative 'focale' will disable 3d sprite zooming.
Default value: 'focale=700'.
-gaussians3d:
_size>0,_opacity
Convert selected 3d objects into set of 3d gaussian-shaped sprites.
-gmic3d:
Input a 3d G'MIC logo.
-gyroid3d:
_resolution>0,_zoom
Input 3d gyroid at (0,0,0), with specified resolution.
Default values: 'resolution=32' and 'zoom=5'.
-histogram3d:
Get 3d color histogram of selected images.
-image6cube3d:
Generate 3d mapped cubes from 6-sets of selected images.
-imageblocks3d:
_maximum_elevation,_smoothness[%]>=0
Generate 3d blocks from selected images.
Transparency of selected images is taken into account.
Default values: 'maximum_elevation=10' and 'smoothness=0'.
-imagecube3d:
Generate 3d mapped cubes from selected images.
-imageplane3d:
Generate 3d mapped planes from selected images.
-imagepyramid3d:
Generate 3d mapped pyramides from selected images.
-imagerubik3d:
_xy_tiles>=1,0<=xy_shift<=100,0<=z_shift<=100
Generate 3d mapped rubik's cubes from selected images.
Default values: 'xy_tiles=3', 'xy_shift=5' and 'z_shift=5'.
-imagesphere3d:
_resolution1>=3,_resolution2>=3
Generate 3d mapped sphere from selected images.
Default values: 'resolution1=32' and 'resolutions2=16'.
-isoline3d (+):
isovalue[%] |
'formula',value,_x0,_y0,_x1,_y1,_size_x>0[%],_size_y>0[%]
Extract 3d isolines with specified value from selected images or from
specified formula.
Default values: 'x0=y0=-3', 'x1=y1=3' and 'size_x=size_y=256'.
-isosurface3d (+):
isovalue[%] |
'formula',value,_x0,_y0,_z0,_x1,_y1,_z1,_size_x>0[%],_size_y>0[%],_size_z>0[%]
Extract 3d isosurfaces with specified value from selected images or from
specified formula.
Default values: 'x0=y0=z0=-3', 'x1=y1=z1=3' and
'size_x=size_y=size_z=32'.
-label3d:
"text",font_height>=0,_opacity,_color1,...
Generate 3d text label.
Default values: 'font_height=13', 'opacity=1' and 'color=255,255,255'.
-label_points3d:
_label_size>0,_opacity
Add a numbered label to all vertices of selected 3d objects.
Default values: 'label_size=13' and 'opacity=0.8'.
-lathe3d:
_resolution>0,_smoothness[%]>=0,_max_angle>=0
Generate 3d object from selected binary XY-profiles.
Default values: 'resolution=128', 'smoothness=0.5%' and 'max_angle=361'.
-light3d (+):
position_x,position_y,position_z |
[texture] |
(no arg)
Set the light coordinates or the light texture for 3d rendering.
(eq. to '-l3d').
(no arg) resets the 3d light to default.
-line3d:
x0,y0,z0,x1,y1,z1
Input 3d line at specified coordinates.
-lissajous3d:
resolution>1,a,A,b,B,c,C
Input 3d lissajous curves
(x(t)=sin(a*t+A*2*pi),y(t)=sin(b*t+B*2*pi),z(t)=sin(c*t+C*2*pi)).
Default values: 'resolution=1024', 'a=2', 'A=0', 'b=1', 'B=0', 'c=0' and
'C=0'.
-mode3d (+):
_mode
Set static 3d rendering mode.
(eq. to '-m3d').
'mode' can be { -1=bounding-box | 0=dots | 1=wireframe | 2=flat |
3=flat-shaded |
4=gouraud-shaded | 5=phong-shaded }.");
Bounding-box mode ('mode==-1') is active only for the interactive 3d viewer.
Default value: 'mode=4'.
-moded3d (+):
_mode
Set dynamic 3d rendering mode for interactive 3d viewer.
(eq. to '-md3d').
'mode' can be { -1=bounding-box | 0=dots | 1=wireframe | 2=flat |
3=flat-shaded |
4=gouraud-shaded | 5=phong-shaded }.
Default value: 'mode=-1'.
-mul3d (+):
factor |
factor_x,factor_y,_factor_z
Scale selected 3d objects isotropically or anisotropically, with specified
factors.
(eq. to '-*3d').
Default value: 'factor_z=0'.
-normalize3d:
Normalize selected 3d objects to unit size.
(eq. to '-n3d').
-opacity3d (+):
_opacity
Set opacity of selected 3d objects.
(eq. to '-o3d').
Default value: 'opacity=1'.
-parametric3d:
_x(a,b),_y(a,b),_z(a,b),_amin,_amax,_bmin,_bmax,_res_a>0,_res_b>0,_res_x>0,
_res_y>0,_res_z>0,_smoothness>=0,_isovalue>=0
Input 3d object from specified parametric surface (x(a,b),y(a,b),z(a,b)).
Default values: 'x=(2+cos(b))*sin(a)', 'y=(2+cos(b))*cos(a)', 'c=sin(b)',
'amin=-pi',
'amax='pi', 'bmin=-pi', 'bmax='pi',
'res_a=512', 'res_b=res_a', 'res_x=64', 'res_y=res_x', 'res_z=res_y',
'smoothness=2%' and
'isovalue=10%'.
-pca_patch3d:
_patch_size>0,_M>0,_N>0,_normalize_input={ 0 | 1
},_normalize_output={ 0 | 1 },
_lambda_xy
Get 3d patch-pca representation of selected images.
The 3d patch-pca is estimated from M patches on the input image, and
displayed as a cloud of N
3d points.
Default values: 'patch_size=7', 'M=1000', 'N=3000', 'normalize_input=1',
'normalize_output=0',
and 'lambda_xy=0'.
-plane3d:
_size_x,_size_y,_nb_subdivisions_x>0,_nb_subdisivions_y>0
Input 3d plane at (0,0,0), with specified geometry.
Default values: 'size_x=1', 'size_y=size_x' and
'nb_subdivisions_x=nb_subdivisions_y=24'.
-point3d:
x0,y0,z0
Input 3d point at specified coordinates.
-pointcloud3d:
Convert selected planar or volumetric images to 3d point clouds.
-pose3d:
p1,...,p12
Apply 3d pose matrix to selected 3d objects.
-primitives3d (+):
mode
Convert primitives of selected 3d objects.
(eq. to '-p3d').
'mode' can be { 0=points | 1=segments | 2=non-textured }.
-projections3d:
_x[%],_y[%],_z[%],_is_bounding_box={ 0 | 1 }
Generate 3d xy,xz,yz projection planes from specified volumetric images.
-pyramid3d:
width,height
Input 3d pyramid at (0,0,0), with specified geometry.
-quadrangle3d:
x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3
Input 3d quadrangle at specified coordinates.
-random3d:
nb_points>=0
Input random 3d point cloud in [0,1]^3.
-reverse3d (+):
Reverse primitive orientations of selected 3d objects.
(eq. to '-rv3d').
-rotate3d (+):
u,v,w,angle
Rotate selected 3d objects around specified axis with specified angle (in
deg.).
(eq. to '-r3d').
-rotation3d:
u,v,w,angle
Input 3x3 rotation matrix with specified axis and angle (in deg).
-sierpinski3d:
_recursion_level>=0,_width,_height
Input 3d Sierpinski pyramid.
-size3d:
Return bounding box size of the last selected 3d object.
-skeleton3d:
_metric,_frame_type={ 0=squares | 1=diamonds | 2=circles | 3=auto },
_skeleton_opacity,_frame_opacity,_is_frame_wireframe={ 0 | 1 }
Build 3d skeletal structure object from 2d binary shapes located in selected
images.
'metric' can be { 0=chebyshev | 1=manhattan | 2=euclidean }.
Default values: 'metric=2', 'bones_type=3', 'skeleton_opacity=1' and
'frame_opacity=0.1'.
-snapshot3d:
_size>0,_zoom>=0,_backgroundR,_backgroundG,_backgroundB,_backgroundA |
[background_image],zoom>=0
Take 2d snapshots of selected 3d objects.
Set 'zoom' to 0 to disable object auto-scaling.
Default values: 'size=512', 'zoom=1' and '[background_image]=(default)'.
-specl3d (+):
value>=0
Set lightness of 3d specular light.
(eq. to '-sl3d').
Default value: 'value=0.15'.
-specs3d (+):
value>=0
Set shininess of 3d specular light.
(eq. to '-ss3d').
Default value: 'value=0.8'.
-sphere3d (+):
radius,_nb_recursions>=0
Input 3d sphere at (0,0,0), with specified geometry.
Default value: 'nb_recursions=3'.
-spherical3d:
_nb_azimuth>=3,_nb_zenith>=3,_radius_function(phi,theta)
Input 3d spherical object at (0,0,0), with specified geometry.
Default values: 'nb_zenith=nb_azimut=64' and
'radius_function="abs(1+0.5*cos(3*phi)*sin(4*
theta))"'.
-spline3d:
x0[%],y0[%],z0[%],u0[%],v0[%],w0[%],x1[%],y1[%],z1[%],u1[%],v1[%],w1[%],
_nb_vertices>=2
Input 3d spline with specified geometry.
Default values: 'nb_vertices=128'.
-split3d (+):
_keep_shared_data={ 0 | 1 }
Split selected 3d objects into 6 feature vectors :
{ header, sizes, vertices, primitives, colors, opacities }.
(eq. to '-s3d').
To recreate the 3d object, append these 6 images along the y-axis.
Default value: 'keep_shared_data=1'.
-sprite3d:
Convert selected images as 3d sprites.
Selected image with alpha channels are managed.
-sprites3d:
[sprite],_sprite_has_alpha_channel={ 0 | 1 }
Convert selected 3d objects as a sprite cloud.
Set 'sprite_has_alpha_channel' to 1 to make the last channel of the selected
sprite be a
transparency mask.
Default value: 'mask_has_alpha_channel=0'.
-star3d:
_nb_branches>0,0<=_thickness<=1
Input 3d star at (0,0,0), with specified geometry.
Default values: 'nb_branches=5' and 'thickness=0.38'.
-streamline3d (+):
x[%],y[%],z[%],_L>=0,_dl>0,_interpolation,_is_backward={ 0 | 1
},_is_oriented={
0 | 1 } |
'formula',x,y,z,_L>=0,_dl>0,_interpolation,_is_backward={ 0 | 1 },
_is_oriented={ 0 | 1 }
Extract 3d streamlines from selected vector fields or from specified formula.
'interpolation' can be { 0=nearest integer | 1=1st-order | 2=2nd-order |
3=4th-order }.
Default values: 'dl=0.1', 'interpolation=2', 'is_backward=0' and
'is_oriented=0'.
-sub3d (+):
tx,_ty,_tz
Shift selected 3d objects with the opposite of specified displacement vector.
(eq. to '--3d').
Default values: 'ty=tz=0'.
-superformula3d:
resolution>1,m>=1,n1,n2,n3
Input 2d superformula curve as a 3d object.
Default values: 'resolution=1024', 'm=8', 'n1=1', 'n2=5' and 'n3=8'.
-text_pointcloud3d:
_"text1",_"text2",_smoothness
Input 3d text pointcloud from the two specified strings.
Default values: 'text1="text1"', 'text2="text2"' and
'smoothness=1'.
-text3d:
text,_font_height>0,_depth>0,_smoothness
Input a 3d text object from specified text.
Default values: 'font_height=53', 'depth=10' and 'smoothness=1.5'.
-texturize3d (+):
[ind_texture],_[ind_coords]
Texturize selected 3d objects with specified texture and coordinates.
(eq. to '-t3d').
When '[ind_coords]' is omitted, default XY texture projection is performed.
Default value: 'ind_coords=(undefined)'.
-torus3d:
_radius1,_radius2,_nb_subdivisions1>2,_nb_subdivisions2>2
Input 3d torus at (0,0,0), with specified geometry.
Default values: 'radius1=1', 'radius2=0.3', 'nb_subdivisions1=24' and
'nb_subdivisions2=12'.
-triangle3d:
x0,y0,z0,x1,y1,z1,x2,y2,z2
Input 3d triangle at specified coordinates.
-volume3d:
Transform selected 3d volumetric images as 3d parallelepipedic objects.
-weird3d:
_resolution>0
Input 3d weird object at (0,0,0), with specified resolution.
Default value: 'resolution=32'.
** Program control:
-apply_parallel:
"command"
Apply specified command on each of the selected images, by parallelizing it
for all image of
the list.
(eq. to '-ap').
-apply_parallel_channels:
"command"
Apply specified command on each of the selected images, by parallelizing it
for all channel of
the images independently.
(eq. to '-apc').
-apply_parallel_overlap:
"command",overlap[%],nb_threads={ 0=auto | 1 | 2 | 4 | 8 | 16 }
Apply specified command on each of the selected images, by parallelizing it
on 'nb_threads'
overlapped sub-images.
(eq. to '-apo').
'nb_threads' must be a power of 2.
Default values: 'overlap=0','nb_threads=0'.
-apply_timeout:
"command",_timeout={ 0=no timeout | >0=with specified timeout
(in seconds) }
Apply a command with a timeout.
-check (+):
expression
Evaluate specified expression and display an error message if evaluated to
false.
If 'expression' is not evaluable, it is regarded as a filename and checked if
it exists.
-check3d (+):
_is_full_check={ 0 | 1 }
Check validity of selected 3d vector objects, and display an error message
if one of the selected image is not a valid 3d vector object.
Full 3d object check is slower but more precise.
Default value: 'is_full_check=1'.
-continue (+):
Go to end of current block 'repeat...done', 'do...while' or
'local...endlocal'.
-break (+):
Break current 'repeat...done', 'do...while' or 'local...endlocal' block.
-do (+):
Start a 'do...while' block.
-done (+):
End a 'repeat...done' block, and go to associated '-repeat' position, if
iterations remain.
-elif (+):
boolean |
filename
Start a 'elif...[else]...endif' block if previous '-if' was not verified
and test if specified boolean is true, or if specified filename exists.
'boolean' can be a float number standing for { 0=false | other=true }.
-else (+):
Execute following commands if previous '-if' or '-elif' conditions
failed.
-endif (+):
End a 'if...[elif]...[else]...endif' block.
-endlocal (+):
End a 'local...endlocal' block.
(eq. to '-endl').
-error (+):
message
Print specified error message on the standard error (stderr) and exit
interpreter, except
if error is caught by a '-onfail' command.
Command selection (if any) stands for displayed call stack subset instead of
image indices.
-exec (+):
command
Execute external command using a system call.
The status value is then set to the error code returned by the system call.
(eq. to '-x').
-if (+):
boolean |
filename
Start a 'if...[elif]...[else]...endif' block and test if specified boolean is
true,
or if specified filename exists.
'boolean' can be a float number standing for { 0=false | other=true }.
-local (+):
Start a 'local...[onfail]...endlocal' block, with selected images.
(eq. to '-l').
-mutex (+):
indice,_action={ 0=unlock | 1=lock }
Lock or unlock specified mutex for multi-threaded programming.
A locked mutex can be unlocked only by the same thread. All mutexes are
unlocked by default.
'indice' designates the mutex indice, in [0,255].
Default value: 'action=1'.
-noarg (+):
Used in a custom command, '-noarg' tells the command that its argument list
have not been used
finally, and so they must be evaluated next in the G'MIC pipeline, just as if
the custom
command takes no arguments at all.
Use this command to write a custom command which can decide if it takes
arguments or not.
-onfail (+):
Execute following commands when an error is encountered in the body of the
'local...endlocal'
block.
The status value is set with the corresponding error message.
-parallel (+):
_wait_threads,"command1","command2",...
Execute specified commands in parallel, each in a different thread.
Parallel threads share the list of images.
'wait_threads' can be { 0=when current environment ends | 1=immediately }.
Default value: 'wait_threads=1'.
-progress (+):
0<=value<=100 |
-1
Set the progress indice of the current processing pipeline.
This command is useful only when G'MIC is used by an embedding
application.
-quit (+):
Quit interpreter.
(eq. to '-q').
-repeat (+):
nb_iterations,_variable_name
Start iterations of a 'repeat...done' block.
-return (+):
Return from current custom command.
-rprogress:
0<=value<=100 | -1 |
"command",0<=value_min<=100,0<=value_max<=100
Set the progress indice of the current processing pipeline (relatively to
previously defined progress bounds), or call the specified command with
specified progress bounds.
-skip (+):
item
Do nothing but skip specified item.
-status (+):
status_string
Set the current status. Used to define a returning value in a function.
(eq. to '-u').
-while (+):
boolean |
filename
End a 'do...while' block and go back to associated '-do'
if specified boolean is true or if specified filename exists.
'boolean' can be a float number standing for { 0=false | other=true }.
** Arrays, tiles and frames:
-array:
M>0,_N>0,_expand_type={ 0=min | 1=max | 2=all }
Create MxN array from selected images.
Default values: 'N=M' and 'expand_type=0'.
-array_fade:
M>0,_N>0,0<=_fade_start<=100,0<=_fade_end<=100,_expand_type={0=min
| 1=max |
2=all}
Create MxN array from selected images.
Default values: 'N=M', 'fade_start=60', 'fade_end=90' and
'expand_type=1'.
-array_mirror:
N>=0,_dir={ 0=x | 1=y | 2=xy | 3=tri-xy },_expand_type={ 0 | 1 }
Create 2^Nx2^N array from selected images.
Default values: 'dir=2' and 'expand_type=0'.
-array_random:
Ms>0,_Ns>0,_Md>0,_Nd>0
Create MdxNd array of tiles from selected MsxNs source arrays.
Default values: 'Ns=Ms', 'Md=Ms' and 'Nd=Ns'.
-frame_blur:
_sharpness>0,_size>=0,_smoothness,_shading,_blur
Draw RGBA-colored round frame in selected images.
Default values: 'sharpness=10', 'size=30', 'smoothness=0', 'shading=1' and
'blur=3%'.
-frame_cube:
_depth>=0,_centering_x,_centering_y,_left_side={0=normal | 1=mirror-x |
2=mirror-y | 3=mirror-xy},_right_side,_lower_side,_upper_side
Insert 3d frames in selected images.
Default values: 'depth=1', 'centering_x=centering_y=0' and
'left_side=right_side,
lower_side=upper_side=0'.
-frame_fuzzy:
size_x[%]>=0,_size_y[%]>=0,_fuzzyness>=0,_smoothness[%]>=0,_R,_G,_B,_A
Draw RGBA-colored fuzzy frame in selected images.
Default values: 'size_y=size_x', 'fuzzyness=5', 'smoothness=1' and
'R=G=B=A=255'.
-frame_painting:
_size[%]>=0,0<=_contrast<=1,_profile_smoothness[%]>=0,_R,_G,_B,
_vignette_size[%]>=0,_vignette_contrast>=0,_defects_contrast>=0,
0<=_defects_density<=100,_defects_size>=0,_defects_smoothness[%]>=0,
_serial_number
Add a painting frame to selected images.
Default values: 'size=10%', 'contrast=0.4', 'profile_smoothness=6%', 'R=225',
'G=200', 'B=120',
'vignette_size=2%', 'vignette_contrast=400', 'defects_contrast=50',
'defects_density=10',
'defects_size=1', 'defects_smoothness=0.5%' and
'serial_number=123456789'.
-frame_pattern:
M>=3,_constrain_size={ 0 | 1 } |
M>=3,_[frame_image],_constrain_size={ 0 | 1 }
Insert selected pattern frame in selected images.
Default values: 'pattern=0' and 'constrain_size=0'.
-frame_round:
_sharpness>0,_size>=0,_smoothness,_shading,_R,_G,_B,_A
Draw RGBA-colored round frame in selected images.
Default values: 'sharpness=10', 'size=10', 'smoothness=0', 'shading=0' and
'R=G=B=A=255'.
-frame_seamless:
frame_size>=0,_patch_size>0,_blend_size>=0,_frame_direction={
0=inner (preserve
image size) | 1=outer }
Insert frame in selected images, so that tiling the resulting image makes
less visible seams.
Default values: 'patch_size=7', 'blend_size=5' and 'frame_direction=1'.
-frame_x:
size_x[%],_col1,...,_colN
Insert colored frame along the x-axis in selected images.
Default values: 'col1=col2=col3=255' and 'col4=255'.
-frame_xy:
size_x[%],_size_y[%],_col1,...,_colN
Insert colored frame along the x-axis in selected images.
Default values: 'size_y=size_x', 'col1=col2=col3=255' and 'col4=255'.
(eq. to '-frame').
-frame_xyz:
size_x[%],_size_y[%],_size_z[%]_col1,...,_colN
Insert colored frame along the x-axis in selected images.
Default values: 'size_y=size_x=size_z', 'col1=col2=col3=255' and
'col4=255'.
-frame_y:
size_y[%],_col1,...,_colN
Insert colored frame along the y-axis in selected images.
Default values: 'col1=col2=col3=255' and 'col4=255'.
-img2ascii:
_charset,_analysis_scale>0,_analysis_smoothness[%]>=0,_synthesis_scale>0,
_output_ascii_filename
Render selected images as binary ascii art.
This command returns the corresponding the list of widths and heights
(expressed as a number of
characters) for each selected image.
Default values: 'charset=[ascii charset]', 'analysis_scale=16',
'analysis_smoothness=20%',
'synthesis_scale=16' and '_output_ascii_filename=[undefined]'.
-imagegrid:
M>0,_N>0
Create MxN image grid from selected images.
Default value: 'N=M'.
-imagegrid_hexagonal:
_resolution>0,0<=_outline<=1
Create hexagonal grids from selected images.
Default values: 'resolution=32', 'outline=0.1' and 'is_antialiased=1'.
-imagegrid_triangular:
pattern_width>=1,_pattern_height>=1,_pattern_type,0<=_outline_opacity<=1,
_outline_color1,...
Create triangular grids from selected images.
'pattern type' can be { 0=horizontal | 1=vertical | 2=crossed | 3=cube |
4=decreasing |
5=increasing }.
Default values: 'pattern_width=24', 'pattern_height=pattern_width',
'pattern_type=0',
'outline_opacity=0.1' and 'outline_color1=0'.
-linearize_tiles:
M>0,_N>0
Linearize MxN tiles on selected images.
Default value: 'N=M'.
-map_sprites:
_nb_sprites>=1,_allow_rotation={ 0=none | 1=90 deg. | 2=180 deg. }
Map set of sprites (defined as the 'nb_sprites' latest images of the
selection) to other
selected images,
according to the luminosity of their pixel values.
-pack:
is_ratio_constraint={ 0 | 1 },_sort_criterion
Pack selected images into a single image.
The returned status contains the list of new (x,y) offsets for each input
image.
Parameter 'is_ratio_constraint' tells if the resulting image must tend to a
square image.
Default values: 'is_ratio_constraint=0' and 'sort_criterion=max(w,h)'.
-puzzle:
_width>0,_height>0,_M>=1,_N>=1,_curvature,_centering,_connectors_variability,
_resolution>=1
Input puzzle binary mask with specified size and geometry.
Default values: 'width=height=512', 'M=N=5', 'curvature=0.5',
'centering=0.5',
'connectors_variability=0.5' and 'resolution=64'.
-quadratize_tiles:
M>0,_N>0
Quadratize MxN tiles on selected images.
Default value: 'N=M'.
-rotate_tiles:
angle,_M>0,N>0
Apply MxN tiled-rotation effect on selected images.
Default values: 'M=8' and 'N=M'.
-shift_tiles:
M>0,_N>0,_amplitude
Apply MxN tiled-shift effect on selected images.
Default values: 'N=M' and 'amplitude=20'.
-taquin:
M>0,_N>0,_remove_tile={ 0=none | 1=first | 2=last | 3=random },_relief,
_border_thickness[%],_border_outline[%],_outline_color
Create MxN taquin puzzle from selected images.
Default value: 'N=M', 'relief=50', 'border_thickness=5', 'border_outline=0'
and 'remove_tile=0'.
-tunnel:
_level>=0,_factor>0,_centering_x,_centering_y,_opacity,_angle
Apply tunnel effect on selected images.
Default values: 'level=9', 'factor=80%', 'centering_x=centering_y=0.5',
'opacity=1' and
'angle=0'
** Artistic:
-boxfitting:
_min_box_size>=1,_max_box_size>=0,_initial_density>=0,_nb_attempts>=1
Apply box fitting effect on selected images, as displayed the web page:
[http://www.complexification.net/gallery/machines/boxFittingImg/]
Default values: 'min_box_size=1', 'max_box_size=0', 'initial_density=0.1' and
'nb_attempts=3'.
-brushify:
[brush],_brush_nb_sizes>=1,0<=_brush_min_size_factor<=1,
_brush_nb_orientations>=1,_brush_light_type,0<=_brush_light_strength<=1,
_brush_opacity,_painting_density[%]>=0,0<=_painting_contours_coherence<=1,
0<=_painting_orientation_coherence<=1,_painting_coherence_alpha[%]>=0,
_painting_coherence_sigma[%]>=0,_painting_primary_angle,
0<=_painting_angle_dispersion<=1
Apply specified brush to create painterly versions of specified images.
'brush_light_type' can be { 0=none | 1=flat | 2=darken | 3=lighten | 4=full
}.
Default values: 'brush_nb_sizes=3', 'brush_min_size_factor=0.66',
'brush_nb_orientations=12',
'brush_light_type=0', 'brush_light_strength=0.25', 'brush_opacity=0.8',
'painting_density=20%',
'painting_contours_coherence=0.9', 'painting_orientation_coherence=0.9',
'painting_coherence_alpha=1', 'painting_coherence_sigma=1',
'painting_primary_angle=0',
'painting_angle_dispersion=0.2'
-cartoon:
_smoothness,_sharpening,_threshold>=0,_thickness>=0,_color>=0,quantization>0
Apply cartoon effect on selected images.
Default values: 'smoothness=3', 'sharpening=150', 'threshold=20',
'thickness=0.25', 'color=1.5'
and 'quantization=8'.
-color_ellipses:
_count>0,_radius>=0,_opacity>=0
Add random color ellipses to selected images.
Default values: 'count=400', 'radius=5' and 'opacity=0.1'.
-cubism:
_density>=0,0<=_thickness<=50,_max_angle,_opacity,_smoothness>=0
Apply cubism effect on selected images.
Default values: 'density=50', 'thickness=10', 'max_angle=75', 'opacity=0.7'
and 'smoothness=0'.
-draw_whirl:
_amplitude>=0
Apply whirl drawing effect on selected images.
Default value: 'amplitude=100'.
-drawing:
_amplitude>=0
Apply drawing effect on selected images.
Default value: 'amplitude=200'.
-drop_shadow:
_offset_x[%],_offset_y[%],_smoothness[%]>=0,0<=_curvature<=1,_expand_size={
0 |
1 }
Drop shadow behind selected images.
Default values: 'offset_x=20', 'offset_y=offset_x', 'smoothness=5',
'curvature=0' and
'expand_size=1'.
-ellipsionism:
_R>0[%],_r>0[%],_smoothness>=0[%],_opacity,_outline>0,_density>0
Apply ellipsionism filter to selected images.
Default values: 'R=10', 'r=3', 'smoothness=1%', 'opacity=0.7', 'outlise=8'
and 'density=0.6'.
-fire_edges:
_edges>=0,0<=_attenuation<=1,_smoothness>=0,_threshold>=0,_nb_frames>0,
_starting_frame>=0,frame_skip>=0
Generate fire effect from edges of selected images.
Default values: 'edges=0.7', 'attenuation=0.25', 'smoothness=0.5',
'threshold=25',
'nb_frames=1', 'starting_frame=20' and 'frame_skip=0'.
-fractalize:
0<=detail_level<=1
Randomly fractalize selected images.
Default value: 'detail_level=0.8'
-glow:
_amplitude>=0
Add soft glow on selected images.
Default value: 'amplitude=1%'.
-halftone:
nb_levels>=2,_size_dark>=2,_size_bright>=2,_shape={ 0=square |
1=diamond |
2=circle | 3=inv-square | 4=inv-diamond | 5=inv-circle
},_smoothness[%]>=0
Apply halftone dithering to selected images.
Default values: 'nb_levels=5', 'size_dark=8', 'size_bright=8', 'shape=5' and
'smoothnesss=0'.
-hardsketchbw:
_amplitude>=0,_density>=0,_opacity,0<=_edge_threshold<=100,_is_fast={
0 | 1 }
Apply hard B&W sketch effect on selected images.
Default values: 'amplitude=1000', 'sampling=3', 'opacity=0.1',
'edge_threshold=20' and
'is_fast=0'.
-hearts:
_density>=0
Apply heart effect on selected images.
Default value: 'density=10'.
-houghsketchbw:
_density>=0,_radius>0,0<=_threshold<=100,0<=_opacity<=1,_votesize[%]>0
Apply hough B&W sketch effect on selected images.
Default values: 'density=8', 'radius=5', 'threshold=80', 'opacity=0.1' and
'votesize=100%'.
-lightrays:
100<=_density<=0,_center_x[%],_center_y[%],_ray_length>=0,_ray_attenuation>=0
Generate ray lights from the edges of selected images.
Defaults values : 'density=50%', 'center_x=50%', 'center_y=50%',
'ray_length=0.9' and
'ray_attenuation=0.5'.
-light_relief:
_ambient_light,_specular_lightness,_specular_size,_light_smoothness,_darkness,
_xl,_yl,_zl,_zscale,_opacity_is_heightmap={ 0 | 1 }
Apply relief light to selected images.
Default values(s) : 'ambient_light=0.3', 'specular_lightness=0.5',
'specular_size=0.2',
'darkness=0', 'xl=0.2', 'yl=zl=0.5',
'zscale=1', 'opacity=1' and 'opacity_is_heightmap=0'.
-mosaic:
0<=_density<=100
Create random mosaic from selected images.
Default values: 'density=30'.
-old_photo:
Apply old photo effect on selected images.
-pencilbw:
_size>=0,_amplitude>=0
Apply B&W pencil effect on selected images.
Default values: 'size=0.3' and 'amplitude=60'.
-pixelsort:
_ordering={ + | - },_axis={ x | y | z | xy | yx
},_[sorting_criterion],_[mask]
Apply a 'pixel sorting' algorithm on selected images, as described in the
page :
http://satyarth.me/articles/pixel-sorting/
-polaroid:
_size1>=0,_size2>=0
Create polaroid effect in selected images.
Default values: 'size1=10' and 'size2=20'.
-polygonize:
_warp_amplitude>=0,_smoothness[%]>=0,_min_area[%]>=0,_resolution_x[%]>0,
_resolution_y[%]>0
Apply polygon effect on selected images.
Default values: 'warp_amplitude=300', 'smoothness=2%', 'min_area=0.1%',
'resolution_x=resolution_y=10%'.
-poster_edges:
0<=_edge_threshold<=100,0<=_edge_shade<=100,_edge_thickness>=0,
_edge_antialiasing>=0,0<=_posterization_level<=15,_posterization_antialiasing>=0
Apply poster edges effect on selected images.
Default values: 'edge_threshold=40', 'edge_shade=5', 'edge_thickness=0.5',
'edge_antialiasing=10', 'posterization_level=12' and
'posterization_antialiasing=0'.
-poster_hope:
_smoothness>=0
Apply Hope stencil poster effect on selected images.
Default value: 'smoothness=3'.
-rodilius:
0<=_amplitude<=100,_0<=thickness<=100,_sharpness>=0,_nb_orientations>0,_offset,
_color_mode={ 0=darker | 1=brighter }
Apply rodilius (fractalius-like) filter on selected images.
Default values: 'amplitude=10', 'thickness=10', 'sharpness=400',
'nb_orientations=7',
'offset=0' and 'color_mode=1'.
-stained_glass:
_edges[%]>=0, shading>=0, is_thin_separators={ 0 | 1 }
Generate stained glass from selected images.
Default values: 'edges=40%', 'shading=0.2' and 'is_precise=0'.
-stars:
_density[%]>=0,_depth>=0,_size>0,_nb_branches>=1,0<=_thickness<=1,
_smoothness[%]>=0,_R,_G,_B,_opacity
Add random stars to selected images.
Default values: 'density=10%', 'depth=1', 'size=32', 'nb_branches=5',
'thickness=0.38',
'smoothness=0.5', 'R=G=B=200' and 'opacity=1'.
-sketchbw:
_nb_orients>0,_start_angle,_angle_range>=0,_length>=0,_threshold>=0,_opacity,
_bgfactor>=0,_density>0,_sharpness>=0,_anisotropy>=0,_smoothness>=0,
_coherence>=0,_is_boost={ 0 | 1 },_is_curved={ 0 | 1 }
Apply sketch effect to selected images.
Default values: 'nb_orients=2', 'start_angle=45', 'angle_range=180',
'length=30', 'threshold=1',
'opacity=0.03',
'bgfactor=0', 'density=0.6', 'sharpness=0.1', 'anisotropy=0.6',
'smoothness=0.25',
'coherence=1', 'is_boost=0' and 'is_curved=1'.
-sponge:
_size>0
Apply sponge effect on selected images.
Default value: 'size=13'.
-stencil:
_radius[%]>=0,_smoothness>=0,_iterations>=0
Apply stencil filter on selected images.
Default values: 'radius=3', 'smoothness=1' and 'iterations=8'.
-stencilbw:
_edges>=0,_smoothness>=0
Apply B&W stencil effect on selected images.
Default values: 'edges=15' and 'smoothness=10'.
-tetris:
_scale>0
Apply tetris effect on selected images.
Default value: 'scale=10'.
-warhol:
_M>0,_N>0,_smoothness>=0,_color>=0
Create MxN Andy Warhol-like artwork from selected images.
Default values: 'M=3', 'N=M', 'smoothness=2' and 'color=20'.
-weave:
_density>=0,0<=_thickness<=100,0<=_shadow<=100,_shading>=0,_fibers_amplitude>=0,
_fibers_smoothness>=0,_angle,-1<=_x_curvature<=1,-1<=_y_curvature<=1
Apply weave effect to the selected images.
'angle' can be { 0=0 deg. | 1=22.5 deg. | 2=45 deg. | 3=67.5 deg. }.
Default values: 'density=6', 'thickness=65', 'shadow=40', 'shading=0.5',
'fibers_amplitude=0',
'fibers_smoothness=0', 'angle=0' and 'curvature_x=curvature_y=0'
-whirls:
_texture>=0,_smoothness>=0,_darkness>=0,_lightness>=0
Add random whirl texture to selected images.
Default values: 'texture=3', 'smoothness=6', 'darkness=0.5' and
'lightness=1.8'.
** Warpings:
-deform:
_amplitude>=0
Apply random smooth deformation on selected images.
Default value: 'amplitude=10'.
-euclidean2polar:
_center_x[%],_center_y[%],_stretch_factor>0,_boundary={ 0=dirichlet |
1=neumann
| 2=periodic }
Apply euclidean to polar transform on selected images.
Default values: 'center_x=center_y=50%', 'stretch_factor=1' and
'boundary=1'.
-equirectangular2nadirzenith:
Transform selected equirectangular images to nadir/zenith rectilinear
projections.
-fisheye:
_center_x,_center_y,0<=_radius<=100,_amplitude>=0
Apply fish-eye deformation on selected images.
Default values: 'x=y=50', 'radius=50' and 'amplitude=1.2'.
-flower:
_amplitude,_frequency,_offset_r[%],_angle,_center_x[%],_center_y[%],_boundary={
0=dirichlet | 1=neumann | 2=periodic }
Apply flower deformation on selected images.
Default values: 'amplitude=30', 'frequency=6', 'offset_r=0', 'angle=0',
'center_x=center_y=50%'
and 'boundary=2'.
-kaleidoscope:
_center_x[%],_center_y[%],_radius,_angle,_boundary={ 0=dirichlet | 1=neumann
|
2=periodic }
Create kaleidoscope effect from selected images.
Default values: 'center_x=center_y=50%', 'radius=100', 'angle=30' and
'boundary=1'.
-map_sphere:
_width>0,_height>0,_radius,_dilation>0,_fading>=0,_fading_power>=0
Map selected images on a sphere.
Default values: 'width=height=512', 'radius=100', 'dilation=0.5', 'fading=0'
and
'fading_power=0.5'.
-nadirzenith2equirectangular:
Transform selected nadir/zenith rectilinear projections to equirectangular
images.
-polar2euclidean:
_center_x[%],_center_y[%],_stretch_factor>0,_boundary={ 0=dirichlet |
1=neumann
| 2=periodic }
Apply euclidean to polar transform on selected images.
Default values: 'center_x=center_y=50%', 'stretch_factor=1' and
'boundary=1'.
-raindrops:
_amplitude,_density>=0,_wavelength>=0,_merging_steps>=0
Apply raindrops deformation on selected images.
Default values: 'amplitude=80','density=0.1', 'wavelength=1' and
'merging_steps=0'.
-ripple:
_amplitude,_bandwidth,_shape={ 0=bloc | 1=triangle | 2=sine | 3=sine+ |
4=random },_angle,_offset
Apply ripple deformation on selected images.
Default values: 'amplitude=10', 'bandwidth=10', 'shape=2', 'angle=0' and
'offset=0'.
-rotoidoscope:
_center_x[%],_center_y[%],_tiles>0,_smoothness[%]>=0,_boundary={
0=dirichlet |
1=neumann | 2=periodic }
Create rotational kaleidoscope effect from selected images.
Default values: 'cx=cy=50%', 'tiles=10', 'smoothness=1' and 'boundary=1'.
-symmetrize:
_x[%],_y[%],_angle,_boundary={ 0=dirichlet | 1=neumann | 2=periodic },
_is_antisymmetry={ 0 | 1 },_swap_sides={ 0 | 1 }
Symmetrize selected image regarding specified axis.
Default values: 'x=y=50%', 'angle=90', 'boundary=1', 'is_antisymmetry=0' and
'swap_sides=0'.
-transform_polar:
"expr_radius",_"expr_angle",_center_x[%],_center_y[%],_boundary={
0=dirichlet |
1=neumann }
Apply user-defined transform on polar representation of selected images.
Default values: 'expr_radius=R-r', 'expr_rangle=a', 'center_x=center_y=50%'
and 'boundary=1'.
-twirl:
_amplitude,_center_x[%],_center_y[%],_boundary={ 0=dirichlet | 1=neumann |
2=periodic }
Apply twirl deformation on selected images.
Default values: 'amplitude=1', 'center_x=center_y=50%' and 'boundary=1'.
-warp_perspective:
_x-angle,_y-angle,_zoom>0,_x-center,_y-center,_boundary={ 0=dirichlet |
1=neumann | 2=periodic }
Warp selected images with perspective deformation.
Default values: 'x-angle=1.5', 'y-angle=0', 'zoom=1', 'x-center=y-center=50'
and 'boundary=2'.
-water:
_amplitude,_smoothness>=0,_angle
Apply water deformation on selected images.
Default values: 'amplitude=30', 'smoothness=1.5' and 'angle=45'.
-wave:
_amplitude>=0,_frequency>=0,_center_x,_center_y
Apply wave deformation on selected images.
Default values: 'amplitude=4', 'frequency=0.4' and
'center_x=center_y=50'.
-wind:
_amplitude>=0,_angle,0<=_attenuation<=1,_threshold
Apply wind effect on selected images.
Default values: 'amplitude=20', 'angle=0', 'attenuation=0.7' and
'threshold=20'.
-zoom:
_factor,_cx,_cy,_cz,_boundary={ 0=dirichlet | 1=neumann | 2=periodic }
Apply zoom factor to selected images.
Default values: 'factor=1', 'cx=cy=cz=0.5' and 'boundary=0'.
** Degradations:
-cracks:
0<=_density<=100,_is_relief={ 0 | 1 },_opacity,_color1,...
Draw random cracks on selected images with specified color.
Default values: 'density=25', 'is_relief=0', 'opacity=1' and 'color1=0'.
-light_patch:
_density>0,_darkness>=0,_lightness>=0
Add light patches to selected images.
Default values: 'density=10', 'darkness=0.9' and 'lightness=1.7'.
-noise_hurl:
_amplitude>=0
Add hurl noise to selected images.
Default value: 'amplitude=10'.
-pixelize:
_scale_x>0,_scale_y>0,_scale_z>0
Pixelize selected images with specified scales.
Default values: 'scale_x=20' and 'scale_y=scale_z=scale_x'.
-scanlines:
_amplitude,_bandwidth,_shape={ 0=bloc | 1=triangle | 2=sine | 3=sine+ |
4=random },_angle,_offset
Apply ripple deformation on selected images.
Default values: 'amplitude=60', 'bandwidth=2', 'shape=0', 'angle=0' and
'offset=0'.
-shade_stripes:
_frequency>=0,_direction={ 0=horizontal | 1=vertical },_darkness>=0,
_lightness>=0
Add shade stripes to selected images.
Default values: 'frequency=5', 'direction=1', 'darkness=0.8' and
'lightness=2'.
-shadow_patch:
_opacity>=0
Add shadow patches to selected images.
Default value: 'opacity=0.7'.
-spread:
_dx>=0,_dy>=0,_dz>=0
Spread pixel values of selected images randomly along x,y and z.
Default values: 'dx=3', 'dy=dx' and 'dz=0'.
-stripes_y:
_frequency>=0
Add vertical stripes to selected images.
Default value: 'frequency=10'.
-texturize_canvas:
_amplitude>=0,_fibrousness>=0,_emboss_level>=0
Add paint canvas texture to selected images.
Default values: 'amplitude=20', 'fibrousness=3' and 'emboss_level=0.6'.
-texturize_paper:
Add paper texture to selected images.
-vignette:
_strength>=0,0<=_radius_min<=100,0<=_radius_max<=100
Add vignette effect to selected images.
Default values: 'strength=100', 'radius_min=70' and 'radius_max=90'.
-watermark_visible:
_text,0<_opacity<1,_size>0,_angle,_mode={ 0=remove | 1=add
},_smoothness>=0
Add or remove a visible watermark on selected images (value range must be
[0,255]).
Default values: 'text=(c) G'MIC', 'opacity=0.3', 'size=53', 'angle=25',
'mode=1' and
'smoothness=0'.
** Blending and fading:
-blend:
[layer],blending_mode,0<=_opacity<=1,_selection_is={ 0=base-layers |
1=top-layers } |
blending_mode,0<=_opacity<=1
Blend selected G,GA,RGB or RGBA images by specified layer or blend all
selected images together,
using specified blending mode.
'blending_mode' can be { add | alpha | and | average | blue | burn | darken |
difference |
divide | dodge | edges | exclusion | freeze | grainextract | grainmerge |
green | hardlight |
hardmix | hue | interpolation | lighten | lightness | linearburn |
linearlight | luminance |
multiply | negation | or | overlay | pinlight | red | reflect | saturation |
seamless |
seamless_mixed |
screen | shapeaverage | shapeaverage0 | softburn | softdodge | softlight |
stamp | subtract |
value |
vividlight | xor }.
Default values: 'blending_mode=alpha', 'opacity=1' and 'selection_is=0'.
-blend_edges:
smoothness[%]>=0
Blend selected images togethers using 'edges' mode.
-blend_fade:
[fading_shape]
Blend selected images together using specified fading shape.
-blend_median:
Blend selected images together using 'median' mode.
-blend_seamless:
_is_mixed_mode={ 0 | 1 },_inner_fading[%]>=0,_outer_fading[%]>=0
Blend selected images using a seamless blending mode (Poisson-based).
Default values: 'is_mixed=0', 'inner_fading=0' and 'outer_fading=100%'.
-fade_diamond:
0<=_start<=100,0<=_end<=100
Create diamond fading from selected images.
Default values: 'start=80' and 'end=90'.
-fade_linear:
_angle,0<=_start<=100,0<=_end<=100
Create linear fading from selected images.
Default values: 'angle=45', 'start=30' and 'end=70'.
-fade_radial:
0<=_start<=100,0<=_end<=100
Create radial fading from selected images.
Default values: 'start=30' and 'end=70'.
-fade_x:
0<=_start<=100,0<=_end<=100
Create horizontal fading from selected images.
Default values: 'start=30' and 'end=70'.
-fade_y:
0<=_start<=100,0<=_end<=100
Create vertical fading from selected images.
Default values: 'start=30' and 'end=70'.
-fade_z:
0<=_start<=100,0<=_end<=100
Create transversal fading from selected images.
Default values: 'start=30' and 'end=70'.
-sub_alpha:
[base_image],_opacity_gain>=1
Compute the minimal alpha-channel difference (opposite of alpha blending)
between the selected
images and the specified base image.
The alpha difference A-B is defined as the image having minimal opacity, such
that
alpha_blend(B,A-B) = A.
Default value: 'opacity_gain=1'.
** Image sequences and videos:
-animate:
filter_name,"param1_start,...,paramN_start","param1_end,...,paramN_end",
nb_frames>=0,_output_frames={ 0 | 1 },_output_filename |
delay>0
Animate filter from starting parameters to ending parameters or animate
selected images
in a display window.
Default value: 'delay=30'.
-apply_camera:
_"command",_camera_index>=0,_skip_frames>=0,_output_filename
Apply specified command on live camera stream, and display it on display
window [0].
Default values: 'command=""', 'camera_index=0' (default camera),
'skip_frames=0' and
'output_filename=""'.
-apply_files:
"filename_pattern",_"command",_first_frame>=0,_last_frame={
>=0 | -1=last },
_frame_step>=1,_output_filename
Apply a G'MIC command on specified input image files, in a streamed way.
If a display window is opened, rendered frames are displayed in it during
processing.
The output filename may have extension '.avi' (saved as a video), or any
other usual image file
extension (saved as a sequence of images).
Default values: 'command=(undefined)', 'first_frame=0', 'last_frame=-1',
'frame_step=1' and
'output_filename=(undefined)'.
-apply_video:
video_filename,_"command",_first_frame>=0,_last_frame={ >=0 |
-1=last },
_frame_step>=1,_output_filename
Apply a G'MIC command on all frames of the specified input video file, in a
streamed way.
If a display window is opened, rendered frames are displayed in it during
processing.
The output filename may have extension '.avi' (saved as a video), or any
other usual image file
extension (saved as a sequence of images).
Default values: 'first_frame=0', 'last_frame=-1', 'frame_step=1' and
'output_filename=(undefined)'.
-average_files:
"filename_pattern",_first_frame>=0,_last_frame={ >=0 |
-1=last },_frame_step>=1,
_output_filename
Average specified input image files, in a streamed way.
If a display window is opened, rendered frames are displayed in it during
processing.
The output filename may have extension '.avi' (saved as a video), or any
other usual image file
extension (saved as a sequence of images).
Default values: 'first_frame=0', 'last_frame=-1', 'frame_step=1' and
'output_filename=(undefined)'.
-average_video:
video_filename,_first_frame>=0,_last_frame={ >=0 | -1=last
},_frame_step>=1,
_output_filename
Average frames of specified input video file, in a streamed way.
If a display window is opened, rendered frames are displayed in it during
processing.
The output filename may have extension '.avi' (saved as a video), or any
other usual image file
extension (saved as a sequence of images).
Default values: 'first_frame=0', 'last_frame=-1', 'frame_step=1' and
'output_filename=(undefined)'.
-fade_files:
"filename_pattern",_nb_inner_frames>0,_first_frame>=0,_last_frame={
>=0 |
-1=last },_frame_step>=1,_output_filename
Generate a temporal fading from specified input image files, in a streamed
way.
If a display window is opened, rendered frames are displayed in it during
processing.
The output filename may have extension 'avi' (saved as a video), or any other
usual image file
extension (saved as a sequence of images).
Default values: 'nb_inner_frames=10', 'first_frame=0', 'last_frame=-1',
'frame_step=1' and
'output_filename=(undefined)'.
-fade_video:
video_filename,_nb_inner_frames>0,_first_frame>=0,_last_frame={ >=0
| -1=last },
_frame_step>=1,_output_filename
Create a temporal fading sequence from specified input video file, in a
streamed way.
If a display window is opened, rendered frames are displayed in it during
processing.
Default values: 'nb_inner_frames=10', 'first_frame=0', 'last_frame=-1',
'frame_step=1' and
'output_filename=(undefined)'.
-files2video:
"filename_pattern",_output_filename,_fps>0,_codec
Convert several files into a single video file.
Default values: 'output_filename=output.avi', 'fps=25' and 'codec=mp4v'.
-median_files:
"filename_pattern",_first_frame>=0,_last_frame={ >=0 |
-1=last },_frame_step>=1,
_frame_rows[%]>=1,_is_fast_approximation={ 0 | 1 }
Compute the median frame of specified input image files, in a streamed way.
If a display window is opened, rendered frame is displayed in it during
processing.
Default values: 'first_frame=0', 'last_frame=-1', 'frame_step=1',
'frame_rows=20%' and
'is_fast_approximation=0'.
-median_video:
video_filename,_first_frame>=0,_last_frame={ >=0 | -1=last
},_frame_step>=1,
_frame_rows[%]>=1,_is_fast_approximation={ 0 | 1 }
Compute the median of all frames of an input video file, in a streamed way.
If a display window is opened, rendered frame is displayed in it during
processing.
Default values: 'first_frame=0', 'last_frame=-1', 'frame_step=1',
'frame_rows=100%' and
'is_fast_approximation=1'.
-morph:
nb_inner_frames>=1,_smoothness>=0,_precision>=0
Create morphing sequence between selected images.
Default values: 'smoothness=0.1' and 'precision=4'.
-morph_files:
"filename_pattern",_nb_inner_frames>0,_smoothness>=0,_precision>=0,
_first_frame>=0,_last_frame={ >=0 | -1=last
},_frame_step>=1,_output_filename
Generate a temporal morphing from specified input image files, in a streamed
way.
If a display window is opened, rendered frames are displayed in it during
processing.
The output filename may have extension '.avi' (saved as a video), or any
other usual image file
extension (saved as a sequence of images).
Default values: 'nb_inner_frames=10', 'smoothness=0.1', 'precision=4',
'first_frame=0',
'last_frame=-1', 'frame_step=1' and 'output_filename=(undefined)'.
-morph_video:
video_filename,_nb_inner_frames>0,_smoothness>=0,_precision>=0,_first_frame>=0,
_last_frame={ >=0 | -1=last },_frame_step>=1,_output_filename
Generate a temporal morphing from specified input video file, in a streamed
way.
If a display window is opened, rendered frames are displayed in it during
processing.
The output filename may have extension '.avi' (saved as a video), or any
other usual image file
extension (saved as a sequence of images).
Default values: 'nb_inner_frames=10', 'smoothness=0.1', 'precision=4',
'first_frame=0',
'last_frame=-1', 'frame_step=1' and 'output_filename=(undefined)'.
-register_nonrigid:
[destination],_smoothness>=0,_precision>0,_nb_scale>=0
Register selected source images with specified destination image, using
non-rigid warp.
Default values: 'smoothness=0.2', 'precision=6' and 'nb_scale=0(auto)'.
-register_rigid:
[destination],_smoothness>=0,_boundary={ 0=dirichlet | 1=neumann |
2=periodic }
Register selected source images with specified destination image, using rigid
warp (shift).
Default values: 'smoothness=1' and 'boundary=0'.
-transition:
[transition_shape],nb_added_frames>=0,100>=shading>=0,_single_frame_only={
-1=disabled | >=0 }
Generate a transition sequence between selected images.
Default values: 'shading=0' and 'single_frame_only=-1'.
-transition3d:
_nb_frames>=2,_nb_xtiles>0,_nb_ytiles>0,_axis_x,_axis_y,_axis_z,_is_antialias={
0 | 1 }
Create 3d transition sequence between selected consecutive images.
'axis_x', 'axis_y' and 'axis_z' can be set as mathematical expressions,
depending on 'x' and
'y'.
Default values: 'nb_frames=10', 'nb_xtiles=nb_ytiles=3', 'axis_x=1',
'axis_y=1', 'axis_z=0' and
'is_antialias=1'.
-video2files:
input_filename,_output_filename,_first_frame>=0,_last_frame={ >=0 |
-1=last },
_frame_step>=1
Split specified input video file into image files, one for each frame.
First and last frames as well as step between frames can be specified.
Default values: 'output_filename=frame.png', 'first_frame=0', 'last_frame=-1'
and
'frame_step=1'.
** PINK-library operators:
-output_pink3d:
filename
Save selected images as P5-coded PPM files (PINK extension for 3d volumetric
images).
-pink:
Pink wrapper name,p1,...,pn (requires the PINK library to be installed).
(http://pinkhq.com/)
prepares input, calls external "name input p1...pn output" and
reads output (/tmp)
-pink_grayskel:
_connectivity={ 4 | 8 | 6 | 26 }, _lambda=0
(http://pinkhq.com/doxygen/grayskel_8c.html)
Grayscale homotopic skeleton (requires the PINK library to be installed).
Default values: 'connectivity=4' and 'lambda=0'.
-pink_heightmaxima:
_connectivity={ 4 | 8 | 6 | 26 },_height=1
(http://pinkhq.com/doxygen/heightmaxima_8c.html)
Heightmaxima filtering (requires the PINK library to be installed).
Default values: 'connectivity=4' and 'height=1'.
-pink_heightminima:
_connectivity={ 4 | 8 | 6 | 26 },_height=1
(http://pinkhq.com/doxygen/heightminima_8c.html)
Heightminima filtering (requires the PINK library to be installed).
Default values: 'connectivity=4' and 'height=1'.
-pink_htkern:
_connectivity={ 4 | 8 | 6 | 26 }, _type={""|u}
(http://pinkhq.com/doxygen/htkern_8c.html)
(http://pinkhq.com/doxygen/htkernu_8c.html)
Grayscale ultimate homotopic thinning/thickening without condition (requires
the PINK library
to be installed).
Default values: 'connectivity=4' and 'type=""'.
-pink_lvkern:
_connectivity={ 4 | 8 | 6 | 26 }, _type={""|u}
(http://pinkhq.com/doxygen/lvkern_8c.html)
(http://pinkhq.com/doxygen/lvkernu_8c.html)
Grayscale ultimate leveling thinning/thickening without condition (requires
the PINK library to
be installed).
Default values: 'connectivity=4' and 'type=""'.
-pink_reg_minima:
_connectivity={ 4 | 8 | 6 | 26 }
(http://pinkhq.com/doxygen/minima_8c.html)
Regional minima (requires the PINK library to be installed).
Default values: 'connectivity=4'.
-pink_skelcurv:
_prio={0|1|2|3|4|8|6|26},_connectivity={ 4 | 8 | 6 | 26
},_inhibit={""}
(http://pinkhq.com/doxygen/skelcurv_8c.html)
Curvilinear binary skeleton guided by a priority function or image (requires
the PINK library
to be installed).
Default values: 'prio=0', 'connectivity=4' and 'inhibit=""'.
-pink_skelend:
_connectivity={ 4 | 8 | 6 | 26 },_n=0
(http://pinkhq.com/doxygen/skelend_8c.html)
Homotopic skeleton of a 2d or 3d binary image with dynamic detection of end
points (requires
the PINK library to be installed).
Default values: 'connectivity=4' and 'n=0'.
-pink_skeleton:
_prio={0|1|2|3|4|8|6|26},_connectivity={ 4 | 8 | 6 | 26
},_inhibit={""}
(http://pinkhq.com/doxygen/skeleton_8c.html)
Ultimate binary skeleton guided by a priority image (requires the PINK
library to be installed).
Default values: 'prio=0', 'connectivity=4' and 'inhibit=""'.
-pink_skelpar:
_algorithm={0...29},_nsteps=_1,_inhibit=""
(http://pinkhq.com/doxygen/skelpar_8c.html)
Parallel binary skeleton (requires the PINK library to be installed).
Default values: 'algorithm=4', 'nsteps=-1' and 'inhibit=""'.
-pink_wshed:
_connectivity={ 4 | 8 | 6 | 26 },_inverse={ 0 | 1 },_height=0
(http://pinkhq.com/doxygen/wshedtopo_8c.html)
Watershed (requires the PINK library to be installed).
Default values: 'connectivity=4', 'inverse=0' and 'height=0'.
** Convenience functions:
-alert:
_title,_message,_label_button1,_label_button2,...
Display an alert box and wait for user's choice.
If a single image is in the selection, it is used as an icon for the alert
box.
Default values: 'title=[G'MIC Alert]' and 'message=This is an alert
box.'.
-arg:
n>=1,_arg1,...,_argN
Return the n-th argument of the specified argument list.
-arg2var:
variable_name,argument_1,...,argument_N
For each i in [1...N], set 'variable_name$i=argument_i'.
The variable name should be global to make this command useful (i.e. starts
by an underscore).
-autocrop_coords:
value1,value2,... | auto
Return coordinates (x0,y0,z0,x1,y1,z1) of the autocrop that could be
performed on the latest of
the selected images.
Default value: 'auto'
-average_color:
Return the average color of the latest of the selected images.
-basename:
file_path,_variable_name_for_folder
Return the basename of a file path, and opt. its folder location.
When specified 'variable_name_for_folder' must starts by an underscore
(global variable accessible from calling function).
-bin:
binary_int1,...
Print specified binary integers into their octal, decimal, hexadecimal and
string
representations.
-bin2dec:
binary_int1,...
Convert specified binary integers into their decimal representations.
-dec:
decimal_int1,...
Print specified decimal integers into their binary, octal, hexadecimal and
string
representations.
-dec2str:
decimal_int1,...
Convert specifial decimal integers into its string representation.
-dec2bin:
decimal_int1,...
Convert specified decimal integers into their binary representations.
-dec2hex:
decimal_int1,...
Convert specified decimal integers into their hexadecimal
representations.
-dec2oct:
decimal_int1,...
Convert specified decimal integers into their octal representations.
-fact:
value
Return the factorial of the specified value.
-fibonacci:
N>=0
Return the Nth number of the Fibonacci sequence.
-file_mv:
filename_src,filename_dest
Rename or move a file from a location $1 to another location $2.
-file_rand:
Return a random filename for storing temporary data.
-file_rm:
filename
Delete a file.
-filename:
filename,_number1,_number2,...,_numberN
Return a filename numbered with specified indices.
-files (+):
_mode,path
Return the list of files and/or subfolders from specified path.
'path' can be eventually a matching pattern.
'mode' can be { 0=files only | 1=folders only | 2=files + folders }.
Add '3' to 'mode' to return full paths instead of filenames only.
Default value: 'mode=5'.
-fitratio_wh:
min_width,min_height,ratio_wh
Return a 2d size 'width,height' which is bigger than 'min_width,min_height'
and has the
specified w/h ratio.
-fitscreen:
width,height,_depth,_minimal_size[%],_maximal_size[%]
Return the 'ideal' size WxH for a window intended to display an image of
specified size on
screen.
Default values: 'depth=1', 'minimal_size=128' and 'maximal_size=85%'.
-fps:
Return the number of time this function is called per second, or -1 if this
info is not yet
available.
Useful to display the framerate when displaying animations.
-gcd:
a,b
Return the GCD (greatest common divisor) between a and b.
-hex:
hexadecimal_int1,...
Print specified hexadecimal integers into their binary, octal, decimal and
string
representations.
-hex2dec:
hexadecimal_int1,...
Convert specified hexadecimal integers into their decimal
representations.
-hex2img:
"hexadecimal_string"
Insert new image 1xN at the end of the list with values specified by the
given
hexadecimal-encoded string.
-hex2str:
hexadecimal_string
Convert specified hexadecimal string into a string.
-img2hex:
Return representation of last image as an hexadecimal-encoded string.
Input image must have values that are integers in [0,255].
-img2str:
Return the content of the latest of the selected image as a special G'MIC
input string.
-img2text:
_line_separator
Return text contained in a multi-line image.
Default value: 'line_separator= '.
-img82hex:
Convert selected 8bits-valued vectors into their hexadecimal representations
(ascii-encoded).
-hex2img8:
Convert selected hexadecimal representations (ascii-encoded) into
8bits-valued vectors.
-is_3d:
Return 1 if all of the selected image are 3d objects, 0 otherwise.
-is_ext:
filename,_extension
Return 1 if specified filename has a given extensioin.
-is_image_arg:
string
Return 1 if specified string looks like '[ind]'.
-is_pattern:
string
Return 1 if specified string looks like a drawing pattern '0x......'.
-is_percent:
string
Return 1 if specified string ends with a '%', 0 otherwise.
-is_videofilename:
Return 1 if extension of specified filename is typical from video files.
-is_windows:
Return 1 if current computer OS is Windows, 0 otherwise.
-math_lib:
Return string that defines a set of several useful macros for the embedded
math evaluator.
-mad:
Return the MAD (Maximum Absolute Deviation) of the last selected image.
The MAD is defined as MAD = med_i|x_i-med_j(x_j)|
-max_w:
Return the maximal width between selected images.
-max_h:
Return the maximal height between selected images.
-max_d:
Return the maximal depth between selected images.
-max_s:
Return the maximal spectrum between selected images.
-max_wh:
Return the maximal wxh size of selected images.
-max_whd:
Return the maximal wxhxd size of selected images.
-max_whds:
Return the maximal wxhxdxs size of selected images.
-med:
Return the median value of the last selected image.
-color_med:
Return the median color value of the last selected image.
-min_w:
Return the minimal width between selected images.
-min_h:
Return the minimal height between selected images.
-min_d:
Return the minimal depth between selected images.
-min_s:
Return the minimal s size of selected images.
-min_wh:
Return the minimal wxh size of selected images.
-min_whd:
Return the minimal wxhxd size of selected images.
-min_whds:
Return the minimal wxhxdxs size of selected images.
-normalize_filename:
filename
Return a "normalized" version of the specified filename, without
spaces and capital letters.
-oct:
octal_int1,...
Print specified octal integers into their binary, decimal, hexadecimal and
string
representations.
-oct2dec:
octal_int1,...
Convert specified octal integers into their decimal representations.
-padint:
number,_size>0
Return a integer with 'size' digits (eventually left-padded with '0').
-path_gimp:
Return a path to store GIMP configuration files for one user (whose value is
OS-dependent).
-path_tmp:
Return a path to store temporary files (whose value is OS-dependent).
-region_feature:
region_label,feature,_default_value
Return feature for a specified region.
This function requires two images [img,region_label] in the selection.
Argument 'feature' is a string that corresponds to the way the feature would
be asked for the entire image.
Default value: 'default_value=0'.
-reset:
Reset global parameters of the interpreter environment.
-RGB:
Return a random int-valued RGB color.
-RGBA:
Return a random int-valued RGBA color.
-str:
string
Print specified string into its binary, octal, decimal and hexadecimal
representations.
-str2hex:
string
Convert specified string into a sequence of hexadecimal values.
-stresc:
val1,...,valN
Return escaped string from specified ascii codes.
-strcat:
"string1","string2",...
Return the concatenation of all strings passed as arguments.
-strcmp:
"string1","string2",_nb_characters>=0
Return '1' if the two specified strings are equals, '0' otherwise.
If 'nb_characters' is specified, the comparison is done only for the
'nb_characters' first
characters.
-strcontains:
string1,string2
Return 1 if the first string contains the second one.
-strlen:
string1
Return the length of specified string argument.
-strreplace:
string,search,replace
Search and replace substrings in an input string.
-strlowercase:
string
Return a lower-case version of the specified string.
-strvar:
string
Return a simplified version of the specified string, that can be used as a
variable name.
-strver:
_version
Return the specified version number of the G'MIC interpreter, as a string.
Default value: 'version=$_version'.
-tic:
Initialize tic-toc timer.
Use it in conjunction with '-toc'.
-toc:
Display elapsed time of the tic-toc timer since the last call to '-tic'.
This command returns the elapsed time in the status value.
Use it in conjunction with '-tic'.
-std_noise:
Return the estimated noise standard deviation of the last selected image.
** Other interactive commands:
-demo:
_run_in_parallel={ 0=no | 1=yes | 2=auto }
Show a menu to select and view all G'MIC interactive demos.
-x_2048:
Launch the 2048 game.
-x_blobs:
Launch the blobs editor.
-x_bouncing:
Launch the bouncing balls demo.
-x_color_curves:
_colorspace={ rgb | cmy | cmyk | hsi | hsl | hsv | lab | lch | ycbcr | last
}
Apply color curves on selected RGB[A] images, using an interactive window.
Set 'colorspace' to 'last' to apply last defined color curves without opening
interactive
windows.
Default value: 'colorspace=rgb'.
-x_colorize:
_is_lineart={ 0 | 1 },_max_resolution={ 0 | >=128
},_multichannels_output={ 0 |
1 },_[palette1],_[palette2],_[grabber1]
Colorized selected B&W images, using an interactive window.
When >0, argument 'max_resolution' defines the maximal image resolution
used in the interactive
window.
Default values: 'is_lineart=1', 'max_resolution=1024' and
'multichannels_output=0'.
-x_fire:
Launch the fire effect demo.
-x_fireworks:
Launch the fireworks demo.
-x_fisheye:
Launch the fish-eye effect demo.
-x_fourier:
Launch the fourier filtering demo.
-x_grab_color:
_variable_name
Open a color grabber widget from the first selected image.
Argument 'variable_name' specifies the variable that contains the selected
color values at any
time.
Assigning '-1' to it forces the interactive window to close.
Default values: 'variable_name=xgc_variable'.
-x_histogram:
Launch the histogram demo.
-x_hough:
Launch the hough transform demo.
-x_jawbreaker:
0<_width<20,0<_height<20,0<_balls<=8
Launch the Jawbreaker game.
-x_landscape:
Launch the virtual landscape demo.
-x_life:
Launch the game of life.
-x_light:
Launch the light effect demo.
-x_mandelbrot:
_julia={ 0 | 1 },_c0r,_c0i
Launch Mandelbrot/Julia explorer.
-x_metaballs3d:
Launch the 3d metaballs demo.
-x_minesweeper:
8<=_width=<20,8<=_height<=20
Launch the Minesweeper game.
-x_minimal_path:
Launch the minimal path demo.
-x_pacman:
Launch pacman game.
-x_paint:
Launch the interactive painter.
-x_plasma:
Launch the plasma effect demo.
-x_quantize_rgb:
_nbcolors>=2
Launch the RGB color quantization demo.
-x_reflection3d:
Launch the 3d reflection demo.
-x_rubber3d:
Launch the 3d rubber object demo.
-x_segment:
_max_resolution={ 0 | >=128 }
Segment foreground from background in selected opaque RGB images,
interactively.
Return RGBA images with binary alpha-channels.
Default value: 'max_resolution=1024'.
-x_select_color:
_variable_name
Display a RGB or RGBA color selector.
Argument 'variable_name' specifies the variable that contains the selected
color values (as R,G,
B,[A]) at any time.
Its value specifies the initial selected color. Assigning '-1' to it forces
the interactive
window to close.
Default value: 'variable_name=xsc_variable'.
-x_select_function1d:
_variable_name,_background_curve_R,_background_curve_G,_background_curve_B
Open an interactive window, where the user can defined its own 1d function.
If an image is selected, it is used to display additional information :
- The first row defines the values of a background curve displayed on the
window (e.g. an
histogram).
- The 2nd, 3rd and 4th rows define the R,G,B color components displayed
beside the X and Y axes.
Argument 'variable_name' specifies the variable that contains the selected
function keypoints
at any time.
Assigning '-1' to it forces the interactive window to close.
Default values: 'variable_name=xsf_variable', 'background_curve_R=220',
'background_curve_G=background_curve_B=background_curve_T'.
-x_select_palette:
_variable_name,_number_of_columns={ 0=auto | >0 }
Open a RGB or RGBA color selector widget from a palette.
The palette is given as a selected image.
Argument 'variable_name' specifies the variable that contains the selected
color values (as R,G,
B,[A]) at any time.
Assigning '-1' to it forces the interactive window to close.
Default values: 'variable_name=xsp_variable' and 'number_of_columns=2'.
-x_shadebobs:
Launch the shade bobs demo.
-x_spline:
Launch spline curve editor.
-x_tetris:
Launch tetris game.
-x_tictactoe:
Launch tic-tac-toe game.
-x_waves:
Launch the image waves demo.
-x_whirl:
_opacity>=0
Launch the fractal whirls demo.
Default values: 'opacity=0.2'.
**** Command shortcuts:
-h : eq. to '-help'.
-m (+): eq. to '-command'.
-d (+): eq. to '-display'.
-d0 : eq. to '-display0'.
-d3d (+): eq. to '-display3d'.
-da : eq. to '-display_array'.
-dfft : eq. to '-display_fft'.
-dg : eq. to '-display_graph'.
-dh : eq. to '-display_histogram'.
-dp : eq. to '-display_polar'.
-dq : eq. to '-display_quiver'.
-drgba : eq. to '-display_rgba'.
-dt : eq. to '-display_tensors'.
-dw : eq. to '-display_warp'.
-e (+): eq. to '-echo'.
-i (+): eq. to '-input'.
-ig : eq. to '-input_glob'.
-o (+): eq. to '-output'.
-on : eq. to '-outputn'.
-op : eq. to '-outputp'.
-ow : eq. to '-outputw'.
-ox : eq. to '-outputx'.
-p (+): eq. to '-print'.
-sh (+): eq. to '-shared'.
-sp : eq. to '-sample'.
-up : eq. to '-update'.
-v (+): eq. to '-verbose'.
-w (+): eq. to '-window'.
-k (+): eq. to '-keep'.
-mv (+): eq. to '-move'.
-nm (+): eq. to '-name'.
-nms : eq. to '-names'.
-rm (+): eq. to '-remove'.
-rv (+): eq. to '-reverse'.
-+ (+): eq. to '-add'.
-& (+): eq. to '-and'.
-<< (+): eq. to '-bsl'.
->> (+): eq. to '-bsr'.
-/ (+): eq. to '-div'.
-== (+): eq. to '-eq'.
->= (+): eq. to '-ge'.
-> (+): eq. to '-gt'.
-<= (+): eq. to '-le'.
-< (+): eq. to '-lt'.
-// (+): eq. to '-mdiv'.
-% (+): eq. to '-mod'.
-** (+): eq. to '-mmul'.
-* (+): eq. to '-mul'.
-!= (+): eq. to '-neq'.
-| (+): eq. to '-or'.
-^ (+): eq. to '-pow'.
-- (+): eq. to '-sub'.
-c (+): eq. to '-cut'.
-f (+): eq. to '-fill'.
-ir : eq. to '-inrange'.
-n (+): eq. to '-normalize'.
-= (+): eq. to '-set'.
-ac : eq. to '-apply_channels'.
-fc : eq. to '-fill_color'.
-a (+): eq. to '-append'.
-z (+): eq. to '-crop'.
-r (+): eq. to '-resize'.
-rr2d : eq. to '-resize_ratio2d'.
-r2dx : eq. to '-resize2dx'.
-r2dy : eq. to '-resize2dy'.
-r3dx : eq. to '-resize3dx'.
-r3dy : eq. to '-resize3dy'.
-r3dz : eq. to '-resize3dz'.
-s (+): eq. to '-split'.
-y (+): eq. to '-unroll'.
-b (+): eq. to '-blur'.
-g (+): eq. to '-gradient'.
-j (+): eq. to '-image'.
-j3d (+): eq. to '-object3d'.
-t (+): eq. to '-text'.
-to : eq. to '-text_outline'.
-+3d (+): eq. to '-add3d'.
-c3d : eq. to '-center3d'.
-col3d (+): eq. to '-color3d'.
-/3d (+): eq. to '-div3d'.
-db3d (+): eq. to '-double3d'.
-f3d (+): eq. to '-focale3d'.
-l3d (+): eq. to '-light3d'.
-m3d (+): eq. to '-mode3d'.
-md3d (+): eq. to '-moded3d'.
-*3d (+): eq. to '-mul3d'.
-n3d : eq. to '-normalize3d'.
-o3d (+): eq. to '-opacity3d'.
-p3d (+): eq. to '-primitives3d'.
-rv3d (+): eq. to '-reverse3d'.
-r3d (+): eq. to '-rotate3d'.
-sl3d (+): eq. to '-specl3d'.
-ss3d (+): eq. to '-specs3d'.
-s3d (+): eq. to '-split3d'.
--3d (+): eq. to '-sub3d'.
-t3d (+): eq. to '-texturize3d'.
-ap : eq. to '-apply_parallel'.
-apc : eq. to '-apply_parallel_channels'.
-apo : eq. to '-apply_parallel_overlap'.
-endl (+): eq. to '-endlocal'.
-x (+): eq. to '-exec'.
-l (+): eq. to '-local'.
-q (+): eq. to '-quit'.
-u (+): eq. to '-status'.
-frame : eq. to '-frame_xy'.
[ Total number of commands: 949 ]
13. Examples of use
---------------
'gmic' is a generic image processing tool which can be used in a wide variety
of situations.
The few examples below illustrate possible uses of this tool:
- View a list of images:
gmic file1.bmp file2.jpeg
- Convert an image file:
gmic input.bmp -o output.jpg
- Create a volumetric image from a movie sequence:
gmic input.mpg -a z -o output.hdr
- Compute image gradient norm:
gmic input.bmp -gradient_norm
- Denoise a color image:
gmic image.jpg -denoise 30,10 -o denoised.jpg
- Compose two images using overlay layer blending:
gmic image1.jpg image2.jpg -blend overlay -o blended.jpg
- Evaluate a mathematical expression:
gmic -e
"cos(pi/4)^2+sin(pi/4)^2={cos(pi/4)^2+sin(pi/4)^2}"
- Plot a 2d function:
gmic 1000,1,1,2 -f
"X=3*(x-500)/500;X^2*sin(3*X^2)+if(c==0,u(0,-1),cos(X*10))"
-plot
- Plot a 3d elevated function in random colors:
gmic 128,128,1,3,"u(0,255)" -plasma 10,3 -blur 4 -sharpen 10000
\
-elevation3d[-1]
"'X=(x-64)/6;Y=(y-64)/6;100*exp(-(X^2+Y^2)/30)*abs(cos(X)*sin(Y))'"
- Plot the isosurface of a 3d volume:
gmic -m3d 5 -md3d 5 -db3d 0 -isosurface3d
"'x^2+y^2+abs(z)^abs(4*cos(x*y*z*3))'",3
- Render a G'MIC 3d logo:
gmic 0 -text G\'MIC,0,0,53,1,1,1,1 -expand_xy 10,0 -blur 1 -n 0,100
--plasma 0.4 -add \
-blur 1 -elevation3d -0.1 -md3d 4
- Generate a 3d ring of torii:
gmic -repeat 20 -torus3d 15,2 -color3d[-1]
"{u(60,255)},{u(60,255)},{u(60,255)}" \
-*3d[-1] 0.5,1 -if "{$>%2}" -rotate3d[-1] 0,1,0,90 -endif
-add3d[-1] 70 -add3d \
-rotate3d 0,0,1,18 -done -moded3d 3 -mode3d 5 -db3d 0
- Create a vase from a 3d isosurface:
gmic -md3d 4 -isosurface3d "'x^2+2*abs(y/2)*sin(2*y)^2+z^2-3',0"
-sphere3d 1.5 \
-sub3d[-1] 0,5 -plane3d 15,15 -rotate3d[-1] 1,0,0,90 -center3d[-1]
-add3d[-1] 0,3.2 \
-color3d[-1] 180,150,255 -color3d[-2] 128,255,0 -color3d[-3] 255,128,0
-add3d
- Display filtered webcam stream:
gmic -apply_camera \"--mirror x --mirror y -add -div 4\"
- Launch a set of G'MIC interactive demos:
gmic -demo
** G'MIC comes with ABSOLUTELY NO WARRANTY; for details visit:
http://gmic.eu **