Provided by: gmic_2.4.5-1_amd64 bug

NAME

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

HELP

         gmic: GREYC's Magic for Image Computing.

               Version 2.4.5, Copyright (c) 2008-2019, David Tschumperle.
               (https://gmic.eu)

        1. Usage
           -----

           gmic [command1 [arg1_1,arg1_2,..]] .. [commandN [argN_1,argN_2,..]]

           'gmic'   is  the  open-source  interpreter  of  the  G'MIC  language,  a  script-based
       programming
           language dedicated to the design of possibly complex image  processing  pipelines  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 rules governing the G'MIC
       language.
           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 indice '0' and is denoted by '[0]'. The second image
       of the
            list is denoted by '[1]', the third by '[2]' and so on.

         - Negative indices are treated in a periodic way: '[-1]' refers to the last image of the
       list,
            '[-2]'  to the penultimate one, etc. Thus, if the list has 4 images, '[1]' and '[-3]'
       both
            designate the second image of the list.

         - A named image may be also indicated by '[name]', if 'name' uses the character set  [a-
       zA-Z0-9_]
            and  does not start with a number. Image names can be set or reassigned at any moment
       during
            the processing pipeline (see 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 be then added as a new custom G'MIC command (stored in a user
            command file), so it can be re-used afterwards 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  the  numerical  precision  when
       executing
            image  processing  pipelines.  For  image  input/output  operations,  you may want to
       prescribe the
            image datatype to be different than 'float' (like 'bool', 'char', 'int', etc...).
            This is possible by specifying it as a file option when using I/O commands.
            (see section 'Input/output properties' to learn more about file options).

        4. Items of a processing pipeline
           ------------------------------

         - In G'MIC, an image processing pipeline is described as a sequence of  items  separated
       by the
            space  character  '  '.  Such items are interpreted and executed from the left to the
       right.
            For instance, the expression:

              filename.jpg blur 3,0 sharpen 10 resize 200%,200% output file_out.jpg

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

         - Each G'MIC item is a string that is either a command, a list of command arguments,
            a filename, or a special input string.

         - Escape characters '\' and double quotes '"' can be used  to  define  items  containing
       spaces or
            other  special  characters. For instance, the two strings 'single\ item' and '"single
       item"'
            both define the same single item, with a space in it.

        5. Input data items
           ----------------

         - If a specified G'MIC item appears to be an existing filename, the corresponding  image
       data
            are  loaded and inserted at the end of the image list (which is equivalent to the use
       of
            'input filename').

         - Special filenames '-'  and  '-.ext'  stand  for  the  standard  input/output  streams,
       optionally
            forced to be in a specific 'ext' file format (e.g. '-.jpg' or '-.png').

         -  The  following  special input strings may be used as G'MIC items to create and insert
       new
            images with prescribed values, at the end of the image list:

           . '[selection]' or '[selection]xN': Insert 1 or N copies of already existing images.
              'selection' may represent one or several images
              (see section 'Command items and selections' to learn more about selections).

           .  'width[%],_height[%],_depth[%],_spectrum[%],_values':  Insert  a  new  image   with
       specified
              size  and values (adding '%' to a dimension means 'percentage of the size along the
       same
              axis, taken from the last image '[-1]'').  Any  specified  dimension  can  be  also
       written as
              '[image]',  and  is  then  set  to  the  size (along the same axis) of the existing
       specified image
              [image]. 'values' can be either a sequence of numbers separated by commas ',', or a
              mathematical expression, as e.g. in input item '256,256,1,3,[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,..)': Insert a new image from specified prescribed values.  Value  separator
       inside
              parentheses  can  be  ','  (column  separator),  ';'  (row  separator),  '/' (slice
       separator) or
              '^' (channel separator). For instance, expression '(1,2,3;4,5,6;7,8,9)'  creates  a
       3x3 matrix
              (scalar image), with values running from 1 to 9.

           .  '0':  Insert  a  new 'empty' image, containing no pixel data. Empty images are used
       only in rare
              occasions.

         - Input item 'name=value' declares a new variable 'name', or assign a new value
            to an existing variable. Variable names must use the character set  [a-zA-Z0-9_]  and
       cannot
            start with a number.

         -  A variable definition is always local to the current command except when it starts by
       the
            underscore character '_'. In that case, it becomes also  accessible  by  any  command
       invoked
            outside the current command scope (global variable).

         -  If  a  variable  name  starts  with two underscores '__', the global variable is also
       shared among
            different threads and can be read/set by commands running in  parallel  (see  command
       'parallel'
            for this purpose). Otherwise, it remains local to the thread that defined it.

         - Numerical variables can be updated with the use of these special operators:
            '+='  (addition),  '-='  (subtraction),  '*=' (multiplication), '/=' (division), '%='
       (modulo),
            '&=' (bitwise and), '|=' (bitwise or), '^=' (power), '<<=' and  '>>='  (bitwise  left
       and right
            shifts). For instance, 'foo=1 foo+=3'.

         -  Input  item  'name.=string'  concatenates  specified  'string' to the end 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. '+=').

        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 that they have their own
            shortcuts, respectively '.', '..'  and  '...'.  For  instance,  command  'blur..'  is
       equivalent to
            'blur[-2]'. These shortcuts work also when specifying command arguments.

         -  G'MIC  commands  invoked without '[selection]' are applied on all images of the list,
       i.e. the
            default selection is '[0--1]' (except for command 'input' whose default selection  is
       '[-1]').

         -  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 '+' or a double hyphen '--'  does  not  act
       'in-place'
            but inserts its result as one or several new images at the end of the image list.

         - There are two different types of commands that can be run by the G'MIC interpreter:

           .  Builtin  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
              builtin  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 builtin or other custom commands.
              They are interpreted by the G'MIC interpreter, and  thus  run  a  bit  slower  than
       builtin 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 builtin commands cannot be added
            (unless you modify the G'MIC interpreter source code and recompile it).

        7. Input/output properties
           -----------------------

         - G'MIC is able to read/write most of the classical image file formats, including:

           . 2D grayscale/color files: .png, .jpeg, .gif, .pnm, .tif, .bmp, ...
           . 3D volumetric files: .dcm, .hdr, .nii, .pan, .inr, .pnk, ...
           . video files: .mpeg, .avi, .mov, .ogg, .flv, ...
           . Generic ascii or binary data files: .gmz, .cimg, .cimgz,  .dlm,  .asc,  .pfm,  .raw,
       .txt, .h.
           . 3D object files: .off.

         -  When dealing with color images, G'MIC generally reads, writes and displays data using
       the usual
            sRGB color space.

         - G'MIC is able to manage 3D objects that may be read from files or generated  by  G'MIC
       commands.
            A 3D object is stored as a one-column scalar image containing the object data, in the
            following order: { magic_number; sizes; vertices; primitives; colors; opacities }.
            These 3D representations can be then processed as regular images.
            (see command 'split3d' for accessing each of these 3D object data separately).

         -  Be  aware  that  usual  file  formats  may  be sometimes not adapted to store all the
       available image
            data, since G'MIC uses float-valued image buffers. For instance, saving an image that
       was
            initially loaded as a 16bits/channel image, as a .jpg file will result in a loss of
            information. Use the G'MIC-specific file 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={ 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 | uchar | char | ushort | short | uint | int |  uint64  |  int64  |  float  |
       double }.

           .  .raw  binary  files:  Image  dimensions  and input pixel type may be specified when
       loading .raw
              files with input 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) }.

           . .gif files: Animated gif files can be saved, using the input expression
              'filename.gif,fps>0,nb_loops'. Specify 'nb_loops=0' to get an  infinite  number  of
       animation
              loops (this is the default behavior).

           . .jpeg files: The output quality may be specified (in %), using the output expression
              'filename.jpg,30' (here, to get a 30% quality output). '100' is the default.

           . .mnc files: The output header can set from another file, using the output expression
              'filename.mnc,header_template.mnc'.

           .  .pan,  .cpp, .hpp, .c and .h files: The output datatype can be selected with output
       expression
              'filename[,datatype]'. 'datatype' can be the same as for .cimg[z] files.

           . .gmic files: These filenames are assumed to be G'MIC custom commands files.  Loading
       such a
              file will add the commands it defines to the interpreter. Debug information can be
              enabled/disabled  by  the  input  expression 'filename.gmic[,add_debug_info={ 0 | 1
       }]'.

           . Inserting 'ext:' on the beginning of a filename (e.g. 'jpg:filename')  forces  G'MIC
       to
              read/write  the  file  as it would have been done if it had the specified extension
       '.ext'.

         - Some input/output  formats  and  options  may  not  be  supported,  depending  on  the
       configuration
            flags that have been set during the build of the G'MIC software.

        8. Substitution rules
           ------------------

         - G'MIC items containing '$' or '{}' are substituted before being interpreted. Use these
            substituting expressions to access various data from the interpreter environment.

         -  '$name'  and  '${name}'  are  both  substituted  by  the value of the specified named
       variable
            (set previously by the item 'name=value'). If this variable has not been already set,
       the
            expression is substituted by the highest positive indice of the named image '[name]'.
       If no
            image has this name, the expression is substituted by the value of the OS environment
       variable
            with same name (it may be thus an empty string).
            The following reserved variables are predefined by the G'MIC interpreter:

              . '$!': The current number of images in the list.
              . '$>' and '$<': The increasing/decreasing indice of the latest (currently running)
                 'repeat...done' loop.
              . '$/': The current call stack. Stack items are separated by slashes '/'.
              . '$|': The current value (expressed in seconds) of a millisecond precision timer.
              . '$^': The current verbosity level.
              . '$_cpus': The number of computation cores available on your machine.
              . '$_pid': The current process identifier, as an integer.
              . '$_prerelease': For pre-releases only, the date of the pre-release as 'yymmdd'.
                 For stable releases, this variable is not defined.
              .  '$_version':  A  3-digits  number telling about the current version of the G'MIC
       interpreter
                 (e.g. '245').
              . '$_vt100': Set to 1 (default value) if colored text  output  is  allowed  on  the
       console.
              .  '$_path_rc':  The  path  to  the  G'MIC  folder  used  to  store  resources  and
       configuration files
                (its value is OS-dependent).
              . '$_path_user': The path to the G'MIC user file .gmic or user.gmic (its value is
                 OS-dependent).

         - '$$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'}' (between single quotes) is substituted by the  sequence  of  ascii  codes
       that compose
            the  specified  string,  separated  by  commas  ','.  For instance, item '{'foo'}' is
       substituted
            by '102,111,111'.

         - '{image,feature}' is substituted by a specific feature of the image  [image].  'image'
       can be
            either  an  image  number or an image name. It can be also eluded, in which case, the
       last image
            '[-1]' of the list is considered for the requested feature.
            Specified 'feature' can be one of:

              . 'b': The image basename (i.e. filename without the folder path nor extension).
              . 'f': The image folder name.
              . 'n': The image name or filename (if the image has been read from a file).
              . 't': The text string from the image values regarded as ascii codes.
              . 'x': The image extension (i.e 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  ascii  codes
       correspond
                 to   the  list  of  values  resulting  from  the  evaluation  of  the  specified
       mathematical
                 expression. For instance, item '{`[102,111,111]`}' is substituted by  'foo'  and
       item
                 '{`vector8(65)`}' by 'AAAAAAAA'.

         - '{*}' is substituted by the visibility state of the instant display window [0] (can be
            { 0=closed | 1=visible }).

         -  '{*,feature}'  or  '{*indice,feature}'  is  substituted  by a specific feature of the
       instant
            display window #0 (or #indice, if specified). Requested 'feature' can be:

              . 'w': display width (i.e. width of the display area managed by the window).
              . 'h': display height (i.e. height of the display area managed by the window).
              . 'wh': display width x display height.
              . 'w,h': display width, display height (equivalent to '{*,w},{*,h}').
              . 'd': window width (i.e. width of the window widget).
              . 'e': window height (i.e. height of the window widget).
              . 'de': window width x window height.
              . 'd,e': window width, window height (equivalent to '{*,d},{*,e}').
              . 'u': screen width (actually independent on the window size).
              .' v': screen height (actually independent on the window size).
              . 'uv': screen width x screen height.
              . 'u,v': screen width, screen height (equivalent to '{*,u},{*,v}').
              . 'n': current normalization type of the instant display.
              . 't': window title of the instant display.
              . 'x': X-coordinate of the mouse position (or -1, if outside the display area).
              . 'y': Y-coordinate of the mouse position (or -1, if outside the display area).
              . 'b': state of the mouse buttons { 1=left-but. | 2=right-but. | 4=middle-but. }.
              . 'o': state of the mouse wheel.
              . 'k': decimal code of the pressed key if any, 0 otherwise.
              . 'c': boolean (0 or 1) telling if the instant display has been closed recently.
              . 'r': boolean telling if the instant display has been resized recently.
              . 'm': boolean telling if the instant display has been moved recently.
              . Any other 'feature' stands for a  keycode  name  (in  capital  letters),  and  is
       substituted by
                 a boolean describing the current key state { 0=pressed | 1=released }.
              . You can also prepend a hyphen '-' to a 'feature' (that supports it) to flush the
                 corresponding  event  immediately after reading its state (works for keys, mouse
       and
                 window events).

         - Item substitution is never performed in items between double quotes.  One  must  break
       the quotes
           to  enable substitution if needed, as in "3+8 kg = "{3+8}" kg". Using double quotes is
       then
           a convenient way to disable the substitutions mechanism in items, when necessary.

         - One can also disable the substitution mechanism on items  outside  double  quotes,  by
       escaping the
            '{','}' or '$' characters, as in '\{3+4\}\ doesn't\ evaluate'.

        9. Mathematical expressions
           ------------------------

         -  G'MIC  has an embedded mathematical parser. It is used to evaluate (possibly complex)
       expressions
            inside braces '{}', or formulas in commands that may take one as  an  argument  (e.g.
       'fill').

         -  When  the  context  allows  it, a formula is evaluated for each pixel of the selected
       images
            (e.g. 'fill').

         - A math expression may return a scalar or vector-valued result (with a fixed number of
            components).

         - The mathematical parser understands the following  set  of  functions,  operators  and
       variables:

           _ Usual operators: || (logical or), && (logical and), | (bitwise or), & (bitwise and),
              !=,  ==,  <=, >=, <, >, << (left bitwise shift), >> (right bitwise shift), -, +, *,
       /,
              % (modulo), ^ (power), ! (logical not), ~ (bitwise not),
              ++, --, +=, -=, *=, /=, %=, &=, |=, ^=, >>=, <<= (in-place operators).

           _ Usual math functions: abs(), acos(), acosh(), arg(), argkth(),  argmax(),  argmin(),
       asin(),
              asinh(),  atan(),  atan2(),  atanh(), avg(), bool(), cbrt(), ceil(), cos(), cosh(),
       cut(), exp(), fact(),
              fibo(), floor(), gauss(), int(),  isval(),  isnan(),  isinf(),  isint(),  isbool(),
       isfile(), isdir(), isin(),
              kth(), log(), log2(), log10(), max(), med(), min(), narg(), prod(), rol() (left bit
       rotation),
              ror() (right bit rotation), round(), sign(), sin(), sinc(), sinh(), sqrt(), std(),
              srand(_seed), sum(), tan(), tanh(), var(), xor().

              . 'atan2(y,x)' is the version of 'atan()' with two arguments 'y'  and  'x'  (as  in
       C/C++).
              .  'permut(k,n,with_order)' computes the number of permutations of k objects from a
       set of
                 n objects.
              .                     'gauss(x,_sigma,_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 ith argument a_i.
              . 'isval()', 'isnan()', 'isinf()', 'isint()', 'isbool()' test the type of the given
                 number or expression, and return 0 (false) or 1 (true).
              . 'isfile()' (resp. 'isdir()') returns 0 (false) or 1 (true) whether  its  argument
       is a
                 path to an existing file (resp. to a directory) or not.
              .  'isin(v,a_1,...,a_n)'  returns 0 (false) or 1 (true) whether the first value 'v'
       appears
                 in the set of other values 'a_i'.
              . 'argmin()', 'argmax()', 'avg()', 'kth()',  'max()',  'med()',  'min()',  'std()',
       'sum()'
                 and 'var()' can be called with an arbitrary number of scalar/vector arguments.
              .  'round(value,rounding_value,direction)' returns a rounded value. 'direction' can
       be
                 { -1=to-lowest | 0=to-nearest | 1=to-highest }.

           _ Variable names below are pre-defined. They can be overridden.

              . 'l': length of the associated list of images.
              . 'w': width of the associated image, if any (0 otherwise).
              . 'h': height of the associated image, if any (0 otherwise).
              . 'd': depth of the associated image, if any (0 otherwise).
              . 's': spectrum of the associated image, if any (0 otherwise).
              . 'r': shared state of the associated image, if any (0 otherwise).
              . 'wh': shortcut for width x height.
              . 'whd': shortcut for width x height x depth.
              . 'whds': shortcut for width x height x depth x  spectrum  (i.e.  number  of  image
       values).
              . 'im','iM','ia','iv','is','ip','ic': Respectively the minimum, maximum, average,
                 variance,  sum,  product  and  median  value  of the associated image, if any (0
       otherwise).
              . 'xm','ym','zm','cm': The pixel coordinates of the minimum value in the associated
                 image, if any (0 otherwise).
              . 'xM','yM','zM','cM': The pixel coordinates of the maximum value in the associated
                 image, if any (0 otherwise).
              . 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 'ic(_#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': Nth channel value  of  current  processed  pixel  (i.e.  value  located  at
       (x,y,z,N)) in
                 the  associated  image,  if  any  (0 otherwise). 'N' must be an integer in range
       [0,9].
              . 'R','G','B' and 'A' are equivalent to 'i0', 'i1', 'i2' and 'i3' respectively.
              . 'I': current vector-valued processed pixel in the associated  image,  if  any  (0
       otherwise).
                 The number of vector components is equal to the number of image channels
                 (e.g. I = [ R,G,B ] for a RGB image).
              .  You may add '#ind' to any of the variable name above to retrieve the information
       for any
                 numbered image [ind] of the list (when this makes sense).  For  instance  'ia#0'
       denotes the
                 average value of the first image of the list).
              . 'x': current processed column of the associated image, if any (0 otherwise).
              . 'y': current processed row of the associated image, if any (0 otherwise).
              . 'z': current processed slice of the associated image, if any (0 otherwise).
              . 'c': current processed channel of the associated image, if any (0 otherwise).
              . 't': thread id when an expression is evaluated with multiple threads (0 means
                 'master thread').
              . 'e': value of e, i.e. 2.71828...
              . 'pi': value of pi, i.e. 3.1415926...
              . 'u': a random value between [0,1], following a uniform distribution.
              . 'g': a random value, following a gaussian distribution of variance 1
                 (roughly in [-6,6]).
              .  'interpolation': value of the default interpolation mode used when reading pixel
       values
                  with the pixel access operators (i.e. when the interpolation  argument  is  not
       explicitly
                  specified,  see  below for more details on pixel access operators). Its initial
       default
                  value is 0.
              . 'boundary': value of the default boundary  conditions  used  when  reading  pixel
       values with
                  the  pixel  access  operators (i.e. when the boundary condition argument is not
       explicitly
                  specified, see below for more details on pixel access operators).  Its  initial
       default
                  value is 0.

           _ Vector calculus: Most operators are also able to work with vector-valued elements.

              .  '[  a0,a1,...,aN  ]' defines a (N+1)-dimensional vector with scalar coefficients
       ak.
              . 'vectorN(a0,a1,,...,)' does the same, with the ak being repeated periodically  if
       only a
                 few are specified.
              .  In  both  previous  expressions,  the  ak  can  be  vectors  themselves,  to  be
       concatenated into a
                 single vector.
              . The scalar element ak of a vector X is retrieved by 'X[k]'.
              . The sub-vector [ X[p]...X[p+q-1] ] (of size q) of a  vector  X  is  retrieved  by
       'X[p,q]'.
              .  Equality/inequality  comparisons between two vectors is done with operators '=='
       and '!='.
              . Some vector-specific functions can be used on vector values:
                'cross(X,Y)'  (cross  product),  'dot(X,Y)'  (dot  product),  'size(X)'   (vector
       dimension),
                'sort(X,_is_increasing,_chunk_size)'   (sorting  values),  'reverse(A)'  (reverse
       order of
                components), '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 an unsigned integer constant or 'inf'). If P is omitted, the L2 norm is
       used.
              .  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,_is_forward,_starting_indice)' returns the  index  where  sub-
       vector B
                 appears  in  vector  A,  (or  -1 if B is not found in A). Argument A can be also
       replaced by
                 an image indice #ind.
              . A 2-dimensional vector may be  seen  as  a  complex  number  and  used  in  those
       particular
                 functions/operators:
                 '**'   (complex   multiplication),   '//'   (complex  division),  '^^'  (complex
       exponentiation),
                 '**='  (complex  self-multiplication),  '//='  (complex  self-division),   '^^='
       (complex
                 self-exponentiation),  'cabs()'  (complex modulus), 'carg()' (complex argument),
       'cconj()'
                 (complex  conjugate),  'cexp()'  (complex  exponential)  and  'clog()'  (complex
       logarithm).
              .  A  MN-dimensional  vector  may  be  seen  as  a  M  x N matrix and used in those
       particular
                 functions/operators:
                 '*' (matrix-vector multiplication), 'det(A)' (determinant), 'diag(V)'  (diagonal
       matrix
                 from  a  vector),  'eig(A)' (eigenvalues/eigenvectors), 'eye(n)' (n x n identity
       matrix),
                 'inv(A)' (matrix inverse), 'mul(A,B,_nb_colsB)' (matrix-matrix multiplication),
                 'pseudoinv(A,_nb_colsA)', 'rot(u,v,w,angle)' (3D rotation matrix),  'rot(angle)'
       (2D
                 rotation  matrix),  'solve(A,B,_nb_colsB)' (least-square solver of linear system
       A.X = B),
                 'svd(A,_nb_colsA)' (singular value decomposition), 'trace(A)' (matrix trace) and
                 'transp(A,nb_colsA)' (matrix transpose). Argument 'nb_colsB' may be  omitted  if
       it is
                 equal to 1.
              .  Specifying  a  vector-valued  math  expression  as an argument of a command that
       operates on
                 image values (e.g. 'fill') modifies the whole spectrum range  of  the  processed
       image(s),
                 for  each spatial coordinates (x,y,z). The command does not loop over the C-axis
       in this
                 case.

           _ String manipulation: Character strings are defined and managed as vectors objects.
              Dedicated functions and initializers to manage strings are

              . [ 'string' ] and 'string' define a vector whose values are the ascii codes of the
                 specified character string (e.g. 'foo' is equal to [ 102,111,111 ]).
              . _'character' returns the (scalar) ascii code of  the  specified  character  (e.g.
       _'A' is
                 equal to 65).
              .  A  special case happens for empty strings: Values of both expressions [ '' ] and
       '' are 0.
              .  Functions  'lowercase()'  and  'uppercase()'  return  string  with  all   string
       characters
                 lowercased or uppercased.
              .  Function  'stov(str,_starting_indice,_is_strict)'  parses specified string 'str'
       and returns the value
                 contained in it.
              . Function 'vtos(expr,_nb_digits,_siz)'  returns  a  vector  of  size  'siz'  which
       contains
                 the ascii representation of values described by expression 'expr'.
                 'nb_digits' can be { -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 'cats(str1,str2,...,strN,siz)' returns the concatenation of given string
       arguments
                 as a new vector of size 'siz'.

           _ Special operators can be used:

              .  ';':  expression  separator.  The  returned value is always the last encountered
       expression.
                 For instance expression '1;2;pi' is evaluated as 'pi'.
              . '=': variable assignment. Variables in mathematical  parser  can  only  refer  to
       numerical
                 values  (vectors  or  scalars).  Variable  names  are  case-sensitive.  Use this
       operator in
                 conjunction with ';' to define more complex evaluable expressions, such as
                 't=cos(x);3*t^2+2*t+1'.
                 These variables remain local to the mathematical parser and cannot  be  accessed
       outside
                  the evaluated expression.
              .  Variables  defined  in  math  parser may have a constant property, by specifying
       keyword const
                 before the variable name (e.g. const foo = pi/4;).  The  value  set  to  such  a
       variable must
                 be  indeed  a  constant  scalar.  Constant  variables  allows  certain  types of
       optimizations in
                 the math JIT compiler.

           _ The following specific functions are also defined:

              . 'u(max)' or 'u(min,max)': return a random value  between  [0,max]  or  [min,max],
       following
                 a uniform distribution.
              .  'i(_a,_b,_c,_d,_interpolation_type,_boundary_conditions)':  return  the value of
       the pixel
                 located at position (a,b,c,d) in the associated image, if any (0 otherwise).
                 'interpolation_type' can be { 0=nearest neighbor | other=linear }.
                 'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic  |  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[offset,_boundary_conditions]'                       and
       'I/J(#ind,_x,_y,_z,_interpolation,_boundary_conditions)' do
                 the same as 'i/j[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).
              . 'sort(#ind,_is_increasing,_axis)' sorts the values in the specified image [ind].
              . '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 x dy x dz x dc. Arguments for coordinates and sizes can be  omitted  if  they
       are not
                 ambiguous (e.g. 'crop(#ind,x,y,dx,dy)' is a valid invocation of this function).
              .  'draw(_#ind,S,x,y,z,c,dx,_dy,_dz,_dc,_opacity,_M,_max_M)'  draws  a  sprite S in
       image [ind]
                 (or in default  image  selected  if  'ind'  is  not  specified)  at  coordinates
       (x,y,z,c).
                 The size of the sprite dx x dy x dz x dc must be specified. You can also specify
       a
                 corresponding opacity mask M if its size matches S.
              . '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.
              .  '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 and geometry.
              . '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==0,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 Nth 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'
                 is verified (i.e. not zero). It may happen that no iteration is done,  in  which
       case the
                 function returns nan. Otherwise, it returns the last value of 'body'.
                 For                  instance,                  the                  expression:
       'if(N<2,N,for(n=N;F0=0;F1=1,n=n-1,F2=F0+F1;F0=F1;F1=F2))'
                 returns the Nth value of the Fibonacci  sequence,  for  N>=0  (e.g.,  46368  for
       N=24).
              .      'while(condition,expression)'      is      exactly      the      same     as
       'for(init,condition,expression)'
                 without the specification of an initializing expression.
              . 'break()' and 'continue()' respectively breaks and continues the current  running
       bloc
                 (loop, init or main environment).
              .  '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.
              . '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   ascii  characters  defined  by  the  vector-valued  expression  (e.g.
       'prints('Hello')').
              . 'debug(expression) prints  detailed  debug  information  about  the  sequence  of
       operations done
                 by the math parser to evaluate the expression (and returns its value).
              . 'display(_X,_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).
              . 'unref(a,b,...) destroys references to the named variable given as arguments.
              . 'breakpoint() inserts a possible computation breakpoint (not supported by the cli
       interface).
              . '_(expr) just ignores its arguments (mainly useful for debugging).
              .  'ext('pipeline')  executes  the  specified  G'MIC  pipeline  as if it was called
       outside
                 the currently evaluated expression.

           - User-defined macros:

              . Custom macro functions can be defined in a math expression, using the  assignment
       operator
                 '=', e.g. 'foo(x,y) = cos(x + y); result = foo(1,2) + foo(2,3)'.
              . Trying to override a built-in function (e.g. 'abs()') has no effect.
              . Overloading macros with different number of arguments is possible. Re-defining a
                 previously defined macro with the same number of arguments discards its previous
                 definition.
              . Macro functions are indeed processed as macros by the mathematical evaluator. You
       should
                 avoid invoking them with arguments that are themselves results of assignments or
                 self-operations. For instance, 'foo(x) = x + x; z =  0;  foo(++z)'  returns  '4'
       rather
                 than expected value '2'.
              .  When  substituted,  macro  arguments  are placed inside parentheses, except if a
       number sign
                 '#' is located just before or after the argument name. For instance, expression
                 'foo(x,y) = x*y; foo(1+2,3)' returns '9'  (being  substituted  as  '(1+2)*(3)'),
       while
                 expression  'foo(x,y)  =  x#*y#;  foo(1+2,3)'  returns '7' (being substituted as
       '1+2*3').
              . Number signs appearing  between  macro  arguments  function  actually  count  for
       'empty'
                 separators.  They  may  be  used to force the substitution of macro arguments in
       unusual
                 places, e.g. as in 'str(N) = ['I like N#'];'.

           - Multi-threaded and in-place evaluation:

              . If your image data are large enough and you have several CPUs  available,  it  is
       likely that
                 the  math  expression  passed  to  a  'fill'  or 'input' command is evaluated in
       parallel,
                 using multiple computation threads.
              . Starting an expression with ':' or '*' forces the  evaluations  required  for  an
       image to be
                 run  in parallel, even if the amount of data to process is small (beware, it may
       be slower
                 to evaluate in this case!). Specify ':' (instead of '*') to avoid possible image
       copy
                 done  before  evaluating  the expression (this saves memory, but do this only if
       you are
                 sure this step is not required!)
              . If the specified expression starts with '>' or '<', the pixel access operators
                 'i(), i[], j()' and 'j[]' return values of the image being currently modified,
                 in forward ('>') or backward ('<') order. The multi-threading evaluation of the
                 expression is also disabled in this case.
              . Function 'critical(operands)' forces the execution of the  given  operands  in  a
       single thread at a
                 time.

           _      Expressions      'i(_#ind,x,_y,_z,_c)=value',      'j(_#ind,x,_y,_z,_c)=value',
       'i[_#ind,offset]=value'
              and 'j[_#ind,offset]=value' set a pixel value at  a  different  location  than  the
       running one
              in  the  image  [ind]  (or  in the associated image if argument '#ind' is omitted),
       either with
              global coordinates/offsets (with 'i(...)'  and  'i[...]'),  or  relatively  to  the
       current
              position  (x,y,z,c)  (with  'j(...)' and 'j[...]'). These expressions always return
       'value'.

         - The last image of the list is always associated to the evaluations of '{expressions}',
            e.g. G'MIC sequence '256,128 fill {w}' will create a 256x128 image filled with  value
       256.

        10. Image and data viewers
            ----------------------

         -  G'MIC  has  some  very  handy embedded visualization modules, for 1D signals (command
       'plot'),
            1D/2D/3D images (command 'display') and 3D objects (command 'display3d'). It manages
            interactive views of the selected image data.

         - The following keyboard shortcuts are available in the interactive viewers:

           . (mousewheel): Zoom in/out.
           . CTRL+D: Increase window size.
           . CTRL+C: Decrease window size.
           . CTRL+R: Reset window size.
           . CTRL+W: Close window.
           . CTRL+F: Toggle fullscreen mode.
           . CTRL+S: Save current window snapshot as numbered file 'gmic_xxxx.bmp'.
           .  CTRL+O:  Save  current  instance   of   the   viewed   data,   as   numbered   file
       'gmic_xxxx.cimgz'.

         - Shortcuts specific to the 1D/2D/3D image viewer (command 'display') are:

           . CTRL+A: Switch cursor mode.
           . CTRL+P: Play z-stack of frames as a movie (for volumetric 3D images).
           . CTRL+V: Show/hide 3D view (for volumetric 3D images).
           . CTRL+(mousewheel): Go up/down.
           . SHIFT+(mousewheel): Go left/right.
           . Numeric PAD: Zoom in/out (+/-) and move through zoomed image (digits).
           . BACKSPACE: Reset zoom scale.

         - Shortcuts specific to the 3D object viewer (command 'display3d') are:

           . (mouse)+(left mouse button): Rotate 3D object.
           . (mouse)+(right mouse button): Zoom 3D object.
           . (mouse)+(middle mouse button): Shift 3D object.
           . CTRL+F1 ... CTRL+F6: Toggle between different 3D rendering modes.
           . CTRL+Z: Enable/disable z-buffered rendering.
           . CTRL+A: Show/hide 3D axes.
           . CTRL+G: Save 3D object, as numbered file 'gmic_xxxx.off'.
           . CTRL+T: Switch between single/double-sided 3D modes.

        11. Adding custom commands
            ----------------------

         - New custom commands can be added by the user, through the use of G'MIC custom commands
       files.

         - A command file is a simple ascii text file, where each line starts either by
            'command_name: command_definition' or 'command_definition (continuation)'.

         - At startup, G'MIC automatically includes user's command file $HOME/.gmic (on Unix) or
            %APPDATA%/user.gmic (on Windows). The CLI tool 'gmic' automatically runs the command
            'cli_start' if defined.

         - Custom command names must use character set  [a-zA-Z0-9_]  and  cannot  start  with  a
       number.

         -  Any ' # comment' expression found in a custom commands file is discarded by the G'MIC
       parser,
            wherever it is located in a line.

         - In a custom command, the following $-expressions are recognized and substituted:

           . '$*' is substituted by a copy of the specified string of arguments.
           . '$"*"' is substituted by a copy of the specified string of arguments, each being
              double-quoted.
           . '$#' is substituted by the maximum indice of known arguments  (either  specified  by
       the user
              or set to a default value in the custom command).
           .  '$[]' is substituted by the list of selected image indices that have been specified
       during 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 substitued by all specified
       command
              arguments except the first and the last one. Expression '${^0}' is then substituted
       by all
              arguments  of  the  invoked  command  (eq.  to '$*' if all specified arguments have
       indeed a
              value).
           . '$=var' is substituted by the set of instructions that will assign each argument  $i
       to the
              named  variable  'var$i'  (for  i  in [0...$#]). This is particularly useful when a
       custom
              command want to manage variable numbers of  arguments.  Variables  names  must  use
       character set
              [a-zA-Z0-9_] and cannot start with a number.

         - These particular $-expressions for custom commands are always substituted, even in
            double-quoted  items  or when the dollar sign '$' is escaped with a backslash '\'. To
       avoid
            substitution, place an empty double quoted string just after the '$' (as in '$""1').

         - Specifying arguments may be skipped when invoking a custom command, by replacing  them
       by commas
            ',' as in expression 'flower ,,3'. Omitted arguments are set to their default values,
       which
            must be thus explicitly defined in the  code  of  the  corresponding  custom  command
       (using
            default argument expressions as '${1=default}').

         -  If  one  numbered  argument  required by a custom command misses a value, an error is
       thrown by the
            G'MIC interpreter.

        12. List of commands
            ----------------

          All available G'MIC commands are listed  below,  classified  by  themes.  When  several
       choices of
          command  arguments  are  possible,  they appear separated by '|'. An argument specified
       inside '[]'
          or starting by '_' is optional except when standing  for  an  existing  image  [image],
       where 'image'
          can  be either an indice number or an image name. In this case, the '[]' characters are
       mandatory
          when writing the item. A command marked with '(+)' is one of the builtin commands. Note
       also that
          all  images  that serve as illustrations in this reference documentation are normalized
       in [0,255]
          before being displayed. You may need to do this explicitly (command 'normalize  0,255')
       if you
          want to save and view images with the same aspect than those illustrated in the example
       codes.

        ** Global Options:

           debug (+):

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

           help:
               command |
               (no arg)

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

           version:

               Display current version number on stdout.

        ** Input / Output:

           camera (+):
               _camera_index>=0,_nb_frames>0,_skip_frames>=0,_capture_width>=0,
                 _capture_height>=0

               Insert one or several frames from specified camera.
               When 'nb_frames==0', the camera  stream  is  released  instead  of  capturing  new
       images.
               Default  values: 'camera_index=0' (default camera), 'nb_frames=1', 'skip_frames=0'
       and           'capture_width=capture_height=0' (default size).

           clut:
               "clut_name",_resolution>0

               Insert one of the pre-defined CLUTs at the end of the image list.
               'clut_name' can  be  {  60's  |  60's_faded  |  60's_faded_alt  |  agfa_apx_100  |
       agfa_apx_25   |            agfa_precisa_100  |  agfa_ultra_color_100  |  agfa_vista_200  |
       alien_green    |              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 |           black_and_white | bleach_bypass
       |  blue_mono  |  color_rich | expired_fade | expired_polaroid |           extreme | fade |
       faded | faded_alt | faded_analog | faded_extreme | faded_vivid | faux_infrared           |
       fuji3510_constlclip  |  fuji3510_constlmap  |  fuji3510_cuspclip  |  fuji3513_constlclip |
       fuji3513_constlmap  |  fuji3513_cuspclip  |  fuji_160c  |  fuji_160c_+  |  fuji_160c_++  |
       fuji_160c_- |           fuji_400h | fuji_400h_+ | fuji_400h_++ | fuji_400h_- | fuji_800z |
       fuji_800z_+ | fuji_800z_++ |           fuji_800z_-  |  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_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_ilford_delta_3200    |   fuji_ilford_delta_3200_+   |   fuji_ilford_delta_3200_++   |
       fuji_ilford_delta_3200_- | fuji_ilford_hp5  |  fuji_ilford_hp5_+  |  fuji_ilford_hp5_++  |
       fuji_ilford_hp5_-   |   fuji_neopan_1600  |  fuji_neopan_1600_+  |  fuji_neopan_1600_++  |
       fuji_neopan_1600_-  |  fuji_neopan_acros_100  |  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_50 | fuji_xtrans_ii_astia_v2
       |              fuji_xtrans_ii_classic_chrome_v1    |    fuji_xtrans_ii_pro_neg_hi_v2     |
       fuji_xtrans_ii_pro_neg_std_v2                   |        fuji_xtrans_ii_provia_v2        |
       fuji_xtrans_ii_velvia_v2 | generic_fuji_astia_100  |            generic_fuji_provia_100  |
       generic_fuji_velvia_100               |               generic_kodachrome_64              |
       generic_kodak_ektachrome_100_vs | golden | golden_bright |  golden_fade  |  golden_mono  |
       golden_vibrant     |    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 | green_mono |
       hong_kong | ilford_delta_100 | ilford_delta_3200 | ilford_delta_400 |  ilford_fp4_plus_125
       |            ilford_hp5_plus_400  |  ilford_hps_800  | ilford_pan_f_plus_50 | ilford_xp2 |
       kodak2383_constlclip              |    kodak2383_constlmap    |    kodak2383_cuspclip    |
       kodak2393_constlclip    |    kodak2393_constlmap    |              kodak2393_cuspclip    |
       kodak_bw_400_cn    |    kodak_e-100_gx_ektachrome_100    |    kodak_ektachrome_100_vs    |
       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_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_t-max_100   |
       kodak_t-max_3200    |    kodak_t-max_400   |   kodak_tmax_3200   |   kodak_tmax_3200_+   |
       kodak_tmax_3200_++ |           kodak_tmax_3200_- | kodak_tri-x_400 |  kodak_tri-x_400_+  |
       kodak_tri-x_400_++    |              kodak_tri-x_400_-    |    light_blown    |   lomo   |
       lomography_redscale_100 | lomography_x-pro_slide_200 |           mono_tinted |  mute_shift
       |    muted_fade    |   natural_vivid   |   nostalgic   |   orange_tone   |   pink_fade   |
       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_--- |
       purple | retro | rollei_ir_400  |  rollei_ortho_25  |            rollei_retro_100_tonal  |
       rollei_retro_80s  |  rotate_muted  |  rotate_vibrant | rotated |           rotated_crush |
       smooth_cromeish  |  smooth_fade  |  soft_fade  |  solarized_color  |  solarized_color2   |
       summer  |  summer_alt  |  sunny  |  sunny_alt  |  sunny_rich  |  sunny_warm | super_warm |
       super_warm_rich | sutro_fx | technicalfx_backlight_filter  |  vibrant  |  vibrant_alien  |
       vibrant_contrast  |  vibrant_cromeish  | vintage | vintage_alt | vintage_brighter | warm |
       warm_highlight  |  warm_yellow   |   zilverfx_b_w_solarization   |   zilverfx_infrared   |
       zilverfx_vintage_b_w }.

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

               Import G'MIC custom commands from specified file, URL or string.
               (eq. to 'm').
               Imported commands are available directly after the 'command' invocation.
               Default value: 'add_debug_info=1'.

           cursor (+):
               _mode = { 0=hide | 1=show }

               Show or hide mouse cursor for selected instant display windows.
               Command  selection  (if  any) stands for instant display window indices instead of
       image indices.
               Default value: 'mode=1'.

           display (+):
               _X[%]>=0,_Y[%]>=0,_Z[%]>=0,_exit_on_anykey={ 0 | 1 }

               Display selected images in an interactive viewer (use the instant  display  window
       [0] if opened).
               (eq. to 'd').
               Arguments  'X','Y','Z'  determine  the  initial  selection view, for 3D volumetric
       images.
               Default value: 'X=Y=Z=0' and 'exit_on_anykey=0'.

           display0:

               Display selected images without value normalization.
               (eq. to 'd0').

           display3d (+):
               _[background_image],_exit_on_anykey={ 0 | 1 } |
               _exit_on_anykey={ 0 | 1 }

               Display selected 3D objects in an interactive  viewer  (use  the  instant  display
       window [0] if opened).
               (eq. to 'd3d').
               Default values: '[background_image]=(default)' and 'exit_on_anykey=0'.

           display_array:
               _width>0,_height>0

               Display images in interactive windows where pixel neighborhoods can be explored.
               Default values: 'width=13' and 'height=width'.

           display_fft:

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

           display_graph:
               _width>=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"'.

           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.
               (eq. to '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'.

           display_parametric:
               _width>0,_height>0,_outline_opacity,_vertex_radius>=0,_is_antialiased={ 0 | 1 },
                 _is_decorated={ 0 | 1 },_xlabel,_ylabel

               Render 2D or 3D parametric curve or point clouds from selected image data.
               Curve points are defined as pixels of a 2 or 3-channel image.
               If the point image contains more than 3 channels, additional channels  define  the
       (R,G,B) color           for each vertex.
               If  'outline_opacity>1',  the outline is colored according to the specified vertex
       colors and           'outline_opacity-1' is used
               as the actual drawing opacity.
               Default     values:     'width=512',     'height=width',      'outline_opacity=3',
       'vertex_radius=0',            'is_antialiased=1',  'is_decorated=1', 'xlabel="x-axis"' and
       'ylabel="y-axis"'.

           display_parallel:

               Display each selected image in a separate interactive display window.
               (eq. to 'dp').

           display_parallel0:

               Display each selected image in a  separate  interactive  display  window,  without
       value           normalization.
               (eq. to 'dp0').

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

           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.
               (eq. to 'dq').
               Default values: 'size_factor=16', 'arrow_size=1.5' and 'color_mode=1'.

           display_rgba:
               _background_RGB_color

               Render selected RGBA images over a checkerboard or colored background.
               (eq. to 'drgba').
               Default values: 'background_RGB_color=undefined' (checkerboard).

           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.
               (eq. to 'dt').
               Default   values:   'size_factor=16',   'ellipse_size=1.5',   'color_mode=2'   and
       'outline=2'.

           display_warp:
               _cell_size>0

               Render selected 2D warping fields.
               (eq. to 'dw').
               Default value: 'cell_size=15'.

           document_gmic:
               _format={  ascii | bash | html | images | latex },_image_path,_write_wrapper={ 0 |
       1 }

               Create documentation of .gmic command files (loaded as  raw  'uchar'  images),  in
       specified format.
               Default values: 'format=ascii', 'image_path=""' and 'write_wrapper=1'.
               Example(s) : raw:filename.gmic,char document_gmic html,img

           echo (+):
               message

               Output specified message on the error output.
               (eq. to 'e').
               Command selection (if any) stands for displayed call stack subset instead of image
       indices.

           echo_file:
               filename,message

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

           echo_stdout:
               message

               Output specified message, on the standard output (stdout).
               (similar to 'echo' for output on standard output instead of standard error).

           function1d:
               0<=smoothness<=1,x0>=0,y0,x1>=0,y1,...,xn>=0,yn

               Insert continuous 1D function from specified list of keypoints (xk,yk)
               in range [0,max(xk)] (xk are positive integers).
               Default values: 'smoothness=1' and 'x0=y0=0'.

           gmicky:

               Insert new image of the G'MIC mascot 'Gmicky'.

           gmicky_deevad:

               Insert new image of the G'MIC mascot 'Gmicky', by David Revoy.

           gmicky_mahvin:

               Insert new image of the G'MIC mascot 'Gmicky', by Mahvin.

           gmicky_wilber:

               Insert new image of the G'MIC mascot 'Gmicky' together with GIMP mascot  'Wilber',
       by Mahvin.

           input (+):
               [type:]filename |
               [type:]http://URL |
               [selection]x_nb_copies>0 |
               { width>0[%] | [image_w] },{ _height>0[%] | [image_h] },{ _depth>0[%] |
                 [image_d] },{ _spectrum>0[%] | [image_s] },_{ value1,_value2,... | 'formula' } |
               (value1{,|;|/|^}value2{,|;|/|^}...) |
               0

               Insert  a  new  image  taken  from  a filename or from a copy of an existing image
       [indice],
               or insert new image with specified dimensions and values.  Single  quotes  may  be
       omitted in
               'formula'. Specifying argument '0' inserts an 'empty' image.
               (eq. to 'i' | (no arg)).
               Default values: 'nb_copies=1', 'height=depth=spectrum=1' and 'value1=0'.

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

               Insert CLUT data from a .cube filename (Adobe CLUT file format).
               Default value: 'convert_1d_cluts_to_3d=1'.

           input_glob:
               pattern

               Insert new images from several filenames that match the specified glob pattern.

           input_gpl:
               filename

               Input specified filename as a .gpl palette data file.

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

               Output selected images as one or several numbered file(s).
               (eq. to 'o').
               Default value: 'format_options'=(undefined).

           output_cube:
               filename

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

           output_ggr:
               filename,_gradient_name

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

           outputn:
               filename

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

           outputp:
               prefix

               Output selected images as prefixed versions of their original filenames.
               (eq. to 'op').
               Default value: 'prefix=_'.

           outputw:

               Output selected images by overwritting their original location.
               (eq. to 'ow').

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

               Output selected images with same base filenames but for N different extensions.
               (eq. to 'ox').
               Default value: 'output_at_same_location=0'.

           pass (+):
               _shared_state={ 0=non-shared (copy) | 1=shared | 2=adaptive }

               Insert images from parent context of a custom command or a local environment.
               Command selection (if any) stands for a selection of images in the parent context.
               By default (adaptive shared state), selected images are inserted in a shared state
       if they do           not belong to the context (selection) of the current  custom  command
       or local environment as well.
               Typical  use  of  command  'pass' concerns the design of custom commands that take
       images as           arguments.
               Default value: 'shared_state=2'.

           plot (+):
               _plot_type,_vertex_type,_xmin,_xmax,_ymin,_ymax,_exit_on_anykey={ 0 | 1 } |
               'formula',_resolution>=0,_plot_type,_vertex_type,_xmin,xmax,_ymin,_ymax,
                 _exit_on_anykey={ 0 | 1 }

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

           print (+):

               Output information on selected images, on the standard error (stderr).
               (eq. to 'p').

           rainbow_lut:

               Input a 256-entries RGB colormap of rainbow colors.

           roddy:

               Input a new image of the G'MIC Rodilius mascot 'Roddy'.

           screen (+):
               _x0[%],_y0[%],_x1[%],_y1[%]

               Take screenshot, optionally grabbed with specified coordinates, and insert it
               at the end of the image list.

           select (+):
               feature_type,_X[%]>=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, optionnally in a compressed
       form.
               'datatype'  can  be { auto | uchar | char | ushort | short | uint | int | uint64 |
       int64 | float |           double }.
               Specify 'datatype' if all selected images have a range of values constrained to  a
       particular           datatype, in order to minimize the memory footprint.
               The resulting image has only integers values in [0,255] and can then be saved as a
       raw image of
               unsigned chars (doing so will output a valid .cimg[z] or .gmz file).
               If 'store_names' is set to '1', serialization uses the .gmz format to  store  data
       in memory           (otherwise the .cimg[z] format).
               Default values: 'datatype=auto', 'is_compressed=1' and 'store_names=1'.

           shape_circle:
               _size>=0

               Input a 2D circle binary shape with specified size.
               Default value: 'size=512'.

           shape_cupid:
               _size>=0

               Input a 2D cupid binary shape with specified size.
               Default value: 'size=512'.

           shape_diamond:
               _size>=0

               Input a 2D diamond binary shape with specified size.
               Default value: 'size=512'.

           shape_fern:
               _size>=0,_density[%]>=0,_angle,0<=_opacity<=1,_type={ 0=Asplenium
                 adiantum-nigrum | 1=Thelypteridaceae }

               Input a 2D Barnsley fern with specified size.
               Default value: 'size=512', 'density=50%', 'angle=30', 'opacity=0.3' and 'type=0'.

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

           shape_heart:
               _size>=0

               Input a 2D heart binary shape with specified size.
               Default value: 'size=512'.

           shape_polygon:
               _size>=0,_nb_vertices>=3,_angle

               Input a 2D polygonal binary shape with specified geometry.
               Default value: 'size=512', 'nb_vertices=5' and 'angle=0'.

           shape_snowflake:
               size>=0,0<=_nb_recursions<=6

               Input a 2D snowflake binary shape with specified size.
               Default values: 'size=512' and 'nb_recursions=5'.

           shape_star:
               _size>=0,_nb_branches>0,0<=_thickness<=1

               Input a 2D star binary shape with specified size.
               Default values: 'size=512', 'nb_branches=5' and 'thickness=0.38'.

           shared (+):
               x0[%],x1[%],y[%],z[%],v[%] |
               y0[%],y1[%],z[%],v[%] |
               z0[%],z1[%],v[%] |
               v0[%],v1[%] |
               v0[%] |
               (no arg)

               Insert shared buffers from (opt. points/rows/planes/channels of) selected images.
               Shared buffers cannot be returned by a command, nor a local environment.
               (eq. to 'sh').

           sample:
               _name1={ ? | apples | barbara | boats | bottles | butterfly | cameraman | car |
                 cat | cliff | david | dog | duck | eagle | elephant | earth | flower | fruits |
                 greece | gummy | house | inside | landscape | leaf | lena | leno | lion |
                 mandrill | monalisa | monkey | parrots | pencils | peppers | rooster | rose |
                 square | teddy | tiger | 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).
               (eq. to 'sp').
               Argument 'name' can be replaced by an integer which serves as a sample index.

           srand (+):
               value |
               (no arg)

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

           string:
               "string"

               Insert new image containing the ascii codes of specified string.

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

               Input a 2D synthetic image.
               Default values: 'width=512', 'height=width' and 'spectrum=3'.

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

               Discard definition of specified custom commands.
               Set argument to '*' for discarding all existing custom commands.

           uniform_distribution:
               nb_levels>=1,spectrum>=1

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

           unserialize (+):

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

           update:

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

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

               Set or increment/decrement the verbosity level. Default level is 0.
               (eq. to 'v').
               When 'level'>=0, G'MIC log messages are displayed on the standard error (stderr).
               Default value: 'level=0'.

           wait (+):
               delay |
               (no arg)

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

           window (+):
               _width[%]>=-1,_height[%]>=-1,_normalization,_fullscreen,_pos_x[%],_pos_y[%],_title

               Display  selected  images  into  an  instant  display  window with specified size,
       normalization type,
               fullscreen mode and title.
               (eq. to 'w').
               If 'width' or 'height' is set to -1, the corresponding dimension  is  adjusted  to
       the window
               or image size.
               When arguments 'pos_x' and 'pos_y' are both different than -1, the window is moved
       to
               the specified coordinates.
               'width'=0 or 'height'=0 closes the instant display window.
               'normalization' can be { -1=keep same | 0=none | 1=always | 2=1st-time | 3=auto }.
               'fullscreen' can be { -1=keep same | 0=no | 1=yes }.
               You can manage up to 10 different instant display windows by  using  the  numbered
       variants
               'w0' (default, eq. to 'w'),'w1',...,'w9' of the command 'w'.
               Invoke  'window'  with  no  selection  to  make the window visible, if is has been
       closed by the user.
               Default       values:        'width=height=normalization=fullscreen=-1'        and
       'title=(undefined)'.

        ** List Manipulation:

           keep (+):

               Keep only selected images.
               (eq. to 'k').

           move (+):
               position[%]

               Move selected images at specified position.
               (eq. to 'mv').

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

               Set names of selected images.
               -  If  the selection contains a single image, then it is assumed the command has a
       single name           argument (possibly containing multiple comas).
               - If the selection contains more than one image, each command argument  defines  a
       single image           name for each image of the selection.
               (eq. to 'nm').

           remove (+):

               Remove selected images.
               (eq. to 'rm').

           remove_duplicates:

               Remove duplicates images in the selected images list.

           remove_empty:

               Remove empty images in the selected image list.

           reverse (+):

               Reverse positions of selected images.
               (eq. to 'rv').

           sort_list:
               _ordering={ + | - },_criterion

               Sort list of selected images according to the specified image criterion.
               Default values: 'ordering=+', 'criterion=i'.

           sort_str:

               Sort selected images (viewed as a list of strings) in lexicographic order.

        ** Mathematical Operators:

           abs (+):

               Compute the pointwise absolute values of selected images.

           acos (+):

               Compute the pointwise arccosine of selected images.

           acosh (+):

               Compute the pointwise hyperbolic arccosine of selected images.

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

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

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

               Compute  the  bitwise  AND  of  selected  images  with  specified  value, image or
       mathematical
               expression, or compute the pointwise sequential bitwise AND of selected images.
               (eq. to '&').

           argmax:

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

           argmin:

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

           asin (+):

               Compute the pointwise arcsine of selected images.

           asinh (+):

               Compute the pointwise hyperbolic arcsine of selected images.

           atan (+):

               Compute the pointwise arctangent of selected images.

           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.

           atanh (+):

               Compute the pointwise hyperbolic arctangent of selected images.

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

               Compute the bitwise left shift of selected images with specified value, image or
               mathematical expression, or compute the pointwise sequential bitwise left shift of
               selected images.
               (eq. to '<<').

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

               Compute the bitwise right shift of selected images with specified value, image or"
               mathematical  expression,  or compute the pointwise sequential bitwise right shift
       of
               selected images.
               (eq. to '>>').

           cos (+):

               Compute the pointwise cosine of selected images.

           cosh (+):

               Compute the pointwise hyperbolic cosine of selected images.

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

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

           div_complex:
               [divider_real,divider_imag],_epsilon>=0

               Perform division of the selected complex  pairs  (real1,imag1,...,realN,imagN)  of
       images by           specified complex pair of images (divider_real,divider_imag).
               In complex pairs, the real image must be always located before the imaginary image
       in the image list.
               Default value: 'epsilon=1e-8'.

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

               Compute the boolean equality of selected images with specified value, image or
               mathematical expression, or compute the boolean equality of selected images.
               (eq. to '==').

           exp (+):

               Compute the pointwise exponential of selected images.

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

               Compute the boolean 'greater or equal than'  of  selected  images  with  specified
       value, image
               or  mathematical  expression,  or  compute  the boolean 'greater or equal than' of
       selected images.
               (eq. to '>=').

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

               Compute the boolean 'greater than' of selected images with specified value,  image
       or
               mathematical expression, or compute the boolean 'greater than' of selected images.
               (eq. to '>').

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

               Compute  the boolean 'less or equal than' of selected images with specified value,
       image or
               mathematical expression, or compute the boolean 'less or equal than'  of  selected
       images.
               (eq. to '<=').

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

               Compute the boolean 'less than' of selected images with specified value, image or
               mathematical expression, or compute the boolean 'less than' of selected images.
               (eq. to '<').

           log (+):

               Compute the pointwise base-e logarithm of selected images.

           log10 (+):

               Compute the pointwise base-10 logarithm of selected images.

           log2 (+):

               Compute the pointwise base-2 logarithm of selected images

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

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

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

               Compute the matrix division of selected matrices/vectors by specified value, image
       or
               mathematical expression, or compute the matrix division of selected images.
               (eq. to 'm/').

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

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

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

               Compute the modulo of selected images with specified value, image or mathematical
               expression, or compute the pointwise sequential modulo of selected images.
               (eq. to '%').

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

               Compute the matrix right multiplication of selected matrices/vectors by  specified
       value, image or
               mathematical  expression,  or  compute the matrix right multiplication of selected
       images.
               (eq. to 'm*').

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

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

           mul_channels:
               value1,_value2,...,_valueN

               Multiply channels of selected images by specified sequence of values.

           mul_complex:
               [multiplier_real,multiplier_imag]

               Perform multiplication of the selected complex pairs (real1,imag1,...,realN,imagN)
       of images by           specified complex pair of images (multiplier_real,multiplier_imag).
               In complex pairs, the real image must be always located before the imaginary image
       in the image list.

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

               Compute the boolean inequality of selected images with specified value, image or
               mathematical expression, or compute the boolean inequality of selected images.
               (eq. to '!=').

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

               Compute the  bitwise  OR  of  selected  images  with  specified  value,  image  or
       mathematical
               expression, or compute the pointwise sequential bitwise OR of selected images.
               (eq. to '|').

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

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

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

               Compute  the  bitwise left rotation of selected images with specified value, image
       or
               mathematical expression, or compute the pointwise sequential bitwise left rotation
       of
               selected images.

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

               Compute  the bitwise right rotation of selected images with specified value, image
       or
               mathematical  expression,  or  compute  the  pointwise  sequential  bitwise  right
       rotation of
               selected images.

           sign (+):

               Compute the pointwise sign of selected images.

           sin (+):

               Compute the pointwise sine of selected images.

           sinc (+):

               Compute the pointwise sinc function of selected images.

           sinh (+):

               Compute the pointwise hyperbolic sine of selected images.

           sqr (+):

               Compute the pointwise square function of selected images.

           sqrt (+):

               Compute the pointwise square root of selected images.

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

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

           tan (+):

               Compute the pointwise tangent of selected images.

           tanh (+):

               Compute the pointwise hyperbolic tangent of selected images.

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

               Compute  the  bitwise  XOR  of  selected  images  with  specified  value, image or
       mathematical
               expression, or compute the pointwise sequential bitwise XOR of selected images.

        ** Values Manipulation:

           apply_curve:
               0<=smoothness<=1,x0,y0,x1,y1,x2,y2,...,xN,yN

               Apply curve transformation to image values.
               Default values: 'smoothness=1', 'x0=0', 'y0=100'.

           apply_gamma:
               gamma>=0

               Apply gamma correction to selected images.

           balance_gamma:
               _ref_color1,...

               Compute gamma-corrected color balance of selected image, with respect to specified
       reference color.
               Default value: 'ref_color1=128'.

           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 { uchar | char | ushort | short |
       uint | int |           uint64 | int64 | float | double }.

           complex2polar:

               Compute complex to polar transforms of selected images.

           compress_clut:
               _max_nbpoints>=1,_max_error>=0,_avg_error>=0

               Compress selected color LUTs as sequences of colored keypoints.
               Default values: 'max_nb_points=2048', 'max_error=17.5' and 'avg_error=1.75'.

           compress_rle:
               _is_binary_data={ 0 | 1 },_maximum_sequence_length>=0

               Compress selected images as 2xN data matrices, using RLE algorithm.
               Set 'maximum_sequence_length=0' to disable maximum length constraint.
               Default values: 'is_binary_data=0' and 'maximum_sequence_length=0'.

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

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

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

               Cut values of selected images in specified range.
               (eq. to 'c').
               (no arg) runs interactive mode (uses the instant display window [0] if opened).
               In interactive mode, the chosen cut values are returned in the status.

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

               Decompress color LUT expressed as a list of colored keypoints.
               Default value: 'width=height=depth=64'.

           decompress_rle:

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

           eigen2tensor:

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

           endian (+):
               _datatype

               Reverse data endianness of selected images, eventually considering the pixel being
       of the           specified datatype.
               'datatype'  can be { uchar | char | ushort | short | uint | int | uint64 | int64 |
       float | double }.

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

               Equalize histograms of selected images.
               If value range is specified, the equalization is  done  only  for  pixels  in  the
       specified
               value range.
               Default values: 'nb_levels=256', 'value_min=0%' and 'value_max=100%'.

           fill (+):
               value1,_value2,... |
               [image] |
               'formula'

               Fill  selected  images  with  values  read from the specified value list, existing
       image
               or mathematical expression. Single quotes may be omitted in 'formula'.
               (eq. to 'f').

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

               Index selected vector-valued images by specified vector-valued palette.
               'predefined_palette' can be { 0=default | 1=HSV | 2=lines | 3=hot | 4=cool | 5=jet
       | 6=flag | 7=cube }.
               Default values: 'dithering=0' and 'map_palette=0'.

           inrange:
               min[%],max[%]

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

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

               Map specified vector-valued palette to selected indexed scalar images.
               'predefined_palette' can be { 0=default | 1=HSV | 2=lines | 3=hot | 4=cool | 5=jet
       | 6=flag | 7=cube }.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
               Default value: 'boundary_conditions=0'.

           map_clut:
               [clut] | "clut_name"

               Map specified RGB color LUT to selected images.

           mix_channels:
               (a00,...,aMN)

               Apply specified matrix to channels of selected images.

           negate:
               base_value |
               (no arg)

               Negate image values.
               Default value: 'base_value=(undefined)'.

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

           noise_poissondisk:
               _radius[%]>0,_max_sample_attempts>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' and 'max_sample_attempts=30'.

           normp:
               p>=0

               Compute the pointwise Lp-norm norm of vector-valued pixels in selected images.
               Default value: 'p=2'.

           norm:

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

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

               Linearly normalize values of selected images in specified range.
               (eq. to 'n').

           normalize_sum:

               Normalize selected images with a unitary sum.

           not:

               Apply boolean not operation on selected images.

           orientation:

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

           oneminus:

               For each selected image, compute one minus image.

           otsu:
               _nb_levels>0

               Hard-threshold selected images using Otsu's method.
               The computed thresholds are returned as a list of values in the status.
               Default value: 'nb_levels=256'.

           polar2complex:

               Compute polar to complex transforms of selected images.

           quantize:
               nb_levels>=1,_keep_values={ 0 | 1 },_is_uniform={ 0 | 1 }

               Quantize selected images.
               Default value: 'keep_values=1' and 'is_uniform=0'.

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

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

               Fill  selected  images  with  random values uniformly distributed in the specified
       range.

           replace:
               source,target

               Replace pixel values in selected images.

           replace_inf:
               _expression

               Replace all infinite values in selected images by specified expression.

           replace_nan:
               _expression

               Replace all NaN values in selected images by specified expression.

           replace_seq:
               "search_seq","replace_seq"

               Search and replace a sequence of values in selected images.

           replace_str:
               "search_str","replace_str"

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

           round (+):
               rounding_value>=0,_rounding_type |
               (no arg)

               Round values of selected images.
               'rounding_type' can be { -1=backward | 0=nearest | 1=forward }.
               Default value: 'rounding_type=0'.

           roundify:
               gamma>=0

               Apply roundify transformation on float-valued data, with specified gamma.
               Default value: 'gamma=0'.

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

               Set pixel value in selected images, at specified coordinates.
               (eq. to '=').
               If specified coordinates are outside the image bounds, no action is performed.
               Default values: 'x=y=z=c=0'.

           set_vector_covariance:
               coef1,coef2,...,coefN

               Apply  linear  transformation  on selected images so that the covariance matrix of
       their           vector-valued pixels
               is prescribed to given matrix. Matrix size 'N' must be equal to 'spectrum^2'.

           threshold (+):
               value[%],_is_soft={ 0 | 1 } |
               (no arg)

               Threshold values of selected images.
               'soft' can be { 0=hard-thresholding | 1=soft-thresholding }.
               (no arg) runs interactive mode (uses the instant display window [0] if opened).
               In interactive mode, the chosen threshold value is returned in the status.
               Default value: 'is_soft=0'.

           unrepeat:

               Remove repetition of adjacent values in selected images.

           vector2tensor:

               Convert selected vector fields to corresponding tensor fields.

        ** Colors Manipulation:

           adjust_colors:
               -100<=_brightness<=100,-100<=_contrast<=100,-100<=_gamma<=100,
                 -100<=_hue_shift<=100,-100<=_saturation<=100,_value_min,_value_max

               Perform a global adjustment of colors on selected images.
               Range of correct image values are considered to be in [value_min,value_max]  (e.g.
       [0,255]).
               If  'value_min==value_max==0',  value  range  is  estimated from min/max values of
       selected images.
               Processed images have pixel values constrained in [value_min,value_max].
               Default   values:   'brightness=0',   'contrast=0',   'gamma=0',    'hue_shift=0',
       'saturation=0',           'value_min=value_max=0'.

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

               Apply specified command on the chosen color channel(s) of each selected images.
               (eq. to 'ac').
               Argument  'color_channels'  refers  to a colorspace, and can be basically one of {
       all | rgba |           rgb | lrgb | ycbcr | lab | lch | hsv | hsi | hsl | cmy | cmyk | yiq
       }.
               You  can  also  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'.

           autoindex:
               nb_colors>0,0<=_dithering<=1,_method={ 0=median-cut | 1=k-means }

               Index selected vector-valued images by adapted colormaps.
               Default values: 'dithering=0' and 'method=1'.

           bayer2rgb:
               _GM_smoothness,_RB_smoothness1,_RB_smoothness2

               Transform selected RGB-Bayer sampled images to color images.
               Default values: 'GM_smoothness=RB_smoothness=1' and 'RB_smoothness2=0.5'.

           cmy2rgb:

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

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

               Estimate best-fitting colormap with 'nb_colors' entries, to index selected images.
               Set 'nb_levels==0' to extract all existing colors of an image.
               Default value: 'method=1' and 'sort_vectors=1'.

           compose_channels:

               Compose  all  channels of each selected image, using specified arithmetic operator
       (+,-,or,min,...).
               Default value: '1=+'.

           direction2rgb:

               Compute RGB representation of selected 2D direction fields.

           ditheredbw:

               Create dithered B&W version of selected images.

           fill_color:
               col1,...,colN

               Fill selected images with specified color.
               (eq. to 'fc').

           gradient2rgb:
               _is_orientation={ 0 | 1 }

               Compute RGB representation of 2D gradient of selected images.
               Default value: 'is_orientation=0'.

           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.

           hsv82rgb:

               Convert color representation of selected images from HSV8 to RGB.

           int2rgb:

               Convert color representation of selected images from INT24 to RGB.

           lab2lch:

               Convert color representation of selected images from Lab to Lch.

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

               Convert color representation of selected images from Lab to RGB.
               Default value: 'illuminant=1'.

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

               Convert color representation of selected images from Lab to sRGB.
               Default value: 'illuminant=1'.

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

               Convert color representation of selected images from Lab8 to sRGB.
               Default value: 'illuminant=1'.

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

               Convert color representation of selected images from Lab to XYZ.
               Default value: 'illuminant=1'.

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

               Convert color representation of selected images from Lab8 to RGB.
               Default value: 'illuminant=1'.

           lch2lab:

               Convert color representation of selected images from Lch to Lab.

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

               Convert color representation of selected images from Lch to RGB.
               Default value: 'illuminant=1'.

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

               Convert color representation of selected images from Lch8 to RGB.
               Default value: 'illuminant=1'.

           luminance:

               Compute luminance of selected sRGB images.

           mix_rgb:
               a11,a12,a13,a21,a22,a23,a31,a32,a33

               Apply 3x3 specified matrix to RGB colors of selected images.
               Default values: 'a11=1', 'a12=a13=a21=0', 'a22=1', 'a23=a31=a32=0' and 'a33=1'.

           pseudogray:
               _max_increment>=0,_JND_threshold>=0,_bits_depth>0

               Generate pseudogray colormap with specified increment and perceptual threshold.
               If 'JND_threshold' is 0, no perceptual constraints are applied.
               Default values: 'max_increment=5', 'JND_threshold=2.3' and 'bits_depth=8'.

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

               Replace pixels from/to specified colors in selected images.

           retinex:
               _value_offset>0,_colorspace={ hsi | hsv | lab | lrgb | rgb | ycbcr },
                 0<=_min_cut<=100,0<=_max_cut<=100,_sigma_low>0,_sigma_mid>0,_sigma_high>0

               Apply  multi-scale  retinex  algorithm  on  selected  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'.

           rgb2cmy:

               Convert color representation of selected images from RGB to CMY.

           rgb2cmyk:

               Convert color representation of selected images from RGB to CMYK.

           rgb2hcy:

               Convert color representation of selected images from RGB to HCY.

           rgb2hsi:

               Convert color representation of selected images from RGB to HSI.

           rgb2hsi8:

               Convert color representation of selected images from RGB to HSI8.

           rgb2hsl:

               Convert color representation of selected images from RGB to HSL.

           rgb2hsl8:

               Convert color representation of selected images from RGB to HSL8.

           rgb2hsv:

               Convert color representation of selected images from RGB to HSV.

           rgb2hsv8:

               Convert color representation of selected images from RGB to HSV8.

           rgb2lab:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from RGB to Lab.
               Default value: 'illuminant=1'.

           rgb2lab8:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from RGB to Lab8.
               Default value: 'illuminant=1'.

           rgb2lch:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from RGB to Lch.
               Default value: 'illuminant=1'.

           rgb2lch8:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from RGB to Lch8.
               Default value: 'illuminant=1'.

           rgb2luv:

               Convert color representation of selected images from RGB to LUV.

           rgb2int:

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

           rgb2srgb:

               Convert color representation of selected images from linear RGB to sRGB.

           rgb2xyz:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from RGB to XYZ.
               Default value: 'illuminant=1'.

           rgb2xyz8:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from RGB to XYZ8.
               Default value: 'illuminant=1'.

           rgb2yiq:

               Convert color representation of selected images from RGB to YIQ.

           rgb2yiq8:

               Convert color representation of selected images from RGB to YIQ8.

           rgb2ycbcr:

               Convert color representation of selected images from RGB to YCbCr.

           rgb2yuv:

               Convert color representation of selected images from RGB to YUV.

           rgb2yuv8:

               Convert color representation of selected images from RGB to YUV8.

           remove_opacity:

               Remove opacity channel of selected images.

           select_color:
               tolerance[%]>=0,col1,...,colN

               Select pixels with specified color in selected images.

           sepia:

               Apply sepia tones effect on selected images.

           solarize:

               Solarize selected images.

           split_colors:
               _tolerance>=0,_max_nb_outputs>0,_min_area>0

               Split selected images as several image containing a single color.
               One selected image can be split as at most 'max_nb_outputs' images.
               Output images are sorted by decreasing area of extracted color regions and have an
       additional           alpha-channel.
               Default values: 'tolerance=0', 'max_nb_outputs=256' and 'min_area=8'.

           split_opacity:

               Split color and opacity parts of selected images.

           srgb2lab:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from sRGB to Lab.
               Default value: 'illuminant=1'.

           srgb2lab8:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from sRGB to Lab8.
               Default value: 'illuminant=1'.

           srgb2rgb:

               Convert color representation of selected images from sRGB to linear RGB.

           to_a:

               Force selected images to have an alpha channel.

           to_color:

               Force selected images to be in color mode (RGB or RGBA).

           to_colormode:
               mode={ 0=adaptive | 1=G | 2=GA | 3=RGB | 4=RGBA }

               Force selected images to be in a given color mode.
               Default value: 'mode=0'.

           to_gray:

               Force selected images to be in GRAY mode.

           to_graya:

               Force selected images to be in GRAYA mode.

           to_pseudogray:
               _max_step>=0,_is_perceptual_constraint={ 0 | 1 },_bits_depth>0

               Convert selected scalar images ([0-255]-valued) to pseudo-gray color images.
               Default values: 'max_step=5', 'is_perceptual_constraint=1' and 'bits_depth=8'.
               The   original   pseudo-gray   technique  has  been  introduced  by  Rich  Franzen
       [http://r0k.us/graphics/          pseudoGrey.html].
               Extension of this technique to arbitrary increments for more tones, has been  done
       by David           Tschumperle.

           to_rgb:

               Force selected images to be in RGB mode.

           to_rgba:

               Force selected images to be in RGBA mode.

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

           transfer_rgb:
               [target],_gamma>=0,_regularization>=0,_luminosity_constraints>=0,
                 _rgb_resolution>=0,_is_constraints={ 0 | 1 }

               Transfer  colors from selected source images to selected reference image (given as
       argument).
               'gamma' determines the importance of color 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'.

           xyz2lab:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from XYZ to Lab.
               Default value: 'illuminant=1'.

           xyz2rgb:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from XYZ to RGB.
               Default value: 'illuminant=1'.

           xyz82rgb:
               illuminant={ 0=D50 | 1=D65 } |
               (no arg)

               Convert color representation of selected images from XYZ8 to RGB.
               Default value: 'illuminant=1'.

           ycbcr2rgb:

               Convert color representation of selected images from YCbCr to RGB.

           yiq2rgb:

               Convert color representation of selected images from YIQ to RGB.

           yiq82rgb:

               Convert color representation of selected images from YIQ8 to RGB.

           yuv2rgb:

               Convert color representation of selected images from YUV to RGB.

           yuv82rgb:

               Convert selected images from YUV8 to RGB color bases.

        ** Geometry Manipulation:

           append (+):
               [image],axis,_centering |
               axis,_centering

               Append  specified image to selected images, or all selected images together, along
       specified axis.
               (eq. to 'a').
               'axis' can be { x | y | z | c }.
               Usual 'centering' values are { 0=left-justified | 0.5=centered | 1=right-justified
       }.
               Default value: 'centering=0'.

           append_tiles:
               _M>=0,_N>=0,0<=_centering_x<=1,0<=_centering_y<=1

               Append MxN selected tiles as new images.
               If 'N' is set to 0, number of rows is estimated automatically.
               If 'M' is set to 0, number of columns is estimated automatically.
               If 'M' and 'N' are both set to '0', auto-mode is used.
               If 'M' or 'N' is set to 0, only a single image is produced.
               'centering_x'  and 'centering_y' tells about the centering of tiles when they have
       different sizes.
               Default values: 'M=0', 'N=0', 'centering_x=centering_y=0.5'.

           apply_scales:
               "command",number_of_scales>0,_min_scale[%]>=0,_max_scale[%]>=0,_scale_gamma>0,
                 _interpolation

               Apply specified command on different scales of selected images.
               'interpolation' can be { 0=none | 1=nearest | 2=average  |  3=linear  |  4=grid  |
       5=bicubic |           6=lanczos }.
               Default value: 'min_scale=25%', 'max_scale=100%' and 'interpolation=3'.

           autocrop (+):
               value1,value2,... |
               (no arg)

               Autocrop selected images by specified vector-valued intensity.
               If no arguments are provided, cropping value is guessed.

           autocrop_components:
               _threshold[%],_min_area[%]>=0,_is_high_connectivity={ 0 | 1 },_output_type={
                 0=crop | 1=segmentation | 2=coordinates }

               Autocrop  and extract connected components in selected images, according to a mask
       given as the           last channel of
               each of the selected image (e.g. alpha-channel).
               Default  values:  'threshold=0%',  'min_area=0.1%',  'is_high_connectivity=0'  and
       'output_type=1'.

           autocrop_seq:
               value1,value2,... | auto

               Autocrop  selected  images  using  the  crop geometry of the last one by specified
       vector-valued           intensity,
               or by automatic guessing the cropping value.
               Default value: auto mode.

           channels (+):
               { [image0] | c0[%] },_{ [image1] | c1[%] }

               Keep only specified channels of selected images.
               Dirichlet boundary is used when specified channels are out of range.

           columns (+):
               { [image0] | x0[%] },_{ [image1] | x1[%] }

               Keep only specified columns of selected images.
               Dirichlet boundary is used when specified columns are out of range.

           crop (+):
               x0[%],x1[%],_boundary_conditions |
               x0[%],y0[%],x1[%],y1[%],_boundary_conditions |
               x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],_boundary_conditions |
               x0[%],y0[%],z0[%],c0[%],x1[%],y1[%],z1[%],c1[%],_boundary_conditions |
               (no arg)

               Crop selected images with specified region coordinates.
               (eq. to 'z').
               'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
               (no arg) runs interactive mode (uses the instant display window [0] if opened).
               In interactive mode, the chosen crop coordinates are returned in the status.
               Default value: 'boundary_conditions=0'.

           diagonal:

               Transform selected vectors as diagonal matrices.

           elevate:
               _depth,_is_plain={ 0 | 1 },_is_colored={ 0 | 1 }

               Elevate selected 2D images into 3D volumes.
               Default values: 'depth=64', 'is_plain=1' and 'is_colored=1'.

           expand_x:
               size_x>=0,_boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic |
                 3=mirror }

               Expand selected images along the x-axis.
               Default value: 'boundary_conditions=1'.

           expand_xy:
               size>=0,_boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

               Expand selected images along the xy-axes.
               Default value: 'boundary_conditions=1'.

           expand_xyz:
               size>=0,_boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

               Expand selected images along the xyz-axes.
               Default value: 'boundary_conditions=1'.

           expand_y:
               size_y>=0,_boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic |
                 3=mirror }

               Expand selected images along the y-axis.
               Default value: 'boundary_conditions=1'.

           expand_z:
               size_z>=0,_boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic |
                 3=mirror }

               Expand selected images along the z-axis.
               Default value: 'boundary_conditions=1'.

           extract_region:
               [label_image],_extract_xyz_coordinates={ 0 | 1 },_label_1,...,_label_M

               Extract all pixels of selected images whose corresponding label in '[label_image]'
       is equal to           'label_m',
               and output them as M column images.
               Default value: 'extract_xyz_coordinates=0'.

           montage:
               "_layout_code",_montage_mode={ 0<=centering<=1 | 2<=scale+2<=3 },_output_mode={
                 0=single layer | 1=multiple layers },"_processing_command"

               Create  a single image montage from selected images, according to specified layout
       code :
               - 'X' to assemble all images using an automatically estimated layout.
               - 'H' to assemble all images horizontally.
               - 'V' to assemble all images vertically.
               - 'A' to assemble all images as an horizontal array.
               - 'B' to assemble all images as a vertical array.
               - 'Ha:b' to assemble two blocks 'a' and 'b' horizontally.
               - 'Va:b' to assemble two blocks 'a' and 'b' vertically.
               - 'Ra' to rotate a block 'a' by 90 deg. ('RRa' for 180 deg.  and  'RRRa'  for  270
       deg.).
               - 'Ma' to mirror a block 'a' along the X-axis ('MRRa' for the Y-axis).
               A  block  'a'  can  be  an  image indice (treated periodically) or a nested layout
       expression 'Hb:c',          'Vb:c','Rb' or 'Mb' itself.
               For example, layout code 'H0:V1:2' creates an image where  image  [0]  is  on  the
       left, and images           [1] and [2] vertically packed on the right.
               Default    values:    'layout_code=X',   'montage_mode=2',   output_mode='0'   and
       'processing_command=""'.

           mirror (+):
               { x | y | z }...{ x | y | z }

               Mirror selected images along specified axes.

           permute (+):
               permutation_string

               Permute selected image axes by specified permutation.
               'permutation' is a combination of the character set {x|y|z|c},
               e.g. 'xycz', 'cxyz', ...

           resize (+):
               [image],_interpolation,_boundary_conditions,_ax,_ay,_az,_ac |
               {[image_w] | width>0[%]},_{[image_h] | height>0[%]},_{[image_d] | depth>0[%]},
                 _{[image_s] | spectrum>0[%]},_interpolation,_boundary_conditions,_ax,_ay,_az,_ac
       |
               (no arg)

               Resize selected images with specified geometry.
               (eq. to 'r').
               'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest | 2=average
       | 3=linear |           4=grid | 5=bicubic | 6=lanczos }.
               'boundary_conditions'  has   different   meanings,   according   to   the   chosen
       'interpolation' mode :
               . When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions' is meaningless.
               .  When 'interpolation==0', 'boundary_conditions' can be { 0=dirichlet | 1=neumann
       | 2=periodic |           3=mirror }.
               . When 'interpolation=={ 3 | 5 | 6 }', 'boundary_conditions' can  be  {  0=none  |
       1=neumann }.
               'ax,ay,az,ac' set the centering along each axis when 'interpolation=0 or 4'
               (set to '0' by default, must be defined in range [0,1]).
               (no arg) runs interactive mode (uses the instant display window [0] if opened).
               Default values: 'interpolation=1', 'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           resize_mn:
               width[%]>=0,_height[%]>=0,_depth[%]>=0,_B_value,_C_value

               Resize selected images with Mitchell-Netravali filter (cubic).
               For   details   about  the  method,  see:  https://de.wikipedia.org/wiki/Mitchell-
       Netravali-Filter
               Default values: 'height=100%', 'depth=100%', 'B=0.3333' and 'C=0.3333'.

           resize_pow2:
               _interpolation,_boundary_conditions,_ax,_ay,_az,_ac

               Resize selected images so that each dimension is a power of 2.
               'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest | 2=average
       | 3=linear |           4=grid | 5=bicubic | 6=lanczos }.
               'boundary_conditions'   has   different   meanings,   according   to   the  chosen
       'interpolation' mode :
               . When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions' is meaningless.
               . When 'interpolation==0', 'boundary_conditions' can be { 0=dirichlet |  1=neumann
       | 2=periodic |           3=mirror }.
               .  When  'interpolation=={  3  | 5 | 6 }', 'boundary_conditions' can be { 0=none |
       1=neumann }.
               'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
               (set to '0' by default, must be defined in range [0,1]).
               Default values: 'interpolation=0', 'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           resize_ratio2d:
               width>0,height>0,_mode={ 0=inside | 1=outside | 2=padded },0=<_interpolation<=6

               Resize selected images while preserving their aspect ratio.
               (eq. to 'rr2d').
               Default values: 'mode=0' and 'interpolation=6'.

           resize2dx:
               width[%]>0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac

               Resize selected images along the x-axis, preserving 2D ratio.
               (eq. to 'r2dx').
               'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest | 2=average
       | 3=linear |           4=grid | 5=bicubic | 6=lanczos }.
               'boundary_conditions'   has   different   meanings,   according   to   the  chosen
       'interpolation' mode :
               . When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions' is meaningless.
               . When 'interpolation==0', 'boundary_conditions' can be { 0=dirichlet |  1=neumann
       | 2=periodic |           3=mirror }.
               .  When  'interpolation=={  3  | 5 | 6 }', 'boundary_conditions' can be { 0=none |
       1=neumann }.
               'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
               (set to '0' by default, must be defined in range [0,1]).
               Default values: 'interpolation=3', 'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           resize2dy:
               height[%]>=0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac

               Resize selected images along the y-axis, preserving 2D ratio.
               (eq. to 'r2dy').
               'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest | 2=average
       | 3=linear |           4=grid | 5=bicubic | 6=lanczos }.
               'boundary_conditions'   has   different   meanings,   according   to   the  chosen
       'interpolation' mode :
               . When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions' is meaningless.
               . When 'interpolation==0', 'boundary_conditions' can be { 0=dirichlet |  1=neumann
       | 2=periodic |           3=mirror }.
               .  When  'interpolation=={  3  | 5 | 6 }', 'boundary_conditions' can be { 0=none |
       1=neumann }.
               'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
               (set to '0' by default, must be defined in range [0,1]).
               Default values: 'interpolation=3', 'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           resize3dx:
               width[%]>0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac

               Resize selected images along the x-axis, preserving 3D ratio.
               (eq. to 'r3dx').
               'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest | 2=average
       | 3=linear |           4=grid | 5=bicubic | 6=lanczos }.
               'boundary_conditions'   has   different   meanings,   according   to   the  chosen
       'interpolation' mode :
               . When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions' is meaningless.
               . When 'interpolation==0', 'boundary_conditions' can be { 0=dirichlet |  1=neumann
       | 2=periodic |           3=mirror }.
               .  When  'interpolation=={  3  | 5 | 6 }', 'boundary_conditions' can be { 0=none |
       1=neumann }.
               'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
               (set to '0' by default, must be defined in range [0,1]).
               Default values: 'interpolation=3', 'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           resize3dy:
               height[%]>0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac

               Resize selected images along the y-axis, preserving 3D ratio.
               (eq. to 'r3dy').
               'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest | 2=average
       | 3=linear |           4=grid | 5=bicubic | 6=lanczos }.
               'boundary_conditions'   has   different   meanings,   according   to   the  chosen
       'interpolation' mode :
               . When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions' is meaningless.
               . When 'interpolation==0', 'boundary_conditions' can be { 0=dirichlet |  1=neumann
       | 2=periodic |           3=mirror }.
               .  When  'interpolation=={  3  | 5 | 6 }', 'boundary_conditions' can be { 0=none |
       1=neumann }.
               'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
               (set to '0' by default, must be defined in range [0,1]).
               Default values: 'interpolation=3', 'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           resize3dz:
               depth[%]>0,_interpolation,_boundary_conditions,_ax,_ay,_az,_ac

               Resize selected images along the z-axis, preserving 3D ratio.
               (eq. to 'r3dz').
               'interpolation' can be { -1=none (memory content) | 0=none | 1=nearest | 2=average
       | 3=linear |           4=grid | 5=bicubic | 6=lanczos }.
               'boundary_conditions'   has   different   meanings,   according   to   the  chosen
       'interpolation' mode :
               . When 'interpolation=={ -1 | 1 | 2 | 4 }', 'boundary_conditions' is meaningless.
               . When 'interpolation==0', 'boundary_conditions' can be { 0=dirichlet |  1=neumann
       | 2=periodic |           3=mirror }.
               .  When  'interpolation=={  3  | 5 | 6 }', 'boundary_conditions' can be { 0=none |
       1=neumann }.
               'ax,ay,az,ac' set the centering along each axis when 'interpolation=0'
               (set to '0' by default, must be defined in range [0,1]).
               Default values: 'interpolation=3', 'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           rotate (+):
               angle,_interpolation,_boundary_conditions,_center_x[%],_center_y[%] |
               u,v,w,angle,interpolation,boundary_conditions,_center_x[%],_center_y[%],
                 _center_z[%]

               Rotate selected images with specified angle (in  deg.),  and  optionally  3D  axis
       (u,v,w).
               'interpolation' can be { 0=none | 1=linear | 2=bicubic }.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
               When  a  rotation  center  (cx,cy,_cz)  is  specified,  the  size  of the image is
       preserved.
               Default      values:      'interpolation=1',      'boundary_conditions=0'      and
       'center_x=center_y=(undefined)'.

           rotate_tileable:
               angle,_max_size_factor>=0

               Rotate selected images by specified angle and make them tileable.
               If resulting size of an image is too big, the image is replaced by a 1x1 image.
               Default values: 'max_size_factor=8'.

           rows (+):
               { [image0] | y0[%] },_{ [image1] | y1[%] }

               Keep only specified rows of selected images.
               Dirichlet boundary conditions are used when specified rows are out of range.

           scale2x:

               Resize selected images using the Scale2x algorithm.

           scale3x:

               Resize selected images using the Scale3x algorithm.

           scale_dcci2x:
               _edge_threshold>=0,_exponent>0,_extend_1px={ 0=false | 1=true }

               Double image size using directional cubic convolution interpolation,
               as                                   described                                  in
       https://en.wikipedia.org/wiki/Directional_Cubic_Convolution_Interpolation.
               Default values: 'edge_threshold=1.15', 'exponent=5' and 'extend_1px=0'.

           seamcarve:
               _width[%]>=0,_height[%]>=0,_is_priority_channel={ 0 | 1 },_is_antialiasing={ 0 |
                  1 },_maximum_seams[%]>=0

               Resize  selected  images  with  specified  2D  geometry,  using  the  seam-carving
       algorithm.
               Default  values:  'height=100%',  'is_priority_channel=0', 'is_antialiasing=1' and
       'maximum_seams=25%'.

           shift (+):
               vx[%],_vy[%],_vz[%],_vc[%],_boundary_conditions,_interpolation={
                 0=nearest_neighbor | 1=linear }

               Shift selected images by specified displacement vector.
               Displacement vector can be non-integer in which case linear interpolation  of  the
       shift is computed.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
               Default value: 'boundary_conditions=0' and 'interpolation=0'.

           shrink_x:
               size_x>=0

               Shrink selected images along the x-axis.

           shrink_xy:
               size>=0

               Shrink selected images along the xy-axes.

           shrink_xyz:
               size>=0

               Shrink selected images along the xyz-axes.

           shrink_y:
               size_y>=0

               Shrink selected images along the y-axis.

           shrink_z:
               size_z>=0

               Shrink selected images along the z-axis.

           slices (+):
               { [image0] | z0[%] },_{ [image1] | z1[%] }

               Keep only specified slices of selected images.
               Dirichlet boundary conditions are used when specified slices are out of range.

           sort (+):
               _ordering={ + | - },_axis={ x | y | z | c }

               Sort pixel values of selected images.
               If  'axis'  is  specified,  the sorting is done according to the data of the first
       column/row/slice/channel
               of selected images.
               Default values: 'ordering=+' and 'axis=(undefined)'.

           split (+):
               { x | y | z | c }...{ x | y | z | c },_split_mode |
               keep_splitting_values={ + | - },_{ x | y | z | c }...{ x | y | z | c },value1,
                 _value2,... |
               (no arg)

               Split selected images along specified axes, or regarding to a sequence  of  scalar
       values           (optionally along specified axes too).
               (eq. to 's').
               'split_mode' can be { 0=split according to constant values | >0=split in N parts |
       <0=split in           parts of size -N }.
               Default value: 'split_mode=-1'.

           split_tiles:
               M!=0,_N!=0,_is_homogeneous={ 0 | 1 }

               Split selected images as a MxN array of tiles.
               If M or N is negative, it stands for the tile size instead.
               Default values: 'N=M' and 'is_homogeneous=0'.

           undistort:
               -1<=_amplitude<=1,_aspect_ratio,_zoom,_center_x[%],_center_y[%],
                 _boundary_conditions

               Correct barrel/pincushion distortions occurring with wide-angle lens.
               References:
               [1] Zhang Z. (1999). Flexible camera calibration by viewing a plane  from  unknown
       orientation.
               [2]  Andrew  W. Fitzgibbon (2001). Simultaneous linear estimation of multiple view
       geometry and           lens distortion.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
               Default      values:      'amplitude=0.25',      'aspect_ratio=0',       'zoom=0',
       'center_x=center_y=50%'  and           'boundary_conditions=0'.

           unroll (+):
               _axis={ x | y | z | c }

               Unroll selected images along specified axis.
               (eq. to 'y').
               Default value: 'axis=y'.

           upscale_smart:
               width[%],_height[%],_depth,_smoothness>=0,_anisotropy=[0,1],sharpening>=0

               Upscale selected images with an edge-preserving algorithm.
               Default  values: 'height=100%', 'depth=100%', 'smoothness=2', 'anisotropy=0.4' and
       'sharpening=10'.

           warp (+):
               [warping_field],_mode,_interpolation,_boundary_conditions,_nb_frames>0

               Warp selected images with specified displacement field.
               'mode' can be { 0=backward-absolute | 1=backward-relative |  2=forward-absolute  |
       3=forward-relative }.
               'interpolation' can be { 0=nearest-neighbor | 1=linear | 2=cubic }.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
               Default   values:   'mode=0',   'interpolation=1',   'boundary_conditions=1'   and
       'nb_frames=1'.

           warp_patch:
               [warping_field],patch_width>=1,_patch_height>=1,_patch_depth>=1,_std_factor>0,
                 _boundary_conditions.

               Patch-warp selected images,  with  specified  2D  or  3D  displacement  field  (in
       backward-absolute mode).
               Argument  'std_factor' sets the std of the gaussian weights for the patch overlap,
       equal to 'std           = std_factor*patch_size'.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.
               Default values: 'std_factor=0.3' and 'boundary_conditions=3'.

        ** Filtering:

           bandpass:
               _min_freq[%],_max_freq[%]

               Apply bandpass filter to selected images.
               Default values: 'min_freq=0' and 'max_freq=20%'.

           bilateral (+):
               [guide],std_deviation_s[%]>=0,std_deviation_r[%]>=0,_sampling_s>=0,
                 _sampling_r>=0 |
               std_deviation_s[%]>=0,std_deviation_r[%]>=0,_sampling_s>=0,_sampling_r>=0

               Blur selected images by anisotropic (eventually joint/cross) bilateral filtering.
               If a guide image is provided, it is used for drive the smoothing filter.
               A guide image must be of the same xyz-size as the selected images.
               Set 'sampling' arguments to '0' for automatic adjustment.

           blur (+):
               std_deviation>=0[%],_boundary_conditions,_kernel |
               axes,std_deviation>=0[%],_boundary_conditions,_kernel

               Blur  selected  images  by  a  quasi-gaussian  or   gaussian   filter   (recursive
       implementation).
               (eq. to 'b').
               'boundary_conditions'  can  be  {  0=dirichlet | 1=neumann } and 'kernel' can be {
       0=quasi-gaussian           (faster) | 1=gaussian }.
               When specified, argument 'axes' is a sequence of { x | y | z | c }.
               Specifying one axis multiple times apply also the blur multiple times.
               Default values: 'boundary_conditions=1' and 'kernel=0'.

           blur_angular:
               amplitude[%],_center_x[%],_center_y[%]

               Apply angular blur on selected images.
               Default values: 'center_x=center_y=50%'.

           blur_bloom:
               _amplitude>=0,_ratio>=0,_nb_iter>=0,_blend_operator={ + | max | min },_kernel={
                 0=quasi-gaussian (faster) | 1=gaussian | 2=box | 3=triangle | 4=quadratic },
                 _normalize_scales={ 0 | 1 },_axes

               Apply a bloom filter that blend multiple blur filters of different radii,
               resulting in a larger but sharper glare than a simple blur.
               When specified, argument 'axes' is a sequence of { x | y | z | c }.
               Specifying one axis multiple times apply also the blur multiple times.
               Reference:  Masaki  Kawase,  "Practical  Implementation  of  High  Dynamic   Range
       Rendering", GDC 2004.
               Default   values:   'amplitude=1',   'ratio=2',  'nb_iter=5',  'blend_operator=+',
       'kernel=0',          'normalize_scales=0' and 'axes=(all)'

           blur_linear:
               amplitude1[%],_amplitude2[%],_angle,_boundary_conditions={ 0=dirichlet |
                 1=neumann }

               Apply linear blur on selected images, with specified angle and amplitudes.
               Default values: 'amplitude2=0', 'angle=0' and 'boundary_conditions=1'.

           blur_radial:
               amplitude[%],_center_x[%],_center_y[%]

               Apply radial blur on selected images.
               Default values: 'center_x=center_y=50%'.

           blur_selective:
               sigma>=0,_edges>0,_nb_scales>0

               Blur selected images using selective gaussian scales.
               Default values: 'sigma=5', 'edges=0.5' and 'nb_scales=5'.

           blur_x:
               amplitude[%]>=0,_boundary_conditions={ 0=dirichlet | 1=neumann }

               Blur selected images along the x-axis.
               Default value: 'boundary_conditions=1'.

           blur_xy:
               amplitude_x[%],amplitude_y[%],_boundary_conditions={ 0=dirichlet | 1=neumann }

               Blur selected images along the X and Y axes.
               Default value: 'boundary_conditions=1'.

           blur_xyz:
               amplitude_x[%],amplitude_y[%],amplitude_z,_boundary_conditions={ 0=dirichlet |
                 1=neumann }

               Blur selected images along the X, Y and Z axes.
               Default value: 'boundary_conditions=1'.

           blur_y:
               amplitude[%]>=0,_boundary_conditions={ 0=dirichlet | 1=neumann }

               Blur selected images along the y-axis.
               Default value: 'boundary_conditions=1'.

           blur_z:
               amplitude[%]>=0,_boundary_conditions={ 0=dirichlet | 1=neumann }

               Blur selected images along the z-axis.
               Default value: 'boundary_conditions=1'.

           boxfilter (+):
               size>=0[%],_order,_boundary_conditions,_nb_iter>=0 |
               axes,size>=0[%],_order,_boundary_conditions,_nb_iter>=0

               Blur  selected  images  by  a  box  filter  of  specified  size  (fast   recursive
       implementation).
               'order' can be { 0=smooth | 1=1st-derivative | 2=2nd-derivative }.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               When specified, argument 'axes' is a sequence of { x | y | z | c }.
               Specifying one axis multiple times apply also the blur multiple times.
               Default values: 'order=0', 'boundary_conditions=1' and 'nb_iter=1'.

           bump2normal:

               Convert selected bumpmaps to normalmaps.

           compose_freq:

               Compose selected low and high frequency parts into new images.

           convolve (+):
               [mask],_boundary_conditions,_is_normalized={ 0 | 1 }

               Convolve selected images by specified mask.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               Default values: 'boundary_conditions=1' and 'is_normalized=0'.

           convolve_fft:
               [mask]

               Convolve selected images with specified mask, in the fourier domain.

           correlate (+):
               [mask],_boundary_conditions,_is_normalized={ 0 | 1 }

               Correlate selected images by specified mask.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               Default values: 'boundary_conditions=1' and 'is_normalized=0'.

           cross_correlation:
               [mask]

               Compute cross-correlation of selected images with specified mask.

           curvature:

               Compute isophote curvatures on selected images.

           dct:
               _{ x | y | z }...{ x | y | z } |
               (no arg)

               Compute the discrete cosine transform of selected images,
               optionally along the specified axes only.
               Default values: (no arg)

           deblur:
               amplitude[%]>=0,_nb_iter>=0,_dt>=0,_regul>=0,_regul_type={ 0=Tikhonov |
                 1=meancurv. | 2=TV }

               Deblur image using a regularized Jansson-Van Cittert algorithm.
               Default values: 'nb_iter=10', 'dt=20', 'regul=0.7' and 'regul_type=1'.

           deblur_goldmeinel:
               sigma>=0, _nb_iter>=0, _acceleration>=0, _kernel_type={ 0=quasi-gaussian
                 (faster) | 1=gaussian }.

               Deblur selected images using Gold-Meinel algorithm
               Default values: 'nb_iter=8', 'acceleration=1' and 'kernel_type=1'.

           deblur_richardsonlucy:
               sigma>=0, nb_iter>=0, _kernel_type={ 0=quasi-gaussian (faster) | 1=gaussian }.

               Deblur selected images using Richardson-Lucy algorithm.
               Default values: 'nb_iter=50' and 'kernel_type=1'.

           deconvolve_fft:
               [kernel],_regularization>=0

               Deconvolve selected images by specified mask in the fourier space.
               Default value: 'regularization>=0'.

           deinterlace:
               _method={ 0 | 1 }

               Deinterlace  selected images ('method' can be { 0=standard or 1=motion-compensated
       }).
               Default value: 'method=0'.

           denoise (+):
               std_deviation_s>=0,_std_deviation_p>=0,_patch_size>0,_lookup_size>0,_smoothness,
                 _fast_approx={ 0 | 1 }

               Denoise selected images by non-local patch averaging.
               Default  values:   'std_deviation_p=10',   'patch_size=5',   'lookup_size=6'   and
       'smoothness=1'.

           denoise_haar:
               _threshold>=0,_nb_scales>=0,_cycle_spinning>0

               Denoise selected images using haar-wavelet thresholding with cycle spinning.
               Set 'nb_scales==0' to automatically determine the optimal number of scales.
               Default values: 'threshold=1.4', 'nb_scale=0' and 'cycle_spinning=10'.

           denoise_patchpca:
               _strength>=0,_patch_size>0,_lookup_size>0,_spatial_sampling>0

               Denoise selected images using the patch-pca algorithm.
               Default    values:    'patch_size=7',    'lookup_size=11',    'details=1.8'    and
       'spatial_sampling=5'.

           deriche (+):
               std_deviation>=0[%],order={ 0 | 1 | 2 },axis={ x | y | z | c },
                 _boundary_conditions

               Apply Deriche recursive filter on selected images, along specified axis and with
               specified standard deviation, order and boundary conditions.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               Default value: 'boundary_conditions=1'.

           dilate (+):
               size>=0 |
               size_x>=0,size_y>=0,size_z>=0 |
               [kernel],_boundary_conditions,_is_real={ 0=binary-mode | 1=real-mode }

               Dilate selected images by a rectangular or the specified structuring element.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               Default values: 'size_z=1', 'boundary_conditions=1' and 'is_real=0'.

           dilate_circ:
               _size>=0,_boundary_conditions,_is_normalized={ 0 | 1 }

               Apply circular dilation of selected images by specified size.
               Default values: 'boundary_conditions=1' and 'is_normalized=0'.

           dilate_oct:
               _size>=0,_boundary_conditions,_is_normalized={ 0 | 1 }

               Apply octagonal dilation of selected images by specified size.
               Default values: 'boundary_conditions=1' and 'is_normalized=0'.

           dilate_threshold:
               size_x>=1,size_y>=1,size_z>=1,_threshold>=0,_boundary_conditions

               Dilate selected images in the (X,Y,Z,I) space.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               Default    values:    'size_y=size_x',     'size_z=1',     'threshold=255'     and
       'boundary_conditions=1'.

           divergence:

               Compute divergence of selected vector fields.

           dog:
               _sigma1>=0[%],_sigma2>=0[%]

               Compute difference of gaussian on selected images.
               Default values: 'sigma1=2%' and 'sigma2=3%'.

           diffusiontensors:
               _sharpness>=0,0<=_anisotropy<=1,_alpha[%],_sigma[%],is_sqrt={ 0 | 1 }

               Compute  the  diffusion  tensors  of selected images for edge-preserving smoothing
       algorithms.
               Default values: 'sharpness=0.7', 'anisotropy=0.3',  'alpha=0.6',  'sigma=1.1'  and
       'is_sqrt=0'.

           edges:
               _threshold[%]>=0

               Estimate contours of selected images.
               Default value: 'edges=15%'

           erode (+):
               size>=0 |
               size_x>=0,size_y>=0,_size_z>=0 |
               [kernel],_boundary_conditions,_is_real={ 0=binary-mode | 1=real-mode }

               Erode selected images by a rectangular or the specified structuring element.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               Default values: 'size_z=1', 'boundary_conditions=1' and 'is_real=0'.

           erode_circ:
               _size>=0,_boundary_conditions,_is_normalized={ 0 | 1 }

               Apply circular erosion of selected images by specified size.
               Default values: 'boundary_conditions=1' and 'is_normalized=0'.

           erode_oct:
               _size>=0,_boundary_conditions,_is_normalized={ 0 | 1 }

               Apply octagonal erosion of selected images by specified size.
               Default values: 'boundary_conditions=1' and 'is_normalized=0'.

           erode_threshold:
               size_x>=1,size_y>=1,size_z>=1,_threshold>=0,_boundary_conditions

               Erode selected images in the (X,Y,Z,I) space.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               Default     values:     'size_y=size_x',     'size_z=1',    'threshold=255'    and
       'boundary_conditions=1'.

           fft (+):
               _{ x | y | z }...{ x | y | z }

               Compute the direct fourier  transform  (real  and  imaginary  parts)  of  selected
       images,
               optionally along the specified axes only.

           gradient (+):
               { x | y | z }...{ x | y | z },_scheme |
               (no arg)

               Compute the gradient components (first derivatives) of selected images.
               (eq. to 'g').
               'scheme'  can  be  {  -1=backward | 0=centered | 1=forward | 2=sobel | 3=rotation-
       invariant           (default) | 4=deriche | 5=vanvliet }.
               (no arg) compute all significant 2D/3D components.
               Default value: 'scheme=3'.

           gradient_norm:

               Compute gradient norm of selected images.

           gradient_orientation:
               _dimension={1,2,3}

               Compute N-d gradient orientation of selected images.
               Default value: 'dimension=3'.

           guided (+):
               [guide],radius[%]>=0,regularization[%]>=0 |
               radius[%]>=0,regularization[%]>=0

               Blur selected images by guided image filtering.
               If a guide image is provided, it is used to drive the smoothing process.
               A guide image must be of the same xyz-size as the selected images.
               This command implements the filtering algorithm described in:
               He, Kaiming; Sun, Jian; Tang, Xiaoou, "Guided Image Filtering,"  Pattern  Analysis
       and Machine           Intelligence,
               IEEE Transactions on , vol.35, no.6, pp.1397,1409, June 2013

           haar:
               scale>0

               Compute the direct haar multiscale wavelet transform of selected images.

           heat_flow:
               _nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }

               Apply iterations of the heat flow on selected images.
               Default values: 'nb_iter=10', 'dt=30' and 'keep_sequence=0'.

           hessian (+):
               { xx | xy | xz | yy | yz | zz }...{ xx | xy | xz | yy | yz | zz } |
               (no arg)

               Compute the hessian components (second derivatives) of selected images.
               (no arg) compute all significant components.

           idct:
               _{ x | y | z }...{ x | y | z } |
               (no arg)

               Compute the inverse discrete cosine transform of selected images,
               optionally along the specified axes only.
               Default values: (no arg)

           iee:

               Compute gradient-orthogonal-directed 2nd derivative of image(s).

           ifft (+):
               _{ x | y | z }...{ x | y | z }

               Compute  the  inverse  fourier  transform  (real  and imaginary parts) of selected
       images.
               optionally along the specified axes only.

           ihaar:
               scale>0

               Compute the inverse haar multiscale wavelet transform of selected images.

           ilaplacian:
               { nb_iterations>0 | 0 },_time_step>0,_[initial_estimate]

               Invert selected Laplacian images.
               If given 'nb_iterations' is '0',  inversion  is  done  in  Fourier  space  (single
       iteration),
               otherwise,  by  applying  'nb_iterations'  of a Laplacian-inversion PDE flow (with
       specified           'time_step').
               Note that the resulting inversions are just  estimation  of  possible/approximated
       solutions.
               Default           values:           'nb_iterations=0','time_step=10'           and
       '[initial_estimated]=(undefined)'.

           inn:

               Compute gradient-directed 2nd derivative of image(s).

           inpaint (+):
               [mask] |
               [mask],0,_fast_method |
               [mask],_patch_size>=1,_lookup_size>=1,_lookup_factor>=0,_lookup_increment!=0,
                 _blend_size>=0,0<=_blend_threshold<=1,_blend_decay>=0,_blend_scales>=1,
                 _is_blend_outer={ 0 | 1 }

               Inpaint selected images by specified mask.
               If no patch size (or 0) is specified, inpainting is done using a fast  average  or
       median           algorithm.
               Otherwise,  it  used  a  patch-based  reconstruction method, that can be very time
       consuming.
               'fast_method' can be { 0=low-connectivity average | 1=high-connectivity average  |
       2=low-connectivity median | 3=high-connectivity median }.
               Default     values:     'patch_size=0',     'fast_method=1',     'lookup_size=22',
       'lookup_factor=0.5',           'lookup_increment=1', 'blend_size=0',  'blend_threshold=0',
       'blend_decay=0.05',           'blend_scales=10' and 'is_blend_outer=1'.

           inpaint_diffusion:
               [mask],_nb_scales[%]>=0,_diffusion_type={ 0=isotropic | 1=delaunay-guided |
                 2=edge-guided | 3=mask-guided },_diffusion_iter>=0

               Inpaint  selected  images by specified mask using a multiscale transport-diffusion
       algorithm.
               If 'diffusion type==3', non-zero values of the mask (e.g. a distance function) are
       used to           guide the diffusion process.
               Default values: 'nb_scales=75%', 'diffusion_type=1' and 'diffusion_iter=20'.

           inpaint_flow:
               [mask],_nb_global_iter>=0,_nb_local_iter>=0,_dt>0,_alpha>=0,_sigma>=0

               Apply iteration of the inpainting flow on selected images.
               Default  values:  'nb_global_iter=4',  'nb_global_iter=15', 'dt=10', 'alpha=1' and
       'sigma=3'.

           inpaint_holes:
               maximal_area[%]>=0,_tolerance>=0,_is_high_connectivity={ 0 | 1 }

               Inpaint all connected regions having an area less than specified value.
               Default values: 'maximal_area=4', 'tolerance=0' and 'is_high_connectivity=0'.

           inpaint_morpho:
               [mask]

               Inpaint selected images by specified mask using morphological operators.

           inpaint_matchpatch:
               [mask],_nb_scales={ 0=auto | >0 },_patch_size>0,_nb_iterations_per_scale>0,
                 _blend_size>=0,_allow_outer_blending={ 0 | 1 },_is_already_initialized={ 0 | 1 }

               Inpaint selected images by specified binary mask, using a  multi-scale  matchpatch
       algorithm.
               Default   values:   'nb_scales=0',  'patch_size=9',  'nb_iterations_per_scale=10',
       'blend_size=5',           'allow_outer_blending=1' and 'is_already_initialized=0'.

           kuwahara:
               size>0

               Apply Kuwahara filter of specified size on selected images.

           laplacian:

               Compute Laplacian of selected images.

           lic:
               _amplitude>0,_channels>0

               Render LIC representation of selected vector fields.
               Default values: 'amplitude=30' and 'channels=1'.

           map_tones:
               _threshold>=0,_gamma>=0,_smoothness>=0,nb_iter>=0

               Apply tone mapping operator on selected images, based on Poisson equation.
               Default values: 'threshold=0.1', 'gamma=0.8', 'smoothness=0.5' and 'nb_iter=30'.

           map_tones_fast:
               _radius[%]>=0,_power>=0

               Apply fast tone mapping operator on selected images.
               Default values: 'radius=3%' and 'power=0.3'.

           meancurvature_flow:
               _nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }

               Apply iterations of the mean curvature flow on selected images.
               Default values: 'nb_iter=10', 'dt=30' and 'keep_sequence=0'.

           median (+):
               size>=0,_threshold>0

               Apply (opt. thresholded) median filter on selected images with structuring element
       size x size.

           nlmeans:
               [guide],_patch_radius>0,_spatial_bandwidth>0,_tonal_bandwidth>0,
                 _patch_measure_command |
               _patch_radius>0,_spatial_bandwidth>0,_tonal_bandwidth>0,_patch_measure_command

               Apply non local means denoising of Buades et al, 2005. on selected images.
               The patch is a gaussian function of 'std _patch_radius'.
               The spatial kernel is a rectangle of radius 'spatial_bandwidth'.
               The tonal kernel is exponential (exp(-d^2/_tonal_bandwidth^2))
               with d the euclidiean distance between image patches.
               Default  values: 'patch_radius=4', 'spatial_bandwidth=4', 'tonal_bandwidth=10' and
       'patch_measure_command=-norm'.

           nlmeans_core:
               _reference_image,_scaling_map,_patch_radius>0,_spatial_bandwidth>0

               Apply non local means denoising using a image for weight and a map for scaling

           normalize_local:
               _amplitude>=0,_radius>0,_n_smooth>=0[%],_a_smooth>=0[%],_is_cut={ 0 | 1 },
                 _min=0,_max=255

               Normalize selected images locally.
               Default  values:   'amplitude=3',   'radius=16',   'n_smooth=4%',   'a_smooth=2%',
       'is_cut=1', 'min=0'           and 'max=255'.

           normalized_cross_correlation:
               [mask]

               Compute normalized cross-correlation of selected images with specified mask.

           peronamalik_flow:
               K_factor>0,_nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }

               Apply iterations of the Perona-Malik flow on selected images.
               Default values: 'K_factor=20', 'nb_iter=5', 'dt=5' and 'keep_sequence=0'.

           phase_correlation:
               [destination]

               Estimate   translation   vector  between  selected  source  images  and  specified
       destination.

           pde_flow:
               _nb_iter>=0,_dt,_velocity_command,_keep_sequence={ 0 | 1 }

               Apply iterations of a generic PDE flow on selected images.
               Default   values:   'nb_iter=10',   'dt=30',   'velocity_command=laplacian'    and
       'keep_sequence=0'.

           periodize_poisson:

               Periodize selected images using a Poisson solver in Fourier space.

           red_eye:
               0<=_threshold<=100,_smoothness>=0,0<=attenuation<=1

               Attenuate red-eye effect in selected images.
               Default values: 'threshold=75', 'smoothness=3.5' and 'attenuation=0.1'.

           remove_hotpixels:
               _mask_size>0, _threshold[%]>0

               Remove hot pixels in selected images.
               Default values: 'mask_size=3' and 'threshold=10%'.

           remove_pixels:
               number_of_pixels[%]>=0

               Remove  specified  number  of pixels (i.e. set them to 0) from the set of non-zero
       pixels in           selected images.

           rolling_guidance:
               std_deviation_s[%]>=0,std_deviation_r[%]>=0,_precision>=0

               Apply the rolling guidance filter on selected image.
               Rolling guidance filter is a fast image abstraction filter, described in:
               "Rolling Guidance Filter", Qi Zhang Xiaoyong, Shen Li, Xu Jiaya Jia, ECCV'2014.
               Default values: 'std_deviation_s=4', 'std_deviation_r=10' and 'precision=0.5'.

           sharpen (+):
               amplitude>=0 |
               amplitude>=0,edge>=0,_alpha,_sigma

               Sharpen selected images by inverse diffusion or shock filters methods.
               'edge' must be specified to enable shock-filter method.
               Default values: 'alpha=0' and 'sigma=0'.

           smooth (+):
               amplitude[%]>=0,_sharpness>=0,0<=_anisotropy<=1,_alpha[%],_sigma[%],_dl>0,_da>0,
                 _precision>0,interpolation,_fast_approx={ 0 | 1 } |
               nb_iterations>=0,_sharpness>=0,_anisotropy,_alpha,_sigma,_dt>0,0 |
               [tensor_field],_amplitude>=0,_dl>0,_da>0,_precision>0,_interpolation,
                 _fast_approx={ 0 | 1 } |
               [tensor_field],_nb_iters>=0,_dt>0,0

               Smooth selected images anisotropically using diffusion PDE's, with specified field
       of
               diffusion tensors.
               'interpolation' can be { 0=nearest | 1=linear | 2=runge-kutta }.
               Default   values:  'sharpness=0.7',  'anisotropy=0.3',  'alpha=0.6',  'sigma=1.1',
       'dl=0.8', 'da=30',           'precision=2', 'interpolation=0' and 'fast_approx=1'.

           split_freq:
               smoothness>0[%]

               Split selected images into low and high frequency parts.

           solve_poisson:
               "laplacian_command",_nb_iterations>=0,_time_step>0,_nb_scales>=0

               Solve Poisson equation so that applying 'laplacian[n]' is close to the  result  of
       'laplacian_command[n]'.
               Solving is performed using a multi-scale gradient descent algorithm.
               If 'nb_scales=0', the number of scales is automatically determined.
               Default values: 'nb_iterations=60', 'dt=5' and 'nb_scales=0'.

           split_details:
               _nb_scales>0,_base_scale[%]>=0,_detail_scale[%]>=0

               Split selected images into 'nb_scales' detail scales.
               If 'base_scale'=='detail_scale'==0, the image decomposition is done with 'a trous'
       wavelets.
               Otherwise, it uses laplacian pyramids with linear standard deviations.
               Default values: 'nb_scales=4', 'base_scale=0' and 'detail_scale=0'.

           structuretensors (+):
               _scheme={ 0=centered | 1=forward/backward }

               Compute the structure tensor field of selected images.
               Default value: 'scheme=1'.

           solidify:
               _smoothness[%]>=0,_diffusion_type={ 0=isotropic | 1=delaunay-oriented |
                 2=edge-oriented },_diffusion_iter>=0

               Solidify selected transparent images.
               Default values: 'smoothness=75%', 'diffusion_type=1' and 'diffusion_iter=20'.

           syntexturize:
               _width[%]>0,_height[%]>0

               Resynthetize  'width'x'height'  versions  of  selected  micro-textures  by   phase
       randomization.
               The  texture synthesis algorithm is a straightforward implementation of the method
       described in :
               http://www.ipol.im/pub/art/2011/ggm_rpn/
               Default values: 'width=height=100%'.

           syntexturize_matchpatch:
               _width[%]>0,_height[%]>0,_nb_scales>=0,_patch_size>0,_blending_size>=0,
                 _precision>=0

               Resynthetize 'width'x'height' versions of selected micro-textures using  a  patch-
       matching           algorithm.
               If 'nbscales==0', the number of scales used is estimated from the image size.
               Default     values:     'width=height=100%',     'nb_scales=0',    'patch_size=7',
       'blending_size=5' and           'precision=1'.

           tv_flow:
               _nb_iter>=0,_dt,_keep_sequence={ 0 | 1 }

               Apply iterations of the total variation flow on selected images.
               Default values: 'nb_iter=10', 'dt=30' and 'keep_sequence=0'.

           unsharp:
               radius[%]>=0,_amount>=0,_threshold[%]>=0

               Apply unsharp mask on selected images.
               Default values: 'amount=2' and 'threshold=0'.

           unsharp_octave:
               _nb_scales>0,_radius[%]>=0,_amount>=0,threshold[%]>=0

               Apply octave sharpening on selected images.
               Default values: 'nb_scales=4', 'radius=1', 'amount=2' and 'threshold=0'.

           vanvliet (+):
               std_deviation>=0[%],order={ 0 | 1 | 2 | 3 },axis={ x | y | z | c },
                 _boundary_conditions

               Apply Vanvliet recursive filter on selected images, along specified axis and with
               specified standard deviation, order and boundary conditions.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
               Default value: 'boundary_conditions=1'.

           voronoi:

               Compute the discrete Voronoi diagram of non-zero pixels in selected images.

           watermark_fourier:
               text,_size>0

               Add a textual watermark in the frequency domain of selected images.
               Default value: 'size=33'.

           watershed (+):
               [priority_image],_is_high_connectivity={ 0 | 1 }

               Compute the watershed transform of selected images.
               Default value: 'is_high_connectivity=1'.

        ** Features Extraction:

           area:
               tolerance>=0,is_high_connectivity={ 0 | 1 }

               Compute area of connected components in selected images.
               Default values: 'is_high_connectivity=0'.

           area_fg:
               tolerance>=0,is_high_connectivity={ 0 | 1 }

               Compute area of connected components for non-zero values in selected images.
               Similar to 'area' except that 0-valued pixels are not considered.
               Default values: 'is_high_connectivity=0'.

           at_line:
               x0[%],y0[%],z0[%],x1[%],y1[%],z1[%]

               Retrieve  pixels  of  the  selected  images  belonging  to  the   specified   line
       (x0,y0,z0)-(x1,y1,z1).

           at_quadrangle:
               x0[%],y0[%],x1[%],y1[%],x2[%],y2[%],x3[%],y3[%],_interpolation,
                 _boundary_conditions |
               x0[%],y0[%],z0[%],x1[%],y1[%],z1[%],x2[%],y2[%],z2[%],x3[%],y3[%],z3[%],
                 _interpolation,_boundary_conditions

               Retrieve  pixels  of  the  selected  images  belonging  to  the specified 2D or 3D
       quadrangle.
               'interpolation' can be { 0=nearest-neighbor | 1=linear | 2=cubic }.
               'boundary_conditions' can be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }.

           barycenter:

               Compute the barycenter vector of pixel values.

           delaunay:

               Generate discrete 2D Delaunay triangulation of non-zero pixels in selected images.
               Input images must be scalar.
               Each pixel of the output image is a triplet (a,b,c) meaning the pixel belongs to
               the Delaunay triangle 'ABC'  where  'a','b','c'  are  the  labels  of  the  pixels
       'A','B','C'.

           detect_skin:
               0<=tolerance<=1,_skin_x,_skin_y,_skin_radius>=0

               Detect skin in selected color images and output an appartenance probability map.
               Detection is performed using CbCr chromaticity data of skin pixels.
               If  arguments  'skin_x',  'skin_y' and 'skin_radius' are provided, skin pixels are
       learnt
               from the sample pixels inside  the  circle  located  at  ('skin_x','skin_y')  with
       radius           'skin_radius'.
               Default value: 'tolerance=0.5' and 'skin_x=skiny=radius=-1'.

           displacement (+):
               [source_image],_smoothness,_precision>=0,_nb_scales>=0,_iteration_max>=0,
                 is_backward={ 0 | 1 },_[guide]

               Estimate displacement field between specified source and selected target images.
               If 'smoothness>=0', regularization type is set to isotropic, else to anisotropic.
               If 'nbscales==0', the number of scales used is estimated from the image size.
               Default      values:      'smoothness=0.1',      'precision=5',     'nb_scales=0',
       'iteration_max=10000',           'is_backward=1' and '[guide]=(unused)'.

           distance (+):
               isovalue[%],_metric |
               isovalue[%],[metric],_method

               Compute the unsigned distance function to specified isovalue, opt. according to  a
       custom metric.
               'metric' can be { 0=chebyshev | 1=manhattan | 2=euclidean | 3=squared-euclidean }.
               'method'  can  be  {  0=fast-marching  |  1=low-connectivity  dijkstra  |  2=high-
       connectivity dijkstra |           3=1+return path | 4=2+return path }.
               Default value: 'metric=2' and 'method=0'.

           fftpolar:

               Compute fourier transform of selected images, as centered magnitude/phase images.

           histogram (+):
               _nb_levels>0[%],_value0[%],_value1[%]

               Compute the histogram of selected images.
               If value range is set, the histogram is estimated only for pixels in the specified
               value range. Argument 'value1' must be specified if 'value0' is set.
               Default values: 'nb_levels=256', 'value0=0%' and 'value1=100%'.

           histogram_nd:
               nb_levels>0[%],_value0[%],_value1[%]

               Compute the 1D,2D or 3D histogram of selected multi-channels images (having 1,2 or
       3 channels).
               If value range is set, the histogram is estimated only for pixels in the specified
               value range.
               Default values: 'value0=0%' and 'value1=100%'.

           histogram_cumul:
               _nb_levels>0,_is_normalized={ 0 | 1 },_val0[%],_val1[%]

               Compute cumulative histogram of selected images.
               Default values: 'nb_levels=256', 'is_normalized=0', 'val0=0%' and 'val1=100%'.

           histogram_pointwise:
               nb_levels>0[%],_value0[%],_value1[%]

               Compute the histogram of each vector-valued point of selected images.
               If value range is set, the histogram is estimated only for values in the specified
               value range.
               Default values: 'value0=0%' and 'value1=100%'.

           hough:
               _width>0,_height>0,gradient_norm_voting={ 0 | 1 }

               Compute hough transform (theta,rho) of selected images.
               Default values: 'width=512', 'height=width' and 'gradient_norm_voting=1'.

           ifftpolar:

               Compute   inverse   fourier   transform   of   selected   images,   from  centered
       magnitude/phase images.

           isophotes:
               _nb_levels>0

               Render isophotes of selected images on a transparent background.
               Default value: 'nb_levels=64'

           label (+):
               _tolerance>=0,is_high_connectivity={ 0 | 1 }

               Label connected components in selected images.
               Default values: 'tolerance=0' and 'is_high_connectivity=0'.

           label_fg:
               tolerance>=0,is_high_connectivity={ 0 | 1 }

               Label connected components for non-zero values (foreground) in selected images.
               Similar to 'label' except that 0-valued pixels are not labeled.
               Default value: 'is_high_connectivity=0'.

           max_patch:
               _patch_size>=1

               Return locations of maximal values in local patch-based neighborhood of given size
       for selected images.
               Default value: 'patch_size=16'.

           min_patch:
               _patch_size>=1

               Return locations of minimal values in local patch-based neighborhood of given size
       for selected images.
               Default value: 'patch_size=16'.

           minimal_path:
               x0[%]>=0,y0[%]>=0,z0[%]>=0,x1[%]>=0,y1[%]>=0,z1[%]>=0,_is_high_connectivity={ 0  |
       1 }

               Compute minimal path between two points on selected potential maps.
               Default value: 'is_high_connectivity=0'.

           mse (+):

               Compute MSE (Mean-Squared Error) matrix between selected images.

           patches:
               patch_width>0,patch_height>0,patch_depth>0,x0,y0,z0,_x1,_y1,_z1,...,_xN,_yN,_zN

               Extract N+1 patches from selected images, centered at specified locations.

           matchpatch (+):
               [patch_image],patch_width>=1,_patch_height>=1,_patch_depth>=1,_nb_iterations>=0,
                 _nb_randoms>=0,_occ_penalization,_output_score={ 0 | 1 },_[guide]

               Estimate  correspondence  map  between  selected images and specified patch image,
       using
               a patch-matching algorithm.
               Each pixel of the returned correspondence map gives  the  location  (p,q)  of  the
       closest patch in
               the  specified  patch image. If 'output_score=1', the third channel also gives the
       corresponding
               matching score for each patch as well.
               Default values:  'patch_height=patch_width',  'patch_depth=1',  'nb_iterations=5',
       'nb_randoms=5',           'occ_penalization=0', 'output_score=0' and 'guide=(undefined)'.

           plot2value:

               Retrieve values from selected 2D graph plots.

           pointcloud:
               _type = { -X=-X-opacity | 0=binary | 1=cumulative | 2=label | 3=retrieve
                 coordinates },_width,_height>0,_depth>0

               Render a set of point coordinates, as a point cloud in a 1D/2D or 3D binary image
               (or  do  the reverse, i.e. retrieve coordinates of non-zero points from a rendered
       point cloud).
               Input point coordinates can be a NxMx1x1, Nx1x1xM or 1xNx1xM image, where  'N'  is
       the number of points,
               and M the point coordinates.
               If 'M'>3, the 3-to-M components sets the (M-3)-dimensional color at each point.
               Parameters 'width','height' and 'depth' are related to the size of the final image
       :
               - If set to 0, the size is automatically set along the specified axis.
               - If set to N>0, the size along the specified axis is N.
               - If set to N<0, the size along the specified axis is at most N.
               Points  with  coordinates   that   are   negative   or   higher   than   specified
       ('width','height','depth')
               are not plotted.
               Default values: 'type=0' and 'max_width=max_height=max_depth=0'.

           psnr:
               _max_value

               Compute PSNR (Peak Signal-to-Noise Ratio) matrix between selected images.
               Default value: 'max_value=255'.

           segment_watershed:
               _threshold>=0

               Apply watershed segmentation on selected images.
               Default values: 'threshold=2'.

           shape2bump:
               _resolution>=0,0<=_weight_avg_max_avg<=1,_dilation,_smoothness>=0

               Estimate bumpmap from binary shape in selected images.
               Default   value:   'resolution=256',   'weight_avg_max=0.75',   'dilation=0'   and
       'smoothness=100'.

           skeleton:
               _boundary_conditions={ 0=dirichlet | 1=neumann }

               Compute skeleton  of  binary  shapes  using  distance  transform  and  constrained
       thinning.
               Default value: 'boundary_conditions=1'.

           slic:
               size>0,_regularity>=0,_nb_iterations>0

               Segment  selected  2D  images  with  superpixels, using the SLIC algorithm (Simple
       Linear Iterative           Clustering).
               Scalar images of increasingly labeled pixels are returned.
               Reference paper: Achanta, R., Shaji,  A.,  Smith,  K.,  Lucchi,  A.,  Fua,  P.,  &
       Süsstrunk, S.           (2010). Slic superpixels (No. EPFL-REPORT-149300).
               Default values: 'size=16', 'regularity=10' and 'nb_iterations=10'.

           ssd_patch:
               [patch],_use_fourier={ 0 | 1 },_boundary_conditions={ 0=dirichlet | 1=neumann }

               Compute fields of SSD between selected images and specified patch.
               Argument 'boundary_conditions' is valid only when 'use_fourier=0'.
               Default value: 'use_fourier=0' and 'boundary_conditions=0'.

           thinning:
               _boundary_conditions={ 0=dirichlet | 1=neumann }

               Compute skeleton of binary shapes using morphological thinning
               (beware, this is a quite slow iterative process)
               Default value: 'boundary_conditions=1'.

           tones:
               N>0

               Get N tones masks from selected images.

           topographic_map:
               _nb_levels>0,_smoothness

               Render selected images as topographic maps.
               Default values: 'nb_levels=16' and 'smoothness=2'.

           tsp:
               _precision>=0

               Try  to  solve  the  'travelling  salesman' problem, using a combination of greedy
       search and 2-opt           algorithms.
               Selected images must have dimensions Nx1x1xC to represent N cities  each  with  C-
       dimensional           coordinates.
               This  command  re-order  the  selected  data  along  the  x-axis so that the point
       sequence becomes a           shortest path.
               Default values: 'precision=256'.

           variance_patch:
               _patch_size>=1

               Compute variance of each images patch centered at (x,y), in selected images.
               Default value: 'patch_size=16'

        ** Image Drawing:

           arrow:
               x0[%],y0[%],x1[%],y1[%],_thickness[%]>=0,_head_length[%]>=0,
                 _head_thickness[%]>=0,_opacity,_pattern,_color1,...

               Draw specified arrow on selected images.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified. If a pattern is specified, the arrow is
               drawn outlined instead of filled.
               Default   values:    'thickness=1%',    'head_length=10%',    'head_thickness=3%',
       'opacity=1',           'pattern=(undefined)' and 'color1=0'.

           axes:
               x0,x1,y0,y1,_font_height>=0,_opacity,_pattern,_color1,...

               Draw xy-axes on selected images.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified.
               To draw only one x-axis at row Y, set both 'y0' and 'y1' to Y.
               To draw only one y-axis at column X, set both 'x0' and 'x1' to X.
               Default   values:   'font_height=14',   'opacity=1',   'pattern=(undefined)'   and
       'color1=0'.

           ball:
               _size>0, _R,_G,_B,0<=_specular_light<=8,0<=_specular_size<=8,_shadow>=0

               Input a 2D RGBA colored ball sprite.
               Default  values:   'size=64',   'R=255',   'G=R',   'B=R',   'specular_light=0.8',
       'specular_size=1' and           'shading=1.5'.

           chessboard:
               size1>0,_size2>0,_offset1,_offset2,_angle,_opacity,_color1,...,_color2,...

               Draw chessboard on selected images.
               Default   values:   'size2=size1',  'offset1=offset2=0',  'angle=0',  'opacity=1',
       'color1=0' and           'color2=255'.

           cie1931:

               Draw CIE-1931 chromaticity diagram on selected images.

           circle:
               x[%],y[%],R[%],_opacity,_pattern,_color1,...

               Draw specified colored circle on selected images.
               A radius of '100%' stands for 'sqrt(width^2+height^2)'.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified. If a pattern is specified, the circle is
               drawn outlined instead of filled.
               Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.

           close_binary:
               0<=_endpoint_rate<=100,_endpoint_connectivity>=0,_spline_distmax>=0,
                 _segment_distmax>=0,0<=_spline_anglemax<=180,_spline_roundness>=0,_area_min>=0,
                 _allow_self_intersection={ 0 | 1 }

               Automatically close open shapes in binary images (defining white strokes on  black
       background).
               Default        values:        'endpoint_rate=75',       'endpoint_connectivity=2',
       'spline_distmax=80',                   'segment_distmax=20',         'spline_anglemax=90',
       'spline_roundness=1','area_min=100',           'allow_self_intersection=1'.

           ellipse (+):
               x[%],y[%],R[%],r[%],_angle,_opacity,_pattern,_color1,...

               Draw specified colored ellipse on selected images.
               A radius of '100%' stands for 'sqrt(width^2+height^2)'.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified. If a pattern is specified, the ellipse is
               drawn outlined instead of filled.
               Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.

           flood (+):
               x[%],_y[%],_z[%],_tolerance>=0,_is_high_connectivity={         0        |        1
       },_opacity,_color1,...

               Flood-fill selected images using specified value and tolerance.
               Default values: 'y=z=0', 'tolerance=0', 'is_high_connectivity=0', 'opacity=1'  and
       'color1=0'.

           gaussian:
               _sigma1[%],_sigma2[%],_angle

               Draw  a  centered  gaussian on selected images, with specified standard deviations
       and orientation.
               Default values: 'sigma1=3', 'sigma2=sigma1' and 'angle=0'.

           graph (+):
               [function_image],_plot_type,_vertex_type,_ymin,_ymax,_opacity,_pattern,_color1,...
       |
               'formula',_resolution>=0,_plot_type,_vertex_type,_xmin,xmax,_ymin,_ymax,
                 _opacity,_pattern,_color1,...

               Draw specified function graph on selected images.
               'plot_type' can be { 0=none | 1=lines | 2=splines | 3=bar }.
               'vertex_type' can be { 0=none | 1=points | 2,3=crosses | 4,5=circles | 6,7=squares
       }.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified.
               Default values: 'plot_type=1', 'vertex_type=1', 'ymin=ymax=0 (auto)', 'opacity=1',
       'pattern=(undefined)'
               and 'color1=0'.

           grid:
               size_x[%]>=0,size_y[%]>=0,_offset_x[%],_offset_y[%],_opacity,_pattern,_color1,...

               Draw xy-grid on selected images.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified.
               Default  values:  'offset_x=offset_y=0',  'opacity=1',  'pattern=(undefined)'  and
       'color1=0'.

           image (+):
               [sprite],_x[%],_y[%],_z[%],_c[%],_opacity,_[sprite_mask],_max_opacity_mask

               Draw specified sprite image on selected images.
               (eq. to 'j').
               Default   values:   'x=y=z=c=0',   'opacity=1',   'sprite_mask=(undefined)'    and
       'max_opacity_mask=1'.

           line (+):
               x0[%],y0[%],x1[%],y1[%],_opacity,_pattern,_color1,...

               Draw specified colored line on selected images.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified.
               Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.

           linethick:
               x0[%],y0[%],x1[%],y1[%],_thickness,_opacity,_color1

               Draw specified colored thick line on selected images.
               Default values: 'thickness=2', 'opacity=1' and 'color1=0'.

           mandelbrot (+):
               z0r,z0i,z1r,z1i,_iteration_max>=0,_is_julia={ 0 | 1 },_c0r,_c0i,_opacity

               Draw mandelbrot/julia fractal on selected images.
               Default values: 'iteration_max=100', 'is_julia=0', 'c0r=c0i=0' and 'opacity=1'.

           marble:
               _image_weight,_pattern_weight,_angle,_amplitude,_sharpness>=0,_anisotropy>=0,
                 _alpha,_sigma,_cut_low>=0,_cut_high>=0

               Render marble like pattern on selected images.
               Default     values:    'image_weight=0.2',    'pattern_weight=0.1',    'angle=45',
       'amplitude=0',           'sharpness=0.4', 'anisotropy=0.8',
               'alpha=0.6', 'sigma=1.1' and 'cut_low=cut_high=0'.

           maze:
               _width>0,_height>0,_cell_size>0

               Input maze with specified size.

           maze_mask:
               _cellsize>0

               Input maze according to size and shape of selected mask images.
               Mask may contain disconnected shapes.

           object3d (+):
               [object3d],_x[%],_y[%],_z,_opacity,_rendering_mode,_is_double_sided={ 0 | 1 },
                 _is_zbuffer={ 0 | 1 },_focale,_light_x,_light_y,_light_z,_specular_lightness,
                 _specular_shininess

               Draw specified 3D object on selected images.
               (eq. to 'j3d').
               'rendering_mode' can be  {  0=dots  |  1=wireframe  |  2=flat  |  3=flat-shaded  |
       4=gouraud-shaded |           5=phong-shaded }.
               Default  values:  'x=y=z=0',  'opacity=1'  and 'is_zbuffer=1'. All other arguments
       take their           default values from the 3D environment variables.

           pack_sprites:
               _nb_scales>=0,0<=_min_scale<=100,_allow_rotation={ 0=0 deg. | 1=180 deg. | 2=90
                 deg. | 3=any },_spacing,_precision>=0,max_iterations>=0

               Try to randomly pack as many sprites as possible onto  the  'empty'  areas  of  an
       image.
               Sprites can be eventually rotated and scaled during the packing process.
               First selected image is the canvas that will be filled with the sprites.
               Its  last  channel  must  be  a  binary mask whose zero values represent potential
       locations for           drawing the sprites.
               All other selected images represent the sprites considered for packing.
               Their last channel must be a binary mask that represents the sprite shape (i.e.  a
       8-connected           component).
               The  order  of  sprite packing follows the order of specified sprites in the image
       list.
               Sprite packing is done on random locations and iteratively with decreasing scales.
               'nb_scales' sets the number of decreasing  scales  considered  for  all  specified
       sprites to be packed.
               'min_scale'  (in  %)  sets the minimal size considered for packing (specified as a
       percentage of           the original sprite size).
               'spacing' can be positive or negative.
               'precision' tells about the desired number of  failed  trials  before  ending  the
       filling process.
               Default  values:  'nb_scales=5',  'min_scale=25', 'allow_rotation=3', 'spacing=1',
       'precision=7'           and 'max_iterations=256'.

           piechart:
               label_height>=0,label_R,label_G,label_B,"label1",value1,R1,G1,B1,...,"labelN",
                 valueN,RN,GN,BN

               Draw pie chart on selected (RGB) images.

           plasma (+):
               _alpha,_beta,_scale>=0

               Draw a random colored plasma fractal on selected images.
               This command implements the so-called 'Diamond-Square' algorithm.
               Default values: 'alpha=1', 'beta=1' and 'scale=8'.

           point (+):
               x[%],y[%],_z[%],_opacity,_color1,...

               Set specified colored pixel on selected images.
               Default values: 'z=0', 'opacity=1' and 'color1=0'.

           polka_dots:
               diameter>=0,_density,_offset1,_offset2,_angle,_aliasing,_shading,_opacity,
                 _color,...

               Draw dots pattern on selected images.
               Default  values:  'density=20',  'offset1=offset2=50',  'angle=0',  'aliasing=10',
       'shading=1',           'opacity=1' and 'color=255'.

           polygon (+):
               N>=1,x1[%],y1[%],...,xN[%],yN[%],_opacity,_pattern,_color1,...

               Draw specified colored N-vertices polygon on selected images.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified. If a pattern is specified, the polygon is
               drawn outlined instead of filled.
               Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.

           quiver:
               [function_image],_sampling[%]>0,_factor>=0,_is_arrow={         0        |        1
       },_opacity,_color1,...

               Draw specified 2D vector/orientation field on selected images.
               Default   values:   'sampling=5%',    'factor=1',    'is_arrow=1',    'opacity=1',
       'pattern=(undefined)'
               and 'color1=0'.

           rectangle:
               x0[%],y0[%],x1[%],y1[%],_opacity,_pattern,_color1,...

               Draw specified colored rectangle on selected images.
               'pattern' is an hexadecimal number starting with '0x' which can be omitted
               even if a color is specified. If a pattern is specified, the rectangle is
               drawn outlined instead of filled.
               Default values: 'opacity=1', 'pattern=(undefined)' and 'color1=0'.

           rorschach:
               'smoothness[%]>=0','mirroring={ 0=none | 1=x | 2=y | 3=xy }

               Render rorschach-like inkblots on selected images.
               Default values: 'smoothness=5%' and 'mirroring=1'.

           sierpinski:
               recursion_level>=0

               Draw Sierpinski triangle on selected images.
               Default value: 'recursion_level=7'.

           spiralbw:

               Draw (squared) spiral on selected images.

           spline:
               x0[%],y0[%],u0[%],v0[%],x1[%],y1[%],u1[%],v1[%],_opacity,_color1,...

               Draw specified colored spline curve on selected images (cubic hermite spline).
               Default values: 'opacity=1' and 'color1=0'.

           tetraedron_shade:
               x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3,R0,G0,B0,...,R1,G1,B1,...,R2,G2,B2,...,R3,G3,B3,...

               Draw tetraedron with interpolated colors on selected (volumetric) images.

           text (+):
               text,_x[%],_y[%],_font_height[%]>=0,_opacity,_color1,...

               Draw specified colored text string on selected images.
               (eq. to 't').
               Sizes '13' and '128' are special and correspond to binary fonts (no-antialiasing).
               Any other font size is rendered with anti-aliasing.
               Specifying an empty target image resizes it to new dimensions such that the  image
       contains
               the entire text string.
               Default values: 'opacity=1' and 'color1=0'.

           text_outline:
               text,_x[%],_y[%],_font_height[%]>0,_outline>=0,_opacity,_color1,...

               Draw specified colored and outlined text string on selected images.
               Default   values:   'x=y=1%',  'font_height=7.5%',  'outline=2',  'opacity=1'  and
       'color1=255'.

           triangle_shade:
               x0,y0,x1,y1,x2,y2,R0,G0,B0,...,R1,G1,B1,...,R2,G2,B2,...

               Draw triangle with interpolated colors on selected images.

           truchet:
               _scale>0,_radius>=0,_pattern_type={ 0=straight | 1=curved }

               Fill selected images with random truchet patterns.
               Default values: 'scale=32', 'radius=5' and 'pattern_type=1'.

           turbulence:
               _radius>0,_octaves={1,2,3...,12},_alpha>0,_difference={-10,10},_mode={0,1,2,3}

               Render fractal noise or turbulence on selected images.
               Default values: 'radius=32', 'octaves=6', 'alpha=3', 'difference=0' and 'mode=0'.

           yinyang:

               Draw a yin-yang symbol on selected images.

        ** Matrix Computation:

           dijkstra (+):
               starting_node>=0,ending_node>=0

               Compute minimal distances and paths  from  specified  adjacency  matrices  by  the
       Dijkstra algorithm.

           eigen (+):

               Compute  the eigenvalues and eigenvectors of selected symmetric matrices or matrix
       fields.
               If one selected image has 3 or 6 channels, it is regarded as a field of 2x2 or 3x3
       symmetric matrices,
               whose eigen elements are computed at each point of the field.

           invert (+):

               Compute the inverse of the selected matrices.

           solve (+):
               [image]

               Solve linear system AX = B for selected B-matrices and specified A-matrix.
               If the system is under- or over-determined, the least square solution is returned.

           svd (+):

               Compute SVD decomposition of selected matrices.

           transpose:

               Transpose selected matrices.

           trisolve (+):
               [image]

               Solve  tridiagonal  system AX = B for selected B-vectors and specified tridiagonal
       A-matrix.
               Tridiagonal matrix must be stored as a 3 column vector, where 2nd column  contains
       the
               diagonal  coefficients,  while  1st  and  3rd  columns  contain the left and right
       coefficients.

        ** 3D Rendering:

           add3d (+):
               tx,_ty,_tz |
               [object3d] |
               (no arg)

               Shift selected 3D objects with specified displacement vector, or merge  them  with
       specified
               3D object, or merge all selected 3D objects together.
               (eq. to '+3d').
               Default values: 'ty=tz=0'.

           animate3d:
               _width>0,_height>0,_angle_dx,_angle_dy,_angle_dz,_zoom_factor>=0,_filename

               Animate selected 3D objects in a window.
               If  argument  'filename'  is  provided,  each frame of the animation is saved as a
       numbered filename.
               Default   values:   'width=640',   'height=480',    'angle_dx=0',    'angle_dy=1',
       'angle_dz=0',           'zoom_factor=1' and 'filename=(undefined)'.

           apply_camera3d:
               pos_x,pos_y,pos_z,target_x,target_y,target_z,up_x,up_y,up_z

               Apply 3D camera matrix to selected 3D objects.
               Default  values: 'target_x=0', 'target_y=0', 'target_z=0', 'up_x=0', 'up_y=-1' and
       'up_z=0'.

           apply_matrix3d:
               a11,a12,a13,...,a31,a32,a33

               Apply specified 3D rotation matrix to selected 3D objects.

           array3d:
               size_x>=1,_size_y>=1,_size_z>=1,_offset_x[%],_offset_y[%],_offset_y[%]

               Duplicate a 3D object along the X,Y and Z axes.
               Default values: 'size_y=1', 'size_z=1' and 'offset_x=offset_y=offset_z=100%'.

           arrow3d:
               x0,y0,z0,x1,y1,z1,_radius[%]>=0,_head_length[%]>=0,_head_radius[%]>=0

               Input 3D arrow with specified starting and ending 3D points.
               Default values: 'radius=5%', 'head_length=25%' and 'head_radius=15%'.

           axes3d:
               _size_x,_size_y,_size_z,_font_size>0,_label_x,_label_y,_label_z

               Input 3D axes with specified sizes along the x,y and z orientations.
               Default values: 'size_x=size_y=size_z=1', 'font_size=23', 'label_x=X', 'label_y=Y'
       and           'label_z=Z'.

           box3d:
               _size_x,_size_y,_size_z

               Input 3D box at (0,0,0), with specified geometry.
               Default values: 'size_x=1' and 'size_z=size_y=size_x'.

           center3d:

               Center selected 3D objects at (0,0,0).
               (eq. to 'c3d').

           circle3d:
               _x0,_y0,_z0,_radius>=0

               Input 3D circle at specified coordinates.
               Default values: 'x0=y0=z0=0' and 'radius=1'.

           circles3d:
               _radius>=0,_is_filled={ 0 | 1 }

               Convert specified 3D objects to sets of 3D circles with specified radius.
               Default values: 'radius=1' and 'is_filled=1'.

           color3d (+):
               R,_G,_B,_opacity

               Set color and opacity of selected 3D objects.
               (eq. to 'col3d').
               Default value: 'B=G=R' and 'opacity=(undefined)'.

           colorcube3d:

               Input 3D color cube.

           cone3d:
               _radius,_height,_nb_subdivisions>0

               Input 3D cone at (0,0,0), with specified geometry.
               Default value: 'radius=1','height=1' and 'nb_subdivisions=24'.

           cubes3d:
               _size>=0

               Convert specified 3D objects to sets of 3D cubes with specified size.
               Default value: 'size=1'.

           cup3d:
               _resolution>0

               Input 3D cup object.

           cylinder3d:
               _radius,_height,_nb_subdivisions>0

               Input 3D cylinder at (0,0,0), with specified geometry.
               Default value: 'radius=1','height=1' and 'nb_subdivisions=24'.

           delaunay3d:

               Generate 3D delaunay triangulations from selected images.
               One assumes that the selected input images are binary images containing the set of
       points to mesh.
               The output 3D object is a mesh composed of non-oriented triangles.

           distribution3d:

               Get 3D color distribution of selected images.

           div3d (+):
               factor |
               factor_x,factor_y,_factor_z

               Scale selected 3D objects isotropically or anisotropically, with  the  inverse  of
       specified
               factors.
               (eq. to '/3d').
               Default value: 'factor_z=0'.

           double3d (+):
               _is_double_sided={ 0 | 1 }

               Enable/disable double-sided mode for 3D rendering.
               (eq. to 'db3d').
               Default value: 'is_double_sided=1'.

           elevation3d (+):
               z-factor |
               [elevation_map] |
               'formula' |
               (no arg)

               Build 3D elevation of selected images, with a specified elevation map.
               When  invoked  with  (no  arg) or 'z-factor', the elevation map is computed as the
       pointwise L2           norm of the
               pixel values. Otherwise, the elevation map is taken from the  specified  image  or
       formula.

           empty3d:

               Input empty 3D object.

           extrude3d:
               _depth>0,_resolution>0,_smoothness[%]>=0

               Generate extruded 3D object from selected binary XY-profiles.
               Default values: 'depth=16', 'resolution=1024' and 'smoothness=0.5%'.

           focale3d (+):
               focale

               Set 3D focale.
               (eq. to 'f3d').
               Set 'focale' to 0 to enable parallel projection (instead of perspective).
               Set negative 'focale' will disable 3D sprite zooming.
               Default value: 'focale=700'.

           gaussians3d:
               _size>0,_opacity

               Convert selected 3D objects into set of 3D gaussian-shaped sprites.

           gmic3d:

               Input a 3D G'MIC logo.

           gyroid3d:
               _resolution>0,_zoom

               Input 3D gyroid at (0,0,0), with specified resolution.
               Default values: 'resolution=32' and 'zoom=5'.

           histogram3d:

               Get 3D color histogram of selected images.

           image6cube3d:

               Generate 3D mapped cubes from 6-sets of selected images.

           imageblocks3d:
               _maximum_elevation,_smoothness[%]>=0

               Generate 3D blocks from selected images.
               Transparency of selected images is taken into account.
               Default values: 'maximum_elevation=10' and 'smoothness=0'.

           imagecube3d:

               Generate 3D mapped cubes from selected images.

           imageplane3d:

               Generate 3D mapped planes from selected images.

           imagepyramid3d:

               Generate 3D mapped pyramids from selected images.

           imagerubik3d:
               _xy_tiles>=1,0<=xy_shift<=100,0<=z_shift<=100

               Generate 3D mapped rubik's cubes from selected images.
               Default values: 'xy_tiles=3', 'xy_shift=5' and 'z_shift=5'.

           imagesphere3d:
               _resolution1>=3,_resolution2>=3

               Generate 3D mapped sphere from selected images.
               Default values: 'resolution1=32' and 'resolutions2=16'.

           isoline3d (+):
               isovalue[%] |
               'formula',value,_x0,_y0,_x1,_y1,_size_x>0[%],_size_y>0[%]

               Extract  3D  isolines  with specified value from selected images or from specified
       formula.
               Default values: 'x0=y0=-3', 'x1=y1=3' and 'size_x=size_y=256'.

           isosurface3d (+):
               isovalue[%] |
               'formula',value,_x0,_y0,_z0,_x1,_y1,_z1,_size_x>0[%],_size_y>0[%],_size_z>0[%]

               Extract 3D isosurfaces with specified value from selected images or from specified
       formula.
               Default values: 'x0=y0=z0=-3', 'x1=y1=z1=3' and 'size_x=size_y=size_z=32'.

           label3d:
               "text",font_height>=0,_opacity,_color1,...

               Generate 3D text label.
               Default values: 'font_height=13', 'opacity=1' and 'color=255,255,255'.

           label_points3d:
               _label_size>0,_opacity

               Add a numbered label to all vertices of selected 3D objects.
               Default values: 'label_size=13' and 'opacity=0.8'.

           lathe3d:
               _resolution>0,_smoothness[%]>=0,_max_angle>=0

               Generate 3D object from selected binary XY-profiles.
               Default values: 'resolution=128', 'smoothness=0.5%' and 'max_angle=361'.

           light3d (+):
               position_x,position_y,position_z |
               [texture] |
               (no arg)

               Set the light coordinates or the light texture for 3D rendering.
               (eq. to 'l3d').
               (no arg) resets the 3D light to default.

           line3d:
               x0,y0,z0,x1,y1,z1

               Input 3D line at specified coordinates.

           lissajous3d:
               resolution>1,a,A,b,B,c,C

               Input                    3D                    lissajous                    curves
       (x(t)=sin(a*t+A*2*pi),y(t)=sin(b*t+B*2*pi),z(t)=sin(c*t+C*2*pi)).
               Default values: 'resolution=1024', 'a=2', 'A=0', 'b=1', 'B=0', 'c=0' and 'C=0'.

           mode3d (+):
               _mode

               Set static 3D rendering mode.
               (eq. to 'm3d').
               'mode' can be { -1=bounding-box | 0=dots | 1=wireframe | 2=flat | 3=flat-shaded  |
       4=gouraud-shaded | 5=phong-shaded }.");
               Bounding-box mode ('mode==-1') is active only for the interactive 3D viewer.
               Default value: 'mode=4'.

           moded3d (+):
               _mode

               Set dynamic 3D rendering mode for interactive 3D viewer.
               (eq. to 'md3d').
               'mode'  can be { -1=bounding-box | 0=dots | 1=wireframe | 2=flat | 3=flat-shaded |
       4=gouraud-shaded | 5=phong-shaded }.
               Default value: 'mode=-1'.

           mul3d (+):
               factor |
               factor_x,factor_y,_factor_z

               Scale  selected  3D  objects  isotropically  or  anisotropically,  with  specified
       factors.
               (eq. to '*3d').
               Default value: 'factor_z=0'.

           normalize3d:

               Normalize selected 3D objects to unit size.
               (eq. to 'n3d').

           opacity3d (+):
               _opacity

               Set opacity of selected 3D objects.
               (eq. to 'o3d').
               Default value: 'opacity=1'.

           parametric3d:
               _x(a,b),_y(a,b),_z(a,b),_amin,_amax,_bmin,_bmax,_res_a>0,_res_b>0,_res_x>0,
                 _res_y>0,_res_z>0,_smoothness>=0,_isovalue>=0

               Input 3D object from specified parametric surface (x(a,b),y(a,b),z(a,b)).
               Default    values:   'x=(2+cos(b))*sin(a)',   'y=(2+cos(b))*cos(a)',   'c=sin(b)',
       'amin=-pi',           'amax='pi', 'bmin=-pi', 'bmax='pi',
               'res_a=512',    'res_b=res_a',    'res_x=64',    'res_y=res_x',     'res_z=res_y',
       'smoothness=2%' and           'isovalue=10%'.

           pca_patch3d:
               _patch_size>0,_M>0,_N>0,_normalize_input={ 0 | 1 },_normalize_output={ 0 | 1 },
                 _lambda_xy

               Get 3D patch-pca representation of selected images.
               The  3D patch-pca is estimated from M patches on the input image, and displayed as
       a cloud of N           3D points.
               Default   values:   'patch_size=7',   'M=1000',   'N=3000',   'normalize_input=1',
       'normalize_output=0',           and 'lambda_xy=0'.

           plane3d:
               _size_x,_size_y,_nb_subdivisions_x>0,_nb_subdisivions_y>0

               Input 3D plane at (0,0,0), with specified geometry.
               Default          values:          'size_x=1',          'size_y=size_x'         and
       'nb_subdivisions_x=nb_subdivisions_y=24'.

           point3d:
               x0,y0,z0

               Input 3D point at specified coordinates.

           pointcloud3d:

               Convert selected planar or volumetric images to 3D point clouds.

           pose3d:
               p1,...,p12

               Apply 3D pose matrix to selected 3D objects.

           primitives3d:
               mode

               Convert primitives of selected 3D objects.
               (eq. to 'p3d').
               'mode' can be { 0=points | 1=outlines | 2=non-textured }.

           projections3d:
               _x[%],_y[%],_z[%],_is_bounding_box={ 0 | 1 }

               Generate 3D xy,xz,yz projection planes from specified volumetric images.

           pyramid3d:
               width,height

               Input 3D pyramid at (0,0,0), with specified geometry.

           quadrangle3d:
               x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3

               Input 3D quadrangle at specified coordinates.

           random3d:
               nb_points>=0

               Input random 3D point cloud in [0,1]^3.

           reverse3d (+):

               Reverse primitive orientations of selected 3D objects.
               (eq. to 'rv3d').

           rotate3d (+):
               u,v,w,angle

               Rotate selected 3D objects around specified axis with specified angle (in deg.).
               (eq. to 'r3d').

           rotation3d:
               u,v,w,angle

               Input 3x3 rotation matrix with specified axis and angle (in deg).

           sierpinski3d:
               _recursion_level>=0,_width,_height

               Input 3d Sierpinski pyramid.

           size3d:

               Return bounding box size of the last selected 3D object.

           skeleton3d:
               _metric,_frame_type={ 0=squares | 1=diamonds | 2=circles | 3=auto },
                 _skeleton_opacity,_frame_opacity,_is_frame_wireframe={ 0 | 1 }

               Build 3D skeletal structure object from  2d  binary  shapes  located  in  selected
       images.
               'metric' can be { 0=chebyshev | 1=manhattan | 2=euclidean }.
               Default    values:    'metric=2',    'bones_type=3',    'skeleton_opacity=1'   and
       'frame_opacity=0.1'.

           snapshot3d:
               _size>0,_zoom>=0,_backgroundR,_backgroundG,_backgroundB,_backgroundA |
               [background_image],zoom>=0

               Take 2d snapshots of selected 3D objects.
               Set 'zoom' to 0 to disable object auto-scaling.
               Default values: 'size=512', 'zoom=1' and '[background_image]=(default)'.

           specl3d (+):
               value>=0

               Set lightness of 3D specular light.
               (eq. to 'sl3d').
               Default value: 'value=0.15'.

           specs3d (+):
               value>=0

               Set shininess of 3D specular light.
               (eq. to 'ss3d').
               Default value: 'value=0.8'.

           sphere3d (+):
               radius,_nb_recursions>=0

               Input 3D sphere at (0,0,0), with specified geometry.
               Default value: 'nb_recursions=3'.

           spherical3d:
               _nb_azimuth>=3,_nb_zenith>=3,_radius_function(phi,theta)

               Input 3D spherical object at (0,0,0), with specified geometry.
               Default             values:              'nb_zenith=nb_azimut=64'              and
       'radius_function="abs(1+0.5*cos(3*phi)*sin(4*          theta))"'.

           spline3d:
               x0[%],y0[%],z0[%],u0[%],v0[%],w0[%],x1[%],y1[%],z1[%],u1[%],v1[%],w1[%],
                 _nb_vertices>=2

               Input 3D spline with specified geometry.
               Default values: 'nb_vertices=128'.

           split3d (+):
               _keep_shared_data={ 0 | 1 }

               Split selected 3D objects into 6 feature vectors :
               { header, sizes, vertices, primitives, colors, opacities }.
               (eq. to 's3d').
               To recreate the 3D object, append these 6 images along the y-axis.
               Default value: 'keep_shared_data=1'.

           sprite3d:

               Convert selected images as 3D sprites.
               Selected images with alpha channels are managed.

           sprites3d:
               [sprite],_sprite_has_alpha_channel={ 0 | 1 }

               Convert selected 3D objects as a sprite cloud.
               Set  'sprite_has_alpha_channel'  to  1  to  make  the last channel of the selected
       sprite be a           transparency mask.
               Default value: 'mask_has_alpha_channel=0'.

           star3d:
               _nb_branches>0,0<=_thickness<=1

               Input 3D star at (0,0,0), with specified geometry.
               Default values: 'nb_branches=5' and 'thickness=0.38'.

           streamline3d (+):
               x[%],y[%],z[%],_L>=0,_dl>0,_interpolation,_is_backward={ 0 | 1 },_is_oriented={  0
       | 1 } |
               'formula',x,y,z,_L>=0,_dl>0,_interpolation,_is_backward={ 0 | 1 },
                 _is_oriented={ 0 | 1 }

               Extract 3D streamlines from selected vector fields or from specified formula.
               'interpolation'  can  be  { 0=nearest integer | 1=1st-order | 2=2nd-order | 3=4th-
       order }.
               Default values: 'dl=0.1', 'interpolation=2', 'is_backward=0' and 'is_oriented=0'.

           sub3d (+):
               tx,_ty,_tz

               Shift selected 3D objects with the opposite of specified displacement vector.
               (eq. to '3d').
               Default values: 'ty=tz=0'.

           superformula3d:
               resolution>1,m>=1,n1,n2,n3

               Input 2D superformula curve as a 3D object.
               Default values: 'resolution=1024', 'm=8', 'n1=1', 'n2=5' and 'n3=8'.

           tensors3d:
               _radius_factor>=0,_shape={ 0=box | >=N=ellipsoid },_radius_min>=0

               Generate 3D tensor fields from selected images.
               when 'shape'>0, it gives the ellipsoid shape precision.
               Default values: 'radius_factor=1', 'shape=2' and 'radius_min=0.05'.

           text_pointcloud3d:
               _"text1",_"text2",_smoothness

               Input 3D text pointcloud from the two specified strings.
               Default values: 'text1="text1"', 'text2="text2"' and 'smoothness=1'.

           text3d:
               text,_font_height>0,_depth>0,_smoothness

               Input a 3D text object from specified text.
               Default values: 'font_height=53', 'depth=10' and 'smoothness=1.5'.

           texturize3d:
               [ind_texture],_[ind_coords]

               Texturize selected 3D objects with specified texture and coordinates.
               (eq. to 't3d').
               When '[ind_coords]' is omitted, default XY texture projection is performed.
               Default value: 'ind_coords=(undefined)'.

           torus3d:
               _radius1,_radius2,_nb_subdivisions1>2,_nb_subdivisions2>2

               Input 3D torus at (0,0,0), with specified geometry.
               Default   values:   'radius1=1',    'radius2=0.3',    'nb_subdivisions1=24'    and
       'nb_subdivisions2=12'.

           triangle3d:
               x0,y0,z0,x1,y1,z1,x2,y2,z2

               Input 3D triangle at specified coordinates.

           volume3d:

               Transform selected 3D volumetric images as 3D parallelepipedic objects.

           weird3d:
               _resolution>0

               Input 3D weird object at (0,0,0), with specified resolution.
               Default value: 'resolution=32'.

        ** Control Flow:

           apply_parallel:
               "command"

               Apply  specified  command  on each of the selected images, by parallelizing it for
       all image of the list.
               (eq. to 'ap').

           apply_parallel_channels:
               "command"

               Apply specified command on each of the selected images, by  parallelizing  it  for
       all channel of           the images independently.
               (eq. to 'apc').

           apply_parallel_overlap:
               "command",overlap[%],nb_threads={ 0=auto | 1 | 2 | 4 | 8 | 16 }

               Apply  specified  command  on  each of the selected images, by parallelizing it on
       'nb_threads'           overlapped sub-images.
               (eq. to 'apo').
               'nb_threads' must be a power of 2.
               Default values: 'overlap=0','nb_threads=0'.

           apply_tiles:
               "command",_bloc_width[%]>0,_bloc_height[%]>0,_bloc_depth[%]>0,
                 _overlap_width[%]>=0,_overlap_height[%]>=0,_overlap_depth[%]>=0,
                 _boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

               Apply specified command on  each  bloc  (neighborhood)  of  the  selected  images,
       eventually with           overlapping blocs.
               (eq. to 'at').
               Default              values:              'bloc_width=bloc_height=bloc_depth=10%',
       'overlap_width=overlap_height=overlap_depth=0' and 'boundary_conditions=1'.

           apply_timeout:
               "command",_timeout={ 0=no timeout | >0=with specified timeout (in seconds) }

               Apply a command with a timeout.

           check (+):
               expression

               Evaluate specified expression and display an error message if evaluated to false.
               If 'expression' is not a math expression, it is regarded as a filename and checked
       if it exists.

           check3d (+):
               _is_full_check={ 0 | 1 }

               Check validity of selected 3D vector objects, and display an error message
               if one of the selected images is not a valid 3D vector object.
               Full 3D object check is slower but more precise.
               Default value: 'is_full_check=1'.

           continue (+):

               Go to end of current 'repeat...done', 'do...while' or 'local...endlocal' block.

           break (+):

               Break current 'repeat...done', 'do...while' or 'local...endlocal' block.

           do (+):

               Start a 'do...while' block.

           done (+):

               End  a  'repeat/for...done'  block, and go to associated 'repeat/for' position, if
       iterations remain.

           elif (+):
               boolean |
               filename

               Start a 'elif...[else]...fi' block if previous 'if' was not verified
               and test if specified boolean is true, or if specified filename exists.
               'boolean' can be a float number standing for { 0=false | other=true }.

           else (+):

               Execute following commands if previous 'if' or 'elif' conditions failed.

           endif (+):

               End a 'if...[elif]...[else]...endif' block.
               (eq. to 'fi').

           endlocal (+):

               End a 'local...endlocal' block.
               (eq. to 'endl').

           error (+):
               message

               Print specified error message on the standard error (stderr) and exit interpreter,
       except
               if error is caught by a 'onfail' command.
               Command selection (if any) stands for displayed call stack subset instead of image
       indices.

           eval (+):
               expression

               Evaluate specified math expression.
               - If no command selection is specified, the expression is evaluated once  and  its
       result is set           to status.
               -  If  command  selection  is  specified,  the  evaluation is looped over selected
       images. Status is           not modified.
               (in this latter case, 'eval' is similar to  'fill'  without  assigning  the  image
       values).

           exec (+):
               _is_verbose={ 0 | 1 },"command"

               Execute external command using a system call.
               The status value is then set to the error code returned by the system call.
               If 'is_verbose=1', the executed command is allowed to output on stdout/stderr.
               (eq. to 'x').
               Default value: 'is_verbose=1'.

           for (+):
               condition

               Start a 'for...done' block.

           if (+):
               boolean |
               filename

               Start a 'if...[elif]...[else]...fi' block and test if specified boolean is true,
               or if specified filename exists.
               'boolean' can be a float number standing for { 0=false | other=true }.

           local (+):

               Start a 'local...[onfail]...endlocal' block, with selected images.
               (eq. to 'l').

           mutex (+):
               indice,_action={ 0=unlock | 1=lock }

               Lock or unlock specified mutex for multi-threaded programming.
               A  locked  mutex can be unlocked only by the same thread. All mutexes are unlocked
       by default.
               'indice' designates the mutex indice, in [0,255].
               Default value: 'action=1'.

           noarg (+):

               Used in a custom command, 'noarg' tells the command that its  argument  list  have
       not been used
               finally,  and so they must be evaluated next in the G'MIC pipeline, just as if the
       custom
               command takes no arguments at all.
               Use this command to write a custom command which can decide if it takes  arguments
       or not.

           onfail (+):

               Execute  following  commands  when  an  error  is  encountered  in the body of the
       'local...endlocal' block.
               The status value is set with the corresponding error message.

           parallel (+):
               _wait_threads,"command1","command2",...

               Execute specified commands in parallel, each in a different thread.
               Parallel threads share the list of images.
               'wait_threads' can be { 0=when current environment ends | 1=immediately }.
               Default value: 'wait_threads=1'.

           progress (+):
               0<=value<=100 |
               -1

               Set the progress indice of the current processing pipeline.
               This command is useful only when G'MIC is used by an embedding application.

           quit (+):

               Quit G'MIC interpreter.
               (eq. to 'q').

           repeat (+):
               nb_iterations,_variable_name

               Start iterations of a 'repeat...done' block.

           return (+):

               Return from current custom command.

           rprogress:
               0<=value<=100 | -1 | "command",0<=value_min<=100,0<=value_max<=100

               Set the progress indice of the current processing pipeline (relatively to
               previously defined progress bounds), or call the specified command with
               specified progress bounds.

           run:
               "G'MIC pipeline"

               Run specified G'MIC pipeline.
               This is only useful when used from a shell, e.g. to avoid shell  substitutions  to
       happen in argument.

           skip (+):
               item

               Do nothing but skip specified item.

           status (+):
               status_string

               Set the current status. Used to define a returning value from a function.
               (eq. to 'u').

           while (+):
               boolean |
               filename

               End a 'do...while' block and go back to associated 'do'
               if specified boolean is true or if specified filename exists.
               'boolean' can be a float number standing for { 0=false | other=true }.

        ** Arrays, Tiles and Frames:

           array:
               M>0,_N>0,_expand_type={ 0=min | 1=max | 2=all }

               Create MxN array from selected images.
               Default values: 'N=M' and 'expand_type=0'.

           array_fade:
               M>0,_N>0,0<=_fade_start<=100,0<=_fade_end<=100,_expand_type={0=min   |   1=max   |
       2=all}

               Create MxN array from selected images.
               Default values: 'N=M', 'fade_start=60', 'fade_end=90' and 'expand_type=1'.

           array_mirror:
               N>=0,_dir={ 0=x | 1=y | 2=xy | 3=tri-xy },_expand_type={ 0 | 1 }

               Create 2^Nx2^N array from selected images.
               Default values: 'dir=2' and 'expand_type=0'.

           array_random:
               Ms>0,_Ns>0,_Md>0,_Nd>0

               Create MdxNd array of tiles from selected MsxNs source arrays.
               Default values: 'Ns=Ms', 'Md=Ms' and 'Nd=Ns'.

           frame_blur:
               _sharpness>0,_size>=0,_smoothness,_shading,_blur

               Draw RGBA-colored round frame in selected images.
               Default  values:  'sharpness=10',  'size=30',  'smoothness=0',   'shading=1'   and
       'blur=3%'.

           frame_cube:
               _depth>=0,_centering_x,_centering_y,_left_side={0=normal | 1=mirror-x |
                 2=mirror-y | 3=mirror-xy},_right_side,_lower_side,_upper_side

               Insert 3D frames in selected images.
               Default  values: 'depth=1', 'centering_x=centering_y=0' and 'left_side=right_side,
       lower_side=upper_side=0'.

           frame_fuzzy:
               size_x[%]>=0,_size_y[%]>=0,_fuzzyness>=0,_smoothness[%]>=0,_R,_G,_B,_A

               Draw RGBA-colored fuzzy frame in selected images.
               Default values: 'size_y=size_x', 'fuzzyness=5', 'smoothness=1' and 'R=G=B=A=255'.

           frame_painting:
               _size[%]>=0,0<=_contrast<=1,_profile_smoothness[%]>=0,_R,_G,_B,
                 _vignette_size[%]>=0,_vignette_contrast>=0,_defects_contrast>=0,
                 0<=_defects_density<=100,_defects_size>=0,_defects_smoothness[%]>=0,
                 _serial_number

               Add a painting frame to selected images.
               Default  values:  'size=10%',  'contrast=0.4',  'profile_smoothness=6%',  'R=225',
       'G=200',       'B=120',                 'vignette_size=2%',       'vignette_contrast=400',
       'defects_contrast=50',          'defects_density=10',                    'defects_size=1',
       'defects_smoothness=0.5%' and 'serial_number=123456789'.

           frame_pattern:
               M>=3,_constrain_size={ 0 | 1 } |
               M>=3,_[frame_image],_constrain_size={ 0 | 1 }

               Insert selected pattern frame in selected images.
               Default values: 'pattern=0' and 'constrain_size=0'.

           frame_round:
               _sharpness>0,_size>=0,_smoothness,_shading,_R,_G,_B,_A

               Draw RGBA-colored round frame in selected images.
               Default   values:   'sharpness=10',  'size=10',  'smoothness=0',  'shading=0'  and
       'R=G=B=A=255'.

           frame_seamless:
               frame_size>=0,_patch_size>0,_blend_size>=0,_frame_direction={ 0=inner (preserve
                 image size) | 1=outer }

               Insert frame in selected images, so that tiling the  resulting  image  makes  less
       visible seams.
               Default values: 'patch_size=7', 'blend_size=5' and 'frame_direction=1'.

           frame_x:
               size_x[%],_col1,...,_colN

               Insert colored frame along the x-axis in selected images.
               Default values: 'col1=col2=col3=255' and 'col4=255'.

           frame_xy:
               size_x[%],_size_y[%],_col1,...,_colN

               Insert colored frame along the x-axis in selected images.
               Default values: 'size_y=size_x', 'col1=col2=col3=255' and 'col4=255'.
               (eq. to 'frame').

           frame_xyz:
               size_x[%],_size_y[%],_size_z[%]_col1,...,_colN

               Insert colored frame along the x-axis in selected images.
               Default values: 'size_y=size_x=size_z', 'col1=col2=col3=255' and 'col4=255'.

           frame_y:
               size_y[%],_col1,...,_colN

               Insert colored frame along the y-axis in selected images.
               Default values: 'col1=col2=col3=255' and 'col4=255'.

           img2ascii:
               _charset,_analysis_scale>0,_analysis_smoothness[%]>=0,_synthesis_scale>0,
                 _output_ascii_filename

               Render selected images as binary ascii art.
               This  command  returns the corresponding the list of widths and heights (expressed
       as a number of           characters) for each selected image.
               Default     values:      'charset=[ascii      charset]',      'analysis_scale=16',
       'analysis_smoothness=20%',                          'synthesis_scale=16'               and
       '_output_ascii_filename=[undefined]'.

           imagegrid:
               M>0,_N>0

               Create MxN image grid from selected images.
               Default value: 'N=M'.

           imagegrid_hexagonal:
               _resolution>0,0<=_outline<=1

               Create hexagonal grids from selected images.
               Default values: 'resolution=32', 'outline=0.1' and 'is_antialiased=1'.

           imagegrid_triangular:
               pattern_width>=1,_pattern_height>=1,_pattern_type,0<=_outline_opacity<=1,
                 _outline_color1,...

               Create triangular grids from selected images.
               'pattern type' can  be  {  0=horizontal  |  1=vertical  |  2=crossed  |  3=cube  |
       4=decreasing |           5=increasing }.
               Default      values:      'pattern_width=24',      'pattern_height=pattern_width',
       'pattern_type=0',           'outline_opacity=0.1' and 'outline_color1=0'.

           linearize_tiles:
               M>0,_N>0

               Linearize MxN tiles on selected images.
               Default value: 'N=M'.

           map_sprites:
               _nb_sprites>=1,_allow_rotation={ 0=none | 1=90 deg. | 2=180 deg. }

               Map set of sprites (defined as the 'nb_sprites' latest images of the selection) to
       other           selected images,
               according to the luminosity of their pixel values.

           pack:
               is_ratio_constraint={ 0 | 1 },_sort_criterion

               Pack selected images into a single image.
               The returned status contains the list of new (x,y) offsets for each input image.
               Parameter 'is_ratio_constraint' tells if the resulting image must tend to a square
       image.
               Default values: 'is_ratio_constraint=0' and 'sort_criterion=max(w,h)'.

           puzzle:
               _width>0,_height>0,_M>=1,_N>=1,_curvature,_centering,_connectors_variability,
                 _resolution>=1

               Input puzzle binary mask with specified size and geometry.
               Default values:  'width=height=512',  'M=N=5',  'curvature=0.5',  'centering=0.5',
       'connectors_variability=0.5' and 'resolution=64'.

           quadratize_tiles:
               M>0,_N>0

               Quadratize MxN tiles on selected images.
               Default value: 'N=M'.

           rotate_tiles:
               angle,_M>0,N>0

               Apply MxN tiled-rotation effect on selected images.
               Default values: 'M=8' and 'N=M'.

           shift_tiles:
               M>0,_N>0,_amplitude

               Apply MxN tiled-shift effect on selected images.
               Default values: 'N=M' and 'amplitude=20'.

           taquin:
               M>0,_N>0,_remove_tile={ 0=none | 1=first | 2=last | 3=random },_relief,
                 _border_thickness[%],_border_outline[%],_outline_color

               Create MxN taquin puzzle from selected images.
               Default  value:  'N=M',  'relief=50', 'border_thickness=5', 'border_outline=0' and
       'remove_tile=0'.

           tunnel:
               _level>=0,_factor>0,_centering_x,_centering_y,_opacity,_angle

               Apply tunnel effect on selected images.
               Default   values:    'level=9',    'factor=80%',    'centering_x=centering_y=0.5',
       'opacity=1' and 'angle=0'

        ** Artistic:

           boxfitting:
               _min_box_size>=1,_max_box_size>=0,_initial_density>=0,_nb_attempts>=1

               Apply box fitting effect on selected images, as displayed the web page:
               [http://www.complexification.net/gallery/machines/boxFittingImg/]
               Default  values:  'min_box_size=1',  'max_box_size=0',  'initial_density=0.1'  and
       'nb_attempts=3'.

           brushify:
               [brush],_brush_nb_sizes>=1,0<=_brush_min_size_factor<=1,
                 _brush_nb_orientations>=1,_brush_light_type,0<=_brush_light_strength<=1,
                 _brush_opacity,_painting_density[%]>=0,0<=_painting_contours_coherence<=1,
                 0<=_painting_orientation_coherence<=1,_painting_coherence_alpha[%]>=0,
                 _painting_coherence_sigma[%]>=0,_painting_primary_angle,
                 0<=_painting_angle_dispersion<=1

               Apply specified brush to create painterly versions of specified images.
               'brush_light_type' can be { 0=none | 1=flat | 2=darken | 3=lighten | 4=full }.
               Default      values:       'brush_nb_sizes=3',       'brush_min_size_factor=0.66',
       'brush_nb_orientations=12',            'brush_light_type=0',  'brush_light_strength=0.25',
       'brush_opacity=0.8', 'painting_density=20%',            'painting_contours_coherence=0.9',
       'painting_orientation_coherence=0.9',                        'painting_coherence_alpha=1',
       'painting_coherence_sigma=1',                                  'painting_primary_angle=0',
       'painting_angle_dispersion=0.2'

           cartoon:
               _smoothness,_sharpening,_threshold>=0,_thickness>=0,_color>=0,quantization>0

               Apply cartoon effect on selected images.
               Default      values:     'smoothness=3',     'sharpening=150',     'threshold=20',
       'thickness=0.25', 'color=1.5'           and 'quantization=8'.

           color_ellipses:
               _count>0,_radius>=0,_opacity>=0

               Add random color ellipses to selected images.
               Default values: 'count=400', 'radius=5' and 'opacity=0.1'.

           cubism:
               _density>=0,0<=_thickness<=50,_max_angle,_opacity,_smoothness>=0

               Apply cubism effect on selected images.
               Default values: 'density=50', 'thickness=10',  'max_angle=75',  'opacity=0.7'  and
       'smoothness=0'.

           draw_whirl:
               _amplitude>=0

               Apply whirl drawing effect on selected images.
               Default value: 'amplitude=100'.

           drawing:
               _amplitude>=0

               Apply drawing effect on selected images.
               Default value: 'amplitude=200'.

           drop_shadow:
               _offset_x[%],_offset_y[%],_smoothness[%]>=0,0<=_curvature<=1,_expand_size={  0 | 1
       }

               Drop shadow behind selected images.
               Default values: 'offset_x=20', 'offset_y=offset_x', 'smoothness=5',  'curvature=0'
       and           'expand_size=1'.

           ellipsionism:
               _R>0[%],_r>0[%],_smoothness>=0[%],_opacity,_outline>0,_density>0

               Apply ellipsionism filter to selected images.
               Default  values:  'R=10',  'r=3',  'smoothness=1%', 'opacity=0.7', 'outlise=8' and
       'density=0.6'.

           fire_edges:
               _edges>=0,0<=_attenuation<=1,_smoothness>=0,_threshold>=0,_nb_frames>0,
                 _starting_frame>=0,frame_skip>=0

               Generate fire effect from edges of selected images.
               Default values: 'edges=0.7', 'attenuation=0.25', 'smoothness=0.5', 'threshold=25',
       'nb_frames=1', 'starting_frame=20' and 'frame_skip=0'.

           fractalize:
               0<=detail_level<=1

               Randomly fractalize selected images.
               Default value: 'detail_level=0.8'

           glow:
               _amplitude>=0

               Add soft glow on selected images.
               Default value: 'amplitude=1%'.

           halftone:
               nb_levels>=2,_size_dark>=2,_size_bright>=2,_shape={ 0=square | 1=diamond |
                 2=circle | 3=inv-square | 4=inv-diamond | 5=inv-circle },_smoothness[%]>=0

               Apply halftone dithering to selected images.
               Default  values:  'nb_levels=5',  'size_dark=8',  'size_bright=8',  'shape=5'  and
       'smoothnesss=0'.

           hardsketchbw:
               _amplitude>=0,_density>=0,_opacity,0<=_edge_threshold<=100,_is_fast={ 0 | 1 }

               Apply hard B&W sketch effect on selected images.
               Default values: 'amplitude=1000', 'sampling=3', 'opacity=0.1', 'edge_threshold=20'
       and           'is_fast=0'.

           hearts:
               _density>=0

               Apply heart effect on selected images.
               Default value: 'density=10'.

           houghsketchbw:
               _density>=0,_radius>0,0<=_threshold<=100,0<=_opacity<=1,_votesize[%]>0

               Apply hough B&W sketch effect on selected images.
               Default   values:   'density=8',  'radius=5',  'threshold=80',  'opacity=0.1'  and
       'votesize=100%'.

           lightrays:
               100<=_density<=0,_center_x[%],_center_y[%],_ray_length>=0,_ray_attenuation>=0

               Generate ray lights from the edges of selected images.
               Defaults values : 'density=50%', 'center_x=50%', 'center_y=50%',  'ray_length=0.9'
       and           'ray_attenuation=0.5'.

           light_relief:
               _ambient_light,_specular_lightness,_specular_size,_light_smoothness,_darkness,
                 _xl,_yl,_zl,_zscale,_opacity_is_heightmap={ 0 | 1 }

               Apply relief light to selected images.
               Default     values(s)     :     'ambient_light=0.3',     'specular_lightness=0.5',
       'specular_size=0.2',           'darkness=0', 'xl=0.2', 'yl=zl=0.5',
               'zscale=1', 'opacity=1' and 'opacity_is_heightmap=0'.

           linify:
               0<=_density<=100,_spreading>=0,_resolution[%]>0,_line_opacity>=0,
                 _line_precision>0,_mode={ 0=subtractive | 1=additive }

               Apply linify effect on selected images.
               The  algorithm   is   inspired   from   the   one   described   on   the   webpage
       'http://linify.me/about'.
               Default  values: 'density=50', 'spreading=2', 'resolution=40%', 'line_opacity=10',
       'line_precision=24' and 'mode=0'.

           mosaic:
               0<=_density<=100

               Create random mosaic from selected images.
               Default values: 'density=30'.

           old_photo:

               Apply old photo effect on selected images.

           pencilbw:
               _size>=0,_amplitude>=0

               Apply B&W pencil effect on selected images.
               Default values: 'size=0.3' and 'amplitude=60'.

           pixelsort:
               _ordering={ + | - },_axis={ x | y | z | xy | yx },_[sorting_criterion],_[mask]

               Apply a 'pixel sorting' algorithm on selected images, as described in the page :
               http://satyarth.me/articles/pixel-sorting/
               Default values: 'ordering=+', 'axis=x' and 'sorting_criterion=mask=(undefined)'.

           polaroid:
               _size1>=0,_size2>=0

               Create polaroid effect in selected images.
               Default values: 'size1=10' and 'size2=20'.

           polygonize:
               _warp_amplitude>=0,_smoothness[%]>=0,_min_area[%]>=0,_resolution_x[%]>0,
                 _resolution_y[%]>0

               Apply polygon effect on selected images.
               Default   values:    'warp_amplitude=300',    'smoothness=2%',    'min_area=0.1%',
       'resolution_x=resolution_y=10%'.

           poster_edges:
               0<=_edge_threshold<=100,0<=_edge_shade<=100,_edge_thickness>=0,
                 _edge_antialiasing>=0,0<=_posterization_level<=15,_posterization_antialiasing>=0

               Apply poster edges effect on selected images.
               Default   values:   'edge_threshold=40',   'edge_shade=5',   'edge_thickness=0.5',
       'edge_antialiasing=10', 'posterization_level=12' and 'posterization_antialiasing=0'.

           poster_hope:
               _smoothness>=0

               Apply Hope stencil poster effect on selected images.
               Default value: 'smoothness=3'.

           rodilius:
               0<=_amplitude<=100,_0<=thickness<=100,_sharpness>=0,_nb_orientations>0,_offset,
                 _color_mode={ 0=darker | 1=brighter }

               Apply rodilius (fractalius-like) filter on selected images.
               Default     values:     'amplitude=10',      'thickness=10',      'sharpness=400',
       'nb_orientations=7',           'offset=0' and 'color_mode=1'.

           stained_glass:
               _edges[%]>=0, shading>=0, is_thin_separators={ 0 | 1 }

               Generate stained glass from selected images.
               Default values: 'edges=40%', 'shading=0.2' and 'is_precise=0'.

           stars:
               _density[%]>=0,_depth>=0,_size>0,_nb_branches>=1,0<=_thickness<=1,
                 _smoothness[%]>=0,_R,_G,_B,_opacity

               Add random stars to selected images.
               Default    values:    'density=10%',    'depth=1',   'size=32',   'nb_branches=5',
       'thickness=0.38',           'smoothness=0.5', 'R=G=B=200' and 'opacity=1'.

           sketchbw:
               _nb_angles>0,_start_angle,_angle_range>=0,_length>=0,_threshold>=0,_opacity,
                 _bgfactor>=0,_density>0,_sharpness>=0,_anisotropy>=0,_smoothness>=0,
                 _coherence>=0,_is_boost={ 0 | 1 },_is_curved={ 0 | 1 }

               Apply sketch effect to selected images.
               Default values: 'nb_angles=2', 'start_angle=45',  'angle_range=180',  'length=30',
       'threshold=3',           'opacity=0.03',
               'bgfactor=0', 'density=0.6', 'sharpness=0.1', 'anisotropy=0.6', 'smoothness=0.25',
       'coherence=1', 'is_boost=0' and 'is_curved=1'.

           sponge:
               _size>0

               Apply sponge effect on selected images.
               Default value: 'size=13'.

           stencil:
               _radius[%]>=0,_smoothness>=0,_iterations>=0

               Apply stencil filter on selected images.
               Default values: 'radius=3', 'smoothness=1' and 'iterations=8'.

           stencilbw:
               _edges>=0,_smoothness>=0

               Apply B&W stencil effect on selected images.
               Default values: 'edges=15' and 'smoothness=10'.

           tetris:
               _scale>0

               Apply tetris effect on selected images.
               Default value: 'scale=10'.

           warhol:
               _M>0,_N>0,_smoothness>=0,_color>=0

               Create MxN Andy Warhol-like artwork from selected images.
               Default values: 'M=3', 'N=M', 'smoothness=2' and 'color=20'.

           weave:
               _density>=0,0<=_thickness<=100,0<=_shadow<=100,_shading>=0,_fibers_amplitude>=0,
                 _fibers_smoothness>=0,_angle,-1<=_x_curvature<=1,-1<=_y_curvature<=1

               Apply weave effect to the selected images.
               'angle' can be { 0=0 deg. | 1=22.5 deg. | 2=45 deg. | 3=67.5 deg. }.
               Default   values:   'density=6',   'thickness=65',   'shadow=40',   'shading=0.5',
       'fibers_amplitude=0',                   'fibers_smoothness=0',        'angle=0'        and
       'curvature_x=curvature_y=0'

           whirls:
               _texture>=0,_smoothness>=0,_darkness>=0,_lightness>=0

               Add random whirl texture to selected images.
               Default values: 'texture=3', 'smoothness=6', 'darkness=0.5' and 'lightness=1.8'.

        ** Warpings:

           deform:
               _amplitude>=0,_interpolation

               Apply random smooth deformation on selected images.
               'interpolation' can be { 0=none | 1=linear | 2=bicubic }.
               Default value: 'amplitude=10'.

           euclidean2polar:
               _center_x[%],_center_y[%],_stretch_factor>0,_boundary_conditions={ 0=dirichlet |
                  1=neumann | 2=periodic | 3=mirror }

               Apply euclidean to polar transform on selected images.
               Default     values:      'center_x=center_y=50%',      'stretch_factor=1'      and
       'boundary_conditions=1'.

           equirectangular2nadirzenith:

               Transform selected equirectangular images to nadir/zenith rectilinear projections.

           fisheye:
               _center_x,_center_y,0<=_radius<=100,_amplitude>=0

               Apply fish-eye deformation on selected images.
               Default values: 'x=y=50', 'radius=50' and 'amplitude=1.2'.

           flower:
               _amplitude,_frequency,_offset_r[%],_angle,_center_x[%],_center_y[%],
                 _boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic | 3=mirror}

               Apply flower deformation on selected images.
               Default    values:   'amplitude=30',   'frequency=6',   'offset_r=0',   'angle=0',
       'center_x=center_y=50%'           and 'boundary_conditions=3'.

           kaleidoscope:
               _center_x[%],_center_y[%],_radius,_angle,_boundary_conditions={ 0=dirichlet |
                 1=neumann | 2=periodic | 3=mirror }

               Create kaleidoscope effect from selected images.
               Default   values:   'center_x=center_y=50%',    'radius=100',    'angle=30'    and
       'boundary_conditions=3'.

           map_sphere:
               _width>0,_height>0,_radius,_dilation>0,_fading>=0,_fading_power>=0

               Map selected images on a sphere.
               Default  values:  'width=height=512', 'radius=100', 'dilation=0.5', 'fading=0' and
       'fading_power=0.5'.

           nadirzenith2equirectangular:

               Transform selected nadir/zenith rectilinear projections to equirectangular images.

           polar2euclidean:
               _center_x[%],_center_y[%],_stretch_factor>0,_boundary_conditions={ 0=dirichlet |
                  1=neumann | 2=periodic | 3=mirror }

               Apply euclidean to polar transform on selected images.
               Default     values:      'center_x=center_y=50%',      'stretch_factor=1'      and
       'boundary_conditions=1'.

           raindrops:
               _amplitude,_density>=0,_wavelength>=0,_merging_steps>=0

               Apply raindrops deformation on selected images.
               Default      values:      'amplitude=80','density=0.1',     'wavelength=1'     and
       'merging_steps=0'.

           ripple:
               _amplitude,_bandwidth,_shape={ 0=bloc | 1=triangle | 2=sine | 3=sine+ |
                 4=random },_angle,_offset

               Apply ripple deformation on selected images.
               Default  values:  'amplitude=10',   'bandwidth=10',   'shape=2',   'angle=0'   and
       'offset=0'.

           rotoidoscope:
               _center_x[%],_center_y[%],_tiles>0,_smoothness[%]>=0,_boundary_conditions={
                 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

               Create rotational kaleidoscope effect from selected images.
               Default      values:      'cx=cy=50%',      'tiles=10',     'smoothness=1'     and
       'boundary_conditions=3'.

           spherize:
               _radius[%]>=0,_strength,_smoothness[%]>=0,_center_x[%],_center_y[%],_ratio_x/
                 y>0,_angle,_interpolation

               Apply spherize effect on selected images.
               Default      values:       'radius=50%',       'strength=1',       'smoothness=0',
       'center_x=center_y=50%', 'ratio_x/          y=1', 'angle=0' and 'interpolation=1'.

           symmetrize:
               _x[%],_y[%],_angle,_boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic |
                  3=mirror },_is_antisymmetry={ 0 | 1 },_swap_sides={ 0 | 1 }

               Symmetrize selected images regarding specified axis.
               Default      values:      'x=y=50%',      'angle=90',     'boundary_conditions=3',
       'is_antisymmetry=0' and           'swap_sides=0'.

           transform_polar:
               "expr_radius",_"expr_angle",_center_x[%],_center_y[%],_boundary_conditions={
                 0=dirichlet | 1=neumann }

               Apply user-defined transform on polar representation of selected images.
               Default values: 'expr_radius=R-r',  'expr_rangle=a',  'center_x=center_y=50%'  and
       'boundary_conditions=1'.

           twirl:
               _amplitude,_center_x[%],_center_y[%],_boundary_conditions={ 0=dirichlet |
                 1=neumann | 2=periodic | 3=mirror }

               Apply twirl deformation on selected images.
               Default       values:       'amplitude=1',       'center_x=center_y=50%'       and
       'boundary_conditions=3'.

           warp_perspective:
               _x-angle,_y-angle,_zoom>0,_x-center,_y-center,_boundary_conditions={
                 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }

               Warp selected images with perspective deformation.
               Default values: 'x-angle=1.5', 'y-angle=0', 'zoom=1',  'x-center=y-center=50'  and
       'boundary_conditions=2'.

           water:
               _amplitude,_smoothness>=0,_angle

               Apply water deformation on selected images.
               Default values: 'amplitude=30', 'smoothness=1.5' and 'angle=45'.

           wave:
               _amplitude>=0,_frequency>=0,_center_x,_center_y

               Apply wave deformation on selected images.
               Default values: 'amplitude=4', 'frequency=0.4' and 'center_x=center_y=50'.

           wind:
               _amplitude>=0,_angle,0<=_attenuation<=1,_threshold

               Apply wind effect on selected images.
               Default values: 'amplitude=20', 'angle=0', 'attenuation=0.7' and 'threshold=20'.

           zoom:
               _factor,_cx,_cy,_cz,_boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic
                 | 3=mirror }

               Apply zoom factor to selected images.
               Default values: 'factor=1', 'cx=cy=cz=0.5' and 'boundary_conditions=0'.

        ** Degradations:

           cracks:
               0<=_density<=100,_is_relief={ 0 | 1 },_opacity,_color1,...

               Draw random cracks on selected images with specified color.
               Default values: 'density=25', 'is_relief=0', 'opacity=1' and 'color1=0'.

           light_patch:
               _density>0,_darkness>=0,_lightness>=0

               Add light patches to selected images.
               Default values: 'density=10', 'darkness=0.9' and 'lightness=1.7'.

           noise_hurl:
               _amplitude>=0

               Add hurl noise to selected images.
               Default value: 'amplitude=10'.

           pixelize:
               _scale_x>0,_scale_y>0,_scale_z>0

               Pixelize selected images with specified scales.
               Default values: 'scale_x=20' and 'scale_y=scale_z=scale_x'.

           scanlines:
               _amplitude,_bandwidth,_shape={ 0=bloc | 1=triangle | 2=sine | 3=sine+ |
                 4=random },_angle,_offset

               Apply ripple deformation on selected images.
               Default   values:   'amplitude=60',   'bandwidth=2',   'shape=0',   'angle=0'  and
       'offset=0'.

           shade_stripes:
               _frequency>=0,_direction={ 0=horizontal | 1=vertical },_darkness>=0,
                 _lightness>=0

               Add shade stripes to selected images.
               Default values: 'frequency=5', 'direction=1', 'darkness=0.8' and 'lightness=2'.

           shadow_patch:
               _opacity>=0

               Add shadow patches to selected images.
               Default value: 'opacity=0.7'.

           spread:
               _dx>=0,_dy>=0,_dz>=0

               Spread pixel values of selected images randomly along x,y and z.
               Default values: 'dx=3', 'dy=dx' and 'dz=0'.

           stripes_y:
               _frequency>=0

               Add vertical stripes to selected images.
               Default value: 'frequency=10'.

           texturize_canvas:
               _amplitude>=0,_fibrousness>=0,_emboss_level>=0

               Add paint canvas texture to selected images.
               Default values: 'amplitude=20', 'fibrousness=3' and 'emboss_level=0.6'.

           texturize_paper:

               Add paper texture to selected images.

           vignette:
               _strength>=0,0<=_radius_min<=100,0<=_radius_max<=100

               Add vignette effect to selected images.
               Default values: 'strength=100', 'radius_min=70' and 'radius_max=90'.

           watermark_visible:
               _text,0<_opacity<1,_size>0,_angle,_mode={ 0=remove | 1=add },_smoothness>=0

               Add or remove a  visible  watermark  on  selected  images  (value  range  must  be
       [0,255]).
               Default  values:  'text=(c) G'MIC', 'opacity=0.3', 'size=53', 'angle=25', 'mode=1'
       and           'smoothness=0'.

        ** Blending and Fading:

           blend:
               [layer],blending_mode,_opacity[%],_selection_is={ 0=base-layers | 1=top-layers } |
               blending_mode,_opacity[%]

               Blend selected G,GA,RGB or RGBA images by specified layer or  blend  all  selected
       images together,           using specified blending mode.
               'blending_mode'  can  be  {  add  | alpha | and | average | blue | burn | darken |
       difference |
               divide | dodge | edges | exclusion | freeze | grainextract | grainmerge | green  |
       hardlight |
               hardmix  |  hue | interpolation | lighten | lightness | linearburn | linearlight |
       luminance |
               multiply | negation | or | overlay | pinlight |  red  |  reflect  |  saturation  |
       seamless |           seamless_mixed | screen |
               shapeareamax  |  shapeareamax0  |  shapeareamin  |  shapeareamin0 | shapeaverage |
       shapeaverage0 |           shapemedian | shapemedian0 |
               shapemin | shapemin0 | shapemax | shapemax0 | softburn | softdodge |  softlight  |
       stamp |           subtract | value | vividlight | xor }.
               'opacity' should be in '[0,1]', or '[0,100]' if expressed with a '%'.
               Default values: 'blending_mode=alpha', 'opacity=1' and 'selection_is=0'.

           blend_edges:
               smoothness[%]>=0

               Blend selected images togethers using 'edges' mode.

           blend_fade:
               [fading_shape]

               Blend selected images together using specified fading shape.

           blend_median:

               Blend selected images together using 'median' mode.

           blend_seamless:
               _is_mixed_mode={ 0 | 1 },_inner_fading[%]>=0,_outer_fading[%]>=0

               Blend selected images using a seamless blending mode (Poisson-based).
               Default values: 'is_mixed=0', 'inner_fading=0' and 'outer_fading=100%'.

           fade_diamond:
               0<=_start<=100,0<=_end<=100

               Create diamond fading from selected images.
               Default values: 'start=80' and 'end=90'.

           fade_linear:
               _angle,0<=_start<=100,0<=_end<=100

               Create linear fading from selected images.
               Default values: 'angle=45', 'start=30' and 'end=70'.

           fade_radial:
               0<=_start<=100,0<=_end<=100

               Create radial fading from selected images.
               Default values: 'start=30' and 'end=70'.

           fade_x:
               0<=_start<=100,0<=_end<=100

               Create horizontal fading from selected images.
               Default values: 'start=30' and 'end=70'.

           fade_y:
               0<=_start<=100,0<=_end<=100

               Create vertical fading from selected images.
               Default values: 'start=30' and 'end=70'.

           fade_z:
               0<=_start<=100,0<=_end<=100

               Create transversal fading from selected images.
               Default values: 'start=30' and 'end=70'.

           sub_alpha:
               [base_image],_opacity_gain>=1

               Compute  the minimal alpha-channel difference (opposite of alpha blending) between
       the selected           images and the specified base image.
               The alpha difference A-B is defined as the image having minimal opacity, such that
       alpha_blend(B,A-B) = A.
               Default value: 'opacity_gain=1'.

        ** Image Sequences and Videos:

           animate:
               filter_name,"param1_start,...,paramN_start","param1_end,...,paramN_end",
                 nb_frames>=0,_output_frames={ 0 | 1 },_output_filename |
               delay>0,_back and forth={ 0 | 1 }

               Animate  filter  from starting parameters to ending parameters or animate selected
       images
               in a display window.
               Default value: 'delay=30'.

           apply_camera:
               _"command",_camera_index>=0,_skip_frames>=0,_output_filename

               Apply specified command on live camera stream, and display it  on  display  window
       [0].
               Default  values:  'command=""', 'camera_index=0' (default camera), 'skip_frames=0'
       and           'output_filename=""'.

           apply_files:
               "filename_pattern",_"command",_first_frame>=0,_last_frame={ >=0 | -1=last },
                 _frame_step>=1,_output_filename

               Apply a G'MIC command on specified input image files, in a streamed way.
               If a display window  is  opened,  rendered  frames  are  displayed  in  it  during
       processing.
               The  output  filename  may  have extension '.avi' (saved as a video), or any other
       usual image file           extension (saved as a sequence of images).
               Default   values:   'command=(undefined)',    'first_frame=0',    'last_frame=-1',
       'frame_step=1' and           'output_filename=(undefined)'.

           apply_video:
               video_filename,_"command",_first_frame>=0,_last_frame={ >=0 | -1=last },
                 _frame_step>=1,_output_filename

               Apply  a  G'MIC  command  on  all  frames  of the specified input video file, in a
       streamed way.
               If a display window  is  opened,  rendered  frames  are  displayed  in  it  during
       processing.
               The  output  filename  may  have extension '.avi' (saved as a video), or any other
       usual image file           extension (saved as a sequence of images).
               Default   values:    'first_frame=0',    'last_frame=-1',    'frame_step=1'    and
       'output_filename=(undefined)'.

           average_files:
               "filename_pattern",_first_frame>=0,_last_frame={ >=0 | -1=last },_frame_step>=1,
                 _output_filename

               Average specified input image files, in a streamed way.
               If  a  display  window  is  opened,  rendered  frames  are  displayed in it during
       processing.
               The output filename may have extension '.avi' (saved as a  video),  or  any  other
       usual image file           extension (saved as a sequence of images).
               Default    values:    'first_frame=0',    'last_frame=-1',    'frame_step=1'   and
       'output_filename=(undefined)'.

           average_video:
               video_filename,_first_frame>=0,_last_frame={ >=0 | -1=last },_frame_step>=1,
                 _output_filename

               Average frames of specified input video file, in a streamed way.
               If a display window  is  opened,  rendered  frames  are  displayed  in  it  during
       processing.
               The  output  filename  may  have extension '.avi' (saved as a video), or any other
       usual image file           extension (saved as a sequence of images).
               Default   values:    'first_frame=0',    'last_frame=-1',    'frame_step=1'    and
       'output_filename=(undefined)'.

           fade_files:
               "filename_pattern",_nb_inner_frames>0,_first_frame>=0,_last_frame={ >=0 |
                 -1=last },_frame_step>=1,_output_filename

               Generate a temporal fading from specified input image files, in a streamed way.
               If  a  display  window  is  opened,  rendered  frames  are  displayed in it during
       processing.
               The output filename may have extension 'avi' (saved as  a  video),  or  any  other
       usual image file           extension (saved as a sequence of images).
               Default    values:    'nb_inner_frames=10',    'first_frame=0',   'last_frame=-1',
       'frame_step=1' and           'output_filename=(undefined)'.

           fade_video:
               video_filename,_nb_inner_frames>0,_first_frame>=0,_last_frame={ >=0 | -1=last },
                 _frame_step>=1,_output_filename

               Create a temporal fading sequence from specified input video file, in  a  streamed
       way.
               If  a  display  window  is  opened,  rendered  frames  are  displayed in it during
       processing.
               Default   values:    'nb_inner_frames=10',    'first_frame=0',    'last_frame=-1',
       'frame_step=1' and           'output_filename=(undefined)'.

           files2video:
               "filename_pattern",_output_filename,_fps>0,_codec

               Convert several files into a single video file.
               Default values: 'output_filename=output.avi', 'fps=25' and 'codec=mp4v'.

           median_files:
               "filename_pattern",_first_frame>=0,_last_frame={ >=0 | -1=last },_frame_step>=1,
                 _frame_rows[%]>=1,_is_fast_approximation={ 0 | 1 }

               Compute the median frame of specified input image files, in a streamed way.
               If  a  display  window  is  opened,  rendered  frame  is  displayed  in  it during
       processing.
               Default values: 'first_frame=0', 'last_frame=-1', 'frame_step=1', 'frame_rows=20%'
       and           'is_fast_approximation=0'.

           median_video:
               video_filename,_first_frame>=0,_last_frame={ >=0 | -1=last },_frame_step>=1,
                 _frame_rows[%]>=1,_is_fast_approximation={ 0 | 1 }

               Compute the median of all frames of an input video file, in a streamed way.
               If  a  display  window  is  opened,  rendered  frame  is  displayed  in  it during
       processing.
               Default     values:     'first_frame=0',     'last_frame=-1',      'frame_step=1',
       'frame_rows=100%' and           'is_fast_approximation=1'.

           morph:
               nb_inner_frames>=1,_smoothness>=0,_precision>=0

               Create morphing sequence between selected images.
               Default values: 'smoothness=0.1' and 'precision=4'.

           morph_files:
               "filename_pattern",_nb_inner_frames>0,_smoothness>=0,_precision>=0,
                 _first_frame>=0,_last_frame={ >=0 | -1=last },_frame_step>=1,_output_filename

               Generate a temporal morphing from specified input image files, in a streamed way.
               If  a  display  window  is  opened,  rendered  frames  are  displayed in it during
       processing.
               The output filename may have extension '.avi' (saved as a  video),  or  any  other
       usual image file           extension (saved as a sequence of images).
               Default    values:    'nb_inner_frames=10',    'smoothness=0.1',    'precision=4',
       'first_frame=0',                    'last_frame=-1',          'frame_step=1'           and
       'output_filename=(undefined)'.

           morph_video:
               video_filename,_nb_inner_frames>0,_smoothness>=0,_precision>=0,_first_frame>=0,
                 _last_frame={ >=0 | -1=last },_frame_step>=1,_output_filename

               Generate a temporal morphing from specified input video file, in a streamed way.
               If  a  display  window  is  opened,  rendered  frames  are  displayed in it during
       processing.
               The output filename may have extension '.avi' (saved as a  video),  or  any  other
       usual image file           extension (saved as a sequence of images).
               Default    values:    'nb_inner_frames=10',    'smoothness=0.1',    'precision=4',
       'first_frame=0',                    'last_frame=-1',          'frame_step=1'           and
       'output_filename=(undefined)'.

           register_nonrigid:
               [destination],_smoothness>=0,_precision>0,_nb_scale>=0

               Register  selected source images with specified destination image, using non-rigid
       warp.
               Default values: 'smoothness=0.2', 'precision=6' and 'nb_scale=0(auto)'.

           register_rigid:
               [destination],_smoothness>=0,_boundary_conditions={ 0=dirichlet | 1=neumann |
                 2=periodic | 3=mirror }

               Register selected source images with specified destination image, using rigid warp
       (shift).
               Default values: 'smoothness=1' and 'boundary_conditions=0'.

           transition:
               [transition_shape],nb_added_frames>=0,100>=shading>=0,_single_frame_only={
                 -1=disabled | >=0 }

               Generate a transition sequence between selected images.
               Default values: 'shading=0' and 'single_frame_only=-1'.

           transition3d:
               _nb_frames>=2,_nb_xtiles>0,_nb_ytiles>0,_axis_x,_axis_y,_axis_z,_is_antialias={  0
       | 1 }

               Create 3D transition sequence between selected consecutive images.
               'axis_x', 'axis_y' and 'axis_z' can be set as mathematical expressions,  depending
       on 'x' and 'y'.
               Default  values:  'nb_frames=10', 'nb_xtiles=nb_ytiles=3', 'axis_x=1', 'axis_y=1',
       'axis_z=0' and           'is_antialias=1'.

           video2files:
               input_filename,_output_filename,_first_frame>=0,_last_frame={ >=0 | -1=last },
                 _frame_step>=1

               Split specified input video file into image files, one for each frame.
               First and last frames as well as step between frames can be specified.
               Default values: 'output_filename=frame.png', 'first_frame=0', 'last_frame=-1'  and
       'frame_step=1'.

        ** Convenience Functions:

           alert:
               _title,_message,_label_button1,_label_button2,...

               Display an alert box and wait for user's choice.
               If a single image is in the selection, it is used as an icon for the alert box.
               Default values: 'title=[G'MIC Alert]' and 'message=This is an alert box.'.

           arg:
               n>=1,_arg1,...,_argN

               Return the n-th argument of the specified argument list.

           arg2var:
               variable_name,argument_1,...,argument_N

               For each i in [1...N], set 'variable_name$i=argument_i'.
               The  variable name should be global to make this command useful (i.e. starts by an
       underscore).

           autocrop_coords:
               value1,value2,... | auto

               Return coordinates (x0,y0,z0,x1,y1,z1) of the autocrop that could be performed  on
       the latest of           the selected images.
               Default value: 'auto'

           base642img:
               "base64_string"

               Decode  given  base64-encoded  string  as a newly inserted image at the end of the
       list.
               The argument string must have been generated using command 'img2base64'.

           base642uchar:
               "base64_string"

               Decode given base64-encoded string as a newly inserted 1-column image at  the  end
       of the list.
               The argument string must have been generated using command 'uchar2base64'.

           basename:
               file_path,_variable_name_for_folder

               Return the basename of a file path, and opt. its folder location.
               When specified 'variable_name_for_folder' must starts by an underscore
               (global variable accessible from calling function).

           bin:
               binary_int1,...

               Print  specified binary integers into their octal, decimal, hexadecimal and string
       representations.

           bin2dec:
               binary_int1,...

               Convert specified binary integers into their decimal representations.

           dec:
               decimal_int1,...

               Print specified decimal integers into their binary, octal, hexadecimal and  string
       representations.

           dec2str:
               decimal_int1,...

               Convert specifial decimal integers into its string representation.

           dec2bin:
               decimal_int1,...

               Convert specified decimal integers into their binary representations.

           dec2hex:
               decimal_int1,...

               Convert specified decimal integers into their hexadecimal representations.

           dec2oct:
               decimal_int1,...

               Convert specified decimal integers into their octal representations.

           fact:
               value

               Return the factorial of the specified value.

           fibonacci:
               N>=0

               Return the Nth number of the Fibonacci sequence.

           file_mv:
               filename_src,filename_dest

               Rename or move a file from a location $1 to another location $2.

           file_rand:

               Return a random filename for storing temporary data.

           file_rm:
               filename

               Delete a file.

           filename:
               filename,_number1,_number2,...,_numberN

               Return a filename numbered with specified indices.

           files (+):
               _mode,path

               Return the list of files and/or subfolders from specified path.
               'path' can be eventually a matching pattern.
               'mode' can be { 0=files only | 1=folders only | 2=files + folders }.
               Add '3' to 'mode' to return full paths instead of filenames only.
               Default value: 'mode=5'.

           fitratio_wh:
               min_width,min_height,ratio_wh

               Return  a  2D  size 'width,height' which is bigger than 'min_width,min_height' and
       has the           specified w/h ratio.

           fitscreen:
               width,height,_depth,_minimal_size[%],_maximal_size[%]

               Return the 'ideal' size WxH for a window intended to display an image of specified
       size on screen.
               Default values: 'depth=1', 'minimal_size=128' and 'maximal_size=85%'.

           fontchart:

               Insert G'MIC font chart at the end of the image list.

           fps:

               Return  the  number of time this function is called per second, or -1 if this info
       is not yet           available.
               Useful to display the framerate when displaying animations.

           gcd:
               a,b

               Return the GCD (greatest common divisor) between a and b.

           hex:
               hexadecimal_int1,...

               Print specified hexadecimal integers into their binary, octal, decimal and  string
       representations.

           hex2dec:
               hexadecimal_int1,...

               Convert specified hexadecimal integers into their decimal representations.

           hex2img:
               "hexadecimal_string"

               Insert  new  image  1xN  at the end of the list with values specified by the given
       hexadecimal-encoded string.

           hex2str:
               hexadecimal_string

               Convert specified hexadecimal string into a string.

           img2hex:

               Return representation of last image as an hexadecimal-encoded string.
               Input image must have values that are integers in [0,255].

           img2str:

               Return the content of the latest of the selected images as a special  G'MIC  input
       string.

           img2text:
               _line_separator

               Return text contained in a multi-line image.
               Default value: 'line_separator= '.

           img82hex:

               Convert  selected  8bits-valued  vectors  into  their  hexadecimal representations
       (ascii-encoded).

           hex2img8:

               Convert selected hexadecimal  representations  (ascii-encoded)  into  8bits-valued
       vectors.

           is_3d:

               Return 1 if all of the selected images are 3D objects, 0 otherwise.

           is_ext:
               filename,_extension

               Return 1 if specified filename has a given extensioin.

           is_image_arg:
               string

               Return 1 if specified string looks like '[ind]'.

           is_pattern:
               string

               Return 1 if specified string looks like a drawing pattern '0x......'.

           is_percent:
               string

               Return 1 if specified string ends with a '%', 0 otherwise.

           is_videofilename:

               Return 1 if extension of specified filename is typical from video files.

           is_windows:

               Return 1 if current computer OS is Windows, 0 otherwise.

           math_lib:

               Return  string  that  defines a set of several useful macros for the embedded math
       evaluator.

           mad:

               Return the MAD (Maximum Absolute Deviation) of the last selected image.
               The MAD is defined as MAD = med_i|x_i-med_j(x_j)|

           max_w:

               Return the maximal width between selected images.

           max_h:

               Return the maximal height between selected images.

           max_d:

               Return the maximal depth between selected images.

           max_s:

               Return the maximal spectrum between selected images.

           max_wh:

               Return the maximal wxh size of selected images.

           max_whd:

               Return the maximal wxhxd size of selected images.

           max_whds:

               Return the maximal wxhxdxs size of selected images.

           med:

               Return the median value of the last selected image.

           median_color:

               Return the median color value of the last selected image.

           min_w:

               Return the minimal width between selected images.

           min_h:

               Return the minimal height between selected images.

           min_d:

               Return the minimal depth between selected images.

           min_s:

               Return the minimal s size of selected images.

           min_wh:

               Return the minimal wxh size of selected images.

           min_whd:

               Return the minimal wxhxd size of selected images.

           min_whds:

               Return the minimal wxhxdxs size of selected images.

           normalize_filename:
               filename

               Return a "normalized" version  of  the  specified  filename,  without  spaces  and
       capital letters.

           oct:
               octal_int1,...

               Print  specified octal integers into their binary, decimal, hexadecimal and string
       representations.

           oct2dec:
               octal_int1,...

               Convert specified octal integers into their decimal representations.

           padint:
               number,_size>0

               Return a integer with 'size' digits (eventually left-padded with '0').

           path_gimp:

               Return a path to store GIMP configuration files for one user (whose value  is  OS-
       dependent).

           path_tmp:

               Return a path to store temporary files (whose value is OS-dependent).

           reset:

               Reset global parameters of the interpreter environment.

           RGB:

               Return a random int-valued RGB color.

           RGBA:

               Return a random int-valued RGBA color.

           std_noise:

               Return the estimated noise standard deviation of the last selected image.

           str:
               string

               Print   specified   string   into  its  binary,  octal,  decimal  and  hexadecimal
       representations.

           str2hex:
               string

               Convert specified string into a sequence of hexadecimal values.

           strcontains:
               string1,string2

               Return 1 if the first string contains the second one.

           strlen:
               string1

               Return the length of specified string argument.

           strreplace:
               string,search,replace

               Search and replace substrings in an input string.

           strlowercase:
               string

               Return a lower-case version of the specified string.

           strvar:
               string

               Return a simplified version of the  specified  string,  that  can  be  used  as  a
       variable name.

           strver:
               _version

               Return the specified version number of the G'MIC interpreter, as a string.
               Default value: 'version=$_version'.

           tic:

               Initialize tic-toc timer.
               Use it in conjunction with 'toc'.

           toc:

               Display elapsed time of the tic-toc timer since the last call to 'tic'.
               This command returns the elapsed time in the status value.
               Use it in conjunction with 'tic'.

           uchar2base64:
               _encoding={ 0=base64 | 1=base64url }

               Encode the values of the latest of the selected images as a base64-encoded string.
               The string can be decoded using command 'base642uchar'.
               Selected images must have values that are integers in [0,255].
               Default values: 'encoding=0'.

           img2base64:
               _encoding={ 0=base64 | 1=base64url }

               Encode selected images as a base64-encoded string.
               The images can be then decoded using command 'base642img'.
               Default values: 'encoding=0'.

           average_colors:

               Return the average vector-value of the latest of the selected images.

           covariance_colors:
               _avg_outvarname

               Return  the  covariance  matrix  of  the vector-valued colors in the latest of the
       selected images           (for arbitrary number of channels).
               Parameter 'avg_outvarname' is used as a variable name that takes the value of  the
       average           vector-value.

        ** Other Interactive Commands:

           demo:
               _run_in_parallel={ 0=no | 1=yes | 2=auto }

               Show a menu to select and view all G'MIC interactive demos.

           x_2048:

               Launch the 2048 game.

           x_blobs:

               Launch the blobs editor.

           x_bouncing:

               Launch the bouncing balls demo.

           x_color_curves:
               _colorspace={ rgb | cmy | cmyk | hsi | hsl | hsv | lab | lch | ycbcr | last }

               Apply color curves on selected RGB[A] images, using an interactive window.
               Set  'colorspace'  to  'last'  to  apply last defined color curves without opening
       interactive windows.
               Default value: 'colorspace=rgb'.

           x_colorize:
               _is_lineart={ 0 | 1 },_max_resolution={ 0 | >=128 },_multichannels_output={ 0 |
                 1 },_[palette1],_[palette2],_[grabber1]

               Colorized selected B&W images, using an interactive window.
               When >0, argument 'max_resolution' defines the maximal image  resolution  used  in
       the interactive window.
               Default        values:       'is_lineart=1',       'max_resolution=1024'       and
       'multichannels_output=0'.

           x_connect4:

               Launch the Connect Four game.

           x_fire:

               Launch the fire effect demo.

           x_fireworks:

               Launch the fireworks demo.

           x_fisheye:

               Launch the fish-eye effect demo.

           x_fourier:

               Launch the fourier filtering demo.

           x_grab_color:
               _variable_name

               Open a color grabber widget from the first selected image.
               Argument 'variable_name' specifies the variable that contains the  selected  color
       values at any time.
               Assigning '-1' to it forces the interactive window to close.
               Default values: 'variable_name=xgc_variable'.

           x_hanoi:

               Launch the Tower of Hanoi game.

           x_histogram:

               Launch the histogram demo.

           x_hough:

               Launch the hough transform demo.

           x_jawbreaker:
               0<_width<20,0<_height<20,0<_balls<=8

               Launch the Jawbreaker game.

           x_landscape:

               Launch the virtual landscape demo.

           x_life:

               Launch the game of life.

           x_light:

               Launch the light effect demo.

           x_mandelbrot:
               _julia={ 0 | 1 },_c0r,_c0i

               Launch Mandelbrot/Julia explorer.

           x_mask_color:
               _colorspace={ all | rgb | lrgb | ycbcr | lab | lch | hsv | hsi | hsl | cmy |
                 cmyk | yiq },_spatial_tolerance>=0,_color_tolerance>=0

               Interactively   select   a   color,  and  add  an  alpha  channel  containing  the
       corresponding color mask.
               Argument  'colorspace'  refers  to  the  color  metric  used  to   compute   color
       similarities, and can be           basically one of { rgb | lrgb | ycbcr | lab | lch | hsv
       | hsi | hsl | cmy | cmyk | yiq }.
               You can also select one one particular channel  of  this  colorspace,  by  setting
       'colorspace' as           'colorspace_channel' (e.g. 'hsv_h' for the hue).
               Default values: 'colorspace=all', 'spatial_tolerance=5' and 'color_tolerance=5'.

           x_metaballs3d:

               Launch the 3D metaballs demo.

           x_minesweeper:
               8<=_width=<20,8<=_height<=20

               Launch the Minesweeper game.

           x_minimal_path:

               Launch the minimal path demo.

           x_pacman:

               Launch pacman game.

           x_paint:

               Launch the interactive painter.

           x_plasma:

               Launch the plasma effect demo.

           x_quantize_rgb:
               _nbcolors>=2

               Launch the RGB color quantization demo.

           x_reflection3d:

               Launch the 3D reflection demo.

           x_rubber3d:

               Launch the 3D rubber object demo.

           x_segment:
               _max_resolution={ 0 | >=128 }

               Segment foreground from background in selected opaque RGB images, interactively.
               Return RGBA images with binary alpha-channels.
               Default value: 'max_resolution=1024'.

           x_select_color:
               _variable_name

               Display a RGB or RGBA color selector.
               Argument  'variable_name'  specifies the variable that contains the selected color
       values (as R,G,          B,[A]) at any time.
               Its value specifies the initial selected color. Assigning '-1' to  it  forces  the
       interactive           window to close.
               Default value: 'variable_name=xsc_variable'.

           x_select_function1d:
               _variable_name,_background_curve_R,_background_curve_G,_background_curve_B

               Open an interactive window, where the user can defined its own 1D function.
               If an image is selected, it is used to display additional information :
               -  The  first row defines the values of a background curve displayed on the window
       (e.g. an           histogram).
               - The 2nd, 3rd and 4th rows define the R,G,B color components displayed beside the
       X and Y axes.
               Argument  'variable_name'  specifies  the  variable  that  contains  the  selected
       function keypoints           at any time.
               Assigning '-1' to it forces the interactive window to close.
               Default    values:     'variable_name=xsf_variable',     'background_curve_R=220',
       'background_curve_G=background_curve_B=background_curve_T'.

           x_select_palette:
               _variable_name,_number_of_columns={ 0=auto | >0 }

               Open a RGB or RGBA color selector widget from a palette.
               The palette is given as a selected image.
               Argument  'variable_name'  specifies the variable that contains the selected color
       values (as R,G,          B,[A]) at any time.
               Assigning '-1' to it forces the interactive window to close.
               Default values: 'variable_name=xsp_variable' and 'number_of_columns=2'.

           x_shadebobs:

               Launch the shade bobs demo.

           x_spline:

               Launch spline curve editor.

           x_starfield3d:

               Launch the 3D starfield demo.

           x_tetris:

               Launch tetris game.

           x_tictactoe:

               Launch tic-tac-toe game.

           x_waves:

               Launch the image waves demo.

           x_whirl:
               _opacity>=0

               Launch the fractal whirls demo.
               Default values: 'opacity=0.2'.

        **** Command shortcuts:

           h : eq. to 'help'.
           m  (+): eq. to 'command'.
           d  (+): eq. to 'display'.
           d0 : eq. to 'display0'.
           d3d  (+): eq. to 'display3d'.
           da : eq. to 'display_array'.
           dfft : eq. to 'display_fft'.
           dg : eq. to 'display_graph'.
           dh : eq. to 'display_histogram'.
           dp : eq. to 'display_parallel'.
           dp0 : eq. to 'display_parallel0'.
           dq : eq. to 'display_quiver'.
           drgba : eq. to 'display_rgba'.
           dt : eq. to 'display_tensors'.
           dw : eq. to 'display_warp'.
           e  (+): eq. to 'echo'.
           i  (+): eq. to 'input'.
           ig : eq. to 'input_glob'.
           o  (+): eq. to 'output'.
           on : eq. to 'outputn'.
           op : eq. to 'outputp'.
           ow : eq. to 'outputw'.
           ox : eq. to 'outputx'.
           p  (+): eq. to 'print'.
           sh  (+): eq. to 'shared'.
           sp : eq. to 'sample'.
           up : eq. to 'update'.
           v  (+): eq. to 'verbose'.
           w  (+): eq. to 'window'.
           k  (+): eq. to 'keep'.
           mv  (+): eq. to 'move'.
           nm  (+): eq. to 'name'.
           rm  (+): eq. to 'remove'.
           rv  (+): eq. to 'reverse'.
           +  (+): eq. to 'add'.
           &  (+): eq. to 'and'.
           <<  (+): eq. to 'bsl'.
           >>  (+): eq. to 'bsr'.
           /  (+): eq. to 'div'.
           ==  (+): eq. to 'eq'.
           >=  (+): eq. to 'ge'.
           >  (+): eq. to 'gt'.
           <=  (+): eq. to 'le'.
           <  (+): eq. to 'lt'.
           m/  (+): eq. to 'mdiv'.
           %  (+): eq. to 'mod'.
           m*  (+): eq. to 'mmul'.
           *  (+): eq. to 'mul'.
           !=  (+): eq. to 'neq'.
           |  (+): eq. to 'or'.
           ^  (+): eq. to 'pow'.
           -  (+): eq. to 'sub'.
           c  (+): eq. to 'cut'.
           f  (+): eq. to 'fill'.
           ir : eq. to 'inrange'.
           n  (+): eq. to 'normalize'.
           =  (+): eq. to 'set'.
           ac : eq. to 'apply_channels'.
           fc : eq. to 'fill_color'.
           a  (+): eq. to 'append'.
           z  (+): eq. to 'crop'.
           r  (+): eq. to 'resize'.
           rr2d : eq. to 'resize_ratio2d'.
           r2dx : eq. to 'resize2dx'.
           r2dy : eq. to 'resize2dy'.
           r3dx : eq. to 'resize3dx'.
           r3dy : eq. to 'resize3dy'.
           r3dz : eq. to 'resize3dz'.
           s  (+): eq. to 'split'.
           y  (+): eq. to 'unroll'.
           b  (+): eq. to 'blur'.
           g  (+): eq. to 'gradient'.
           j  (+): eq. to 'image'.
           j3d  (+): eq. to 'object3d'.
           t  (+): eq. to 'text'.
           to : eq. to 'text_outline'.
           +3d  (+): eq. to 'add3d'.
           c3d : eq. to 'center3d'.
           col3d  (+): eq. to 'color3d'.
           /3d  (+): eq. to 'div3d'.
           db3d  (+): eq. to 'double3d'.
           f3d  (+): eq. to 'focale3d'.
           l3d  (+): eq. to 'light3d'.
           m3d  (+): eq. to 'mode3d'.
           md3d  (+): eq. to 'moded3d'.
           *3d  (+): eq. to 'mul3d'.
           n3d : eq. to 'normalize3d'.
           o3d  (+): eq. to 'opacity3d'.
           p3d  (+): eq. to 'primitives3d'.
           rv3d  (+): eq. to 'reverse3d'.
           r3d  (+): eq. to 'rotate3d'.
           sl3d  (+): eq. to 'specl3d'.
           ss3d  (+): eq. to 'specs3d'.
           s3d  (+): eq. to 'split3d'.
           -3d  (+): eq. to 'sub3d'.
           t3d : eq. to 'texturize3d'.
           ap : eq. to 'apply_parallel'.
           apc : eq. to 'apply_parallel_channels'.
           apo : eq. to 'apply_parallel_overlap'.
           at : eq. to 'apply_tiles'.
           fi  (+): eq. to 'endif'.
           endl  (+): eq. to 'endlocal'.
           x  (+): eq. to 'exec'.
           l  (+): eq. to 'local'.
           q  (+): eq. to 'quit'.
           u  (+): eq. to 'status'.
           frame : eq. to 'frame_xy'.

          [ Total number of commands: 982 ]

        13. Examples of use
            ---------------

        'gmic' is a generic image processing tool  which  can  be  used  in  a  wide  variety  of
       situations.
        The few examples below illustrate possible uses of this tool:

         - View a list of images:
            gmic file1.bmp file2.jpeg

         - Convert an image file:
            gmic input.bmp output output.jpg

         - Create a volumetric image from a movie sequence:
            gmic input.mpg append z output output.hdr

         - Compute image gradient norm:
            gmic input.bmp gradient_norm

         - Denoise a color image:
            gmic image.jpg denoise 30,10 output denoised.jpg

         - Compose two images using overlay layer blending:
            gmic image1.jpg image2.jpg blend overlay output blended.jpg

         - Evaluate a mathematical expression:
            gmic echo "cos(pi/4)^2+sin(pi/4)^2={cos(pi/4)^2+sin(pi/4)^2}"

         - Plot a 2D function:
            gmic 1000,1,1,2 fill "X=3*(x-500)/500;X^2*sin(3*X^2)+if(c==0,u(0,-1),cos(X*10))" plot

         - Plot a 3D elevated function in random colors:
            gmic 128,128,1,3,"u(0,255)" plasma 10,3 blur 4 sharpen 10000 \
             elevation3d[-1] "'X=(x-64)/6;Y=(y-64)/6;100*exp(-(X^2+Y^2)/30)*abs(cos(X)*sin(Y))'"

         - Plot the isosurface of a 3D volume:
            gmic       mode3d       5       moded3d      5      double3d      0      isosurface3d
       "'x^2+y^2+abs(z)^abs(4*cos(x*y*z*3))'",3

         - Render a G'MIC 3D logo:
            gmic 0 text G\'MIC,0,0,53,1,1,1,1 expand_xy 10,0 blur 1 normalize 0,100  +plasma  0.4
       add \
             blur 1 elevation3d -0.1 moded3d 4

         - Generate a 3D ring of torii:
            gmic repeat 20 torus3d 15,2 color3d[-1] "{u(60,255)},{u(60,255)},{u(60,255)}" \
             *3d[-1] 0.5,1 if "{$>%2}" rotate3d[-1] 0,1,0,90 fi add3d[-1] 70 add3d \
             rotate3d 0,0,1,18 done moded3d 3 mode3d 5 double3d 0

         - Create a vase from a 3D isosurface:
            gmic moded3d 4 isosurface3d "'x^2+2*abs(y/2)*sin(2*y)^2+z^2-3',0" sphere3d 1.5 \
             sub3d[-1] 0,5 plane3d 15,15 rotate3d[-1] 1,0,0,90 center3d[-1] add3d[-1] 0,3.2 \
             color3d[-1] 180,150,255 color3d[-2] 128,255,0 color3d[-3] 255,128,0 add3d

         - Display filtered webcam stream:
            gmic apply_camera \"+mirror x +mirror y add div 4\"

         - Launch a set of G'MIC interactive demos:
            gmic demo

        ** G'MIC comes with ABSOLUTELY NO WARRANTY; for details visit: https://gmic.eu **

                                                                                         G'MIC(1)