manpagez: man pages & more
man gmic(1)
Home | html | info | man
G'MIC(1)                                                              G'MIC(1)




NAME

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



HELP

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

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

         1. Usage
            -----

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

         'gmic' is the open-source interpreter of the G'MIC language, a
          script-based  programming language dedicated to the design of possi-
       bly complex
          image processing pipelines and operators.
         It can be used to convert, manipulate,  filter  and  visualize  image
       datasets made
          of one or several 1D/2D or 3D multi-spectral images.

         This  reference  documentation describes all the technical aspects of
       the G'MIC
          framework, in its current version 2.9.7.

         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  (uncom-
       pressed).
          * The first image of the list has index '0' and is denoted by
          '[0]'. The second image of the list is denoted by '[1]', the third
          by '[2]' and so on.
          *  Negative  indices are treated in a periodic way: '[-1]' refers to
       the
          last image of the list, '[-2]' to the penultimate one, etc. Thus, if
       the
          list has 4 images, '[1]' and '[-3]' both designate the second image
          of the list.
          * A named image may be also indicated by '[name]', if 'name' uses
          the  character  set '[a-zA-Z0-9_]' and does not start with a number.
       Image
          names can be set or reassigned at any moment during  the  processing
       pipeline
          (see command name for this purpose).
          *  G'MIC  defines  a set of various commands and substitution mecha-
       nisms to allow
          the design of complex pipelines and operators managing this list  of
       images, in
          a  very  flexible  way: You can insert or remove images in the list,
       rearrange
          image order, process images (individually or grouped),  merge  image
       data
          together, display and output image files, etc.
          * Such a pipeline can define a new custom G'MIC command (stored in a
       user
          command file), and re-used afterwards as a  regular  command,  in  a
       larger
          pipeline if necessary.


         3. Image Definition and Terminology
            --------------------------------

          *  In  G'MIC,  each  image is modeled as a 1D, 2D, 3D or 4D array of
       scalar
          values,  uniformly  discretized  on  a  rectangular/parallelepipedic
       domain.
          * The four dimensions of this array are respectively denoted by:
            -  'width', the number of image columns (size along the
          'x-axis').
            -  'height', the number of image rows (size along the 'y-axis').
            -  'depth', the number of image slices (size along the
          'z-axis'). The depth is equal to '1' for usual color or grayscale
          2D images.
            -  'spectrum', the number of image channels (size along the
          'c-axis'). The spectrum is respectively equal to '3' and '4'
          for usual 'RGB' and 'RGBA' color images.

          *  There are no hard limitations on the size of the image along each
       dimension.
          For instance, the number of image slices or channels can be of arbi-
       trary 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 spa-
       tial
          '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 process-
       ing
          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 dif-
       ferent 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 selec-
       tions).
            -        'width[%],_height[%],_depth[%],_spectrum[%],_values[xN]':
       Insert
          one  or  N  images  with  specified size and values (adding '%' to a
       dimension
          means "percentage of the size along the same axis", taken  from  the
       last
          image '[-1]'). Any specified dimension can be also written as
          '[image]', and is then set to the size (along the same axis) of the
          existing specified image '[image]'. 'values' can be either a
          sequence  of  numbers  separated  by  commas  ',', or a mathematical
       expression,
           as e.g. in input item '256,256,1,3,[x,y,128]' which creates a
          '256x256' RGB color image with a spatial  shading  on  the  red  and
       green
          channels. (see section Mathematical Expressions to learn more about
          mathematical expressions).
            -  '(v1,v2,..)[xN]': Insert one or 'N' new images from specified
          prescribed  values.  Value  separator  inside parentheses can be ','
       (column
          separator), ';' (row separator), '/' (slice separator) or '^'
          (channel separator). For instance, expression '(1,2,3;4,5,6;7,8,9)'
          creates a 33 matrix (scalar image), with values running from  1  to
       9.
            -  '('string'[:delimiter])[xN]': Insert one or N new images from
          specified  string,  by  filling  the images with the character codes
       composing the
          string. When specified, 'delimiter' tells about the main orientation
       of
          the image. Delimiter can be 'x' (eq. to ',' which is the default),
          'y' (eq. to ';'), 'z' (eq. to '/') or 'c' (eq. to
          '^'). When specified delimiter is ',', ';', '/' or
          '^', the expression is actually equivalent to
          '({'string'[:delimiter]})[xN]' (see section Substitution Rules for
          more information on the syntax).
            -  '0[xN]': Insert one or N new 'empty' images, containing no
          pixel data. Empty images are used only in rare occasions.

          * Input item 'name=value' declares a new variable 'name', or
          assign  a  new  string value to an existing variable. Variable names
       must use the
          character set '[a-zA-Z0-9_]' and cannot start with a number.
          * A variable definition is  always  local  to  the  current  command
       except when it
          starts  by  the  underscore  character '_'. In that case, it becomes
       also
          accessible by any command invoked outside the current command  scope
       (global
          variable).
          * 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).  Other-
       wise,
          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. '+=').
          * Variables usually store numbers or strings. Use command store to
          assign variables from image data (and syntax  'input  $variable'  to
       bring
          them back on the image list afterwards).


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

          * A G'MIC item that is not a filename nor a special input string
          designates a 'command' most of the time. Generally, commands perform
          image processing operations on one or several  available  images  of
       the list.
          * Reccurent commands have two equivalent names ('regular' and
          'short'). For instance, command names 'resize' and 'r' refer
          to the same image resizing action.
          * A G'MIC command may have mandatory or optional arguments. Command
          arguments  must  be  specified in the next item on the command line.
       Commas ',
          ' are used to separate multiple arguments of a single command,  when
       required.
          *  The execution of a G'MIC command may be restricted only to a sub-
       set 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-9:25%]': Apply command only on images '[0]' to
          '[9]', with a step of 25% (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 sin-
       gle
          command multiple times  on  an  image,  use  a  'repeat..done'  loop
       instead.
          Inverting  the  order of images for a command is achieved by explic-
       itly inverting
          the order of the images in the list,  with  command  'reverse[selec-
       tion]'.
          * Command selections '[-1]', '[-2]' and '[-3]' are so often
          used they have their own shortcuts, respectively '.', '..' and
          '...'. For instance, command 'blur..' is equivalent to
          'blur[-2]'.  These shortcuts work also when specifying command argu-
       ments.
          * G'MIC commands invoked without '[selection]' are  applied  on  all
       images
          of the list, i.e. the default selection is '[0--1]' (except for com-
       mand
          input whose default selection is '[-1]'').
          * Prepending a single hyphen '-' to a G'MIC command is allowed. This
       may
          be  useful  to  recognize  command  items more easily in a one-liner
       pipeline
          (typically invoked from a shell).
          * A G'MIC command prepended with a plus sign '+' does not act
          in-place but inserts its result as one or several new images at  the
       end
          of the image list.
          *  There  are two different types of commands that can be run by the
       G'MIC
          interpreter:
            -  Built-in commands are the hard-coded functionalities in the
          interpreter core. They are thus compiled  as  binary  code  and  run
       fast, most of
          the  time.  Omitting an argument when invoking a built-in command is
       not
          permitted, except if all following arguments are also  omitted.  For
       instance,
          invoking 'plasma 10,,5' is invalid but 'plasma 10' is correct.
            -  Custom commands, are defined as G'MIC pipelines of built-in or
          other custom commands. They are parsed by the G'MIC interpreter, and
       thus run a
          bit slower than built-in commands. Omitting arguments when  invoking
       a custom
          command  is  permitted. For instance, expressions 'flower ,,,100,,2'
       or
          'flower ,' are correct.

          * Most of the existing commands in G'MIC  are  actually  defined  as
       custom
          commands.
          *  A user can easily add its own custom commands to the G'MIC inter-
       preter (see
          section  Adding Custom Commands for more details). New built-in com-
       mands
          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  for-
       mats,
          including:
            -  2D grayscale/color files: '.png', '.jpeg', '.gif',
          '.pnm', '.tif', '.bmp', ...
            -  3D volumetric files: '.dcm', '.hdr', '.nii',
          '.cube', '.pan', '.inr', '.pnk', ...
            -  Video files: '.mpeg', '.avi', '.mp4', '.mov',
          '.ogg', '.flv', ...
            -  Generic text or binary data files: '.gmz', '.cimg',
          '.cimgz', 'flo', 'ggr', 'gpl', '.dlm',
          '.asc', '.pfm', '.raw', '.txt', '.h'.
            -  3D mesh files: '.off', '.obj' (output only)

          *  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 preci-
       sion is
          preserved when saving images.
          * Sometimes, file options may/must be set for file formats:
            -  Video files: Only  sub-frames  of  an  image  sequence  may  be
       loaded,
          using the input expression 'filename.ext,[first_frame[,last_frame[,
          step]]]'. Set 'last_frame==-1' to tell it must be the last frame of
          the video. Set 'step' to '0' to force an opened video file to be
          opened/closed.  Output  framerate and codec can be also set by using
       the output
          expression 'filename.avi,_fps,_codec,_keep_open' where 'keep_open'
          can be { 0 | 1 }. 'codec' is a 4-char string (see
          http://www.fourcc.org/codecs.php ) or '0' for the default codec.
          'keep_open' tells if the output video file must be kept open for
          appending new frames afterwards.
            -  '.cimg[z]' files: Only crops and sub-images of .cimg files
          can be loaded, using the input expressions 'filename.cimg,N0,N1',
          'filename.cimg,N0,N1,x0,x1', 'filename.cimg,N0,N1,x0,y0,x1,y1',
          'filename.cimg,N0,N1,x0,y0,z0,x1,y1,z1'          or           'file-
       name.cimg,N0,N1,x0,y0,
          z0,c0,x1,y1,z1,c1'.  Specifying  '-1' for one coordinates stands for
       the
          maximum     possible     value.     Output     expression     'file-
       name.cimg[z][,datatype]'
          can be used to force the output pixel type. 'datatype' can be { auto
       |
          bool | 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_subsam-
       pling[,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     'file-
       name.tif,_first_frame,_last_frame,
          _step'. Output expression 'filename.tiff,_datatype,_compression,
          _force_multipage,_use_bigtiff' can be used  to  specify  the  output
       pixel type,
          as well as the compression method. 'datatype' can be the same as for
          '.cimg[z]' files. 'compression' can be  { none (default) | lzw |
          jpeg }. 'force_multipage' can be { 0=no (default) | 1=yes }.
          'use_bigtiff' can be { 0=no | 1=yes (default) }.
            -  '.pdf' files: When loading a file, the rendering resolution
          can be specified using the  input  expression  'filename.pdf,resolu-
       tion',
          where 'resolution' is an unsigned integer value.
            -  '.gif' files: Animated gif files can be saved, using the
          input expression 'filename.gif,fps>0,nb_loops'. Specify
          'nb_loops=0'  to  get an infinite number of animation loops (this is
       the
          default behavior).
            -  '.jpeg' files: The output quality may be specified (in %),
          using the output expression 'filename.jpg,30' (here, to  get  a  30%
       quality
          output). '100' is the default.
            -  '.mnc' files: The output header can set from another file,
          using the output expression 'filename.mnc,header_template.mnc'.
            -  '.pan', '.cpp', '.hpp', '.c' and '.h'
          files: The output datatype can be selected with output expression
          'filename[,datatype]'. 'datatype' can be the same as for
          '.cimg[z]' files.
            -  '.gmic' files: These filenames are assumed to be G'MIC custom
          commands files. Loading such a file will add the commands it defines
       to the
          interpreter. Debug information can be enabled/disabled by the  input
       expression
          'filename.gmic[,add_debug_info' where 'debug_info' can be {
          0=false | 1=true }.
            -  Inserting 'ext:' on the beginning of a filename (e.g.
          'jpg:filename') forces G'MIC to read/write the file as it would have
       been
          done if it had the specified extension '.ext'.

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


         8. Substitution Rules
            ------------------

          * G'MIC items containing '$' or '{}' are substituted before
          being interpreted. Use these substituting expressions to access var-
       ious 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  substi-
       tuted by the
          highest  positive index of the named image '[name]'. If no image has
       this
          name, the expression is substituted by the value of the OS  environ-
       ment variable
          with  same  name  (it  may  be  thus  an  empty  string if it is not
       defined).
          * The following reserved  variables  are  predefined  by  the  G'MIC
       interpreter:
            -  '$!': The current number of images in the list.
            -  '$>' and '$<': The increasing/decreasing index of the latest
          (currently running) 'repeat...done' loop. '$>' goes from '0'
          (first loop iteration) to 'nb_iterations - 1' (last iteration).
          '$<' does the opposite.
            -   '$/':  The  current  call  stack. Stack items are separated by
       slashes
          '/'.
            -  '$|': The current value (expressed in seconds) of a millisecond
          precision timer.
            -  '$^': The current verbosity level.
            -   '$_cpus':  The  number  of computation cores available on your
       machine.
            -  '$_flags': The list of enabled flags when G'MIC interpreter has
          been compiled.
            -  '$_host': A string telling about the host running the G'MIC
          interpreter (e.g. 'cli' or 'gimp').
            -  '$_os': A string describing the running operating system.
            -  '$_path_rc': The path to the G'MIC folder used to store
          configuration files (its value is OS-dependent).
            -  '$_path_user': The path to the G'MIC user file '.gmic' or
          'user.gmic' (its value is OS-dependent).
            -  '$_path_commands': A list of all imported command files (stored
       as
          a list-valued variable).
            -  '$_pid': The current process identifier, as an integer.
            -  '$_pixeltype': The type of image pixels (default: 'float').
            -  '$_prerelease': For pre-releases, the date of  the  pre-release
       as
          'yymmdd'. For stable releases, this variable is set to '0'.
            -   '$_version':  A 3-digits number telling about the current ver-
       sion of
          the G'MIC interpreter  (e.g. '297').
            -  '$_vt100': Set to '1' if colored text output is allowed on
          the console. Otherwise, set to '0'.

          * '$$name' and '$${name}' are both substituted by the G'MIC script
          code of the specified named 'custom command', or by an empty  string
       if no
          custom command with specified name exists.
          * '${"-pipeline"}' is substituted by the status value after the
          execution of the specified G'MIC pipeline (see command status).
          Expression '${}' thus stands for the current status value.
          * '{``string}' (starting with two backquotes) is substituted by a
          double-quoted version of the specified string.
          * '{/string}' is substituted by the escaped version of the specified
          string.
          * '{'string'[:delimiter]}' (between single quotes) is substituted by
       the
          sequence of character codes that composes the specified string, sep-
       arated by
          specified delimiter. Possible delimiters are ',' (default), ';',
          '/', '^' or ' '. For instance, item '{'foo'}' is substituted
          by '102,111,111' and '{'foo':;}' by '102;111;111'.
          * '{image,feature[:delimiter]}' is substituted by a specific feature
       of
          the image '[image]'. 'image' can be either an image number or an
          image  name.  It  can  be also eluded, in which case, the last image
       '[-1]'
          of the list is considered for the requested feature. Specified 'fea-
       ture'
          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 charac-
       ter
          codes.
            -  'x': The image extension (i.e the characters after the last
          '.' in the image name).
            -  '^': The sequence of all image values, separated by commas ',
          '.
            -  '@subset': The sequence of image values corresponding to the
          specified subset, and separated by commas ','.
            -  Any other 'feature' is considered as a mathematical
          expression associated to the image '[image]' and is  substituted  by
       the
          result  of  its  evaluation  (float value). For instance, expression
       '{0,
          w+h}' is substituted by the sum of the width and height of the first
       image
          (see section Mathematical Expressions for more details). If a
          mathematical expression starts with an underscore '_', the resulting
          value is truncated to a readable format. For instance, item  '{_pi}'
       is
          substituted by '3.14159' (while '{pi}' is substituted by
          '3.141592653589793').
            -   A  'feature'  delimited  by backquotes is replaced by a string
       whose
          character codes correspond to the list of values resulting from  the
       evaluation
          of   the  specified  mathematical  expression.  For  instance,  item
       '{`[102,111,
          111]`}' is substituted by 'foo' and item '{`vector8(65)`}' by
          'AAAAAAAA'.

          * '{*}' is substituted by the visibility state of the  instant  dis-
       play
          window '#0' (can be { 0=closed | 1=visible }.
          * '{*[index],feature1,...,featureN[:delimiter]}' is substituted by a
          specific set of features of the instant display window '#0' (or
          '#index', if specified). Requested 'features' can be:
            -  'w': display width (i.e. width of the display area  managed  by
       the
          window).
            -  'h': display height (i.e. height of the display area managed by
       the
          window).
            -  'wh': display width x display height.
            -  'd': window width (i.e. width of the window widget).
            -  'e': window height (i.e. height of the window widget).
            -  'de': window width x window height.
            -  'u': screen width (actually independent on the window size).
            -  'v': screen height (actually independent on the window size).
            -  'uv': screen width x screen height.
            -  'n': current normalization type of the instant display.
            -  't': window title of the instant display.
            -  'x': X-coordinate of the mouse position (or -1, if outside the
          display area).
            -  'y': Y-coordinate of the mouse position (or -1, if outside the
          display area).
            -  'b': state of the mouse buttons { 1=left-but. | 2=right-but. |
          4=middle-but. }.
            -  'o': state of the mouse wheel.
            -  'k': decimal code of the pressed key if any, 0 otherwise.
            -  'c': boolean (0 or 1) telling if the instant display has been
          closed recently.
            -  'r': boolean telling if the instant display has been resized
          recently.
            -  'm': boolean telling if the  instant  display  has  been  moved
       recently.
            -   Any other 'feature' stands for a keycode name (in capital let-
       ters),
          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  dis-
       able the
          substitutions mechanism in items, when necessary.
          *  One  can also disable the substitution mechanism on items outside
       double
          quotes, by escaping the '{', '}' or '$' characters, as in
          '3+4 doesn't evaluate'.


         9. Mathematical Expressions
            ------------------------

          * G'MIC has an embedded mathematical parser, used to evaluate
          (possibly complex) math expressions specified inside braces '{}', or
          formulas in commands that may take one as an argument (e.g. fill or
          eval).
          *  When the context allows it, a formula is evaluated for each pixel
       of
          the selected images (e.g. fill or eval).
          * A math expression may return a scalar or a vector-valued result
          (with a fixed number of components).
         The mathematical parser understands the following set  of  functions,
       operators
          and variables:

         ## Usual operators:

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

         ## Usual math functions:

         'abs()', 'acos()', 'acosh()', 'arg()', 'arg0()',
          'argkth()', 'argmax()', 'argmaxabs()', 'argmin()',
          'argminabs()', 'asin()', 'asinh()', 'atan()',
          'atan2()', 'atanh()', 'avg()', 'bool()', 'cbrt()',
           'ceil()', 'cos()', 'cosh()', 'cut()', 'exp()',
          'fact()', 'fibo()', 'floor()', 'gauss()', 'gcd()',
           'int()', 'isnan()', 'isnum()', 'isinf()',
          'isint()', 'isbool()', 'isexpr()', 'isfile()',
          'isdir()', 'isin()', 'kth()', 'log()', 'log2()',
          'log10()', 'max()', 'maxabs()', 'med()', 'min()',
          'minabs()', '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 'i'-th argument 'a_i'.
          * 'isnum()', 'isnan()', 'isinf()', 'isint()',
          'isbool()' test the type of the  given  number  or  expression,  and
       return
          '0' (false) or '1' (true).
          * 'isfile('path')' (resp. 'isdir('path')') returns '0'
          (false) or '1' (true) whether its string argument is a path to an
          existing file (resp. to a directory) or not.
          * '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'.
          * 'inrange(value,m,M,include_m,include_M)' returns '0' (false) or
          '1' (true) whether the specified value lies in range '[m,M]' or not
          ('include_m' and 'includeM' tells how boundaries 'm' and
          'M' are considered).
          * 'argkth()', 'argmin()', 'argmax()', 'argminabs()',
          'argmaxabs()'', 'avg()', 'kth()', 'min()',
          'max()', 'minabs()', 'maxabs()', 'med()',
          'prod()', 'std()', 'sum()' and 'var()' can be called
          with an arbitrary number of scalar/vector arguments.
          * 'vargkth()', 'vargmin()', 'vargmax()',
          'vargminabs()', 'vargmaxabs()', 'vavg()', 'vkth()',
          'vmin()', 'vmax()', 'vminabs()', 'vmaxabs()',
          'vmed()', 'vprod()', 'vstd()', 'vsum()' and
          'vvar()'  are the versions of the previous function with vector-val-
       ued
          arguments.
          * 'round(value,rounding_value,direction)' returns a rounded value.
          'direction' can be { -1=to-lowest | 0=to-nearest | 1=to-highest }.
          * 'lerp(a,b,t)' returns 'a(1-t) + bt'.
          * 'swap(a,b)' swaps the values of the given arguments.

         ## Variable names:

         Variable names below are pre-defined. They can be overridden.
          * 'l': length of the associated list of images.
          * 'k': index of the associated image, in '[0,l-1]'.
          * 'w': width of the associated image, if any ('0' otherwise).
          * 'h': height of the associated image, if any ('0' otherwise).
          * 'd': depth of the associated image, if any ('0' otherwise).
          * 's': spectrum of the associated image, if any ('0' otherwise).
          * 'r': shared state of the associated image, if any ('0'
          otherwise).
          * 'wh': shortcut for width x height.
          * 'whd': shortcut for width x height x depth.
          * 'whds': shortcut for width x height x depth x spectrum (i.e.  num-
       ber of
          image values).
          * 'im', 'iM', 'ia', 'iv', 'is', 'ip',
          'ic', 'in': Respectively the minimum, maximum, average, variance,
          sum,  product,  median value and L2-norm of the associated image, if
       any
          ('0' otherwise).
          * 'xm', 'ym', 'zm', 'cm': The pixel coordinates of the
          minimum value in the associated image, if any ('0' otherwise).
          * 'xM', 'yM', 'zM', 'cM': The pixel coordinates of the
          maximum value in the associated image, if any ('0' otherwise).
          * All these variables are considered as constant values by the math
          parser (for optimization purposes) which is indeed the case most  of
       the time.
          Anyway, this might not be the case, if function 'resize(#ind,..)' is
       used
          in the math expression. If so,  it  is  safer  to  invoke  functions
       'l()',
          'w(_#ind)', 'h(_#ind)', ... 's(_#ind)' and 'in(_#ind)'
          instead of the corresponding named variables.
          * 'i': current processed pixel value (i.e. value located at '(x,y,z,
          c)') in the associated image, if any ('0' otherwise).
          * 'iN': N-th channel value of current processed pixel (i.e. value
          located at '(x,y,z,N)' in the associated image, if any ('0'
          otherwise). 'N' must be an integer in range '[0,9]'.
          * 'R', 'G', 'B' and 'A' are equivalent to 'i0',
          'i1', 'i2' and 'i3' respectively.
          * 'I': current  vector-valued  processed  pixel  in  the  associated
       image, if
          any ('0' otherwise). The number of vector components is equal to the
          number of image channels (e.g. 'I' = '[ R,G,B ]' for a 'RGB'
          image).
          * You may add '#ind' to any of the variable name above  to  retrieve
       the
          information  for  any  numbered image '[ind]' of the list (when this
       makes
          sense). For instance 'ia#0' denotes the average value of  the  first
       image
          of the list).
          * 'x': current processed column of the associated image, if any
          ('0' otherwise).
          * 'y': current processed row of the associated image, if any ('0'
          otherwise).
          * 'z': current processed slice of the associated image, if any
          ('0' otherwise).
          * 'c': current processed channel of the associated image, if any
          ('0' otherwise).
          *  't':  thread  id  when  an  expression is evaluated with multiple
       threads
          ('0' means master thread).
          * '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-1]' defines a 'N'-dimensional vector with scalar
          coefficients 'ak'.
          * 'vectorN(a0,a1,,...,aN-1)' does the same, with the 'ak' being
          repeated periodically if only a few are specified.
          * 'vector(#N,a0,a1,,...,aN-1)' does the same, and can  be  used  for
       any
          constant expression 'N'.
          * In previous expressions, the 'ak' can be vectors themselves, to be
          concatenated into a single vector.
          * The scalar element 'ak' of a vector 'X' is retrieved by
          'X[k]'.
          * The sub-vector '[X[p],X[p+s]...X[p+s*(q-1)]]' (of size 'q') of a
          vector 'X' is retrieved by 'X[p,q,s]'.
          * 'expr(formula,_w,_h,_d,_s)' outputs a vector of size 'w*h*d*s'
          with values generated from the specified formula,  as  if  one  were
       filling an
          image with dimensions '(w,h,d,s)'.
          *  Equality/inequality  comparisons between two vectors is done with
       operators
          '==' and '!='.
          * Some vector-specific functions  can  be  used  on  vector  values:
       'cross(X,
          Y)' (cross product), 'dot(X,Y)' (dot product), 'size(X)' (vector
          dimension), 'sort(X,_is_increasing,_nb_elts,_size_elt)' (sorted val-
       ues),
          '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 calculated.
          *   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=near-
       est
          | 2=average | 3=linear | 4=grid | 5=bicubic | 6=lanczos }, and
          'boundary_conditions'  can be { 0=dirichlet | 1=neumann | 2=periodic
       |
          3=mirror }.
          *  Function  'find(A,B,_starting_index,_search_step)'  returns   the
       index
          where sub-vector 'B' appears in vector 'A', (or '-1' if
          'B' is not contained in 'A'). Argument 'A' can be also
          replaced by an image index '#ind'.
          *  A '2'-dimensional vector may be seen as a complex number and used
       in
          those particular functions/operators: '**' (complex multiplication),
          '//' (complex division), '^^' (complex exponentiation), '**='
          (complex self-multiplication), '//=' (complex self-division), '^^='
          (complex self-exponentiation), 'cabs()' (complex modulus), 'carg()'
          (complex argument), 'cconj()' (complex conjugate), 'cexp()'
          (complex exponential), 'clog()' (complex logarithm),  'ccos()'
          (complex cosine), 'csin()' (complex sine), 'ctan()' (complex
          tangent), 'ccosh()' (complex hyperpolic cosine), 'csinh()' (complex
          hyperbolic sine) and 'ctanh()' (complex hyperbolic tangent).
          * 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/eigenvec-
       tors),
          'eye(n)' (n x n identity matrix), 'invert(A,_solver)' (matrix
          inverse), 'mul(A,B,_nb_colsB)' (matrix-matrix multiplication),
          'pseudoinvert(A,_nb_colsA,_solver)', 'rot(u,v,w,angle)' (3D
          rotation matrix), 'rot(angle)' (2D rotation matrix), 'solve(A,B,
          _nb_colsB)' (solver of linear system A.X = B), 'svd(A,_nb_colsA)'
          (singular value decomposition), 'trace(A)' (matrix trace) and
          'transpose(A,nb_colsA)' (matrix transpose). Argument 'nb_colsB' may
          be omitted if it is equal to '1'.
          *        'mproj(S,nb_colsS,D,nb_colsD,method,max_iter,max_residual)'
       projects a
          matrix 'S' onto a dictionary (matrix) 'D'. Equivalent to command
          mproj but inside the math evaluator.
          *  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.  Dedi-
       cated
          functions and initializers to manage strings are:
          * '['string']' and ''string'' define a vector whose values are the
          character codes of the specified 'character string' (e.g. ''foo''
          is equal to '[ 102,111,111 ]').
          * '_'character'' returns the (scalar) byte code of the specified
          character (e.g. '_'A'' is equal to '65').
          *  A  special case happens for empty strings: Values of both expres-
       sions
          '['']' and '''' are '0'.
          * Functions 'lowercase()' and 'uppercase()' return string with all
          string characters lowercased or uppercased.
          * Function 'stov(str,_starting_index,_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  character  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 'string(_#siz,str1,str2,...,strN)' generates a vector
          corresponding to the concatenation of given string/number arguments.

         ## Special operators:

          * ';': expression separator. The returned value is always the last
          encountered  expression.  For instance expression '1;2;pi' is evalu-
       ated as
          'pi'.
          * '=': variable assignment. Variables  in  mathematical  parser  can
       only
          refer to numerical values (vectors or scalars). Variable names are
          case-sensitive.  Use this operator in conjunction with ';' to define
       more
          complex evaluable expressions, such as

           t = cos(x); 3*t^2 + 2*t + 1

         These variables remain local to the mathematical parser and cannot be
          accessed outside the evaluated expression.
          * Variables defined in math parser may have a constant property, by
          specifying keyword 'const' before the variable name (e.g. 'const foo
       =
          pi/4;'). The value set to such a variable must be indeed a constant
          scalar. Constant variables allows certain types of optimizations  in
       the math
          JIT compiler.

         ## Specific functions:

          *  'addr(expr)': return the pointer address to the specified expres-
       sion
          'expr'. * 'u(max)' or 'u(min,max)': return a random value
          between '[0,max]' or '[min,max]', following a uniform  distribution.
          * 'f2ui(value)' and 'ui2f(value)': Convert a large unsigned
          integer as a negative floating point value (and vice-versa), so that
       32bits
          floats can be used to store large integers while keeping  a  unitary
       precision.
          *  'i(_a,_b,_c,_d,_interpolation_type,_boundary_conditions)': return
       the
          value of the pixel located at position '(a,b,c,d)' in the associated
          image, if any ('0' otherwise). 'interpolation_type' can be {
          0=nearest neighbor | 1=linear | 2=cubic }. 'boundary_conditions' can
          be { 0=dirichlet | 1=neumann | 2=periodic | 3=mirror }. Omitted
          coordinates are replaced by their default values which  are  respec-
       tively
          '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 rela-
       tive
          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,off-
       set,
          _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).
          *     '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.
          *      'polygon(_#ind,-nb_vertices,coords,_opacity,_pattern,_color)'
       draws a
          outlined polygon in image '[ind]' (or in default image selected if
          'ind'  is not specified) at specified coordinates and with specified
       line
          pattern. It draws a single line if 'nb_vertices' is set to 2.
          *     'ellipse(_#ind,xc,yc,radius1,_radius2,_angle,_opacity,_color)'
       draws a
          filled ellipse in image '[ind]' (or in default image selected if
          'ind' is not specified) with specified coordinates.
          * 'ellipse(_#ind,xc,yc,-radius1,-_radius2,_angle,_opacity,_pattern,
          _color)' draws an outlined ellipse in image '[ind]' (or in default
          image selected if 'ind' is not specified).
          *                   'resize(#ind,w,_h,_d,_s,_interp,_boundary_condi-
       tions,_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 N-th value of the Fibonacci sequence, for 'N>=0' (e.g.,
          '46368' for 'N=24'). 'do(expression,condition)' always
          evaluates the specified expression at least once, then check for the
       loop
          condition. When done, it returns the last value of 'expression'.
          * 'for(init,condition,_procedure,body)' first evaluates the  expres-
       sion
          'init', then iteratively evaluates 'body' (followed by
          'procedure' if specified) while 'condition' holds (i.e. not zero).
          It  may  happen that no iterations are done, in which case the func-
       tion returns
          'nan'. Otherwise, it returns the last value of 'body'. For instance,
           the expression:

           if(N<2,N,for(n=N;F0=0;F1=1,n=n-1,F2=F0+F1;F0=F1;F1=F2))

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

         ## User-defined macros:

          * Custom macro functions can be defined in a math expression,  using
       the
          assignment operator '=', e.g.

           foo(x,y) = cos(x + y); result = foo(1,2) + foo(2,3)

          *  Trying  to  override  a  built-in  function (e.g. 'abs()') has no
       effect.
          * Overloading macros with different number of arguments is possible.
          Re-defining a previously defined macro with the same number of argu-
       ments
          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', 'eval' or
          'input'  commands  is evaluated in parallel, using multiple computa-
       tion
          threads.
          * Starting an expression with ':' or '*' forces the evaluations
          required for an image to be run in parallel, even if the  amount  of
       data to
          process  is  small  (beware,  it  may  be slower to evaluate in this
       case!). Specify
          ':' (rather than '*') to avoid possible image copy done before
          evaluating the expression (this saves memory, but do  this  only  if
       you are sure
          this step is not required!)
          * 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 expres-
       sion is
          disabled in this case.
          * Function  'critical(expr)'  forces  the  execution  of  the  given
       expression
          in a single thread at a time.
          * 'begin_t(expr)' and 'end_t(expr)' evaluates the specified
          expression  once for each running thread (so possibly several times)
       at the
          beginning and the end of the evaluation procedure.
          * 'merge(variable,operator)' tells to merge the local variable value
          computed  by  threads, with the specified operator, when all threads
       have
          finished computing.
          * Expressions 'i(_#ind,x,_y,_z,_c)=value', 'j(_#ind,x,_y,_z,
          _c)=value', 'i[_#ind,offset]=value' and 'j[_#ind,offset]=value'
          set a pixel value at a different location than the  running  one  in
       the image
          '[ind]' (or in the associated image if argument '#ind' is omitted),
          either with global coordinates/offsets (with 'i(...)' and 'i[...]'),
           or relatively to the current position '(x,y,z,c)' (with 'j(...)'
          and 'j[...]'). These expressions always return 'value'.
          * 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
          vector  objects (command display3d). It manages interactive views of
       the
          selected image data.
          * The following actions are available in the interactive viewers:
            -  '(mousewheel)': Zoom in/out.
            -  'ESC': Close window.
            -  'CTRL+D': Increase window size.
            -  'CTRL+C': Decrease window size.
            -  'CTRL+R': Reset window size.
            -  'CTRL+F': Toggle fullscreen mode.
            -  'CTRL+S': Save current view as a numbered file
          'gmic_xxxx.ext'.
            -  'CTRL+O': Save copy of the viewed data, as a numbered file
          'gmic_xxxx.ext'.

          * Actions specific to the 1D/2D image viewer (command display) are:
            -  'Left mouse button': Create an image selection  and  zoom  into
       it.
            -  'Middle mouse button', or 'CTRL+left mouse button': Move
          image.
            -  'Mouse wheel' or 'PADD+/-': Zoom in/out.
            -  'Arrow keys': Move image left/right/up/down.
            -  'CTRL+A': Enable/disable transparency (show alpha channel).
            -  'CTRL+N': Change normalization mode (can be { none | normal |
          channel-by-channel }).
            -  'CTRL+SPACE': Reset view.
            -  'CTRL+X': Show/hide axes.
            -  'CTRL+Z': Hold/release aspect ratio.

          * Actions specific to the 3D volumetric image viewer (command
          display) are:
            -  'CTRL+P': Play z-stack of frames as a movie.
            -  'CTRL+V': Show/hide 3D view on bottom right zone.
            -  'CTRL+X': Show/hide axes.
            -  '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.

          * Actions 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.
            -  'F1 ... F6': Toggle between different 3D rendering modes.
            -  'F7/F8': Decrease/increase focale.
            -  'F9': Select animation mode.
            -  'F10': Select animation speed.
            -  'SPACE': Start/stop animation.
            -  'CTRL+A': Show/hide 3D axes.
            -  'CTRL+B': Switch between available background.
            -  'CTRL+G': Save 3D object, as numbered file 'gmic_xxxx.obj'.
            -  'CTRL+L': Show/hide outline.
            -  'CTRL+P': Print current 3D pose on stderr.
            -  'CTRL+T': Switch between single/double-sided 3D modes.
            -  'CTRL+V': Start animation with video output.
            -  'CTRL+X': Show/hide 3D bounding box.
            -  'CTRL+Z': Enable/disable z-buffered rendering.


         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  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 argu-
       ments.
            -  '$"*"' is substituted by a copy of the specified string of
          arguments, each being double-quoted.
            -  '$#' is substituted by the maximum  index  of  known  arguments
       (either
          specified  by  the user or set to a default value in the custom com-
       mand).
            -  '$[]' is substituted by the list of selected image indices that
          have been specified in the command invocation.
            -  '$?' is substituted by a printable version of '$[]' to be
          used in command descriptions.
            -  '$i' and '${i}' are both substituted by the 'i'-th
          specified argument. Negative indices such as '${-j}' are allowed and
          refer to the 'j'-th latest argument. '$0' is substituted by the
          custom command name.
            -  '${i=default}' is substituted by the value of '$i' (if
          defined) or by its new value set to 'default' otherwise ('default'
          may be a '$-expression' as well).
            -  '${subset}' is substituted by the argument values (separated by
          commas ',') of a specified argument subset. For instance expression
          '${2--2}'  is  substituted by all specified command arguments except
       the
          first and the last one. Expression '${^0}' is  then  substituted  by
       all
          arguments  of the invoked command (eq. to '$*' if all arguments have
       been
          indeed specified).
            -  '$=var' is substituted by the set  of  instructions  that  will
       assign
          each argument '$i' to the named variable 'var$i' (for i in
          '[0...$#]'.  This  is particularly useful when a custom command want
       to
          manage variable numbers of arguments. Variables names must use char-
       acter 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 com-
       mand, 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, by categories. An
       argument
          specified between '[]' or starting by '_' is optional except when
          standing for an existing image '[image]', where 'image' can be
          either an index number or an image name. In this case, the '[]'
          characters are mandatory when writing the item. Note that all images
       that serve
          as  illustrations  in this reference documentation are normalized in
       range '[0,
          255]' before being displayed. You may need  to  do  this  explicitly
       (command
          'normalize 0,255') if you want to save and view images with the same
       aspect
          than those illustrated in the example codes.

         12.1. Global Options
               --------------

         debug (+):

           Activate debug mode.
           When activated, the G'MIC interpreter becomes very verbose and out-
       puts
           additional log
           messages  about its internal state on the standard output (stdout).
           This option is useful for developers or to report possible bugs  of
       the
           interpreter.

         h:
             Shortcut for command 'help'.

         help:
             command |
             (no arg)

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

         version:

           Display current version number on stdout.

         12.2. Input / Output
               --------------

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

           Insert one or several frames from specified camera.
           When 'nb_frames==0', the camera stream is released instead of
           capturing new images.
           This command requires features from the OpenCV library (not enabled
       in
           G'MIC by default).

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

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

           Insert one of the 889 pre-defined CLUTs at the  end  of  the  image
       list.
           'clut_name' can be { 2-strip-process | 60s | 60s_faded |
           60s_faded_alt | 7drk_21 | action_magenta_01 | action_red_01 |
           adventure_1453 | agfa_apx_100 | agfa_apx_25 | agfa_precisa_100 |
           agfa_ultra_color_100    |    agfa_vista_200    |    agressive_high-
       ligjtes_recovery_5 |
           alberto_street | alien_green | amstragram | amstragram+ |
           analogfx_anno_1870_color       |       analogfx_old_style_i       |
       analogfx_old_style_ii |
           analogfx_old_style_iii        |        analogfx_sepia_color       |
       analogfx_soft_sepia_i |
           analogfx_soft_sepia_ii | anime | apocalypse_this_very_moment | aqua
       |
           aqua_and_orange_dark | arabica_12 | autumn | ava_614 | avalanche |
           azrael_93  |  bboyz_2  | bc_darkum | berlin_sky | black_and_white |
       black_star
           | blade_runner | bleach_bypass | bleachbypass_1 | bleachbypass_2 |
           bleachbypass_3 | bleachbypass_4 | bleech_bypass_green |
           bleech_bypass_yellow_01 | blue_cold_fade | blue_dark | blue_house |
           blue_ice  |  blue_mono | blue_shadows_01 | blues | bob_ford | bour-
       bon_64 |
           bright_green_01 | bright_teal_orange | bright_warm | brightgreen |
           brown_mobster | brownbm | brownish | bw_1 | bw_10 | bw_2 |  bw_3  |
       bw_4 |
           bw_5  | bw_6 | bw_7 | bw_8 | bw_9 | byers_11 | candlelight | caribe
       |
           chemical_168 | chrome_01 | cineblue | cinebm_4k | cinema | cinema_2
       |
           cinema_3  | cinema_4 | cinema_5 | cinema_noir | cinematic-1 | cine-
       matic-10 |
           cinematic-2 | cinematic-3 | cinematic-4 | cinematic-5 | cinematic-6
       |
           cinematic-7  |  cinematic-8  |  cinematic-9  | cinematic_01 | cine-
       matic_02 |
           cinematic_03 | cinematic_for_flog  |  cinematic_lady_bird  |  cine-
       matic_mexico
           | city_7 | classic_teal_and_orange | clayton_33 | clear_teal_fade |
           clouseau_54   |   cobi_3   |   coffee_44   |   cold_clear_blue    |
       cold_clear_blue_1 |
           cold_ice  |  cold_simplicity_2  | color_rich | colorful_0209 | col-
       ornegative |
           conflict_01 | contrail_35 | contrast_with_highlights_protection |
           contrasty_afternoon | contrasty_green | crispromance | crispwarm |
           crispwinter | cross_process_cp_130 | cross_process_cp_14 |
           cross_process_cp_15 | cross_process_cp_16 | cross_process_cp_18 |
           cross_process_cp_3  |  cross_process_cp_4  |  cross_process_cp_6  |
       crushin |
           cubicle_99  |  d_o_1  |  dark_blues_in_sunlight  |  dark_green_02 |
       dark_green_1
           | dark_man_x | dark_place_01 | date_39 | day_4nite |  day_for_night
       | deep |
           deep_blue | deep_dark_warm | deep_high_contrast | deep_teal_fade |
           deep_warm_fade | deepskintones_2 | deepskintones_3 | delicatessen |
           denoiser_simple_40 | desert_gold_37 | dimension |  directions_23  |
       django_25
           | domingo_145 | dream_1 | dream_85 | drop_green_tint_14 | dropblues
       |
           earth_tone_boost  |  edgyember  |   elegance_38   |   enchanted   |
       eterna_for_flog |
           expired_69 | expired_fade | expired_polaroid | extreme | fade |
           fade_to_green  |  faded  |  faded_47  |  faded_alt | faded_analog |
       faded_extreme
           | faded_green | faded_print |  faded_retro_01  |  faded_retro_02  |
       faded_vivid
           | fadedlook | fallcolors | faux_infrared | faux_infrared_bw_1 |
           faux_infrared_color_p_2 | faux_infrared_color_p_3 |
           faux_infrared_color_r_0a | faux_infrared_color_r_0b |
           faux_infrared_color_yp_1  | fgcinebasic | fgcinebright | fgcinecold
       |
           fgcinedrama | fgcinetealorange_1 | fgcinetealorange_2  |  fgcinevi-
       brant |
           fgcinewarm  |  film_0987  | film_9879 | film_gb-19 | film_high_con-
       trast |
           film_print_01 | film_print_02 | filmic | flat_30 | flavin |  foggy-
       night |
           folger_50  | formula_b | french_comedy | frosted | frostedbeachpic-
       nic |
           fuji_160c  |   fuji_160c_+   |   fuji_160c_++   |   fuji_160c_-   |
       fuji_3510_constlclip
           | fuji_3510_constlmap | fuji_3510_cuspclip | fuji_3513_constlclip |
           fuji_3513_constlmap | fuji_3513_cuspclip | fuji_400h |  fuji_400h_+
       |
           fuji_400h_++ | fuji_400h_- | fuji_800z | fuji_800z_+ | fuji_800z_++
       |
           fuji_800z_-   |   fuji_astia_100_generic   |   fuji_astia_100f    |
       fuji_fp-100c |
           fuji_fp-100c_+    |    fuji_fp-100c_++    |    fuji_fp-100c_+++   |
       fuji_fp-100c_++_alt |
           fuji_fp-100c_-   |    fuji_fp-100c_--    |    fuji_fp-100c_alt    |
       fuji_fp-100c_cool |
           fuji_fp-100c_cool_+ | fuji_fp-100c_cool_++ | fuji_fp-100c_cool_- |
           fuji_fp-100c_cool_--  |  fuji_fp-100c_negative | fuji_fp-100c_nega-
       tive_+ |
           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_nega-
       tive_+ |
           fuji_fp-3000b_negative_++ | fuji_fp-3000b_negative_+++ |
           fuji_fp-3000b_negative_- | fuji_fp-3000b_negative_-- |
           fuji_fp-3000b_negative_early   |   fuji_fp_100c   |   fuji_hdr    |
       fuji_neopan_1600 |
           fuji_neopan_1600_+ | fuji_neopan_1600_++ | fuji_neopan_1600_- |
           fuji_neopan_acros_100  | fuji_provia_100_generic | fuji_provia_100f
       |
           fuji_provia_400f | fuji_provia_400x | fuji_sensia_100 |  fuji_supe-
       ria_100 |
           fuji_superia_100_+ | fuji_superia_100_++ | fuji_superia_100_- |
           fuji_superia_1600 | fuji_superia_1600_+ | fuji_superia_1600_++ |
           fuji_superia_1600_- | fuji_superia_200 | fuji_superia_200_xpro |
           fuji_superia_400 | fuji_superia_400_+ | fuji_superia_400_++ |
           fuji_superia_400_- | fuji_superia_800 | fuji_superia_800_+ |
           fuji_superia_800_++ | fuji_superia_800_- | fuji_superia_hg_1600 |
           fuji_superia_reala_100       |       fuji_superia_x-tra_800       |
       fuji_velvia_100_generic |
           fuji_velvia_50 | fuji_xtrans_iii_acros | fuji_xtrans_iii_acros+g |
           fuji_xtrans_iii_acros+r      |      fuji_xtrans_iii_acros+ye      |
       fuji_xtrans_iii_astia
           | fuji_xtrans_iii_classic_chrome | fuji_xtrans_iii_mono |
           fuji_xtrans_iii_mono+g       |       fuji_xtrans_iii_mono+r       |
       fuji_xtrans_iii_mono+ye |
           fuji_xtrans_iii_pro_neg_hi | fuji_xtrans_iii_pro_neg_std |
           fuji_xtrans_iii_provia       |       fuji_xtrans_iii_sepia        |
       fuji_xtrans_iii_velvia |
           fusion_88   |  futuristicbleak_1  |  futuristicbleak_2  |  futuris-
       ticbleak_3 |
           futuristicbleak_4 | going_for_a_walk |  golden  |  golden_bright  |
       golden_fade
           |   golden_mono   |   golden_night_softner_43  |  golden_sony_37  |
       golden_vibrant |
           goldengate | goldentime | goldfx_bright_spring_breeze |
           goldfx_bright_summer_heat | goldfx_hot_summer_heat |
           goldfx_perfect_sunset_01min | goldfx_perfect_sunset_05min |
           goldfx_perfect_sunset_10min |  goldfx_spring_breeze  |  goldfx_sum-
       mer_heat |
           good_morning  | green_15 | green_2025 | green_action | green_after-
       noon |
           green_and_orange | green_blues | green_conflict | green_day_01 |
           green_day_02 | green_g_09 | green_indoor | green_light | green_mono
       |
           green_yellow | greenish_contrasty | greenish_fade | greenish_fade_1
       |
           gremerta  |  hackmanite  |  happyness_133  |   hard_teal_orange   |
       harsh_day |
           harsh_sunset | helios | herderite | heulandite | hiddenite |
           highlights_protection | hilutite | hitman | hlg_1_1 | hong_kong |
           horrorblue | howlite | hydracore | hyla_68 | hypersthene | hypnosis
       |
           hypressen    |    ilford_delta_100    |     ilford_delta_3200     |
       ilford_delta_3200_+ |
           ilford_delta_3200_++ | ilford_delta_3200_- | ilford_delta_400 |
           ilford_fp_4_plus_125 | ilford_hp_5 | ilford_hp_5_+ | ilford_hp_5_++
       |
           ilford_hp_5_- | ilford_hp_5_plus_400 | ilford_hps_800 |
           ilford_pan_f_plus_50 | ilford_xp_2 | indoor_blue | industrial_33  |
       instantc
           |  justpeachy | jwick_21 | k_tone_vintage_kodachrome | kh_1 | kh_10
       | kh_2 |
           kh_3 | kh_4 | kh_5 | kh_6 | kh_7 | kh_8 | kh_9 | killstreak |
           kodak_2383_constlclip | kodak_2383_constlmap |  kodak_2383_cuspclip
       |
           kodak_2393_constlclip  | kodak_2393_constlmap | kodak_2393_cuspclip
       |
           kodak_bw_400_cn       |       kodak_e-100_gx_ektachrome_100       |
       kodak_ektachrome_100_vs |
           kodak_ektachrome_100_vs_generic       |      kodak_ektar_100      |
       kodak_elite_100_xpro |
           kodak_elite_chrome_200       |       kodak_elite_chrome_400       |
       kodak_elite_color_200 |
           kodak_elite_color_400      |      kodak_elite_extracolor_100      |
       kodak_hie_hs_infra |
           kodak_kodachrome_200 | kodak_kodachrome_25 | kodak_kodachrome_64 |
           kodak_kodachrome_64_generic | kodak_portra_160 | kodak_portra_160_+
       |
           kodak_portra_160_++ | kodak_portra_160_- | kodak_portra_160_nc |
           kodak_portra_160_nc_+   |   kodak_portra_160_nc_++   |   kodak_por-
       tra_160_nc_- |
           kodak_portra_160_vc   |    kodak_portra_160_vc_+    |    kodak_por-
       tra_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_por-
       tra_400_nc_- |
           kodak_portra_400_uc   |    kodak_portra_400_uc_+    |    kodak_por-
       tra_400_uc_++ |
           kodak_portra_400_uc_- | kodak_portra_400_vc | kodak_portra_400_vc_+
       |
           kodak_portra_400_vc_++ | kodak_portra_400_vc_- | kodak_portra_800 |
           kodak_portra_800_+ | kodak_portra_800_++ | kodak_portra_800_- |
           kodak_portra_800_hc | kodak_t-max_100 | kodak_t-max_3200 | kodak_t-
       max_400
           | kodak_tmax_3200 | kodak_tmax_3200_+ | kodak_tmax_3200_++ |
           kodak_tmax_3200_- | kodak_tmax_3200_alt | kodak_tri-x_400 |
           kodak_tri-x_400_+ | kodak_tri-x_400_++ | kodak_tri-x_400_- |
           kodak_tri-x_400_alt | korben_214 |  landscape_1  |  landscape_10  |
       landscape_2
           |  landscape_3  |  landscape_4  | landscape_5 | landscape_6 | land-
       scape_7 |
           landscape_8 | landscape_9 | lateafternoonwanderlust | latesunset  |
       lc_1 |
           lc_10  |  lc_2  |  lc_3 | lc_4 | lc_5 | lc_6 | lc_7 | lc_8 | lc_9 |
       lenox_340 |
           life_giving_tree | light_blown | lomo | lomography_redscale_100 |
           lomography_x-pro_slide_200 | london_nights  |  louetta  |  low_con-
       trast_blue |
           low_key_01   |   lucky_64   |   lushgreensummer   |  magenta_day  |
       magenta_day_01 |
           magenta_dream | magenta_yellow | magentacoffee |  matrix  |  mckin-
       non_75 |
           memories  |  metropolis  |  milo_5  | minimalistcaffeination | mod-
       ern_film |
           mono_tinted | monochrome | monochrome_1 | monochrome_2 | moody_1  |
       moody_10
           |  moody_2  |  moody_3  |  moody_4  | moody_5 | moody_6 | moody_7 |
       moody_8 |
           moody_9 | moonlight | moonlight_01 | moonrise |  morning_6  |  mor-
       roco_16 |
           mostly_blue | moviz_1 | moviz_10 | moviz_11 | moviz_12 | moviz_13 |
           moviz_14 | moviz_15 | moviz_16 | moviz_17 | moviz_18 |  moviz_19  |
       moviz_2 |
           moviz_20  |  moviz_21 | moviz_22 | moviz_23 | moviz_24 | moviz_25 |
       moviz_26
           | moviz_27 | moviz_28 | moviz_29 | moviz_3 | moviz_30 | moviz_31  |
       moviz_32
           | moviz_33 | moviz_34 | moviz_35 | moviz_36 | moviz_37 | moviz_38 |
           moviz_39 | moviz_4 | moviz_40 | moviz_41 | moviz_42  |  moviz_43  |
       moviz_44 |
           moviz_45  |  moviz_46  |  moviz_47 | moviz_48 | moviz_5 | moviz_6 |
       moviz_7 |
           moviz_8 | moviz_9 | mute_shift | muted_01 | muted_fade | mysticpur-
       plesunset
           | nah | natural_vivid | nemesis | neon_770 | neutral_teal_orange |
           neutral_warm_fade   |   newspaper  |  night_01  |  night_blade_4  |
       night_king_141 |
           night_spy | nightfromday | nightlife | nostalgiahoney | nostalgic |
       nw-1 |
           nw-10  |  nw-2  |  nw-3 | nw-4 | nw-5 | nw-6 | nw-7 | nw-8 | nw-9 |
       old_west |
           once_upon_a_time | only_red | only_red_and_blue |  operation_yellow
       |
           orange_dark_4 | orange_dark_7 | orange_dark_look | orange_tone |
           orange_underexposed   |   oranges   |   paladin  |  paladin_1875  |
       pasadena_21 |
           passing_by | pink_fade | pitaya_15 | polaroid_664 | polaroid_665 |
           polaroid_665_+ | polaroid_665_++ | polaroid_665_- | polaroid_665_--
       |
           polaroid_665_negative | polaroid_665_negative_+ | polaroid_665_neg-
       ative_- |
           polaroid_665_negative_hc   |   polaroid_667   |   polaroid_669    |
       polaroid_669_+ |
           polaroid_669_++    |    polaroid_669_+++    |    polaroid_669_-   |
       polaroid_669_-- |
           polaroid_669_cold | polaroid_669_cold_+ | polaroid_669_cold_- |
           polaroid_669_cold_-- | polaroid_672 | polaroid_690 | polaroid_690_+
       |
           polaroid_690_++    |    polaroid_690_-    |    polaroid_690_--    |
       polaroid_690_cold |
           polaroid_690_cold_+ | polaroid_690_cold_++ | polaroid_690_cold_- |
           polaroid_690_cold_-- | polaroid_690_warm | polaroid_690_warm_+ |
           polaroid_690_warm_++ | polaroid_690_warm_- | polaroid_690_warm_-- |
           polaroid_polachrome        |        polaroid_px-100uv+_cold       |
       polaroid_px-100uv+_cold_+ |
           polaroid_px-100uv+_cold_++ | polaroid_px-100uv+_cold_+++ |
           polaroid_px-100uv+_cold_- | polaroid_px-100uv+_cold_-- |
           polaroid_px-100uv+_warm | polaroid_px-100uv+_warm_+ |
           polaroid_px-100uv+_warm_++ | polaroid_px-100uv+_warm_+++ |
           polaroid_px-100uv+_warm_-    |     polaroid_px-100uv+_warm_--     |
       polaroid_px-680 |
           polaroid_px-680_+ | polaroid_px-680_++ | polaroid_px-680_- |
           polaroid_px-680_--  | polaroid_px-680_cold | polaroid_px-680_cold_+
       |
           polaroid_px-680_cold_++ | polaroid_px-680_cold_++_alt |
           polaroid_px-680_cold_-      |       polaroid_px-680_cold_--       |
       polaroid_px-680_warm |
           polaroid_px-680_warm_+       |       polaroid_px-680_warm_++      |
       polaroid_px-680_warm_- |
           polaroid_px-680_warm_-- | polaroid_px-70 | polaroid_px-70_+ |
           polaroid_px-70_++ | polaroid_px-70_+++ | polaroid_px-70_- |
           polaroid_px-70_-- | polaroid_px-70_cold | polaroid_px-70_cold_+ |
           polaroid_px-70_cold_++       |       polaroid_px-70_cold_-        |
       polaroid_px-70_cold_-- |
           polaroid_px-70_warm         |        polaroid_px-70_warm_+        |
       polaroid_px-70_warm_++ |
           polaroid_px-70_warm_-       |       polaroid_px-70_warm_--        |
       polaroid_time_zero_expired
           | polaroid_time_zero_expired_+ | polaroid_time_zero_expired_++ |
           polaroid_time_zero_expired_- | polaroid_time_zero_expired_-- |
           polaroid_time_zero_expired_--- | polaroid_time_zero_expired_cold |
           polaroid_time_zero_expired_cold_-                                 |
       polaroid_time_zero_expired_cold_-- |
           polaroid_time_zero_expired_cold_--- | portrait_1  |  portrait_10  |
       portrait_2
           | portrait_3 | portrait_4 | portrait_5 | portrait_6 | portrait_7 |
           portrait_8 | portrait_9 | progressen | protect_highlights_01 |
           prussian_blue | pseudogrey | purple | purple_2 | red_afternoon_01 |
           red_day_01   |   red_dream_01   |   redblueyellow    |    reds    |
       reds_oranges_yellows |
           reeve_38   |   remy_24   |  rest_33  |  retro  |  retro_brown_01  |
       retro_magenta_01 |
           retro_summer_3 | retro_yellow_01 | rollei_ir_400 |  rollei_ortho_25
       |
           rollei_retro_100_tonal   |   rollei_retro_80s   |   rotate_muted  |
       rotate_vibrant |
           rotated | rotated_crush | saturated_blue | saving_private_damon |
           science_fiction | serenity | seringe_4 | serpent |  seventies_maga-
       zine |
           sevsuz  |  shadow_king_39  |  shine | skin_tones | smart_contrast |
       smokey |
           smooth_clear | smooth_cromeish | smooth_fade |  smooth_green_orange
       |
           smooth_sailing | smooth_teal_orange | soft_fade | softwarming |
           solarized_color  | solarized_color_2 | springmorning | sprocket_231
       | spy_29
           | street | studio_skin_tone_shaper | subtle_blue | subtle_green |
           subtle_yellow | summer  |  summer_alt  |  sunlightlove  |  sunny  |
       sunny_alt |
           sunny_rich | sunny_warm | super_warm | super_warm_rich | sutro_fx |
           sweet_bubblegum | sweet_gelatto | taiga | tarraco | teal_fade |
           teal_moonlight | tealmagentagold  |  tealorange  |  tealorange_1  |
       tealorange_2
           |  tealorange_3  |  technicalfx_backlight_filter | teigen_28 | ten-
       siongreen_1
           | tensiongreen_2 | tensiongreen_3  |  tensiongreen_4  |  terra_4  |
       the_matrices
           |  thriller_2  |  toastedgarden | trent_18 | true_colors_8 | turki-
       est_42 |
           tweed_71 | ultra_water | undeniable  |  undeniable_2  |  unknown  |
       urban_cowboy
           | uzbek_bukhara | uzbek_marriage | uzbek_samarcande | velvetia |
           very_warm_greenish   |   vfb_21   |   vibrant   |  vibrant_alien  |
       vibrant_contrast |
           vibrant_cromeish | victory | vintage | vintage_163 | vintage_alt |
           vintage_brighter | vintage_chrome | vintage_mob |  vintage_warmth_1
       |
           vireo_37 | warm | warm_dark_contrasty | warm_fade | warm_fade_1 |
           warm_highlight  |  warm_neutral  |  warm_sunset_red  |  warm_teal |
       warm_vintage
           | warm_yellow | well_see | western | westernlut_2 | whiter_whites |
           winterlighthouse  |  wipe  |  wooden_gold_20  |  yellow_55b  | yel-
       low_film_01 |
           yellowstone | you_can_do_it | zed_32 | zeke_39 | zilverfx_bw_solar-
       ization |
           zilverfx_infrared | zilverfx_vintage_bw }

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

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

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

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

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

           Imported commands are available directly after the 'command'
           invocation.

           Default value: 'add_debug_info=1'.

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

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

           Show or hide mouse cursor for selected instant display windows.
           Command  selection  (if  any)  stands  for  instant  display window
       indices
           instead of image indices.

           Default value: 'mode=1'.

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

           Delete specified filenames on disk. Multiple filenames must be sep-
       arated
           by commas.

         d (+):
             Shortcut for command 'display'.

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

           Tutorial: https://gmic.eu/oldtutorial/_display.shtml

         d0:
             Shortcut for command 'display0'.

         display0:

           Display selected images without value normalization.
           (equivalent to shortcut command 'd0').

         d2d:
             Shortcut for command 'display2d'.

         display2d:

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

           This command is used by default by command 'display' when  display-
       ing
           2d images.
           If selected image is a volumetric image, each slice is displayed on
       a
           separate display
           window (up to 10 images can be displayed simultaneously this  way),
       with
           synchronized moves.
           When interactive window is opened, the following actions are possi-
       ble:
            * Left mouse button: Create an image selection and zoom into it.
            * Middle mouse button, or CTRL+left mouse button: Move image.
            * Mouse wheel or PADD+/-: Zoom in/out.
            * Arrow keys: Move image left/right/up/down.
            * 'CTRL + A': Enable/disable transparency (show/hide  alpha  chan-
       nel).
            * 'CTRL + C': Decrease window size.
            * 'CTRL + D': Increase window size.
            * 'CTRL + F': Toggle fullscreen mode.
            * 'CTRL + N': Change normalization mode (can be { none | normal |
           channel-by-channel }).
            * 'CTRL + O': Save a copy of the input image, as a numbered file
           'gmic_xxxxxx.gmz'.
            * 'CTRL + R': Reset both window size and view.
            * 'CTRL + S': Save a screenshot of the current view, as a numbered
           file 'gmic_xxxxxx.png'.
            * 'CTRL + SPACE': Reset view.
            * 'CTRL + X': Show/hide axes.
            * 'CTRL + Z': Hold/release aspect ratio.

         d3d:
             Shortcut for command 'display3d'.

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

           Default values: '[background_image]=(default)' and
            'exit_on_anykey=0'.

         da:
             Shortcut for command 'display_array'.

         display_array:
             _width>0,_height>0

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

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

         dc:
             Shortcut for command 'display_camera'.

         display_camera:

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

         dfft:
             Shortcut for command 'display_fft'.

         display_fft:

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

           Example:
             [#1] image.jpg +display_fft

         dg:
             Shortcut for command 'display_graph'.

         display_graph:
             _width>=0,_height>=0,_plot_type,_ver-
       tex_type,_xmin,_xmax,_ymin,_ymax,
               _xlabel,_ylabel

           Render graph plot from selected image data.
           'plot_type' can be { 0=none | 1=lines | 2=splines | 3=bar }.
           'vertex_type' can be { 0=none | 1=points | 2,3=crosses | 4,
           5=circles | 6,7=squares }.
           'xmin','xmax','ymin','ymax' set the coordinates of
           the displayed xy-axes.
           if specified 'width' or 'height' is '0', then image size
           is set to half the screen size.

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

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

         dh:
             Shortcut for command 'display_histogram'.

         display_histogram:
             _width>=0,_height>=0,_clus-
       ters>0,_min_value[%],_max_value[%],_show_axes={
               0 | 1 },_expression.

           Render a channel-by-channel histogram.
           If selected images have several slices, the rendering is  performed
       for all
           input slices.
           'expression' is a mathematical expression used to transform the
           histogram data for visualization purpose.
           (equivalent to shortcut command 'dh').

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

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

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

         display_parametric:
             _width>0,_height>0,_outline_opacity,_ver-
       tex_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 chan-
       nels
           define the (R,G,B) color for each vertex.
           If 'outline_opacity>1', the outline is colored according to the
           specified vertex colors and
           'outline_opacity-1' is used as the actual drawing opacity.

           Default values: 'width=512', 'height=width',
            'outline_opacity=3', 'vertex_radius=0',
            'is_antialiased=1','is_decorated=1',
            'xlabel="x-axis"' and 'ylabel="y-axis"'.

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

         dp:
             Shortcut for command 'display_parallel'.

         display_parallel:

           Display  each selected image in a separate interactive display win-
       dow.
           (equivalent to shortcut command 'dp').

         dp0:
             Shortcut for command 'display_parallel0'.

         display_parallel0:

           Display each selected image in a separate interactive display  win-
       dow,
           without value normalization.
           (equivalent to shortcut command 'dp0').

         display_polar:
             _width>32,_height>32,_out-
       line_type,_fill_R,_fill_G,_fill_B,_theta_start,
               _theta_end,_xlabel,_ylabel

           Render polar curve from selected image data.
           'outline_type' can be { r<0=dots with radius -r | 0=no outline |
           r>0=lines+dots with radius r }.
           'fill_color' can be { -1=no fill | R,G,B=fill with specified
           color }.

           Default values: 'width=500', 'height=width',
            'outline_type=1', 'fill_R=fill_G=fill_B=200',
            'theta_start=0', 'theta_end=360', 'xlabel="x-axis"'
            and 'ylabel="y-axis"'.

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

         dq:
             Shortcut for command 'display_quiver'.

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

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

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

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

         drgba:
             Shortcut for command 'display_rgba'.

         display_rgba:
             _background_RGB_color

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

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

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

         dt:
             Shortcut for command 'display_tensors'.

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

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

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

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

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

         dw:
             Shortcut for command 'display_warp'.

         display_warp:
             _cell_size>0

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

           Default value: 'cell_size=15'.

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

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

         echo (+):
             message

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

           Command  selection  (if any) stands for displayed call stack subset
       instead
           of image indices.

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

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

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

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

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

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

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

           Tutorial: https://gmic.eu/tutorial/_input.shtml

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

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

           Default value: 'reverse_endianness=0'.

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

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

           Default value: 'convert_1d_cluts_to_3d=1'.

         input_flo:
             "filename"

           Insert  optical  flow  data  from  a  .flo filename (vision.middle-
       bury.edu file
           format).

         ig:
             Shortcut for command 'input_glob'.

         input_glob:
             pattern

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

         input_gpl:
             filename

           Input specified filename as a .gpl palette data file.

         it:
             Shortcut for command 'input_text'.

         input_text:
             filename

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

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

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

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

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

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

           Default value: 'format_options'=(undefined).

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

           Output selected images as raw RGB-565 files.

           Default value: 'reverse_endianness=0'.

         output_cube:
             "filename"

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

         output_flo:
             "filename"

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

         output_ggr:
             filename,_gradient_name

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

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

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

           Default value: 'save_materials=1'.

         ot:
             Shortcut for command 'output_text'.

         output_text:
             filename

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

         on:
             Shortcut for command 'outputn'.

         outputn:
             filename,_index

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

         op:
             Shortcut for command 'outputp'.

         outputp:
             prefix

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

           Default value: 'prefix=_'.

         ow:
             Shortcut for command 'outputw'.

         outputw:

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

         ox:
             Shortcut for command 'outputx'.

         outputx:
             extension1,_extension2,_...,_extensionN,_output_at_same_loca-
       tion={ 0 | 1 }

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

           Default value: 'output_at_same_location=0'.

         parse_cli:
             _output_mode,_{ * | command_name }

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

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

         parse_gmd:

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

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

           Convert selected gmd-formatted text images to html format.

           Default values: 'include_default_header_footer=1'.

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

           Convert selected gmd-formatted text images to ascii format.

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

         parse_gui:
             _outputmode,_{ * | filter_name}

           Parse selected filter definitions and generate info  about  filters
       in
           selected output mode.
           'outputmode' can be { json | list | print | strings | update |
           zart }.
           It is possible to define a custom output mode, by implementing the
           following commands
           ('outputmode'  must be replaced by the name of the custom user out-
       put
           mode):
           . 'parse_gui_outputmode' : A command that outputs the parsing
           information with a custom format.
           . 'parse_gui_parseparams_outputmode' (optional): A simple command
           that returns 0 or 1. It tells  the  parser  whether  parameters  of
       matching
           filter must be analyzed (slower) or not.
           . 'parse_gui_trigger_outputmode' (optional): A command that is
           called  by  the parser just before parsing the set of each matching
       filters.
           Here is the list of global variables set by the parser,  accessible
       in
           command 'parse_gui_outputmode':
           '$_nbfilters': Number of matching filters.
           '$_nongui' (stored as an image): All merged lines in the file that
           do not correspond to '#@gui' lines.
           For each filter '     * '$_fF_name' : Filter name.
            * '$_fF_path' : Full path.
            * '$_fF_locale' : Filter locale (empty, if not specified).
            * '$_fF_command' : Filter command.
            * '$_fF_commandpreview' : Filter preview command (empty, if not
           specified).
            *  '$_fF_zoomfactor'  :  Default zoom factor (empty, if not speci-
       fied).
            * '$_fF_zoomaccurate' : Is preview accurate when zoom changes ?
           (can be { 0=false | 1=true }).
            * '$_fF_inputmode' : Default preferred input mode (empty, if not
           specified).
            * '$_fF_hide' : Path of filter hid by current filter  (for  local-
       ized
           filters, empty if not specified).
            * '$_fF_nbparams' : Number of parameters.
           For each parameter '    $_fF_nbparams-1]'):
            * '$_fF_pP_name' : Parameter name.
            * '$_fF_pP_type' : Parameter type.
            * '$_fF_pP_responsivity' : Parameter responsivity (can be { 0 |
           1 }).
            * '$_fF_pP_visibility' : Parameter visibility.
            * '$_fF_pP_propagation' : Propagation of the parameter visibility.
            * '$_fF_pP_nbargs' : Number of parameter arguments.
           For each argument '    $_fF_pP_nbargs-1]'):
            * '$_fF_pP_aA' : Argument value
           Default parameters: 'filter_name=*' and 'output_format=print'.

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

           Insert images from parent context of a custom command or a local
           environment.
           Command  selection (if any) stands for a selection of images in the
       parent
           context.
           By default (adaptive shared state), selected images are inserted in
       a
           shared state if they do not belong
           to the context (selection) of the current custom command or local
           environment as well.
           Typical  use  of  command 'pass' concerns the design of custom com-
       mands
           that take images as arguments.
           This commands return the list of corresponding indices in the  sta-
       tus.

           Default value: 'shared_state=2'.

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

         plot (+):
             _plot_type,_vertex_type,_xmin,_xmax,_ymin,_ymax,_exit_on_anykey={
       0 | 1 } |
             'formula',_resolution>=0,_plot_type,_ver-
       tex_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'.

         p (+):
             Shortcut for command 'print'.

         print (+):

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

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

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

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

           Example:
             [#1] repeat 6 random_pattern 256 done

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

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

         shape_circle:
             _size>=0

           Input a 2D circle binary shape with specified size.

           Default value: 'size=512'.

           Example:
             [#1] shape_circle ,

         shape_cupid:
             _size>=0

           Input a 2D cupid binary shape with specified size.

           Default value: 'size=512'.

           Example:
             [#1] shape_cupid ,

         shape_diamond:
             _size>=0

           Input a 2D diamond binary shape with specified size.

           Default value: 'size=512'.

           Example:
             [#1] shape_diamond ,

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

           Input a 2D Dragon curve with specified size.

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

           Example:
             [#1] shape_dragon ,

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

           Input a 2D Barnsley fern with specified size.

           Default value: 'size=512', 'density=50%',
            'angle=30', 'opacity=0.3' and 'type=0'.

           Example:
             [#1] shape_fern ,

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

           Input a 2D gear binary shape with specified size.

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

           Example:
             [#1] shape_gear ,

         shape_heart:
             _size>=0

           Input a 2D heart binary shape with specified size.

           Default value: 'size=512'.

           Example:
             [#1] shape_heart ,

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

           Input a 2D polygonal binary shape with specified geometry.

           Default value: 'size=512', 'nb_vertices=5' and
            'angle=0'.

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

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

           Input a 2D snowflake binary shape with specified size.

           Default values: 'size=512' and 'nb_recursions=5'.

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

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

           Input a 2D star binary shape with specified size.

           Default values: 'size=512', 'nb_branches=5' and
            'thickness=0.38'.

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

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

         shared (+):
             x0[%],x1[%],y[%],z[%],c[%] |
             y0[%],y1[%],z[%],c[%] |
             z0[%],z1[%],c[%] |
             c0[%],c1[%] |
             c0[%] |
             (no arg)

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

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

           Tutorial: https://gmic.eu/tutorial/_shared.shtml

         sp:
             Shortcut for command 'sample'.

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

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

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

           Example:
             [#1] repeat 6 sample done

         srand (+):
             value |
             (no arg)

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

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

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

           Default value: 'is_compressed=0'.

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

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

           Input a 2D synthetic image.

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

           Example:
             [#1] testimage2d 512

         um:
             Shortcut for command 'uncommand'.

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

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

         uniform_distribution:
             nb_levels>=1,spectrum>=1

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

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

         unserialize (+):

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

         up:
             Shortcut for command 'update'.

         update:

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

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

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

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

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

           Default value: 'level=1'.

         wait (+):
             delay |
             (no arg)

           Wait for a given delay (in ms), optionally since the last call to
           'wait'.
           or wait for a user event occurring on the selected instant  display
       windows.
           'delay' can be { <0=delay+flush events | 0=event | >0=delay }.
           Command  selection  (if  any)  stands  for  instant  display window
       indices
           instead of image indices.
           If no window indices are specified and if 'delay' is positive, the
           command results
           in a 'hard' sleep during specified delay.

           Default value: 'delay=0'.

         warn (+):
             _force_visible={ 0 | 1 },_message

           Print specified warning message, on the standard error (stderr).
           Command selection (if any) stands for displayed call  stack  subset
       instead
           of image indices.

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

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

           Display selected images into an instant display window with  speci-
       fied size,
            normalization type,
           fullscreen mode and title.
           (equivalent to shortcut command 'w').

           If 'width' or 'height' is set to -1, the corresponding
           dimension is adjusted to the window
           or image size.
           Specify 'pos_x' and 'pos_y' arguments only if the window has
           to be moved to the specified
           coordinates. Otherwise, they can be avoided.
           'width'=0 or 'height'=0 closes the instant display window.
           'normalization' can be { -1=keep same | 0=none | 1=always |
           2=1st-time | 3=auto }.
           'fullscreen' can be { -1=keep same | 0=no | 1=yes }.
           You  can manage up to 10 different instant display windows by using
       the
           numbered variants
           'w0' (default, eq. to 'w'),'w1',...,'w9' of the
           command 'w'.
           Invoke 'window' with no selection to make the window visible, if it
           has been closed by the user.

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

         12.3. List Manipulation
               -----------------

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

         keep (+):

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

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

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

         move (+):
             position[%]

           Move selected images at specified position.
           (equivalent to shortcut command 'mv').

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

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

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

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

           Tutorial: https://gmic.eu/tutorial/_name.shtml

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

         remove (+):

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

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

         remove_duplicates:

           Remove duplicates images in the selected images list.

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

         remove_empty:

           Remove empty images in the selected image list.

         rmn:
             Shortcut for command 'remove_named'.

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

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

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

         reverse (+):

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

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

         sort_list:
             _ordering={ + | - },_criterion

           Sort list of selected images according to the specified image  cri-
       terion.

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

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

         12.4. Mathematical Operators
               ----------------------

         abs (+):

           Compute the pointwise absolute values of selected images.

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

         acos (+):

           Compute the pointwise arccosine of selected images.

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

           Tutorial:   https://gmic.eu/tutorial/trigometric-and-inverse-trigo-
       metric-commands.shtml

         acosh (+):

           Compute the pointwise hyperbolic arccosine of selected images.

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

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

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

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

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

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

           Compute  the  bitwise  AND of selected images with specified value,
       image or
           mathematical expression, or compute the pointwise  sequential  bit-
       wise AND of
           selected images.
           (equivalent to shortcut command '&').

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

         argmax:

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

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

         argmaxabs:

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

         argmin:

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

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

         argminabs:

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

         asin (+):

           Compute the pointwise arcsine of selected images.

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

           Tutorial:   https://gmic.eu/tutorial/trigometric-and-inverse-trigo-
       metric-commands.shtml

         asinh (+):

           Compute the pointwise hyperbolic arcsine of selected images.

         atan (+):

           Compute the pointwise arctangent of selected images.

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

           Tutorial:   https://gmic.eu/tutorial/trigometric-and-inverse-trigo-
       metric-commands.shtml

         atan2 (+):
             [x_argument]

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

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

           Tutorial:   https://gmic.eu/tutorial/trigometric-and-inverse-trigo-
       metric-commands.shtml

         atanh (+):

           Compute the pointwise hyperbolic arctangent of selected images.

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

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

           Compute the bitwise left shift of selected  images  with  specified
       value,
           image  or mathematical expression, or compute the pointwise sequen-
       tial
           bitwise left shift of selected images.
           (equivalent to shortcut command '<<').

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

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

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

           Compute the bitwise right shift of selected images  with  specified
       value,
           image  or mathematical expression, or compute the pointwise sequen-
       tial
           bitwise right shift of selected images.
           (equivalent to shortcut command '>>').

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

         cos (+):

           Compute the pointwise cosine of selected images.

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

           Tutorial:   https://gmic.eu/tutorial/trigometric-and-inverse-trigo-
       metric-commands.shtml

         cosh (+):

           Compute the pointwise hyperbolic cosine of selected images.

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

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

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

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

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

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

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

           Default value: 'epsilon=1e-8'.

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

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

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

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

         exp (+):

           Compute the pointwise exponential of selected images.

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

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

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

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

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

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

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

           Compute the boolean 'greater than' of selected images  with  speci-
       fied value,
            image  or mathematical expression, or compute the boolean 'greater
       than' of
           selected images.
           (equivalent to shortcut command '>').

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

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

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

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

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

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

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

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

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

         log (+):

           Compute the pointwise base-e logarithm of selected images.

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

         log10 (+):

           Compute the pointwise base-10 logarithm of selected images.

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

         log2 (+):

           Compute the pointwise base-2 logarithm of selected images

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

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

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

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

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

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

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

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

           Compute the matrix division of selected matrices/vectors by  speci-
       fied
           value,  image  or  mathematical  expression,  or compute the matrix
       division of
           selected images.
           (equivalent to shortcut command 'm/').

         med:

           Compute the median of selected images.

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

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

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

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

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

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

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

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

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

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

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

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

           Compute the matrix right multiplication of  selected  matrices/vec-
       tors by
           specified  value,  image or mathematical expression, or compute the
       matrix
           right multiplication of selected images.
           (equivalent to shortcut command 'm*').

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

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

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

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

           See also: add, sub, div.

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

         mul_channels:
             value1,_value2,...,_valueN

           Multiply channels of selected images by specified sequence of  val-
       ues.

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

         mul_complex:
             [multiplier_real,multiplier_imag]

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

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

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

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

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

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

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

           Compute  the  bitwise  OR  of selected images with specified value,
       image or
           mathematical expression, or compute the pointwise  sequential  bit-
       wise OR of
           selected images.
           (equivalent to shortcut command '|').

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

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

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

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

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

         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 sequen-
       tial
           bitwise left rotation of selected images.

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

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

           Compute the bitwise right rotation of selected images  with  speci-
       fied value,
            image or mathematical expression, or compute the pointwise sequen-
       tial
           bitwise right rotation of selected images.

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

         sign (+):

           Compute the pointwise sign of selected images.

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

         sin (+):

           Compute the pointwise sine of selected images.

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

           Tutorial:   https://gmic.eu/tutorial/trigometric-and-inverse-trigo-
       metric-commands.shtml

         sinc (+):

           Compute the pointwise sinc function of selected images.

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

         sinh (+):

           Compute the pointwise hyperbolic sine of selected images.

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

         sqr (+):

           Compute the pointwise square function of selected images.

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

         sqrt (+):

           Compute the pointwise square root of selected images.

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

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

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

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

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

         tan (+):

           Compute the pointwise tangent of selected images.

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

           Tutorial:   https://gmic.eu/tutorial/trigometric-and-inverse-trigo-
       metric-commands.shtml

         tanh (+):

           Compute the pointwise hyperbolic tangent of selected images.

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

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

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

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

         12.5. Values Manipulation
               -------------------

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

           Apply curve transformation to image values.

           Default values: 'smoothness=1', 'x0=0', 'y0=100'.

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

         apply_gamma:
             gamma>=0

           Apply gamma correction to selected images.

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

         balance_gamma:
             _ref_color1,...

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

           Default value: 'ref_color1=128'.

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

         cast:
             datatype_source,datatype_target

           Cast datatype of image buffer from specified source type to  speci-
       fied
           target type.
           'datatype_source' and 'datatype_target' can be { uchar |
           char  | ushort | short | uint | int | uint64 | int64 | float | dou-
       ble }.

         complex2polar:

           Compute complex to polar transforms of selected images.

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

         compress_clut:
             _max_error>0,_avg_error>0,_max_nbpoints>=8     |     0    (unlim-
       ited),_error_metric={
               0=L2-norm  |  1=deltaE_1976  |   2=deltaE_2000   },_reconstruc-
       tion_colorspa
               ce={ 0=srgb | 1=rgb | 2=lab },_try_rbf_first={ 0 | 1 }

           Compress selected color LUTs as sequences of colored keypoints.

           Default values: 'max_error=1.5', 'avg_error=0.75',
            'max_nb_points=2048', 'error_metric=2',
            'reconstruction_colorspace=0' and 'try_rbf_first=1'.

         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  con-
       straint.

           Default values: 'is_binary_data=0' and
            'maximum_sequence_length=0'.

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

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

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

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

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

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

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

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

         decompress_clut:
             _width>0,_height>0,_depth>0,_reconstruction_colorspace={ 0=srgb |
       1=rgb |
               2=lab }

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

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

         decompress_clut_rbf:
             _width>0,_height>0,_depth>0,_reconstruction_colorspace={ 0=srgb |
       1=rgb |
               2=lab }

           Decompress selected colored keypoints into 3D CLUTs, using RBF thin
       plate
           spline interpolation.

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

         decompress_clut_pde:
             _width>0,_height>0,_depth>0,_reconstruction_colorspace={ 0=srgb |
       1=rgb |
               2=lab }

           Decompress selected colored keypoints into 3D CLUTs,  using  multi-
       scale
           diffusion PDE's.

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

         decompress_rle:

           Decompress selected data vectors, using RLE algorithm.

         discard (+):
             _value1,_value2,... |
             { x | y | z | c}...{ x | y | z | c},_value1,_value2,... |
             (no arg)

           Discard specified values in selected images or discard neighboring
           duplicate values,
           optionally only for the values along the first of a specified axis.
           If no arguments are specified,  neighboring  duplicate  values  are
       discarded.
           If all pixels of a selected image are discarded, an empty image is
           returned.

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

         eigen2tensor:

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

           Tutorial: https://gmic.eu/tutorial/_eigen2tensor.shtml

         endian (+):
             _datatype

           Reverse data endianness of selected images, eventually  considering
       the
           pixel being of the specified datatype.
           'datatype' can be { bool | uchar | char | ushort | short | uint |
           int | uint64 | int64 | float | double }.
           This command does nothing for 'bool', 'uchar' and 'char'
           datatypes.

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

           Equalize histograms of selected images.
           If value range is specified, the equalization is done only for pix-
       els in
           the specified
           value range.

           Default values: 'nb_levels=256', 'value_min=0%' and
            'value_max=100%'.

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

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

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

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

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

           Tutorial: https://gmic.eu/tutorial/_fill.shtml

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

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

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

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

           Tutorial: https://gmic.eu/tutorial/_index.shtml

         ir:
             Shortcut for command 'inrange'.

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

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

           Default value: 'include_min_boundary=include_max_boundary=1'.

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

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

           Map  specified  vector-valued  palette  to  selected indexed scalar
       images.
           'palette_name' can be { default | hsv | lines | hot | cool | jet
           | flag | cube | rainbow | algae | amp | balance |  curl  |  deep  |
       delta |
           dense  | diff | gray | haline | ice | matter | oxy | phase | rain |
       solar |
           speed | tarn | tempo | thermal | topo | turbid |  aurora  |  hocus-
       pocus | srb2
           | uzebox }
           'boundary_conditions' can be { 0=dirichlet | 1=neumann |
           2=periodic | 3=mirror }.

           Default value: 'boundary_conditions=0'.

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

           Tutorial: https://gmic.eu/tutorial/_map.shtml

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

           Apply specified matrix to channels of selected images.

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

         negate:
             base_value |
             (no arg)

           Negate image values.

           Default value: 'base_value=(undefined)'.

           Example:
             [#1] image.jpg +negate

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

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

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

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

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

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

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

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

           Default values: 'radius=8' and 'max_sample_attempts=30'.

           Example:
             [#1] 300,300 noise_poissondisk 8

         normp:
             p>=0

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

           Default value: 'p=2'.

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

         norm:

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

           Example:
             [#1] image.jpg +norm

           Tutorial: https://gmic.eu/tutorial/_norm.shtml

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

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

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

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

           Tutorial: https://gmic.eu/tutorial/_normalize.shtml

         normalize_sum:

           Normalize selected images with a unitary sum.

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

         not:

           Apply boolean not operation on selected images.

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

         orientation:

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

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

           Tutorial: https://gmic.eu/tutorial/_orientation.shtml

         oneminus:

           For each selected image, compute one minus image.

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

         otsu:
             _nb_levels>0

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

           Default value: 'nb_levels=256'.

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

         polar2complex:

           Compute polar to complex transforms of selected images.

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

           Quantize selected images.

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

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

         quantize_area:
             _min_area>0

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

           Default value: 'min_area=10'.

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

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

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

           Example:
             [#1] 400,400,1,3 rand -10,10 +blur 10 sign[-1]

         replace:
             source,target

           Replace pixel values in selected images.

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

         replace_inf:
             _expression

           Replace all infinite values in selected images by specified expres-
       sion.

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

         replace_nan:
             _expression

           Replace all NaN values in selected images by specified  expression.

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

         replace_naninf:
             _expression

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

         replace_seq:
             "search_seq","replace_seq"

           Search and replace a sequence of values in selected images.

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

         replace_str:
             "search_str","replace_str"

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

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

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

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

           Default value: 'rounding_type=0'.

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

         roundify:
             gamma>=0

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

           Default value: 'gamma=0'.

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

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

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

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

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

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

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

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

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

           Default value: 'is_soft=0'.

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

           Tutorial: https://gmic.eu/tutorial/_threshold.shtml

         vector2tensor:

           Convert selected vector fields to corresponding tensor fields.

         12.6. Colors
               ------

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

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

           Default values: 'brightness=0', 'contrast=0',
            'gamma=0', 'hue_shift=0', 'saturation=0',
            'value_min=value_max=0'.

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

         ac:
             Shortcut for command 'apply_channels'.

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

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

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

           Default value: 'value_action=0'.

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

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

           Index selected vector-valued images by adapted colormaps.

           Default values: 'dithering=0' and 'method=1'.

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

         bayer2rgb:
             _GM_smoothness,_RB_smoothness1,_RB_smoothness2

           Transform selected RGB-Bayer sampled images to color images.

           Default values: 'GM_smoothness=RB_smoothness=1' and
            'RB_smoothness2=0.5'.

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

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

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

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

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

         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=deutera-
       nomaly |
               4=tritanopia  |  5=tritanomaly  |  6=achromatopsia  |  7=achro-
       matomaly }

           Simulate color blindness vision.

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

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

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

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

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

           Tutorial: https://gmic.eu/tutorial/_colormap.shtml

         compose_channels:

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

           Default value: '1=+'.

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

           Tutorial: https://gmic.eu/tutorial/_compose_channels.shtml

         direction2rgb:

           Compute RGB representation of selected 2D direction fields.

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

         ditheredbw:

           Create dithered B&W version of selected images.

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

         fc:
             Shortcut for command 'fill_color'.

         fill_color:
             col1,...,colN

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

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

           Tutorial: https://gmic.eu/tutorial/_fill_color.shtml

         gradient2rgb:
             _is_orientation={ 0 | 1 }

           Compute RGB representation of 2D gradient of selected images.

           Default value: 'is_orientation=0'.

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

         hcy2rgb:

           Convert color representation of selected images from HCY to RGB.

         hsi2rgb:

           Convert color representation of selected images from HSI to RGB.

         hsi82rgb:

           Convert color representation of selected images from HSI8 to RGB.

         hsl2rgb:

           Convert color representation of selected images from HSL to RGB.

         hsl82rgb:

           Convert color representation of selected images from HSL8 to RGB.

         hsv2rgb:

           Convert color representation of selected images from HSV to RGB.

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

         hsv82rgb:

           Convert color representation of selected images from HSV8 to RGB.

         int2rgb:

           Convert color representation of selected images from INT24 to  RGB.

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

           Convert color representation of selected images from RGB to Jzazbz.

           Default value: 'illuminant=2'.

         jzazbz2xyz:

           Convert color representation of selected images from RGB to XYZ.

         lab2lch:

           Convert color representation of selected images from Lab to Lch.

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

           Convert color representation of selected images from Lab to RGB.

           Default value: 'illuminant=2'.

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

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

           Convert color representation of selected images from Lab to sRGB.

           Default value: 'illuminant=2'.

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

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

           Convert color representation of selected images from Lab8 to  sRGB.

           Default value: 'illuminant=2'.

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

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

           Convert color representation of selected images from Lab to XYZ.

           Default value: 'illuminant=2'.

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

           Convert color representation of selected images from Lab8 to RGB.

           Default value: 'illuminant=2'.

         lch2lab:

           Convert color representation of selected images from Lch to Lab.

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

           Convert color representation of selected images from Lch to RGB.

           Default value: 'illuminant=2'.

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

           Convert color representation of selected images from Lch8 to RGB.

           Default value: 'illuminant=2'.

         luminance:

           Compute luminance of selected sRGB images.

           Example:
             [#1] image.jpg +luminance

         lightness:

           Compute lightness of selected sRGB images.

           Example:
             [#1] image.jpg +lightness

         lut_contrast:
             _nb_colors>1,_min_rgb_value

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

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

         map_clut:
             [clut] | "clut_name"

           Map specified RGB color LUT to selected images.

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

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

           Apply 33 specified matrix to RGB colors of selected images.

           Default values: 'a11=1', 'a12=a13=a21=0', 'a22=1',
            'a23=a31=a32=0' and 'a33=1'.

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

           Tutorial: https://gmic.eu/tutorial/_mix_rgb.shtml

         oklab2rgb:

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

         palette:
             palette_name | palette_number

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

           Example:
             [#1] palette hsv

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

           Generate  pseudogray  colormap with specified increment and percep-
       tual
           threshold.
           If 'JND_threshold' is 0, no perceptual constraints are applied.

           Default values: 'max_increment=5', 'JND_threshold=2.3'
            and 'bits_depth=8'.

           Example:
             [#1] pseudogray 5

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

           Replace pixels from/to specified colors in selected images.

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

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

           Apply  multi-scale  retinex algorithm on selected images to improve
       color
           consistency.
           (as described in the page http://www.ipol.im/pub/art/2014/107/).

           Default values: 'offset=1', 'colorspace=hsv',
            'min_cut=1', 'max_cut=1', 'sigma_low=15',
            'sigma_mid=80' and 'sigma_high=250'.

         rgb2bayer:
             _start_pattern=0,_color_grid=0

           Transform selected color images to RGB-Bayer sampled images.

           Default values: 'start_pattern=0' and 'color_grid=0'.

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

         rgb2cmy:

           Convert color representation of selected images from RGB to CMY.

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

         rgb2cmyk:

           Convert color representation of selected images from RGB to CMYK.

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

         rgb2hcy:

           Convert color representation of selected images from RGB to HCY.

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

         rgb2hsi:

           Convert color representation of selected images from RGB to HSI.

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

         rgb2hsi8:

           Convert color representation of selected images from RGB to HSI8.

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

         rgb2hsl:

           Convert color representation of selected images from RGB to HSL.

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

         rgb2hsl8:

           Convert color representation of selected images from RGB to HSL8.

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

         rgb2hsv:

           Convert color representation of selected images from RGB to HSV.

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

         rgb2hsv8:

           Convert color representation of selected images from RGB to HSV8.

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

         rgb2int:

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

           Example:
             [#1] image.jpg rgb2int

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

           Convert color representation of selected images from RGB to Jzazbz.

           Default value: 'illuminant=2'.

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

           Convert color representation of selected images from RGB to Lab.

           Default value: 'illuminant=2'.

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

           Convert color representation of selected images from RGB to Lab8.

           Default value: 'illuminant=2'.

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

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

           Convert color representation of selected images from RGB to Lch.

           Default value: 'illuminant=2'.

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

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

           Convert color representation of selected images from RGB to Lch8.

           Default value: 'illuminant=2'.

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

         rgb2luv:

           Convert color representation of selected images from RGB to LUV.

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

         rgb2oklab:

           Convert color representation of selected images from RGB to  Oklab.
           (see       colorspace      definition      at:      https://bottos-
       son.github.io/posts/oklab/
           fR ).
           See also: oklab2rgb.

         rgb2ryb:

           Convert color representation of selected images from RGB to RYB.

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

         rgb2srgb:

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

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

           Convert color representation of selected images from RGB to XYZ.

           Default value: 'illuminant=2'.

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

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

           Convert color representation of selected images from RGB to XYZ8.

           Default value: 'illuminant=2'.

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

         rgb2yiq:

           Convert color representation of selected images from RGB to YIQ.

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

         rgb2yiq8:

           Convert color representation of selected images from RGB to YIQ8.

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

         rgb2ycbcr:

           Convert  color representation of selected images from RGB to YCbCr.

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

         rgb2yuv:

           Convert color representation of selected images from RGB to YUV.

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

         rgb2yuv8:

           Convert color representation of selected images from RGB to YUV8.

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

         remove_opacity:

           Remove opacity channel of selected images.

         ryb2rgb:

           Convert color representation of selected images from RYB to RGB.

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

           Select pixels with specified color in selected images.

           Example:
             [#1] image.jpg +select_color 40,204,153,110

           Tutorial: https://gmic.eu/tutorial/_select_color.shtml

         sepia:

           Apply sepia tones effect on selected images.

           Example:
             [#1] image.jpg sepia

         solarize:

           Solarize selected images.

           Example:
             [#1] image.jpg solarize

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

           Example:
             [#1] image.jpg quantize 5 +split_colors , display_rgba

         split_opacity:

           Split color and opacity parts of selected images.

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

           Convert color representation of selected images from sRGB to Lab.

           Default value: 'illuminant=2'.

           Example:
             [#1] image.jpg srgb2lab split c
             [#2] image.jpg srgb2lab +split c mul[-2,-1] 2.5  append[-3--1]  c
       lab2srgb

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

           Convert  color representation of selected images from sRGB to Lab8.

           Default value: 'illuminant=2'.

         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.

           Example:
             [#1] image.jpg +to_gray

         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 TschumperlA(C).

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

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

         transfer_pca:
             [reference_image],_color_channels

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

           Default value: 'color_channels=all'.

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

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

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

         xyz2jzazbz:

           Convert color representation of selected images from XYZ to RGB.

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

           Convert color representation of selected images from XYZ to Lab.

           Default value: 'illuminant=2'.

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

           Convert color representation of selected images from XYZ to RGB.

           Default value: 'illuminant=2'.

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

           Convert color representation of selected images from XYZ8 to RGB.

           Default value: 'illuminant=2'.

         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.

         12.7. Geometry Manipulation
               ---------------------

         a (+):
             Shortcut for command 'append'.

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

           Append  specified  image to selected images, or all selected images
       together,
            along specified axis.
           (equivalent to shortcut command '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'.

           Example:
             [#1] image.jpg split y,10 reverse append y
             [#2] image.jpg repeat 5  +rows[0]  0,{10+18*$>}%  done  remove[0]
       append x,
              0.5
             [#3] image.jpg append[0] [0],y

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

           Example:
             [#1] image.jpg split xy,4 append_tiles ,

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

           Example:
             [#1] image.jpg apply_scales "blur 5 sharpen 1000",4

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

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

           Example:
             [#1]      400,400,1,3      fill_color      64,128,255     ellipse
       50%,50%,120,120,0,1,255
              +autocrop

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

           Example:
             [#1] 256,256 noise 0.1,2 eq 1 dilate_circ 20 label_fg 0,1 normal-
       ize 0,
              255 +neq 0 *[-1] 255 append c +autocrop_components ,

         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.

           Example:
             [#1] image.jpg +fill[-1] 0 ellipse[-1] 50%,50%,30%,20%,0,1,1
              autocrop_seq 0

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

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

           Example:
             [#1] image.jpg channels 0,1
             [#2] image.jpg luminance channels 0,2

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

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

           Example:
             [#1] image.jpg columns -25%,50%

         z (+):
             Shortcut for command 'crop'.

         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_condi-
       tions

           Crop selected images with specified region coordinates.
           (equivalent to shortcut command 'z').

           'boundary_conditions' can be { 0=dirichlet | 1=neumann |
           2=periodic | 3=mirror }.

           Default value: 'boundary_conditions=0'.

           Example:
             [#1]     image.jpg     +crop     -230,-230,280,280,1      crop[0]
       -230,-230,280,280,0
             [#2] image.jpg crop 25%,25%,75%,75%

         diagonal:

           Transform selected vectors as diagonal matrices.

           Example:
             [#1] 1,10,1,1,'y' +diagonal

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

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

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

           Expand selected images along the xy-axes.

           Default value: 'boundary_conditions=1'.

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

         expand_xyz:
             size>=0,_boundary_conditions={  0=dirichlet | 1=neumann | 2=peri-
       odic |
               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'.

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

         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:
             "condition",_output_type={ 0=xyzc-coordinates | 1=xyz-coordinates
       |
               2=scalar-values | 3=vector-values }

           Extract a list of coordinates or values from selected image, where
           specified mathematical condition holds.
           For N coordinates matching, result is a 1xNx1x4 image.

           Default values: 'output_type=0'.

           Example:
             [#1] sp lena +extract "norm(I)>128",3

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

           Example:
             [#1] image.jpg +blur 3 quantize. 4,0 +extract_region[0] [1],0,1,3

         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 index (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=""'.

           Example:
             [#1]  image.jpg  sample  ?  +plasma[0]  shape_cupid 256 normalize
       0,255
              frame 3,3,0 frame 10,10,255 to_rgb +montage A +montage[^-1]
              H1:V0:VH2:1H0:3

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

           Mirror selected images along specified axes.

           Example:
             [#1] image.jpg +mirror y +mirror[0] c
             [#2] image.jpg +mirror x +mirror y append_tiles 2,2

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

           Example:
             [#1] image.jpg permute yxzc

         r (+):
             Shortcut for command 'resize'.

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

           Resize selected images with specified geometry.
           (equivalent to shortcut command '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]).

           Default values: 'interpolation=1',
            'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           Example:
             [#1]    image.jpg    +resize[-1]    256,128,1,3,2     +resize[-1]
       120%,120%,1,3,0,1,
              0.5,0.5 +resize[-1] 120%,120%,1,3,0,0,0.2,0.2 +resize[-1]
              [0],[0],1,3,4

         ri:
             Shortcut for command 'resize_as_image'.

         resize_as_image:
             [reference],_interpolation,_boundary_conditions,_ax,_ay,_az,_ac

           Resize  selected  images  to  the geometry of specified [reference]
       image.
           (equivalent to shortcut command 'ri').

           Default values: 'interpolation=1',
            'boundary_conditions=0' and 'ax=ay=az=ac=0'.

           Example:
             [#1] image.jpg sample duck +resize_as_image[-1] [-2]

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

           Example:
             [#1] image.jpg resize2dx 32 resize_mn 800%,800%

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

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

         rr2d:
             Shortcut for command 'resize_ratio2d'.

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

           Resize selected images while preserving their aspect ratio.
           (equivalent to shortcut command 'rr2d').

           Default values: 'mode=0' and 'interpolation=6'.

         r2dx:
             Shortcut for command 'resize2dx'.

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

           Resize selected images along the x-axis, preserving 2D ratio.
           (equivalent to shortcut command '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'.

           Example:
             [#1] image.jpg +resize2dx 100,2 append x

         r2dy:
             Shortcut for command 'resize2dy'.

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

           Resize selected images along the y-axis, preserving 2D ratio.
           (equivalent to shortcut command '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'.

           Example:
             [#1] image.jpg +resize2dy 100,2 append x

         r3dx:
             Shortcut for command 'resize3dx'.

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

           Resize selected images along the x-axis, preserving 3D ratio.
           (equivalent to shortcut command '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'.

         r3dy:
             Shortcut for command 'resize3dy'.

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

           Resize selected images along the y-axis, preserving 3D ratio.
           (equivalent to shortcut command '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'.

         r3dz:
             Shortcut for command 'resize3dz'.

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

           Resize selected images along the z-axis, preserving 3D ratio.
           (equivalent to shortcut command '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[%],_cen-
       ter_y[%] |
             u,v,w,angle,interpolation,boundary_conditions,_center_x[%],_cen-
       ter_y[%],
               _center_z[%]

           Rotate  selected images with specified angle (in deg.), and option-
       ally 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)'
            .

           Example:
             [#1] image.jpg +rotate -25,1,2,50%,50% rotate[0] 25

         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.

           Example:
             [#1] image.jpg rows -25%,50%

         scale2x:

           Resize selected images using the Scale2x algorithm.

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

         scalex:

           Resize selected images using the Scale3 algorithm.

           Example:
             [#1] image.jpg threshold 50% resize 33%,33% +scale3

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

           Double  image  size  using directional cubic convolution interpola-
       tion,
           as described in     
           https://en.wikipedia.org/wiki/Directional_Cubic_Convolution_Interpolation.

           Default values: 'edge_threshold=1.15', 'exponent=5' and
            'extend_1px=0'.

           Example:
             [#1] image.jpg +scale_dcci2x ,

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

           Example:
             [#1] image.jpg seamcarve 60%

         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  inter-
       polation
           should be chosen.
           'boundary_conditions' can be { 0=dirichlet | 1=neumann |
           2=periodic | 3=mirror }.

           Default value: 'boundary_conditions=0' and
            'interpolation=0'.

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

         shrink_x:
             size_x>=0

           Shrink selected images along the x-axis.

           Example:
             [#1] image.jpg shrink_x 30

         shrink_xy:
             size>=0

           Shrink selected images along the xy-axes.

           Example:
             [#1] image.jpg shrink_xy 30

         shrink_xyz:
             size>=0

           Shrink selected images along the xyz-axes.

         shrink_y:
             size_y>=0

           Shrink selected images along the y-axis.

           Example:
             [#1] image.jpg shrink_y 30

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

           Example:
             [#1] 64 rand 0,100 +sort display_graph 400,300,3

         s (+):
             Shortcut for command 'split'.

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

           Example:
             [#1] image.jpg split c
             [#2] image.jpg split y,3
             [#3] image.jpg split x,-128
             [#4] 1,20,1,1,"1,2,3,4" +split -,2,3 append[1--1] y
             [#5] (1,2,2,3,3,3,4,4,4,4) +split x,0 append[1--1] y

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

           Example:
             [#1]  image.jpg  +local  split_tiles  5,4  blur  3,0  sharpen 700
       append_tiles
              4,5 endlocal

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

         y (+):
             Shortcut for command 'unroll'.

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

           Unroll selected images along specified axis.
           (equivalent to shortcut command 'y').

           Default value: 'axis=y'.

           Example:
             [#1] (1,2,3;4,5,6;7,8,9) +unroll y

         upscale_smart:
             width[%],_height[%],_depth,_smoothness>=0,_anisot-
       ropy=[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'.

           Example:
             [#1] image.jpg resize2dy 100 +upscale_smart 500%,500% append x

         warp (+):
             [warping_field],_mode,_interpolation,_boundary_condi-
       tions,_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'.

           Example:
             [#1]                                                    image.jpg
       100%,100%,1,2,'X=x/w-0.5;Y=y/h-0.5;R=(X*X+Y*Y)^0.5;A=atan
              2(Y,X);130*R*if(c==0,cos(4*A),sin(8*A))' warp[-2] [-1],1,1,0
              quiver[-1] [-1],10,1,1,1,100

           Tutorial: https://gmic.eu/tutorial/_warp.shtml

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

         warp_rbf:
             xs0[%],ys0[%],xt0[%],yt0[%],...,xsN[%],ysN[%],xtN[%],ytN[%]

           Warp selected images using RBF-based interpolation.
           Each argument (xsk,ysk)-(xtk,ytk) corresponds to the coordinates of
       a
           keypoint
           respectively  on  the source and target images. The set of all key-
       points
           define the overall image deformation.

           Example:
             [#1]                     image.jpg                      +warp_rbf
       0,0,0,0,100%,0,100%,0,100%,100%,100%,100%,0,
              100%,0,100%,50%,50%,70%,50%,25%,25%,25%,75%

         12.8. Filtering
               ---------

         bandpass:
             _min_freq[%],_max_freq[%]

           Apply bandpass filter to selected images.

           Default values: 'min_freq=0' and 'max_freq=20%'.

           Example:
             [#1] image.jpg bandpass 1%,3%

           Tutorial: https://gmic.eu/tutorial/_bandpass.shtml

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

           Blur selected images by anisotropic (eventually joint/cross) bilat-
       eral
           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.

           Example:
             [#1] image.jpg repeat 5 bilateral 10,10 done

         b (+):
             Shortcut for command 'blur'.

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

           Blur selected images by a deriche or gaussian filter (recursive
           implementation).
           (equivalent to shortcut command 'b').

           'boundary_conditions' can be { 0=dirichlet | 1=neumann }.
           'kernel' can be { 0=deriche | 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=1'.

           Example:
             [#1] image.jpg +blur 5,0 +blur[0] 5,1
             [#2] image.jpg +blur y,10%

           Tutorial: https://gmic.eu/tutorial/_blur.shtml

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

           Apply angular blur on selected images.

           Default values: 'center_x=center_y=50%'.

           Example:
             [#1] image.jpg blur_angular 2%

           Tutorial: https://gmic.eu/tutorial/_blur_angular.shtml

         blur_bloom:
             _amplitude>=0,_ratio>=0,_nb_iter>=0,_blend_operator={  +  | max |
       min },
               _kernel={ 0=deriche | 1=gaussian | 2=box | 3=triangle |  4=qua-
       dratic
               },_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=1',
            'normalize_scales=0' and 'axes=(all)'

           Example:
             [#1] image.jpg blur_bloom ,

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

           Example:
             [#1] image.jpg blur_linear 10,0,45

           Tutorial: https://gmic.eu/tutorial/_blur_linear.shtml

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

           Apply radial blur on selected images.

           Default values: 'center_x=center_y=50%'.

           Example:
             [#1] image.jpg blur_radial 2%

           Tutorial: https://gmic.eu/tutorial/_blur_radial.shtml

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

           Example:
             [#1] image.jpg noise 20 cut 0,255 +local[-1] repeat 4 blur_selec-
       tive ,
              done endlocal

           Tutorial: https://gmic.eu/tutorial/_blur_selective.shtml

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

           Blur selected images along the x-axis.

           Default value: 'boundary_conditions=1'.

           Example:
             [#1] image.jpg +blur_x 6

           Tutorial: https://gmic.eu/tutorial/_blur_x.shtml

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

           Example:
             [#1] image.jpg +blur_xy 6

           Tutorial: https://gmic.eu/tutorial/_blur_xy.shtml

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

           Tutorial: https://gmic.eu/tutorial/_blur_xyz.shtml

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

           Blur selected images along the y-axis.

           Default value: 'boundary_conditions=1'.

           Example:
             [#1] image.jpg +blur_y 6

           Tutorial: https://gmic.eu/tutorial/_blur_y.shtml

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

           Blur selected images along the z-axis.

           Default value: 'boundary_conditions=1'.

           Tutorial: https://gmic.eu/tutorial/_blur_z.shtml

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

           Example:
             [#1] image.jpg +boxfilter 5%
             [#2] image.jpg +boxfilter y,3,1

         bump2normal:

           Convert selected bumpmaps to normalmaps.

           Example:
             [#1] 300,300 circle 50%,50%,128,1,1 blur 5% bump2normal

         compose_freq:

           Compose selected low and high frequency parts into new images.

           Example:
             [#1] image.jpg split_freq 2% mirror[-1] x compose_freq

         convolve (+):
             [mask],_boundary_conditions,_is_normalized={  0  |   1   },_chan-
       nel_mode,
               _xcenter,_ycenter,_zcenter,_xstart,_ystart,_zstart,_xend,_yend,
               _zend,_xstride,_ystride,_zstride,_xdilation,_ydilation,_zdila-
       tion

           Convolve selected images by specified mask.
           'boundary_conditions' can be { 0=dirichlet | 1=neumann |
           2=periodic | 3=mirror }.
           'channel_mode' can be { 0=sum input channels | 1=one-for-one |
           2=expand }.

           Default values: 'boundary_conditions=1',
            'is_normalized=0', 'channel_mode=1',
            'xcenter=ycenter=zcenter=-1' (-1=centered),
            'xstart=ystart=zstart=0', 'xend=yend=zend=-1' (-1=max
            coordinates), 'xstride=ystride=zstride=1' and
            'xdilation=ydilation=zdilation=1'.

           Example:
             [#1] image.jpg (0,1,0;1,-4,1;0,1,0) convolve[-2] [-1] keep[-2]
             [#2] image.jpg (0,1,0) resize[-1] 130,1,1,1,3 +convolve[0] [1]

           Tutorial: https://gmic.eu/tutorial/_convolve.shtml

         convolve_fft:
             [mask],_boundary_conditions

           Convolve  selected  images  with  specified  mask,  in  the fourier
       domain.
           'boundary_conditions' can be { 0=dirichlet | 1=neumann |
           2=periodic | 3=mirror }.

           Example:
             [#1] image.jpg 100%,100%  gaussian[-1]  20,1,45  +convolve_fft[0]
       [1]

         correlate (+):
             [mask],_boundary_conditions,_is_normalized={   0   |  1  },_chan-
       nel_mode,
               _xcenter,_ycenter,_zcenter,_xstart,_ystart,_zstart,_xend,_yend,
               _zend,_xstride,_ystride,_zstride,_xdilation,_ydilation,_zdila-
       tion

           Correlate selected images by specified mask.
           'boundary_conditions' can be { 0=dirichlet | 1=neumann |
           2=periodic | 3=mirror }.
           'channel_mode' can be { 0=sum input channels | 1=one-for-one |
           2=expand }.

           Default values: 'boundary_conditions=1',
            'is_normalized=0', 'channel_mode=1',
            'xcenter=ycenter=zcenter=-1' (-1=centered),
            'xstart=ystart=zstart=0', 'xend=yend=zend=-1' (-1=max
            coordinates), 'xstride=ystride=zstride=1' and
            'xdilation=ydilation=zdilation=1'.

           Example:
             [#1] image.jpg (0,1,0;1,-4,1;0,1,0) correlate[-2] [-1] keep[-2]
             [#2] image.jpg +crop 40%,40%,60%,60% +correlate[0] [-1],0,1

         cross_correlation:
             [mask]

           Compute cross-correlation of selected images with specified mask.

           Example:
             [#1] image.jpg +shift -30,-20 +cross_correlation[0] [1]

         curvature:

           Compute isophote curvatures on selected images.

           Example:
             [#1] image.jpg blur 10 curvature

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

           Compute the discrete cosine transform of selected  images,  option-
       ally along
           the specified axes only.
           Output  images  are always evenly sized, so this command may change
       the size
           of the selected images.

           Default values: (no arg)
           See also: idct.

           Example:
             [#1] image.jpg +dct +idct[-1] abs[-2] +[-2] 1 log[-2]

           Tutorial: https://gmic.eu/tutorial/_dct-and-idct.shtml

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

           Example:
             [#1] image.jpg blur 3 +deblur 3,40,20,0.01

         deblur_goldmeinel:
             sigma>=0,_nb_iter>=0,_acceleration>=0,_kernel_type={ 0=deriche |
               1=gaussian }.

           Deblur selected images using Gold-Meinel algorithm

           Default values: 'nb_iter=8', 'acceleration=1' and
            'kernel_type=1'.

           Example:
             [#1] image.jpg +blur 1 +deblur_goldmeinel[-1] 1

         deblur_richardsonlucy:
             sigma>=0, nb_iter>=0, _kernel_type={ 0=deriche | 1=gaussian }.

           Deblur selected images using Richardson-Lucy algorithm.

           Default values: 'nb_iter=50' and 'kernel_type=1'.

           Example:
             [#1] image.jpg +blur 1 +deblur_richardsonlucy[-1] 1

         deconvolve_fft:
             [kernel],_regularization>=0

           Deconvolve  selected images by specified mask in the fourier space.

           Default value: 'regularization>=0'.

           Example:
             [#1]  image.jpg  +gaussian   5   +convolve_fft[0]   [1]   +decon-
       volve_fft[-1] [1]

         deinterlace:
             _method={ 0 | 1 }

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

           Default value: 'method=0'.

           Example:
             [#1]  image.jpg  +rotate  3,1,1,50%,50%  resize  100%,50%  resize
       100%,200%,1,
              3,4 shift[-1] 0,1 add +deinterlace 1

         denoise (+):
             [guide],std_deviation_s[%]>=0,_std_devia-
       tion_r[%]>=0,_patch_size>0,
               _lookup_size>0,_smoothness,_fast_approx={ 0 | 1 } |
             std_deviation_s[%]>=0,_std_devia-
       tion_r[%]>=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'.

           Example:
             [#1] image.jpg +denoise 5,5,8

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

           Example:
             [#1] image.jpg noise 20 cut 0,255 +denoise_haar[-1] 0.8

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

           Example:
             [#1] image.jpg +noise 20 cut[-1] 0,255 +denoise_patchpca[-1] ,

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

           Example:
             [#1] image.jpg deriche 3,1,x
             [#2] image.jpg +deriche 30,0,x deriche[-2] 30,0,y add

           Tutorial: https://gmic.eu/tutorial/_deriche.shtml

         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 structur-
       ing
           element.
           'boundary_conditions' can be { 0=dirichlet | 1=neumann }.

           Default values: 'size_z=1', 'boundary_conditions=1' and
            'is_real=0'.

           Example:
             [#1] image.jpg +dilate 10

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

           Example:
             [#1] image.jpg +dilate_circ 7

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

           Example:
             [#1] image.jpg +dilate_oct 7

         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.

           Example:
             [#1] image.jpg luminance +gradient append[-2,-1] c divergence[-1]

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

           Compute difference of gaussian on selected images.

           Default values: 'sigma1=2%' and 'sigma2=3%'.

           Example:
             [#1] image.jpg dog 2,3

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

           Compute the diffusion tensors of selected images for  edge-preserv-
       ing
           smoothing algorithms.

           Default values: 'sharpness=0.7', 'anisotropy=0.3',
            'alpha=0.6', 'sigma=1.1' and 'is_sqrt=0'.

           Example:
             [#1] image.jpg diffusiontensors 0.8 abs pow 0.2

           Tutorial: https://gmic.eu/tutorial/_diffusiontensors.shtml

         edges:
             _threshold[%]>=0

           Estimate contours of selected images.

           Default value: 'edges=15%'

           Example:
             [#1] image.jpg +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'.

           Example:
             [#1] image.jpg +erode 10

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

           Example:
             [#1] image.jpg +erode_circ 7

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

           Example:
             [#1] image.jpg +erode_oct 7

         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.
           See also: ifft.

           Example:
             [#1] image.jpg luminance +fft append[-2,-1] c norm[-1] log[-1]
              shift[-1] 50%,50%,0,0,2
             [#2]    image.jpg    w2={int(w/2)}    h2={int(h/2)}   fft   shift
       $w2,$h2,0,0,2
              ellipse $w2,$h2,30,30,0,1,0 shift -$w2,-$h2,0,0,2 ifft
              remove[-1]

           Tutorial: https://gmic.eu/tutorial/_fft.shtml

         g (+):
             Shortcut for command 'gradient'.

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

           Compute the gradient components  (first  derivatives)  of  selected
       images.
           (equivalent to shortcut command '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 components.

           Default value: 'scheme=0'.

           Example:
             [#1] image.jpg gradient

           Tutorial: https://gmic.eu/tutorial/_gradient.shtml

         gradient_norm:

           Compute gradient norm of selected images.

           Example:
             [#1] image.jpg gradient_norm equalize

           Tutorial: https://gmic.eu/tutorial/_gradient_norm.shtml

         gradient_orientation:
             _dimension={1,2,3}

           Compute N-d gradient orientation of selected images.

           Default value: 'dimension=3'.

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

         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",
           IEEE  Transactions  on  Pattern  Analysis and Machine Intelligence,
       vol.35,
           no.6, pp.1397,1409, June 2013

           Example:
             [#1] image.jpg +guided 5,400

         haar:
             scale>0

           Compute the direct haar multiscale wavelet  transform  of  selected
       images.
           See also: ihaar.

           Tutorial: https://gmic.eu/tutorial/_haar.shtml

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

           Example:
             [#1] image.jpg +heat_flow 20

         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.

           Example:
             [#1] image.jpg hessian

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

           Compute the inverse discrete cosine transform of selected images,
           optionally along the specified axes only.
           Output  images  are always evenly sized, so this command may change
       the size
           of the selected images.
           (dct images obtained with the 'dct' command are evenly  sized  any-
       way).

           Default values: (no arg)
           See also: dct.

           Tutorial: https://gmic.eu/tutorial/_dct-and-idct.shtml

         iee:

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

           Example:
             [#1] image.jpg iee

         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.
           See also: fft.

           Tutorial: https://gmic.eu/tutorial/_fft.shtml

         ihaar:
             scale>0

           Compute the inverse haar multiscale wavelet transform  of  selected
       images.
           See also: haar.

         ilaplacian:
             { nb_iterations>0 | 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.
           Note that the resulting inversions are just estimation of
           possible/approximated solutions.

           Default values: 'nb_iterations=0' and
            '[initial_estimated]=(undefined)'.

           Example:
             [#1] image.jpg +laplacian +ilaplacian[-1] 0

         inn:

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

           Example:
             [#1] image.jpg inn

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

           Example:
             [#1] image.jpg 100%,100%  ellipse  50%,50%,30,30,0,1,255  ellipse
       20%,20%,
              30,10,0,1,255 +inpaint[-2] [-1] remove[-2]
             [#2]  image.jpg  100%,100%  circle  30%,30%,30,1,255,0,255 circle
       70%,70%,
              50,1,255,0,255 +inpaint[0] [1],5,15,0.5,1,9,0 remove[1]

         inpaint_pde:
             [mask],_nb_scales[%]>=0,_diffusion_type={ 0=isotropic |  1=delau-
       nay-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 dis-
       tance
           function) are used
           to guide the diffusion process.

           Default values: 'nb_scales=75%', 'diffusion_type=1' and
            'diffusion_iter=20'.

           Example:
             [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255
              +inpaint_pde[0] [1]

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

           Apply iteration of the inpainting flow on selected images.

           Default values: 'nb_global_iter=10', 'nb_local_iter=100',
             'dt=5', 'alpha=1' and 'sigma=3'.

           Example:
             [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255
              inpaint_flow[0] [1]

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

           Example:
             [#1] image.jpg noise 5%,2 +inpaint_holes 8,40

         inpaint_morpho:
             [mask]

           Inpaint selected images by specified mask using morphological oper-
       ators.

           Example:
             [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255
              +inpaint_morpho[0] [1]

         inpaint_matchpatch:
             [mask],_nb_scales={   0=auto   |   >0  },_patch_size>0,_nb_itera-
       tions_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'.

           Example:
             [#1] image.jpg 100%,100% ellipse[-1] 30%,30%,40,30,0,1,255
              +inpaint_matchpatch[0] [1]

         kuwahara:
             size>0

           Apply Kuwahara filter of specified size on selected images.

           Example:
             [#1] image.jpg kuwahara 9

         laplacian:

           Compute Laplacian of selected images.

           Example:
             [#1] image.jpg laplacian

         lic:
             _amplitude>0,_channels>0

           Render LIC representation of selected vector fields.

           Default values: 'amplitude=30' and 'channels=1'.

           Example:
             [#1]  400,400,1,2,'if(c==0,x-w/2,y-h/2)'  +lic  200,3  quiver[-2]
       [-2],10,1,
              1,1,255

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

           Example:
             [#1] image.jpg +map_tones ,

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

           Apply fast tone mapping operator on selected images.

           Default values: 'radius=3%' and 'power=0.3'.

           Example:
             [#1] image.jpg +map_tones_fast ,

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

           Example:
             [#1] image.jpg +meancurvature_flow 20

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

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

           Example:
             [#1] image.jpg +median 5

         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 euclidean distance between image patches.

           Default values: 'patch_radius=4', 'spatial_bandwidth=4',
            'tonal_bandwidth=10' and 'patch_measure_command=-norm'.

           Example:
             [#1] image.jpg +noise 10 nlmeans[-1] 4,4,{0.6*${-std_noise}}

         nlmeans_core:
             _reference_image,_scaling_map,_patch_radius>0,_spatial_band-
       width>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'.

           Example:
             [#1] image.jpg normalize_local 8,10

         normalized_cross_correlation:
             [mask]

           Compute normalized cross-correlation of selected images with speci-
       fied
           mask.

           Example:
             [#1]  image.jpg  +shift  -30,-20 +normalized_cross_correlation[0]
       [1]

         percentile:
             [mask],0<=_min_percentile[%]<=100,0<=_max_percentile[%]<=100.

           Apply percentile averaging filter to selected images.

           Default values: 'min_percentile=0' and
            'max_percentile=100'.

           Example:
             [#1] image.jpg shape_circle 11,11 +percentile[0] [1],25,75

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

           Example:
             [#1] image.jpg +heat_flow 20

         phase_correlation:
             [destination]

           Estimate translation vector  between  selected  source  images  and
       specified
           destination.

           Example:
             [#1]   image.jpg   +shift   -30,-20   +phase_correlation[0]   [1]
       unroll[-1] y

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

           Example:
             [#1] image.jpg +pde_flow 20

         periodize_poisson:

           Periodize selected images using a Poisson solver in Fourier  space.

           Example:
             [#1] image.jpg +periodize_poisson array 2,2,2

         rbf:
             dx,_x0,_x1,_phi(r) |
             dx,dy,_x0,_y0,_x1,_y1,_phi(r) |
             dx,dy,dz,x0,y0,z0,x1,y1,z1,phi(r)

           Reconstruct 1D/2D or 3D image from selected sets of keypoints, by
           RBF-interpolation.
           A  set  of keypoints is represented by a vector-valued image, where
       each
           pixel represents a single keypoint.
           Vector components of a keypoint have the following meaning:
              -  For 1D reconstruction: [ x_k, f1(k),...fN(k) ].
              -  For 2D reconstruction: [ x_k,y_k, f1(k),...,fN(k) ].
              -  For 3D reconstruction: [ x_k,y_k,z_k, f1(k),...,fN(k) ].
           Values 'x_k','y_k' and 'z_k' are the spatial coordinates
           of keypoint 'k'.
           Values 'f1(k),..,fN(k)' are the 'N' components of the vector
           value of keypoint 'k'.
           The   command   reconstructs   an   image   with   specified   size
       'dx'x'dy'x'dz',
            with 'N' channels.

           Default values: 'x0=y0=z0=0', 'x1=dx-1', 'y1=dy-1',
             'z1=dz-1', 'phi(r)=r^2*log(1e-5+r)'.

           Example:
             [#1]   sp  colorful  r2dx  400  100%,100%  noise_poissondisk.  10
       1,{is},1,5
              eval[-2] "begin(p=0);i?(I[#-1,p++]=[x,y,I(#0)])" to_rgb[1]
              mul[0,1] dilate_circ[0] 5 +rbf[-1] {0,[w,h]} c[-1] 0,255
             [#2] 32,1,1,5,u([400,400,255,255,255]) rbf 400,400 c 0,255

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

           Example:
             [#1] image.jpg +red_eye ,

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

           Remove hot pixels in selected images.

           Default values: 'mask_size=3' and 'threshold=10%'.

           Example:
             [#1] image.jpg noise 10,2 +remove_hotpixels ,

         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.

           Example:
             [#1] image.jpg +remove_pixels 50%

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

           Example:
             [#1] image.jpg +rolling_guidance , +-

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

           Sharpen selected images by inverse diffusion or shock filters meth-
       ods.
           'edge' must be specified to enable shock-filter method.

           Default values: 'alpha=0' and 'sigma=0'.

           Example:
             [#1] image.jpg sharpen 300
             [#2] image.jpg blur 5 sharpen 300,1

         smooth (+):
             amplitude[%]>=0,_sharpness>=0,0<=_anisot-
       ropy<=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,_interpola-
       tion,
               _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'.

           Example:
             [#1] image.jpg repeat 3 smooth 40,0,1,1,2 done
             [#2]   image.jpg   100%,100%,1,2   rand[-1]   -100,100  repeat  2
       smooth[-1] 100,
              0.2,1,4,4 done warp[0] [-1],1,1

           Tutorial: https://gmic.eu/tutorial/_smooth.shtml

         split_freq:
             smoothness>0[%]

           Split selected images into low and high frequency parts.

           Example:
             [#1] image.jpg split_freq 2%

         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  algo-
       rithm.
           If 'nb_scales=0', the number of scales is automatically determined.

           Default values: 'nb_iterations=60', 'dt=5' and
            'nb_scales=0'.

           Example:
             [#1] image.jpg command "foo  :  gradient  x"  +solve_poisson  foo
       +foo[0]
              +laplacian[1]

         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  devia-
       tions.

           Default values: 'nb_scales=4', 'base_scale=0' and
            'detail_scale=0'.

           Example:
             [#1] image.jpg split_details ,

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

           Compute the structure tensor field of selected images.

           Default value: 'scheme=1'.

           Example:
             [#1] image.jpg structuretensors abs pow 0.2

           Tutorial: https://gmic.eu/tutorial/_structuretensors.shtml

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

           Solidify selected transparent images.

           Default values: 'smoothness=75%', 'diffusion_type=1' and
            'diffusion_iter=20'.

           Example:
             [#1] image.jpg 100%,100% circle[-1] 50%,50%,25%,1,255 append c
              +solidify , display_rgba

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

           Example:
             [#1] image.jpg crop 2,282,50,328 +syntexturize 320,320

         syntexturize_matchpatch:
             _width[%]>0,_height[%]>0,_nb_scales>=0,_patch_size>0,_blend-
       ing_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'.

           Example:
             [#1]   image.jpg   crop  25%,25%,75%,75%  syntexturize_matchpatch
       512,512

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

           Example:
             [#1] image.jpg +tv_flow 40

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

           Apply unsharp mask on selected images.

           Default values: 'amount=2' and 'threshold=0'.

           Example:
             [#1] image.jpg blur 3 +unsharp 1.5,15 cut 0,255

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

           Example:
             [#1] image.jpg blur 3 +unsharp_octave 4,5,15 cut 0,255

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

           Example:
             [#1] image.jpg +vanvliet 3,1,x
             [#2] image.jpg +vanvliet 30,0,x vanvliet[-2] 30,0,y add

         voronoi:

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

           Example:
             [#1]  400,400  noise  0.2,2  eq 1 +label_fg 0 voronoi[-1] +gradi-
       ent[-1] xy,
              1 append[-2,-1] c norm[-1] ==[-1] 0 map[-2] 2,2 mul[-2,-1]
              normalize[-2] 0,255 dilate_circ[-2] 4 reverse max

         watermark_fourier:
             text,_size>0

           Add a textual watermark in the frequency domain of selected images.

           Default value: 'size=33'.

           Example:
             [#1]  image.jpg  +watermark_fourier  "Watermarked!"  +display_fft
       remove[-3,
              -1] normalize 0,255 append[-4,-2] y append[-2,-1] y

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

           Compute the watershed transform of selected images.

           Default value: 'is_high_connectivity=1'.

           Example:
             [#1] 400,400 noise 0.2,2 eq 1 +distance 1 mul[-1] -1 label[-2]
              watershed[-2] [-1] mod[-2] 256 map[-2] 0 reverse

         12.9. Features Extraction
               -------------------

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

           Compute area of connected components in selected images.

           Default values: 'is_high_connectivity=0'.

           Example:
             [#1] image.jpg luminance stencil[-1] 1 +area 0

           Tutorial: https://gmic.eu/tutorial/_area.shtml

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

           Example:
             [#1] image.jpg luminance stencil[-1] 1 +area_fg 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).

           Example:
             [#1]     image.jpg     +at_line     0,0,0,100%,100%,0     line[0]
       0,0,100%,100%,1,
              0xFF00FF00,255,0,0

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

           Example:
             [#1] image.jpg params=5%,5%,95%,5%,60%,95%,40%,95% +at_quadrangle
              $params polygon.. 4,$params,0.5,255

         barycenter:

           Compute the barycenter vector of pixel values.

           Example:
             [#1] 256,256 ellipse 50%,50%,20%,20%,0,1,1 deform 20 +barycenter
              +ellipse[-2] {@0,1},5,5,0,10

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

           Example:
             [#1] 400,400 rand 32,255 100%,100% noise. 0.4,2 eq. 1 mul +delau-
       nay
             [#2]  image.jpg  b  1% 100%,100% noise. 0.8,2 eq. 1 mul +delaunay
       channels
              0,2

         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,_itera-
       tion_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)'.

           Example:
             [#1]  image.jpg  +rotate  3,1,0,50%,50%  +displacement[-1]   [-2]
       quiver[-1]
              [-1],15,1,1,1,{1.5*iM}

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

           Example:
             [#1] image.jpg threshold 20% distance 0 pow 0.3
             [#2] 400,400 set 1,50%,50% +distance[0] 1,2 +distance[0] 1,1
              distance[0] 1,0 mod 32 threshold 16 append c

           Tutorial: https://gmic.eu/tutorial/_distance.shtml

         fftpolar:

           Compute  fourier  transform  of selected images, as centered magni-
       tude/phase
           images.

           Example:
             [#1] image.jpg fftpolar ellipse 50%,50%,10,10,0,1,0 ifftpolar

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

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

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

           Example:
             [#1] image.jpg channels 0,1 +histogram_nd 256

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

           Example:
             [#1]   image.jpg   +histogram_cumul  256  histogram[0]  256  dis-
       play_graph 400,
              300,3

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

           Example:
             [#1] image.jpg +blur 1.5 hough[-1] 400,400 blur[-1] 0.5 add[-1] 1
              log[-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'

           Example:
             [#1] image.jpg blur 2 isophotes 6 dilate_circ 5 display_rgba

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

           Label connected components in selected images.

           Default values: 'tolerance=0', 'is_high_connectivity=0'
            and 'is_L2_norm=1'.

           Example:
             [#1]  image.jpg luminance threshold 60% label normalize 0,255 map
       0
             [#2] 400,400 set 1,50%,50% distance 1 mod 16  threshold  8  label
       mod 255
              map 2

           Tutorial: https://gmic.eu/tutorial/_label.shtml

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

         laar:

           Extract the largest axis-aligned rectangle  in  non-zero  areas  of
       selected
           images.
           Rectangle coordinates are returned in status, as a sequence of num-
       bers x0,
           y0,x1,y1.

           Example:
             [#1] shape_cupid 256 coords=${-laar} normalize 0,255 to_rgb  rec-
       tangle
              $coords,0.5,0,128,0

         max_patch:
             _patch_size>=1

           Return  locations  of maximal values in local patch-based neighbor-
       hood of
           given size for selected images.

           Default value: 'patch_size=16'.

           Example:
             [#1] image.jpg norm +max_patch 16

         min_patch:
             _patch_size>=1

           Return locations of minimal values in local  patch-based  neighbor-
       hood of
           given size for selected images.

           Default value: 'patch_size=16'.

           Example:
             [#1] image.jpg norm +min_patch 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'.

           Example:
             [#1] image.jpg +gradient_norm fill[-1]  1/(1+i)  minimal_path[-1]
       0,0,0,
              100%,100%,0 pointcloud[-1] 0 *[-1] 280 to_rgb[-1] ri[-1]
              [-2],0 or

         mse (+):

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

           Example:
             [#1] image.jpg +noise 30 +noise[0] 35 +noise[0] 38 cut. 0,255 mse

         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.

           Example:
             [#1]                      image.jpg                      +patches
       64,64,1,153,124,0,184,240,0,217,126,0,275,38,0

         matchpatch (+):
             [patch_image],patch_width>=1,_patch_height>=1,_patch_depth>=1,
               _nb_iterations>=0,_nb_randoms>=0,_patch_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.
           If 'patch_penalization' is >=0, SSD is penalized with patch
           occurrences.
           If 'patch_penalization' is <0, SSD is inf-penalized when distance
           between patches are less than '-patch_penalization'.

           Default values: 'patch_height=patch_width',
            'patch_depth=1', 'nb_iterations=5', 'nb_randoms=5',
            'patch_penalization=0', 'output_score=0' and
            'guide=(undefined)'.

           Example:
             [#1]  image.jpg  sample  colorful  +matchpatch[0] [1],3 +warp[-2]
       [-1],0

         plot2value:

           Retrieve values from selected 2D graph plots.

           Example:
             [#1] 400,300,1,1,'if(y>300*abs(cos(x/10+2*u)),1,0)' +plot2value
              +display_graph[-1] 400,300

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

           Example:
             [#1] 3000,2 rand 0,400 +pointcloud 0 dilate[-1] 3
             [#2]  3000,2 rand 0,400 {w} {w},3 rand[-1] 0,255 append y +point-
       cloud 0
              dilate[-1] 3

         psnr:
             _max_value

           Compute PSNR (Peak Signal-to-Noise Ratio) matrix  between  selected
       images.

           Default value: 'max_value=255'.

           Example:
             [#1]  image.jpg +noise 30 +noise[0] 35 +noise[0] 38 cut[-1] 0,255
       psnr
              255 replace_inf 0

         segment_watershed:
             _threshold>=0

           Apply watershed segmentation on selected images.

           Default values: 'threshold=2'.

           Example:
             [#1] image.jpg segment_watershed 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 con-
       strained
           thinning.

           Default value: 'boundary_conditions=1'.

           Example:
             [#1] shape_cupid 320 +skeleton 0

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

           Segment selected 2D images with superpixels, using the  SLIC  algo-
       rithm
           (Simple Linear Iterative Clustering).
           Scalar images of increasingly labeled pixels are returned.
           Reference  paper:  Achanta,  R.,  Shaji, A., Smith, K., Lucchi, A.,
       Fua, P., &
           Susstrunk, S. (2010). SLIC Superpixels (No. EPFL-REPORT-149300).

           Default values: 'size=16', 'regularity=10' and
            'nb_iterations=10'.

           Example:
             [#1] image.jpg +srgb2lab slic[-1] 16  +blend  shapeaverage  f[-2]
       "j(1,
              0)==i && j(0,1)==i" *[-1] [-2]

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

           Example:
             [#1] image.jpg +crop 20%,20%,35%,35% +ssd_patch[0] [1],0,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'.

           Example:
             [#1] shape_cupid 320 +thinning

         tones:
             N>0

           Get N tones masks from selected images.

           Example:
             [#1] image.jpg +tones 3

         topographic_map:
             _nb_levels>0,_smoothness

           Render selected images as topographic maps.

           Default values: 'nb_levels=16' and 'smoothness=2'.

           Example:
             [#1] image.jpg topographic_map 10

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

           Example:
             [#1] 256,1,1,2 rand 0,512 tsp , 512,512,1,3 repeat w#0 circle[-1]
       {0,
              I[$>]},2,1,255,255,255 line[-1] {0,boundary=2;[I[$>],
              I[$>+1]]},1,255,128,0 done keep[-1]

         variance_patch:
             _patch_size>=1

           Compute  variance  of  each  images  patch  centered  at  (x,y), in
       selected
           images.

           Default value: 'patch_size=16'

           Example:
             [#1] image.jpg +variance_patch

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

           Example:
             [#1]         400,400,1,3         repeat         100         arrow
       50%,50%,{u(100)}%,{u(100)}%,3,20,10,
              0.3,${-rgb} done

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

           Example:
             [#1] 400,400,1,3,255 axes -1,1,1,-1

         ball:
             _size>0,                _R,_G,_B,0<=_specular_light<=8,0<=_specu-
       lar_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'.

           Example:
             [#1] repeat 9 ball {1.5^($>+2)},${-rgb} done append x

         chessboard:
             size1>0,_size2>0,_offset1,_offset2,_angle,_opac-
       ity,_color1,...,_color2,...

           Draw chessboard on selected images.

           Default values: 'size2=size1', 'offset1=offset2=0',
            'angle=0', 'opacity=1', 'color1=0' and
            'color2=255'.

           Example:
             [#1] image.jpg chessboard 32,32,0,0,25,0.3,255,128,0,0,128,255

         cie1931:

           Draw CIE-1931 chromaticity diagram on selected images.

           Example:
             [#1] 500,400,1,3 cie1931

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

           Example:
             [#1] image.jpg repeat 300 circle {u(100)}%,{u(100)}%,{u(30)},0.3,
              ${-rgb} done circle 50%,50%,100,0.7,255

         close_binary:
             0<=_endpoint_rate<=100,_endpoint_connectivity>=0,_spline_dist-
       max>=0,
               _segment_distmax>=0,0<=_spline_anglemax<=180,_spline_round-
       ness>=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'.

           Example:
             [#1]         image.jpg         repeat         300         ellipse
       {u(100)}%,{u(100)}%,{u(30)},{u(30)},
              {u(180)},0.3,${-rgb} done ellipse 50%,50%,100,100,0,0.7,255

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

           Example:
             [#1]         image.jpg         repeat         1000          flood
       {u(100)}%,{u(100)}%,0,20,0,1,${-rgb}
              done

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

           Draw  a  centered gaussian on selected images, with specified stan-
       dard
           deviations and orientation.

           Default values: 'sigma1=3', 'sigma2=sigma1' and
            'angle=0'.

           Example:
             [#1] 400,400 gaussian 100,30,45

           Tutorial: https://gmic.eu/tutorial/_gaussian.shtml

         graph (+):
             [function_image],_plot_type,_vertex_type,_ymin,_ymax,_opac-
       ity,_pattern,
               _color1,... |
             'formula',_resolution>=0,_plot_type,_ver-
       tex_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'.

           Example:
             [#1] image.jpg +rows  50%  blur[-1]  3  split[-1]  c  div[0]  1.5
       graph[0] [1],
              2,0,0,0,1,255,0,0 graph[0] [2],2,0,0,0,1,0,255,0 graph[0]
              [3],2,0,0,0,1,0,0,255 keep[0]

         grid:
             size_x[%]>=0,size_y[%]>=0,_offset_x[%],_offset_y[%],_opac-
       ity,_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'.

           Example:
             [#1] image.jpg grid 10%,10%,0,0,0.5,255
             [#2] 400,400,1,3,255 grid 10%,10%,0,0,0.3,0xCCCCCCCC,128,32,16

         j (+):
             Shortcut for command 'image'.

         image (+):
             [sprite],_x[%|~],_y[%|~],_z[%|~],_c[%|~],_opacity,_[opac-
       ity_mask],
               _max_opacity_mask

           Draw specified sprite image on selected images.
           (equivalent to shortcut command 'j').

           If one of the x,y,z or c argument ends with a '~', its value is
           expected to be
           a centering ratio (in [0,1]) rather than a position.
           Usual centering ratio are { 0=left-justified | 0.5=centered |
           1=right-justified }.

           Default values: 'x=y=z=c=0', 'opacity=1',
            'opacity_mask=(undefined)' and 'max_opacity_mask=1'.

           Example:
             [#1] image.jpg +crop 40%,40%,60%,60% resize[-1] 200%,200%,1,3,5
              frame[-1] 2,2,0 image[0] [-1],30%,30% keep[0]

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

           Example:
             [#1]  image.jpg repeat 500 line 50%,50%,{u(w)},{u(h)},0.5,${-rgb}
       done
              line 0,0,100%,100%,1,0xCCCCCCCC,255 line 100%,0,0,100%,1,
              0xCCCCCCCC,255

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

           Example:
             [#1]        400,400,1,3        repeat        100        linethick
       {u([w,h,w,h,5])},0.5,${-rgb} done

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

           Example:
             [#1] 400,400 mandelbrot -2.5,-2,2,2,1024 map  0  +blur  2  eleva-
       tion3d[-1]
              -0.2

         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' and
            'anisotropy=0.8',
           'alpha=0.6', 'sigma=1.1' and 'cut_low=cut_high=0'.

           Example:
             [#1] image.jpg +marble ,

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

           Input maze with specified size.

           Example:
             [#1] maze 30,20 negate normalize 0,255

         maze_mask:
             _cellsize>0

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

           Example:
             [#1] 0 text "G'MIC",0,0,53,1,1 dilate 3 autocrop 0 frame 1,1,0
              maze_mask 8 dilate 3 negate mul 255

         newton_fractal:
             z0r,z0i,z1r,z1i,_angle,0<=_descent_method<=2,_iteration_max>=0,
               _convergence_precision>0,_expr_p(z),_expr_dp(z),_expr_d2p(z)

           Draw  newton  fractal  on  selected  images, for complex numbers in
       range (z0r,
           z0i) - (z1r,z1i).
           Resulting images have  3  channels  whose  meaning  is  [  last_zr,
       last_zi,
           nb_iter_used_for_convergence ].
           'descent_method' can be { 0=secant | 1=newton | 2=householder
           }.

           Default values: 'angle=0', 'descent_method=1',
            'iteration_max=200', 'convergence_precision=0.01',
            'expr_p(z)=z^^3-1', 'expr_dp(z)=3*z^^2' and
            'expr_d2z(z)=6*z'.

           Example:
             [#1]  400,400 newton_fractal -1.5,-1.5,1.5,1.5,0,2,200,0.01,"z^^6
       + z^^3
              - 1","6*z^^5 + 3*z^^2","30*z^^4 + 6*z" f "[ atan2(i1,
              i0)*90+20,1,cut(i2/30,0.2,0.7) ]" hsl2rgb

         j3d (+):
             Shortcut for command 'object3d'.

         object3d (+):
             [object3d],_x[%],_y[%],_z,_opacity,_rendering_mode,_is_dou-
       ble_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.
           (equivalent to shortcut command '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.

           Example:
             [#1]   image.jpg   torus3d  100,10  cone3d  30,-120  add3d[-2,-1]
       rotate3d. 1,1,
              0,60 object3d[0] [-1],50%,50% keep[0]

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

           Example:
             [#1]      512,512,1,3,"min(255,y*c/2)"      100%,100%      circle
       50%,50%,100,1,255
              append c image.jpg resize2dy[-1] 24 to_rgba pack_sprites 3,25

         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.

           Example:
             [#1]                      image.jpg                      piechart
       25,0,0,0,"Red",55,255,0,0,"Green",40,0,255,0,
              "Blue",30,128,128,255,"Other",5,128,128,128

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

           Example:
             [#1] 400,400,1,3 plasma

           Tutorial: https://gmic.eu/tutorial/_plasma.shtml

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

           Set specified colored pixel on selected images.

           Default values: 'z=0', 'opacity=1' and 'color1=0'.

           Example:
             [#1] image.jpg repeat 10000 point {u(100)}%,{u(100)}%,0,1,${-rgb}
       done

         polka_dots:
             diameter>=0,_density,_offset1,_offset2,_angle,_aliasing,_shad-
       ing,_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'.

           Example:
             [#1] image.jpg polka_dots 10,15,0,0,20,10,1,0.5,0,128,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 poly-
       gon is
           drawn outlined instead of filled.

           Default values: 'opacity=1', 'pattern=(undefined)' and
            'color1=0'.

           Example:
             [#1]                      image.jpg                       polygon
       4,20%,20%,80%,30%,80%,70%,20%,80%,0.3,0,255,0
              polygon 4,20%,20%,80%,30%,80%,70%,20%,80%,1,0xCCCCCCCC,255
             [#2]     image.jpg     2,16,1,1,'u(if(x,{h},{w}))'    polygon[-2]
       {h},{^},0.6,255,
              0,255 remove[-1]

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

           Example:
             [#1]      100,100,1,2,'if(c==0,x-w/2,y-h/2)'      500,500,1,3,255
       quiver[-1] [-2],
              10
             [#2] image.jpg +resize2dy 600 luminance[0] gradient[0] mul[1] -1
              reverse[0,1] append[0,1] c blur[0] 8 orientation[0]
              quiver[1] [0],20,1,1,0.8,255

         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  rec-
       tangle is
           drawn outlined instead of filled.

           Default values: 'opacity=1', 'pattern=(undefined)' and
            'color1=0'.

           Example:
             [#1] image.jpg repeat 30 rectangle {u(100)}%,{u(100)}%,{u(100)}%,
              {u(100)}%,0.3,${-rgb} done

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

           Example:
             [#1] 400,400 rorschach 3%

         sierpinski:
             recursion_level>=0

           Draw Sierpinski triangle on selected images.

           Default value: 'recursion_level=7'.

           Example:
             [#1] image.jpg sierpinski 7

         spiralbw:
             width>0,_height>0,_is_2dcoords={ 0 | 1 }

           Input a 2D rectangular spiral image with specified size.

           Default values: 'height=width' and 'is_2dcoords=0'.

           Example:
             [#1] spiralbw 16
             [#2] image.jpg spiralbw {[w,h]},1 +warp[0] [1],0 +warp[2] [1],2

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

           Draw  specified colored spline curve on selected images (cubic her-
       mite
           spline).

           Default values: 'opacity=1' and 'color1=0'.

           Example:
             [#1]         image.jpg         repeat          30          spline
       {u(100)}%,{u(100)}%,{u(-600,600)},
              {u(-600,600)},{u(100)}%,{u(100)}%,{u(-600,600)},{u(-600,
              600)},0.6,255 done

         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.

         t (+):
             Shortcut for command 'text'.

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

           Draw specified colored text string on selected images.
           (equivalent to shortcut command 't').

           If  one  of  the  x  or  y  argument  ends with a '~', its value is
       expected
           to be
           a centering ratio (in [0,1]) rather than a position.
           Usual centering ratio are { 0=left-justified | 0.5=centered |
           1=right-justified }.
           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: 'x=y=0.01~', 'font_height=16',
            'opacity=1' and 'color1=0'.

           Example:
             [#1] image.jpg resize2dy 600 y=0 repeat 30 text {2*$>}" : This is
       a
              nice text, isn't it ?",10,$y,{2*$>},0.9,255 y+={2*$>} done
             [#2] 0 text "G'MIC",0,0,23,1,255

         to:
             Shortcut for command 'text_outline'.

         text_outline:
             text,_x[%|~],_y[%|~],_font_height[%]>0,_outline>=0,_opac-
       ity,_color1,...

           Draw specified colored and outlined text string on selected images.
           If one of the x or y  argument  ends  with  a  '~',  its  value  is
       expected
           to be
           a centering ratio (in [0,1]) rather than a position.
           Usual centering ratio are { 0=left-justified | 0.5=centered |
           1=right-justified }.

           Default values: 'x=y=0.01~', 'font_height=7.5%',
            'outline=2', 'opacity=1', 'color1=color2=color3=255'
            and 'color4=255'.

           Example:
             [#1] image.jpg text_outline "Hi there!",10,10,63,3

         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.

           Example:
             [#1]                   image.jpg                   triangle_shade
       20,20,400,100,120,200,255,0,0,0,255,0,0,0,
              255

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

           Example:
             [#1] 400,300 truchet ,

         turbulence:
             _radius>0,_octaves={1,2,3...,12},_alpha>0,_differ-
       ence={-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'.

           Example:
             [#1] 400,400,1,3 turbulence 16

           Tutorial: https://gmic.eu/tutorial/_turbulence.shtml

         yinyang:

           Draw a yin-yang symbol on selected images.

           Example:
             [#1] 400,400 yinyang

         12.11. Matrix Computation
                ------------------

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

           Compute minimal distances and paths from specified adjacency matri-
       ces 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 33 symmetric matrices,
           whose eigen elements are computed at each point of the field.

           Example:
             [#1] (1,0,0;0,2,0;0,0,3) +eigen
             [#2] image.jpg structuretensors blur 2 eigen split[0] c

           Tutorial: https://gmic.eu/tutorial/_eigen.shtml

         invert (+):
             solver={ 0=SVD | 1=LU }

           Compute the inverse of the selected matrices.
           SVD solver is slower but less numerically instable than LU.

           Default value: 'solver=1'.

           Example:
             [#1] (0,1,0;0,0,1;1,0,0) +invert

         orthogonalize:
             _mode = { 0=orthogonalize | 1=orthonormalize }

           Orthogonalize or orthonormalize selected matrices, using Modified
           Gram-Schmidt process.

           Default value: 'mode=0'.

         mproj (+):
             [dictionary],_method,_max_iter={ 0=auto | >0 },_max_residual>=0

           Find best matching projection of selected matrices onto the span of
       an
           over-complete
           dictionary D, using the orthogonal projection or Matching Pursuit
           algorithm.
           Selected  images  are  2D-matrices in which each column represent a
       signal to
           project.
           '[dictionary]' is a matrix in which each column is  an  element  of
       the
           dictionary D.
           'method'  tells  what  projection algorithm must be applied. It can
       be:
              - 0 = orthogonal projection (least-squares  solution  using  LU-
       based
           solver).
              - 1 = matching pursuit.
              - 2 = matching pursuit, with a single orthogonal projection step
       at
           the end.
              - >=3 = orthogonal matching pursuit where an orthogonal  projec-
       tion
           step is performed
                      every 'method-2' iterations.
           'max_iter' sets the max number of iterations processed for each
           signal.
           If set to '0' (default), 'max_iter' is equal to the number of
           columns in D.
           (only meaningful for matching pursuit and its variants).
           'max_residual' gives a stopping criterion on signal reconstruction
           accuracy.
           (only meaningful for matching pursuit and its variants).
           For each selected image, the result is returned as a matrix W
           whose  columns  correspond to the weights associated to each column
       of D,
           such that the matrix product D*W is an approximation of  the  input
       matrix.

           Default values: 'method=0', 'max_iter=0' and
            'max_residual=1e-6'.

         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 squares solu-
       tion is
           returned
           (using SVD-based solver).

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

         svd (+):

           Compute SVD decomposition of selected matrices.

           Example:
             [#1] 10,10,1,1,'if(x==y,x+u(-0.2,0.2),0)' +svd

         transpose:

           Transpose selected matrices.

           Example:
             [#1] image.jpg +transpose

         trisolve (+):
             [image]

           Solve  tridiagonal  system AX = B for selected B-vectors and speci-
       fied
           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.

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

         12.12. 3D Meshes
                ---------

         +3d (+):
             Shortcut for command 'add3d'.

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

           Default values: 'ty=tz=0'.

           Example:
             [#1] sphere3d 10 repeat 5 +add3d[-1] 10,{u(-10,10)},0 color3d[-1]
              ${-rgb} done add3d
             [#2] repeat 20 torus3d 15,2 color3d[-1] ${-rgb}  mul3d[-1]  0.5,1
       if $>%2
              rotate3d[-1] 0,1,0,90 fi add3d[-1] 70 add3d rotate3d[-1] 0,0,
              1,18 done double3d 0

         animate3d:
             _width>0,_height>0,_angle_dx,_angle_dy,_angle_dz,_zoom_fac-
       tor>=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.

           Example:
             [#1]           torus3d            10,1            +apply_matrix3d
       {mul(rot(1,0,1,-15),[1,0,0,0,2,0,0,0,
              8],3)} double3d 0

         array3d:
             size_x>=1,_size_y>=1,_size_z>=1,_offset_x[%],_offset_y[%],_off-
       set_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%'.

           Example:
             [#1] torus3d 10,1 +array3d 5,5,5,110%,110%,300%

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

           Example:
             [#1]        repeat        10        a={$>*2*pi/10}        arrow3d
       0,0,0,{cos($a)},{sin($a)},-0.5
              done +3d

         axes3d:
             _size_x,_size_y,_size_z,_font_size>0,_label_x,_label_y,_label_z,
               _is_origin={ 0=no | 1=yes }

           Input 3D axes with specified sizes along the  x,y  and  z  orienta-
       tions.

           Default values: 'size_x=size_y=size_z=1', 'font_size=23',
             'label_x=X', 'label_y=Y', 'label_z=Z' and
            'is_origin=1'

           Example:
             [#1] axes3d ,

         boundingbox3d:

           Replace selected 3D objects by their 3D bounding boxes.

           Example:
             [#1] torus3d 100,30 +boundingbox3d +3d[-1] [-2]

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

           Example:
             [#1] box3d 100,40,30 +primitives3d 1 color3d[-2] ${-rgb}

         c3d:
             Shortcut for command 'center3d'.

         center3d:

           Center selected 3D objects at (0,0,0).
           (equivalent to shortcut command 'c3d').

           Example:
             [#1] repeat 100 circle3d {u(100)},{u(100)},{u(100)},2 done add3d
              color3d[-1] 255,0,0 +center3d color3d[-1] 0,255,0 add3d

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

           Input 3D circle at specified coordinates.

           Default values: 'x0=y0=z0=0' and 'radius=1'.

           Example:
             [#1] repeat 500 a={$>*pi/250} circle3d {cos(3*$a)},{sin(2*$a)},0,
              {$a/50} color3d[-1] ${-rgb},0.4 done add3d

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

           Convert specified 3D objects to sets of 3D circles  with  specified
       radius.

           Default values: 'radius=1' and 'is_wireframe=1'.

           Example:
             [#1]  image.jpg luminance resize2dy 40 threshold 50% * 255 point-
       cloud3d
              color3d[-1] 255,255,255 circles3d 0.7

         col3d (+):
             Shortcut for command 'color3d'.

         color3d (+):
             R,_G,_B,_opacity |
             (no arg)

           Set color and opacity of selected 3D objects.
           (equivalent to shortcut command 'col3d').

           Default value: 'B=G=R' and 'opacity=(undefined)'.

           Example:
             [#1] torus3d 100,10 double3d 0 repeat 7 +rotate3d[-1] 1,0,0,20
              color3d[-1] ${-rgb} done add3d

         colorcube3d:

           Input 3D color cube.

           Example:
             [#1] colorcube3d mode3d 2 +primitives3d 1

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

           Example:
             [#1] cone3d 10,40 +primitives3d 1 color3d[-2] ${-rgb}

         cubes3d:
             _size>=0

           Convert specified 3D objects to sets of  3D  cubes  with  specified
       size.

           Default value: 'size=1'.

           Example:
             [#1]  image.jpg luminance resize2dy 40 threshold 50% * 255 point-
       cloud3d
              color3d[-1] 255,255,255 cubes3d 1

         cup3d:
             _resolution>0

           Input 3D cup object.

           Default value: 'resolution=128'.

           Example:
             [#1] cup3d ,

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

           Example:
             [#1] cylinder3d 10,40 +primitives3d 1 color3d[-2] ${-rgb}

         delaunay3d:

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

           Example:
             [#1] 500,500 noise 0.05,2  eq  1  *  255  +delaunay3d  color3d[1]
       255,128,0
              dilate_circ[0] 5 to_rgb[0] +object3d[0] [1],0,0,0,1,1
              max[-1] [0]

         distribution3d:

           Get 3D color distribution of selected images.

           Example:
             [#1]  image.jpg  distribution3d  colorcube3d  primitives3d[-1]  1
       add3d

         /3d (+):
             Shortcut for command 'div3d'.

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

           Scale selected 3D objects isotropically  or  anisotropically,  with
       the
           inverse of specified
           factors.
           (equivalent to shortcut command '/3d').

           Default value: 'factor_z=0'.

           Example:
             [#1]  torus3d  5,2  repeat  5  +add3d[-1]  12,0,0  div3d[-1]  1.2
       color3d[-1]
              ${-rgb} done add3d

         db3d (+):
             Shortcut for command 'double3d'.

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

           Enable/disable double-sided mode for 3D rendering.
           (equivalent to shortcut command 'db3d').

           Default value: 'is_double_sided=1'.

           Example:
             [#1] mode3d 1 repeat 2 torus3d 100,30 rotate3d[-1] 1,1,0,60  dou-
       ble3d $>
              snapshot3d[-1] 400 done

         elevation3d:
             { z-factor | [elevation_map] | 'formula' },base_height={ -1 | >=0
       } |
             (no arg)

           Generate 3D elevation of selected images,  opt.  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 speci-
       fied
           image or formula.

           Example:
             [#1] image.jpg +blur 5 elevation3d. 0.75
             [#2] 128,128,1,3,u(255) plasma 10,3 blur 4 sharpen 10000 n 0,255
              elevation3d[-1] 'X=(x-64)/6;Y=(y-64)/6;-100*exp(-(X^2+Y^2)/30
              )*abs(cos(X)*sin(Y))'

         empty3d:

           Input empty 3D object.

           Example:
             [#1] empty3d

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

           Example:
             [#1] image.jpg threshold 50% extrude3d 16

         f3d (+):
             Shortcut for command 'focale3d'.

         focale3d (+):
             focale

           Set 3D focale.
           (equivalent to shortcut command 'f3d').

           Set 'focale' to 0 to enable parallel projection (instead of
           perspective).
           Set negative 'focale' will disable 3D sprite zooming.

           Default value: 'focale=700'.

           Example:
             [#1] repeat  5  torus3d  100,30  rotate3d[-1]  1,1,0,60  focale3d
       {$<*90}
              snapshot3d[-1] 400 done remove[0]

         gaussians3d:
             _size>0,_opacity

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

           Example:
             [#1] image.jpg r2dy 32 distribution3d gaussians3d 20 colorcube3d
              primitives3d[-1] 1 +3d

         gmic3d:

           Input a 3D G'MIC logo.

           Example:
             [#1] gmic3d +primitives3d 1

         gyroid3d:
             _resolution>0,_zoom

           Input 3D gyroid at (0,0,0), with specified resolution.

           Default values: 'resolution=32' and 'zoom=5'.

           Example:
             [#1] gyroid3d 48 +primitives3d 1

         histogram3d:

           Get 3D color histogram of selected images.

           Example:
             [#1] image.jpg resize2dx 64 histogram3d  circles3d  3  opacity3d.
       0.75
              colorcube3d primitives3d[-1] 1 add3d

         image6cube3d:

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

           Example:
             [#1] image.jpg animate flower,"30,0","30,5",6 image6cube3d

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

           Example:
             [#1] image.jpg resize2dy 32 imageblocks3d -20 mode3d 3

         imagecube3d:

           Generate 3D mapped cubes from selected images.

           Example:
             [#1] image.jpg imagecube3d

         imageplane3d:

           Generate 3D mapped planes from selected images.

           Example:
             [#1] image.jpg imageplane3d

         imagepyramid3d:

           Generate 3D mapped pyramids from selected images.

           Example:
             [#1] image.jpg imagepyramid3d

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

           Example:
             [#1] image.jpg imagerubik3d ,

         imagesphere3d:
             _resolution1>=3,_resolution2>=3

           Generate 3D mapped sphere from selected images.

           Default values: 'resolution1=32' and 'resolutions2=16'.

           Example:
             [#1] image.jpg imagesphere3d 32,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'.

           Example:
             [#1] image.jpg blur 1 isoline3d 50%
             [#2] isoline3d 'X=x-w/2;Y=y-h/2;(X^2+Y^2)%20',10,-10,-10,10,10

         isosurface3d (+):
             isovalue[%] |
             'for-
       mula',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'.

           Example:
             [#1] image.jpg resize2dy 128 luminance threshold 50% expand_z 2,0
       blur
              1 isosurface3d 50% mul3d 1,1,30
             [#2] isosurface3d 'x^2+y^2+abs(z)^abs(4*cos(x*y*z*3))',3

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

           Example:
             [#1] torus3d 100,40,6,6 label_points3d 23,1 mode3d 1

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

           Example:
             [#1] 300,300 rand -1,1 blur 40 sign normalize 0,255 lathe3d ,

         l3d (+):
             Shortcut for command 'light3d'.

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

           Set the light coordinates or the light texture for 3D rendering.
           (equivalent to shortcut command 'l3d').

           (no arg) resets the 3D light to default.

           Example:
             [#1]  torus3d  100,30  double3d  0  specs3d  1.2 repeat 5 light3d
       {$>*100},0,
              -300 +snapshot3d[0] 400 done remove[0]

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

           Input 3D line at specified coordinates.

           Example:
             [#1]        repeat        100         a={$>*pi/50}         line3d
       0,0,0,{cos(3*$a)},{sin(2*$a)},0
              color3d. ${-rgb} done add3d

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

           Input 3D lissajous curves (x(t)=sin(at+A*2pi), y(t)=sin(bt+B*2pi),
            z(t)=sin(ct+C*2pi)).

           Default values: 'resolution=1024', 'a=2', 'A=0',
            'b=1', 'B=0', 'c=0' and 'C=0'.

           Example:
             [#1] lissajous3d ,

         m3d (+):
             Shortcut for command 'mode3d'.

         mode3d (+):
             _mode

           Set static 3D rendering mode.
           (equivalent to shortcut command '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'.

           Example:
             [#1]  (0,1,2,3,4,5)  double3d   0   repeat   w   torus3d   100,30
       rotate3d[-1] 1,1,
              0,60 mode3d {0,@$>} snapshot3d[-1] 300 done remove[0]

         md3d (+):
             Shortcut for command 'moded3d'.

         moded3d (+):
             _mode

           Set dynamic 3D rendering mode for interactive 3D viewer.
           (equivalent to shortcut command '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'.

         *3d (+):
             Shortcut for command 'mul3d'.

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

           Scale  selected  3D  objects isotropically or anisotropically, with
       specified
           factors.
           (equivalent to shortcut command '*3d').

           Default value: 'factor_z=0'.

           Example:
             [#1]  torus3d  5,2  repeat  5  +add3d[-1]  10,0,0  mul3d[-1]  1.2
       color3d[-1]
              ${-rgb} done add3d

         n3d:
             Shortcut for command 'normalize3d'.

         normalize3d:

           Normalize selected 3D objects to unit size.
           (equivalent to shortcut command 'n3d').

           Example:
             [#1] repeat 100 circle3d {u(3)},{u(3)},{u(3)},0.1 done add3d
              color3d[-1] 255,0,0 +normalize3d[-1] color3d[-1] 0,255,0
              add3d

         o3d (+):
             Shortcut for command 'opacity3d'.

         opacity3d (+):
             _opacity

           Set opacity of selected 3D objects.
           (equivalent to shortcut command 'o3d').

           Default value: 'opacity=1'.

           Example:
             [#1] torus3d 100,10 double3d 0 repeat 7 +rotate3d[-1] 1,0,0,20
              opacity3d[-1] {u} done add3d

         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  '(a,b)  a9|
       (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%'.

           Example:
             [#1] parametric3d ,

         pca_patch3d:
             _patch_size>0,_M>0,_N>0,_normalize_input={   0   |  1  },_normal-
       ize_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'.

           Example:
             [#1] image.jpg pca_patch3d 7

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

           Example:
             [#1] plane3d 50,30 +primitives3d 1 color3d[-2] ${-rgb}

         point3d:
             x0,y0,z0

           Input 3D point at specified coordinates.

           Example:
             [#1] repeat 1000 a={$>*pi/500} point3d {cos(3*$a)},{sin(2*$a)},0
              color3d[-1] ${-rgb} done add3d

         pointcloud3d:

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

           Example:
             [#1] image.jpg luminance resize2dy 100 threshold 50% mul 255
              pointcloud3d color3d[-1] 255,255,255

         pose3d:
             p1,...,p12

           Apply 3D pose matrix to selected 3D objects.

           Example:
             [#1]              torus3d              100,20              pose3d
       0.152437,1.20666,-0.546366,0,-0.535962,
              0.559129,1.08531,0,1.21132,0.0955431,0.548966,0,0,0,-206,1
              snapshot3d 400

         p3d:
             Shortcut for command 'primitives3d'.

         primitives3d:
             mode

           Convert primitives of selected 3D objects.
           (equivalent to shortcut command 'p3d').

           'mode' can be { 0=points | 1=outlines | 2=non-textured }.

           Example:
             [#1] sphere3d 30 primitives3d 1 torus3d 50,10 color3d[-1] ${-rgb}
       add3d

         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.

           Example:
             [#1] pyramid3d 100,-100 +primitives3d 1 color3d[-2] ${-rgb}

         quadrangle3d:
             x0,y0,z0,x1,y1,z1,x2,y2,z2,x3,y3,z3

           Input 3D quadrangle at specified coordinates.

           Example:
             [#1] quadrangle3d -10,-10,10,10,-10,10,10,10,10,-10,10,10  repeat
       10
              +rotate3d[-1] 0,1,0,30 color3d[-1] ${-rgb},0.6 done add3d
              mode3d 2

         random3d:
             nb_points>=0

           Input random 3D point cloud in [0,1]^3.

           Example:
             [#1] random3d 100 circles3d 0.1 opacity3d 0.5

         rv3d (+):
             Shortcut for command 'reverse3d'.

         reverse3d (+):

           Reverse primitive orientations of selected 3D objects.
           (equivalent to shortcut command 'rv3d').

           Example:
             [#1] torus3d 100,40 double3d 0 +reverse3d

         r3d (+):
             Shortcut for command 'rotate3d'.

         rotate3d (+):
             u,v,w,angle

           Rotate  selected  3D  objects  around specified axis with specified
       angle (in
           deg.).
           (equivalent to shortcut command 'r3d').

           Example:
             [#1] torus3d 100,10 double3d 0 repeat  7  +rotate3d[-1]  1,0,0,20
       done
              add3d

         rotation3d:
             u,v,w,angle

           Input 33 rotation matrix with specified axis and angle (in deg).

           Example:
             [#1] rotation3d 1,0,0,0 rotation3d 1,0,0,90 rotation3d 1,0,0,180

         sierpinski3d:
             _recursion_level>=0,_width,_height

           Input 3d Sierpinski pyramid.

           Example:
             [#1] sierpinski3d 3,100,-100 +primitives3d 1 color3d[-2] ${-rgb}

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

           Example:
             [#1] shape_cupid 480 +skeleton3d ,

         snapshot3d:
             _size>0,_zoom>=0,_backgroundR,_backgroundG,_backgroundB,_back-
       groundA |
             [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)'.

           Example:
             [#1]    torus3d    100,20    rotate3d     1,1,0,60     snapshot3d
       400,1.2,128,64,32
             [#2]  torus3d  100,20  rotate3d  1,1,0,60 sample ? +snapshot3d[0]
       [1],1.2

         sl3d (+):
             Shortcut for command 'specl3d'.

         specl3d (+):
             value>=0

           Set lightness of 3D specular light.
           (equivalent to shortcut command 'sl3d').

           Default value: 'value=0.15'.

           Example:
             [#1] (0,0.3,0.6,0.9,1.2) repeat  w  torus3d  100,30  rotate3d[-1]
       1,1,0,60
              color3d[-1] 255,0,0 specl3d {0,@$>} snapshot3d[-1] 400 done
              remove[0]

         ss3d (+):
             Shortcut for command 'specs3d'.

         specs3d (+):
             value>=0

           Set shininess of 3D specular light.
           (equivalent to shortcut command 'ss3d').

           Default value: 'value=0.8'.

           Example:
             [#1]  (0,0.3,0.6,0.9,1.2)  repeat  w  torus3d 100,30 rotate3d[-1]
       1,1,0,60
              color3d[-1] 255,0,0 specs3d {0,@$>} snapshot3d[-1] 400 done
              remove[0]

         sphere3d (+):
             radius,_nb_recursions>=0

           Input 3D sphere at (0,0,0), with specified geometry.

           Default value: 'nb_recursions=3'.

           Example:
             [#1] sphere3d 100 +primitives3d 1 color3d[-2] ${-rgb}

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

           Example:
             [#1] spherical3d 64 +primitives3d 1

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

           Example:
             [#1]               repeat               100              spline3d
       {u},{u},{u},{u},{u},{u},{u},{u},{u},{u},{u},
              {u},128 color3d[-1] ${-rgb} done box3d 1 primitives3d[-1] 1
              add3d

         s3d (+):
             Shortcut for command 'split3d'.

         split3d (+):
             _full_split={ 0 | 1 }

           Split selected 3D objects into feature vectors :
            * If 'full_split==0', { header, sizes, vertices, primitives,
           colors, opacities }.
            * If 'full_split==1', { header, sizes, vertices, p0,...,pP, c0,
           ...,cP, o0,...,oP }.
           (equivalent to shortcut command 's3d').

           To recreate the 3D object, append all produced images along the  y-
       axis.

           Default value: 'full_split=0'.

           Example:
             [#1] box3d 100 +split3d

         sprite3d:

           Convert selected images as 3D sprites.
           Selected images with alpha channels are managed.

           Example:
             [#1] image.jpg sprite3d

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

           Example:
             [#1] torus3d 100,20 image.jpg resize2dy[-1]  64  100%,100%  gaus-
       sian[-1]
              30%,30% *[-1] 255 append[-2,-1] c +sprites3d[0] [1],1
              display_rgba[-2]

         star3d:
             _nb_branches>0,0<=_thickness<=1

           Input 3D star at position '(0,0,0)', with specified geometry.

           Default values: 'nb_branches=5' and 'thickness=0.38'.

           Example:
             [#1] star3d , +primitives3d 1 color3d[-2] ${-rgb}

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

           Example:
             [#1] 100,100,100,3 rand -10,10 blur 3 repeat 300 +streamline3d[0]
              {u(100)},{u(100)},{u(100)},1000,1,1 color3d[-1] ${-rgb} done
              remove[0] box3d 100 primitives3d[-1] 1 add3d

         -3d (+):
             Shortcut for command 'sub3d'.

         sub3d (+):
             tx,_ty,_tz

           Shift  selected 3D objects with the opposite of specified displace-
       ment
           vector.
           (equivalent to shortcut command '3d').

           Default values: 'ty=tz=0'.

           Example:
             [#1] sphere3d 10 repeat 5 +sub3d[-1] 10,{u(-10,10)},0 color3d[-1]
              ${-rgb} done add3d

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

           Example:
             [#1] superformula3d ,

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

           Example:
             [#1] 6,6,6,9,"U = [x,y,z] - [w,h,d]/2; U/=norm(U); mul(U,U,3) +
              0.3*eye(3)" tensors3d 0.8

         text_pointcloud3d:
             _"text1",_"text2",_smoothness

           Input 3D text pointcloud from the two specified strings.

           Default values: 'text1="text1"', 'text2="text2"' and
            'smoothness=1'.

           Example:
             [#1] text_pointcloud3d "G'MIC","Rocks!"

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

           Example:
             [#1] text3d "G'MIC as a0D logo!"

         t3d:
             Shortcut for command 'texturize3d'.

         texturize3d:
             [ind_texture],_[ind_coords]

           Texturize selected 3D objects with specified  texture  and  coordi-
       nates.
           (equivalent to shortcut command 't3d').

           When '[ind_coords]' is omitted, default XY texture projection is
           performed.

           Default value: 'ind_coords=(undefined)'.

           Example:
             [#1] image.jpg torus3d 100,30 texturize3d[-1] [-2] keep[-1]

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

           Example:
             [#1] torus3d 10,3 +primitives3d 1 color3d[-2] ${-rgb}

         triangle3d:
             x0,y0,z0,x1,y1,z1,x2,y2,z2

           Input 3D triangle at specified coordinates.

           Example:
             [#1] repeat 100 a={$>*pi/50} triangle3d 0,0,0,0,0,3,{cos(3*$a)},
              {sin(2*$a)},0 color3d[-1] ${-rgb} done add3d

         volume3d:

           Transform  selected  3D  volumetric  images  as 3D parallelepipedic
       objects.

           Example:
             [#1] image.jpg animate blur,0,5,30 append z volume3d

         weird3d:
             _resolution>0

           Input 3D weird object at (0,0,0), with specified resolution.

           Default value: 'resolution=32'.

           Example:
             [#1] weird3d 48 +primitives3d 1 color3d[-2] ${-rgb}

         12.13. Control Flow
                ------------

         ap:
             Shortcut for command 'apply_parallel'.

         apply_parallel:
             "command"

           Apply specified command on each of the selected images,  by  paral-
       lelizing
           it for all image of the list.
           (equivalent to shortcut command 'ap').

           Example:
             [#1] image.jpg +mirror x +mirror y apply_parallel "blur 3"

         apc:
             Shortcut for command 'apply_parallel_channels'.

         apply_parallel_channels:
             "command"

           Apply  specified  command on each of the selected images, by paral-
       lelizing
           it for all channel
           of the images independently.
           (equivalent to shortcut command 'apc').

           Example:
             [#1] image.jpg apply_parallel_channels "blur 3"

         apo:
             Shortcut for command 'apply_parallel_overlap'.

         apply_parallel_overlap:
             "command",overlap[%],nb_threads={ 0=auto | 1 | 2 | 4 | 8 | 16 }

           Apply specified command on each of the selected images,  by  paral-
       lelizing
           it on 'nb_threads'
           overlapped sub-images.
           (equivalent to shortcut command 'apo').

           'nb_threads' must be a power of 2.

           Default values: 'overlap=0','nb_threads=0'.

           Example:
             [#1] image.jpg +apply_parallel_overlap "smooth 500,0,1",1

         at:
             Shortcut for command 'apply_tiles'.

         apply_tiles:
             "command",_tile_width[%]>0,_tile_height[%]>0,_tile_depth[%]>0,
               _overlap_width[%]>=0,_overlap_height[%]>=0,_over-
       lap_depth[%]>=0,
               _boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic |
               3=mirror }

           Apply specified command on each tile (neighborhood) of the selected
       images,
            eventually with overlapping tiles.
           (equivalent to shortcut command 'at').

           Default values: 'tile_width=tile_height=tile_depth=10%',
            'overlap_width=overlap_height=overlap_depth=0' and
            'boundary_conditions=1'.

           Example:
             [#1]   image.jpg   +equalize[0]   256  +apply_tiles[0]  "equalize
       256",16,16,1,
              50%,50%

         apply_timeout:
             "command",_timeout={ 0=no timeout | >0=with specified timeout (in
       seconds)
               }

           Apply a command with a timeout.
           Set variable '$_is_timeout' to '1' if timeout occurred,
           '0' otherwise.

           Default value: 'timeout=20'.

         check (+):
             condition

           Evaluate specified condition and display an error message if evalu-
       ated 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.

           Example:
             [#1]  image.jpg  repeat  10  blur 1 if 1==1 continue fi deform 10
       done

         break (+):

           Break current 'repeat...done', 'do...while' or
           'local...endlocal' block.

           Example:
             [#1] image.jpg repeat 10 blur 1 if 1==1 break fi deform 10 done

         do (+):

           Start a 'do...while' block.

           Example:
             [#1] image.jpg luminance i={ia+2} do set  255,{u(100)}%,{u(100)}%
       while
              ia<$i

         done (+):

           End a 'repeat/for...done' block, and go to associated
           'repeat/for' position, if iterations remain.

         elif (+):
             condition

           Start a 'elif...[else]...fi' block if previous 'if' was not
           verified
           and test if specified condition holds
           'condition' is a mathematical expression, whose evaluation is
           interpreted as { 0=false | other=true }..

         else (+):

           Execute following commands if previous 'if' or 'elif'
           conditions failed.

         fi (+):

           End a 'if...[elif]...[else]...fi' block.
           (equivalent to shortcut command 'fi').

         endl (+):
             Shortcut for command 'endlocal'.

         endlocal (+):

           End a 'local...endlocal' block.
           (equivalent to shortcut command '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 evalu-
       ated 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).

         x (+):
             Shortcut for command 'exec'.

         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 sys-
       tem call.
           If 'is_verbose=1', the executed command is allowed to output on
           stdout/stderr.
           (equivalent to shortcut command 'x').

           Default value: 'is_verbose=1'.

         xo:
             Shortcut for command 'exec_out'.

         exec_out:
             _mode,"command"

           Execute external command using a system call, and return resulting
           'stdout' and/or 'stderr'.
           'mode' can be { 0=stdout | 1=stderr | 2=stdout+stderr }.

         for (+):
             condition

           Start a 'for...done' block.

           Example:
             [#1] image.jpg resize2dy 32 400,400,1,3 x=0 for  $x<400  image[1]
       [0],$x,
              $x x+=40 done

         if (+):
             condition

           Start a 'if...[elif]...[else]...fi' block and test if specified
           condition holds.
           'condition' is a mathematical expression, whose evaluation is
           interpreted as { 0=false | other=true }.

           Example:
             [#1]  image.jpg  if ia<64 add 50% elif ia<128 add 25% elif ia<192
       sub 25%
              else sub 50% fi cut 0,255

         l (+):
             Shortcut for command 'local'.

         local (+):

           Start a 'local...[onfail]...endlocal' block, with selected  images.
           (equivalent to shortcut command 'l').

           Example:
             [#1]  image.jpg  local[] 300,300,1,3 rand[0] 0,255 blur 4 sharpen
       1000
              endlocal
             [#2] image.jpg +local repeat 3 deform 20 done endlocal

           Tutorial: https://gmic.eu/tutorial/_local.shtml

         mutex (+):
             index,_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.
           'index' designates the mutex index, 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.

           Example:
             [#1] image.jpg +local blur -3 onfail mirror x endlocal

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

           Example:
             [#1] image.jpg [0] parallel "blur[0] 3","mirror[1] c"

         progress (+):
             0<=value<=100 |
             -1

           Set the progress index of the current processing pipeline.
           This  command  is  useful  only  when G'MIC is used by an embedding
       application.

         q (+):
             Shortcut for command 'quit'.

         quit (+):

           Quit G'MIC interpreter.
           (equivalent to shortcut command 'q').

         repeat (+):
             nb_iterations,_variable_name

           Start 'nb_iterations' iterations of a 'repeat...done' block.
           'nb_iterations' is a mathematical expression that  will  be  evalu-
       ated.

           Example:
             [#1]  image.jpg  split  y  repeat  $!,n shift[$n] $<,0,0,0,2 done
       append y
             [#2] image.jpg mode3d 2 repeat 4 imagecube3d rotate3d 1,1,0,40
              snapshot3d 400,1.4 done

           Tutorial: https://gmic.eu/tutorial/_repeat.shtml

         return (+):

           Return from current custom command.

         rprogress:
             0<=value<=100          |           -1           |           "com-
       mand",0<=value_min<=100,0<=value_max<=100

           Set  the  progress  index of the current processing pipeline (rela-
       tively 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.

         u (+):
             Shortcut for command 'status'.

         status (+):
             status_string

           Set  the  current  status.  Used to define a returning value from a
       function.
           (equivalent to shortcut command 'u').

           Example:
             [#1]  image.jpg  command  "foo   :   u0=Dark   u1=Bright   status
       ${u{ia>=128}}"
              text_outline ${-foo},2,2,23,2,1,255

         while (+):
             condition

           End a 'do...while' block and go back to associated 'do' if
           specified condition holds.
           'condition' is a mathematical expression, whose evaluation is
           interpreted as { 0=false | other=true }.

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

           Example:
             [#1] image.jpg array 3,2,2

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

           Example:
             [#1] image.jpg array_fade 3,2

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

           Example:
             [#1] image.jpg array_mirror 2

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

           Example:
             [#1] image.jpg +array_random 8,8,15,10

         frame:
             Shortcut for command 'frame_xy'.

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

           Example:
             [#1] image.jpg frame_blur 3,30,8,10%

         frame_cube:
             _depth>=0,_centering_x,_centering_y,_left_side={0=normal | 1=mir-
       ror-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'.

           Example:
             [#1] image.jpg frame_cube ,

         frame_fuzzy:
             size_x[%]>=0,_size_y[%]>=0,_fuzzyness>=0,_smooth-
       ness[%]>=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'.

           Example:
             [#1] image.jpg frame_fuzzy 20

         frame_painting:
             _size[%]>=0,0<=_contrast<=1,_profile_smoothness[%]>=0,_R,_G,_B,
               _vignette_size[%]>=0,_vignette_contrast>=0,_defects_con-
       trast>=0,
               0<=_defects_density<=100,_defects_size>=0,_defects_smooth-
       ness[%]>=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'.

           Example:
             [#1] image.jpg frame_painting ,

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

           Example:
             [#1] image.jpg frame_pattern 8

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

           Example:
             [#1] image.jpg frame_round 10

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

           Example:
             [#1] image.jpg +frame_seamless 30 array 2,2

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

           Example:
             [#1] image.jpg frame_x 20,255,0,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'.
           (equivalent to shortcut command 'frame').

           Example:
             [#1] image.jpg frame_xy 1,1,0 frame_xy 20,10,255,0,255

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

           Example:
             [#1] image.jpg frame_y 20,255,0,255

         img2ascii:
             _charset,_analysis_scale>0,_analysis_smoothness[%]>=0,_synthe-
       sis_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]'.

           Example:
             [#1] image.jpg img2ascii ,

         imagegrid:
             M>0,_N>0

           Create MxN image grid from selected images.

           Default value: 'N=M'.

           Example:
             [#1] image.jpg imagegrid 16

         imagegrid_hexagonal:
             _resolution>0,0<=_outline<=1

           Create hexagonal grids from selected images.

           Default values: 'resolution=32', 'outline=0.1' and
            'is_antialiased=1'.

           Example:
             [#1] image.jpg imagegrid_hexagonal 24

         imagegrid_triangular:
             pattern_width>=1,_pattern_height>=1,_pattern_type,0<=_out-
       line_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'.

           Example:
             [#1] image.jpg imagegrid_triangular 6,10,3,0.5

         linearize_tiles:
             M>0,_N>0

           Linearize MxN tiles on selected images.

           Default value: 'N=M'.

           Example:
             [#1] image.jpg +linearize_tiles 16

         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.

           Example:
             [#1] image.jpg  resize2dy  48  repeat  16  ball  {8+2*$>},${-rgb}
       mul[-1]
              {(1+$>)/16} done map_sprites 16

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

           Example:
             [#1] image.jpg repeat  10  +resize2dx[-1]  75%  balance_gamma[-1]
       ${-rgb}
              done pack 0

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

           Example:
             [#1] puzzle ,

         quadratize_tiles:
             M>0,_N>0

           Quadratize MxN tiles on selected images.

           Default value: 'N=M'.

           Example:
             [#1] image.jpg +quadratize_tiles 16

         rotate_tiles:
             angle,_M>0,N>0

           Apply MxN tiled-rotation effect on selected images.

           Default values: 'M=8' and 'N=M'.

           Example:
             [#1]  image.jpg  to_rgba rotate_tiles 10,8 drop_shadow 10,10 dis-
       play_rgba

         shift_tiles:
             M>0,_N>0,_amplitude

           Apply MxN tiled-shift effect on selected images.

           Default values: 'N=M' and 'amplitude=20'.

           Example:
             [#1] image.jpg +shift_tiles 8,8,10

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

           Example:
             [#1] image.jpg +taquin 8

         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'

           Example:
             [#1] image.jpg tunnel 20

         12.15. Artistic
                --------

         boxfitting:
             _min_box_size>=1,_max_box_size>=0,_initial_den-
       sity>=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'.

           Example:
             [#1] image.jpg boxfitting ,

         brushify:
             [brush],_brush_nb_sizes>=1,0<=_brush_min_size_factor<=1,
               _brush_nb_orienta-
       tions>=1,_brush_light_type,0<=_brush_light_strength
               <=1,_brush_opacity,_painting_density[%]>=0,0<=_painting_con-
       tours_coh
               erence<=1,0<=_painting_orientation_coherence<=1,
               _painting_coherence_alpha[%]>=0,_painting_coher-
       ence_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_coher
            ence=0.9', 'painting_coherence_alpha=1',
            'painting_coherence_sigma=1', 'painting_primary_angle=0',
            'painting_angle_dispersion=0.2'

           Example:
             [#1]   image.jpg   40,40   gaussian[-1]   10,4   spread[-1]  10,0
       brushify[0] [1],1

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

           Example:
             [#1] image.jpg cartoon 3,50,10,0.25,3,16

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

           Example:
             [#1] image.jpg +color_ellipses ,,0.15

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

           Example:
             [#1] image.jpg cubism ,

         draw_whirl:
             _amplitude>=0

           Apply whirl drawing effect on selected images.

           Default value: 'amplitude=100'.

           Example:
             [#1] image.jpg draw_whirl ,

         drawing:
             _amplitude>=0

           Apply drawing effect on selected images.

           Default value: 'amplitude=200'.

           Example:
             [#1] image.jpg +drawing ,

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

           Example:
             [#1]  image.jpg  drop_shadow  10,20,5,0.5  expand_xy  20,0   dis-
       play_rgba

         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', 'outline=8' and 'density=0.6'.

           Example:
             [#1] image.jpg ellipsionism ,

         fire_edges:
             _edges>=0,0<=_attenuation<=1,_smoothness>=0,_thresh-
       old>=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'.

           Example:
             [#1] image.jpg fire_edges ,

         fractalize:
             0<=detail_level<=1

           Randomly fractalize selected images.

           Default value: 'detail_level=0.8'

           Example:
             [#1] image.jpg fractalize ,

         glow:
             _amplitude>=0

           Add soft glow on selected images.

           Default value: 'amplitude=1%'.

           Example:
             [#1] image.jpg glow ,

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

           Example:
             [#1] image.jpg halftone ,

         hardsketchbw:
             _amplitude>=0,_density>=0,_opacity,0<=_edge_thresh-
       old<=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'.

           Example:
             [#1] image.jpg +hardsketchbw 200,70,0.1,10  median[-1]  2  +local
       reverse
              blur[-1] 3 blend[-2,-1] overlay endlocal

         hearts:
             _density>=0

           Apply heart effect on selected images.

           Default value: 'density=10'.

           Example:
             [#1] image.jpg hearts ,

         houghsketchbw:
             _density>=0,_radius>0,0<=_threshold<=100,0<=_opacity<=1,_vote-
       size[%]>0

           Apply hough B&W sketch effect on selected images.

           Default values: 'density=100', 'radius=3',
            'threshold=100', 'opacity=0.1' and 'votesize=100%'.

           Example:
             [#1] image.jpg +houghsketchbw ,

         lightrays:
             100<=_density<=0,_center_x[%],_center_y[%],_ray_length>=0,
               _ray_attenuation>=0

           Generate ray lights from the edges of selected images.

           Default values: 'density=50%', 'center_x=50%',
            'center_y=50%', 'ray_length=0.9' and
            'ray_attenuation=0.5'.

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

         light_relief:
             _ambient_light,_specular_lightness,_specular_size,_darkness,
               _light_smoothness,_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'.

           Example:
             [#1] image.jpg blur 2 light_relief 0.3,4,0.1,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'.

           Example:
             [#1] image.jpg linify 60

         mosaic:
             0<=_density<=100

           Create random mosaic from selected images.

           Default values: 'density=30'.

           Example:
             [#1] image.jpg mosaic , +fill "I!=J(1) || I!=J(0,1)?[0,0,0]:I"

         old_photo:

           Apply old photo effect on selected images.

           Example:
             [#1] image.jpg old_photo

         pencilbw:
             _size>=0,_amplitude>=0

           Apply B&W pencil effect on selected images.

           Default values: 'size=0.3' and 'amplitude=60'.

           Example:
             [#1] image.jpg pencilbw ,

         pixelsort:
             _ordering={ + | - },_axis={ x | y | z | xy | yx  },_[sorting_cri-
       terion],
               _[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)'.

           Example:
             [#1] image.jpg +norm +ge[-1] 30% +pixelsort[0] +,y,[1],[2]

         polaroid:
             _size1>=0,_size2>=0

           Create polaroid effect in selected images.

           Default values: 'size1=10' and 'size2=20'.

           Example:
             [#1] image.jpg to_rgba polaroid  5,30  rotate  20  drop_shadow  ,
       drgba

         polygonize:
             _warp_amplitude>=0,_smoothness[%]>=0,_min_area[%]>=0,_resolu-
       tion_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%'.

           Example:
             [#1] image.jpg image.jpg  polygonize  100,10  +fill  "I!=J(1)  ||
       I!=J(0,
              1)?[0,0,0]:I"

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

           Example:
             [#1] image.jpg poster_edges ,

         poster_hope:
             _smoothness>=0

           Apply Hope stencil poster effect on selected images.

           Default value: 'smoothness=3'.

           Example:
             [#1] image.jpg poster_hope ,

         rodilius:
             0<=_amplitude<=100,_0<=thickness<=100,_sharpness>=0,_nb_orienta-
       tions>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'.

           Example:
             [#1] image.jpg rodilius 12,10,300,10 normalize_local 10,6
             [#2] image.jpg normalize_local 10,16 rodilius 10,4,400,16  smooth
       60,0,1,
              1,4 normalize_local 10,16

         sketchbw:
             _nb_angles>0,_start_angle,_angle_range>=0,_length>=0,_thresh-
       old>=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'.

           Example:
             [#1]  image.jpg +sketchbw 1 reverse blur[-1] 3 blend[-2,-1] over-
       lay

         sponge:
             _size>0

           Apply sponge effect on selected images.

           Default value: 'size=13'.

           Example:
             [#1] image.jpg sponge ,

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

           Example:
             [#1] image.jpg stained_glass 20%,1 cut 0,20

         stars:
             _density[%]>=0,_depth>=0,_size>0,_nb_branches>=1,0<=_thick-
       ness<=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'.

           Example:
             [#1] image.jpg stars ,

         stencil:
             _radius[%]>=0,_smoothness>=0,_iterations>=0

           Apply stencil filter on selected images.

           Default values: 'radius=3', 'smoothness=1' and
            'iterations=8'.

           Example:
             [#1] image.jpg +norm stencil. 2,1,4 +mul rm[0]

         stencilbw:
             _edges>=0,_smoothness>=0

           Apply B&W stencil effect on selected images.

           Default values: 'edges=15' and 'smoothness=10'.

           Example:
             [#1] image.jpg +stencilbw 40,4

         stylize:
             [style_image],_fidelity_finest,_fidelity_coarsest,
               _fidelity_smoothness_finest>=0,_fidelity_smoothnes_coarsest>=0,
               0<=_fidelity_chroma<=1,_init_type,_init_resolution>=0,
               init_max_gradient>=0,_patchsize_analysis>0,_patchsize_synthe-
       sis>0,
               _patchsize_synthesis_final>0,_nb_matches_finest>=0,
               _nb_matches_coarsest>=0,_penalize_repetitions>=0,
               _matching_precision>=0,_scale_factor>1,_skip_finest_scales>=0,
               _"image_matching_command"

           Transfer colors and textures from specified style image to selected
       images,
            using a multi-scale patch-mathing algorithm.
           If instant display window[0] is opened, the steps of the image syn-
       thesis
           are displayed on it.
           'init_type' can be { 0=best-match | 1=identity | 2=randomized
           }.

           Default values: 'fidelity_finest=0.5',
            'fidelity_coarsest=2', 'fidelity_smoothness_finest=3',
            'fidelity_smoothness_coarsest=0.5', 'fidelity_chroma=0.1',
            'init_type=0', 'init_resolution=16',
            'init_max_gradient=0', 'patchsize_analysis=5',
            'patchsize_synthesis=5', 'patchsize_synthesis_final=5',
            'nb_matches_finest=2', 'nb_matchesc_coarsest=30',
            'penalize_repetitions=10', 'matching_precision=2',
            'scale_factor=1.85', 'skip_finest_scales=0' and
            'image_matching_command'="s c,-3 transfer_pca[0] [2] b[0,2] xy,0.7
       n[0,
            2] 0,255 n[1,2] 0,200 a[0,1] c a[1,2] c"'.

         tetris:
             _scale>0

           Apply tetris effect on selected images.

           Default value: 'scale=10'.

           Example:
             [#1] image.jpg +tetris 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'.

           Example:
             [#1] image.jpg warhol 3,3,3,40

         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'

           Example:
             [#1] image.jpg weave ,

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

           Example:
             [#1] image.jpg whirls ,

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

           Example:
             [#1] image.jpg +deform[0] 10 +deform[0] 20

         euclidean2polar:
             _center_x[%],_center_y[%],_stretch_factor>0,_boundary_condi-
       tions={
               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'.

           Example:
             [#1] image.jpg +euclidean2polar ,

         equirectangular2nadirzenith:

           Transform selected equirectangular images to nadir/zenith rectilin-
       ear
           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'.

           Example:
             [#1] image.jpg +fisheye ,

         flower:
             _amplitude,_frequency,_offset_r[%],_angle,_center_x[%],_cen-
       ter_y[%],
               _boundary_conditions={ 0=dirichlet | 1=neumann | 2=periodic |
               3=mirror}

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

           Example:
             [#1] image.jpg +flower ,

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

           Example:
             [#1] image.jpg kaleidoscope ,

         map_sphere:
             _width>0,_height>0,_radius,_dilation>0,_fading>=0,_fad-
       ing_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'.

           Example:
             [#1] image.jpg map_sphere ,

         nadirzenith2equirectangular:

           Transform  selected   nadir/zenith   rectilinear   projections   to
       equirectangular
           images.

         polar2euclidean:
             _center_x[%],_center_y[%],_stretch_factor>0,_boundary_condi-
       tions={
               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'.

           Example:
             [#1] image.jpg +euclidean2polar ,

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

           Example:
             [#1] image.jpg +raindrops ,

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

           Example:
             [#1] image.jpg +ripple ,

         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: 'center_x=center_y=50%', 'tiles=10',
            'smoothness=1' and 'boundary_conditions=3'.

           Example:
             [#1] image.jpg +rotoidoscope ,

         spherize:
             _radius[%]>=0,_strength,_smoothness[%]>=0,_center_x[%],_cen-
       ter_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'.

           Example:
             [#1] image.jpg grid 5%,5%,0,0,0.6,255 spherize ,

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

           Example:
             [#1] image.jpg +symmetrize 50%,50%,45 +symmetrize[-1] 50%,50%,-45

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

           Example:
             [#1]   image.jpg    +transform_polar[0]    R*(r/R)^2,a    +trans-
       form_polar[0] r,2*a

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

           Example:
             [#1] image.jpg twirl 0.6

         warp_perspective:
             _x-angle,_y-angle,_zoom>0,_x-center,_y-center,_boundary_condi-
       tions={
               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'.

           Example:
             [#1] image.jpg warp_perspective ,

         water:
             _amplitude,_smoothness>=0,_angle

           Apply water deformation on selected images.

           Default values: 'amplitude=30', 'smoothness=1.5' and
            'angle=45'.

           Example:
             [#1] image.jpg water ,

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

           Example:
             [#1] image.jpg wave ,

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

           Example:
             [#1] image.jpg +wind ,

         zoom:
             _factor,_cx,_cy,_cz,_boundary_conditions={  0=dirichlet  | 1=neu-
       mann |
               2=periodic | 3=mirror }

           Apply zoom factor to selected images.

           Default values: 'factor=1', 'cx=cy=cz=0.5' and
            'boundary_conditions=0'.

           Example:
             [#1] image.jpg +zoom[0] 0.6 +zoom[0] 1.5

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

           Example:
             [#1] image.jpg +cracks ,

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

           Example:
             [#1] image.jpg +light_patch 20,0.9,4

         noise_hurl:
             _amplitude>=0

           Add hurl noise to selected images.

           Default value: 'amplitude=10'.

           Example:
             [#1] image.jpg +noise_hurl ,

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

           Example:
             [#1] image.jpg +pixelize ,

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

           Example:
             [#1] image.jpg +scanlines ,

         shade_stripes:
             _frequency>=0,_direction={  0=horizontal  |  1=vertical  },_dark-
       ness>=0,
               _lightness>=0

           Add shade stripes to selected images.

           Default values: 'frequency=5', 'direction=1',
            'darkness=0.8' and 'lightness=2'.

           Example:
             [#1] image.jpg +shade_stripes 30

         shadow_patch:
             _opacity>=0

           Add shadow patches to selected images.

           Default value: 'opacity=0.7'.

           Example:
             [#1] image.jpg +shadow_patch 0.4

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

           Example:
             [#1] image.jpg +spread 3

         stripes_y:
             _frequency>=0

           Add vertical stripes to selected images.

           Default value: 'frequency=10'.

           Example:
             [#1] image.jpg +stripes_y ,

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

           Example:
             [#1] image.jpg +texturize_canvas ,

         texturize_paper:

           Add paper texture to selected images.

           Example:
             [#1] image.jpg +texturize_paper

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

           Example:
             [#1] image.jpg vignette ,

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

           Example:
             [#1] image.jpg watermark_visible ,0.7

         12.18. 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 | grain-
       merge |
           green | hardlight |
           hardmix | hue | interpolation | lchlightness | lighten |  lightness
       |
           linearburn | linearlight | luminance |
           multiply  |  negation  |  or | overlay | pinlight | red | reflect |
       saturation
           | seamless | seamless_mixed |
           screen  |  shapeareamax  |  shapeareamax0  |  shapeareamin  |  sha-
       peareamin0 |
           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'.

           Example:
             [#1] image.jpg +drop_shadow ,  resize2dy[-1]  200  rotate[-1]  20
       +blend
              alpha display_rgba[-2]
             [#2] image.jpg testimage2d {w},{h} blend overlay
             [#3] command "ex : $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
              text_outline[-1] Mode:
              image.jpg testimage2d {w},{h} ex add,alpha,and,average,blue,
              burn,darken
             [#4] command "ex : $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
              text_outline[-1] Mode:
              image.jpg testimage2d {w},{h} ex difference,divide,dodge,
              exclusion,freeze,grainextract,grainmerge
             [#5] command "ex : $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
              text_outline[-1] Mode:
              image.jpg testimage2d {w},{h} ex green,hardlight,hardmix,hue,
              interpolation,lighten,lightness
             [#6] command "ex : $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
              text_outline[-1] Mode:
              image.jpg testimage2d {w},{h} ex linearburn,linearlight,
              luminance,multiply,negation,or,overlay
             [#7] command "ex : $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
              text_outline[-1] Mode:
              image.jpg testimage2d {w},{h} ex pinlight,red,reflect,
              saturation,screen,shapeaverage,softburn
             [#8] command "ex : $""=arg repeat $""# +blend[0,1] ${arg{$>+1}}
              text_outline[-1] Mode:
              image.jpg testimage2d {w},{h} ex softdodge,softlight,stamp,
              subtract,value,vividlight,xor

         blend_edges:
             smoothness[%]>=0

           Blend selected images togethers using 'edges' mode.

           Example:
             [#1] image.jpg testimage2d {w},{h} +blend_edges 0.8

         blend_fade:
             [fading_shape]

           Blend selected images together using specified fading shape.

           Example:
             [#1] image.jpg testimage2d {w},{h} 100%,100%,1,1,'cos(y/10)'
              normalize[-1] 0,1 +blend_fade[0,1] [2]

         blend_median:

           Blend selected images together using 'median' mode.

           Example:
             [#1] image.jpg testimage2d {w},{h} +mirror[0] y +blend_median

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

           Example:
             [#1] image.jpg testimage2d {w},{h} +fade_diamond 80,85

         fade_linear:
             _angle,0<=_start<=100,0<=_end<=100

           Create linear fading from selected images.

           Default values: 'angle=45', 'start=30' and
            'end=70'.

           Example:
             [#1] image.jpg testimage2d {w},{h} +fade_linear 45,48,52

         fade_radial:
             0<=_start<=100,0<=_end<=100

           Create radial fading from selected images.

           Default values: 'start=30' and 'end=70'.

           Example:
             [#1] image.jpg testimage2d {w},{h} +fade_radial 30,70

         fade_x:
             0<=_start<=100,0<=_end<=100

           Create horizontal fading from selected images.

           Default values: 'start=30' and 'end=70'.

           Example:
             [#1] image.jpg testimage2d {w},{h} +fade_x 30,70

         fade_y:
             0<=_start<=100,0<=_end<=100

           Create vertical fading from selected images.

           Default values: 'start=30' and 'end=70'.

           Example:
             [#1] image.jpg testimage2d {w},{h} +fade_y 30,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'.

           Example:
             [#1] image.jpg testimage2d {w},{h} +sub_alpha[0] [1] display_rgba

         12.19. Image Sequences and Videos
                --------------------------

         animate:
             fil-
       ter_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'.

           Example:
             [#1] image.jpg animate flower,"0,3","20,8",9

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

           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' or '.mp4' (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' or '.mp4' (saved
           as a video), or any other usual image
           file extension (saved as a sequence of images).
           This command requires features from the OpenCV library (not enabled
       in
           G'MIC by default).

           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' or '.mp4' (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' or '.mp4' (saved
           as a video), or any other usual image
           file extension (saved as a sequence of images).
           This command requires features from the OpenCV library (not enabled
       in
           G'MIC by default).

           Default values: 'first_frame=0', 'last_frame=-1',
            'frame_step=1' and 'output_filename=(undefined)'.

         fade_files:
             "filename_pat-
       tern",_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' or 'mp4' (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.
           This command requires features from the OpenCV library (not enabled
       in
           G'MIC by default).

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

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

           Example:
             [#1] image.jpg +rotate 20,1,1,50%,50% morph 9

         morph_files:
             "filename_pattern",_nb_inner_frames>0,_smoothness>=0,_preci-
       sion>=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' or '.mp4' (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_rbf:
             nb_inner_frames>=1,xs0[%],ys0[%],xt0[%],yt0[%],...,xsN[%],ysN[%],xtN[%],
               ytN[%]

           Create morphing sequence between selected images, using RBF-based
           interpolation.
           Each argument (xsk,ysk)-(xtk,ytk) corresponds to the coordinates of
       a
           keypoint
           respectively on the source and target images. The set of  all  key-
       points
           define the overall image deformation.

         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' or '.mp4' (saved
           as a video), or any other usual image
           file extension (saved as a sequence of images).
           This command requires features from the OpenCV library (not enabled
       in
           G'MIC by default).

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

           Example:
             [#1] image.jpg +rotate 20,1,1,50%,50% +register_nonrigid[0] [1]

         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=0.1%' and
            'boundary_conditions=0'.

           Example:
             [#1] image.jpg +shift 30,20 +register_rigid[0] [1]

         transition:
             [transition_shape],nb_added_frames>=0,100>=shading>=0,_sin-
       gle_frame_only={
               -1=disabled | >=0 }

           Generate a transition sequence between selected images.

           Default values: 'shading=0' and 'single_frame_only=-1'.

           Example:
             [#1]  image.jpg  +mirror  c  100%,100%  plasma[-1]  1,1,6 transi-
       tion[0,1] [2],
              5

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

           Example:
             [#1] image.jpg +blur 5 transition3d 9 display_rgba

         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 speci-
       fied.

           Default values: 'output_filename=frame.png',
            'first_frame=0', 'last_frame=-1' and 'frame_step=1'.

         12.20. Neural Networks
                ---------------

         nn_new_input:
             module_name,width,_height,_spectrum

           Add an input module with specified size to the neural network.

         nn_new_output:
             module_name,previous_module_name

           Add an output module to the neural network.

         nn_new_fullyconnected:
             module_name,previous_module_name,nb_neurons,activation_function

           Add a fully-connected module to the neural network.

         nn_propagate_batch:
             module_name,[inputs_zstacked]

           Batch propagate specified inputs through the neural network.
           Insert image of corresponding network outputs at  the  end  of  the
       list.

         nn_propagate:
             module_name

           Propagate input through the neural network.

         nn_backpropagate_batch:
             module_name,[inputs_zstacked],[expected_outputs_zstacked],
               _insert_network_outputs={ 0 | 1 },_loss_function

           Batch  propagate and backpropagate inputs and errors in neural net-
       work.
           Optionnally insert image of corresponding network  outputs  at  the
       end of
           the list.
           Return averaged loss.

         nn_backpropagate:
             module_name,[expected_output],_loss_function

           Propagate input, then back-propagate output error, through the neu-
       ral
           network.
           This command set the network output.
           Return average loss.

         nn_update:
             module_name,epsilon

           Update neural network weights, after back-propagation of the error.

         nn_output:
             module_name,filename

           Output specified network as a file.

         nn_serialize:
             module_name,_is_compressed={ 0 | 1 }

           Serialize  network into a single image, optionnally in a compressed
       form.

         nn_unserialize:

           Unserialize specified selection to retrieve a neural network.

         nn_input:
             "filename"

           Input neural network from file.

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

         arg0:
             n>=0,_arg0,...,_argN

           Return the n-th argument of the specified argument list (where 'n'
           starts from '0').

         arg2var:
             variable_name,argument_1,...,argument_N

           For each i in [1...N], set 'variable_name$i=argument_i'.
           The variable name should be global  to  make  this  command  useful
       (i.e.
           starts by an underscore).

         autocrop_coords:
             value1,value2,... | auto

           Return  coordinates  (x0,y0,z0,x1,y1,z1) of the autocrop that could
       be
           performed on the latest
           of the selected images.

           Default value: 'auto'

         average_colors:

           Return the average vector-value  of  the  latest  of  the  selected
       images.

         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, hexadec-
       imal and
           string representations.

         bin2dec:
             binary_int1,...

           Convert specified binary integers into  their  decimal  representa-
       tions.

         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.

         dec:
             decimal_int1,...

           Print specified decimal integers into their binary, octal, hexadec-
       imal and
           string representations.

         dec2str:
             decimal_int1,...

           Convert specifial decimal integers into its string  representation.

         dec2bin:
             decimal_int1,...

           Convert  specified  decimal  integers into their binary representa-
       tions.

         dec2hex:
             decimal_int1,...

           Convert specified decimal integers into their hexadecimal represen-
       tations.

         dec2oct:
             decimal_int1,...

           Convert  specified  decimal  integers  into their octal representa-
       tions.

         fact:
             value

           Return the factorial of the specified value.

         fibonacci:
             N>=0

           Return the Nth number of the Fibonacci sequence.

           Example:
             [#1] echo ${"fibonacci 10"}


             [gmic]-0./ Start G'MIC interpreter.
             [gmic]-0./ 55
             [gmic]-0./ End G'MIC interpreter.

         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.

         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[%] |
             [image],_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.

           Example:
             [#1] fontchart

         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, dec-
       imal and
           string representations.

         hex2dec:
             hexadecimal_int1,...

           Convert specified hexadecimal integers into their decimal represen-
       tations.

         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.
           See also: str2hex.

         img2base64:
             _encoding={ 0=base64 | 1=base64url },_store_names={ 0 | 1 }

           Encode selected images as a base64-encoded string.
           The images can be then decoded using command 'base642img'.

           Default values: 'encoding=0'.

         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 spe-
       cial 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_change:
             _value={ 0=false | 1=true }

           Set or unset the 'is_change' flag associated to the image list.
           This  flag  tells  the  interpreter  whether  or not the image list
       should be
           displayed when the pipeline ends.

           Default value: 'value=1'.

         is_half:

           Return 1 if the type of image pixels is limited to half-float.

         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_variable_name:
             "str"

           Returns  1  if  specified  argument can be considered as a variable
       name, 0
           otherwise.

         is_videofilename:

           Return 1 if extension of specified filename is typical  from  video
       files.

         is_macos:

           Return 1 if current computer OS is Darwin (MacOS), 0 otherwise.

         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.

         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.

         nmd (+):
             Shortcut for command 'named'.

         named (+):
             _mode,"name1","name2",...

           Return  the set of indices corresponding to images of the selection
       with
           specified names.
           After this command returns, the status contains a list of indices
           (unsigned integers),
           separated by commas (or an empty string if  no  images  with  those
       names have
           been found).
           (equivalent to shortcut command 'nmd').

           'mode' can be { 0=all indices (default) | 1=lowest index |
           2=highest  index  | 3 = all indices (case insensitive) | 4 = lowest
       index
           (case insensitive) | 5 = highest index (case insensitive)}

         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, hexadec-
       imal and
           string representations.

         oct2dec:
             octal_int1,...

           Convert specified octal integers  into  their  decimal  representa-
       tions.

         padint:
             number,_size>0

           Return a integer with 'size' digits (eventually left-padded with
           '0').

         path_cache:

           Return  a  path to store G'MIC data files for one user (whose value
       is
           OS-dependent).

         path_current:

           Return current folder from where G'MIC has been run.

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

         remove_copymark:
             "image_name"

           Remove copy mark from names of selected images.

         reset:

           Reset global parameters of the interpreter environment.

         rgb:

           Return a random int-valued RGB color.

         rgba:

           Return a random int-valued RGBA color.

         shell_cols:

           Return the estimated number of columns of the current shell.

         size_value:

           Return the size (in bytes) of an image value.

         std_noise:

           Return the estimated noise standard deviation of the last  selected
       image.

         str:
             string

           Print specified string into its binary, octal, decimal and hexadec-
       imal
           representations.

         str2hex:
             "string"

           Convert specified string argument into a  sequence  of  hexadecimal
       values
           (returned as a string).
           See also: hex2str.

           Example:
             [#1] hex=${"str2hex


             [gmic]-0./ Start G'MIC interpreter.
             [gmic]-0./ 48656c6c6f206d7920667269656e6473
             [gmic]-0./ End G'MIC interpreter.

         strcapitalize:
             string

           Capitalize specified string.

         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.

         struppercase:
             string

           Return an upper-case version of the specified string.

         strvar:
             "string"

           Return  a  simplified  version of the specified string, that can be
       used as a
           variable name.
           (version that creates  a  lowercase  result,  no  longer  than  128
       chars).

         strcasevar:
             "string"

           Return  a  simplified  version of the specified string, that can be
       used as a
           variable name.
           (version that keeps original case of specified  string,  no  longer
       than 128
           chars).

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

         to_clutname:
             "string"

           Return simplified name that can be used as a CLUT name, from speci-
       fied
           input string.

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

         12.22. Other Interactive Commands
                --------------------------

         demos:
             _run_in_parallel={ 0=no | 1=yes | 2=auto }

           Show a menu to select and view all G'MIC interactive demos.

         tixy:
             "expression"

           Animate specified mathematical expression with a 16x16 grid of cir-
       cles,
           using the rules described at https://tixy.land.

         x_2048:

           Launch the 2048 game.

         x_blobs:

           Launch the blobs editor.
           ../img/x_blobs.jpg [image: 'x_blobs']

         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],_[grab-
       ber1]

           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.

         xz:
             Shortcut for command 'x_crop'.

         x_crop:

           Crop selected images interactively.
           (equivalent to shortcut command 'xz').

         x_cut:

           Cut selected images interactively.

         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_morph:
             _nb_frames>=2,_preview_fidelity={ 0=coarsest | 1=coarse |  2=nor-
       mal |
               3=fine | 4=finest }

           Launch the interactive image morpher.

           Default values: 'nb_frames=16' and 'preview_fidelity=3'.

         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,_back-
       ground_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  informa-
       tion :
              -   The  first row defines the values of a background curve dis-
       played 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_threshold:

           Threshold selected images interactively.

         x_tictactoe:

           Launch tic-tac-toe game.

         x_warp:
             _nb_keypoints_xgrid>=2,_nb_keypoints_ygrid>=2,_nb_keypoints_con-
       tours>=0,
               _preview_fidelity={ 0=coarsest | 1=coarse | 2=normal | 3=fine |
               4=finest },_[background_image],0<=_background_opacity<=1

           Launch the interactive image warper.

           Default values: 'nb_keypoints_xgrid=nb_keypoints_ygrid=2',
            'nb_keypoints_contours=0' and 'preview_fidelity=1'.

         x_waves:

           Launch the image waves demo.

         x_whirl:
             _opacity>=0

           Launch the fractal whirls demo.

           Default values: 'opacity=0.2'.

         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

                             ../img/example_plot.png [image: '']

         ### Plot a 3D elevated function in random colors:

           $  gmic  128,128,1,3,"u(0,255)"  plasma 10,3 blur 4 sharpen 10000 n
       0,255
          elevation3d[-1]
       "'X=(x-64)/6;Y=(y-64)/6;100*exp(-(X^2+Y^2)/30)*abs(cos(X)*s
          in(Y))'"

                             ../img/example_elevation3d.png [image: '']

         ### 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

                             ../img/example_isosurface3d.png [image: '']

         ### 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

                             ../img/example_logo.png [image: '']

         ### 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

                             ../img/example_torii.png [image: '']

         ### 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

                             ../img/example_vase.png [image: '']

         ### Launch a set of interactive demos:

           $ gmic demos

         ## Launch a set of interactive demos:


         ** G'MIC comes  with  ABSOLUTELY  NO  WARRANTY;  for  details  visit:
       https://gmic.eu **



                                                                      G'MIC(1)

gmic 2.9.7 - Generated Tue Apr 13 16:12:38 CDT 2021
© manpagez.com 2000-2021
Individual documents may contain additional copyright information.