NAME

gmic - Perform image processing operations using the G'MIC framework.

HELP

gmic: GREYC's Magic for Image Computing: command-line interface
Version 3.3.5
(https://gmic.eu)

Copyright (c) Since 2008, David Tschumperlé / GREYC / CNRS.
(https://www.greyc.fr)

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
scripting programming language dedicated to the design of possibly complex
image processing pipelines and operators.
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 all the technical aspects of the G'MIC
framework, in its current version 3.3.5.

As a starting point, you may want to visit our detailed tutorial pages, at:
https://gmic.eu/tutorial/

2. Overall Context
---------------

* At any time, G'MIC manages one list of numbered (and optionally named)
pixel-based images, entirely stored in computer memory (uncompressed).
* The first image of the list has index '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 command name for this purpose).
* G'MIC defines a set of various commands and substitution mechanisms to allow
the design of complex pipelines and operators managing this list of images, in
a very flexible way: You can insert or remove images in the list, rearrange
image order, process images (individually or grouped), merge image data
together, display and output image files, etc.
* Such a pipeline can define a new custom G'MIC command (stored in a user
command file), and re-used afterwards as a regular command, in a larger
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 of 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 can be the default).
* Considering 'float'-valued pixels ensure to keep 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 file_out.jpg

defines a valid pipeline composed of nine G'MIC items.

* Each G'MIC item 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
----------

* 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[xN]': Insert
one or N images 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,[x,y,128]' 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,..)[xN]': Insert one or 'N' new images 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.
- '('string'[:delimiter])[xN]': Insert one or N new images from
specified string, by filling the images with the character codes composing the
string. When specified, 'delimiter' tells about the main orientation of
the image. Delimiter can be 'x' (eq. to ',' which is the default),
'y' (eq. to ';'), 'z' (eq. to '/') or 'c' (eq. to
'^'). When specified delimiter is ',', ';', '/' or
'^', the expression is actually equivalent to
'({'string'[:delimiter]})[xN]' (see section Substitution Rules for
more information on the syntax).
- '0[xN]': Insert one or N new 'empty' images, containing no
pixel data. Empty images are used only in rare occasions.

* Input item 'name=value' declares a new variable 'name', or
assign a new string 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).
- When defined in a subcommand of the current command, a variable
becomes also accessible in the parent command. A subcommand of a command
'foo' is a command whose name starts with '_foo' (e.g.
'_foo_sub') and that is called from 'foo'.
* 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). For instance, 'foo=1' 'foo+=3'.
* Input item 'name.=string' appends specified 'string' at the end
of variable 'name'.
* Input item 'name..=string' prepends specified 'string' at the
beginning of variable 'name'.
* Multiple variable assignments and updates are allowed, with expressions:
'name1,name2,...,nameN=value' or 'name1,name2,...,nameN=value1,value2,
...,valueN' where assignment operator '=' can be replaced by one of
the allowed operators (e.g. '+=').
* Variables usually store numbers or strings. Use command store to
assign variables from image data (and syntax 'input $variable' to bring
them back on the image list afterwards).

6. Command Items and Selections
----------------------------

* A G'MIC item that is not a filename nor a special input string
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 first two.
- '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 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]'').
* Prepending a single hyphen '-' to a G'MIC command is allowed. This may
be useful to recognize command items more easily in a one-liner pipeline
(typically invoked from a shell).
* A G'MIC command prepended with a plus sign '+' 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:
- Built-in 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 built-in 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 built-in or
other custom commands. They are parsed by the G'MIC interpreter, and thus run a
bit slower than built-in 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 built-in 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',
'.cube', '.pan', '.inr', '.pnk', ...
- Video files: '.mpeg', '.avi', '.mp4', '.mov',
'.ogg', '.flv', ...
- Generic text or binary data files: '.gmz', '.cimg',
'.cimgz', 'flo', 'ggr', 'gpl', '.dlm',
'.asc', '.pfm', '.raw', '.txt', '.h'.
- 3D mesh files: '.off', '.obj'.

* When dealing with color images, G'MIC generally reads, writes and displays
data using the usual sRGB color space.
* When loading a '.png' and '.tiff' file, the bit-depth of the
input image(s) is returned to the status.
* G'MIC is able to manage 3D mesh 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 extension '.gmz' to ensure that all data precision is
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' where 'keep_open'
can be { 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 { auto |
bool | uint8 | int8 | uint16 | int16 | uint32 | int32 | uint64 | int64 |
float32 | float64 }.
- '.raw' binary files: Image dimensions and input pixel type
may be specified when loading '.raw' files with input expression
'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 when loading,
and only sub-frames of an image sequence may be loaded, using the input
expression 'filename.yuv,width,height[,chroma_subsampling[,first_frame[,
last_frame[,step]]]'. 'chroma_subsampling' can be { 420 | 422 | 444
}. When saving, chroma subsampling mode can be specified with output
expression 'filename.yuv[,chroma_subsampling]'.
- '.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) }.
- '.pdf' files: When loading a file, the rendering resolution
can be specified using the input expression 'filename.pdf,resolution',
where 'resolution' is an unsigned integer value.
- '.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]' where 'debug_info' can be {
0:false | 1:true }.
- 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 index 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 if it is not defined).
* The following reserved variables are predefined by the G'MIC interpreter:
- '$!': The current number of images in the list.
- '$>' and '$<': The increasing/decreasing index of the latest
(currently running) 'repeat...done' loop. '$>' goes from '0'
(first loop iteration) to 'nb_iterations - 1' (last iteration).
'$<' does the opposite.
- '$/': 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.
- '$_flags': The list of enabled flags when G'MIC interpreter has
been compiled.
- '$_host': A string telling about the host running the G'MIC
interpreter (e.g. 'cli' or 'gimp').
- '$_os': A string describing the running operating system.
- '$_path_rc': The path to the G'MIC folder used to store
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).
- '$_path_commands': A list of all imported command files (stored as
an image list).
- '$_pid': The current process identifier, as an integer.
- '$_pixeltype': The type of image pixels (default: 'float32').
- '$_prerelease': For pre-releases, the date of the pre-release as
'yymmdd'. For stable releases, this variable is set to '0'.
- '$_version': A 3-digits number telling about the current version of
the G'MIC interpreter (e.g. '335').
- '$_vt100': Set to '1' if colored text output is allowed on
the console. Otherwise, set to '0'.

* '$$name' and '$${name}' are both substituted by the G'MIC script
code of the specified named 'custom command', or by an empty string if no
custom command with specified name exists.
* '${"-pipeline"}' is substituted by the status value after the
execution of the specified G'MIC pipeline (see command 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'[:delimiter]}' (between single quotes) is substituted by the
sequence of character codes that composes the specified string, separated by
specified delimiter. Possible delimiters are ',' (default), ';',
'/', '^' or ' '. For instance, item '{'foo'}' is substituted
by '102,111,111' and '{'foo':;}' by '102;111;111'.
* '{image,feature[:delimiter]}' 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 character
codes.
- 'x': The image extension (i.e the 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
character 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 }.
* '{*[index],feature1,...,featureN[:delimiter]}' is substituted by a
specific set of features of the instant display window '#0' (or
'#index', if specified). Requested 'features' can be:
- 'u': screen width (actually independent on the window size).
- 'v': screen height (actually independent on the window size).
- 'uv': screen width*screen height.
- 'd': window width (i.e. width of the window widget).
- 'e': window height (i.e. height of the window widget).
- 'de': window width*window height.
- '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*display height.
- 'i': X-coordinate of the display window.
- 'j': Y-coordinate of the display window.
- 'f': current fullscreen state of the instant display.
- '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, used to evaluate
(possibly complex) math expressions specified inside braces '{}', or
formulas in commands that may take one as an argument (e.g. fill or
eval).
* When the context allows it, a formula is evaluated for each pixel of
the selected images (e.g. fill or eval).
* A math expression may return or take as an argument a scalar or a
vector-valued result (with a fixed number of components).
The mathematical parser understands the following set of functions, operators
and variables:

## Usual math 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()', 'acosh()', 'arg()', 'arg0()',
'argkth()', 'argmax()', 'argmaxabs()', 'argmin()',
'argminabs()', 'asin()', 'asinh()', 'atan()',
'atan2()', 'atanh()', 'avg()', 'bool()', 'cbrt()',
'ceil()', 'cos()', 'cosh()', 'cut()',
'deg2rad()', 'erf()', 'erfinv()', 'exp()',
'fact()', 'fibo()', 'floor()', 'gamma()',
'gauss()', 'gcd()', 'hypot()', 'int()',
'isconst()', 'isnan()', 'isnum()', 'isinf()',
'isint()', 'isbool()', 'isexpr()', 'isfile()',
'isdir()', 'isin()', 'kth()', 'lcm()', 'log()',
'log2()', 'log10()', 'max()', 'maxabs()', 'med()',
'min()', 'minabs()', 'narg()', 'prod()',
'rad2deg()', 'rol()' (left bit rotation), 'ror()' (right bit
rotation), 'round()', 'sign()', 'sin()', 'sinc()',
'sinh()', 'sqrt()', 'std()', 'srand(_seed)',
'sum()', 'tan()', 'tanh()', 'var()', 'xor()'.

* 'cov(A,B,_avgA,_avgB)' estimates the covariance between vectors
'A' and 'B' (estimated averages of these vectors may be specified
as arguments).
* 'mse(A,B)' returns the mean-squared error between vectors 'A'
and 'B'.
* 'atan2(y,x)' is the version of 'atan()' with two arguments
'y' and 'x' (as in C/C++).
* 'perm(k,n,_with_order)' computes the number of permutations of
'k' objects from a set of 'n' objects.
* 'gauss(x,_sigma,_is_normalized)' returns
'exp(-x^2/(2*s^2))/(is_normalized?sqrt(2*pi*sigma^2):1)'.
* '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 'i'-th argument 'a_i'.
* 'isnum()', 'isnan()', 'isinf()', 'isint()',
'isbool()' test the type of the given number or expression, and return
'0' (false) or '1' (true).
* 'isfile('path')' (resp. 'isdir('path')') returns '0'
(false) or '1' (true) whether its string argument is a path to an
existing file (resp. to a directory) or not.
* 'ispercentage(arg)' returns '1' (true) or '0' (false)
whether 'arg' ends with a '%' or not.
* 'isvarname('str')' returns '0' (false) or '1' (true)
whether its string argument would be a valid to name a variable or not.
* 'isin(v,a_1,...,a_n)' returns '0' (false) or '1' (true)
whether the first argument 'v' appears in the set of other argument
'a_i'.
* 'isint(x,_xmin,_xmax)' returns '1' (true), if 'x' is an
integer in range '[xmin,xmax]', otherwise '0' (false).
* 'inrange(value,m,M,include_m,include_M)' returns '0' (false) or
'1' (true) whether the specified value lies in range '[m,M]' or not
('include_m' and 'includeM' tells how boundaries 'm' and
'M' are considered).
* 'argkth()', 'argmin()', 'argmax()', 'argminabs()',
'argmaxabs()'', 'avg()', 'kth()', 'min()',
'max()', 'minabs()', 'maxabs()', 'med()',
'prod()', 'std()', 'sum()' and 'var()' can be called
with an arbitrary number of scalar/vector arguments.
* 'vargkth()', 'vargmin()', 'vargmax()',
'vargminabs()', 'vargmaxabs()', 'vavg()', 'vkth()',
'vmin()', 'vmax()', 'vminabs()', 'vmaxabs()',
'vmed()', 'vprod()', 'vstd()', 'vsum()' and
'vvar()' are the versions of the previous function with vector-valued
arguments.
* 'round(value,rounding_value,direction)' returns a rounded value.
'direction' can be { -1:to-lowest | 0:to-nearest | 1:to-highest }.
* 'lerp(a,b,t)' returns 'a*(1-t)+b*t'.
* 'swap(a,b)' swaps the values of the given arguments.

## Predefined variable names:

Variable names below are pre-defined. They can be overridden though.
* 'l': length of the associated list of images.
* 'k': index of the associated image, in '[0,l-1]'.
* '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*height'.
* 'whd': shortcut for 'width*height*depth'.
* 'whds': shortcut for 'width*height*depth*spectrum' (i.e. number
of image values).
* 'im', 'iM', 'ia', 'iv', 'id', 'is',
'ip', 'ic', 'in': Respectively the minimum, maximum, average,
variance, standard deviation, sum, product, median value and L2-norm 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).
* All these variables are considered as constant values by the math
parser (for optimization purposes) which is indeed the case most of the time.
Anyway, this might not be the case, if function 'resize(#ind,..)' is used
in the math expression. If so, it is safer to invoke functions 'l()',
'w(_#ind)', 'h(_#ind)', ... 's(_#ind)' and 'in(_#ind)'
instead of the corresponding named variables.
* 'i': current processed pixel value (i.e. value located at '(x,y,z,
c)') in the associated image, if any ('0' otherwise).
* 'iN': N-th 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.
* '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).
* 'n': maximum number of threads when expression is evaluated in
parallel (so that 't' goes from '0' to 'n-1').
* 'e': value of e, i.e. '2.71828...'.
* 'pi': value of pi, i.e. '3.1415926...'.
* 'eps': value of machine epsilon, that is the difference between 1.0
and the next value representable by a double.
* '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'.
* The last image of the list is always associated to the evaluations of
'expressions', e.g. G'MIC sequence

256,128 fill {w}

will create a 256x128 image filled with value 256.

## Vector-valued functions and operators:

The math evaluator is able to work with vector-valued elements. A math function
applied on a vector-valued argument usually returns a vector with same
dimension, where each element of the input vector has been passed to the
specified function (e.g. 'abs([-1,2,-3])' returns '[1,2,3]').

There are specific functions and operators to define or compute vector-valued
elements though :
* '[a0,a1,...,aN-1]' defines a 'N'-dimensional vector with scalar
coefficients 'ak'.
* 'vectorN(a0,a1,,...,aN-1)' does the same, with the 'ak' being
repeated periodically if only a few are specified.
* 'vector(#N,a0,a1,,...,aN-1)' does the same, and can be used for any
constant expression 'N'.
* In 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+s]...X[p+s*(q-1)]]' (of size 'q') of a
vector 'X' is retrieved by 'X[p,q,s]'.
* 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,_nb_elts,_size_elt)' (sorted values),
'reverse(A)' (reverse order of components), 'map(X,P,_nb_channelsX,
_nb_channelsP,_boundary_conditions)', 'shift(A,_length,
_boundary_conditions)' and 'same(A,B,_nb_vals,_is_case_sensitive)'
(vector equality test).
* Function 'normP(u1,...,un)' computes the LP-norm of the specified
vector ('P' being a constant or 'inf', as in e.g. 'norm1()').
* Function 'normp(V,_p)' computes the Lp-norm of the specified vector
'V'. Here, 'p' can be variable. Default value for 'p' is 2.
* Function 'unitnorm(V,_p)' returns a normalized version
'V/normp(V)' of specified vector 'V'. Default value for 'p'
is 2.
* 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 |
3:mirror }.
* Function 'find(A,B,_starting_index,_search_step)' returns the index
where sub-vector 'B' appears in vector 'A', (or '-1' if
'B' is not contained in 'A'). Argument 'A' can be also
replaced by an image index '#ind'.
* 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.

## Complex-valued functions:

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), 'clog()' (complex logarithm), 'ccos()'
(complex cosine), 'csin()' (complex sine), 'csqr()' (complex
square), 'csqrt()' (complex square root), 'ctan()' (complex
tangent), 'ccosh()' (complex hyperpolic cosine), 'csinh()' (complex
hyperbolic sine) and 'ctanh()' (complex hyperbolic tangent).

## Matrix-valued functions:

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), 'invert(A,_nb_colsA,_use_LU,_lambda)' (matrix
inverse), 'mul(A,B,_nb_colsB)' (matrix-matrix multiplication), 'rot(u,
v,w,angle)' (3D rotation matrix), 'rot(angle)' (2D rotation matrix),
'solve(A,B,_nb_colsB,_use_LU)' (solver of linear system A.X = B),
'svd(A,_nb_colsA)' (singular value decomposition), 'trace(A)'
(matrix trace) and 'transpose(A,nb_colsA)' (matrix transpose). Argument
'nb_colsB' may be omitted if it is equal to '1'.

## Image-valued functions:

Some functions takes vector-valued arguments that represent image data :
* Function 'expr(formula,_w,_h,_d,_s)' outputs a vector of size
'w*h*d*s' with values generated from the specified formula, as if one
were filling an image with dimensions '(w,h,d,s)'.
* Function 'resize(A,wA,hA,dA,sA,nwA,_nhA,_ndA,_nsA,_interpolation,
_boundary_conditions,_ax,_ay,_az,_ac)' is an extended version of the
'resize()' function. It allows to resize the vector 'A', seen as an
image of size '(ow,oh,od,os)' as a new image of size '(nw,nh,nd,
ns)', with specified resizing options.
* Function 'warp(A,wA,hA,dA,sA,B,wB,hB,dB,sB,_mode,_interpolation,
_boundary_conditions)' returns the warped version of the image 'A' (of
size '(wA,hA,dA,sA)', viewed as a vector of size 'wA*hA*dA*sA') by
the warping field 'B' (of size '(wB,hB,dB,sB)'). The resulting
image has size '(wB,hB,dB,sA)'. This is the math evaluator analog to
command warp.
* Function 'index(A,P,nb_channelsP,_dithering,_map_colors)' returns the
indexed version of the image 'A' by the colormap 'P'. This is the
math evaluator analog to command index.
* Function 'permute(A,wA,hA,dA,sA,permutation_string)' returns a
permuted version of the image 'A' (of size '(wA,hA,dA,sA)', viewed
as a vector of size 'wA*hA*dA*sA'). This is the math evaluator analog to
command permute.
* Function 'mirror(A,wA,hA,dA,sA,axes_string)' returns a mirrored
version of the image 'A' (of size '(wA,hA,dA,sA)', viewed as a
vector of size 'wA*hA*dA*sA'). This is the math evaluator analog to
command mirror.
* Function 'cumulate(A,wA,hA,dA,sA,_axes_string)' returns a cumulated
version of the image 'A' (of size '(wA,hA,dA,sA)', viewed as a
vector of size 'wA*hA*dA*sA'). This is the math evaluator analog to
command cumulate.
* Function 'histogram(A,nb_levels,_min_value,_max_value)' returns the
histogram of the vector 'A'. This is the math evaluator analog to command
histogram.
* Function 'equalize(A,nb_levels,_min_value,_max_value)' returns the
equalized version of the vector 'A'. This is the math evaluator analog to
command equalize.
* Function 'normalize(A,_min_value,_max_value)' returns the normalized
version of the vector 'A'. This is the math evaluator analog to command
normalize.
* 'mproj(S,nb_colsS,D,nb_colsD,method,max_iter,max_residual)' projects a
matrix 'S' onto a dictionary (matrix) 'D'. This is the math
evaluator analog to command mproj.
* Function 'noise(A,amplitude,_noise_type)' returns the noisy version of
the vector 'A'. This is the math evaluator analog to command noise.
* Function 'rand(#size,_min_value,_max_value,_pdf,_precision)' returns
the a vector of 'size' random values. This is the math evaluator analog
to command rand.

## String manipulation:

Character strings are defined as vectors objects and can be then managed as is.
Dedicated functions and initializers to manage strings exist:
* '['string']' and ''string'' define a vector whose values are the
character codes of the specified 'character string' (e.g. ''foo''
is equal to '[ 102,111,111 ]').
* '_'character'' returns the (scalar) byte 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 's2v(str,_starting_index,_is_strict)' parses specified string
'str' and returns the value contained in it.
* Function 'v2s(expr,_nb_digits,_siz)' returns a vector of size
'siz' which contains the character representation of values described by
expression 'expr'. 'nb_digits' can be { <-1:0-padding of
integers | -1:auto-reduced | 0:all | >0:max number of digits }.
* Function 'echo(str1,str2,...,strN)' prints the concatenation of given
string arguments on the console.
* Function 'string(_#siz,str1,str2,...,strN)' generates a vector
corresponding to the concatenation of given string/number arguments.

## Dynamic arrays:

A dynamic array is defined as a one-column (or empty) image '[ind]' in
the image list. It allows elements to be added or removed, each element having
the same dimension (which is actually the number of channels of image
'[ind]'). Dynamic arrays adapt their size to the number of elements they
contain.

A dynamic array can be manipulated in a math expression, with the following
functions:
* 'da_size(_#ind)': Return the number of elements in dynamic array
'[ind]'.
* 'da_back(_#ind)': Return the last element of the dynamic array
'[ind]'.
* 'da_insert(_#ind,pos,elt_1,_elt_2,...,_elt_N)': Insert 'N' new
elements 'elt_k' starting from index 'pos' in dynamic array
'[ind]'.
* 'da_push(_#ind,elt1,_elt2,...,_eltN)': Insert 'N' new elements
'elt_k' at the end of dynamic array '[ind]'.
* 'da_pop(_#ind)': Same as 'da_back()' but also remove last
element from the dynamic array '[ind]'.
* 'da_push_heap(_#ind,elt1,_elt2,...,_eltN)' and
'da_pop_heap(_#ind)' does the same but for a dynamic array viewed as a
min-heap structure.
* 'da_remove(_#ind,_start,_end)': Remove elements located between
indices 'start' and 'end' (included) in dynamic array '[ind]'.
* 'da_freeze(_#ind)': Convert a dynamic array into a 1-column image with
height 'da_size(#ind)'.
* The value of the k-th element of dynamic array '[ind]' is retrieved
with 'i[_#ind,k]' (if the element is a scalar value), or 'I[_#ind,
k]' (if the element is a vector).

In the functions above, argument '#ind' may be omitted in which case it
is assumed to be '#-1'.

## Special operators:

* ';': 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.

## Specific functions:

* 'addr(expr)': return the pointer address to the specified expression
'expr'.
* 'o2c(_#ind,offset)' and 'c2o(_#ind,x,_y,_z,_c)': Convert image
offset to image coordinates and vice-versa.
* 'fill(target,expr)' or 'fill(target,index_name,expr)' fill the
content of the specified target (often vector-valued) using a given expression,
e.g. 'V = vector16(); fill(V,k,k^2 + k + 1);'. For a vector-valued target,
it is basically equivalent to: 'for (index_name = 0,
index_name<size(target), ++index_name, target[index_name] = expr);'.
* 'u(max)' or 'u(min,max,_include_min,_include_max)': return a
random value in range '0...max' or 'min...max', following a uniform
distribution. Each range extremum can be included (default) in the distribution
or not.
* 'v(max)' or 'v(min,max,_include_min,_include_max)' do the same
but returns an integer in specified range.
* 'f2ui(value)' and 'ui2f(value)': Convert a large unsigned
integer as a negative floating point value (and vice-versa), so that 32bits
floats can be used to store large integers while keeping a unitary precision.
* '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 | 1:linear | 2:cubic }. 'boundary_conditions' can
be { 0:dirichlet | 1:neumann | 2:periodic | 3:mirror }. 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_conditions)', 'j(#ind,
_dx,_dy,_dz,_dc,_interpolation,_boundary_conditions)', 'i[#ind,offset,
_boundary_conditions]' and 'i[offset,_boundary_conditions]' are
similar expressions used to access pixel values for any numbered image
'[ind]' of the list.
* 'I/J[_#ind,offset,_boundary_conditions]' and 'I/J(_#ind,_x,_y,_z,
_interpolation,_boundary_conditions)' do the same as 'i/j[_#ind,offset,
_boundary_conditions]' and 'i/j(_#ind,_x,_y,_z,_c,_interpolation,
_boundary_conditions)' 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_conditions)' 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,dy,dz,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 invocation of this function).
* 'crop(S,w,h,d,s,_x,_y,_z,_c,_dx,_dy,_dz,_dc,_boundary_conditions)'
does the same but extracts the cropped data from a vector 'S', viewed as
an image of size '(w,h,d,s)'.
* 'draw(_#ind,S,_x,_y,_z,_c,_dx,_dy,_dz,_dc,_opacity,_opacity_mask,
_max_opacity_mask)' draws a sprite 'S' in image '[ind]' (or in
default image selected if 'ind' is not specified) at coordinates '(x,y,
z,c)'.
* 'draw(D,w,h,s,d,S,_x,_y,_z,_c,_dx,_dy,_dz,_dc,_opacity,_M,_max_M)'
does the same but draw the sprite 'S' in the vector 'D', viewed as
an image of size '(w,h,d,s)'.
* 'polygon(_#ind,nb_vertices,coords,_opacity,_color)' draws a filled
polygon in image '[ind]' (or in default image selected if 'ind' is
not specified) at specified coordinates. It draws a single line if
'nb_vertices' is set to 2.
* 'polygon(_#ind,-nb_vertices,coords,_opacity,_pattern,_color)' draws a
outlined polygon in image '[ind]' (or in default image selected if
'ind' is not specified) at specified coordinates and with specified line
pattern. It draws a single line if 'nb_vertices' is set to 2.
* 'ellipse(_#ind,xc,yc,radius1,_radius2,_angle,_opacity,_color)' draws a
filled ellipse in image '[ind]' (or in default image selected if
'ind' is not specified) with specified coordinates.
* 'ellipse(_#ind,xc,yc,-radius1,-_radius2,_angle,_opacity,_pattern,
_color)' draws an outlined ellipse in image '[ind]' (or in default
image selected if 'ind' is not specified).
* 'flood(_#ind,_x,_y,_z,_tolerance,_is_high_connectivity,_opacity,
_color)' performs a flood fill in image '[ind]' (or in default image
selected if 'ind' is not specified) with specified coordinates. This is
the math evaluator analog to command flood.
* 'resize(#ind,w,_h,_d,_s,_interp,_boundary_conditions,_cx,_cy,_cz,_cc)'
resizes an image of the associated list with specified dimension and
interpolation method. When using this function, you should consider retrieving
the (non-constant) image dimensions using the dynamic functions
'w(_#ind)', 'h(_#ind)', 'd(_#ind)', 's(_#ind)',
'wh(_#ind)', 'whd(_#ind)' and 'whds(_#ind)' instead of the
corresponding constant variables.
* '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),255,i)

and

fill x%10?i:255

both draw blank vertical lines on every 10th column of an image.
* 'do(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;do(F2=F0+F1;F0=F1;F1=F2,n=n-1))

returns the N-th value of the Fibonacci sequence, for 'N>=0' (e.g.,
'46368' for 'N=24'). 'do(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' holds (i.e. not zero).
It may happen that no iterations are 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 'N'-th value of the Fibonacci sequence, for 'N>=0'
(e.g., '46368' for 'N=24').
* 'while(condition,expression)' is exactly the same as 'for(init,
condition,expression)' without the specification of an initializing
expression.
* 'repeat(nb_iters,expr)' or 'fill(nb_iters,iter_name,expr)' run
'nb_iters' iterations of the specified expression 'expr', e.g.
'V = vector16(); repeat(16,k,V[k] = k^2 + k + 1);'. It is basically
equivalent to: 'for (iter_name = 0, iter_name<nb_iters, ++iter_name,
expr);'.
* 'break()' and 'continue()' respectively breaks and continues the
current running block.
* 'fsize('filename')' returns the size of the specified 'filename'
(or '-1' if file does not exist).
* '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 }, or a vector of
those values.
* 'date(_attr)' returns the specified attribute for the current (locale)
date (attributes being { 0...6:same meaning as above | 7:milliseconds }).
* 'print(expr1,expr2,...)' or 'print(#ind)' prints the value of
the specified expressions (or image information) on the console, and returns
the value of the last expression (or 'nan' in case of an image). Function
'prints(expr)' also prints the string composed of the character codes
defined by the vector-valued expression (e.g. 'prints('Hello')').
* 'debug(expression)' prints detailed debug info about the sequence of
operations done by the math parser to evaluate the expression (and returns its
value).
* 'display(_X,_w,_h,_d,_s)' or 'display(#ind)' display the
contents of the vector 'X' (or specified image) and wait for user events.
if no arguments are provided, a memory snapshot of the math parser environment
is displayed instead.
* 'begin(expression)' and 'end(expression)' evaluates the
specified expressions only once, respectively at the beginning and end of the
evaluation procedure, and this, even when multiple evaluations are required
(e.g. in 'fill ">begin(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.
* 'stats(_#ind)' returns the statistics vector of the running image
'[ind]', i.e the vector '[ im,iM,ia,iv,xm,ym,zm,cm,xM,yM,zM,cM,is,ip
]' (14 values).
* 'ref(expr,a)' references specified expression 'expr' as variable
name 'a'.
* 'unref(a,b,...)' destroys references to the named variable given as
arguments.
* 'breakpoint()' inserts a possible computation breakpoint (useless with
the cli interface).
* '_(comment) expr' just returns expression 'expr' (useful for inserting
inline comments in math expressions).
* 'run('pipeline')' executes the specified G'MIC pipeline as if it was
called outside the currently evaluated expression.
* 'set('variable_name',A)' set the G'MIC variable '$variable_name'
with the value of expression 'A'. If 'A' is a vector-valued
variable, it is assumed to encode a string.
* 'store('variable_name',A,_w,_h,_d,_s,_is_compressed)' transfers the
data of vector 'A' as a '(w,h,d,s)' image to the G'MIC variable
'$variable_name'. Thus, the data becomes available outside the math
expression (that is equivalent to using the regular command store, but
directly in the math expression).
* 'get('variable_name',_size,_return_as_string)' returns the value of
the specified variable, as a vector of 'size' values, or as a scalar (if
'size' is zero or not specified).
* 'name(_#ind,size)' returns a vector of size 'size', whose values
are the characters codes of the name of image '[ind]' (or default image
selected if 'ind' is not specified).
* 'correlate(I,wI,hI,dI,sI,K,wK,hK,dK,sK,_boundary_conditions,
_is_normalized,_channel_mode,_xcenter,_ycenter,_zcenter,_xstart,_ystart,_zstart,
_xend,_yend,_zend,_xstride,_ystride,_zstride,_xdilation,_ydilation,_zdilation,
_interpolation_type)' returns the correlation, unrolled as a vector, of the
'(wI,hI,dI,sI)'-sized image 'I' with the '(wK,hK,dK,
sK)'-sized kernel 'K' (the meaning of the other arguments are the same
as in command 'correlate'). Similar function 'convolve(...)' is
also defined for computing the convolution between 'I' and 'K'.

## 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#'];

* Macros with variadic arguments can be defined, by specifying a single
argument name followed by '...'. For instance,

foo(args...) = sum([ args ]^2);

defines a macro that returns the sum of its squared arguments, so 'foo(1,2,
3)' returns '14' and 'foo(4,5)' returns '41'.

## 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', 'eval' or
'input' commands 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
':' (rather than '*') 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!)
* Expression starting with '+' are evaluated in a single-threaded way,
with possible image copy.
* 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
disabled in this case.
* Function 'critical(expr)' forces the execution of the given expression
in a single thread at a time.
* 'begin_t(expr)' and 'end_t(expr)' evaluates the specified
expression once for each running thread (so possibly several times) at the
beginning and the end of the evaluation procedure.
* 'merge(variable,operator)' tells to merge the local variable value
computed by threads, with the specified operator, when all threads have
finished computing.
* 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'.

10. 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 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 '%USERPROFILE%ser.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 verbatim copy of the specified string of
arguments (do not include arguments set to default values).
- '$"*"' is substituted by the sequence of specified arguments,
separated by commas ',', each being double-quoted (include arguments set
to default values).
- '$#' is substituted by the maximum index of known arguments (either
specified by the user or set to a default value in the custom command).
- '$[]' is substituted by the list of selected image indices that
have been specified in the command invocation.
- '$?' is substituted by a printable version of '$[]' to be
used in command descriptions.
- '$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 substituted 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 arguments have been
indeed specified).
- '$=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.
* It is possible to specialize the invocation of a '+command' by
defining it as

+command_name: command_definition

* A +-specialization takes priority over the regular command definition when
the command is invoked with a prepended '+'.
* When only a +-specialization of a command is defined, invoking
'command' is actually equivalent to '+command'.

11. List of Commands
----------------

All available G'MIC commands are listed below, by categories. An argument
specified between '[]' or starting by '_' is optional except when
standing for an existing image '[image]', where 'image' can be
either an index number or an image name. In this case, the '[]'
characters are mandatory when writing the item. Note that all images that serve
as illustrations in this reference documentation are normalized in range '[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.
The examples accompanying this 'List of Commands' illustrate the use of the
G'MIC language and are written as they would appear in a custom command.
While some examples may work if entered directly at a shell prompt, there is no
guarantee. No attempt has been made to escape special characters in these
examples, which many shells reserve.

11.1. Global Options
--------------

debug (+):

Activate debug mode.
When activated, the G'MIC interpreter becomes very verbose and outputs
additional 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.

h:
Shortcut for command 'help'.

help:
command |
(no arg)

Display help (optionally for specified command only) and exit.
(equivalent to shortcut command 'h').

version:

Display current version number on stdout.

11.2. 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.
This command requires features from the OpenCV library (not enabled in
G'MIC by default).

Default values: 'camera_index=0' (default camera),
'nb_frames=1', 'skip_frames=0' and
'capture_width=capture_height=0' (default size).

m (+):
Shortcut for command 'command'.

command (+):
_add_debug_info={ 0 | 1 },{ filename | http[s]://URL | "string" }

Import G'MIC custom commands from specified file, URL or string.
(equivalent to shortcut command 'm').

Imported commands are available directly after the 'command'
invocation.
Specified filename is not allowed to contain colons ':'.

Default value: 'add_debug_info=1' (except for a "string"
argument, in which case 'add_debug_info=0').

Example:
[#1] image.jpg command "foo : mirror y deform $""1" +foo[0] 5 +foo[0] 15

compress_to_keypoints:
_method,_max_keypoints>=0,_err_avg[%]>=0,_err_max[%]>=0,_"err_command"

Compress each of the selected images into a set of keypoints that can be
further decompressed using command decompress_from_keypoints.
Beware: This type of compression is effective only for images with
very smooth content.
'method' can be { 0:PDE | 1:RBF }. Add '2' to
'method' to enable removal step.
* 'max_keypoints' is the maximal number of keypoints generated by
the compression method. If 'max_keypoints<0', the removal step is not
done when number of maximal keypoints has been reached.
'max_keypoints=0' means 'no limits'.
* 'err_avg' is the desired average compression error.
* 'err_max' is the desired pointwise max compression error.
* 'err_command' is the code of a command that inputs the two images
'[reference]' and '[compressed]' and compute a single error map
as a last image.
Defaults values: 'method=3', 'max_keypoints=0',
'err_avg=1%', 'err_max=5%' and 'err_command=-. [0] norm.'

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'.

delete (+):
filename1[,filename2,...]

Delete specified filenames on disk. Multiple filenames must be separated
by commas.

d:
Shortcut for command 'display'.

display:

Display selected images in an interactive window.
(equivalent to shortcut command 'd').

When invoked with a '+' prefix (i.e. '+display'), the command
outputs its log messages on 'stdout' rather than on 'stderr'.
Display window #0 is used as the default window for the display, if
already opened.

Available controls are shown below (where 'LMB' = Left mouse button,
'RMB' = Right mouse button, 'MMB' = Middle mouse button and
'MW' = Mouse wheel).

* Thumbnail navigation bar:
'TAB': Show/hide thumbnails - 'LMB': Select thumbnail or shift
thumbnail bar - '0'-'9','ARROWS' (opt. '+SHIFT'),
'B','BACKSPACE','C','E','END','H',
'HOME','SPACE': Navigate and select thumbnails (add
'CTRL' if mouse pointer is outside thumbnail bar).

* Image view:
'LMB' or 'MMB': Image pan - 'RMB' or 'MW': Image
zoom - 'ARROWS' (opt. '+SHIFT'),'HOME','END': Shift
view - 'A': Switch alpha rendering - 'C': Center view -
'E': Go to lower-right corner - 'ENTER': Reset view -
'G': Toggle grid - 'H': Go to upper-left corner - 'K':
Switch background - 'M': Toggle 3D view - 'N': Switch
normalization - 'P': Print info about current image pixel on
'stdout' - 'PAGEUP' or 'PAGEDOWN': Raise/lower base
channel - 'R': Rotate image - 'V': Crop image - 'Z':
Switch zoom factor - '0'-'9': Set zoom factor.

* 3D mesh view:
'LMB': Mesh rotation - 'CTRL+LMB' or 'MMB': Mesh pan -
'RMB': Mesh zoom - 'A': Toggle axes - 'D': Switch face
side mode - 'F': Change focale - 'J': Start/stop animation -
'K': Switch background - 'O': Switch outline mode - 'P':
Print 3D pose matrix on 'stdout' - 'R': Switch rendering mode -
'T': Switch motion rendering mode - 'X': Show/hide bounding-box
- 'U': Switch animation mode - 'Z': Toggle z-buffer.

* 2D images specific:
'CTRL+LMB': Rectangular selection.

* 3D volumetric images specific:
'CTRL+MW': Pan along orthogonal axis - 'X': Reset area layout.

* Window size, decoration and data I/O:
'CTRL+C': Decrease window size - 'CTRL+D': Increase window
size - 'CTRL+F': Toggle fullscreen - 'CTRL+I': Toggle info
label - 'CTRL+O': Save copy of image as a '.gmz' file -
'CTRL+L': Save copy of image list as '.gmz' file - 'CTRL+S':
Save screenshot as a '.png' file - 'CTRL+W': Start/stop window
recording - 'CTRL+X': Toggle cursor.

* Configuration variables:
The viewer configuration can be tuned by assigning the following variables:
- '_display_selected' is an integer or an image name that tells
which image is selected by default.
- '_display_alpha' can be { 0:off | 1:on | 2:over black |
3:over gray | 4:over white } (default value: '0').
- '_display_background', an integer in range [ 0,9 ] (default
value: '3').
- '_display_cursor' can be { 0:off | 1:on (2D only) | 2:on
(+3D volumetric images) } (default value: '1').
- '_display_is_grid' can be { 0:off | 1:on } (default
value: '1').
- '_display_is_info' can be { 0:off | 1:on } (default
value: '1').
- '_display_normalization' can be { -1:auto | 0:off | 1:cut |
2:stretch channelwise | 3:stretch global | 4: stretch (global once) }
(default value: '-1').
- '_display_print_images' can be { 0:off | N>0 } (default
value: '5'). It sets the max number 'N' of images whose
information is initially printed on 'stderr' or 'stdout'.
- '_display_3d_is_rendered' can be { 0:off | 1:on }
(default value: '1').
- '_display_3d_rendering_mode' can be { 0:dots | 1:wireframe
| 2:flat | 3:flat-shaded | 4:gouraud-shaded | 5=phong-shaded } (default
value: '4').
- '_display_3d_outline_mode' can be { 0:no-outline |
1:black-outline | 2:gray-outline | 3:red-outline | 4:green-outline |
5:blue-outline | 6:white-outline } (default value: '0').
- '_display_3d_motion_rendering_mode' can be {
-1:bounding-box | 0:dots | 1:wireframe | 2:flat | 3:flat-shaded |
4:gouraud-shaded | 5=phong-shaded } (default value: '3').
- '_display_3d_motion_time_limit' is specified in ms. Above this
time, motion rendering toggle to 'bounding-box' mode (default value:
'300').
- '_display_3d_side_mode' can be { 0:single-sided |
1:double-sided | 2:single-sided (flipped) } (default value: '0').
- '_display_3d_is_zbuffer' can be { 0:off | 1:on }
(default value: '1').
- '_display_3d_focale' can be { <0: perspective projection
w/o sprite zooming, 0: parallel projection | >0: perspective projection
} (default value: 1.5).
- '_display_3d_is_axes' can be { 0:off | 1:on } (default
value: '1').
- '_display_3d_is_bounding_box' can be { 0:off | 1:on }
(default value: '0').
- '_display_3d_background' is an unsigned integer in range [0,
11] (default value: '11').
- '_display_3d_pose' is a sequence of 12 values that defines the
current 3D pose matrix (read/write).
- '_display_3d_animation' can be { 0:off | 1:forward |
2:backward } (default value: '0').
- '_display_3d_animation_mode' can be { 0-3:X-axis |
4-7:Y-axis | 8-11:Z-axis | 12-15:XYZ-axes } (default value: '4').

d0:
Shortcut for command 'display0'.

display0:

Display selected images in an interactive window, without normalization
and alpha mode activated.

da:
Shortcut for command 'display_array'.

display_array:
_width>0,_height>0

Display images in interactive windows where pixel neighborhoods can be
explored.

Default values: 'width=13' and 'height=width'.

dc:
Shortcut for command 'display_camera'.

display_camera:

Open camera viewer.
This command requires features from the OpenCV library (not enabled in
G'MIC by default).

dclut:
Shortcut for command 'display_clut'.

display_clut:
_image_resolution>0,_clut_resolution>0

Display selected 3D color LUTs.

Default values: 'image_resolution=320' and
'clut_resolution=33'.

Example:
[#1] clut tealorange clut summer clut 60s display_clut 400

dfft:
Shortcut for command 'display_fft'.

display_fft:

Display fourier transform of selected images, with centered log-module and
argument.
(equivalent to shortcut command 'dfft').

Example:
[#1] image.jpg +display_fft

dg:
Shortcut for command 'display_graph'.

display_graph:
_width>=0,_height>=0,_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.
if specified 'width' or 'height' is '0', then image size
is set to half the screen size.

Default values: 'width=0', 'height=0',
'plot_type=1', 'vertex_type=1', 'xmin=xmax=ymin=ymax=0
(auto)', 'xlabel="x-axis"' and 'ylabel="y-axis"'.

Example:
[#1] 128,1,1,1,'cos(x/10+u)' +display_graph 400,300,3

dh:
Shortcut for command 'display_histogram'.

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 images have several slices, the rendering is performed for all
input slices.
'expression' is a mathematical expression used to transform the
histogram data for visualization purpose.
(equivalent to shortcut command 'dh').

if specified 'width' or 'height' is '0', then image size
is set to half the screen size.

Default values: 'width=0', 'height=0',
'clusters=256', 'min_value=0%', 'max_value=100%',
'show_axes=1' and 'expression=i'.

Example:
[#1] image.jpg +display_histogram 512,300

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"'.

Example:
[#1] 1024,1,1,2,'t=x/40;(!c?sin(t):cos(t))*(exp(cos(t))-2*cos(4*t)-sin(t
/12)^5)' display_parametric 512,512
[#2] 1000,1,1,2,u(-100,100) quantize 4,1 noise 12 channels 0,2
+normalize 0,255 append c display_parametric 512,512,0.1,8

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.
'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"'.

Example:
[#1] 300,1,1,1,'0.3+abs(cos(10*pi*x/w))+u(0.4)' display_polar 512,512,4,
200,255,200
[#2] 3000,1,1,1,'x^3/1e10' display_polar 400,400,1,-1,,,0,{15*360}

dq:
Shortcut for command 'display_quiver'.

display_quiver:
_size_factor>0,_arrow_size>=0,_color_mode={ 0:monochrome | 1:grayscale |
2:color }

Render selected images of 2D vectors as a field of 2D arrows.
(equivalent to shortcut command 'dq').

Default values: 'size_factor=16', 'arrow_size=1.5' and
'color_mode=1'.

Example:
[#1] image.jpg +luminance gradient[-1] xy rv[-2,-1] *[-2] -1 a[-2,-1] c
crop 60,10,90,30 +display_quiver[1] ,

drgba:
Shortcut for command 'display_rgba'.

display_rgba:
_background_RGB_color

Render selected RGBA images over a checkerboard or colored background.
(equivalent to shortcut command 'drgba').

Default values: 'background_RGB_color=undefined'
(checkerboard).

Example:
[#1] image.jpg +norm threshold[-1] 40% blur[-1] 3 normalize[-1] 0,255
append c display_rgba

dt:
Shortcut for command 'display_tensors'.

display_tensors:
_size_factor>0,_ellipse_size>=0,_color_mode={ 0:monochrome | 1:grayscale |
2:color },_outline>=0

Render selected images of tensors as a field of 2D ellipses.
(equivalent to shortcut command 'dt').

Default values: 'size_factor=16', 'ellipse_size=1.5',
'color_mode=2' and 'outline=2'.

Example:
[#1] image.jpg +diffusiontensors 0.1,0.9 rescale2d. 64
+display_tensors. 16,2

Tutorial: https://gmic.eu/oldtutorial/_display_tensors

dv3d:
Shortcut for command 'display_voxels3d'.

display_voxels3d:

Display selected images as set of 3D voxels.
(equivalent to shortcut command 'dv3d').

dw:
Shortcut for command 'display_warp'.

display_warp:
_cell_size>0

Render selected 2D warping fields.
(equivalent to shortcut command 'dw').

Default value: 'cell_size=15'.

Example:
[#1] 400,400,1,2,'x=x-w/2;y=y-h/2;r=sqrt(x*x+y*y);a=atan2(y,
x);5*sin(r/10)*[cos(a),sin(a)]' +display_warp 10

e (+):
Shortcut for command 'echo'.

echo (+):
message

Output specified message on the error output.
(equivalent to shortcut command 'e').

Command selection (if any) stands for displayed call stack subset instead
of image indices.
When invoked with a '+' prefix (i.e. '+echo'), the command
output its message on stdout rather than stderr.

echo_file:
filename,message

Output specified message, appending it to specified output file.
(similar to 'echo' for specified output file stream).

font:
{ 'Font_name' | font_number | font.gmz },_font_height[%]>0,_is_bold={ 0 |
1 }

Return font identifier (variable name) that can be further used in command
'text' as a custom font.
'Font_name' can be { Acme | Arial | Arial Black | Black Ops One |
BlackChancery | Cabin Sketch | Caprasimo | Carnevalee Freakshow | Cheese
Burger | Cheque | Cheque-Black | Chlorinar | Comic Sans MS | Courier New |
Creepster | Georgia | Impact | Lobster | Luckiest Guy | Macondo |
MedievalSharp | Odin Rounded | Oswald | Palatino Linotype | Playfair
Display | Roboto | Sacramento | Satisfy | Sofia | Tex Gyre Adventor | Times
New Roman | Titan One | Verdana }.
If a filename 'font.gmz' is specified, it must be a file converted
with command 'font2gmz'.

Default values: 'font_height=64' and 'is_bold=0'.

Example:
[#1] 400,300,1,3 text "Hello World!",0.5~,0.5~,${"font
Burger

font2gmz:
_font_name,_font_size>0,_font_qualifier

Convert specified font to G'MIC format, so that it can be used as a custom
font for command 'text'.
'font_name' can be either a filename as 'font.ttf', or a
'Google Font Name'.
This command requires the command line tool 'cutycapt' to be installed
on your system.
Beware, 'font_size' is the size of font used for the rendering, it
does not correspond to the font height.

Default values: 'font_name=Sofia', 'font_size=24' and
'font_qualifier=""'.

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).

Example:
[#1] function1d 1,0,0,10,30,40,20,70,30,80,0 +display_graph 400,300

identity:
_width>=0,_height>=0,_depth>=0

Insert an identity map of given size at the end of the image list.

Default values: 'height=width' and 'depth=1'.

Example:
[#1] identity 5,1 identity 8,8

i (+):
Shortcut for command 'input'.

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{,|;|/|^}...[:{x|y|z|c|,|;|/|^}]) |
0

Insert a new image taken from a filename or from a copy of an existing
image [index],
or insert new image with specified dimensions and values. Single quotes
may be omitted in
'formula'. Specifying argument '0' inserts an 'empty'
image.
(equivalent to shortcut command 'i').

Default values: 'nb_copies=1', 'height=depth=spectrum=1'
and 'value1=0'.

Example:
[#1] input image.jpg
[#2] input (1,2,3;4,5,6;7,8,9^9,8,7;6,5,4;3,2,1)
[#3] image.jpg (1,2,3;4,5,6;7,8,9) (255^128^64) 400,400,1,3,
'(x>w/2?x:y)*c'

Tutorial: https://gmic.eu/tutorial/input

input_565:
filename,width>0,height>0,reverse_endianness={ 0 | 1 }

Insert image data from a raw RGB-565 file, at the end of the list.

Default value: 'reverse_endianness=0'.

ib:
Shortcut for command 'input_bytes'.

input_bytes:
filename

Input specified filename as a 1D array of bytes.
(equivalent to shortcut command 'ib').

input_csv:
"filename",_read_data_as={ 0:numbers | 1:strings | _variable_name }

Insert number of string array from specified .csv file.
If 'variable_name' is provided, the string of each cell is stored in
a numbered variable '_variable_name_x_y', where 'x' and
'y' are the indices of the cell column and row respectively (starting
from '0').
Otherwise, a 'WxH' image is inserted at the end of the list, with
each vector-valued pixel 'I(x,y)' encoding the number or the string
of each cell.
This command returns the 'W,H' dimension of the read array, as the
status.

Default value: 'read_data_as=1'.

input_cube:
"filename",_convert_1d_cluts_to_3d={ 0 | 1 }.

Insert CLUT data from a .cube filename (Adobe CLUT file format).

Default value: 'convert_1d_cluts_to_3d=1'.

input_flo:
"filename"

Insert optical flow data from a .flo filename (vision.middlebury.edu file
format).

ig:
Shortcut for command 'input_glob'.

input_glob:
pattern

Insert new images from several filenames that match the specified glob
pattern.
(equivalent to shortcut command 'ig').

input_gpl:
filename

Input specified filename as a .gpl palette data file.

input_cached:
"basename.ext",_try_downloading_from_gmic_server={ 0 | 1 }

Input specified filename, assumed to be stored in one of the G'MIC
resource folder.
If file not found and 'try_downloading=1', file is downloaded from
the G'MIC server and stored
in the '${-path_cache}' folder.

Default value: 'try_downloading_from_gmic_server=1'.

input_obj:
filename

Input specified 3D mesh from a .obj Wavefront file.

it:
Shortcut for command 'input_text'.

input_text:
filename

Input specified text-data filename as a new image.
(equivalent to shortcut command 'it').

lorem:
_width>0,_height>0

Input random image of specified size, retrieved from Internet.

Default values: 'width=height=800'.

network (+):
mode={ -1=disabled | 0:enabled w/o timeout | >0:enabled w/ specified
timeout in seconds }

Enable/disable load-from-network and set corresponding timeout.
(Default mode is 'enabled w/o timeout').

o (+):
Shortcut for command 'output'.

output (+):
[type:]filename,_format_options

Output selected images as one or several numbered file(s).
(equivalent to shortcut command 'o').

Default value: 'format_options'=(undefined).

output_565:
"filename",reverse_endianness={ 0:false | 1:true }

Output selected images as raw RGB-565 files.

Default value: 'reverse_endianness=0'.

output_cube:
"filename"

Output selected CLUTs as a .cube file (Adobe CLUT format).

output_flo:
"filename"

Output selected optical flow as a .flo file (vision.middlebury.edu file
format).

output_ggr:
filename,_gradient_name

Output selected images as .ggr gradient files (GIMP).
If no gradient name is specified, it is deduced from the filename.

output_gmz:
filename,_datatype

Output selected images as .gmz files (G'MIC native file format).
'datatype' can be { bool | uint8 | int8 | uint16 | int16 | uint32
| int32 | uint64 | int64 | float32 | float64 }.

output_obj:
filename,_save_materials={ 0:no | 1:yes }

Output selected 3D meshes as Wavefront 3D object files.
Set 'save_materials' to '1' to produce a corresponding
material file ('.mtl') and eventually texture files.
Beware, the export to '.obj' files may be quite slow for large 3D
objects.

Default value: 'save_materials=1'.

ot:
Shortcut for command 'output_text'.

output_text:
filename

Output selected images as text-data filenames.
(equivalent to shortcut command 'ot').

on:
Shortcut for command 'outputn'.

outputn:
filename,_index

Output selected images as automatically numbered filenames in
repeat...done loops.
(equivalent to shortcut command 'on').

op:
Shortcut for command 'outputp'.

outputp:
prefix

Output selected images as prefixed versions of their original filenames.
(equivalent to shortcut command 'op').

Default value: 'prefix=_'.

ow:
Shortcut for command 'outputw'.

outputw:

Output selected images by overwriting their original location.
(equivalent to shortcut command 'ow').

ox:
Shortcut for command 'outputx'.

outputx:
extension1,_extension2,_...,_extensionN,_output_at_same_location={ 0 | 1 }

Output selected images with same base filenames but for N different
extensions.
(equivalent to shortcut command 'ox').

Default value: 'output_at_same_location=0'.

parse_cli:
_output_mode,_{ * | command_name }

Parse definition of '@cli'-documented commands and output info about
them in specified output mode.
'output_mode' can be { ascii | bashcompletion | html | images |
print }.

Default values: 'output_mode=print' and 'command_name=*'.

parse_gmd:

Parse and tokenize selected images, viewed as text strings formatted with
the G'MIC markdown syntax.

gmd2html:
_include_default_header_footer={ 0:none | 1:Reference | 2:Tutorial |
3:News } |
(no arg)

Convert selected gmd-formatted text images to html format.

Default values: 'include_default_header_footer=1'.

gmd2ascii:
_max_line_length>0,_indent_forced_newlines>=0 |
(no arg)

Convert selected gmd-formatted text images to ascii format.

Default values: 'max_line_length=80' and
'indent_forced_newline=0'.

parse_gui:
_outputmode,_{ * | filter_name}

Parse selected filter definitions and generate info about filters in
selected output mode.
'outputmode' can be { gmicol | images | json | list | print |
strings | update | zart }.
It is possible to define a custom output mode, by implementing the
following commands
('outputmode' must be replaced by the name of the custom user output
mode):
. 'parse_gui_outputmode' : A command that outputs the parsing
information with a custom format.
. 'parse_gui_parseparams_outputmode' (optional): A simple command
that returns 0 or 1. It tells the parser whether parameters of matching
filter must be analyzed (slower) or not.
. 'parse_gui_trigger_outputmode' (optional): A command that is
called by the parser just before parsing the set of each matching filters.
Here is the list of global variables set by the parser, accessible in
command 'parse_gui_outputmode':
'$_nb_filters': Number of matching filters.
'$_nongui' (stored as an image): All merged lines in the file that
do not correspond to '#@gui' lines.
For each filter ' * '$_fF_name' : Filter name.
* '$_fF_path' : Full path.
* '$_fF_locale' : Filter locale (empty, if not specified).
* '$_fF_command' : Filter command.
* '$_fF_command_preview' : Filter preview command (empty, if not
specified).
* '$_fF_zoom_factor' : Default zoom factor (empty, if not
specified).
* '$_fF_preview_accuracy' : Preview accuracy (can be { 0:does
not support zoom in/out | 1:support zoom in/out | 2:pixel-perfect }).
* '$_fF_input_mode' : Default preferred input mode (empty, if not
specified).
* '$_fF_hide' : Path of filter hid by current filter (for localized
filters, empty if not specified).
* '$_fF_nb_params' : Number of parameters.
For each parameter ' $_fF_nb_params-1]'):
* '$_fF_pP_name' : Parameter name.
* '$_fF_pP_type' : Parameter type.
* '$_fF_pP_responsivity' : Parameter responsivity (can be { 0 |
1 }).
* '$_fF_pP_visibility' : Parameter visibility.
* '$_fF_pP_propagation' : Propagation of the parameter visibility.
* '$_fF_pP_nb_args' : Number of parameter arguments.
For each argument ' $_fF_pP_nb_args-1]'):
* '$_fF_pP_aA' : Argument value
Default parameters: 'filter_name=*' and 'output_format=print'.

pass (+):
_shared_state={ -1:status only | 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.
This commands return the list of corresponding indices in the status.

Default value: 'shared_state=2'.

Example:
[#1] command "average : pass$""1 add[^-1] [-1] remove[-1] div 2" sample
? +mirror y +average[0] [1]

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 images 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'.

poincare_disk:
_size>=0,_p>2,_q>2,_angle,_tiling={ 0:triangular | 1:polygonal },
_nb_max_iter>=0,_xmin,_ymin,_xmax,_ymax

Return a 3-channels image of a poincare disk. Output channels are '[x,y,
it]'.

Default values: 'size=1024', 'p=5', 'q=3',
'angle=0', 'tiling=0', 'nb_max_iter=20',
'xmin=ymin=-1' and 'xmax=ymax=1'.
repeat 4 { poincare_disk 1024,{3+$>} channels[-1] 2 mod[-1] 3
neq[-1] 2 } rescale2d 50%

portrait:
_size>0

Input random portrait image of specified size, retrieved from Internet.

Default values: 'size=800'.

p:
Shortcut for command 'print'.

print:

Print information on selected images, on the standard error
('stderr').
(equivalent to shortcut command 'p').

When invoked with a '+' prefix (i.e. '+print'), the command
outputs on 'stdout' rather than on 'stderr'.

random_pattern:
_width>0,_height>0,_min_detail_level>=0

Insert a new RGB image of specified size at the end of the image list,
rendered with a random pattern.

Default values: 'width=height=512' and
'min_detail_level=2'.

Example:
[#1] repeat 6 { random_pattern 256 }

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[%]>=0,_Y[%]>=0,_Z[%]>=0,_exit_on_anykey={ 0 | 1 },
_is_deep_selection={ 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.

Default values: 'X=Y=Z=(undefined)', 'exit_on_anykey=0'
and 'is_deep_selection=0'.

serialize (+):
_datatype,_is_compressed={ 0 | 1 },_store_names={ 0 | 1 }

Serialize selected list of images into a single image, optionally in a
compressed form.
'datatype' can be { auto | uint8 | int8 | uint16 | int16 | uint32
| int32 | uint64 | int64 | float32 | float64 }.
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=auto', 'is_compressed=1' and
'store_names=1'.

Example:
[#1] image.jpg +serialize uint8 +unserialize[-1]

shape_circle:
_size>=0

Input a 2D circle binary shape with specified size.

Default value: 'size=512'.

Example:
[#1] shape_circle ,

shape_cupid:
_size>=0

Input a 2D cupid binary shape with specified size.

Default value: 'size=512'.

Example:
[#1] shape_cupid ,

shape_diamond:
_size>=0

Input a 2D diamond binary shape with specified size.

Default value: 'size=512'.

Example:
[#1] shape_diamond ,

shape_dragon:
_size>=0,_recursion_level>=0,_angle

Input a 2D Dragon curve with specified size.

Default value: 'size=512', 'recursion_level=18' and
'angle=0'.

Example:
[#1] shape_dragon ,

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'.

Example:
[#1] shape_fern ,

shape_gear:
_size>=0,_nb_teeth>0,0<=_height_teeth<=100,0<=_offset_teeth<=100,
0<=_inner_radius<=100

Input a 2D gear binary shape with specified size.

Default value: 'size=512', 'nb_teeth=12',
'height_teeth=20', 'offset_teeth=0' and
'inner_radius=40'.

Example:
[#1] shape_gear ,

shape_heart:
_size>=0

Input a 2D heart binary shape with specified size.

Default value: 'size=512'.

Example:
[#1] shape_heart ,

shape_menger:
_nb_iterations>=0

Input a 3D voxelized representation of the Menger sponge.

Default value: 'nb_iterations=3'.

Example:
[#1] shape_menger 4 surfels3d , color3d 200 m3d 3

shape_mosely:
_nb_iterations>=0

Input a 3D voxelized representation of the Mosely snowflake.

Default value: 'nb_iterations=3'.

Example:
[#1] shape_mosely 4 surfels3d , color3d 200 m3d 3

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'.

Example:
[#1] repeat 6 { shape_polygon 256,{3+$>} }

shape_rays:
_size>=0,_xcenter[%],_ycenter[%],_branches>0,_angle[%],_twist,
0<=_perspective<=1,_is_antialias={ 0 | 1 }

Input a 3D binary spiral with specified size and attributes.

Default values: 'size=512', 'xcenter=50%',
'ycenter=50%', 'branches=7', 'angle=50%',
'twist=0', 'perspective=0.35' and 'is_antialias=0'.

Example:
[#1] shape_rays 400,50%,50%,7 shape_rays 400,50%,50%,3,0,3

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'.

Example:
[#1] repeat 6 { shape_snowflake 256,$> }

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'.

Example:
[#1] repeat 9 { shape_star 256,{$>+2} }

sh (+):
Shortcut for command 'shared'.

shared (+):
x0[%],x1[%],y[%],z[%],c[%] |
y0[%],y1[%],z[%],c[%] |
z0[%],z1[%],c[%] |
c0[%],c1[%] |
c0[%] |
(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.
(equivalent to shortcut command 'sh').

Example:
[#1] image.jpg shared 1 blur[-1] 3 remove[-1]
[#2] image.jpg repeat s { shared 25%,75%,0,$> mirror[-1] x remove[-1] }

Tutorial: https://gmic.eu/oldtutorial/_shared

sp:
Shortcut for command 'sample'.

sample:
_name1={ ? | apples | balloons | barbara | boats | bottles | butterfly |
cameraman | car | cat | cliff | chick | colorful | david | dog |
duck | eagle | elephant | earth | flower | fruits | gmicky |
gmicky_mahvin | gmicky_wilber | greece | gummy | house | inside |
landscape | leaf | lena | leno | lion | mandrill | monalisa |
monkey | parrots | pencils | peppers | portrait0 | portrait1 |
portrait2 | portrait3 | portrait4 | portrait5 | portrait6 |
portrait7 | portrait8 | portrait9 | roddy | rooster | rose | square
| swan | teddy | tiger | tulips | wall | waterfall | zelda },_name2,
...,_nameN,_width={ >=0 | 0 (auto) },_height = { >=0 | 0 (auto) } |
(no arg)

Input a new sample RGB image (opt. with specified size).
(equivalent to shortcut command 'sp').

Argument 'name' can be replaced by an integer which serves as a
sample index.

Example:
[#1] repeat 6 { sample }

srand (+):
value |
(no arg)

Set random generator seed.
If no argument is specified, a random value is used as the random
generator seed.

store (+):
_is_compressed={ 0 | 1 },variable_name1,_variable_name2,...

Store selected images into one or several named variables.
Selected images are transferred to the variables, and are so removed from
the image list.
(except if the prepended variant of the command '+store[selection]'
is used).
If a single variable name is specified, all images of the selection are
assigned
to the named variable. Otherwise, there must be as many variable names as
images
in the selection, and each selected image is assigned to each specified
named variable.
Use command 'input $variable_name' to bring the stored images back in
the list.

Default value: 'is_compressed=0'.

Example:
[#1] sample eagle,earth store img1,img2 input $img2 $img1

Tutorial: https://gmic.eu/tutorial/store

testimage2d:
_width>0,_height>0,_spectrum>0

Input a 2D synthetic image.

Default values: 'width=512', 'height=width' and
'spectrum=3'.

Example:
[#1] testimage2d 512

um:
Shortcut for command 'uncommand'.

uncommand (+):
command_name[,_command_name2,...] |
*

Discard definition of specified custom commands.
Set argument to '*' for discarding all existing custom commands.
(equivalent to shortcut command 'um').

uniform_distribution:
nb_levels>=1,spectrum>=1

Input set of uniformly distributed spectrum-d points in [0,1]^spectrum.

Example:
[#1] uniform_distribution 64,3 * 255 +distribution3d circles3d[-1] 10

unserialize (+):

Recreate lists of images from serialized image buffers, obtained with
command 'serialize'.

up:
Shortcut for command 'update'.

update:

Update commands from the latest definition file on the G'MIC server.
(equivalent to shortcut command 'up').

v (+):
Shortcut for command 'verbose'.

verbose (+):
level |
{ + | - }

Set or increment/decrement the verbosity level. Default level is 0.
(equivalent to shortcut command 'v').

When 'level>0', G'MIC log messages are displayed on the standard
error (stderr).

Default value: 'level=1'.

wait (+):
delay |
(no arg)

Wait for a given delay (in ms), optionally since the last call to
'wait'.
or wait for a user event occurring 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.

w (+):
Shortcut for command 'window'.

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.
(equivalent to shortcut command 'w').

If 'width' or 'height' is set to -1, the corresponding
dimension is adjusted to the window
or image size.
Specify 'pos_x' and 'pos_y' arguments only if the window has
to be moved to the specified
coordinates. Otherwise, they can be avoided.
'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 it
has been closed by the user.

Default values: 'width=height=normalization=fullscreen=-1' and
'title=(undefined)'.

11.3. List Manipulation
-----------------

k (+):
Shortcut for command 'keep'.

keep (+):

Keep only selected images.
(equivalent to shortcut command 'k').

Example:
[#1] image.jpg split x keep[0-50%:2] append x
[#2] image.jpg split x keep[^30%-70%] append x

kn:
Shortcut for command 'keep_named'.

keep_named:
"name1","name2",...

Keep all images with specified names from the list of images.
Remove all images if no images with those names exist.
(equivalent to shortcut command 'kmn').

mv (+):
Shortcut for command 'move'.

move (+):
position[%]

Move selected images at specified position.
Images are actually inserted between current positions 'position-1'
and 'position'.
(equivalent to shortcut command 'mv').

Example:
[#1] image.jpg split x,3 move[1] 0
[#2] image.jpg split x move[50%--1:2] 0 append x

nm (+):
Shortcut for command 'name'.

=> (+):
Shortcut for command 'name'.

name (+):
"name1","name2",...,"nameN"

Set names of selected images.
* If no explicit image selection is given, image selection is assumed to
be '[-N--1]', where 'N' is the number of specified arguments.
* If 'N' is higher than the number of images in selection, an error
is thrown.
* If 'N' is lower than the number of images in selection, image
names are assigned in a periodic way, i.e. 'name(selection[k]) =
arg[k%N]'.
(equivalent to shortcut command '=>').

Example:
[#1] image.jpg name image blur[image] 2

Tutorial: https://gmic.eu/tutorial/name

rm (+):
Shortcut for command 'remove'.

remove (+):

Remove selected images.
(equivalent to shortcut command 'rm').

Example:
[#1] image.jpg split x remove[30%-70%] append x
[#2] image.jpg split x remove[0-50%:2] append x

remove_duplicates:

Remove duplicates images in the selected images list.

Example:
[#1] (1,2,3,4,2,4,3,1,3,4,2,1) split x remove_duplicates append x

remove_empty:

Remove empty images in the selected image list.

rmn:
Shortcut for command 'remove_named'.

remove_named:
"name1","name2",...

Remove all images with specified names from the list of images.
Does nothing if no images with those names exist.
(equivalent to shortcut command 'rmn').

rv (+):
Shortcut for command 'reverse'.

reverse (+):

Reverse positions of selected images.
(equivalent to shortcut command 'rv').

Example:
[#1] image.jpg split x,3 reverse[-2,-1]
[#2] image.jpg split x,-16 reverse[50%-100%] append x

sort_list:
_ordering={ + | - },_criterion

Sort list of selected images according to the specified image criterion.

Default values: 'ordering=+', 'criterion=i'.

Example:
[#1] (1;4;7;3;9;2;4;7;6;3;9;1;0;3;3;2) split y sort_list +,i append y

11.4. Mathematical Operators
----------------------

abs (+):

Compute the pointwise absolute values of selected images.

Example:
[#1] image.jpg +sub {ia} abs[-1]
[#2] 300,1,1,1,'cos(20*x/w)' +abs display_graph 400,300

acos (+):

Compute the pointwise arccosine of selected images.

Example:
[#1] image.jpg +normalize -1,1 acos[-1]
[#2] 300,1,1,1,'cut(x/w+0.1*u,0,1)' +acos display_graph 400,300

Tutorial: https://gmic.eu/oldtutorial/trigometric-and-inverse-trigometric-commands

acosh (+):

Compute the pointwise hyperbolic arccosine of selected images.

+ (+):
Shortcut for command 'add'.

add (+):
value[%] |
[image] |
'formula' |
(no arg)

Add specified value, image or mathematical expression to selected images,
or compute the pointwise sum of selected images.
(equivalent to shortcut command '+').

Example:
[#1] image.jpg +add 30% cut 0,255
[#2] image.jpg +blur 5 normalize 0,255 add[1] [0]
[#3] image.jpg add '80*cos(80*(x/w-0.5)*(y/w-0.5)+c)' cut 0,255
[#4] image.jpg repeat 9 { +rotate[0] {$>*36},1,0,50%,50% } add div 10

& (+):
Shortcut for command 'and'.

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.
(equivalent to shortcut command '&').

Example:
[#1] image.jpg and {128+64}
[#2] image.jpg +mirror x and

argmax:

Compute the argmax of selected images. Returns a single image
with each pixel value being the index of the input image with maximal
value.

Example:
[#1] image.jpg sample lena,lion,square +argmax

argmaxabs:

Compute the argmaxabs of selected images. Returns a single image
with each pixel value being the index of the input image with maxabs value.

argmin:

Compute the argmin of selected images. Returns a single image
with each pixel value being the index of the input image with minimal
value.

Example:
[#1] image.jpg sample lena,lion,square +argmin

argminabs:

Compute the argminabs of selected images. Returns a single image
with each pixel value being the index of the input image with minabs value.

asin (+):

Compute the pointwise arcsine of selected images.

Example:
[#1] image.jpg +normalize -1,1 asin[-1]
[#2] 300,1,1,1,'cut(x/w+0.1*u,0,1)' +asin display_graph 400,300

Tutorial: https://gmic.eu/oldtutorial/trigometric-and-inverse-trigometric-commands

asinh (+):

Compute the pointwise hyperbolic arcsine of selected images.

atan (+):

Compute the pointwise arctangent of selected images.

Example:
[#1] image.jpg +normalize 0,8 atan[-1]
[#2] 300,1,1,1,'4*x/w+u' +atan display_graph 400,300

Tutorial: https://gmic.eu/oldtutorial/trigometric-and-inverse-trigometric-commands

atan2 (+):
[x_argument]

Compute the pointwise oriented arctangent of selected images.
Each selected image is regarded as the y-argument of the arctangent
function, while the
specified image gives the corresponding x-argument.

Example:
[#1] (-1,1) (-1;1) resize 400,400,1,1,3 atan2[1] [0] keep[1] mod {pi/8}

Tutorial: https://gmic.eu/oldtutorial/trigometric-and-inverse-trigometric-commands

atanh (+):

Compute the pointwise hyperbolic arctangent of selected images.

<< (+):
Shortcut for command 'bsl'.

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.
(equivalent to shortcut command '<<').

Example:
[#1] image.jpg bsl 'round(3*x/w,0)' cut 0,255

>> (+):
Shortcut for command 'bsr'.

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.
(equivalent to shortcut command '>>').

Example:
[#1] image.jpg bsr 'round(3*x/w,0)' cut 0,255

cos (+):

Compute the pointwise cosine of selected images.

Example:
[#1] image.jpg +normalize 0,{2*pi} cos[-1]
[#2] 300,1,1,1,'20*x/w+u' +cos display_graph 400,300

Tutorial: https://gmic.eu/oldtutorial/trigometric-and-inverse-trigometric-commands

cosh (+):

Compute the pointwise hyperbolic cosine of selected images.

Example:
[#1] image.jpg +normalize -3,3 cosh[-1]
[#2] 300,1,1,1,'4*x/w+u' +cosh display_graph 400,300

deg2rad:

Convert pointwise angle values of selected images, from degrees to radians
(apply 'i*pi/180').

/ (+):
Shortcut for command 'div'.

div (+):
value[%] |
[image] |
'formula' |
(no arg)

Divide selected images by specified value, image or mathematical
expression, or compute the pointwise quotient of selected images.
(equivalent to shortcut command '/').

Example:
[#1] image.jpg div '1+abs(cos(x/10)*sin(y/10))'
[#2] image.jpg +norm add[-1] 1 +div

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'.

== (+):
Shortcut for command 'eq'.

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.
(equivalent to shortcut command '==').

Example:
[#1] image.jpg round 40 eq {round(ia,40)}
[#2] image.jpg +mirror x eq

erf (+):

Compute the pointwise error function of selected images.

Example:
[#1] image.jpg +normalize 0,2 erf[-1]
[#2] 300,1,1,1,'7*x/w-3.5+u' +erf display_graph 400,300

exp (+):

Compute the pointwise exponential of selected images.

Example:
[#1] image.jpg +normalize 0,2 exp[-1]
[#2] 300,1,1,1,'7*x/w+u' +exp display_graph 400,300

>= (+):
Shortcut for command 'ge'.

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.
(equivalent to shortcut command '>=').

Example:
[#1] image.jpg ge {ia}
[#2] image.jpg +mirror x ge

> (+):
Shortcut for command 'gt'.

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.
(equivalent to shortcut command '>').

Example:
[#1] image.jpg gt {ia}
[#2] image.jpg +mirror x gt

<= (+):
Shortcut for command 'le'.

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.
(equivalent to shortcut command '<=').

Example:
[#1] image.jpg le {ia}
[#2] image.jpg +mirror x le

< (+):
Shortcut for command 'lt'.

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.
(equivalent to shortcut command '<').

Example:
[#1] image.jpg lt {ia}
[#2] image.jpg +mirror x lt

log (+):

Compute the pointwise base-e logarithm of selected images.

Example:
[#1] image.jpg +add 1 log[-1]
[#2] 300,1,1,1,'7*x/w+u' +log display_graph 400,300

log10 (+):

Compute the pointwise base-10 logarithm of selected images.

Example:
[#1] image.jpg +add 1 log10[-1]
[#2] 300,1,1,1,'7*x/w+u' +log10 display_graph 400,300

log2 (+):

Compute the pointwise base-2 logarithm of selected images

Example:
[#1] image.jpg +add 1 log2[-1]
[#2] 300,1,1,1,'7*x/w+u' +log2 display_graph 400,300

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.

Example:
[#1] image.jpg +mirror x max
[#2] image.jpg max 'R=((x/w-0.5)^2+(y/h-0.5)^2)^0.5;255*R'

maxabs (+):
value[%] |
[image] |
'formula' |
(no arg)

Compute the maxabs between selected images and specified value, image or
mathematical expression, or compute the pointwise maxabs between selected
images.

m/ (+):
Shortcut for command 'mdiv'.

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.
(equivalent to shortcut command 'm/').

med:

Compute the median of selected images.

Example:
[#1] image.jpg sample lena,lion,square +med

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.

Example:
[#1] image.jpg +mirror x min
[#2] image.jpg min 'R=((x/w-0.5)^2+(y/h-0.5)^2)^0.5;255*R'

minabs (+):
value[%] |
[image] |
'formula' |
(no arg)

Compute the minabs between selected images and specified value, image or
mathematical expression, or compute the pointwise minabs between selected
images.

% (+):
Shortcut for command 'mod'.

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.
(equivalent to shortcut command '%').

Example:
[#1] image.jpg +mirror x n. 1,255 round. mod
[#2] image.jpg mod 'R=((x/w-0.5)^2+(y/h-0.5)^2)^0.5;255*R'

m* (+):
Shortcut for command 'mmul'.

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.
(equivalent to shortcut command 'm*').

Example:
[#1] (0,1,0;0,0,1;1,0,0) (1;2;3) +mmul

* (+):
Shortcut for command 'mul'.

mul (+):
value[%] |
[image] |
'formula' |
(no arg)

Multiply selected images by specified value, image or mathematical
expression, or compute the pointwise product of selected images.
(equivalent to shortcut command '*').

See also: add, sub, div.

Example:
[#1] image.jpg +mul 2 cut 0,255
[#2] image.jpg (1,2,3,4,5,6,7,8) ri[-1] [0] mul[0] [-1]
[#3] image.jpg mul '1-3*abs(x/w-0.5)' cut 0,255
[#4] image.jpg +luminance negate[-1] +mul

mul_channels:
value1,_value2,...,_valueN

Multiply channels of selected images by specified sequence of values.

Example:
[#1] image.jpg +mul_channels 1,0.5,0.8

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.

!= (+):
Shortcut for command 'neq'.

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.
(equivalent to shortcut command '!=').

Example:
[#1] image.jpg round 40 neq {round(ia,40)}

| (+):
Shortcut for command 'or'.

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.
(equivalent to shortcut command '|').

Example:
[#1] image.jpg or 128
[#2] image.jpg +mirror x or

^ (+):
Shortcut for command 'pow'.

pow (+):
value[%] |
[image] |
'formula' |
(no arg)

Raise selected images to the power of specified value, image or
mathematical expression, or compute the pointwise sequential powers of
selected images.
(equivalent to shortcut command '^').

Example:
[#1] image.jpg div 255 +pow 0.5 mul 255
[#2] image.jpg gradient pow 2 add pow 0.2

rad2deg:

Convert pointwise angle values of selected images, from radians to degrees
(apply 'i*180/pi').

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.

Example:
[#1] image.jpg rol 'round(3*x/w,0)' cut 0,255

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.

Example:
[#1] image.jpg ror 'round(3*x/w,0)' cut 0,255

sign (+):

Compute the pointwise sign of selected images.

Example:
[#1] image.jpg +sub {ia} sign[-1]
[#2] 300,1,1,1,'cos(20*x/w+u)' +sign display_graph 400,300

sin (+):

Compute the pointwise sine of selected images.

Example:
[#1] image.jpg +normalize 0,{2*pi} sin[-1]
[#2] 300,1,1,1,'20*x/w+u' +sin display_graph 400,300

Tutorial: https://gmic.eu/oldtutorial/trigometric-and-inverse-trigometric-commands

sinc (+):

Compute the pointwise sinc function of selected images.

Example:
[#1] image.jpg +normalize {-2*pi},{2*pi} sinc[-1]
[#2] 300,1,1,1,'20*x/w+u' +sinc display_graph 400,300

sinh (+):

Compute the pointwise hyperbolic sine of selected images.

Example:
[#1] image.jpg +normalize -3,3 sinh[-1]
[#2] 300,1,1,1,'4*x/w+u' +sinh display_graph 400,300

sqr (+):

Compute the pointwise square function of selected images.

Example:
[#1] image.jpg +sqr
[#2] 300,1,1,1,'40*x/w+u' +sqr display_graph 400,300

sqrt (+):

Compute the pointwise square root of selected images.

Example:
[#1] image.jpg +sqrt
[#2] 300,1,1,1,'40*x/w+u' +sqrt display_graph 400,300

- (+):
Shortcut for command 'sub'.

sub (+):
value[%] |
[image] |
'formula' |
(no arg)

Subtract specified value, image or mathematical expression to selected
images, or compute the pointwise difference of selected images.
(equivalent to shortcut command '-').

Example:
[#1] image.jpg +sub 30% cut 0,255
[#2] image.jpg +mirror x sub[-1] [0]
[#3] image.jpg sub 'i(w/2+0.9*(x-w/2),y)'
[#4] image.jpg +mirror x sub

tan (+):

Compute the pointwise tangent of selected images.

Example:
[#1] image.jpg +normalize {-0.47*pi},{0.47*pi} tan[-1]
[#2] 300,1,1,1,'20*x/w+u' +tan display_graph 400,300

Tutorial: https://gmic.eu/oldtutorial/trigometric-and-inverse-trigometric-commands

tanh (+):

Compute the pointwise hyperbolic tangent of selected images.

Example:
[#1] image.jpg +normalize -3,3 tanh[-1]
[#2] 300,1,1,1,'4*x/w+u' +tanh display_graph 400,300

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.

Example:
[#1] image.jpg xor 128
[#2] image.jpg +mirror x xor

11.5. 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'.

Example:
[#1] image.jpg +apply_curve 1,0,0,128,255,255,0

apply_gamma:
gamma>=0

Apply gamma correction to selected images.

Example:
[#1] image.jpg +apply_gamma 2

balance_gamma:
_ref_color1,...

Compute gamma-corrected color balance of selected image, with respect to
specified reference color.

Default value: 'ref_color1=128'.

Example:
[#1] image.jpg +balance_gamma 128,64,64

cast:
datatype_source,datatype_target

Cast datatype of image buffer from specified source type to specified
target type.
'datatype_source' and 'datatype_target' can be { uint8 |
int8 | uint16 | int16 | uint32 | int32 | uint64 | int64 | float32 | float64
}.

complex2polar:

Compute complex to polar transforms of selected images.

Example:
[#1] image.jpg +fft complex2polar[-2,-1] log[-2] shift[-2] 50%,50%,0,0,
2 remove[-1]

compress_clut:

Compress selected color LUTs as sequences of colored keypoints.

compress_huffman:
[huffman_tree],_max_leaf_value

Compress selected images with Huffman coding.
See also: decompress_huffman, huffman_tree.

huffman_tree:

Generate Huffman coding tree from the statistics of all selected images.
Huffman tree is returned as a 1xN image inserted at the end of the image
list, representing the 'N' vector-valued leafs/nodes of the tree,
encoded as '[ value,parent,child0,child1 ]'.
Last row of the returned image corresponds to the tree root.
Selected images must contain only positive integer values.
Return maximal value of the input data in the status.
See also: compress_huffman, decompress_huffman.

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'.

Example:
[#1] image.jpg rescale2d ,100 quantize 4 round +compress_rle ,
+decompress_rle[-1]

cumulate (+):
{ x | y | z | c }...{ x | y | z | c } |
(no arg)

Compute the cumulative function of specified image data, optionally along
the specified axes.

Example:
[#1] image.jpg +histogram 256 +cumulate[-1] display_graph[-2,-1] 400,
300,3

c (+):
Shortcut for command 'cut'.

cut (+):
{ value0[%] | [image0] },{ value1[%] | [image1] } |
[image]

Cut values of selected images in specified range.
(equivalent to shortcut command 'c').

Example:
[#1] image.jpg +add 30% cut[-1] 0,255
[#2] image.jpg +cut 25%,75%

decompress_clut:
_width>0,_height>0,_depth>0

Decompress selected colored keypoints into 3D CLUTs, using a mixed RBF/PDE
approach.

Default values: 'width=height=depth=33' and
'reconstruction_colorspace=0'.

decompress_from_keypoints:
_width>0,_height>0,_depth>0 |
(no arg)

Decompress selected sets of keypoints as images (opt. of specified size).
A set of keypoints is defined as a vector-valued image, such that:
* The first pixel is a vector which encodes the '[ Width,Height,Depth
]' of the decompressed image.
* The second pixel is a vector which encodes '[ Min,Max,Use_RBF ]',
where 'Min' and 'Max' defines the value range of the
decompressed image, and 'Use_RBF' tells is the decompression scheme
must use RBFs ('Use_RBF=1') or Multiscale Diffusion PDE's
('Use_RBF=0').
* The remaining pixels define the keypoint coordinates and values, as:
- '[ x_k,y_k,z_k, v1_k,...,vN_k ]' for a 3D target image of
N-valued vectors.
- '[ x_k,y_k, v1_k,...,vN_k ]' for a 2D target image of N-valued
vectors.
- '[ x_k, v1_k,...,vN_k ]' for a 1D target image of N-valued
vectors.
where the coordinates 'x_k', 'y_k' and 'z_k' are defined
respectively in ranges '[0,Width-1]', '[0,Height-1]' and '[0,
Depth-1]'.
If the 'width', 'height' and 'depth' arguments are
provided, they define the size of the decompressed image, : overriding then
the original image size '[ Width,Height,Depth ]' defined in the
keypoints header.

decompress_huffman:
[huffman_tree]

Decompress selected images with Huffman decoding.
See also: compress_huffman, huffman_tree.

Example:
[#1] image.jpg huffman_tree compress_huffman.. . +decompress_huffman.. .

decompress_rle:

Decompress selected data vectors, 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 arguments are specified, neighboring duplicate values are discarded.
If all pixels of a selected image are discarded, an empty image is
returned.

Example:
[#1] (1;2;3;4;3;2;1) +discard 2
[#2] (1,2,2,3,3,3,4,4,4,4) +discard x

eigen2tensor:

Recompose selected pairs of eigenvalues/eigenvectors as 2x2 or 3x3 tensor
fields.

Tutorial: https://gmic.eu/tutorial/eigen2tensor

endian (+):
_datatype

Reverse data endianness of selected images, eventually considering the
pixel being of the specified datatype.
'datatype' can be { bool | uint8 | int8 | uint16 | int16 | uint32
| int32 | uint64 | int64 | float32 | float64 }.
This command does nothing for 'bool', 'uint8' and 'int8'
datatypes.

equalize (+):
_nb_levels>0[%],_value_min[%],_value_max[%] |
(no arg)

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%'.

Example:
[#1] image.jpg +equalize
[#2] image.jpg +equalize 4,0,128

f (+):
Shortcut for command 'fill'.

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'.
(equivalent to shortcut command 'f').

Example:
[#1] 4,4 fill 1,2,3,4,5,6,7
[#2] 4,4 (1,2,3,4,5,6,7) fill[-2] [-1]
[#3] 400,400,1,3 fill "X=x-w/2; Y=y-h/2; R=sqrt(X^2+Y^2); a=atan2(Y,X);
R<=180?255*abs(cos(c+200*(x/w-0.5)*(y/h-0.5))):850*(a%(0.1*(c
+1)))"

Tutorial: https://gmic.eu/tutorial/fill

index (+):
{ [palette] | palette_name },0<=_dithering<=1,_map_colors={ 0 | 1 }

Index selected vector-valued images by specified vector-valued palette.
'palette_name' can be { default | hsv | lines | hot | cool | jet
| flag | cube | rainbow | algae | amp |balance | curl | deep | delta |
dense | diff | haline | ice | matter | oxy | phase | rain | solar | speed |
tarn |tempo | thermal | topo | turbid | aurora | hocuspocus | srb2 | uzebox
}

Default values: 'dithering=0' and 'map_colors=0'.

Example:
[#1] image.jpg +index 1,1,1
[#2] image.jpg (0;255;255^0;128;255^0;0;255) +index[-2] [-1],1,1

Tutorial: https://gmic.eu/tutorial/gindex

ir:
Shortcut for command 'inrange'.

inrange:
min[%],max[%],_include_min_boundary={ 0:no | 1:yes },
_include_max_boundary={ 0:no | 1:yes }

Detect pixels whose values are in specified range '[min,max]', in
selected images.
(equivalent to shortcut command 'ir').

Default value: 'include_min_boundary=include_max_boundary=1'.

Example:
[#1] image.jpg +inrange 25%,75%

map (+):
[palette],_boundary_conditions |
palette_name,_boundary_conditions

Map specified vector-valued palette to selected indexed images.
Each output image has 'M*N' channels, where 'M' and 'N'
are the numbers of channels of, respectively, the corresponding input image
and the 'palette' image.
'palette_name' can be { default | hsv | lines | hot | cool | jet
| flag | cube | rainbow | algae | amp | balance | curl | deep | delta |
dense | diff | gray | haline | ice | matter | oxy | phase | rain | solar |
speed | tarn | tempo | thermal | topo | turbid | aurora | hocuspocus | srb2
| uzebox }
'boundary_conditions' can be { 0:dirichlet | 1:neumann |
2:periodic | 3:mirror }.

Default value: 'boundary_conditions=0'.

Example:
[#1] image.jpg +luminance map[-1] 3
[#2] image.jpg +rgb2ycbcr split[-1] c (0,255,0) resize[-1] 256,1,1,1,3
map[-4] [-1] remove[-1] append[-3--1] c ycbcr2rgb[-1]

Tutorial: https://gmic.eu/tutorial/map

mix_channels:
(a00,...,aMN) |
[matrix]

Apply specified matrix to channels of selected images.

Example:
[#1] image.jpg +mix_channels (0,1,0;1,0,0;0,0,1)

negate:
base_value |
(no arg)

Negate image values.

Default value: 'base_value=(undefined)'.

Example:
[#1] image.jpg +negate

noise (+):
amplitude>=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'.

Example:
[#1] image.jpg +noise[0] 50,0 +noise[0] 50,1 +noise[0] 10,2 cut 0,255
[#2] 300,300,1,3 [0] noise[0] 20,0 noise[1] 20,1 +histogram 100
display_graph[-2,-1] 400,300,3

noise_perlin:
_scale_x[%]>0,_scale_y[%]>0,_scale_z[%]>0,_seed_x,_seed_y,_seed_z

Render 2D or 3D Perlin noise on selected images, from specified
coordinates.
The Perlin noise is a specific type of smooth noise,
described here : https://en.wikipedia.org/wiki/Perlin_noise.

Default values: 'scale_x=scale_y=scale_z=16' and
'seed_x=seed_y=seed_z=0'.

Example:
[#1] 500,500,1,3 noise_perlin ,

noise_poissondisk:
_radius[%]>0,_max_sample_attempts>0,_p_norm>0

Add poisson disk sampling noise to selected images.
Implements the algorithm from the article "Fast Poisson Disk Sampling in
Arbitrary Dimensions",
by Robert Bridson (SIGGRAPH'2007).

Default values: 'radius=8', 'max_sample_attempts=30' and
'p_norm=2'.

Example:
[#1] 300,300 noise_poissondisk 8

normp:
p>=0

Compute the pointwise Lp-norm norm of vector-valued pixels in selected
images.

Default value: 'p=2'.

Example:
[#1] image.jpg +normp[0] 0 +normp[0] 1 +normp[0] 2 +normp[0] inf

norm1:

Compute the pointwise L1-norm of vector-valued pixels in selected images.

Example:
[#1] image.jpg +norm1

Tutorial: https://gmic.eu/tutorial/norm1

norm:
Shortcut for command 'norm2'.

norm2:

Compute the pointwise L2-norm (euclidean norm) of vector-valued pixels in
selected images.

Example:
[#1] image.jpg +norm

Tutorial: https://gmic.eu/tutorial/norm2

n (+):
Shortcut for command 'normalize'.

normalize (+):
{ value0[%] | [image0] },{ value1[%] | [image1] },_constant_case_ratio |
[image]

Linearly normalize values of selected images in specified range.
(equivalent to shortcut command 'n').

Example:
[#1] image.jpg split x,2 normalize[-1] 64,196 append x

Tutorial: https://gmic.eu/tutorial/normalize

normalize_l2:

Normalize selected images such that they have a unit L2 norm.

normalize_sum:

Normalize selected images such that they have a unit sum.

Example:
[#1] image.jpg +histogram 256 normalize_sum[-1] display_graph[-1] 400,
300

not:

Apply boolean not operation on selected images.

Example:
[#1] image.jpg +ge 50% +not[-1]

orientation:

Compute the pointwise orientation of vector-valued pixels in selected
images.

Example:
[#1] image.jpg +orientation +norm[-2] negate[-1] mul[-2] [-1]
reverse[-2,-1]

Tutorial: https://gmic.eu/tutorial/orientation

oneminus:

For each selected image, compute one minus image.

Example:
[#1] image.jpg normalize 0,1 +oneminus

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'.

Example:
[#1] image.jpg luminance +otsu ,

polar2complex:

Compute polar to complex transforms of selected images.

quantize:
nb_levels>=1,_keep_values={ 0 | 1 },_quantization_type={ -1:median-cut |
0:k-means | 1:uniform }

Quantize selected images.

Default value: 'keep_values=1' and 'quantization_type=0'.

Example:
[#1] image.jpg luminance +quantize 3
[#2] 200,200,1,1,'cos(x/10)*sin(y/10)' +quantize[0] 6 +quantize[0] 4
+quantize[0] 3 +quantize[0] 2

quantize_area:
_min_area>0

Quantize selected images such that each flat region has an area greater or
equal to 'min_area'.

Default value: 'min_area=10'.

Example:
[#1] image.jpg quantize 3 +blur 1 round[-1] +quantize_area[-1] 2

rand (+):
{ value0[%] | [image0] },_{ value1[%] | [image1] },_[pdf],_precision |
[image]

Fill selected images with random values in the specified range.
If no '[pdf]' (probability density function) is specified, random
values follow a uniform distribution.
Argument 'precision' tells about the number of distinct values that
can be generated when a '[pdf]' is specified.

Example:
[#1] 400,400,1,3 rand -10,10 +blur 10 sign[-1]
[#2] (8,2,1) 50,50 rand[-1] 0,255,[-2]
[#3] 256 gaussian[-1] 30 line[-1] 47%,0,53%,0,1,0 500,500 rand[-1] 0,
255,[-2] +histogram[-1] 256 display_graph[0,2] 640,480,3,0

rand_sum:
sum>0,_random_function

Fill selected images with strictly positive, random, integer values, that
sums to 'sum'.
For each image, 'sum' must be greater or equal than
'width*height*depth*spectrum'.

Default value: 'random_function=u'.

Example:
[#1] 100 rand_sum 1000

replace:
source,target

Replace pixel values in selected images.

Example:
[#1] (1;2;3;4) +replace 2,3

replace_inf:
_expression

Replace all infinite values in selected images by specified expression.

Example:
[#1] (0;1;2) log +replace_inf 2

replace_infnan:
_expression

Replace all NaN and infinite values in selected images by specified
expression.

replace_nan:
_expression

Replace all NaN values in selected images by specified expression.

Example:
[#1] (-1;0;2) sqrt +replace_nan 2

replace_seq:
"search_seq","replace_seq"

Search and replace a sequence of values in selected images.

Example:
[#1] (1;2;3;4;5) +replace_seq "2,3,4","7,8"

replace_str:
"search_str","replace_str"

Search and replace a string in selected images (viewed as strings, i.e.
sequences of character codes).

Example:
[#1] ('"Hello there, how are you ?"') +replace_str "Hello there","Hi
David"

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'.

Example:
[#1] image.jpg +round 100
[#2] image.jpg mul {pi/180} sin +round

roundify:
gamma>=0

Apply roundify transformation on float-valued data, with specified gamma.

Default value: 'gamma=0'.

Example:
[#1] 1000 fill '4*x/w' repeat 5 { +roundify[0] {$>*0.2} } append c
display_graph 400,300

= (+):
Shortcut for command 'set'.

set (+):
value,_x[%],_y[%],_z[%],_c[%]

Set pixel value in selected images, at specified coordinates.
(equivalent to shortcut command '=').

If specified coordinates are outside the image bounds, no action is
performed.

Default values: 'x=y=z=c=0'.

Example:
[#1] 2,2 set 1,0,0 set 2,1,0 set 3,0,1 set 4,1,1
[#2] image.jpg repeat 10000 { set 255,{u(100)}%,{u(100)}%,0,{u(100)}% }

threshold:
value[%],_is_soft={ 0 | 1 } :

Threshold values of selected images.
'soft' can be { 0:hard-thresholding | 1:soft-thresholding }.

Default value: 'is_soft=0'.

Example:
[#1] image.jpg +threshold[0] 50% +threshold[0] 50%,1

Tutorial: https://gmic.eu/tutorial/threshold

vector2tensor:

Convert selected vector fields to corresponding tensor fields.

11.6. Colors
------

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'.

Example:
[#1] image.jpg +adjust_colors 0,30,0,0,30

ac:
Shortcut for command 'apply_channels'.

apply_channels:
"command",color_channels,_value_action={ 0:none | 1:cut | 2:normalize }

Apply specified command on the chosen color channel(s) of each selected
images.
(equivalent to shortcut command 'ac').

Argument 'color_channels' refers to a colorspace, and can be
basically one of
{ all | rgba | [s]rgb | ryb | lrgb | ycbcr | lab | lch | hsv | hsi |
hsl | cmy | cmyk | yiq }.
You can also make the processing focus on a few particular channels of
this colorspace,
by setting 'color_channels' as 'colorspace_channel' (e.g.
'hsv_h' for the hue).
All channel values are considered to be provided in the [0,255] range.

Default value: 'value_action=0'.

Example:
[#1] image.jpg +apply_channels "equalize blur 2",ycbcr_cbcr

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'.

Example:
[#1] image.jpg +autoindex[0] 4 +autoindex[0] 8 +autoindex[0] 16

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'.

Example:
[#1] image.jpg rgb2bayer 0 +bayer2rgb 1,1,0.5

clut:
"clut_name",_resolution>0,_cut_and_round={ 0:no | 1:yes }

Insert one of the 1149 pre-defined CLUTs at the end of the image list.
'clut_name' can be { 12_years_a_slave | 1917 | 2-strip-process |
60s | 60s_faded | 60s_faded_alt | 7drk_21 | action_magenta_01 |
action_red_01 | ad_astra | adventure_1453 | agfa_apx_100 | agfa_apx_25 |
agfa_precisa_100 | agfa_ultra_color_100 | agfa_vista_200 |
agressive_highligjtes_recovery_5 | aladdin | alberto_street | alien_green |
ampio | amstragram | amstragram+ | analog_film_1 | analogfx_anno_1870_color
| analogfx_old_style_i | analogfx_old_style_ii | analogfx_old_style_iii |
analogfx_sepia_color | analogfx_soft_sepia_i | analogfx_soft_sepia_ii |
anime | ant-man | apocalypse_this_very_moment | aqua | aqua_and_orange_dark
| aquaman | arabica_12 | asistas | atomic_pink | atusa | autumn |
autumn_leaves | ava_614 | avalanche | avengers_endgame | azrael_93 |
baby_driver | bad_boys_for_life | basuco | bboyz_2 | bc_darkum |
beach_aqua_orange | beach_faded_analog | beati | beauty_and_the_beast |
berlin_sky | bisogno | black_and_white | black_panther | black_star |
black_white_01 | black_white_02 | black_white_03 | black_white_04 |
black_white_05 | black_white_06 | blade_runner | bleach_bypass |
bleachbypass_1 | bleachbypass_2 | bleachbypass_3 | bleachbypass_4 |
bleech_bypass_green | bleech_bypass_yellow_01 | blue_cold_fade | blue_dark
| blue_house | blue_ice | blue_love_39 | blue_mono | blue_shadows_01 |
bluearchitecture | bluehour | blues | bob_ford | bohemian_rhapsody |
bombshell | bourbon_64 | boyado | bright_green_01 | bright_teal_orange |
bright_warm | brightgreen | brown_mobster | brownbm | brownish | bw_1 |
bw_10 | bw_2 | bw_3 | bw_4 | bw_5 | bw_6 | bw_7 | bw_8 | bw_9 |
bw_but_yellow | byers_11 | calidum | candlelight | captain_marvel | caribe
| chemical_168 | chrome_01 | cineblue | cinebm_4k | cinema | cinema_2 |
cinema_3 | cinema_4 | cinema_5 | cinema_noir | cinematic-1 | cinematic-10 |
cinematic-2 | cinematic-3 | cinematic-4 | cinematic-5 | cinematic-6 |
cinematic-7 | cinematic-8 | cinematic-9 | cinematic_01 | cinematic_02 |
cinematic_03 | cinematic_04 | cinematic_05 | cinematic_06 | cinematic_07 |
cinematic_for_flog | cinematic_forest | cinematic_lady_bird |
cinematic_mexico | city | city_7 | city_dust | city_of_god |
classic_films_01 | classic_films_02 | classic_films_03 | classic_films_04 |
classic_films_05 | classic_teal_and_orange | clayton_33 | clear |
clear_teal_fade | clouseau_54 | cobi_3 | coffee_44 | cold_clear_blue |
cold_clear_blue_1 | cold_ice | cold_simplicity_2 | coldchrome | color_rich
| colore | colorful_0209 | colornegative | conflict_01 | contrail_35 |
contrast_with_highlights_protection | contrasty_afternoon | contrasty_green
| convold | cosa | creed_2 | crispautumn | crispromance | crispwarm |
crispwinter | cross_process_cp_130 | cross_process_cp_14 |
cross_process_cp_15 | cross_process_cp_16 | cross_process_cp_18 |
cross_process_cp_3 | cross_process_cp_4 | cross_process_cp_6 | crushin |
cubicle_99 | culor | d_o_1 | dark_blues_in_sunlight | dark_green_02 |
dark_green_1 | dark_man_x | dark_orange_teal | dark_place_01 |
darkandsomber | darkness | date_39 | day_4nite | day_for_night |
day_to_night_kings_blue | deep | deep_blue | deep_dark_warm |
deep_high_contrast | deep_teal_fade | deep_warm_fade | deepskintones_2 |
deepskintones_3 | delicatessen | denoiser_simple_40 | desert_gold_37 |
dimension | dimmer | directions_23 | django_25 | doctor_strange |
domingo_145 | dream_1 | dream_85 | drop_green_tint_14 | dropblues | dunkirk
| duotone_blue_red | earth_tone_boost | eda_0_2 | edgyember | elegance_38 |
enchanted | ensaya | eterna_for_flog | expired_69 | expired_fade |
expired_polaroid | extreme | fade | fade_to_green | faded | faded_47 |
faded_alt | faded_analog | faded_extreme | faded_green | faded_pink-ish |
faded_print | faded_retro_01 | faded_retro_02 | faded_vivid | fadedlook |
fallcolors | falua | farkling | fatos | faux_infrared | faux_infrared_bw_1
| faux_infrared_color_p_2 | faux_infrared_color_p_3 |
faux_infrared_color_r_0a | faux_infrared_color_r_0b |
faux_infrared_color_yp_1 | fezzle | fg_cinebasic | fg_cinebright |
fg_cinecold | fg_cinedrama | fg_cinetealorange_1 | fg_cinetealorange_2 |
fg_cinevibrant | fg_cinewarm | fgcinebasic | fgcinebright | fgcinecold |
fgcinedrama | fgcinetealorange_1 | fgcinetealorange_2 | fgcinevibrant |
fgcinewarm | fight_club | film_0987 | film_9879 | film_gb-19 |
film_high_contrast | film_print_01 | film_print_02 | filmic | filo |
flat_30 | flat_blue_moon | flavin | flog_to_rec_709 | foggynight |
folger_50 | ford_v_ferrari | foresta | formula_b | french_comedy | frosted
| frostedbeachpicnic | fuji_160c | fuji_160c_+ | fuji_160c_++ | fuji_160c_-
| fuji_3510_constlclip | fuji_3510_constlmap | fuji_3510_cuspclip |
fuji_3513_constlclip | fuji_3513_constlmap | fuji_3513_cuspclip | fuji_400h
| fuji_400h_+ | fuji_400h_++ | fuji_400h_- | fuji_800z | fuji_800z_+ |
fuji_800z_++ | fuji_800z_- | fuji_astia_100_generic | fuji_astia_100f |
fuji_fp-100c | fuji_fp-100c_+ | fuji_fp-100c_++ | fuji_fp-100c_+++ |
fuji_fp-100c_++_alt | fuji_fp-100c_- | fuji_fp-100c_-- | fuji_fp-100c_alt |
fuji_fp-100c_cool | fuji_fp-100c_cool_+ | fuji_fp-100c_cool_++ |
fuji_fp-100c_cool_- | fuji_fp-100c_cool_-- | fuji_fp-100c_negative |
fuji_fp-100c_negative_+ | fuji_fp-100c_negative_++ |
fuji_fp-100c_negative_+++ | fuji_fp-100c_negative_++_alt |
fuji_fp-100c_negative_- | fuji_fp-100c_negative_-- | fuji_fp-3000b |
fuji_fp-3000b_+ | fuji_fp-3000b_++ | fuji_fp-3000b_+++ | fuji_fp-3000b_- |
fuji_fp-3000b_-- | fuji_fp-3000b_hc | fuji_fp-3000b_negative |
fuji_fp-3000b_negative_+ | fuji_fp-3000b_negative_++ |
fuji_fp-3000b_negative_+++ | fuji_fp-3000b_negative_- |
fuji_fp-3000b_negative_-- | fuji_fp-3000b_negative_early | fuji_fp_100c |
fuji_hdr | fuji_neopan_1600 | fuji_neopan_1600_+ | fuji_neopan_1600_++ |
fuji_neopan_1600_- | fuji_neopan_acros_100 | fuji_provia_100_generic |
fuji_provia_100f | fuji_provia_400f | fuji_provia_400x | fuji_sensia_100 |
fuji_superia_100 | fuji_superia_100_+ | fuji_superia_100_++ |
fuji_superia_100_- | fuji_superia_1600 | fuji_superia_1600_+ |
fuji_superia_1600_++ | fuji_superia_1600_- | fuji_superia_200 |
fuji_superia_200_xpro | fuji_superia_400 | fuji_superia_400_+ |
fuji_superia_400_++ | fuji_superia_400_- | fuji_superia_800 |
fuji_superia_800_+ | fuji_superia_800_++ | fuji_superia_800_- |
fuji_superia_hg_1600 | fuji_superia_reala_100 | fuji_superia_x-tra_800 |
fuji_velvia_100_generic | fuji_velvia_50 | fuji_xtrans_iii_acros |
fuji_xtrans_iii_acros+g | fuji_xtrans_iii_acros+r |
fuji_xtrans_iii_acros+ye | fuji_xtrans_iii_astia |
fuji_xtrans_iii_classic_chrome | fuji_xtrans_iii_mono |
fuji_xtrans_iii_mono+g | fuji_xtrans_iii_mono+r | fuji_xtrans_iii_mono+ye |
fuji_xtrans_iii_pro_neg_hi | fuji_xtrans_iii_pro_neg_std |
fuji_xtrans_iii_provia | fuji_xtrans_iii_sepia | fuji_xtrans_iii_velvia |
fusion_88 | futuristicbleak_1 | futuristicbleak_2 | futuristicbleak_3 |
futuristicbleak_4 | going_for_a_walk | golden | golden_bright | golden_fade
| golden_mono | golden_night_softner_43 | golden_sony_37 | golden_vibrant |
goldengate | goldentime | goldfx_bright_spring_breeze |
goldfx_bright_summer_heat | goldfx_hot_summer_heat |
goldfx_perfect_sunset_01min | goldfx_perfect_sunset_05min |
goldfx_perfect_sunset_10min | goldfx_spring_breeze | goldfx_summer_heat |
good_morning | green_15 | green_2025 | green_action | green_afternoon |
green_and_orange | green_blues | green_book | green_conflict | green_day_01
| green_day_02 | green_g_09 | green_indoor | green_light | green_mono |
green_yellow | greenish_contrasty | greenish_fade | greenish_fade_1 |
gremerta | greyhound | hackmanite | hallowen_dark | happyness_133 |
hard_teal_orange | hardboost | harsh_day | harsh_sunset | helios |
herderite | heulandite | hiddenite | highlights_protection | hilutite |
hitman | hlg_1_1 | honey_light | hong_kong | horrorblue | howlite | huesio
| husmes | huyan | hydracore | hyla_68 | hypersthene | hypnosis | hypressen
| i_tonya | ideo | ilford_delta_100 | ilford_delta_3200 |
ilford_delta_3200_+ | ilford_delta_3200_++ | ilford_delta_3200_- |
ilford_delta_400 | ilford_fp_4_plus_125 | ilford_hp_5 | ilford_hp_5_+ |
ilford_hp_5_++ | ilford_hp_5_- | ilford_hp_5_plus_400 | ilford_hps_800 |
ilford_pan_f_plus_50 | ilford_xp_2 | inception | indoor_blue |
industrial_33 | infrared_-_dust_pink | instantc | j | jarklin | jojo_rabbit
| joker | jumanji_the_next_level | jurassic_world_fallen_kingdom |
justice_league | justpeachy | jwick_21 | k_tone_vintage_kodachrome |
kahve_3 | kh_1 | kh_10 | kh_2 | kh_3 | kh_4 | kh_5 | kh_6 | kh_7 | kh_8 |
kh_9 | killstreak | kingsman_the_golden_circle | knives_out |
kodak_2383_constlclip | kodak_2383_constlmap | kodak_2383_cuspclip |
kodak_2393_constlclip | kodak_2393_constlmap | kodak_2393_cuspclip |
kodak_bw_400_cn | kodak_e-100_gx_ektachrome_100 | kodak_ektachrome_100_vs |
kodak_ektachrome_100_vs_generic | kodak_ektar_100 | kodak_elite_100_xpro |
kodak_elite_chrome_200 | kodak_elite_chrome_400 | kodak_elite_color_200 |
kodak_elite_color_400 | kodak_elite_extracolor_100 | kodak_hie_hs_infra |
kodak_kodachrome_200 | kodak_kodachrome_25 | kodak_kodachrome_64 |
kodak_kodachrome_64_generic | kodak_portra_160 | kodak_portra_160_+ |
kodak_portra_160_++ | kodak_portra_160_- | kodak_portra_160_nc |
kodak_portra_160_nc_+ | kodak_portra_160_nc_++ | kodak_portra_160_nc_- |
kodak_portra_160_vc | kodak_portra_160_vc_+ | kodak_portra_160_vc_++ |
kodak_portra_160_vc_- | kodak_portra_400 | kodak_portra_400_+ |
kodak_portra_400_++ | kodak_portra_400_- | kodak_portra_400_nc |
kodak_portra_400_nc_+ | kodak_portra_400_nc_++ | kodak_portra_400_nc_- |
kodak_portra_400_uc | kodak_portra_400_uc_+ | kodak_portra_400_uc_++ |
kodak_portra_400_uc_- | kodak_portra_400_vc | kodak_portra_400_vc_+ |
kodak_portra_400_vc_++ | kodak_portra_400_vc_- | kodak_portra_800 |
kodak_portra_800_+ | kodak_portra_800_++ | kodak_portra_800_- |
kodak_portra_800_hc | kodak_t-max_100 | kodak_t-max_3200 | kodak_t-max_400
| kodak_tmax_3200 | kodak_tmax_3200_+ | kodak_tmax_3200_++ |
kodak_tmax_3200_- | kodak_tmax_3200_alt | kodak_tri-x_400 |
kodak_tri-x_400_+ | kodak_tri-x_400_++ | kodak_tri-x_400_- |
kodak_tri-x_400_alt | korben_214 | la_la_land | landscape | landscape_01 |
landscape_02 | landscape_03 | landscape_04 | landscape_05 | landscape_1 |
landscape_10 | landscape_2 | landscape_3 | landscape_4 | landscape_5 |
landscape_6 | landscape_7 | landscape_8 | landscape_9 |
lateafternoonwanderlust | latesunset | lavark | lc_1 | lc_10 | lc_2 | lc_3
| lc_4 | lc_5 | lc_6 | lc_7 | lc_8 | lc_9 | lenox_340 | levex |
life_giving_tree | light | light_blown | litore | little_women | logan |
lomo | lomography_redscale_100 | lomography_x-pro_slide_200 | london_nights
| longbeachmorning | loro | lotta | louetta | low_contrast_blue |
low_key_01 | lucky_64 | lushgreen | lushgreensummer | mad_max_fury_road |
maesky | magenta_day | magenta_day_01 | magenta_dream | magenta_yellow |
magentacoffee | magichour | marriage_story | matrix | mckinnon_75 |
memories | mercato | metropolis | milo_5 | minimalistcaffeination |
modern_film | modern_films_01 | modern_films_02 | modern_films_03 |
modern_films_04 | modern_films_05 | modern_films_06 | modern_films_07 |
molti | mono_2 | mono_tinted | monochrome | monochrome_1 | monochrome_2 |
moody_1 | moody_10 | moody_2 | moody_3 | moody_4 | moody_5 | moody_6 |
moody_7 | moody_8 | moody_9 | moonlight | moonlight_01 | moonlight_2 |
moonrise | morning_6 | morroco_16 | mostly_blue | mother! | motus | moviz_1
| moviz_10 | moviz_11 | moviz_12 | moviz_13 | moviz_14 | moviz_15 |
moviz_16 | moviz_17 | moviz_18 | moviz_19 | moviz_2 | moviz_20 | moviz_21 |
moviz_22 | moviz_23 | moviz_24 | moviz_25 | moviz_26 | moviz_27 | moviz_28
| moviz_29 | moviz_3 | moviz_30 | moviz_31 | moviz_32 | moviz_33 | moviz_34
| moviz_35 | moviz_36 | moviz_37 | moviz_38 | moviz_39 | moviz_4 | moviz_40
| moviz_41 | moviz_42 | moviz_43 | moviz_44 | moviz_45 | moviz_46 |
moviz_47 | moviz_48 | moviz_5 | moviz_6 | moviz_7 | moviz_8 | moviz_9 |
mucca | mute_shift | muted_01 | muted_fade | mysticpurplesunset | nah |
natural_vivid | naturalboost | negative | nemesis | neon_770 | neutral |
neutral_pump | neutral_teal_orange | neutral_warm_fade | newspaper |
night_01 | night_02 | night_03 | night_04 | night_05 | night_blade_4 |
night_king_141 | night_spy | night_view | nightfromday | nightlife | nigrum
| no_time_to_die | nostalgiahoney | nostalgic | nw-1 | nw-10 | nw-2 | nw-3
| nw-4 | nw-5 | nw-6 | nw-7 | nw-8 | nw-9 | old_west | once_upon_a_time |
once_upon_a_time_in_hollywood | onda | only_red | only_red_and_blue |
operation_yellow | orange_dark_4 | orange_dark_7 | orange_dark_look |
orange_tone | orange_underexposed | orangeandblue | oranges | padre |
paladin | paladin_1875 | parasite | partia | pasadena_21 | passing_by |
perso | picola | pink_fade | pirates_of_the_caribbean | pitaya_15 |
pmcinematic_01 | pmcinematic_02 | pmcinematic_03 | pmcinematic_04 |
pmcinematic_05 | pmcinematic_06 | pmcinematic_07 | pmnight_01 | pmnight_02
| pmnight_03 | pmnight_04 | pmnight_05 | polaroid_664 | polaroid_665 |
polaroid_665_+ | polaroid_665_++ | polaroid_665_- | polaroid_665_-- |
polaroid_665_negative | polaroid_665_negative_+ | polaroid_665_negative_- |
polaroid_665_negative_hc | polaroid_667 | polaroid_669 | polaroid_669_+ |
polaroid_669_++ | polaroid_669_+++ | polaroid_669_- | polaroid_669_-- |
polaroid_669_cold | polaroid_669_cold_+ | polaroid_669_cold_- |
polaroid_669_cold_-- | polaroid_672 | polaroid_690 | polaroid_690_+ |
polaroid_690_++ | polaroid_690_- | polaroid_690_-- | polaroid_690_cold |
polaroid_690_cold_+ | polaroid_690_cold_++ | polaroid_690_cold_- |
polaroid_690_cold_-- | polaroid_690_warm | polaroid_690_warm_+ |
polaroid_690_warm_++ | polaroid_690_warm_- | polaroid_690_warm_-- |
polaroid_polachrome | polaroid_px-100uv+_cold | polaroid_px-100uv+_cold_+ |
polaroid_px-100uv+_cold_++ | polaroid_px-100uv+_cold_+++ |
polaroid_px-100uv+_cold_- | polaroid_px-100uv+_cold_-- |
polaroid_px-100uv+_warm | polaroid_px-100uv+_warm_+ |
polaroid_px-100uv+_warm_++ | polaroid_px-100uv+_warm_+++ |
polaroid_px-100uv+_warm_- | polaroid_px-100uv+_warm_-- | polaroid_px-680 |
polaroid_px-680_+ | polaroid_px-680_++ | polaroid_px-680_- |
polaroid_px-680_-- | polaroid_px-680_cold | polaroid_px-680_cold_+ |
polaroid_px-680_cold_++ | polaroid_px-680_cold_++_alt |
polaroid_px-680_cold_- | polaroid_px-680_cold_-- | polaroid_px-680_warm |
polaroid_px-680_warm_+ | polaroid_px-680_warm_++ | polaroid_px-680_warm_- |
polaroid_px-680_warm_-- | polaroid_px-70 | polaroid_px-70_+ |
polaroid_px-70_++ | polaroid_px-70_+++ | polaroid_px-70_- |
polaroid_px-70_-- | polaroid_px-70_cold | polaroid_px-70_cold_+ |
polaroid_px-70_cold_++ | polaroid_px-70_cold_- | polaroid_px-70_cold_-- |
polaroid_px-70_warm | polaroid_px-70_warm_+ | polaroid_px-70_warm_++ |
polaroid_px-70_warm_- | polaroid_px-70_warm_-- | polaroid_time_zero_expired
| polaroid_time_zero_expired_+ | polaroid_time_zero_expired_++ |
polaroid_time_zero_expired_- | polaroid_time_zero_expired_-- |
polaroid_time_zero_expired_--- | polaroid_time_zero_expired_cold |
polaroid_time_zero_expired_cold_- | polaroid_time_zero_expired_cold_-- |
polaroid_time_zero_expired_cold_--- | portrait | portrait_1 | portrait_10 |
portrait_2 | portrait_3 | portrait_4 | portrait_5 | portrait_6 | portrait_7
| portrait_8 | portrait_9 | progressen | protect_highlights_01 |
prussian_blue | pseudogrey | purple | purple_2 | quraqqq_12 | randas |
red_afternoon_01 | red_day_01 | red_dream_01 | redblueyellow | reds |
reds_oranges_yellows | reeve_38 | remy_24 | rest_33 | retro |
retro_brown_01 | retro_magenta_01 | retro_summer_3 | retro_yellow_01 |
rocketman | rollei_ir_400 | rollei_ortho_25 | rollei_retro_100_tonal |
rollei_retro_80s | rotate_muted | rotate_vibrant | rotated | rotated_crush
| satid | saturated_blue | saving_private_damon | scala | science_fiction |
scrittle | sea | seges | selor | sensum | separation | serenity | seringe_4
| serpent | seventies_magazine | sevsuz | shade_kings_ink | shadow_king_39
| shine | sicario | sino | skin_tones | slog_to_rec709_basic |
slog_to_rec709_contrasty | slog_to_rec709_crush_shadows |
slog_to_rec709_green_correction | smart_contrast | smokey | smooth_clear |
smooth_cromeish | smooth_fade | smooth_green_orange | smooth_sailing |
smooth_teal_orange | soft_fade | softblackandwhite | softwarming |
solarized_color | solarized_color_2 | soldi | spider-man_far_from_home |
spotlight | springmorning | sprocket_231 | spy_29 | standard |
star_wars_the_rise_of_skywalker | strano | street | stringa |
studio_skin_tone_shaper | subtle_blue | subtle_green | subtle_yellow |
sully | summer | summer_alt | sunlight_love_11 | sunlightlove | sunny |
sunny_alt | sunny_rich | sunny_warm | sunset | sunset_aqua_orange |
sunset_intense_violet_blue | sunset_violet_mood | super_warm |
super_warm_rich | sutro_fx | sweet_bubblegum | sweet_gelatto |
taşdemirrr_1 | taiga | tarraco | teal-orange_for_flog | teal_fade |
teal_moonlight | tealmagentagold | tealorange | tealorange_1 | tealorange_2
| tealorange_3 | technicalfx_backlight_filter | teigen_28 | tenet |
tensiongreen_1 | tensiongreen_2 | tensiongreen_3 | tensiongreen_4 | terra_4
| the_dark_knight | the_darkest_hour | the_gentelmen |
the_grand_budapest_hotel | the_hurt_locker | the_irishman | the_lighthouse
| the_lobster | the_martian | the_matrices | the_revenant |
the_shape_of_water | the_social_network | the_two_popes | the_way_back |
thor_ragnarok | thriller_2 | tirare | toastedgarden | top_gun_maverick |
trent_18 | true_colors_8 | turkiest_42 | tutto | tweed_71 | ultra_water |
uncut_gems | undeniable | undeniable_2 | underwater | unknown | upglow |
urban_01 | urban_02 | urban_03 | urban_04 | urban_05 | urban_cowboy |
uzbek_bukhara | uzbek_marriage | uzbek_samarcande | valize | valsky |
velvetia | venom | very_warm_greenish | vfb_21 | vibrant | vibrant_alien |
vibrant_contrast | vibrant_cromeish | victory | vintage | vintage_01 |
vintage_02 | vintage_03 | vintage_04 | vintage_05 | vintage_163 |
vintage_alt | vintage_brighter | vintage_chrome | vintage_mob |
vintage_warmth_1 | violet_taste | vireo_37 | vita | vivid | vubes |
war_for_the_planet_of_the_apes | warm | warm_dark_contrasty | warm_fade |
warm_fade_1 | warm_highlight | warm_neutral | warm_sunset_red | warm_teal |
warm_vintage | warm_yellow | wavefire | waves | well_see | western |
western_6 | westernlut_2 | westernlut_2_13 | whiter_whites |
winterlighthouse | wipe | wolf_of_wall_street | wonder_woman |
wooden_gold_20 | x-men_dark_phoenix | yangabuz_8 | yellow_55b |
yellow_film_01 | yellowstone | you_can_do_it | zed_32 | zeke_39 |
zilverfx_bw_solarization | zilverfx_infrared | zilverfx_vintage_bw |
zombieland_double_tap }

Default values: 'resolution=33' and 'cut_and_round=1'.

Example:
[#1] clut summer clut alien_green,17 clut orange_dark4,48

clut2hald:

Convert selected 3D CLUTs to 2D HaldCLUTs.

Example:
[#1] clut summer +clut2hald

hald2clut:

Convert selected 2D HaldCLUTs to 3D CLUTs.

cmy2rgb:

Convert color representation of selected images from CMY to RGB.

cmyk2rgb:

Convert color representation of selected images from CMYK to RGB.

colorblind:
type={ 0:protanopia | 1:protanomaly | 2:deuteranopia | 3:deuteranomaly |
4:tritanopia | 5:tritanomaly | 6:achromatopsia | 7:achromatomaly }

Simulate color blindness vision.
Simulation method of Vienot, Brettel & Mollon 1999, "Digital video
colourmaps for checking the legibility of displays by dichromats".
The dichromacy matrices of the paper were adapted to sRGB (RGB->XYZ).
Anomalous trichromacy simulated via linear interpolation with the identity
and a factor of 0.6.

Example:
[#1] image.jpg +colorblind 0

colormap:
nb_levels>=0,_method={ 0:median-cut | 1:k-means },_sort_vectors

Estimate best-fitting colormap with 'nb_colors' entries, to index
selected images.
Set 'nb_levels==0' to extract all existing colors of an image.
'sort_vectors' can be { 0:unsorted | 1:by increasing norm | 2:by
decreasing occurrence }.

Default value: 'method=1' and 'sort_vectors=1'.

Example:
[#1] image.jpg +colormap[0] 4 +colormap[0] 8 +colormap[0] 16

Tutorial: https://gmic.eu/oldtutorial/_colormap

compose_channels:

Compose all channels of each selected image, using specified arithmetic
operator (+,-,or,min,...).

Default value: '1=+'.

Example:
[#1] image.jpg +compose_channels and

Tutorial: https://gmic.eu/tutorial/compose_channels

count_colors:
_count_until={ 0 |
none | >0 |
max number of counted colors }

Count number of distinct colors in selected images until it reaches the
specified max number of counted colors.
Set 'count_until' to '0' to disable limit on counted colors.
This command returns the number of distinct colors for each image
(separated by commas).

deltaE:
[image],_metric={ 0:deltaE_1976 | 1:deltaE_2000 },"_to_Lab_command"

Compute the CIE DeltaE color difference between selected images and
specified [image].
Argument 'to_Lab_command' is a command able to convert colors of
[image] into a Lab representation.

Default values: 'metric=1' and 'to_Lab_command="srgb2lab"
'.

Example:
[#1] image.jpg +blur 2 +deltaE[0] [1],1,srgb2lab

direction2rgb:

Compute RGB representation of selected 2D direction fields.

Example:
[#1] image.jpg luminance gradient append c blur 2 orientation
+direction2rgb

ditheredbw:

Create dithered B&W version of selected images.

Example:
[#1] image.jpg +equalize ditheredbw[-1]

fc:
Shortcut for command 'fill_color'.

fill_color:
col1,...,colN

Fill selected images with specified color.
(equivalent to shortcut command 'fc').

Example:
[#1] image.jpg +fill_color 255,0,255

Tutorial: https://gmic.eu/oldtutorial/_fill_color

gradient2rgb:
_is_orientation={ 0 | 1 }

Compute RGB representation of 2D gradient of selected images.

Default value: 'is_orientation=0'.

Example:
[#1] image.jpg +gradient2rgb 0 equalize[-1]

hcy2rgb:

Convert color representation of selected images from HCY to RGB.

hsi2rgb:

Convert color representation of selected images from HSI to RGB.

hsi82rgb:

Convert color representation of selected images from HSI8 to RGB.

hsl2rgb:

Convert color representation of selected images from HSL to RGB.

hsl82rgb:

Convert color representation of selected images from HSL8 to RGB.

hsv2rgb:

Convert color representation of selected images from HSV to RGB.

Example:
[#1] (0,360;0,360^0,0;1,1^1,1;1,1) resize 400,400,1,3,3 hsv2rgb

hsv82rgb:

Convert color representation of selected images from HSV8 to RGB.

int2rgb:

Convert color representation of selected images from INT24 to RGB.

ipremula:

Convert selected images with premultiplied alpha colors to normal colors.
See also: premula.

jzazbz2rgb:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from RGB to Jzazbz.

Default value: 'illuminant=2'.

jzazbz2xyz:

Convert color representation of selected images from RGB to XYZ.

lab2lch:

Convert color representation of selected images from Lab to Lch.

lab2rgb:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from Lab to RGB.

Default value: 'illuminant=2'.

Example:
[#1] (50,50;50,50^-3,3;-3,3^-3,-3;3,3) resize 400,400,1,3,3 lab2rgb

lab2srgb:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from Lab to sRGB.

Default value: 'illuminant=2'.

Example:
[#1] (50,50;50,50^-3,3;-3,3^-3,-3;3,3) resize 400,400,1,3,3 lab2rgb

lab82srgb:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from Lab8 to sRGB.

Default value: 'illuminant=2'.

Example:
[#1] (50,50;50,50^-3,3;-3,3^-3,-3;3,3) resize 400,400,1,3,3 lab2rgb

lab2xyz:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from Lab to XYZ.

Default value: 'illuminant=2'.

lab82rgb:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from Lab8 to RGB.

Default value: 'illuminant=2'.

lch2lab:

Convert color representation of selected images from Lch to Lab.

lch2rgb:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from Lch to RGB.

Default value: 'illuminant=2'.

lch82rgb:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from Lch8 to RGB.

Default value: 'illuminant=2'.

luminance:

Compute luminance of selected sRGB images.

Example:
[#1] image.jpg +luminance

Tutorial: https://gmic.eu/tutorial/luminance

lightness:

Compute lightness of selected sRGB images.

Example:
[#1] image.jpg +lightness

lut_contrast:
_nb_colors>1,_min_rgb_value

Generate a RGB colormap where consecutive colors have high contrast.
This function performs a specific score maximization to generate the
result, so
it may take some time when 'nb_colors' is high.

Default values: 'nb_colors=256' and 'min_rgb_value=64'.

map_clut:
[clut] | "clut_name"

Map specified RGB color LUT to selected images.

Example:
[#1] image.jpg uniform_distribution {2^6},3 mirror[-1] x +map_clut[0]
[1]

match_histogram:
[reference_image],_nb_levels>0,_color_channels

Transfer histogram of the specified reference image to selected images.
Argument 'color channels' is the same as with command
'apply_channels'.

Default value: 'nb_levels=256' and 'color_channels=all'.

Example:
[#1] image.jpg 100,100,1,3,"u([256,200,100])" +match_histogram[0] [1]

match_icp:
[reference_image],_precision>0,_transformation_variable

Transform selected set of d-dimensional vectors to match specified set of
reference vectors, using ICP (Iterative Closest Point) algorithm.
A description of ICP is available at https://en.wikipedia.org/wiki/Itera
tive_closest_point.
Return the L2 alignment error.

Default values: 'precision=1e-2' and
'transformation_variable=(undefined)'.
sample lena,earth +match_icp[0] [1]

match_pca:
[reference_image],_color_channels

Transfer mean and covariance matrix of specified vector-valued reference
image to selected images.
Argument 'color channels' is the same as with command
'apply_channels'.

Default value: 'color_channels=all'.

Example:
[#1] sample lena,earth +match_pca[0] [1]

match_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 occurrences 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'.

Example:
[#1] sample pencils,wall +match_rgb[0] [1],0,0.01

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'.

Example:
[#1] image.jpg +mix_rgb 0,1,0,1,0,0,0,0,1

Tutorial: https://gmic.eu/tutorial/mix_rgb

oklab2rgb:

Convert color representation of selected images from OKlab to RGB.
(see colorspace definition at: https://bottosson.github.io/posts/oklab/ fR ).
See also: rgb2oklab.

palette:
palette_name | palette_number

Input specified color palette at the end of the image list.
'palette_name' can be { default | hsv | lines | hot | cool | jet
| flag | cube | rainbow | parula | spring | summer | autumn | winter | bone
| copper | pink | vga | algae | amp | balance | curl | deep | delta | dense
| diff | gray | haline | ice | matter | oxy | phase | rain | solar | speed
| tarn | tempo | thermal | topo | turbid | aurora | hocuspocus | srb2 |
uzebox | amiga7800 | amiga7800mess | fornaxvoid1 }

Example:
[#1] palette hsv

premula:

Convert selected images with normal colors to premultiplied alpha colors.
After conversion, alpha channel of resulting images has value in [0,1]
range.
See also: ipremula.

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'.

Example:
[#1] pseudogray 5

random_clut:

Generate a 33x33x33 random 3D color LUT.

Example:
[#1] image.jpg random_clut +map_clut.. .

random_clut:
_seed = { >=0 | -1 }

Generate a 33x33x33 random 3D color LUT.
If specified 'seed' is positive, it is used as a seed for the random
number generator @cli : (so that using the same seed will return the same
CLUT).

Example:
[#1] image.jpg random_clut +map_clut.. .

replace_color:
tolerance[%]>=0,smoothness[%]>=0,src1,src2,...,dest1,dest2,...

Replace pixels from/to specified colors in selected images.

Example:
[#1] image.jpg +replace_color 40,3,204,153,110,255,0,0

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 images 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'.

Example:
[#1] image.jpg +rgb2bayer 0

rgb2cmy:

Convert color representation of selected images from RGB to CMY.

Example:
[#1] image.jpg rgb2cmy split c

rgb2cmyk:

Convert color representation of selected images from RGB to CMYK.

Example:
[#1] image.jpg rgb2cmyk split c
[#2] image.jpg rgb2cmyk split c fill[3] 0 append c cmyk2rgb

rgb2hcy:

Convert color representation of selected images from RGB to HCY.

Example:
[#1] image.jpg rgb2hcy split c

rgb2hsi:

Convert color representation of selected images from RGB to HSI.

Example:
[#1] image.jpg rgb2hsi split c

rgb2hsi8:

Convert color representation of selected images from RGB to HSI8.

Example:
[#1] image.jpg rgb2hsi8 split c

rgb2hsl:

Convert color representation of selected images from RGB to HSL.

Example:
[#1] image.jpg rgb2hsl split c
[#2] image.jpg rgb2hsl +split c add[-3] 100 mod[-3] 360 append[-3--1] c
hsl2rgb

rgb2hsl8:

Convert color representation of selected images from RGB to HSL8.

Example:
[#1] image.jpg rgb2hsl8 split c

rgb2hsv:

Convert color representation of selected images from RGB to HSV.

Example:
[#1] image.jpg rgb2hsv split c
[#2] image.jpg rgb2hsv +split c add[-2] 0.3 cut[-2] 0,1 append[-3--1] c
hsv2rgb

rgb2hsv8:

Convert color representation of selected images from RGB to HSV8.

Example:
[#1] image.jpg rgb2hsv8 split c

rgb2int:

Convert color representation of selected images from RGB to INT24 scalars.

Example:
[#1] image.jpg rgb2int

rgb2jzazbz:
illuminant={ 0:D50 | 1:D65 | 2:E } |
(no arg)

Convert color representation of selected images from RGB to Jzazbz.

Default value: 'illuminant=2'.